public override void Verify(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder) { CommandCallList childCommands = commandCall.Children; childCommands.SetUp(evaluator, resultRecorder); childCommands.Execute(evaluator, resultRecorder); childCommands.Verify(evaluator, resultRecorder); String expression = commandCall.Expression; Object result = evaluator.Evaluate(expression); if (result != null && result is Boolean) { if ((Boolean) result) { ProcessTrueResult(commandCall, resultRecorder); } else { ProcessFalseResult(commandCall, resultRecorder); } } else { throw new InvalidExpressionException("Expression '" + expression + "' did not produce a boolean result (needed for assertTrue)."); } }
public override void Execute(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder) { try { m_command.Execute(commandCall, evaluator, resultRecorder); } catch (Exception e) { resultRecorder.Error(e); AnnounceThrowableCaught(commandCall.Element, e, commandCall.Expression); } }
public override void Execute(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder) { try { m_command.Execute(commandCall, evaluator, resultRecorder); } catch (Exception e) { resultRecorder.Record(Result.Exception); OnExceptionCaught(commandCall.Element, e, commandCall.Expression); } }
public override void Verify(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder) { try { m_command.Verify(commandCall, evaluator, resultRecorder); } catch (Exception e) { resultRecorder.Record(Result.Exception); AnnounceThrowableCaught(commandCall.Element, e, commandCall.Expression); } }
public override void Execute(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder) { Check.IsFalse(commandCall.HasChildCommands, "Nesting commands inside a 'run' is not supported"); var element = commandCall.Element; var href = element.GetAttributeValue("href"); Check.NotNull(href, "The 'href' attribute must be set for an element containing concordion:run"); var runnerType = commandCall.Expression; var expression = element.GetAttributeValue("params", "concordion"); if (expression != null) { evaluator.Evaluate(expression); } try { IRunner concordionRunner; Runners.TryGetValue(runnerType, out concordionRunner); // TODO - re-check this. Check.NotNull(concordionRunner, "The runner '" + runnerType + "' cannot be found. " + "Choices: (1) Use 'concordion' as your runner (2) Ensure that the 'concordion.runner." + runnerType + "' System property is set to a name of an IRunner implementation " + "(3) Specify an assembly fully qualified class name of an IRunner implementation"); var result = concordionRunner.Execute(evaluator.Fixture, commandCall.Resource, href).Result; if (result == Result.Success) { resultRecorder.Success(); AnnounceSuccess(element); } else if (result == Result.Ignored) { resultRecorder.Ignore(); AnnounceIgnored(element); } else { resultRecorder.Failure(string.Format("test {0} failed", href), commandCall.Element.ToXml()); AnnounceFailure(element); } } catch (Exception e) { resultRecorder.Error(e); AnnounceError(e, element, expression); } }
public void Execute(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder) { IExecuteStrategy strategy; if (commandCall.Element.IsNamed("table")) { strategy = new TableExecuteStrategy(); } else { strategy = new DefaultExecuteStrategy(); } strategy.Execute(commandCall, evaluator, resultRecorder); }
public void Verify(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder) { var pattern = new Regex("(#.+?) *: *(.+)"); var matcher = pattern.Match(commandCall.Expression); if (!matcher.Success) { throw new InvalidOperationException("The expression for a \"verifyRows\" should be of the form: #var : collectionExpr"); } var loopVariableName = matcher.Groups[1].Value; var iterableExpression = matcher.Groups[2].Value; var obj = evaluator.Evaluate(iterableExpression); Check.NotNull(obj, "Expression returned null (should be an IEnumerable)."); Check.IsTrue(obj is IEnumerable, obj.GetType() + " is not IEnumerable"); Check.IsTrue(!(obj is IDictionary), obj.GetType() + " does not have a predictable iteration order"); var iterable = (IEnumerable)obj; var tableSupport = new TableSupport(commandCall); var detailRows = tableSupport.GetDetailRows(); AnnounceExpressionEvaluated(commandCall.Element); int index = 0; foreach (var loopVar in iterable) { evaluator.SetVariable(loopVariableName, loopVar); Row detailRow; if (detailRows.Count > index) { detailRow = detailRows[index]; } else { detailRow = tableSupport.AddDetailRow(); AnnounceSurplusRow(detailRow.RowElement); } tableSupport.CopyCommandCallsTo(detailRow); commandCall.Children.Verify(evaluator, resultRecorder); index++; } for (; index < detailRows.Count; index++) { Row detailRow = detailRows[index]; resultRecorder.Record(Result.Failure); AnnounceMissingRow(detailRow.RowElement); } }
public override void Verify(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder) { object savedTextValue = evaluator.GetVariable(TEXT_VARIABLE); object savedHrefValue = evaluator.GetVariable(HREF_VARIABLE); try { evaluator.SetVariable(TEXT_VARIABLE, commandCall.Element.Text); evaluator.SetVariable(HREF_VARIABLE, getHref(commandCall.Element)); m_command.Verify(commandCall, evaluator, resultRecorder); } finally { evaluator.SetVariable(TEXT_VARIABLE, savedTextValue); evaluator.SetVariable(HREF_VARIABLE, savedHrefValue); } }
private void AddToTestResults(IResultSummary singleResult, IResultRecorder resultSummary) { if (resultSummary == null) return; if (singleResult.HasExceptions) { resultSummary.Record(Result.Exception); } else if (singleResult.HasFailures) { resultSummary.Record(Result.Failure); } else { resultSummary.Record(Result.Success); } }
public void Execute(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder) { increaseLevel(evaluator); ListSupport listSupport = new ListSupport(commandCall); foreach (ListEntry listEntry in listSupport.GetListEntries()) { commandCall.Element = listEntry.Element; if (listEntry.IsItem) { commandCall.Execute(evaluator, resultRecorder); } if (listEntry.IsList) { Execute(commandCall, evaluator, resultRecorder); } } decreaseLevel(evaluator); }
public void Verify(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder) { Check.IsFalse(commandCall.HasChildCommands, "Nesting commands inside an 'echo' is not supported"); Object result = evaluator.Evaluate(commandCall.Expression); Element element = commandCall.Element; if (result != null) { element.AppendText(result.ToString()); } else { Element child = new Element("em"); child.AppendText("null"); element.AppendChild(child); } }
public void Verify(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder) { Check.IsFalse(commandCall.HasChildCommands, "Nesting commands inside an 'assertEquals' is not supported"); Element element = commandCall.Element; object actual = evaluator.Evaluate(commandCall.Expression); string expected = element.Text; if (m_comparer.Compare(actual, expected) == 0) { resultRecorder.Record(Result.Success); OnSuccessReported(element); } else { resultRecorder.Record(Result.Failure); OnFailureReported(element, actual, expected); } }
public override void Verify(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder) { Check.IsFalse(commandCall.HasChildCommands, "Nesting commands inside an 'assertEquals' is not supported"); Element element = commandCall.Element; object actual = evaluator.Evaluate(commandCall.Expression); string expected = element.Text; if (this.m_Comparer.Compare(actual, expected) == 0) { resultRecorder.Success(); AnnounceSuccess(element); } else { resultRecorder.Failure(string.Format("expected {0} but was {1}", expected, actual), element.ToXml()); AnnounceFailure(element, expected, actual); } }
protected override void ProcessTrueResult(CommandCall commandCall, IResultRecorder resultRecorder) { resultRecorder.Record(Result.Success); AnnounceSuccess(commandCall.Element); }
public void Verify(IEvaluator evaluator, IResultRecorder resultRecorder) { Command.Verify(this, evaluator, resultRecorder); }
public abstract void Verify(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder);
public void Execute(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder) { OnSpecificationCommandProcessing(commandCall.Resource, commandCall.Element); commandCall.Children.ProcessSequentially(evaluator, resultRecorder); OnSpecificationCommandProcessed(commandCall.Resource, commandCall.Element); }
public void Verify(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder) { throw new InvalidOperationException("Unexpected call to SpecificationCommand's Verify() method. Only the Execute() method should be called."); }
public void Setup(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder) { }
protected abstract void ProcessTrueResult(CommandCall commandCall, IResultRecorder resultRecorder);
public virtual void Verify(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder) { }
public void Execute(IEvaluator evaluator, IResultRecorder resultRecorder) { Command.Execute(this, evaluator, resultRecorder); }
protected override void ProcessFalseResult(CommandCall commandCall, IResultRecorder resultRecorder) { resultRecorder.Record(Result.Failure); string expected = commandCall.Element.Text; AnnounceFailure(commandCall.Element, expected, "== false"); }
public void Setup(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder) { Check.IsFalse(commandCall.HasChildCommands, "Nesting commands inside a 'set' is not supported"); evaluator.SetVariable(commandCall.Expression, commandCall.Element.Text); }
public void SetUp(IEvaluator evaluator, IResultRecorder resultRecorder) { Command.Setup(this, evaluator, resultRecorder); }
public void Execute(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder) { this.LogWriter.WriteLine(commandCall.Element.Text); }
private void AddToTestResults(IResultSummary singleResult, IResultRecorder resultSummary) { if (resultSummary == null) return; if (singleResult.HasExceptions) { resultSummary.AddResultDetails(singleResult.ErrorDetails); } else if (singleResult.HasFailures) { resultSummary.AddResultDetails(singleResult.FailureDetails); } else { resultSummary.Success(); } }
public void Process(IEvaluator evaluator, IResultRecorder resultRecorder) { RootCommandNode.Execute(evaluator, resultRecorder); }
public abstract void Execute(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder);
public override void Execute(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder) { AnnounceBeforeProcessingEvent(commandCall.Resource, commandCall.Element); commandCall.Children.ProcessSequentially(evaluator, resultRecorder); AnnounceAfterProcessingEvent(commandCall.Resource, commandCall.Element); }
public void Execute(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder) { }
virtual public void Execute(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder) { }
virtual public void Verify(CommandCall commandCall, IEvaluator evaluator, IResultRecorder resultRecorder) { }