C# ITestContext.ResultsFor方法代码示例

        protected override void execute(IWebElement element, IDictionary<string, object> cellValues, IStep step, ITestContext context)
        {
            // TODO -- StoryTeller needs to pull this all inside the Cell
            if (!cellValues.ContainsKey(_cell.Key))
            {
                // already caught as a syntax error
                return;
            }

            var handler = ElementHandlers.FindHandler(element);
            var expectedValue = cellValues[_cell.Key];

            var matchingHandler = handler as IMatchingHandler ?? new BasicMatchingHandler(handler, context);

            if (matchingHandler.MatchesData(element, expectedValue))
            {
                context.IncrementRights();
            }
            else
            {
                context.ResultsFor(step).MarkFailure(_cell.Key);
                context.IncrementWrongs();
            }

            context.ResultsFor(step).SetActual(_cell.Key, handler.GetData(CurrentContext, element));
        }

        public void WriteResults(ITestContext context)
        {
            context.ResultsFor(_step).ForExceptionText(writeExceptionText);

            rows().Each(row => writeResultsRow(row, context));

            _headerRow.FirstChild().AddClass("left-cell");
        }

        public void WriteResults(ITestContext context)
        {
            // This code Dru.  If there's an exception in the results, call
            // back to the writeExceptionText(string) method to write in
            // the exception
            context.ResultsFor(_step).ForExceptionText(writeExceptionText);

            rows().Each(row => writeResultsRow(row, context));
        }

        public void Execute(IStep containerStep, ITestContext context)
        {
            var actualObjects = findTheObjects(containerStep, context);
            var actualRows = buildActualRows(actualObjects);
            var expectedRows = buildExpectedRows(context, containerStep);

            var matcher = new SetRowMatcher(expectedRows, actualRows, context);
            IList<SetRow> results = Ordered ? matcher.CompareOrdered() : matcher.Compare();

            markCounts(context, results);

            context.ResultsFor(containerStep).SetResult(results, _leafName);
        }

        public void WriteSetVerificationResults(SetVerification verification, ITestContext context)
        {
            if (verification.Ordered)
            {
                _headerRow.InsertFirst(new HtmlTag("th").Text("Order"));
            }

            var results = context.ResultsFor(_step);
            results.ForExceptionText(writeExceptionText);

            var rows = results.GetResult<IList<SetRow>>(_table.LeafName) ?? new List<SetRow>();
            // TODO -- order this the right way

            rows.Each(x =>
            {
                writeVerificationResultRow(x, context, verification.Ordered);
            });
        }

        public void WriteResults(ITestContext context)
        {
            write(new Results(this, context));

            var results = context.ResultsFor(_step);
            if (results.HasErrors())
            {
                AddClass(HtmlClasses.EXCEPTION);
                Next = new ExceptionTag(results.ExceptionText);
            }
            else
            {
                if (_sentence.IsFact)
                {
                    var success = (bool)results.GetActual(_sentence.ResultCell.Key);
                    var className = success ? HtmlClasses.PASS : HtmlClasses.FAIL;
                    AddClass(className);
                }
            }
        }

        private void writeVerificationResultRow(SetRow setRow, ITestContext context, bool ordered)
        {
            AddBodyRow(row =>
            {
                if (ordered)
                {
                    row.Cell(setRow.ActualOrder == 0 ? string.Empty : setRow.ActualOrder.ToString());
                }

                _table.Cells.Each(cell =>
                {
                    var display = context.GetDisplay(setRow.Values[cell.Key]);
                    row.Cell(display);
                });

                switch (setRow.Result)
                {
                    case SetMatch.Match:
                        row.AddClass(HtmlClasses.PASS);

                        break;

                    case SetMatch.Extra:
                        row.AddClass(HtmlClasses.FAIL);
                        var firstChild = row.FirstChild();
                        firstChild.Text("Extra:  " + firstChild.Text());
                        break;

                    case SetMatch.Missing:
                        row.AddClass(HtmlClasses.FAIL);
                        var tag = row.FirstChild();
                        tag.Text("Missing:  " + tag.Text());
                        break;

                    case SetMatch.OutOfOrder:
                        row.AddClass(HtmlClasses.FAIL);

                        string text = "Expected {0} but was {1}".ToFormat(setRow.ExpectedOrder, setRow.ActualOrder);
                        row.FirstChild().Text(text);
                        break;
                }

                row.FirstChild().AddClass("left-cell");
            });

            if (setRow.Step != null)
            {
                context.ResultsFor(setRow.Step).ForExceptionText(writeExceptionText);
            }
        }

        private void writeResultsRow(IStep step, ITestContext context)
        {
            AddBodyRow(row =>
            {
                StepResults results = context.ResultsFor(step);
                results.Collapse();

                _writer.DisplayCells.Each(cell =>
                {

                    var tag = new CellTag(cell, step);
                    tag.TagName("td");
                    row.Append(tag);

                    tag.WriteResults(results, context);
                });

                row.FirstChild().AddClass("left-cell");

                results.ForExceptionText(writeExceptionText);
            });
        }

 public void WriteResults(ITestContext context)
 {
     context.ResultsFor(_section).ForExceptionText(text => _body.Append(new ExceptionTag(text)));
 }

 public void WriteResults(ITestContext context)
 {
     context.ResultsFor(_step).ForExceptionText(text => Child(new ExceptionTag(text)));
 }

 public Results(SentenceTag tag, ITestContext context)
 {
     _tag = tag;
     _context = context;
     _results = _context.ResultsFor(tag._step);
     _step = tag._step;
 }

        private void writeResultsRow(IStep step, ITestContext context)
        {
            AddBodyRow(row =>
            {
                _table.Cells.Each(cell =>
                {
                    StepResults results = context.ResultsFor(step);
                    var tag = new CellTag(cell, _step);
                    tag.WriteResults(results, context);

                    // Ditto this line of code
                    results.ForExceptionText(writeExceptionText);

                    row.Cell().Child(tag);
                });
            });
        }