xcfit 0.2.0

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/FitFramework/FitServer/properties.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0"?>
+<properties>
+	<Files/>
+	<RecentChanges/>
+	<WhereUsed/>
+</properties>

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/FitFramework/FitServerProtocol/content.txt

@@ -0,0 +1,31 @@
+!c !3 A description of the FitServer component that is required for each FIT.
+!c !3 This is the protocol of communication between FIT and FitNesse.
+'''Invocation:'''
+FitServer is invoked by a simple console command.
+''!-java fit.FitServer-!''
+
+'''Command Line Arguments:'''
+Java usage: !-java fit.FitServer [-v]-! ''host port socketTicket''
+
+'''Execution:'''
+ * '''Connecting'''
+  1 Use the ''socketTicket'' to build an HTTP request of the form:
+   * !-GET /?responder=socketCatcher&ticket=-!''socketTicket'' !-HTTP/1.1\r\n\r\n-!
+  1 open socket connection to the given ''host'' and ''port''.
+  2 write the http request over the socket (do not precede with size)
+  5 receive ''STATUS'' as ''INTEGER''.
+ * '''Transactions''' - loops until a 0 ''INTEGER'' is read as the size of a document.
+  1 ''READ'' document from socket
+  2 process document and ''WRITE'' processed document to socket.
+   * the processes document may be written in 1 to many chunks.
+  3 write 0 to socket an an ''INTEGER''.
+  4 ''WRITE COUNTS'' for document to socket
+ * '''Closing''' - invoked by reading a document size of 0.
+  1 close the socket.
+  2 exit execution with a value of (wrongs + exceptions)
+!include FitProtocol
+
+
+'''Errors and Exceptions:'''
+ - ''Connection Error'': If the ''STATUS'' recieved at connection is not zero, then somehitng has gone wrong.  The value of ''STATUS'' is the length of the error message the FitNesse will send.  Before exiting FitServer should read the error message and print it to standard error.
+ - ''Transaction Error'': If an exception is thrown during the processing of transactions then the exception should be wrapped in an HTML table and written back over the socket as though it were the test results.  An exception thrown at any other point is considered fatal and may invoke abnormal termination.

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/FitFramework/FitServerProtocol/properties.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0"?>
+<properties>
+	<Files/>
+	<RecentChanges>true</RecentChanges>
+	<WhereUsed/>
+</properties>

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/FitFramework/KeywordsInTestTables/content.txt

@@ -0,0 +1,7 @@
+There are three keywords that can appear in a test table.
+
+|null|''is replaced with a true null when used in a string column''|
+|blank|''is replaced with an empty string when used in a string column''|
+|error|''Turns the cell red if there were no errors.  Turns the cell green if there was an exception.''|
+
+Click [[here][.FitNesse.SuiteAcceptanceTests.SuiteFixtureTests.SuiteGeneralFixtureSpec.TestBlankAndNullCells]] to see the acceptance tests for null and blank.

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/FitFramework/KeywordsInTestTables/properties.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0"?>
+<properties>
+	<Files/>
+	<RecentChanges/>
+	<WhereUsed/>
+</properties>

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/FitFramework/ParametersInFixtures/content.txt

@@ -0,0 +1,60 @@
+!3 You are allowed to pass arguments into any fixture.
+
+Arguments are in cells that are to the right of the cell with the fixture name.  The protected field ''args'' in Fixture holds a String array with the arguments.
+
+Below you can see a simple RowFixture that takes a single integer argument and produces the prime factors of that argument.
+
+|!-fitnesse.fixtures.PrimeFactorsFixture-!|6|
+|factor|
+|2|
+|3|
+
+The code for this fixture is shown below.  Note that the ''query'' method uses the ''args'' field.
+(Note the "6" that follows the fixture name above.)  You can put as many arguments there as you like.
+{{{
+public class PrimeFactorsFixture extends RowFixture
+{
+  public static class Factor
+  {
+    public Factor(int factor)
+    {
+      this.factor = factor;
+    }
+
+    public int factor;
+  }
+
+  public Object[] query()
+  {
+    int n = Integer.parseInt(args[0]);
+    ArrayList factors = new ArrayList();
+    for(int f = 2; n > 1; f++)
+      for(; n % f == 0; n /= f)
+        factors.add(new Factor(f));
+    return (Factor[]) factors.toArray(new Factor[0]);
+  }
+
+  public Class getTargetClass()             // get expected type of row
+  {
+    return Factor.class;
+  }
+}
+}}}
+Because this is a RowFixture, the order of the rows is unimportant.  As shown below the rows will be matched and found regardless of their order.
+|!-fitnesse.fixtures.PrimeFactorsFixture-!|1000|
+|factor|
+|2|
+|5|
+|2|
+|5|
+|5|
+|2|
+
+And of course any cells that are missing, or extra will be marked in red.
+|!-fitnesse.fixtures.PrimeFactorsFixture-!|63|
+|factor|
+|7|
+|3|
+|5|
+
+

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/FitFramework/ParametersInFixtures/properties.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<properties>
+<Files/>
+<RecentChanges/>
+<Test/>
+<WhereUsed/>
+</properties>

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/FitFramework/ParametricRowFixture/content.txt

@@ -0,0 +1,58 @@
+!3 This fixture is just like a RowFixture except that it allows you to pass arguments into the fixture.
+
+Below you can see a simple ParametricRowFixture that takes a single integer argument and produces the prime factors of that argument.
+
+|!-fitnesse.fixtures.PrimeFactorsFixture-!|6|
+|factor|
+|2|
+|3|
+
+The code for this fixture is shown below.  Note that the ''query'' method takes a ''String args[]'' argument.  The arguments to the fixture are passed in through this array.   The arguments are all the table cells that follow the fixture name.  (Note the "6" that follows the fixture name above.)  You can put as many arguments there as you like.
+{{{
+public class PrimeFactorsFixture extends ParametricRowFixture
+{
+  public static class Factor
+  {
+    public Factor(int factor)
+    {
+      this.factor = factor;
+    }
+
+    public int factor;
+  }
+
+  public Object[] query(String[] args)
+  {
+    int n = Integer.parseInt(args[0]);
+    ArrayList factors = new ArrayList();
+    for(int f = 2; n > 1; f++)
+      for(; n % f == 0; n /= f)
+        factors.add(new Factor(f));
+    return (Factor[]) factors.toArray(new Factor[0]);
+  }
+
+  public Class getTargetClass()             // get expected type of row
+  {
+    return Factor.class;
+  }
+}
+
+}}}
+As in RowFixture, the order of the rows is unimportant.  As shown below the rows will be matched and found regardless of their order.
+|!-fitnesse.fixtures.PrimeFactorsFixture-!|1000|
+|factor|
+|2|
+|5|
+|2|
+|5|
+|5|
+|2|
+
+As in RowFixture, and as shown below, any cells that are missing, or extra will be marked in red.
+|!-fitnesse.fixtures.PrimeFactorsFixture-!|63|
+|factor|
+|7|
+|3|
+|5|
+
+

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/FitFramework/ParametricRowFixture/properties.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0"?>
+<properties>
+	<Files/>
+	<RecentChanges/>
+	<WhereUsed/>
+	<Test/>
+</properties>

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/FitFramework/RowEntryFixture/content.txt

@@ -0,0 +1,37 @@
+!3 A Fixture for entering rows of data.
+
+Sometimes, as in the [[!-BuildOperateCheck-!][<UserGuide.WritingAcceptanceTests.AcceptanceTestPatterns.BuildOperateCheck]] pattern, we want to add a bunch of data to a database.  Or sometimes we want to call a function over and over again with different arguments.  This is often done in order to configure the system for a subsequent fixture that will run tests based upon the configured data.
+
+We have seen examples where this was done with the help of a ''valid()'' function.
+
+RowEntryFixture is a better option in many cases.
+
+ * RowEntryFixture is an abstract class.  You have to derive from it.
+ * It derives from ColumnFixture and works just the same way it does.
+ * You override the ''enterRow'' function to add your data to the database.
+  * If you have trouble adding your data, you throw an exception loaded with a message explaining the problem.
+
+|Comment|
+|{{{public abstract void enterRow() throws Exception;}}}|Override this function to add your row of data.  Throw an exception if there are any problems.|
+
+Here is an example of a very simple RowEntryFixture:
+{{{public class RowEntryExample extends RowEntryFixture
+{
+  public int v;
+  public void enterRow() throws Exception
+  {
+    if (v == 0)
+      throw new Exception("Oh, no!  Zero!");
+  }
+} }}}
+And here you can see it running.
+
+|!-fitnesse.fixtures.RowEntryExample-!|
+|v|
+|1|
+|0|
+
+
+
+
+

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/FitFramework/RowEntryFixture/properties.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<properties>
+<Files/>
+<RecentChanges/>
+<Test/>
+<WhereUsed/>
+</properties>

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/FitFramework/RowFixture/content.txt

@@ -0,0 +1,125 @@
+!1 Checking Query Results Using !-RowFixture-!
+This style of test table is best for checking the results of queries. For the sake of discussion, let's call each of the items that you get back from a query a '''record'''. A RowFixture lets you test that you get back '''exactly the set of records''' from a query that you expect to get.
+
+Here is a simplistic example. Let's say that we have asked our application for the first five prime numbers.  We want to make sure we got them all.
+
+|!-fitnesse.fixtures.PrimeNumberRowFixture-!|
+|prime|
+|3|
+|2|
+|5|
+|7|
+|11|
+
+This test table style does not read the way that a ColumnFixture style test table does. In this case, each cell in the ''prime'' column represents a '''key''' that identifies one of the records we expect to get back (in this case, a prime number). And '''the entire set of rows of data''' represent the output we expect to get back: no more and no less than that '''exact set of records''' (though they need not be in that exact order).
+
+Hit the test button to run this test. OK, we got them all. For an explanation of the fixture code for this RowFixture example, see RowFixtureCode.
+
+!2 Missing Records
+The following table shows what happens when you ask for a record that doesn't exist. ''(Note the extra 12.'')
+
+|!-fitnesse.fixtures.PrimeNumberRowFixture-!|
+|prime|
+|2|
+|3|
+|5|
+|7|
+|11|
+|12|
+
+!2 Surplus Records
+And this table shows what happens when you don't ask for a record that ''is'' in the query results.  ''(Note the 11 is missing.)''
+
+|!-fitnesse.fixtures.PrimeNumberRowFixture-!|
+|prime|
+|2|
+|3|
+|5|
+|7|
+
+!2 Testing Fields in Returned Records
+Often you want to see that you got a specific set of records back, '''and'''  you want to '''test certain fields in the returned records'''. For this you use the same question-mark syntax we saw used for output columns in ColumnFixture style tables.
+
+For example, lets say that we have a database of employee records.  We want to test that the employees were paid correctly. The ''pay?'' column in the table below specifies the exact amount we expect to get back for the pay field of each returned employee record:
+
+|!-fitnesse.fixtures.EmployeePayRecordsRowFixture-!|
+|id|pay?|
+|1|1000|
+|2|2000|
+
+!3 Incorrect Output
+Here's what it would look like if the pay was not correct for the employee whose id is 2. It looks just as it does for incorrect output values in a ColumnFixture table cell:
+
+|!-fitnesse.fixtures.EmployeePayRecordsRowFixture-!|
+|id|pay?|
+|1|1000|
+|2|3000|
+
+!3 Missing or Extra Records
+And regardless whether you check aspects of queried records, FitNesse shows you whether any are missing or extra:
+
+|!-fitnesse.fixtures.EmployeePayRecordsRowFixture-!|
+|id|pay()|
+|1|1000|
+|5|5000|
+
+To see the fixture code for these tables, see RowFixtureCode.
+
+!2 Querying Using Multiple "Keys"
+Sometimes we need more than one piece of data to uniquely identify a record.
+
+Suppose we have records for the last three months' worth of paychecks.  Each paycheck is uniquely identified by the ''employeeId'' and the ''date''.  We want to make sure that the checks were generated properly. We use a RowFixture table to ask for a set of checks identified by both ''employeeId'' '''and''' ''date'':
+
+|!-fitnesse.fixtures.PayCheckRecordFixture-!|
+|date|employeeId|name|pay()|
+|3/1/03|1||1000|
+|3/1/03|2||2002|
+|4/1/03|1||1015|
+|4/1/03|2||2003|
+
+Notice, once again, that the order of the table rows doesn't matter.  For example, this table also works fine for that same query:
+
+|!-fitnesse.fixtures.PayCheckRecordFixture-!|
+|date|employeeId|name|pay()|
+|4/1/03|1||1015|
+|3/1/03|1||1000|
+|4/1/03|2||2003|
+|3/1/03|2||2002|
+
+!3 Blank Fields
+Notice the ''name'' field. We provided the field name, knowing that it was part of each record, but we provided no expected values in that column. As a result, FitNesse did not make this field part of the key for finding records, but merely filled in the values found for that field in each record, so we could see them. Here's what would have happened if we filled in the ''name'' column correctly for some cells, and incorrectly for another.
+
+|!-fitnesse.fixtures.PayCheckRecordFixture-!|
+|date|employeeId|name|pay()|
+|3/1/03|1|Bob|1000|
+|4/1/03|1|Bob|1015|
+|3/1/03|2|Bill|2002|
+|4/1/03|2|Biff|2003|
+
+And here's what would happen if a row were missing or surplus.
+
+|!-fitnesse.fixtures.PayCheckRecordFixture-!|
+|date|employeeId|name|pay()|
+|3/1/03|1||1000|
+|4/1/03|1||1015|
+|3/1/03|2||2002|
+|4/1/03|3||2003|
+
+!2 Summary
+  * RowFixture tables are designed for checking that you get back exactly the set of records you want from a query.
+  * FitNesse will cause the test to fail if the query had any '''missing''' or '''surplus''' records.
+  * You can also test fields in the returned records.
+  * If you provide a field name column, but provide no expected values for it, then FitNesse will fill in the returned values so you can see them.
+
+!2 Learning More
+To learn about the fixture code for the above examples, see RowFixtureCode.
+Also check out the other TestTableStyles.
+
+
+
+
+
+
+
+
+

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/FitFramework/RowFixture/properties.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0"?>
+<properties>
+	<Files/>
+	<Help/>
+	<RecentChanges/>
+	<Suites/>
+	<Test/>
+	<WhereUsed/>
+	<saveId>1221210977814</saveId>
+	<ticketId>-6830312487753414061</ticketId>
+</properties>

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/FitFramework/RowFixtureCode/content.txt

@@ -0,0 +1,93 @@
+!1 How RowFixture Fixture Code Works
+
+Here is our simplistic prime number test table again:
+
+|!-fitnesse.fixtures.PrimeNumberRowFixture-!|
+|prime|
+|2|
+|3|
+|5|
+|7|
+|11|
+
+Hit the test button to run this test. OK, we got them all. How does the table tell the code what to expect?
+
+Each data column specifies a query '''key'''. Above, ''prime'' is our only key. We just want to see whether our set of primes contains each of these numbers.
+
+Now here is the code for the !-PrimeNumberRowFixture-!:{{{package fitnesse.fixtures;
+
+import fit.RowFixture;
+
+public class PrimeNumberRowFixture extends RowFixture {
+  public Object[] query() throws Exception {
+    PrimeData[] array = new PrimeData[5];
+    array[0] = new PrimeData(11);
+    array[1] = new PrimeData(5);
+    array[2] = new PrimeData(3);
+    array[3] = new PrimeData(7);
+    array[4] = new PrimeData(2);
+    return array;
+  }
+
+  public Class getTargetClass() {
+    return PrimeData.class;
+  }
+} }}} All we are doing is assembling and returning an array of !-PrimeData-! objects: these are our ''records''. We also use the special ''getTargetClass()'' method to specify to Fit the type of the '''record''' objects we need it to inspect for us. In this case, ''!-PrimeData.class-!''.
+
+Notice that the '''key''' column name (''prime'') in the table corresponds to the public member variable ''prime'' in !-PrimeData-!.  Fit inspects each of the !-PrimeData-! objects in the returned array, comparing the table cell values in the ''prime'' column with the contents of the ''prime'' variable in !-PrimeData-!. Here is the code for !-PrimeData-!: {{{package fitnesse.fixtures;
+
+public class PrimeData {
+  public int prime;
+  public PrimeData(int prime) {
+    this.prime = prime;
+  }
+} }}}  Notice also that the order of the records in our query array is not the same as the order of key values in the table.  RowFixture does not care about the order of the records returned by a query, as long as they are all there, and as long as there are no extras.
+
+!2 Employee Pay Records Example: Testing Fields in Returned Records
+Here is our sample table (from the RowFixture page) that checks that a company's employees were paid correctly:
+
+|!-fitnesse.fixtures.EmployeePayRecordsRowFixture-!|
+|id|pay()|
+|1|1000|
+|2|2000|
+
+And here is the corresponding fixture code:{{{package fitnesse.fixtures;
+
+import fit.RowFixture;
+
+public class EmployeePayRecordsRowFixture extends RowFixture  {
+  public Object[] query() throws Exception {
+    EmployeePayRecord[] records = new EmployeePayRecord[2];
+    records[0] = new EmployeePayRecord(1, 1000);
+    records[1] = new EmployeePayRecord(2,2000);
+    return records;
+  }
+  public Class getTargetClass() {
+    return EmployeePayRecord.class;
+  }
+} }}} Again, we are merely assembling an array of records; in this case, employee payroll records. We also identify the class of the '''record''' type Fit must inspect: ''!-EmployeePayRecord.class-!''. Now here is !-EmployeePayRecord-!: {{{package fitnesse.fixtures;
+
+public class EmployeePayRecord {
+  public int id;
+  private double salary;
+  public EmployeePayRecord(int id, double salary) {
+    this.id = id;
+    this.salary = salary;
+  }
+  public double pay() {
+    return salary;
+  }
+} }}} To identify each row in the table, Fit finds the corresponding !style_code(!-EmployeePayRecord-!) by matching the ''id'' value in the table with the contents of the ''id'' variable, and matching the ''salary'' value in the table with the contents of the ''salary'' variable. For each found record, Fit then checks the value in the ''pay?'' column against the amount returned by the ''pay()'' method.
+
+!3 Wait a Minute. We're Just Assembling The Query Results in the Fixture!
+Yeah, you're right. We're cheating, in the interest of clarity and simplicity. These examples show the mechanics of RowFixtureCode, but not a realistic use. It will rarely make sense to be assembling the array you need within the fixture code, since that does not demonstrate that your production code correctly provides the query results you need.
+
+When you write application code in order to get tests like the above to pass, you will likely want to have an array of the right objects already handy, so that something like !-EmployeePayRecordsRowFixture-! can just grab it, instead of having to assemble it. Alternatively, you might have production code ready to grab the array of query results from a database. In either case, the fixture code would just ask the production code to return the array of records it needs.
+
+!2 Learning More
+To learn more about the RowFixture style of test table, see RowFixture.
+To learn more about how FitNesse fixture code works in general, check out [[!-FixtureCode-!][<UserGuide.WritingAcceptanceTests.FixtureCode]].
+Also check out the other TestTableStyles.
+
+
+