Concordion - 快速指南

什么是 Concordion？

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

主动软件规范

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

Concordion 中的主动规范分为两个部分

使用 XHTML 编写的简洁明了的需求文档，其中描述了所需的用 XHTML 编写的功能。基于 XHTML 的规范包含对使用验收测试示例提供的功能的描述。示例数据使用简单的 HTML 标签标记。
验收测试是用 Java 语言编写的，称为夹具代码。使用标准 JUnit 测试用例的 Concordion 扩展，实现测试。夹具代码负责查找由标签标记的示例数据，并使用它们来验证正在开发的软件。

Cncordion 的输出

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

主要特征

以下是 Concordion 的主要功能

规范作为文档 - Concordion 规范具有很强的可读性，可以用作活动的系统文档。由于基于 Concordion 的规范是用 HTML 编写的，因此这些文档可以超链接。
规范是活跃的 - Concordion 规范包含针对系统执行的行为工作示例。规范使用颜色编码，以便任何人都可以查看示例是否有效。定期执行 Concordion 规范使文档保持最新。
将“什么？”与“如何？”分开 - Concordion 规范有助于维护系统实现和所需行为之间的分离。它提供了以后可以更改实现的灵活性。
易于学习 - Concordion 库的设计旨在缩短学习曲线并使其简洁。它只有很少的命令需要学习，并且示例使用 JUnit 测试自动化，以便可以轻松运行测试并轻松地集成到现有项目中。
强大的自定义功能 - Concordion 提供扩展 API，允许添加功能。例如，可以使用 Excel 电子表格作为规范，可以将屏幕截图添加到输出中，可以显示日志信息等等。

Concordion - 环境设置

本教程将指导您如何准备开发环境以开始使用 Spring Framework 的工作。本教程还将教您如何在设置 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

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

$/usr/local/eclipse/eclipse

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

步骤 3：下载 Junit 档案

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

操作系统	档案名称
Windows	junit4.10.jar
Linux	junit4.10.jar
Mac	junit4.10.jar

步骤 4：设置 JUnit 环境

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

操作系统	输出
Windows	将环境变量 JUNIT_HOME 设置为 C:\JUNIT
Linux	export JUNIT_HOME=/usr/local/JUNIT
Mac	export JUNIT_HOME=/Library/JUNIT

步骤 5：设置 CLASSPATH 变量

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

操作系统	输出
Windows	将环境变量 CLASSPATH 设置为 %CLASSPATH%;%JUNIT_HOME%\junit4.10.jar;.;
Linux	export CLASSPATH=$CLASSPATH:$JUNIT_HOME/junit4.10.jar:.
Mac	export CLASSPATH=$CLASSPATH:$JUNIT_HOME/junit4.10.jar:.

步骤 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 - 源代码文件夹
- main
- test
- test-dummies
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 及其依赖项添加到我们的项目中。为此，右键单击您的项目名称concordion，然后按照上下文菜单中提供的选项：构建路径→配置构建路径以显示 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的包。为此，右键单击包资源管理器部分中的spec，然后按照选项：新建→包。

接下来，我们将在 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 测试 fixture。

@RunWith(ConcordionRunner.class)
public class SystemFixture {

SystemFixture 具有一个 getGreeting 方法，该方法返回对用户的问候。

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

步骤 5 - 运行程序

右键单击 SystemFixture 的内容区域，然后选择以...方式运行 > JUnit 测试用例。您将看到以下输出，并且 junit 成功。

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

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

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

Concordion - set 命令

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 应用程序 -

步骤	描述
1	创建一个名为 concordion 的项目，并在创建的项目中 src 文件夹下创建一个名为 com.tutorialspoint 的包。
2	使用添加外部 JAR 选项添加所需的 Concordion 库，如Concordion - 第一个应用程序章节中所述。
3	在 com.tutorialspoint 包下创建 Java 类 System。
4	在 specs.tutorialspoint 包下创建 Fixture 类 SystemFixture。
5	在 specs.tutorialspoint 包下创建规范 html System.html。
6	最后一步是创建所有 Java 文件和规范文件的内容，并按照以下说明运行应用程序。

以下是 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 应用程序 -

步骤	描述
1	创建一个名为 concordion 的项目，并在创建的项目中 src 文件夹下创建一个名为 com.tutorialspoint 的包。
2	使用添加外部 JAR 选项添加所需的 Concordion 库，如Concordion - 第一个应用程序章节中所述。
3	在 com.tutorialspoint 包下创建 Java 类 System。
4	在 specs.tutorialspoint 包下创建 Fixture 类 SystemFixture。
5	在 specs.tutorialspoint 包下创建规范 html System.html。
6	最后一步是创建所有 Java 文件和规范文件的内容，并按照以下说明运行应用程序。

以下是 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 命令

当 fixture 需要知道预期结果才能执行测试时，使用 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”。然后，它将检查 userName 是否以在下一个命令中设置的 #letter 变量指定的字母开头。

示例

让我们准备好一个正在运行的 Eclipse IDE，并按照以下步骤创建 Concordion 应用程序 -

步骤	描述
1	创建一个名为 concordion 的项目，并在创建的项目中 src 文件夹下创建一个名为 com.tutorialspoint 的包。
2	使用添加外部 JAR 选项添加所需的 Concordion 库，如Concordion - 第一个应用程序章节中所述。
3	在 com.tutorialspoint 包下创建 Java 类 System。
4	在 specs.tutorialspoint 包下创建 Fixture 类 SystemFixture。
5	在 specs.tutorialspoint 包下创建规范 html System.html。
6	最后一步是创建所有 Java 文件和规范文件的内容，并按照以下说明运行应用程序。

以下是 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 命令

当 fixture 需要知道预期结果才能执行测试时，使用 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>

示例

让我们准备好一个正在运行的 Eclipse IDE，并按照以下步骤创建 Concordion 应用程序 -

步骤	描述
1	创建一个名为 concordion 的项目，并在创建的项目中 src 文件夹下创建一个名为 com.tutorialspoint 的包。
2	使用添加外部 JAR 选项添加所需的 Concordion 库，如Concordion - 第一个应用程序章节中所述。
3	在 com.tutorialspoint 包下创建 Java 类 System。
4	在 specs.tutorialspoint 包下创建 Fixture 类 SystemFixture。
5	在 specs.tutorialspoint 包下创建规范 html System.html。
6	最后一步是创建所有 Java 文件和规范文件的内容，并按照以下说明运行应用程序。

以下是 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
Successes: 1, Failures: 0

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

Concordion - execute 命令

Concordion execute 命令用于运行 concordion fixture 的操作。考虑以下需求 -

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”，然后使用 #firstNumber 和 #secondNumber 作为参数执行 sum() 方法，使用 execute 命令并将结果设置到 #result 变量中，并检查 #result 变量是否等于“5”。

示例

让我们准备好一个正在运行的 Eclipse IDE，并按照以下步骤创建 Concordion 应用程序 -

步骤	描述
1	创建一个名为 concordion 的项目，并在创建的项目中 src 文件夹下创建一个名为 com.tutorialspoint 的包。
2	使用添加外部 JAR 选项添加所需的 Concordion 库，如Concordion - 第一个应用程序章节中所述。
3	在 com.tutorialspoint 包下创建 Java 类 System。
4	在 specs.tutorialspoint 包下创建 Fixture 类 SystemFixture。
5	在 specs.tutorialspoint 包下创建规范 html System.html。
6	最后一步是创建所有 Java 文件和规范文件的内容，并按照以下说明运行应用程序。

以下是 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 execute 命令可用于以对象的形式获取行为的结果，我们可以使用该对象获取行为的多个输出。例如，考虑以下需求 -

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

这里我们需要有一个 split 函数，它接受一个用户名并返回一个结果对象，该对象具有 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 函数。然后，它将使用 #TEXT 作为参数执行 split() 方法，使用 execute 命令并将结果设置到 #result 变量中，并使用结果对象，打印 firstName 和 lastName 属性作为输出。

示例

让我们准备好一个正在运行的 Eclipse IDE，并按照以下步骤创建 Concordion 应用程序 -

步骤	描述
1	创建一个名为 concordion 的项目，并在创建的项目中 src 文件夹下创建一个名为 com.tutorialspoint 的包。
2	使用添加外部 JAR 选项添加所需的 Concordion 库，如Concordion - 第一个应用程序章节中所述。
3	在 com.tutorialspoint 包下创建 Java 类 System、Result。
4	在 specs.tutorialspoint 包下创建 Fixture 类 SystemFixture。
5	在 specs.tutorialspoint 包下创建规范 html System.html。
6	最后一步是创建所有 Java 文件和规范文件的内容，并按照以下说明运行应用程序。

以下是 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

Concordion execute 命令可用于以 Map 的形式获取行为的结果，我们可以使用该 Map 获取行为的多个输出。例如，考虑以下需求 -

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

这里我们需要有一个 spilt 函数，它接受一个用户名并返回一个 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 函数。然后，它将使用 #TEXT 作为参数执行 split() 方法，使用 execute 命令并将结果设置到 #result 变量中，并使用结果 Map，打印 firstName 和 lastName 值作为输出。

示例

让我们准备好一个正在运行的 Eclipse IDE，并按照以下步骤创建 Concordion 应用程序 -

步骤	描述
1	创建一个名为 concordion 的项目，并在创建的项目中 src 文件夹下创建一个名为 com.tutorialspoint 的包。
2	使用添加外部 JAR 选项添加所需的 Concordion 库，如Concordion - 第一个应用程序章节中所述。
3	在 com.tutorialspoint 包下创建 Java 类 System。
4	在 specs.tutorialspoint 包下创建 Fixture 类 SystemFixture。
5	在 specs.tutorialspoint 包下创建规范 html System.html。
6	最后一步是创建所有 Java 文件和规范文件的内容，并按照以下说明运行应用程序。

以下是 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 execute 命令可用于以 Map 的形式获取行为的结果，我们可以使用该 Map 获取行为的多个输出。例如，考虑以下需求 -

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>

示例

让我们准备好一个正在运行的 Eclipse IDE，并按照以下步骤创建 Concordion 应用程序 -

步骤	描述
1	创建一个名为 concordion 的项目，并在创建的项目中 src 文件夹下创建一个名为 com.tutorialspoint 的包。
2	使用添加外部 JAR 选项添加所需的 Concordion 库，如Concordion - 第一个应用程序章节中所述。
3	在 com.tutorialspoint 包下创建 Java 类 System。
4	在 specs.tutorialspoint 包下创建 Fixture 类 SystemFixture。
5	在 specs.tutorialspoint 包下创建规范 html System.html。
6	最后一步是创建所有 Java 文件和规范文件的内容，并按照以下说明运行应用程序。

以下是 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 execute 命令可用于以重复的方式运行 concordion fixture 的操作。例如，如果我们想以表格的形式用多个示例来说明一个需求，它将非常有用。

考虑以下需求 -

<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”。然后，它将使用 #firstNumber 和 #secondNumber 作为参数执行 sum() 方法，使用 execute 命令并将结果设置到 #result 变量中，并检查 #result 变量是否等于“5”。此过程对每个表格行元素重复。

示例

让我们准备好一个正在运行的 Eclipse IDE，并按照以下步骤创建 Concordion 应用程序 -

步骤	描述
1	创建一个名为 concordion 的项目，并在创建的项目中 src 文件夹下创建一个名为 com.tutorialspoint 的包。
2	使用添加外部 JAR 选项添加所需的 Concordion 库，如Concordion - 第一个应用程序章节中所述。
3	在 com.tutorialspoint 包下创建 Java 类 System。
4	在 specs.tutorialspoint 包下创建 Fixture 类 SystemFixture。
5	在 specs.tutorialspoint 包下创建规范 html System.html。
6	最后一步是创建所有 Java 文件和规范文件的内容，并按照以下说明运行应用程序。

以下是 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 execute 命令可用于以重复的方式运行 concordion fixture 的操作。例如，如果我们想以列表的形式用多个示例来说明一个需求，它将非常有用。

考虑以下需求 -

<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 的值为当前元素的值“Robert De”，并将其传递给 split 函数。然后，它将使用 #TEXT 作为参数执行 split() 方法，使用 execute 命令并将结果设置到 #result 变量中，并使用结果，打印 firstName 和 lastName 值作为输出。

示例

让我们准备好一个正在运行的 Eclipse IDE，并按照以下步骤创建 Concordion 应用程序 -

步骤	描述
1	创建一个名为 concordion 的项目，并在创建的项目中 src 文件夹下创建一个名为 com.tutorialspoint 的包。
2	使用添加外部 JAR 选项添加所需的 Concordion 库，如Concordion - 第一个应用程序章节中所述。
3	在 com.tutorialspoint 包下创建 Java 类 System。
4	在 specs.tutorialspoint 包下创建 Fixture 类 SystemFixture。
5	在 specs.tutorialspoint 包下创建规范 html System.html。
6	最后一步是创建所有 Java 文件和规范文件的内容，并按照以下说明运行应用程序。

以下是 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>
         <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>
      </div>
   </body>

</html>

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

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

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

Concordion - verifyRows 命令

Concordion verifyRows 命令可用于检查系统返回的结果集合的内容。例如，如果我们在系统中设置了一组用户并在其上进行部分搜索，则系统应返回匹配的元素，否则我们的验收测试将失败。

考虑以下需求 -

<table>
   <tr><th>Users</th></tr>
   <tr><td>Robert De</td></tr>
   <tr><td>John Diere</td></tr>
   <tr><td>Julie Re</td></tr>
</table>

<p>Search for J should return:</p>

<table>
   <tr><th>Matching Users</th></tr>
   <tr><td>John Diere</td></tr>
   <tr><td>Julie Re</td></tr>
</table>

如果我们想要为这样一个搜索功能编写规范，该功能将搜索并返回一个集合，那么规范将如下所示：

<table concordion:execute = "addUser(#username)">
   <tr><th concordion:set = "#username">Username</th></tr>
   <tr><td>Robert De</td></tr>
   <tr><td>John Diere</td></tr>
   <tr><td>Julie Re</td></tr>
</table>

<p>Search for "<b concordion:set = "#searchString">J</b>" should return:</p>

<table concordion:verifyRows = "#username : search(#searchString)">
   <tr><th concordion:assertEquals = "#username">Matching Usernames</th></tr>
   <tr><td>John Diere</td></tr>
   <tr><td>Julie Re</td></tr>
</table>

当 Concordion 解析文档时，它将在第一个表的每一行上执行 addUser()，然后将 searchString 设置为 J。接下来，Concordion 将执行搜索功能，该功能应返回一个具有可预测迭代顺序的 Iterable 对象（例如 List、LinkedHashSet 或 TreeSet），verifyRows 为集合中的每个项目运行并运行 assertEquals 命令。

示例

让我们准备好一个正在运行的 Eclipse IDE，并按照以下步骤创建 Concordion 应用程序 -

步骤	描述
1	创建一个名为 concordion 的项目，并在创建的项目中 src 文件夹下创建一个名为 com.tutorialspoint 的包。
2	使用添加外部 JAR 选项添加所需的 Concordion 库，如Concordion - 第一个应用程序章节中所述。
3	在 com.tutorialspoint 包下创建 Java 类 System。
4	在 specs.tutorialspoint 包下创建 Fixture 类 SystemFixture。
5	在 specs.tutorialspoint 包下创建规范 html System.html。
6	最后一步是创建所有 Java 文件和规范文件的内容，并按照以下说明运行应用程序。

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

package com.tutorialspoint;

import java.util.HashSet;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;

public class System { 
   private Set<String> users = new HashSet<String>();
	
   public void addUser(String username) {
      users.add(username);
   }
	
   public Iterable<String> search(String searchString) {
      SortedSet<String> matches = new TreeSet<String>();
		
      for (String username : users) {
         if (username.contains(searchString)) {
            matches.add(username);
         }
      }
		
      return matches;
   }
}

以下是 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 void addUser(String username) {
      system.addUser(username);
   }
	
   public Iterable<String> search(String searchString) {
      return system.search(searchString);
   }
}

以下是 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 add a partial search capability on user names:</p>
		
      <div class = "example">      
         <h3>Example</h3>
			
         <table concordion:execute = "addUser(#username)">
            <tr><th concordion:set = "#username">Username</th></tr>
            <tr><td>Robert De</td></tr>
            <tr><td>John Diere</td></tr>
            <tr><td>Julie Re</td></tr>
         </table>
			
         <p>Search for "<b concordion:set = "#searchString">J</b>" should return:</p>
			
         <table concordion:verifyRows = "#username : search(#searchString)">
            <tr><th concordion:assertEquals = "#username">Matching Usernames</th></tr>
            <tr><td>John Diere</td></tr>
            <tr><td>Julie Re</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 - 在列表上执行和Concordion - 在表格上执行章节中创建的规范作为系统规范和计算器规范。

示例

让我们准备好一个正在运行的 Eclipse IDE，并按照以下步骤创建 Concordion 应用程序 -

步骤	描述
1	创建一个名为 concordion 的项目，并在创建的项目中 src 文件夹下创建一个名为 com.tutorialspoint 的包。
2	使用添加外部 JAR 选项添加所需的 Concordion 库，如Concordion - 第一个应用程序章节中所述。
3	在 com.tutorialspoint 包下创建 Java 类 System。
4	在 specs.tutorialspoint 包下创建 Fixture 类 SystemFixture、CalculatorFixture。
5	在 specs.tutorialspoint 包下创建规范 html 文件 System.html、Calculator.html。
6	最后一步是创建所有 Java 文件和规范文件的内容，并按照以下说明运行应用程序。

以下是 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;
   }
	
   public int sum(int firstNumber, int secondNumber) {
      return firstNumber + secondNumber;
   }
}

以下是 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);
   }  
}

以下是 CalculatorFixture.java 文件的内容：

package specs.tutorialspoint;

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

@RunWith(ConcordionRunner.class)

public class CalculatorFixture {
   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>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>
			
         <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>
      </div>
   
      <a concordion:run = "concordion" href = "Calculator.html">
         Calculator Service Specifications</a>
   </body>

</html>

以下是 Calculator.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
C:\DOCUME~1\ADMINI~1\LOCALS~1\Temp\concordion\specs\tutorialspoint\System.html
Successes: 6, Failures: 0

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

点击链接“计算器服务规范”。您将看到以下输出：

打印页面

Concordion - 快速指南

Concordion - 概述

什么是 Concordion？

主动软件规范

Cncordion 的输出

主要特征

Concordion - 环境设置

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

步骤 2 - 设置 Eclipse IDE

步骤 3：下载 Junit 档案

步骤 4：设置 JUnit 环境

步骤 5：设置 CLASSPATH 变量

步骤 6 - 设置 Concordion 库

Concordion - 第一个应用程序

步骤 1 - 创建 Java 项目

步骤 2 - 添加所需的库

步骤 3 - 创建源文件

步骤 4 - 创建规范文件

步骤 5 - 运行程序

Concordion - set 命令

示例

Concordion - assertEquals 命令

示例

Concordion - assertTrue 命令

示例

Concordion - assertFalse 命令

示例

Concordion - execute 命令

示例

Concordion - 返回对象

示例

Concordion - 返回 Map

示例

Concordion - 返回 MultiValueResult

示例

Concordion - 在表格上执行

示例

Concordion - 在列表上执行

示例

Concordion - verifyRows 命令

示例

Concordion - 运行命令

示例