public void TearDown()
{
_output = null;
_mockOutput = null;
_textWriter.Flush();
_textWriter = null;
}
public void ProvidesProperDescription()
{
TextMessageWriter writer = new TextMessageWriter();
theConstraint.WriteDescriptionTo(writer);
Assert.AreEqual(expectedDescription, writer.ToString());
}
public void SetUp()
{
_output = new ConsoleOutput();
_mockOutput = new MockOutput();
_textWriter = new TextMessageWriter();
Console.SetOut(_textWriter);
}
public void ProvidesProperDescription()
{
TextMessageWriter writer = new TextMessageWriter();
Matcher.WriteDescriptionTo(writer);
Assert.That(writer.ToString(), Is.EqualTo(Description), null);
}
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());
}
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 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 Setup()
{
_textMessageWriter = new TextMessageWriter();
Console.SetOut(_textMessageWriter);
ConsoleMessageLogger.WindowWidth = 40;
}
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 SetUp()
{
TheConstraint = new AndConstraint(new GreaterThanConstraint(40), new LessThanConstraint(50));
ExpectedDescription = "greater than 40 and less than 50";
StringRepresentation = "<and <greaterthan 40> <lessthan 50>>";
messageWriter = new TextMessageWriter();
}
private void compareWithConfiguration(IEnumerable <CultureCurrencyInfo> fromGlobalization)
{
var writer = new TextMessageWriter();
using (var initializer = new EmbeddedXmlInitializer())
{
foreach (var global in fromGlobalization)
{
CurrencyInfo notGlobal = initializer.Get(global.Info.Code);
var comparer = new CurrencyInfoComparer(global.Culture);
if (!comparer.Equals(global.Info, notGlobal))
{
CanonicalCultureAttribute attr;
Enumeration.TryGetAttribute(notGlobal.Code, out attr);
CultureInfo canonical = attr != null?attr.Culture() : null;
if (canonical != null && !canonical.Name.Equals(global.Culture.Name))
{
displayCultureInformation(writer, global, notGlobal);
}
else
{
var differences = comparer.ExtendedEquals(global.Info, notGlobal);
displayDifferences(global, notGlobal, differences, writer);
}
}
}
}
}
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)
"
));
}
private void ReportFailure(ConstraintResult result, string message, params object[] args)
{
MessageWriter writer = new TextMessageWriter(message, args);
result.WriteMessageTo(writer);
ReportFailure(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));
}
public void SucceedsWithGoodValues(object value)
{
if (!theConstraint.Matches(value))
{
MessageWriter writer = new TextMessageWriter();
theConstraint.WriteMessageTo(writer);
Assert.Fail(writer.ToString());
}
}
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 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 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 );
}
}
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(TExpected value)
{
var result = Constraint.ApplyTo(value);
if (!result.IsSuccess)
{
MessageWriter writer = new TextMessageWriter();
result.WriteMessageTo(writer);
Assert.Fail(writer.ToString());
}
}
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 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 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 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 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"));
}
/// <summary>
/// this is not a real test, is used only to see the log that
/// a failing assertion does.
/// </summary>
public void TestBasicCompareFalseVerifyLog()
{
AnEntity entity1 = AnEntity.Create(10, "test", 100);
AnEntity entity2 = AnEntity.Create(10, "test", 110);
ObjectEqualConstraint c = new ObjectEqualConstraint(entity2);
c.Matches(entity1);
MessageWriter mw = new TextMessageWriter();
c.WriteDescriptionTo(mw);
Assert.That(entity1, DotNetMarche.TestHelpers.SyntaxHelpers.Is.ObjectEqual(entity2));
}
private static void displayDifference(TextMessageWriter writer, KeyValuePair <string, Pair> difference)
{
writer.Write("\t");
writer.Write(difference.Key);
writer.Write(" --> ");
writer.Write("globalization: ");
writer.WriteExpectedValue(difference.Value.First);
writer.Write("\t");
writer.Write("configuration: ");
writer.WriteActualValue(difference.Value.Second);
writer.WriteLine();
}
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>")));
}
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 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 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>" ) ) );
}
}
/// <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());
}
}
}
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());
}
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 ProvidesProperDescription()
{
TextMessageWriter writer = new TextMessageWriter();
theConstraint.WriteDescriptionTo(writer);
Assert.AreEqual(expectedDescription, writer.ToString());
}
public void SetUp()
{
writer = new TextMessageWriter();
}
public void ProvidesProperDescription()
{
TextMessageWriter writer = new TextMessageWriter();
Matcher.WriteDescriptionTo(writer);
Assert.That(writer.ToString(), new EqualConstraint(Description), null);
}
protected override void SetUp()
{
writer = new TextMessageWriter();
}
