FitNess使用

破壳成龙

参考文献：fixturegallery-20080708.pdf

Basic
FIT fixtures（基本FIT夹具）
1）、ColumnFixture：ColumnFixture将表的列的字段与fixture类的属性、方法映射起来。ColumnFixture对同一测试的一系列的不同输入值反复验证时非常有效。

Table Format 表格格式：表的第一行是测试类的类名。第二行是列名，指定与列相关的方法或字段。输出值必须以问号或小括号结尾。第三行及以后的行是一系列的输入值和预期输出值。

!|info.fitnesse.fixturegallery.ColumnFixtureTest|
|first
part|second part|together?|total length?|
|Hello|World|Hello,World|10|
|Houston|We
Have a Problem|Houston,We Have a Problem|24|

Fixture Class 夹具类： 类继承fit.ColumnFixture并声明公有(必须是public，否则会报错)属性和方法来匹配表的第二行。（采用驼峰命名规则命名）
// Java
Source Code
package
info.fitnesse.fixturegallery;
import
fit.ColumnFixture;
public
class ColumnFixtureTest extends ColumnFixture {
    public String firstPart; //对应列名|first part|
    public String secondPart; //对应列名|second part|
    private int length;
    public String together(){//对应列名|together?|
       length=firstPart.length()+secondPart.length();
       return firstPart+ ",
"+secondPart;
    }
    public int totalLength(){//对应列名|total length?|
       return length;
    }
}

Notes 注意：类的属性只能用作输入，类方法只能用作输出。无参函数也能用作输出。用Java实现大小写是敏感的。不直接支持JavaBeans。从上到下执行表的行，从左到右执行单元格。因而，类的方法的持续性对同一行的单元格及下一行的单元格会有影响。为使用它们相互独立互不影响，可重写reset()方法。
将一个输出单元格设置为空，则测试时只在该单元格中显示实际值（fixture 类的方法的返回值）而不做任何测试。

Usage 用法：ColumnFixture能很好的描述基于计算的业务规则和状态机。验证同类计算的一系列的输入值，并预先知道它们所有的不同组合时，有ColumnFixture很有效。
如果测试不重复（只有一步），可以考虑用DoFixture，而不用ColumnFixture。
在flow mode(流模式)中用DoFixture。
如果你想测试动态的对象列表，可以考虑用ArrayFixture或RowFixture，因为它们也能校验列表中的内容。
人们经常误用ColumnFixture来设置其它测试，尤其是误用ColumnFixture来创建domain object(领域对象)或往数据库中插入记录。典型的错误用法是在表的尾列添加一个返回形如“OK”这样的状态码的Create方法。只有当你想为创建（和待返回的错误码）检查业务规则时才有意义。
如果你想为其它测试作准备，可以考虑用SetUpFixture，这使得测试页可读性更好，并且只须为夹具类写更少的代码。

2）、ActionFixture：ActionFixture最初用于非重复的workflow-style tests(工作流样式的测试)，它用UI metaphor（UI隐喻）来自动操作其它fixtures(夹具)。
Table Format表格格式：ActionFixture 表的第一行总是初使化fixture class(夹具类)，它是ActionFixture自身而非自定义的子类。从第二行开始，所有的行都以command
cell(指令单元)开始，后面剩余的单元是指令参数。第二行用“start”命令启动测试。它所须的参数是用于自动化测试的夹具类名。接下来用“check”、“ press”和“ enter”指令来描述测试。
1、check—executes a
method and verifies its value.
执行一个方法并验证它的值。
2、press—executes a void
method without testing anything.
执行一个void方法。
3、enter—executes a
method and passes an argument to it.
执行一个方法并给它传一个参数。

!|ActionFixture|
|start|ActionFixtureTest|
|enter|first
part|Hello|
|enter|secondPart|World|
|press|join|
|check|together|Hello,World|

Fixture class 夹具类：ActionFixture和所有其它的夹具的重要区别是你自定义的夹具类不能继承ActionFixture类，而是直接继承fit.Fixture类，然后用“start”命令来执行它。
// Java
Source Code
package
info.fitnesse.fixturegallery;
public
class ActionFixtureTest extends fit.Fixture{
    private String first, second, both;
    public void firstPart(String s){  //对应于|first part|单元
       first=s;
    }
    public void
secondPart(String s){  //对应于|secondPart|单元
       second=s;
    }
    public void join(){  //对应|join|单元

       both=first+ ", "+second;
    }
    public String together(){ //对应|together|单元
       return both;
    }
}

Notes 注意：In the java version, ActionFixture only works on methods. 在Java版中，ActionFixture只能影响方法，而不能获得或设置字段值。

Usage 用法：你可以用ActionFixture描述UI-style verifications（UI样式验证）。一般地，ActionFixture已经被DoFixture取代了并且现在也没什么理由再用ActionFixture了。在fixture和FitNesse表中，你用DoFixture，只需写少量的代码，便能更简单的写出workflow-style
tests（工作流样式测试）。它也支持直接domain object wrapping(领域对象包装)。

3）、RowFixture：RowFixture测试动态对象列表。它将比较预期的列表（FitNesse表）和实际结果（来自夹具代码）并报告任何附加的或丢失的项。
Table Format 表格格式：表的第一行是夹具类的类名。第二行描述列表的对象结构（待验证的属性或方法）。第二行以下的所有行描述列表的预期对象。

!include-seamless
SetUpFixture
!|RowFixtureTest|
|name|post
code|
|John
Smith|SW4 66Z|
|Michael
Jordan|NE1 8AT|

Fixture class 夹具类：夹具类继承fit.RowFixture并且重写下列两个方法：
1、getTargetClass—returns
the Type or Class object representing the type of objects contained in the
array.
getTargetClass——返回象征着包含在数组中的对象类型的类对象。
2、query—returns the
actual array of objects to be verified.
query——返回待校验的实际的对象数组。

// Java Source Code
package
info.fitnesse.fixturegallery;
import
info.fitnesse.fixturegallery.domain.Player;
import
fit.RowFixture;
public
class RowFixtureTest extends RowFixture{
    public Class getTargetClass() {
       return Player.class;
    }
    public Object[] query() throws Exception {
           return
Player.players.toArray();
    }
}

Notes 注意：如果对象的属性可以被作为标识的一部分（例如，主键），将它写在表的左边，即辅助属性之前。这使得错误报告更容易阅读。
query方法不允许传递任何附加的参数。
The
order of elements in the list is irrelevant,RowFixture will ignore it.
列表中的元素的顺序是不相关的，RowFixture将忽略它。

Usage 用法：用RowFixture测试及校验对象列表，或执行列表中每个对象中的方法。当元素顺序很重要时不能用RowFixture，而用ArrayFixture。


4）、TableFixture：TableFixture是FitNesse包中的附加类（它不是FIT夹具集的核心，而是随着FitNesse作为某个类库的一部分发布的）。它被用于执行free-form（自由形态)的无重复结构的表。

Table Format 表格格式：通过TableFixture，你可以决定表格格式及哪个单元实际上被用作测试的一部分了。TableFixture表的唯一限制是，它的第一行必需指明你自定义的夹具类名。

!|TableFixtureTest|
|Item|Product
code|Price|
|Pragmatic
Programmer|B978-0201616224|34.03|
|Sony
RDR-GX330|ERDR-GX330|94.80|
|Test
Driven Development By Example|B978-0321146533|32.39|
|Net
Total|  |161.22|
|Tax(10%on
applicable items)|  |9.48|
|Total|  |170.70|

Fixture class 夹具类：夹具类继承fitnesse.fixtures.TableFixture，并且重写doStaticTable（int rows）方法。doStaticTable方法通过getText(row,column)方法检索相关单元的内容来处理表。你可以通过right(row,column)
方法或wrong(row,column,actualValue)方法来标记测试单元是否正确.

// Java
Source Code
package
info.fitnesse.fixturegallery;
import
info.fitnesse.fixturegallery.domain.TaxCalculator;
import
fitnesse.fixtures.TableFixture;
public
class TableFixtureTest extends TableFixture{
    protected void doStaticTable(int rows) {
          TaxCalculator tc=new TaxCalculator();
         
double totaltax = 0;
         
for (int row = 1; row    {
           
  totaltax +=
tc.GetTax(getText(row, 1),
            
Double.parseDouble(getText(row, 2)));
         
}
         
double taxintable = Double.parseDouble(getText(rows - 2, 2));
          if (taxintable == totaltax)  
        
right(rows - 2, 2); //标记倒数第二行和第三个单元正确
         
else  //标记倒数第二行和第三个单元有误
wrong(rows - 2,
2,String.valueOf(totaltax));
}
}

Notes 注意：你可以用getInt方法来检索单元值并将其转换为整数。

Usage 用法：当你想在business-specific table format（专用业务表格格式）中描述你的测试，而用其它类型的夹具不容易描述该测试时，用TableFixture。如果你已经有可以导入到HTML表格的文档时用TableFixture尤其有效，因为你可以直接将HTML粘贴到FitNesse中。


5）、Import 引入：引入夹具告诉FitNesse从哪里查找夹具类。引入名字空间或包后，你不需要再写类的完整名字（包名.类名），这使得表的可读性更好。
Table Format 表格格式：表的第一行只有“Import”。其它的行列出要引入的名字空间或包名。每行中有一个单元。

|Import|
|info.fitnesse.fixturegallery|     

Notes 注意：在Java版中，大小写是敏感的，如果第一行的“Import”首字母不是大写的，则报错。记住，在flow mode(流模式)中，Import
表必须在最初的flow class name(流程类名)后面出现，否则flow mode(流模式)不起作用。
Usage 用法：用Import表使得测试页可读性更好。具有代表性的用法是，为测试套具，将Import表写在SetUp页中。


6）、SummaryFixture： 在测试页面底部添加一个fit.SummaryFixture 表，系统将为测试结果显示一个三行的表格，为该页的测试给出标准的统计（正确数，错误数，忽略数和异常个数）及夹具的测试启动时间和运行时间。查看这个报表，容易度量每个独立页的测试效率及运行时间。
Table Format 表格格式：   ！|fit.SummaryFixture|


FitLibrary Fixtures （FitLibrary 夹具）
FitLibrary是第三方的夹具集，但它非常有效而被当作标准测试类型。在Java版中，它仍然作为单独的包维护，但它被打包与FitNesse绑定在一起。

1）、SetUpFixture：如果你不想测试任何东西，只是为其它夹具做准备，则SetUpFixture是ColumnFixture的优秀的替代品。例如，你可以用SetUpFixture往数据库表中插入行或为随后的测试创建domain objects（领域对象）。  

Table Format 表格格式：SetUpFixture表的第一行是夹具类名。第二行列出了对象的属性名。从第三开始的所有行包含属性值。在SetUpFixture表中没有输出单元，所有的单元都用于输入。

!|SetUpFixtureTest|
|player|post
code|balance|
|John
Smith|SW4 66Z|10.00|
|Michael
Jordan|NE1 8AT|12.00|

Fixture class 夹具类：夹具类继承fitlibrary.SetUpFixture并声明一个方法。该方法的名字必须与表中所有属性名的结合体相匹配（即：playerPostCodeBalance）（用驼峰规则命名）。该方法必须有参数（对应于表中的列，有几列就有几个参数）。
// Java
Source Code
package info.fitnesse.fixturegallery;
import info.fitnesse.fixturegallery.domain.Player;
import java.util.ArrayList;
import
java.util.List;
import
fitlibrary.SetUpFixture;
public
class SetUpFixtureTest extends SetUpFixture {
    public SetUpFixtureTest() {
       Player.players.clear();
    }
    public void playerPostCodeBalance(String
name, String postCode,
           double balance) {
       Player.addPlayer(name,
postCode, balance);
    }
}

Notes 注意：这个方法名可能会很长，手动键入它易出错。取而代之的是，写好测试表并启动测试，FitNesse将会报错，FitNesse 将显示它要寻找的方法名，然后你复制并粘贴这个方法名到你的源代码中。

Usage 用法：用SetUpFixture来快速初始化一列 domain objects（领域对象），准备数据库表，或用不同的参数多次执行同一方法。
如果运算结果或错误验证很重要，则不能用SetUpFixture，而用ColumnFixture或 CalculateFixture。


2）、CalculateFixture CalculateFixture为不同组合的输入参数校验一个或多个计算结果。CalculateFixture与ColumnFixture的与功能一致，但表格格式不同并且夹具类所需的代码量更少。

Table Format 表格格式：CalculateFixture表的第一行是夹具类名，第二行包含输入参数名的单元，接着是一个空单元，然后是用于计算的方法（输出值）名的单元。从第三行起的所有行指定输入参数值和预期计算结果，并用空单元分隔输入值和预期计算结果。

!|CalculateFixtureTest|
|firstPart|secondPart|
|together|
|Hello|World|
|Hello,World|
|Houston|We
Have a Problem|  |Houston,We Have a
Problem|

Fixture class 夹具类：夹具类继承fitlibrary.CalculateFixture，它为每个计算列声明一个方法。方法名必需是输出参数名连接所有输入参数名的组合体（即：togetherFirstPartSecondPart）。（用驼峰标识命名）

// Java
Source Code
package
info.fitnesse.fixturegallery;
import
fitlibrary.CalculateFixture;
public class CalculateFixtureTest extends CalculateFixture {
public String
togetherFirstPartSecondPart(String firstPart, String secondPart) {
       return
firstPart + ", " + secondPart;
    }
}

Notes 注意：这个方法名可能会很长，手动键入它易出错。取而代之的是，写好测试表并启动测试，FitNesse将会报错，FitNesse 将打印它要寻找的方法名，然后你复制并粘贴这个方法名到你的源代码中。

Usage用法：用CalculateFixture为不同组合的输入参数执行同一方法或一组方法并校验结果。
如果你只是想执行一个方法并且输出结果不重要（或这个方法是void方法），则用SetUpFixture表而不用CalculateFixture。
如果你想在初始化属性后，执行领域对象内的方法
，建议用ColumnFixture。ColumnFixture 也允许你只显示计算结果，而不测试它。
CalculateFixture
把空单元作为空串处理，并且将它与计算结果作比较。因此，如果你让一个输出单元为空，该行将显示错误标记(红色)。


3）、DoFixture：DoFixture几乎能用日常英语来描述story-like tests（故事样测试）。用它代替ActionFixture效果非常明显。DoFixture且具有重要特征，如flow-mode coordination（流模式协调），wrapping domain objects(包装领域对象)。

Table Format 表格格式：DoFixture表的第一行是夹具类名。其后所有的行都被用于执行验证或通过执行夹具类的方法来履行动作。方法名由每行的奇数单元格的参数名连接而成，而参数值从每行的偶数单元格取得。如果方法返回一个布尔值，则这行被认为是测试，并且如果返回值为“FALSE”，则这个测试报错。如果这个方法是void或返回除布尔值外的其它值，除非抛出异常，否则对这个测试的输出值没有任何影响。

!|DoFixtureTest|
|fill|10|times
with|x|
|char
at|4|is|x|
|set
list|A,B,C,D|
|char
at|2|is|C|

Fixture class 夹具类：夹具类继承fitlibrary.DoFixture。为所有验证和动作声明公有方法。方法名由每列的奇数单元参数组合而成，方法的参数从该列的偶数单元中取得。先写测试表并启动测试，FitNesse将会报错，从测试报告中复制预期的方法名，粘贴到夹具源代码中。

// Java
Source Code
package
info.fitnesse.fixturegallery;
import
java.util.Arrays;
import
fitlibrary.DoFixture;
public
class DoFixtureTest extends DoFixture {
    public String letters;
    public void fillTimesWith(int count, char c)
{
       char[] arr = new char[count];
       Arrays.fill(arr, c);
       letters = new String(arr);
    }
    public boolean charAtIs(int position, char
c) {
       return letters.charAt(position) == c;
    }
    public void setList(char[] array) {
       letters = new String(array);
    }
    public char charAt(int position) {
       return letters.charAt(position);
    }
}

Notes 注意：DoFixture也支持许多用于方法名前辍的关键字。如果用了关键字，则奇数单元格用于构建方法名，偶数行（除了第一个）用作参数。下面是几个常用的关键字：
1、reject will invert the logic of a test,returning TRUE will make the
test fail if the row is prefixed with reject.
“reject”将使测试的逻辑颠倒。如果该行的前辍是“reject”，返回“TURE”将使测试标记为失败。
2、show will print out the value of a calculation in the test
results(similar to an empty cell in ColumnFixture).
“show”将在输出单元中打印输出值（类似于ColumnFixture中的空单元）。
3、check allows you to verify results of non-boolean calculations.Prefix
the row with check and put the expected value of the calculation on the end of
the row,in a new cell.
“check”允许校验非布尔值。 将“check” 作为该行的前辍，则在该行的最后，在一个新单格中输入预期值。

在Java版的FIT实现中，“check”和“show”直接映射JavaBean属性，因此，不需要写getters。然而，这些关键字不能用于公有字段。

!|DoFixtureTest|
|fill|10|times
with|x|
|check|char
at|4|x|
|set
list|A,B,C,D|
|show|char
at|2|

Usage 用法：Use DoFixture to describe workflow tests or tests that do not follow any particular
repetitive structure.用DoFixture描述工作流测试或不跟随任何精确的重复结构的测试。DoFixture很好的协调其它夹具。


4）、SequenceFixture：SequenceFixture 与DoFixture非常相似，它们几乎有相同的特征，事实上，唯一的区别是方法的命名约定。SequenceFixture将每行的第一个单元作为方法名，其它单元作为参数（如果没有关键字改变行功能）。DoFixture的所有关键字、flow mode（流模式）和domain object wrapping（领域对象包装）都支持SequenceFixture。

Table Format 表格式：除了方法命名约束不同外，SequenceFixture 表格式与DoFixture表格式完全一致。

!|SequenceFixtureTest|
|fill|10|x|
|check|char
at|4|x|
|set
list|A,B,C,D|
|check|char
at|2|C|

Fixture class 夹具类：夹具类继承fitlibrary.SequenceFixture。为所有的验证和动作声明公有方法。方法名从表每行的第一个单元取得，参数由表每行的所有的其它的单元取得。

// Java
Source Code
package
info.fitnesse.fixturegallery;
import
java.util.Arrays;
import
fitlibrary.SequenceFixture;
public
class SequenceFixtureTest extends SequenceFixture {
    public String letters;
    public void fill(int count, char c) {
       char[] arr = new char[count];
       Arrays.fill(arr, c);
       letters = new String(arr);
    }
    public void setList(char[] array) {
       letters = new String(array);
    }
    public char charAt(int position) {
       return letters.charAt(position);
    }
}

Usage 用法：SequenceFixture具有DoFixture所有的灵活性及功能，但没有DoFixture愚蠢的命名方式。它对更高技术要求的workflow tests（工作流测试），尤其是将FitNesse表直接映射到existing business domain services（现有的业务领域服务）非常有效。



5）、ArrayFixture：ArrayFixture作为RowFixture的替代品，它与其它夹具很类似，但有两个主要的区别：
1、Element order is
important for ArrayFixture.
ArrayFixture表的元素顺序很重要。
2、ArrayFixture can work
with generic collections as well as with arrays.
ArrayFixture能与普通collections（容器）、arrays（数组）一起使用。

Table Format 表格式：ArrayFixture表的第一行是夹具类名。第二行列出字段、属性、方法名。

!include
-seamless SetUpFixture
!|ArrayFixtureTest|
|name|post
code|credit limit|
|John
Smith|SW4 66Z|10|
|Michael
Jordan|NE1 8AT|12|

Fixture class夹具类：夹具类继承fitlibrary.ArrayFixture。ArrayFixture作用于被称作actualCollection的内部属性，而不是重写query方法。在夹具类的构造函数中初始化那个collection。

//Java
Source Code
package
info.fitnesse.fixturegallery;
import
info.fitnesse.fixturegallery.domain.Player;
import
fitlibrary.ArrayFixture;
public class ArrayFixtureTest extends ArrayFixture {
    public
ArrayFixtureTest() {
       setActualCollection(Player.players);
    }
}

Notes注意：在Java版中，ArrayFixture也能正确处理JavaBeans属性。因此，如果你有getters，例如：getCreditLimit，那么你可以将该列命名为“credit limit”。
FitLibrary有一个忽略元素顺序的SetFixture和一个忽略实际结果中的附加元素的SubSetFixture。这两个夹具的表格格式及夹具类结构与ArrayFixture十分相似。

Usage 用法：当元素顺序非常重要或避免对象列表转换到数组中时用ArrayFixture 代替RowFixture。
DoFixture将自动地将返回列表或数组的方法包装到ArrayFixture中，因此，你可以用DoFixture来测试对象列表，而不需要写一个附加的RowFixture类。类似的，返回对象集合的方法会自动地包装到SetFixture类中。
在Java中，为lists of business domain objects(业务领域对象列表)用ArrayFixture非常有意义，因为这个夹具用JavaBeans的getters能正确地运转。


6）、CombinationFixture：CombinationFixture用于执行成双成对的值。这些值在行和列中指定，并且对所有的组合值进行运算。

Table Format 表格格式：表的第一行是夹具类名。第二行的第一个单元是空单元，紧接着的是含有用作运算的第二个参数的单元。接下来的所有行的第一个单元含有用作运算的第一个参数的值，紧接着的是含有运算预期值的单元。

!|CombinationFixtureTest|
| |1|2|3|
|6|6|3|2|
|12|12|6|4|

Fixture class 夹具类：夹具类继承fitlibrary.CombinationFixture。它声明combine方法，这个方法有两个参数（row 和 column），并返回一个值。
// Java
Source Code
package
info.fitnesse.fixturegallery;
import
fitlibrary.CombinationFixture;
public class CombinationFixtureTest extends CombinationFixture {
    public
int combine(int theFirst, int theSecond) {
       return
theFirst / theSecond;
    }
}

Usage用法：CombinationFixture用于描述严密地依赖于两个参数的计算规则。


7）、ConstraintFixture：ConstraintFixture是CalculateFixture的变种，对于每个计算，它都有一个值为“ture”的预期值。

Table Format表格格式：表的第一行是夹具名。第二行含有输入参数名。其它的所有行指定输入参数值。

!|ConstraintFixtureTest|
|firstPart|secondPart|
|1|2|
|2|3|

Fixture
class夹具类：夹具类继承fitlibrary.ConstraintFixture。它声明一个返回值为布尔值的方法，方法名由所有参数名连接而成（如：firstPartSecondPart）。
// Java
Source Code
package
info.fitnesse.fixturegallery;
import
fitlibrary.ConstraintFixture;
public class ConstraintFixtureTest extends ConstraintFixture {
public boolean
firstPartSecondPart(int
firstPart, int secondPart) {
       return
firstPart
    }
}

8）、SetFixture：SetFixture与ArrayFixture相同，但有一点不同：它不检查行序。
Notes注意：在Java flow mode（流模式）中，从flow fixture（流程夹具）方法返回的集合自动地映射到SetFixture。
Usage用法：在Java中，当处理JavaBeans对象时，用SetFixture代替RowFixture，因为它用JavaBeans 的getters能正确的运转。当元素的顺序不重要时，用SetFixture代替ArrayFixture。

9）、SubsetFixture：SubsetFixture是 SetFixture的变种，但有一点差异：夹具表中的行可以是实际行的一个子集。

Usage 用法：当你想忽略剩余的元素（例如，检查某些行是否存在于数据库表中，而不管可能在同一个数据库表中其它的行）时，用SubsetFixture代替RowFixture和 SetFixture。



第五章 重要概念
1）、Fixture Arguments夹具参数：FIT表的第一行通常用于初始化夹具类。除此之个，你可以通过在该行的夹具类名后追加单元格来给夹具传递参数。夹具参数的运作与main方法的命令行参数相似，并且在夹具中它能用的args数组来存取数据。你可以利用这个特征来参数化你的夹具，使得它们可复用性更强。例如，它允许你传递参数到RowFixture中。
!|ArgumentsTest|Hello
World|Houston We Have a Problem|
|word|
|Hello|
|World|
|Houston|
|We|
|Have|
|a|
|Problem|
// Java Source Code
package info.fitnesse.fixturegallery;
import java.util.HashSet;
import java.util.Set;
import fit.Parse;
import fitlibrary.SetFixture;
import fitlibrary.parser.table.Table;
public class ArgumentsTest extends SetFixture {
    public class Word {
       public String word;
       public Word(String w) {
           this.word = w;
       }
    }
    public void
doTable(Parse arg0) {
       Set set = new
HashSet();
       for (String s : args) {     
           for (String word :
s.split(" "))   // 以空格拆分
              set.add(new
Word(word));
       }
       this.setActualCollection(set);
       super.doTable(arg0);
    }
}
注意：参数只是普通字符串，
A
very important thing to remember related to arguments is that they will not be
available in the fixture constructor,since they are initialised after the class
is loaded.They will be available to other methods,however.
argument（参数）在夹具类被加载之后初始化，因而在夹具类被加载之前，在夹具类的构造函数中argument（参数）不可用。然而在其它函数中是可用的。

2）、Flow Mode 流模式：如果DoFixture 或SequenceFixture被测试页的第一张表加载，它们将接管全部的测试页并执行测试。为了使这个测试更具可读性，你可以把这个测试表分割若干个测试表。
!|info.fitnesse.fixturegallery.DoFixtureTest|
|fill|10|times
with|x|
|check|char
at|4|x|
|set
list|A,B,C,D|
|show|char
at|2|

When
the table is split like this,then each sub-table is first matched to an enclosing
flow fixture method.If no such method exists,a fixture class is loaded as it
would normally be,without the flow mode.This allows you to write tests that use
DoFixture methods to implement story-like workflow,but still use the benefits
of a more structured approach when that makes sense.DoFixture even helps you
with that:if the flow mode method returns an instance of a fit.Fixture class or
one of its subclasses,the rest of the active table is processed as if it were
writen for that fixture.So you can use a DoFixture method to initialise other fixtures,prepare
the context or clean up.If the flow method returns an array or list of
objects,the table is analysed as if it was written for an ArrayFixture.Here is
an example that uses an embedded fixture and array conversion:
当表像这样被拆分，每个子表首先与一个装入的流程方法相匹配。如果这样的方法不存在，在无流程模式情况下，夹具类被正常加载。这允许你用DoFixture 方法写测试来实现story-like工作流。DoFixture 在这方面帮助你：如果流程模式方法返回一个fit.Fixture类实例或它的一个子类，则其余的活动表被处理，好像它是为夹具而写的。因此，可以用DoFixture方法初始化其它的夹具，准备或清理上下文。如果流程方法返回一个数组或对象列表，这个测试表将被分析，好像它是为ArrayFixture而写的。

!|info.fitnesse.fixturegallery.DoFixtureFlowTest|

!3
The following table is executed by an embedded!-SetUpFixture-!
|prepare
players|
|player|post
code|balance|
|John
Smith|SW4 66Z|10.00|
|Michael
Jordan|NE1 8AT|12.00|

!3
The following table is executed by an!-ArrayFixture-!
|list
players|
|name|post
code|balance|
|John
Smith|SW4 66Z|10.00|
|Michael
Jordan|NE1 8AT|12.00|

// Java
Source Code
package
info.fitnesse.fixturegallery;
import
info.fitnesse.fixturegallery.domain.Player;
import java.util.List;
import fit.Fixture;
import
fitlibrary.DoFixture;
public
class DoFixtureFlowTest extends DoFixture {
    public Fixture preparePlayers() {
       return new SetUpFixtureTest();
    }
    public List listPlayers() {
       return Player.players;
    }
}

3）、Target objects 目标对象: 是DotNet专业用的概念，不支持Java。


4）、System under test（SUT）被测系统：  
DoFixture
和SequenceFixture可用于直接自动地测试你的（business domain classes）业务领域类，而不需要重新声明或包装夹具中业务类方法。这个特征被称作“System under test”。在Java中， 调用setSystemUnderTest方法并传递你的业务领域对象。
注意：在Java中，普通（临时的）类不能这么用，因为FIT不能找到合适的类参数，并试图为所有方法用Object 参数。
当system under test（被测系统）已经定义了，在你的测试中可以调用夹具类中的方法。如果夹具中没有合适的方法，FIT将在system under test（被测系统）中寻找合适的方法。

!|SystemUnderTest|
|Enqueue|directly
calling queue|
|check|count|1|
|Generate|12|Messages|
|check|count|13|
|check|dequeue|directly
calling queue|

// Java
Source Code
package
info.fitnesse.fixturegallery;
import
fitlibrary.DoFixture;
import
info.fitnesse.fixturegallery.domain.*;
public
class SystemUnderTest extends DoFixture {
    Queue queue;
    public
SystemUnderTest() {
       queue = new
Queue();
       setSystemUnderTest(queue);
    }
    public void
generateMessages(int i) {
       for (int cnt
= 0; cnt
           queue.enqueue("M"
+ i);
       }
    }
}



5）、Symbols 符号：Symbols是FIT的全局变量。它们用于在表间动态地交换值，你可以创建一个领域对象（如：一个player）并存储它的ID或整个对象到一个符号中，因此，随后它可以在不同的测试中使用。

Symbols in Java：
在FIT的Java实现中，ColumnFixture有一种专用语法支持symbols。在列名前添加一个等号表示方法的值不被测试而被存储在一个symbols（符号）中。然后在单元格中输入符号名代替预期结果。在列名后添加等号并再次在单元中用符号名，则在稍后的不同测试表中单元中输入符号名代替输入值。

!|ColumnFixtureTest|
|firstPart|secondPart|=together()|
|Hello|World|line1|

!|SymbolsTest|
|check|symbol
value|line1|Hello,World|
|set symbol value|line2|Hello|

!|ColumnFixtureTest|
|firstPart=|secondPart|together()|
|line1|World|Hello,World,World|
|line2|World|Hello,World|

在FIT的Java实现中，你可以用静态方法Fixture.getSymbol和Fixture.setSymbol来存取符号值。
// Java
Source Code
package
info.fitnesse.fixturegallery;
import
fitlibrary.SequenceFixture;
import
fit.Fixture;
public
class SymbolsTest extends SequenceFixture {
    public Object symbolValue(String s) {
       return Fixture.getSymbol(s);
    }
    public void setSymbolValue(String symbol,
String value) {
       Fixture.setSymbol(symbol, value);
    }
}


Markup Variables：标记变量
在FitNesse页面中，标记变量用于宏替换。它们提供了另一种测试静态值（测试过程值不变）的参数化方式。
标记变量的定义：!define variablename {value}
用法：${value}
不同于符号，标记变量可用作单元的一部分。注意，直到构建HTML页时，标记变量才被执行，因此，在运行时，它们在夹具内是不可用的。
!define town {Houston}
!|ColumnFixtureTest|
|firstPart|secondPart|together?|
|Hello|World|Hello,World|
|${town}|We Have a Problem|${town},We Have a Problem|

当提取公值到一个单独的位置时，标记变量非常有效，因为它很容易被改变。它们也可用于嵌套页间的参数化。例如，你写了一个频繁使用的测试组件，然后通过标记变量用不同的参数值调用它。参见
http://fitnesse.org/FitNesse.ParameterizedIncludes
。
               
               
               
               

本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u2/76927/showart_2045110.html