Concordion - 快速指南

---

Concordion - 概述

什么是Concordion音？

Concordion 是一个强大的工具，用于在基于 Java 的项目中编写和管理自动化验收测试。它直接与 JUnit 框架集成，使其可以与所有流行的基于 JAVA 的 IDE（例如 Netbeans、Eclipse、IntelliJ IDEA）一起使用。

活动软件规范

主动软件规范是一种指定功能Behave的方法。它还提供了一种通过与正在开发的系统连接来实现和验证软件规范的方法。

Concordion 中的有效规范由两部分组成：

1. 一份清晰的需求文档，描述了使用 XHTML 编写的所需功能。基于 XHTML 的规范包含对验收测试示例提供的功能的描述。示例的数据使用简单的 HTML 标签进行标记。

2. 验收测试是用 Java 语言编写的，称为固定代码。使用标准 JUnit 测试用例的 Concordion 扩展来实现测试。Fixture Code 的职责是找到由 tag 标记的示例数据，并使用它们来验证正在开发的软件。

手风琴的输出

运行 Concordion 主动规范测试时，输出 XHTML 文件会显示原始规范和测试结果。成功的测试使用“绿色”突出显示，失败的测试使用“红色”突出显示。由于系统中的任何更改都会导致测试失败，这有助于确定要更新的规范，因此 Concordion 将这些规范称为活动规范。因此，规格始终是最新的。

主要特征

以下是 Concordion 的主要功能：

• 规范作为文档- Concordion 规范具有很高的可读性，可以用作活动的系统文档。由于基于 Concordion 的规范是用 HTML 编写的，因此可以对这些文档进行超链接。

• 规范是实时的- Concordion 规范包含针对系统执行的Behave的工作示例。规范采用颜色编码，以便任何人都可以看到示例是否有效。定期执行 Concordion 规范可以使文档保持最新状态。

• 分开“什么？” 来自“如何？” - 协调规范有助于保持系统的实现和所需Behave之间的分离。它提供了以后可以更改实现的灵活性。

• 简单易学- Concordion 库的设计使学习曲线简短明了。它需要学习的命令很少，并且示例使用 JUnit 测试实现自动化，因此可以轻松运行测试并轻松与现有项目集成。

• 强大的定制- Concordion 提供扩展 API，允许添加功能。例如，Excel 电子表格可以用作规范，屏幕截图可以添加到输出中，可以显示日志信息等等。

Concordion - 环境设置

本教程将指导您如何准备开发环境以开始使用 Spring 框架。本教程还将教您如何在安装 Spring Framework 之前在计算机上安装 JDK、Tomcat 和 Eclipse：

第 1 步 - 设置 Java 开发工具包 (JDK)：

您可以从 Oracle 的 Java 站点下载最新版本的 SDK：Java SE 下载。您将在下载的文件中找到安装 JDK 的说明，按照给定的说明进行安装和配置设置。最后设置 PATH 和 JAVA_HOME 环境变量以引用包含 java 和 javac 的目录，通常分别为 java_install_dir/bin 和 java_install_dir。

如果您运行的是 Windows 并将 JDK 安装在 C:\jdk1.7.0_75 中，则必须将以下行放入 C:\autoexec.bat 文件中。

set PATH=C:\jdk1.7.0_75\bin;%PATH%
set JAVA_HOME=C:\jdk1.7.0_75

或者，在 Windows NT/2000/XP 上，您也可以右键单击“我的电脑”，选择“属性”，然后选择“高级”，然后选择“环境变量”。然后，您将更新 PATH 值并按“确定”按钮。

在 Unix（Solaris、Linux 等）上，如果 SDK 安装在 /usr/local/jdk1.7.0_75 中并且您使用 C shell，则需要将以下内容放入 .cshrc 文件中。

setenv PATH /usr/local/jdk1.7.0_75/bin:$PATH
setenv JAVA_HOME /usr/local/jdk1.7.0_75

或者，如果您使用集成开发环境 (IDE)，例如 Borland JBuilder、Eclipse、IntelliJ IDEA 或 Sun ONE Studio，请编译并运行一个简单的程序以确认 IDE 知道您安装 Java 的位置，否则按照给定文档进行正确设置IDE 的。

第 2 步 - 设置 Eclipse IDE

本教程中的所有示例都是使用 Eclipse IDE 编写的。所以我建议你应该在你的机器上安装最新版本的 Eclipse。

要安装 Eclipse IDE，请从http://www.eclipse.org/downloads/下载最新的 Eclipse 二进制文件。下载安装后，将二进制发行版解压到一个方便的位置。例如，在 Windows 上的 C:\eclipse 中，或在 Linux/Unix 上的 /usr/local/eclipse 中，最后适当地设置 PATH 变量。

可以通过在 Windows 机器上执行以下命令来启动 Eclipse，也可以直接双击 eclipse.exe

 %C:\eclipse\eclipse.exe

Eclipse可以通过在Unix（Solaris、Linux等）机器上执行以下命令来启动：

$/usr/local/eclipse/eclipse

成功启动后，如果一切正常，则应显示以下结果：

第 3 步：下载 Junit 存档

从http://www.junit.org下载最新版本的 JUnit jar 文件。在编写本教程时，我下载了Junit-4.10.jar并将其复制到 C:\>JUnit 文件夹中。

第四步：设置JUnit环境

将JUNIT_HOME环境变量设置为指向计算机上存储 JUNIT jar 的基本目录位置。假设我们已将 junit4.10.jar 存储在各种操作系统上的 JUNIT 文件夹中，如下所示。

第 5 步：设置 CLASSPATH 变量

将CLASSPATH环境变量设置为指向 JUNIT jar 位置。假设我们已将 junit4.10.jar 存储在各种操作系统上的 JUNIT 文件夹中，如下所示。

第 6 步 - 设置Concordion库

现在，如果一切正常，那么您可以继续设置您的 Concordion 库。以下是在您的计算机上下载并安装框架的简单步骤。

从 http://dl.bintray.com/concordion/downloads/concordion-1.5.1.zip 下载最新版本的 Concordion 框架二进制文件。

在编写本教程时，我在 Windows 计算机上下载了 concordion-1.5.1，当您解压下载的文件时，它将在 E:\concordion-1.5.1 中提供以下目录结构，如下所示。

• lib - 库文件夹

  • hamcrest-core-1.3.jar

  • junit-4.12.jar

  • ognl-2.6.9.jar

  • xom-1.2.5.jar

• src - 源代码文件夹

  • 主要的

  • 测试

  • 测试假人

• Concordion-1.5.1.jar

您将在目录 E:\concordion\lib 中找到所有 Concordion 依赖库。确保在此目录上正确设置 CLASSPATH 变量，否则在运行应用程序时将遇到问题。如果您使用 Eclipse，则不需要设置 CLASSPATH，因为所有设置都将通过 Eclipse 完成。

完成最后一步后，您就可以继续进行第一个Concordion示例，您将在下一章中看到该示例。

Concordion - 首次应用

让我们开始使用 Concordion 进行编程。在开始使用 Concordion 编写第一个示例之前，您必须确保已按照Concordion - 环境设置教程中的说明正确设置了 Concordion 环境。我们还假设您有一点 Eclipse IDE 的应用知识。

因此，让我们继续编写一个简单的 Concordion 应用程序，它将打印以下验收测试 -

Example
When Robert logs in the system, a greeting "Hello Robert!" is displayed.

第 1 步 - 创建 Java 项目

第一步是使用 Eclipse IDE 创建一个简单的 Java 项目。按照选项“文件”→“新建”→“项目”，最后从向导列表中选择“Java 项目向导”。现在使用向导窗口将您的项目命名为Concordion ，如下所示 -

成功创建项目后，您的项目资源管理器中将包含以下内容-

第 2 步 - 添加所需的库

让我们在项目中添加Concordion及其依赖项。为此，右键单击您的项目名称concorion，然后按照上下文菜单中的可用选项进行操作：构建路径 → 配置构建路径以显示 Java 构建路径窗口，如下所示 -

现在，使用“库”选项卡下的“添加外部 JAR”按钮从 Concordion 文件夹中添加以下核心 JAR。

• Concordion-1.5.1
• hamcrest-core-1.3
• junit-4.12
• ognl-2.6.9
• xom-1.2.5

第 3 步 - 创建源文件

现在让我们在Concordion项目下创建实际的源文件。首先，我们需要创建一个名为com.tutorialspoint的包。为此，请右键单击包资源管理器部分中的src并遵循选项：新建 → 包。

接下来，我们将在 com.tutorialspoint 包下创建 System.java文件。

这是System.java文件的内容-

package com.tutorialspoint;

public class System {
   public String getGreeting(String userName){
      return "Hello " + userName + "!";
   }
}

第 4 步 - 创建规范文件

现在让我们在Concordion项目下创建实际的规范文件。首先，我们需要创建一个名为specs的新源文件夹。该文件夹将包含 JUnitFixture 或测试运行程序等规范文件以及规范的 html 文件。现在我们需要创建一个名为specs.tutorialspoint的包。为此，请右键单击包资源管理器部分中的规范，然后选择选项：新建 → 包。

接下来，我们将在specs.tutorialspoint包下创建System.html和SystemFixture.java文件。此后，我们将在specs源文件夹下添加concordion.css。

这是System.html文件的内容-

<html xmlns:concordion = "http://www.concordion.org/2007/concordion">
   <head>
      <link href = "../concordion.css" rel = "stylesheet" type="text/css" />
   </head>

   <body>
      <h1>System Specifications</h1>
      <p>We are building specifications for our online order tracking application.</p>
      <p>Following is the requirement to show greeting to logged in user:</p>
      <div class = "example">      
         <h3>Example</h3>
         <p>When <span concordion:set = "#userName">Robert</span> 
            logs in the system, a greeting "<span concordion:assertEquals = "getGreeting(#userName)">
            Hello Robert!</span>" is displayed.</p>
      </div>
   </body>

</html>

这是SystemFixture.java文件的内容-

package specs.tutorialspoint;

import com.tutorialspoint.System;
import org.concordion.integration.junit4.ConcordionRunner;
import org.junit.runner.RunWith;

@RunWith(ConcordionRunner.class)

public class SystemFixture {

   System system = new System();
	
   public String getGreeting(String userName){
      return system.getGreeting(userName);
   }
}

这是concordion.css文件的内容-

* {
   font-family: Arial;
}

body {
   padding: 32px;  
}

pre {
   padding: 6px 28px 6px 28px;
   background-color: #E8EEF7;
}

pre, pre *, code, code *, kbd {
   font-family: Courier New, Courier;
   font-size: 10pt;
}

h1, h1 * {
   font-size: 24pt;	
}

p, td, th, li, .breadcrumbs {
   font-size: 10pt;
}

p, li {
   line-height: 140%;
}

table {
   border-collapse: collapse;
   empty-cells: show;
   margin: 8px 0px 8px 0px;
}

th, td {
   border: 1px solid black;
   padding: 3px;
}

td {
   background-color: white;
   vertical-align: top;
}

th {
   background-color: #C3D9FF;
}

li {
   margin-top: 6px;
   margin-bottom: 6px; 
}

.example {
   padding: 6px 16px 6px 16px;
   border: 1px solid #D7D7D7;
   margin: 6px 0px 28px 0px;
   background-color: #F7F7F7;
}

.example h3 {
   margin-top: 8px;
   margin-bottom: 8px;
   font-size: 12pt;
}

.special {
  font-style: italic;
}

.idea {
  font-size: 9pt;
  color: #888;
  font-style: italic;	
}

.tight li {
  margin-top: 1px;
  margin-bottom: 1px; 
}

.commentary {
  float: right;
  width: 200px;
  background-color: #ffffd0;
  padding:8px;
  border: 3px solid #eeeeb0;	 
  margin: 10px 0px 10px 10px;	 
}

.commentary, .commentary * {
  font-size: 8pt;
}

关于规范 html 文件和测试夹具，有两点需要注意：

• System.html 是使用concordion 命名空间的规范html 文件。

<html xmlns:concordion="http://www.concordion.org/2007/concordion">

• System.html使用concordion:set命令将临时变量userName的值设置为Robert。这里，userName 是要传递给 System Fixture 的 getGreeting 方法的参数。

When <span concordion:set="#userName">Robert</span> logs in the system

• System.html 使用 concordion:assertEquals 命令检查 getGreeting(userName) 函数的输出是否为 Hello Robert!。

a greeting "<span concordion:assertEquals="getGreeting(#userName)">
Hello Robert!</span>" is displayed.

• SystemFixture 是一个用 ConcordionRunner.class 注释的 JUnit 测试装置。

@RunWith(ConcordionRunner.class)
public class SystemFixture {

• SystemFixture 有一个 getGreeting 方法，可以向用户返回问候语。

public String getGreeting(String userName){
   return system.getGreeting(userName);
}

第 5 步 - 运行程序

右键单击 SystemFixture 的内容区域并选择Run as > JUnit Test Case。如果 junit 成功，您将看到以下输出。

C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\concordion\specs\tutorialspoint\System.html
Successes: 1, Failures: 0

System.html 是 Concordion 测试运行的输出。

恭喜，您已成功创建第一个 Concordion 验收测试。此外，让我们在接下来的几章中开始做一些更有趣的事情。

Concordion - 设置命令

Concordion set 命令用于存储可在其他 Concordion 命令中使用的临时变量。

考虑以下要求 -

The Sum of two numbers 2 and 3 will be 5.

如果我们希望数字 2 和 3 作为参数并将它们作为参数传递给 sum 函数，以便可以根据系统返回的结果来验证它们，那么我们可以在数字周围的 span 标签内使用 concordion:set 命令。

<p>The Sum of two numbers <span concordion:set = "#firstNumber">2</span> 
   and <span concordion:set = "#secondNumber">3</span> will be 
   <span concordion:assertEquals = "sum(#firstNumber, #secondNumber)">5
   </span>.</p>

当 Concordion 解析文档时，它将设置临时变量 #firstNumber 为值“2”，#secondNumber 为值“3”，然后以 #firstNumber 和 #secondNumber 为参数调用 sum() 方法并检查结果等于“5”。

例子

让我们有一个可用的 Eclipse IDE，并按照下面给出的步骤创建一个 Concordion 应用程序 -

这是 System.java 文件的内容 -

package com.tutorialspoint;
public class System {
   public int sum(int firstNumber, int secondNumber) {
      return firstNumber + secondNumber;
   }
}

以下是 SystemFixture.java 文件的内容 -

package specs.tutorialspoint;

import org.concordion.integration.junit4.ConcordionRunner;
import org.junit.runner.RunWith;
import com.tutorialspoint.System;

@RunWith(ConcordionRunner.class)

public class SystemFixture {
   System system = new System();
   public int sum(int firstNumber, int secondNumber) {
      return system.sum(firstNumber, secondNumber);
   }
}

以下是 System.html 文件的内容 -

<html xmlns:concordion = "http://www.concordion.org/2007/concordion">
   <head>
      <link href = "../concordion.css" rel = "stylesheet" type = "text/css" />
   </head>

   <body>
      <h1>Calculator Specifications</h1>
      <p>We are building online calculator support in our website.</p>
      <p>Following is the requirement to add two numbers:</p>
		
      <div class = "example">
         <h3>Example</h3>
         <p>The Sum of two numbers <span concordion:set = "#firstNumber">2</span> 
            and <span concordion:set = "#secondNumber">3</span> will be 
            <span concordion:execute = "#result = sum(#firstNumber, #secondNumber)"></span>
            <span concordion:assertEquals = "#result">5</span>.</p>
      </div>
   </body>

</html>

完成源文件和规范文件的创建后，让我们将应用程序作为 JUnit 测试运行。如果您的应用程序一切正常，它将产生以下结果 -

C:\DOCUME>1\ADMINI>1\LOCALS>1\Temp\concordion\specs\tutorialspoint\System.html
Successes: 1, Failures: 0

System.html 是Concordion测试运行的输出。

Concordion -assertEquals 命令

Concordion assertEquals 命令用于根据指定值检查 Java bean 属性或方法结果。

考虑以下要求 -

The sum of two numbers 2 and 3 will be 5.

如果我们希望数字 2 和 3 作为参数并将它们作为参数传递给 sum 函数，以便可以根据系统返回的结果 5 进行验证，那么我们可以在 sum 函数周围的 span 标签内使用 concordion:assertEquals 命令。

<p>The Sum of two numbers <span concordion:set="#firstNumber">2</span> 
   and  <span concordion:set="#secondNumber">3</span> will be 
   <span concordion:assertEquals="sum(#firstNumber, #secondNumber)">5</span>.</p>

当Concordion解析文档时，它会使用set命令将临时变量#firstNumber设置为值“2”，将#secondNumber设置为值“3”，然后调用参数为#firstNumber和#secondNumber的sum()方法并使用assertEquals命令检查结果是否等于“5”。

例子

让我们准备好可用的 Eclipse IDE，并按照以下步骤创建 Concordion 应用程序 -

这是 System.java 文件的内容 -

package com.tutorialspoint;
public class System {
   public int sum(int firstNumber, int secondNumber) {
      return firstNumber + secondNumber;
   }
}

以下是 SystemFixture.java 文件的内容 -

package specs.tutorialspoint;

import org.concordion.integration.junit4.ConcordionRunner;
import org.junit.runner.RunWith;
import com.tutorialspoint.System;

@RunWith(ConcordionRunner.class)

public class SystemFixture {
   System system = new System();
   public int sum(int firstNumber, int secondNumber) {
      return system.sum(firstNumber, secondNumber);
   }
}

以下是 System.html 文件的内容 -

<html xmlns:concordion = "http://www.concordion.org/2007/concordion">
   <head>
      <link href = "../concordion.css" rel = "stylesheet" type = "text/css" />
   </head>

   <body>
      <h1>Calculator Specifications</h1>
      <p>We are building online calculator support in our website.</p>
      <p>Following is the requirement to add two numbers:</p>
		
      <div class = "example">
         <h3>Example</h3>
         <p>The Sum of two numbers <span concordion:set = "#firstNumber">2</span> 
            and  <span concordion:set = "#secondNumber">3</span> will be 
            <span concordion:assertEquals = "sum(#firstNumber, #secondNumber)">5</span>.</p>
      </div>
		
   </body>

</html>

创建完源文件和规范文件后，让我们将应用程序作为 JUnit 测试运行。如果您的应用程序一切正常，那么它将显示以下结果 -

C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\concordion\specs\tutorialspoint\System.html
Successes: 1, Failures: 0

System.html 是 Concordion 测试运行的输出。

成功：1，失败：0

Concordion-assertTrue 命令

当装置需要知道预期结果以执行测试时，使用 Concordion assertTrue 命令。

考虑以下要求 -

User Name : Robert De
The User name starts with R.
The User name starts with S == false.

如果我们想对用户名执行测试，检查用户名是否以R开头。

<p>User Name :<span concordion:set = "#userName">Robert De</span></p>
<p>The User name <span concordion:assertTrue = "#userName.startsWith(#letter)">starts
   with <b concordion:set = "#letter">R</b></span>.</p>
<p>The User name <span concordion:assertTrue = "#userName.startsWith(#letter)">starts
   with <b concordion:set = "#letter">S</b></span>.</p>   

当 Concordion 解析文档时，它会将临​​时变量 #userName 设置为值“Robert De”。然后它将检查用户名是否以下一个命令中设置的#letter变量指定的字母开头。

例子

让我们有一个可用的 Eclipse IDE，并按照下面给出的步骤创建一个 Concordion 应用程序 -

这是 System.java 文件的内容 -

package com.tutorialspoint;
public class System {   
}

以下是 SystemFixture.java 文件的内容 -

package specs.tutorialspoint;

import org.concordion.integration.junit4.ConcordionRunner;
import org.junit.runner.RunWith;

@RunWith(ConcordionRunner.class)

public class SystemFixture {
}

以下是 System.html 文件的内容 -

<html xmlns:concordion = "http://www.concordion.org/2007/concordion">
   <head>
      <link href = "../concordion.css" rel = "stylesheet" type = "text/css" />
   </head>

   <body>
      <h1>System Specifications</h1>
      <p>We are building specifications for our online order tracking application.</p>
      <p>Following is the requirement to split full name of a logged in user to 
         its constituents by splitting name by whitespace:</p>
   
      <div class = "example">      
         <h3>Example</h3>
         <p>User Name :<span concordion:set = "#userName">Robert De</span></p>
         <p>The User name <span concordion:assertTrue = "#userName.startsWith(#letter)">starts
            with <b concordion:set = "#letter">R</b></span>.</p>
         <p>The User name <span concordion:assertTrue = "#userName.startsWith(#letter)">starts
            with <b concordion:set = "#letter">S</b></span>.</p>          
      </div>
		
   </body>

</html>

创建完源文件和规范文件后，让我们将应用程序作为 JUnit 测试运行。如果您的应用程序一切正常，那么它将产生以下结果 -

C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\concordion\specs\tutorialspoint\System.html
Successes: 1, Failures: 1

System.html 是 Concordion 测试运行的输出。

Concordion-assertFalse 命令

当装置需要知道预期结果以执行测试时，使用 Concordion assertFalse 命令。

考虑以下要求 -

User Name : Robert De
The User name does not start with S.

如果我们想要对用户名执行测试并检查用户名是否不以 S 开头。

<p>User Name :<span concordion:set = "#userName">Robert De</span></p>
<p>The User name <span concordion:assertFalse = "#userName.startsWith(#letter)">does not start
   with <b concordion:set = "#letter">S</b></span>.</p>  

当 Concordion 解析文档时，它会将临​​时变量 #userName 设置为值“Robert De”。然后，它将检查用户名是否以下一个命令中设置的#letter变量指定的字母开头。

例子

让我们有一个可用的 Eclipse IDE，并按照下面给出的步骤创建一个 Concordion 应用程序 -

这是 System.java 文件的内容 -

package com.tutorialspoint;
public class System {   
}

以下是 SystemFixture.java 文件的内容 -

package specs.tutorialspoint;

import org.concordion.integration.junit4.ConcordionRunner;
import org.junit.runner.RunWith;

@RunWith(ConcordionRunner.class)

public class SystemFixture {
}

以下是 System.html 文件的内容 -

<html xmlns:concordion = "http://www.concordion.org/2007/concordion">
   <head>
      <link href = "../concordion.css" rel = "stylesheet" type = "text/css" />
   </head>

   <body>
      <h1>System Specifications</h1>
      <p>We are building specifications for our online order tracking application.</p>
      <p>Following is the requirement to split full name of a logged in user to its 
         constituents by splitting name by whitespace:</p>
			
      <div class = "example">      
         <h3>Example</h3>
         <p>User Name :<span concordion:set = "#userName">Robert De</span></p>
         <p>The User name <span concordion:assertFalse = "#userName.startsWith(#letter)">
            does not start with <b concordion:set = "#letter">
            S</b></span>.</p> 
      </div>
		
   </body>

</html>

创建完源文件和规范文件后，让我们将应用程序作为 JUnit 测试运行。如果您的应用程序一切正常，那么它将产生以下结果 -

C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\concordion\specs\tutorialspoint\System.html
成功：1，失败：0

System.html 是 Concordion 测试运行的输出。

Concordion - 执行命令

Concordion执行命令用于运行Concordion夹具的操作。考虑以下要求 -

The sum of two numbers 2 and 3 will be 5.

如果我们想为一个 sum 函数编写一个规范，它接受两个数字并输出它们的和，那么规范将如下 -

<p>The Sum of two numbers <span concordion:set = "#firstNumber">2</span> and 
   <span concordion:set = "#secondNumber">3</span> will be
   <span concordion:execute = "#result = sum(#firstNumber, #secondNumber)">
   </span><span concordion:assertEquals = "#result">5</span>.</p>

当 Concordion 解析文档时，它将设置一个临时变量#firstNumber 为值“2”，#secondNumber 为值“3”，然后使用execute 执行参数为#firstNumber 和#secondNumber 的sum() 方法。命令并将结果设置到#result变量中，并检查#result变量是否等于“5”。

例子

让我们有一个可用的 Eclipse IDE，并按照下面给出的步骤创建一个 Concordion 应用程序 -

这是 System.java 文件的内容 -

package com.tutorialspoint;
public class System {
   public int sum(int firstNumber, int secondNumber) {
      return firstNumber + secondNumber;
   }
}

以下是 SystemFixture.java 文件的内容 -

package specs.tutorialspoint;

import org.concordion.integration.junit4.ConcordionRunner;
import org.junit.runner.RunWith;
import com.tutorialspoint.System;

@RunWith(ConcordionRunner.class)

public class SystemFixture {
   System system = new System();
   public int sum(int firstNumber, int secondNumber) {
      return system.sum(firstNumber, secondNumber);
   }
}

以下是 System.html 文件的内容 -

<html xmlns:concordion = "http://www.concordion.org/2007/concordion">
   <head>
      <link href = "../concordion.css" rel = "stylesheet" type = "text/css" />
   </head>

   <body>
      <h1>Calculator Specifications</h1>
      <p>We are building online calculator support in our website.</p>
      <p>Following is the requirement to add two numbers:</p>
		
      <div class = "example">
         <h3>Example</h3>
         <p>The Sum of two numbers <span concordion:set = "#firstNumber">2</span> 
            and <span concordion:set = "#secondNumber">3</span> will be 
            <span concordion:execute = "#result = sum(#firstNumber, #secondNumber)">
            </span><span concordion:assertEquals = "#result">5</span>.</p>
      </div>
		
   </body>

</html>

创建完源文件和规范文件后，让我们将应用程序作为 JUnit 测试运行。如果您的应用程序一切正常，那么它将产生以下结果 -

C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\concordion\specs\tutorialspoint\System.html
Successes: 1, Failures: 0

System.html 是 Concordion 测试运行的输出。

Concordion - 返回对象

Concordion 执行命令可用于以对象的形式获取Behave的结果，使用对象我们可以获得Behave的多个输出。例如，考虑以下要求 -

The full name Robert De is to be broken into first name Robert and last name De.

这里我们需要一个 split 函数，它接受用户名并返回一个以名字和姓氏作为属性的结果对象，以便我们可以使用它们。

如果我们想为这样的 split 函数编写一个规范，该函数需要用户名并输出结果对象，那么规范如下：

<p>The full name <span concordion:execute = "#result = split(#TEXT)">Robert 
   De</span> is to be broken into first name 
   <span concordion:assertEquals = "#result.firstName">Robert</span> and last name 
   <span concordion:assertEquals = "#result.lastName">De</span>.</p>

当Concordion解析文档时，它会将特殊变量#TEXT的值设置为当前元素的值“Robert De”，并将其传递给split函数。然后，它将使用execute命令执行参数为#TEXT的split()方法，并将结果设置到#result变量中，并使用结果对象，打印firstName和lastName属性作为输出。

例子

让我们有一个可用的 Eclipse IDE，并按照下面给出的步骤创建一个 Concordion 应用程序 -

这是 Result.java 文件的内容 -

package com.tutorialspoint;
public class Result {
   private String firstName;
   private String lastName;
	
   public String getFirstName() {
      return firstName;
   }
	
   public void setFirstName(String firstName) {
      this.firstName = firstName;
   }
	
   public String getLastName() {
      return lastName;
   }
	
   public void setLastName(String lastName) {
      this.lastName = lastName;
   } 
}

这是 System.java 文件的内容 -

package com.tutorialspoint;
public class System {
   public Result split(String userName){
      Result result = new Result();
      String[] words = userName.split(" ");
      result.setFirstName(words[0]);
      result.setLastName(words[1]);
      return result;
   }
}

以下是 SystemFixture.java 文件的内容 -

package specs.tutorialspoint;

import com.tutorialspoint.Result;
import com.tutorialspoint.System;
import org.concordion.integration.junit4.ConcordionRunner;
import org.junit.runner.RunWith;

@RunWith(ConcordionRunner.class)

public class SystemFixture {
   System system = new System();
   public Result split(String userName){
      return system.split(userName);
   }  
}

以下是 System.html 文件的内容 -

<html xmlns:concordion = "http://www.concordion.org/2007/concordion">
   <head>
      <link href = "../concordion.css" rel = "stylesheet" type = "text/css" />
   </head>

   <body>
      <h1>System Specifications</h1>
      <p>We are building specifications for our online order tracking application.</p>
      <p>Following is the requirement to split full name of a logged in user to its 
         constituents by splitting name by whitespace:</p>
			
      <div class = "example">      
         <h3>Example</h3>
         <p>The full name <span concordion:execute = "#result = split(#TEXT)">Robert 
            De</span> is to be broken into first name <span 
            concordion:assertEquals = "#result.firstName">Robert</span> and last name <span 
            concordion:assertEquals = "#result.lastName">De</span>.</p>
      </div>
		
   </body>
	
</html>

完成源文件和规范文件的创建后，让我们将应用程序作为 JUnit 测试运行。如果您的应用程序一切正常，那么它将产生以下结果 -

C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\concordion\specs\tutorialspoint\System.html
Successes: 1, Failures: 0

System.html 是 Concordion 测试运行的输出。

康科迪恩 - 返回地图

Concordion 执行命令可用于以 Map 的形式获取Behave的结果，使用它我们可以获得Behave的多个输出。例如，考虑以下要求 -

The full name Robert De is to be broken into its first name Robert and last name De.

这里我们需要一个溢出函数，它接受用户名并返回一个 Map 对象，该对象以firstName和lastName为键，并具有相应的值，以便我们可以使用它们。

如果我们想为这样的 split 函数编写一个规范，该函数将接受用户名并输出结果对象，那么规范如下：

<p>The full name <span concordion:execute = "#result = split(#TEXT)">Robert 
   De</span> is to be broken into first name <span 
   concordion:assertEquals = "#result.firstName">Robert</span> and last name <span 
   concordion:assertEquals = "#result.lastName">De</span>.</p>

当Concordion解析文档时，它会将特殊变量#TEXT的值设置为当前元素的值“Robert De”，并将其传递给split函数。然后它将使用execute命令执行参数为#TEXT的split()方法，并将结果设置到#result变量中，并使用结果映射，打印firstName和lastName值作为输出。

例子

让我们有一个可用的 Eclipse IDE，并按照下面给出的步骤创建一个 Concordion 应用程序 -

这是 System.java 文件的内容 -

package com.tutorialspoint;

import java.util.HashMap;
import java.util.Map;

public class System {
   public Map split(String userName){
      Map<String, String> result = new HashMap<String, String>();
      String[] words = userName.split(" ");
      result.put("firstName", words[0]);
      result.put("lastName", words[1]);
      return result;
   }
}

以下是 SystemFixture.java 文件的内容 -

package specs.tutorialspoint;

import java.util.Map;
import com.tutorialspoint.Result;
import com.tutorialspoint.System;
import org.concordion.integration.junit4.ConcordionRunner;
import org.junit.runner.RunWith;

@RunWith(ConcordionRunner.class)

public class SystemFixture {
   System system = new System();
   public Map<String, String> split(String userName){
      return system.split(userName);
   }  
}

以下是 System.html 文件的内容 -

<html xmlns:concordion = "http://www.concordion.org/2007/concordion">
   <head>
      <link href = "../concordion.css" rel = "stylesheet" type = "text/css" />
   </head>

   <body>
      <h1>System Specifications</h1>
      <p>We are building specifications for our online order tracking application.</p>
      <p>Following is the requirement to split full name of a logged in user to its 
         constituents by splitting name by whitespace:</p>
			
      <div class = "example">      
         <h3>Example</h3>
         <p>The full name <span concordion:execute = "#result = split(#TEXT)">Robert 
            De</span> is to be broken into first name <span 
            concordion:assertEquals = "#result.firstName">Robert</span> and last name 
            <span concordion:assertEquals = "#result.lastName">De</span>.</p>
      </div>
		
   </body>

</html>

完成源文件和规范文件的创建后，让我们将应用程序作为 JUnit 测试运行。如果您的应用程序一切正常，那么它将产生以下结果 -

C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\concordion\specs\tutorialspoint\System.html
Successes: 1, Failures: 0

System.html 是 Concordion 测试运行的输出。

Concordion - 返回 MultiValueResult

Concordion 执行命令可用于以 Map 的形式获取Behave的结果，使用它我们可以获得Behave的多个输出。例如，考虑以下要求 -

The full name Robert De is to be broken into its first name Robert and last name De.

这里我们需要一个 split 函数，它接受用户名并返回一个 Map 对象，该对象以firstName和lastName作为键及其相应的值，以便我们可以使用它们。

如果我们想为这样的 split 函数编写一个规范，该函数将接受用户名并输出结果对象，那么规范将如下 -

<p>The full name <span concordion:execute = "#result = split(#TEXT)">Robert 
   De</span> is to be broken into first name 
   <span concordion:assertEquals = "#result.firstName">Robert</span> and last name 
   <span concordion:assertEquals = "#result.lastName">De</span>.</p>

当Concordion解析文档时，它会将特殊变量#TEXT的值设置为当前元素的值“Robert De”，并将其传递给split函数。然后它将使用execute命令执行参数为#TEXT的split()方法，并将结果设置到#result变量中，并使用结果映射，打印firstName和lastName值作为输出。

例子

让我们有一个可用的 Eclipse IDE，并按照下面给出的步骤创建一个 Concordion 应用程序 -

这是 System.java 文件的内容 -

package com.tutorialspoint;
import org.concordion.api.MultiValueResult;

public class System { 
   public MultiValueResult split(String userName){  
      MultiValueResult result = new MultiValueResult();
      String[] words = userName.split(" ");   
      result.with("firstName", words[0]).with("lastName", words[1]);       
      return result;
   }
}

以下是 SystemFixture.java 文件的内容 -

package specs.tutorialspoint;

import org.concordion.api.MultiValueResult;
import org.concordion.integration.junit4.ConcordionRunner;
import org.junit.runner.RunWith;

import com.tutorialspoint.System;

@RunWith(ConcordionRunner.class)
public class SystemFixture {
   System system = new System();
   public MultiValueResult split(String userName){
      return system.split(userName);
   }  
}

以下是 System.html 文件的内容 -

<html xmlns:concordion = "http://www.concordion.org/2007/concordion">
   <head>
      <link href = "../concordion.css" rel = "stylesheet" type = "text/css" />
   </head>

   <body>
      <h1>System Specifications</h1>
      <p>We are building specifications for our online order tracking application.</p>
      <p>Following is the requirement to split full name of a logged in 
         user to its constituents by splitting name by whitespace:</p>
		
      <div class = "example">      
         <h3>Example</h3>
         <p>The full name <span concordion:execute = "#result = split(#TEXT)">Robert De</span> 
            is to be broken into first name <span 
            concordion:assertEquals = "#result.firstName">Robert</span> and last name <span 
            concordion:assertEquals = "#result.lastName">De</span>.</p>
      </div>
		
   </body>

</html>

完成源文件和规范文件的创建后，让我们将应用程序作为 JUnit 测试运行。如果您的应用程序一切正常，那么它将产生以下结果 -

C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\concordion\specs\tutorialspoint\System.html
Successes: 2, Failures: 0

System.html 是 Concordion 测试运行的输出。

Concordion - 在表上执行

Concordion执行命令可用于重复运行Concordion夹具的操作。例如，如果我们想以表格的形式用多个示例来说明某个需求，这将很有用。

考虑以下要求 -

<table>
   <tr><th>First Number</th><th>Second Number</th><th>Sum</th></tr>
   <tr><td>2</td><td>3</td><td>5</td></tr>
   <tr><td>4</td><td>5</td><td>9</td></tr>
</table>

如果我们想为一个 sum 函数编写一个规范，它接受两个数字并输出它们的和，那么规范将如下 -

<table>
   <tr><th>First Number</th><th>Second Number</th><th>Sum</th></tr>
   <tr concordion:execute = "#result = sum(#fullName)">
      <td concordion:set = "#firstNumber">2</td>
      <td concordion:set = "#secondNumber">3</td>
      <td concordion:assertEquals = "#result">5</td>
   </tr>
   <tr concordion:execute = "#result = sum(#fullName)">
      <td concordion:set = "#firstNumber">4</td>
      <td concordion:set = "#secondNumber">5</td>
      <td concordion:assertEquals = "#result">9</td>
   </tr>
</table>

当Concordion 解析文档时，它会将临​​时变量#firstNumber 设置为值“2”，将#secondNumber 设置为值“3”。然后，它将使用execute命令执行参数为#firstNumber和#secondNumber的sum()方法，并将结果设置到#result变量中，并检查#result变量是否等于“5”。对每个表行元素重复此过程。

例子

让我们有一个可用的 Eclipse IDE，并按照下面给出的步骤创建一个 Concordion 应用程序 -

这是 System.java 文件的内容 -

package com.tutorialspoint;
public class System {
   public int sum(int firstNumber, int secondNumber) {
      return firstNumber + secondNumber;
   }
}

以下是 SystemFixture.java 文件的内容 -

package specs.tutorialspoint;

import org.concordion.integration.junit4.ConcordionRunner;
import org.junit.runner.RunWith;
import com.tutorialspoint.System;

@RunWith(ConcordionRunner.class)

public class SystemFixture {
   System system = new System();
   public int sum(int firstNumber, int secondNumber) {
      return system.sum(firstNumber, secondNumber);
   }
}

以下是 System.html 文件的内容 -

<html xmlns:concordion = "http://www.concordion.org/2007/concordion">
   <head>
      <link href = "../concordion.css" rel = "stylesheet" type = "text/css" />
   </head>

   <body>
      <h1>Calculator Specifications</h1>
      <p>We are building online calculator support in our website.</p>
      <p>Following is the requirement to add two numbers:</p>
		
      <div class = "example">
         <h3>Example</h3>
         <table>
            <tr>
               <th>First Number</th>
               <th>Second Number</th>
               <th>Sum</th>
            </tr>
            <tr concordion:execute = "#result = sum(#firstNumber, #secondNumber)">
               <td concordion:set = "#firstNumber">2</td>
               <td concordion:set = "#secondNumber">3</td>
               <td concordion:assertEquals = "#result">5</td>
            </tr>
            <tr concordion:execute = "#result = sum(#firstNumber, #secondNumber)">
               <td concordion:set = "#firstNumber">4</td>
               <td concordion:set = "#secondNumber">5</td>
               <td concordion:assertEquals = "#result">9</td>
            </tr>
         </table>
      </div>
		
   </body>

</html>

完成源文件和规范文件的创建后，让我们将应用程序作为 JUnit 测试运行。如果您的应用程序一切正常，那么它将产生以下结果 -

C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\concordion\specs\tutorialspoint\System.html
Successes: 2, Failures: 0

System.html 是 Concordion 测试运行的输出。

Concordion - 在列表上执行

Concordion执行命令可用于重复运行Concordion夹具的操作。例如，如果我们想以列表的形式用多个示例来说明某个需求，这将很有用。

考虑以下要求 -

<ul>
   <li>The full name Robert De is to be split as
      <ul>
         <li>Robert</li>
         <li>De</li>
      </ul>
   </li>
	
   <li>The full name John Diere is to be split as
      <ul>
         <li>John</li>
         <li>Diere</li>
      </ul>
   </li>
	
</ul>

如果我们想为 split 函数编写一个规范，它将一个名字分割成名字和姓氏，那么规范将如下 -

<ul>
   <li>The full name <span concordion:execute = "#result = split(#TEXT)">
      Robert De</span> is to be splited as
      <ul>
         <li><span concordion:assertEquals = "#result.firstName">Robert</span></li>
         <li><span concordion:assertEquals = "#result.lastName">De</span></li>
      </ul>
   </li>
	
   <li>The full name <span concordion:execute = "#result = split(#TEXT)">
      John Diere</span> is to be splited as
      <ul>
         <li><span concordion:assertEquals = "#result.firstName">John</span></li>
         <li><span concordion:assertEquals = "#result.lastName">Diere</span></li>
      </ul>
   </li>
</ul>

当Concordion解析文档时，它会将特殊变量#TEXT的值设置为当前的值