public void TestPrintingObject() { var builder = ParamsBuilder <IPrintParent> .New("PrintParent"); var testObject = builder.Build(); var testStream = new TextMessageWriter(); builder.WriteParams(testObject, testStream); Console.WriteLine(testStream.ToString()); Assert.That(testStream.ToString(), Is.EqualTo( @"PrintParent: ParentLevelInt: 120021 (From Default) Child1: When: ""Now"" (From Default) AnIntFromDefault: 110011 (From Default) AString: ""I came from IPrintParent"" (From Override on Child1) Deep: Deeper: ""I came from IPrintParent too"" (From Override on Child1) Derp: Deeper: ""I came from Derp"" (From Override on Child1.Derp) ParentLevelString: ""I'm on the parent"" (From Default) " )); }
public void ProvidesProperFailureMessage() { TextMessageWriter writer = new TextMessageWriter(); Matcher.Matches(BadValues[0]); Matcher.WriteMessageTo(writer); Assert.That(writer.ToString(), Is.StringContaining(Description)); Assert.That(writer.ToString(), Is.Not.StringContaining("<UNSET>")); }
public void ProvidesProperFailureMessage() { object badValue = BadValues[0]; string badString = badValue == null ? "null" : badValue.ToString(); TextMessageWriter writer = new TextMessageWriter(); Matcher.Matches(badValue); Matcher.WriteMessageTo(writer); Assert.That(writer.ToString(), new SubstringConstraint(Description)); Assert.That(writer.ToString(), new SubstringConstraint(badString)); Assert.That(writer.ToString(), new NotConstraint(new SubstringConstraint("<UNSET>"))); }
public void ProvidesProperFailureMessage() { if (Matcher != null) { // We are being called from an inhereting class object badValue = BadValues[0]; string badString = badValue == null ? "null" : badValue.ToString(); TextMessageWriter writer = new TextMessageWriter(); Matcher.Matches(badValue); Matcher.WriteMessageTo(writer); Ensure.That(writer.ToString(), new SubstringConstraint(Description)); Ensure.That(writer.ToString(), new SubstringConstraint(badString)); Ensure.That(writer.ToString(), new NotConstraint(new SubstringConstraint("<UNSET>"))); } }
public void ShouldIncludeAdditionalInformationFromFailedConstraint_Right() { var constraint = new AndConstraint(Is.Ordered, Is.EquivalentTo(new[] { 1, 2, 3 })); string expectedMsg = " Expected: collection ordered and equivalent to < 1, 2, 3 >" + Environment.NewLine + " But was: < 1, 2 >" + Environment.NewLine + " Missing (1): < 3 >" + Environment.NewLine; var constraintResult = constraint.ApplyTo(new[] { 1, 2 }); Assert.That(constraintResult.IsSuccess, Is.False); constraintResult.WriteMessageTo(messageWriter); Assert.That(messageWriter.ToString(), Is.EqualTo(expectedMsg)); }
public override string ToString() { MessageWriter writer = new TextMessageWriter(); WriteMessageTo(writer); return(writer.ToString()); }
private static void PerformAssertWithConstraint <TActual>(IResolveConstraint constraint, object actual, Func <string> getExceptionMessage = null, string message = null, object[] args = null) { using (var messageWitter = new TextMessageWriter()) { var resolveConstraint = constraint.Resolve(); TestExecutionContext.CurrentContext.IncrementAssertCount(); var result = actual is ActualValueDelegate <TActual>?resolveConstraint.ApplyTo <TActual>(actual as ActualValueDelegate <TActual>) : resolveConstraint.ApplyTo(actual); var expectedValue = result.Description; result.WriteActualValueTo(messageWitter); var actualValue = messageWitter.ToString(); if (!result.IsSuccess) { InconclusiveException exceptiopn = null; if (getExceptionMessage != null) { exceptiopn = new InconclusiveException(getExceptionMessage()); } else { using (var errorMessageWritter = new TextMessageWriter(message, args)) { result.WriteMessageTo(errorMessageWritter); exceptiopn = new InconclusiveException(errorMessageWritter.ToString()); } } LogHelper.LoggerForCurrentTest.Assume(FormatAssertFailMessage(getExceptionMessage, message, args), false, actual, expectedValue, actualValue, exceptiopn.ToString()); throw exceptiopn ?? new InconclusiveException($"Assume.That() failed.{Environment.NewLine} Expected {expectedValue}.{Environment.NewLine} Actual {actualValue}."); } LogHelper.LoggerForCurrentTest.Assume("Asserting expression -- success.", true, actual, expectedValue, actualValue); } }
public void TestConstraintResultMessageDisplaysMissingAndExtraElements() { List <string> expectedCollection = new List <string>() { "one", "two" }; List <string> actualCollection = new List <string>() { "three", "one" }; ConstraintResult cr = new CollectionEquivalentConstraint(expectedCollection).ApplyTo(actualCollection); TextMessageWriter writer = new TextMessageWriter(); cr.WriteMessageTo(writer); string expectedMsg = " Expected: equivalent to < \"one\", \"two\" >" + Environment.NewLine + " But was: < \"three\", \"one\" >" + Environment.NewLine + " Missing (1): < \"two\" >" + Environment.NewLine + " Extra (1): < \"three\" >" + Environment.NewLine; Assert.AreEqual(expectedMsg, writer.ToString()); }
public bool Expect(bool fatal, object actual, Constraint constraint, string message, params object[] args) { if (constraint.Matches(actual)) { ++countAssertions; return(true); } using (var writer = new TextMessageWriter(message, args)) { constraint.WriteMessageTo(writer); var error = new AssertionException(writer.ToString()); string text = string.Empty;; if ((message != null) && (message != string.Empty)) { if (args != null) { text = string.Format(message, args); } else { text = message; } } AddError(text, error); if (AlwaysFatal || fatal) { throw error; } return(false); } }
public void ProvidesProperDescription() { TextMessageWriter writer = new TextMessageWriter(); Matcher.WriteDescriptionTo(writer); Assert.That(writer.ToString(), Is.EqualTo(Description), null); }
public void ProvidesProperDescription() { TextMessageWriter writer = new TextMessageWriter(); theConstraint.WriteDescriptionTo(writer); Assert.AreEqual(expectedDescription, writer.ToString()); }
private static void IssueWarning(ConstraintResult result, string message = null, params object[] args) { MessageWriter writer = new TextMessageWriter(message, args); result.WriteMessageTo(writer); Assert.Warn(writer.ToString()); }
private void ReportFailure(ConstraintResult result, string message, params object[] args) { MessageWriter writer = new TextMessageWriter(message, args); result.WriteMessageTo(writer); ReportFailure(writer.ToString()); }
public void FailureMessageWithHashSetAndArray() { var hash = new HashSet <string>(new string[] { "presto", "abracadabra", "hocuspocus" }); var array = new string[] { "abracadabra", "presto", "hocusfocus" }; var constraint = new CollectionEquivalentConstraint(hash); Assert.False(constraint.Matches(array)); TextMessageWriter writer = new TextMessageWriter(); constraint.WriteMessageTo(writer); Assert.That(writer.ToString(), Is.EqualTo( " Expected: equivalent to < \"presto\", \"abracadabra\", \"hocuspocus\" >" + Environment.NewLine + " But was: < \"abracadabra\", \"presto\", \"hocusfocus\" >" + Environment.NewLine)); Console.WriteLine(writer.ToString()); }
public void Setup() { _textMessageWriter = new TextMessageWriter(); Console.SetOut(_textMessageWriter); _subject = new TestSuiteMessageLogger("test"); _suiteStartedMessage = "##teamcity[testSuiteStarted name='test']\r\n"; Assert.That(_textMessageWriter.ToString(), Is.EqualTo(_suiteStartedMessage)); }
public void Setup() { _textMessageWriter = new TextMessageWriter(); Console.SetOut(_textMessageWriter); _subject = new TestSuiteLogger(0, "Suite"); _suiteStartedMessage = " [TEST] Suite\r\n"; Assert.That(_textMessageWriter.ToString(), Is.EqualTo(_suiteStartedMessage)); }
private static void OutputFailedResultMessage(Constraint listComparerConstraint, [CallerMemberName] string memberName = "") { using (var messageWriter = new TextMessageWriter()) { listComparerConstraint.WriteMessageTo(messageWriter); Console.WriteLine("----- {0}", memberName); Console.WriteLine(messageWriter.ToString()); } }
public void SucceedsWithGoodValues(object value) { if (!theConstraint.Matches(value)) { MessageWriter writer = new TextMessageWriter(); theConstraint.WriteMessageTo(writer); Assert.Fail(writer.ToString()); } }
public void ProvidesProperDescription() { if (Matcher != null) { // We are being called from an inhereting class TextMessageWriter writer = new TextMessageWriter(); Matcher.WriteDescriptionTo(writer); Ensure.That(writer.ToString(), new EqualConstraint(Description), null); } }
public void ProvidesProperDescription() { if ( Matcher != null ) { // We are being called from an inhereting class TextMessageWriter writer = new TextMessageWriter(); Matcher.WriteDescriptionTo( writer ); Ensure.That( writer.ToString(), new EqualConstraint( Description ), null ); } }
private void AssertSuccess <T>(T actual) { var constraintResult = TheConstraint.ApplyTo(actual); if (!constraintResult.IsSuccess) { MessageWriter writer = new TextMessageWriter(); constraintResult.WriteMessageTo(writer); Assert.Fail(writer.ToString()); } }
public void HonorsIgnoreCase(IEnumerable expected, IEnumerable actual) { var constraint = new CollectionSupersetConstraint(expected).IgnoreCase; var constraintResult = constraint.ApplyTo(actual); if (!constraintResult.IsSuccess) { MessageWriter writer = new TextMessageWriter(); constraintResult.WriteMessageTo(writer); Assert.Fail(writer.ToString()); } }
public void SucceedsWithGoodValues(object value) { var constraintResult = theConstraint.ApplyTo(value); if (!constraintResult.IsSuccess) { MessageWriter writer = new TextMessageWriter(); constraintResult.WriteMessageTo(writer); Assert.Fail(writer.ToString()); } }
public void SucceedsWithNonVoidReturningFunction() { var constraintResult = TheConstraint.ApplyTo(TestDelegates.ThrowsInsteadOfReturns); if (!constraintResult.IsSuccess) { MessageWriter writer = new TextMessageWriter(); constraintResult.WriteMessageTo(writer); Assert.Fail(writer.ToString()); } }
public void SucceedsWithGoodValues(TExpected value) { var result = Constraint.ApplyTo(value); if (!result.IsSuccess) { MessageWriter writer = new TextMessageWriter(); result.WriteMessageTo(writer); Assert.Fail(writer.ToString()); } }
public void PropertyEqualToValueWithTolerance() { Constraint c = new EqualConstraint(105m).Within(0.1m); TextMessageWriter w = new TextMessageWriter(); c.WriteDescriptionTo(w); Assert.That(w.ToString(), Is.EqualTo("105m +/- 0.1m")); c = new PropertyConstraint("D", new EqualConstraint(105m).Within(0.1m)); w = new TextMessageWriter(); c.WriteDescriptionTo(w); Assert.That(w.ToString(), Is.EqualTo("property D equal to 105m +/- 0.1m")); }
public void FailsWithBadValues(object badActualValue, string actualMessage, string missingMessage) { var constraintResult = TheConstraint.ApplyTo(badActualValue); Assert.IsFalse(constraintResult.IsSuccess); TextMessageWriter writer = new TextMessageWriter(); constraintResult.WriteMessageTo(writer); Assert.That(writer.ToString(), Is.EqualTo( TextMessageWriter.Pfx_Expected + ExpectedDescription + Environment.NewLine + TextMessageWriter.Pfx_Actual + actualMessage + Environment.NewLine + " Missing items: " + missingMessage + Environment.NewLine)); }
public void ProvidesProperFailureMessage( [ValueSource("FailureData")] object badValue, [ValueSource("ActualValues")] string message) { theConstraint.Matches(badValue); TextMessageWriter writer = new TextMessageWriter(); theConstraint.WriteMessageTo(writer); Assert.AreEqual( TextMessageWriter.Pfx_Expected + expectedDescription + Environment.NewLine + TextMessageWriter.Pfx_Actual + message + Environment.NewLine, writer.ToString()); }
public void WriteHeader_ShouldOpenNewHeaderIfNothingElseHasBeenOpened() { var header = "test"; _subject.WriteHeader(header); Assert.That(_textMessageWriter.ToString(), Is.EqualTo(String.Format("##teamcity[blockOpened name='{0}']" + Environment.NewLine, header))); }
private static void PerformAssertWithConstraint <T>(IResolveConstraint constraint, object actual, Func <string> getExceptionMessage = null, string message = null, object[] args = null) { using (var messageWitter = new TextMessageWriter()) { var resolveConstraint = constraint.Resolve(); TestExecutionContext.CurrentContext.IncrementAssertCount(); var result = actual is ActualValueDelegate <T>?resolveConstraint.ApplyTo <T>(actual as ActualValueDelegate <T>) : resolveConstraint.ApplyTo(actual); var expectedValue = result.Description; result.WriteActualValueTo(messageWitter); var actualValue = messageWitter.ToString(); if (!result.IsSuccess) { if (IsSkipBug()) { TestExecutionContext.CurrentContext.CurrentResult.RecordAssertion(AssertionStatus.Warning, "Triaged test case failure", StackFilter.DefaultFilter.Filter(SystemEnvironmentFilter.Filter(Environment.StackTrace))); } else { TestExecutionContext.CurrentContext.CurrentResult.RecordAssertion(AssertionStatus.Failed, message, StackFilter.DefaultFilter.Filter(SystemEnvironmentFilter.Filter(Environment.StackTrace))); AssertionException exceptiopn = null; if (getExceptionMessage != null) { exceptiopn = new AssertionException(getExceptionMessage()); } else { using (var errorMessageWritter = new TextMessageWriter(message, args)) { result.WriteMessageTo(errorMessageWritter); exceptiopn = new AssertionException(errorMessageWritter.ToString()); } } LogHelper.LoggerForCurrentTest.Assert(FormatAssertFailMessage(getExceptionMessage, message, args), false, actual, expectedValue, actualValue, exceptiopn.ToString()); throw exceptiopn ?? new AssertionException($"Assert.That() failed.{Environment.NewLine} Expected {expectedValue}.{Environment.NewLine} Actual {actualValue}."); } } if (IsSkipBug() && result.IsSuccess) { TestExecutionContext.CurrentContext.CurrentResult.RecordAssertion(AssertionStatus.Failed, "Test Cases Marked as Bug, but passed.", StackFilter.DefaultFilter.Filter(SystemEnvironmentFilter.Filter(Environment.StackTrace))); LogHelper.LoggerForCurrentTest.Assert("Test Cases Marked as Bug, but passed.", false, actual, expectedValue, actualValue); } else { LogHelper.LoggerForCurrentTest.Assert("Asserting expression -- success.", true, actual, expectedValue, actualValue); } } }
public void FailsWithBadValues(object badValue, string message) { string NL = Env.NewLine; Assert.IsFalse(theConstraint.Matches(badValue)); TextMessageWriter writer = new TextMessageWriter(); theConstraint.WriteMessageTo(writer); Assert.That(writer.ToString(), Is.EqualTo( TextMessageWriter.Pfx_Expected + expectedDescription + NL + TextMessageWriter.Pfx_Actual + message + NL)); }
/// <summary> /// Wraps code containing a series of assertions, which should all /// be executed, even if they fail. Failed results are saved and /// reported at the end of the code block. /// </summary> /// <param name="testDelegate">A TestDelegate to be executed in Multiple Assertion mode.</param> public static void Multiple(TestDelegate testDelegate) { TestExecutionContext context = TestExecutionContext.CurrentContext; Guard.OperationValid(context != null, "Assert.Multiple called outside of a valid TestExecutionContext"); context.MultipleAssertLevel++; try { testDelegate(); } finally { context.MultipleAssertLevel--; } if (context.MultipleAssertLevel == 0) { int count = context.CurrentResult.AssertionResults.Count; if (count > 0) { var writer = new TextMessageWriter("Multiple Assert block had {0} failure(s).", count); int counter = 0; foreach (var assertion in context.CurrentResult.AssertionResults) writer.WriteLine(string.Format(" {0}) {1}", ++counter, assertion.Message)); throw new AssertionException(writer.ToString()); } } }
private static void ReportFailure(ConstraintResult result, string message, params object[] args) { MessageWriter writer = new TextMessageWriter(message, args); result.WriteMessageTo(writer); ReportFailure(writer.ToString()); }
public void ProvidesProperFailureMessage() { if ( Matcher != null ) { // We are being called from an inhereting class object badValue = BadValues[0]; string badString = badValue == null ? "null" : badValue.ToString(); TextMessageWriter writer = new TextMessageWriter(); Matcher.Matches( badValue ); Matcher.WriteMessageTo( writer ); Ensure.That( writer.ToString(), new SubstringConstraint( Description ) ); Ensure.That( writer.ToString(), new SubstringConstraint( badString ) ); Ensure.That( writer.ToString(), new NotConstraint( new SubstringConstraint( "<UNSET>" ) ) ); } }
public void FailureMessageWithHashSetAndArray() { var hash = new HashSet<string>(new string[] { "presto", "abracadabra", "hocuspocus" }); var array = new string[] { "abracadabra", "presto", "hocusfocus" }; var constraint = new CollectionEquivalentConstraint(hash); Assert.False(constraint.Matches(array)); TextMessageWriter writer = new TextMessageWriter(); constraint.WriteMessageTo(writer); Assert.That(writer.ToString(), Is.EqualTo( " Expected: equivalent to < \"presto\", \"abracadabra\", \"hocuspocus\" >" + Environment.NewLine + " But was: < \"abracadabra\", \"presto\", \"hocusfocus\" >" + Environment.NewLine)); Console.WriteLine(writer.ToString()); }
public void ProvidesProperDescription() { TextMessageWriter writer = new TextMessageWriter(); Matcher.WriteDescriptionTo(writer); Assert.That(writer.ToString(), new EqualConstraint(Description), null); }