public override void DoRow(Parse row) {
			hadRowOperation = false;
			base.DoRow(row);
			if (!hadRowOperation) {
				clean();
			}
		}

 public void testIterating()
 {
     Parse p = new Parse("leader<table><tr><td>one</td><td>two</td><td>three</td></tr></table>trailer");
     Assert.AreEqual("one", p.parts.parts.body);
     Assert.AreEqual("two", p.parts.parts.more.body);
     Assert.AreEqual("three", p.parts.parts.more.more.body);
 }

 public void DoCheckOperation(Parse expectedValue, CellRange cells)
 {
     CellOperation.Check(GetTargetObject(),
                                 new CellRange(MethodCells(cells)),
                                 new CellRange(ParameterCells(cells)),
                                 expectedValue);
 }

 public override void DoRows(Parse theRows) {
     if (theRows == null) throw new TableStructureException("No header row.");
     ExamineTableStructure(theRows.Parts);
     if (expectedCount == 0) return;
     myValues = new ValueArray(RepeatString);
     base.DoRows(theRows.More);
 }

 public static Parse TestResult(Parse theTest)
 {
     var story = new StoryTest(theTest);
     story.writer = story.SaveTestResult;
     story.Execute();
     return story.resultTables;
 }

 private void CheckRowSize(Parse theCells) {
     int expectedSize = myParameterCount + expectedCount + 1;
     if (theCells.Size < expectedSize ||
         (!IHaveNoteColumns && theCells.Size != expectedSize)) {
         throw new RowWidthException(expectedSize);
     }
 }

 private Parse AddRow(Parse lastRow, DataRow dr, bool markAsError, String desc)
 {
     Parse newRow = new Parse("tr", null, null, null);
     lastRow.More = newRow;
     lastRow = newRow;
     try
     {
         Parse firstCell = new Parse("td",
                 GetStringValue(dr, columnNames[0]), null, null);
         newRow.Parts = firstCell;
         if (markAsError)
         {
             firstCell.AddToBody(Fixture.Gray(desc));
             this.Wrong(firstCell);
         }
         for (int i = 1; i < columnNames.Length; i++)
         {
             Parse nextCell = new Parse("td",
                     GetStringValue(dr, columnNames[i]), null, null);
             firstCell.More = nextCell;
             firstCell = nextCell;
         }
     }
     catch (Exception e)
     {
         this.Exception(newRow, e);
     }
     return lastRow;
 }

 public ParseTree(Parse theParse) {
     tree = new ListTree(GetTitle(theParse));
     for (Parse child = Root(theParse).Parts; child != null; child = child.More) {
         tree.AddChild(new ParseTree(child));
     }
     myHashCode = theParse.ToString().GetHashCode();
 }

 static Parse GetCellForColumn(Parse row, int col)
 {
     Parse cell = row.Parts;
     for (int i = 0; i < col; i++)
         cell = cell.More;
     return cell;
 }

        public String ResultingHTML()
        {
            Parse table = new Parse(OriginalHTML);
            Parse row = table.at(0, Row - 1);
            Parse cell = row.at(0, Column - 1);

            if (OverwriteCellBody != null) cell.body = OverwriteCellBody;
            if (AddToCellBody != null) cell.addToBody(AddToCellBody);

            if (OverwriteCellTag != null) cell.tag = OverwriteCellTag;
            if (OverwriteEndCellTag != null) cell.end = OverwriteEndCellTag;
            if (AddToCellTag != null) cell.addToTag(stripDelimiters(AddToCellTag));

            if (OverwriteRowTag != null) row.tag = OverwriteRowTag;
            if (OverwriteEndRowTag != null) row.end = OverwriteEndRowTag;
            if (AddToRowTag != null) row.addToTag(stripDelimiters(AddToRowTag));

            if (OverwriteTableTag != null) table.tag = OverwriteTableTag;
            if (OverwriteEndTableTag != null) table.end = OverwriteEndTableTag;
            if (AddToTableTag != null) table.addToTag(stripDelimiters(AddToTableTag));

            if (AddCellFollowing != null) addParse(cell, AddCellFollowing, new String[] {"td"});
            if (RemoveFollowingCell != null) removeParse(cell);

            if (AddRowFollowing != null) addParse(row, AddRowFollowing, new String[] {"tr", "td"});
            if (RemoveFollowingRow != null) removeParse(row);

            if (AddTableFollowing != null) addParse(table, AddTableFollowing, new String[] {"table", "tr", "td"});

            return GenerateOutput(table);
        }

 public static Parse MakeTables(params object[] theRows) {
     Parse tables = null;
     for (int i = theRows.Length-1; i >=0; i--) {
         tables = new Parse("table", null, (Parse)theRows[i], tables);
     }
     return tables;
 }

 public static Parse MakeCells(params object[] theContents) {
     Parse cells = null;
     for (int i = theContents.Length-1; i >=0; i--) {
         cells = new Parse("td", theContents[i].ToString(), null, cells);
     }
     return cells;
 }

 public static Parse MakeRows(params object[] theCells) {
     Parse rows = null;
     for (int i = theCells.Length-1; i >=0; i--) {
         rows = new Parse("tr", null, (Parse)theCells[i], rows);
     }
     return rows;
 }

 public override void DoRow(Parse row)
 {
     FitRow fRow = new FitRow(row);
     TableHandler.ProcessRow(fRow);
     
     HandleRowResult(ref row);
 }

 public void DoCheckOperation(Parse expectedValue, CellRange cells)
 {
     CellOperation.Check(GetTargetObject(),
                                 MethodRowSelector.SelectMethodCells(cells),
                                 MethodRowSelector.SelectParameterCells(cells),
                                 expectedValue);
 }

 public override void DoTable(Parse table)
 {
     var rows = table.Parts.More;
     if (rows == null) throw new TableStructureException("Header row missing.");
     myHeaderRow = rows;
     CompareRows(table, 1);
 }

 public void testRecursing()
 {
     Parse p = new Parse("leader<table><TR><Td>body</tD></TR></table>trailer");
     Assert.AreEqual(null, p.body);
     Assert.AreEqual(null, p.parts.body);
     Assert.AreEqual("body", p.parts.parts.body);
 }

 public override void DoTable(Parse theTable)
 {
     if (Args.Length > 0) {
         string behavior = Args[0].Trim().ToLower();
         Processor.Configuration.GetItem<Settings>().Behavior = behavior;
     }
 }

        public override void DoRow(Parse theRow)
        {
            try {
                CheckRowSize(theRow.Parts);

                for (int j = 0; j < expectedCount; j++) {
                    var memberCells = new List<Parse> { headerCells.At(j) };
                    foreach (Parse cell in methodSuffixCells.Cells) memberCells.Add(cell);

                    Parse expectedCell = theRow.Parts.At(myParameterCount + j + 1);

                    try {
                        CellOperation.Check(GetTargetObject(), new CellRange(memberCells),
                                            myValues.GetCells(new CellRange(theRow.Parts, myParameterCount).Cells),
                                            expectedCell);
                    }
                    catch (MemberMissingException e) {
                        TestStatus.MarkException(headerCells.At(j), e);
                        TestStatus.MarkIgnore(expectedCell);
                    }
                    catch (IgnoredException) {
                        TestStatus.MarkIgnore(expectedCell);
                    }
                    catch (Exception e) {
                        TestStatus.MarkException(expectedCell, e);
                    }
                }
            }
            catch (Exception e) {
                TestStatus.MarkException(theRow.Parts, e);
            }
        }

		private void RunRow(Parse row) {
			Parse cell = row.Parts;
			//first set input params
            for (int col = 0; col < columnAccessors.Length; col++)
            {
                Accessor accessor = columnAccessors[col];
                ICellHandler cellHandler = CellOperation.GetHandler(this, cell, accessor.ParameterType);
                if (!isOutputColumn[col])
                {
                    cellHandler.HandleInput(this, cell, accessor);
                }
                cell = cell.More;
            }
            command.ExecuteNonQuery();
			cell = row.Parts;
			//next evaluate output params
            for (int col=0; col<columnAccessors.Length; col++)
            {
			    Accessor accessor=columnAccessors[col];
                ICellHandler cellHandler = CellOperation.GetHandler(this,cell, accessor.ParameterType);
				if (isOutputColumn[col]) {
					cellHandler.HandleCheck(this, cell, accessor);
				}
				cell = cell.More;
			}
		}