xcfit 0.2.0

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/SliM/SlimProtocol/properties.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<properties>
+<Edit>true</Edit>
+<Files>true</Files>
+<Properties>true</Properties>
+<RecentChanges>true</RecentChanges>
+<Refactor>true</Refactor>
+<Search>true</Search>
+<Versions>true</Versions>
+<WhereUsed>true</WhereUsed>
+</properties>

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/SliM/SubsetQueryTable/content.txt

@@ -0,0 +1,7 @@
+|Subset Query:employees hired before|10-Dec-1980                     |
+|employee number                    |first name|last name|hire date  |
+|1429                               |Bob       |Martin   |10-Oct-1974|
+
+The first thing to notice is the ''Subset Query:'' in the first cell of the table.  This tells the Slim table processor that this is a subset query table. Subset query tables are almost identical to [[Query tables][QueryTable]] except that we only need to put those rows into the table that we want to make sure to exist in the query response.
+
+Our definition of subset here is not ''proper'' subset. Thus the table may contain all the rows of the query response.

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/SliM/SubsetQueryTable/properties.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0"?>
+<properties>
+	<Edit/>
+	<Files/>
+	<Help/>
+	<Properties/>
+	<RecentChanges/>
+	<Refactor/>
+	<Search/>
+	<Suites/>
+	<Test/>
+	<Versions/>
+	<WhereUsed/>
+</properties>

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/SliM/SymbolsInTables/content.txt

@@ -0,0 +1,20 @@
+|DT:some decision table|
+|input     |output?    |
+|3         |$V=        |
+|$V        |8          |
+|9         |$V         |
+
+
+If a $''<symbolName>'' appears in an output cell (whether in a Decision Table, Script Table, or any other kind of table that can call functions) then that symbol will be loaded with that output.  Both the slim server running in the SUT and !-FitNesse-! will remember that symbol.
+
+The first row above loads the return value of the ''output'' function into the symbol ''V''.  The second row will load the previously stored value of ''V'' into the input.  (If you think about this in the context of the SlimProtocol you'll realize that this means that the symbol must be stored on the SUT).  The third row compares the output with the previously stored value of the symbol.
+
+You can combine symbols as follows:
+
+|$V and $X are symbols|
+
+The symbols V and X will be replaced with their values...  
+
+!3 Read also:
+
+.FitNesse.SuiteAcceptanceTests.SuiteSlimTests.SlimSymbols

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/SliM/SymbolsInTables/properties.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<properties>
+<Edit>true</Edit>
+<Files>true</Files>
+<LastModifyingUser>six42</LastModifyingUser>
+<Properties>true</Properties>
+<RecentChanges>true</RecentChanges>
+<Refactor>true</Refactor>
+<Search>true</Search>
+<Versions>true</Versions>
+<WhereUsed>true</WhereUsed>
+<saveId>1238174405669</saveId>
+<ticketId>-5189210762337118063</ticketId>
+</properties>

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/SliM/SystemUnderTest/content.txt

@@ -0,0 +1,51 @@
+!3 System Under Test
+
+'''Currently only available in Java'''
+
+!-Using SystemUnderTest allows you to let SliM directly invoke a method on your SystemUnderTest without having to create a method in a SliM fixture for it.-!
+
+!4 Example
+{{{
+import fitnesse.slim.SystemUnderTest;
+
+/**
+ * The slim fixture.
+ */
+public class SlimDriver {
+  
+  // field MUST be declared PUBLIC
+  @SystemUnderTest
+  public Service service = new Service();
+
+  public void init() {
+    Database.clean();
+  }
+
+}
+
+/**
+ * The service under test.
+ */
+public class Service {
+
+  public void createPerson(String name) {
+    Database.persist(new Person("name"));
+  }
+
+  public boolean exists(String name) {
+    return Database.get(name) != null;
+  }
+ 
+}
+
+}}}
+
+With the !-@SystemUnderTest-! annotation you can now say:
+
+!|script|SlimDriver|
+|init|
+|create person|Ben Vonk|
+|ensure|exists|Ben Vonk|
+
+When a method that should be invoked on the !-SliM-! fixture is missing, it will try to invoke that method on a '''public''' field annotated with !-SystemUnderTest-!.
+

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/SliM/SystemUnderTest/properties.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0"?>
+<properties>
+	<Edit/>
+	<Files/>
+	<Help/>
+	<Normal/>
+	<Properties/>
+	<RecentChanges/>
+	<Refactor/>
+	<Search/>
+	<Suites/>
+	<Versions/>
+	<WhereUsed/>
+</properties>

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/SliM/TableTable/ReportTables/content.txt

@@ -0,0 +1,16 @@
+!3 Generating reports inside pages using Table tables.
+
+Since you can pass back any size result to a Table table, and since you can create a Table table that has only one row, you can generate reports.
+
+For example:
+
+|table:counts|
+
+This table will execute the !style_code(doTable) method of the !style_code(counts) fixture.  If that method returns a table like this:{{{[
+  [report:Employees,pass:22],
+  [report:Managers,fail:21]
+]}}} then the resulting table will be
+
+|!style_pass(table:counts)|
+|Employees|!style_pass(22)|
+|Managers|!style_fail(21)|

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/SliM/TableTable/ReportTables/properties.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0"?>
+<properties>
+	<Edit>true</Edit>
+	<Files>true</Files>
+	<Properties>true</Properties>
+	<RecentChanges>true</RecentChanges>
+	<Refactor>true</Refactor>
+	<Search>true</Search>
+	<Versions>true</Versions>
+	<WhereUsed>true</WhereUsed>
+	<saveId>1232732180225</saveId>
+	<ticketId>-4574603253238332954</ticketId>
+</properties>

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/SliM/TableTable/content.txt

@@ -0,0 +1,128 @@
+|Table:Bowling|
+|3|5|4|/|X||X||3|4|6|/|7|2|3|4|9|-|4|/|3|
+||8 ||28||51||68||75||92||101||108||117|||130|
+
+The "Table" table allows you to write a fixture that accepts an arbitrary table, and returns a table of results.  The table of results has a similar geometry to the input table (without the first row). Each cell of the result table can be one of the following codes:
+
+|Comment|
+|''pass''            |The original contents will be colored green.|
+|''pass:<message>''  |The original contents will be replaced with ''<message>'' and colored green.|
+|''fail''            |The original contents will be colored red.|
+|''fail:<message>''  |The original contents will be replaced with ''<message>'' and colored red.|
+|''ignore''          |The original contents will be colored grey.|
+|''ignore:<message>''|The original contents will be replaced with ''<message>'' and colored grey.|
+|''report:<message>''|The original contents will be replaced with ''<message>''.|
+|''<empty string>'' or ''no change''|The corresponding cell will be unchanged|
+|''error:<message>'' |''/!\ <message>'' will be appended to the original contents and colored yellow.|
+|''<anything else>'' |The original contents will be replaced with ''<anything else>'' and colored red.|
+
+The fixture is written with a !style_code(doTable) method.  This method takes a List argument and returns a List.  The incomming list is a list of rows.  Each row is a list of strings.  The returned list has a similar structure except that it does not have the first row.  If any row of the returned list is longer than the corresponding row of the incomming list, then the extra columns will be added to the colored table.  If there are extra rows, then they will be added too.  So the returned table can be larger, horizontally and vertically.  It cannot be smaller!
+
+See [[Report Tables][>ReportTables]] to see how to use the different geometries to create reports.
+
+Here is the fixture for the above table.{{{
+package fitnesse.slim.test;
+
+import static fitnesse.util.ListUtility.*;
+
+import java.util.List;
+
+public class Bowling {
+  public List doTable(List<List<String>> table) {
+    Game g = new Game();
+    List rollResults = list("","","","","","","","","","","","","","","","","","","","","");
+    List scoreResults = list("","","","","","","","","","","","","","","","","","","","","");
+    rollBalls(table, g);
+    evaluateScores(g, table.get(1), scoreResults);
+    return list(rollResults, scoreResults);
+  }
+
+  private void evaluateScores(Game g, List<String> scoreRow, List scoreResults) {
+    for (int frame=0; frame<10; frame++) {
+      int actualScore = g.score(frame+1);
+      int expectedScore = Integer.parseInt(scoreRow.get(frameCoordinate(frame)));
+      if (expectedScore == actualScore)
+        scoreResults.set(frameCoordinate(frame), "pass");
+      else
+        scoreResults.set(frameCoordinate(frame), String.format("Was:%d, expected:%s.", actualScore, expectedScore));
+    }
+  }
+
+  private int frameCoordinate(int frame) {
+    return frame < 9 ? frame*2+1 : frame*2+2;
+  }
+
+  private void rollBalls(List<List<String>> table, Game g) {
+    List<String> rollRow = table.get(0);
+    for (int frame = 0; frame < 10; frame++) {
+      String firstRoll = rollRow.get(frame * 2);
+      String secondRoll = rollRow.get(frame * 2 + 1);
+      if (firstRoll.equalsIgnoreCase("X"))
+        g.roll(10);
+      else {
+        int firstRollInt = 0;
+        if (firstRoll.equals("-"))
+          g.roll(0);
+        else {
+          firstRollInt = Integer.parseInt(firstRoll);
+          g.roll(firstRollInt);
+        }
+        if (secondRoll.equals("/"))
+          g.roll(10 - firstRollInt);
+        else if (secondRoll.equals("-"))
+          g.roll(0);
+        else
+          g.roll(Integer.parseInt(secondRoll));
+      }
+    }
+  }
+
+  private class Game {
+    int rolls[] = new int[21];
+    int currentRoll = 0;
+
+    public void roll(int pins) {
+      rolls[currentRoll++] = pins;
+    }
+
+    public int score(int frame) {
+      int score = 0;
+      int firstBall = 0;
+      for (int f=0; f<frame; f++) {
+        if (isStrike(firstBall)) {
+          score += 10 + nextTwoBallsForStrike(firstBall);
+          firstBall += 1;
+        } else if (isSpare(firstBall)) {
+          score += 10 + nextBallForSpare(firstBall);
+          firstBall += 2;
+        } else {
+          score += twoBallsInFrame(firstBall);
+          firstBall += 2;
+        }
+      }
+      return score;
+    }
+
+    private int twoBallsInFrame(int firstBall) {
+      return rolls[firstBall] + rolls[firstBall+1];
+    }
+
+    private int nextBallForSpare(int firstBall) {
+      return rolls[firstBall+2];
+    }
+
+    private int nextTwoBallsForStrike(int firstBall) {
+      return rolls[firstBall+1] + rolls[firstBall+2];
+    }
+
+    private boolean isSpare(int firstBall) {
+      return rolls[firstBall] + rolls[firstBall+1] == 10;
+    }
+
+    private boolean isStrike(int firstBall) {
+      return rolls[firstBall] == 10;
+    }
+  }
+}
+
+}}}

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/SliM/TableTable/properties.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0"?>
+<properties>
+	<Edit/>
+	<Files/>
+	<Help/>
+	<Properties/>
+	<RecentChanges/>
+	<Refactor/>
+	<Search/>
+	<Suites/>
+	<Test/>
+	<Versions/>
+	<WhereUsed/>
+	<saveId>1232732770570</saveId>
+	<ticketId>6617471917833325753</ticketId>
+</properties>

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/SliM/ValueComparisons/content.txt

@@ -0,0 +1,25 @@
+!3 Numerical Comparisons
+You can use relational comparisons for the numeric values in your table cells.
+
+|DT:Some Decision Table|
+|input|output?|
+|3|<5|
+|5|>=3|
+|8|3<_<9|
+
+You can use all the normal operators: <, >, <=, >=, !=.
+
+The ''~='' relational operator means ''approximately equal''.  It applies to floating point numbers.  So if ''~=3.0'' then the ''3.0'' sets the precision so that 2.95 or 3.049 will both show equality.  It is the number of decimals on the right side of the operator that determines the precision.
+
+So 2.5~=3 but 2.5 is not ~= 3.0.
+
+!3 Regular Expression Comparisons
+You can match regular expressions by using the syntax =~/''regex''/.  For example:
+
+|check|echo|Bob|=~/Bob/|
+|check|echo|My name is Bob."|=~/B.b/|
+
+The regular expression syntax is the '''Java''' standard.  
+
+
+

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/SliM/ValueComparisons/properties.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0"?>
+<properties>
+	<Edit>true</Edit>
+	<Files>true</Files>
+	<Properties>true</Properties>
+	<RecentChanges>true</RecentChanges>
+	<Refactor>true</Refactor>
+	<Search>true</Search>
+	<Versions>true</Versions>
+	<WhereUsed>true</WhereUsed>
+	<saveId>1225294538423</saveId>
+	<ticketId>4620953944571182425</ticketId>
+</properties>

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/SliM/content.txt

@@ -0,0 +1,65 @@
+!define TEST_SYSTEM {slim}
+!2 The ''SLIM'' Test System
+Slim (Simple List Invocation Method) is an alternative to Fit. Rather than running all the HTML processing, comparisons, and colorizing in the System Under Test (SUT), Slim keeps all that behavior on in FitNesse. What executes in the SUT is a very tiny kernel that implements the [[''Slim Protocol''][>SlimProtocol]]. This protocol is a bare bones RPC system that allows FitNesse to call functions in the SUT.
+
+This strategy has a number of advantages:
+
+ * The Slim protocol is very easy to port. Getting new platforms to use SLIM is a matter of a few hours of work.
+ * All the features are on the FitNesse side, so test tables remain consistent regardless of the platform of the SUT.
+ * Since HTML is not an intrinsic part of SLIM, new test syntaxes can be explored.
+
+!3 Using the SLIM Test System
+If you want a test page to be run under SLIM, you simply set the TEST_SYSTEM variable to "slim" instead of "fit".
+
+{{{&bang;define TEST_SYSTEM {slim} }}}If this variable is set on your page, (as it is on this page!) or on any parent page, then your page will be run with Slim. That's all there is to it.
+
+!3 The Slim Tables
+The first cell of a slim table tells you what kind of table it is. Here are the table types so far:
+
+| [[Decision Table][>DecisionTable]] | Supplies the inputs and outputs for decisions. This is similar to the Fit Column Fixture |
+| [[Dynamic Decision Table][>DynamicDecisionTable]] | Has the same syntax as a >DecisionTable, but passes the column headers as parameters to the fixture. |
+| [[Query Table][>QueryTable]] | Supplies the expected results of a query. This is similar to the Fit Row Fixture |
+| [[Subset Query Table][>SubsetQueryTable]] | Supplies a subset of the expected results of a query. |
+| [[Ordered query Table][>OrderedQueryTable]] | Supplies the expected results of a query. The rows are expected to be in order. This is similar to the Fit Row Fixture |
+| [[Script Table][>ScriptTable]] | A series of actions and checks. Similar to Do Fixture. |
+| [[Table Table][>TableTable]] | Whatever you want it to be! |
+| [[Import][>ImportTable]] | Add a path to the fixture search path. |
+| [[Comment][>CommentTable]] | A table that does nothing. |
+| [[Scenario Table][>ScenarioTable]] | A table that can be called from other tables. |
+| [[Library Table][>LibraryTable]] | A table that installs fixtures available for all test pages |
+| [[Define Table Type][>DefineTableType]] | A helper table that defines the default table type for named fixtures. |
+| [[Define Alias][>DefineAlias]] | A helper table that defines alias names for fixtures. |
+
+!4 Data Types.
+The data in your tables is all Strings. However your fixtures don't want to be constrained to Strings. So Slim comes with several standard data type converters that will automatically convert the strings in the tables into the data types expected by your fixtures.
+
+!see >DataTypes
+You can also create your own custom type converters if you like.
+
+!see >CustomTypes
+Content returned from the SUT will be escaped by default, so your fixture can return a piece of output without the need to transform it to HTML compatible output. On the other hand, if you're returning HTML content (e.g. a <table>..</table>), FitNesse will try to detect that (based on a valid HTML start and end tag) and will render the HTML in-line.
+
+!4 Configure SLIM
+The Slim test system can be configured using the following properties:
+
+| slim.port | 8085 | Base port for SLIM. |
+| slim.pool.size | 10 | The size of the pool of ports to cycle through. By default the ports 8085 up to 8095 are used (''slim.port'' + ''slim.pool.size''). |
+| slim.host | localhost | The host the SLIM server will be running on. This is mostly useful if you're running a remote SLIM server. |
+| slim.flags | | Extra flags to provide to the SLIM server. Arguments supported by the slim service are: !-
+-![-v] [-i interactionClass] [-s statementTimeout] [-d] [-ssl parameterClass] |
+| slim.timeout | 10 seconds | Connection timeout starting and finishing a test run. |
+| slim.debug.timeout | ''slim.timeout'' | Same as ''slim.timeout'', used when the debug property is set (falls back to ''slim.timeout''). |
+| manually.start.test.runner.on.debug | false | Do not launch a SLIM server if the test is ran in debug mode. |
+
+Those properties can be either provided by a wiki page, on the command line (e.g. ''-Dslim.port=9000'') or in the plugins.properties file.
+
+!4 Extra Goodies that are consistent throughout all Slim tables and ports.
+| [[''Exception Handling''][>ExceptionHandling]] |
+| [[''Symbols in tables''][>SymbolsInTables]] |
+| [[''Constructor arguments''][>ConstructorArguments]] |
+| [[''Value comparisons''][>ValueComparisons]] |
+| [[''Graceful names''][>GracefulNames]] |
+
+!4 Java goodies
+| [[''System Under Test''][>SystemUnderTest]] |
+| [[''Interaction Aware Fixture''][>InteractionAwareFixture]] |

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/SliM/properties.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<properties>
+<Files/>
+<RecentChanges/>
+<Search/>
+<Static/>
+<WhereUsed/>
+<saveId>1236195430393</saveId>
+<ticketId>-797601756276826570</ticketId>
+</properties>

data/XCFitDemo/FitNesseRoot/FitNesse/UserGuide/WritingAcceptanceTests/SpecialPages/content.txt

@@ -0,0 +1,44 @@
+The following pages are automatically included into other pages.  Some are included at the stop, others are included at the bottom.  Some may be included only into certain kinds of pages.  However, they all follow one identical rule.  A given page will be included only if it is a brother or uncle of the target page.
+
+Consider !-PageHeader-!.  !-PageHeader-! is included at the top of all of it's sibling pages.  If !-FitNesse-! did not have sub pages, this would make perfect sense.  The page named !-PageHeader-! would simply be included into every other page.  But !-FitNesse-! ''does'' have sub pages.  So the rule is that if a page includes !-PageHeader-! then the children of that page will include it as well.  This rule is recursive, so the childrens
+children also include !-PageHeader-! etc.
+
+Now imagine that you have a hierarchy that looks like this:
+ * Bob
+  * !-PageHeader-!
+  * Angela
+   * Alexis
+
+Bob is at the top level and there is no !-PageHeader-! at the top level.  So nothing is included into Bob.
+Angela has a sibling page named !-PageHeader-! so !-Bob.PageHeader-! is included into Angela.  And since Angela includes it, the children of Angela will include it too.  So Alexis will also include !-Bob.PageHeader-!.
+
+Clear?  Just remember brothers and uncles.
+
+
+!3 !-PageHeader-!
+Included at the top of a page.  Often used for common titles, or links.
+
+!3 !-PageFooter-!
+Included at the bottom of a page.  Used for copyrights, footers, and common links.
+
+!3 !-SetUp-!
+Included at the top of test pages only.  Used to initialize the test and supply Import tables.
+
+!3 !-TearDown-!
+Included at the bottom of test pages only.  Used to decommission resources used in a test.
+
+!3 !-SuiteSetUp-!
+Included at the top of a test page and before !-SetUp-!.  When a suite is run, this page will only be included once at the top of the suite.
+
+!3 !-SuiteTearDown-!
+Included at the bottom of a test page only, and after !-TearDown-!.  When a suite is run this page will be included only once at the end of the suite.
+
+!3 !-ScenarioLibrary-!
+These pages are intended for scenario tables.  They are included just after the !-SetUp-! in any ''SLIM'' test.  Unlike the other special pages, ''all'' brother and uncle !-ScenarioLibrary-! pages are included.  The oldest (grandest uncle) is included first.  The brother, if it exists, is included last.  This allows younger !-ScenarioLibrary-! pages to override older ones.
+
+!3 !-TemplateLibrary-!
+These pages act as a marker to find templates to show as available for insertion when editing a page. All children of a !-TemplateLibrary-! will be shown in the drop-down list of templates available for insertion. Unlike the other special pages, ''all'' brother and uncle !-TemplateLibrary-! pages are included.  The oldest (grandest uncle) is included first.  The brother, if it exists, is included last.  This allows younger !-TemplateLibrary-! pages to override older ones.
+
+
+!3 Suites.
+A special word about suites.  The !-SuiteSetUp-! and !-SuiteTearDown-! that are included in a suite run are the pages that are the nearest brothers or uncles of the ''Suite'' page.  If the suite has a deep hierarchy, and there are !-SuiteSetUp-! and/or !-SuiteTearDown-! pages below the suite page, they will not be included.