public ValueAssertionResult AssertValue(string actual)
{
return(ValueAssertionResult.Create(
actual.Contains_NullAware(expected),
HarmonizeLineCount(
actual.ToValueString(),
ComposeLog.Expected($"contains {expected.ToValueString()}"))));
}
public ValueAssertionResult AssertValue(string actual)
{
return(ValueAssertionResult.Create(
string.Equals(actual, expected),
HarmonizeLineCount(
actual.ToValueString(),
ComposeLog.Expected(expected.ToValueString()))));
}
public ValueAssertionResult AssertValue(string actual)
{
return(ValueAssertionResult.Create(
actual?.Length == expected,
HarmonizeLineCount(
$"{actual.ToValueString()}[{actual?.Length ?? 0}]",
ComposeLog.Expected($"length {expected}"))));
}
public ValueAssertionResult AssertValue(string actual)
{
return(ValueAssertionResult.Create(
actual.EndsWith_NullAware(expectedEnd),
HarmonizeLineCount(
actual.ToValueString(),
$"(expected: ends with {expectedEnd.ToValueString()})")));
}
public ValueAssertionResult AssertValue(string actual)
{
return(ValueAssertionResult.Create(
actual != string.Empty,
HarmonizeLineCount(
actual.ToValueString(),
ComposeLog.Expected("not empty"))));
}
public ValueAssertionResult AssertValue(string actual)
{
return(ValueAssertionResult.Create(
!actual.StartsWith(expected),
HarmonizeLineCount(
actual.ToValueString(),
ComposeLog.Expected($"doesn't start with '{expected}'"))));
}
public void WithEmptyString_ShouldReturnSuccess()
{
IsEmptyAssertion assertion = IsEmptyAssertion();
ValueAssertionResult result = assertion.AssertValue("");
Assert.IsTrue(result.succeeded);
Assert.AreEqual("''", result.actualValueString);
Assert.AreEqual(ComposeLog.Expected("empty string"), result.expectationString);
}
public void OnFalse_ShouldFail()
{
var assertion = new IsTrueAssertion();
ValueAssertionResult result = assertion.AssertValue(false);
Assert.AreEqual("False", result.actualValueString);
Assert.AreEqual(ComposeLog.Expected("True"), result.expectationString);
Assert.IsFalse(result.succeeded);
}
public void WithEmptyEnumerable_ShouldReturnFailure()
{
IsNotEmptyAssertion <string> assertion = IsNotEmptyAssertion();
ValueAssertionResult result = assertion.AssertValue(new string[0]);
Assert.AreEqual("<empty>", result.actualValueString);
Assert.AreEqual(ComposeLog.Expected("not empty"), result.expectationString);
Assert.IsFalse(result.succeeded);
}
public void OnEqualsStringy_WithNull_ShouldReturnFailure()
{
EqualAssertion assertion = EqualAssertion("Stringy");
ValueAssertionResult result = assertion.AssertValue(null);
Assert.AreEqual("null", result.actualValueString);
Assert.AreEqual(ComposeLog.Expected("'Stringy'"), result.expectationString);
Assert.IsFalse(result.succeeded);
}
public void OnEqualsNull_WithNull_ShouldReturnSuccess()
{
EqualAssertion assertion = EqualAssertion(null);
ValueAssertionResult result = assertion.AssertValue(null);
Assert.AreEqual("null", result.actualValueString);
Assert.AreEqual(ComposeLog.Expected("null"), result.expectationString);
Assert.IsTrue(result.succeeded);
}
public void Assert_WithNull_ShouldReturnSuccess()
{
IsNullAssertion <string> assertion = CreateStringIsNullAssertion();
ValueAssertionResult result = assertion.AssertValue(null);
Assert.IsTrue(result.succeeded);
Assert.AreEqual("null", result.actualValueString);
Assert.AreEqual("(expected: null)", result.expectationString);
}
public void Assert_WithString_ShouldReturnFailure()
{
IsNullAssertion <string> assertion = CreateStringIsNullAssertion();
ValueAssertionResult result = assertion.AssertValue("String");
Assert.IsFalse(result.succeeded);
Assert.AreEqual("'String'", result.actualValueString);
Assert.AreEqual("(expected: null)", result.expectationString);
}
public void Assert_WithAnyString_ShouldReturnSuccess()
{
IsNotNullAssertion <string> assertion = IsNotNullAssertion <string>();
ValueAssertionResult result = assertion.AssertValue("AnyString");
Assert.IsTrue(result.succeeded);
Assert.AreEqual("'AnyString'", result.actualValueString);
Assert.AreEqual("(expected: not null)", result.expectationString);
}
public void Assert_WithNull_ShouldReturnFailure()
{
IsNotNullAssertion <string> assertion = IsNotNullAssertion <string>();
ValueAssertionResult result = assertion.AssertValue(null);
Assert.IsFalse(result.succeeded);
Assert.AreEqual("null", result.actualValueString);
Assert.AreEqual("(expected: not null)", result.expectationString);
}
public void OnHasNoneWhichIsNull_WithNull_ShouldReturnSuccess()
{
HasNoneAssertion <string> assertion = HasNoneAssertion(s => s.IsNull());
ValueAssertionResult result = assertion.AssertValue(null);
result.ExAssert(r => r.Member(x => x.succeeded).IsTrue()
.Member(x => x.actualValueString).IsEqualTo("null")
.Member(x => x.expectationString).IsEqualTo(ComposeLog.Expected("0 matches")));
}
public void WithEnumerableHavingOneString_ShouldReturnSuccess()
{
IsNotEmptyAssertion <string> assertion = IsNotEmptyAssertion();
ValueAssertionResult result = assertion.AssertValue(new[] { "Stringy" });
Assert.AreEqual("['Stringy']", result.actualValueString);
Assert.AreEqual(ComposeLog.Expected("not empty"), result.expectationString);
Assert.IsTrue(result.succeeded);
}
public void Assert_OnEquals12_With12_ShouldReturnSuccess()
{
EqualAssertion <int> assertion = EqualAssertion <int>(12);
ValueAssertionResult result = assertion.AssertValue(12);
Assert.IsTrue(result.succeeded);
Assert.AreEqual("12", result.actualValueString);
Assert.AreEqual(ComposeLog.Expected("12"), result.expectationString);
}
public void OnEqualsStringy_WithStringy_ShouldReturnSuccess()
{
EqualAssertion assertion = EqualAssertion("Stringy");
ValueAssertionResult result = assertion.AssertValue("Stringy");
Assert.AreEqual("'Stringy'", result.actualValueString);
Assert.AreEqual(ComposeLog.Expected("'Stringy'"), result.expectationString);
Assert.IsTrue(result.succeeded);
}
public void Assert_OnEquals12_With25_ShouldReturnFailure()
{
EqualAssertion <int> assertion = EqualAssertion(12);
ValueAssertionResult result = assertion.AssertValue(25);
Assert.IsFalse(result.succeeded);
Assert.AreEqual("25", result.actualValueString);
Assert.AreEqual(ComposeLog.Expected("12"), result.expectationString);
}
public void WithNull_ShouldReturnFailure()
{
IsEmptyAssertion assertion = IsEmptyAssertion();
ValueAssertionResult result = assertion.AssertValue(null);
Assert.IsFalse(result.succeeded);
Assert.AreEqual("null", result.actualValueString);
Assert.AreEqual(ComposeLog.Expected("empty string"), result.expectationString);
}
public void WithEmptyEnumerable_ShouldReturnSuccess()
{
IsEmptyAssertion <string> assertion = IsEmptyAssertion <string>();
ValueAssertionResult result = assertion.AssertValue(new string[0]);
Assert.IsTrue(result.succeeded);
Assert.AreEqual("<empty>", result.actualValueString);
Assert.AreEqual(ComposeLog.Expected("empty enumerable"), result.expectationString);
}
public ValueAssertionResult AssertValue(T?actual)
{
if (actual.HasValue)
{
return(assertion.AssertValue(actual.Value));
}
ValueAssertionResult innerResult = assertion.AssertValue(default(T));
return(new ValueAssertionResult(false, actual.ToValueString(), innerResult.expectationString));
}
public void OnHasAnyWhichIsNull_WithNull_ShouldReturnFailure()
{
HasAnyAssertion <string> assertion = HasAnyAssertion(s => s.IsNull());
ValueAssertionResult result = assertion.AssertValue(null);
Assert.IsFalse(result.succeeded);
Assert.AreEqual("null", result.actualValueString);
Assert.AreEqual(ComposeLog.Expected("at least 1 match"),
result.expectationString);
}
public void OnHasNoneWhichIsNull_WithArrayHavingStringy_ShouldReturnSuccess()
{
HasNoneAssertion <string> assertion = HasNoneAssertion(x => x.IsNull());
ValueAssertionResult result = assertion.AssertValue(new[] { "Stringy" });
result.ExAssert(r => r.Member(x => x.succeeded).IsTrue()
.Member(x => x.actualValueString).IsEqualTo("<0 matches>".NewLine()
.Add("'Stringy'"))
.Member(x => x.expectationString).IsEqualTo(ComposeLog.Expected("0 matches").NewLine()
.Add(ComposeLog.Expected("null"))));
}
public void OnHasNoneWhichIsNull_WithArrayHavingNull_ShouldReturnFailure()
{
HasNoneAssertion <string> assertion = HasNoneAssertion(s => s.IsNull());
ValueAssertionResult result = assertion.AssertValue(new string[] { null });
result.ExAssert(r => r.Member(x => x.succeeded).IsFalse()
.Member(x => x.actualValueString).IsEqualTo("<1 match>".NewLine()
.Add("null"))
.Member(x => x.expectationString).IsEqualTo(ComposeLog.Expected("0 matches").NewLine()
.Add(ComposeLog.Expected("null"))));
}
public void OnHasAnyWhichIsNull_WithArrayHavingNull_ShouldReturnSuccess()
{
HasAnyAssertion <string> assertion = HasAnyAssertion(s => s.IsNull());
ValueAssertionResult result = assertion.AssertValue(new string[] { null });
Assert.IsTrue(result.succeeded);
Assert.AreEqual("<1 match>".NewLine()
.Add("null"),
result.actualValueString);
Assert.AreEqual(ComposeLog.Expected("at least 1 match").NewLine()
.Add(ComposeLog.Expected("null")),
result.expectationString);
}
public void OnHasAnyWhichIsNull_WhitArrayHavingStringy_ShouldFail()
{
HasAnyAssertion <string> assertion = HasAnyAssertion(s => s.IsNull());
ValueAssertionResult result = assertion.AssertValue(new[] { "Stringy" });
Assert.IsFalse(result.succeeded);
Assert.AreEqual("<0 matches>".NewLine()
.Add("'Stringy'"),
result.actualValueString);
Assert.AreEqual(ComposeLog.Expected("at least 1 match").NewLine()
.Add(ComposeLog.Expected("null")),
result.expectationString);
}
public void OnEqualsMultiLineString_WithMultiLineString_ShouldReturnSuccess()
{
var multiLineString = "MultiLine".NewLine().Add("String");
EqualAssertion assertion = EqualAssertion(multiLineString);
ValueAssertionResult result = assertion.AssertValue(multiLineString);
Assert.AreEqual("'MultiLine".NewLine()
.Add(" String'"),
result.actualValueString);
Assert.AreEqual("(expected: 'MultiLine".NewLine()
.Add(" String')"),
result.expectationString);
Assert.IsTrue(result.succeeded);
}
public static MemberAssertionResult Assert <TMember>(IAssertValue <TMember> assertion, string memberName,
TMember value)
{
if (assertion == null)
{
return(new MemberAssertionResult(memberName,
new ValueAssertionResult(false,
"no assertion specified",
string.Empty)));
}
ValueAssertionResult result = assertion.AssertValue(value);
return(new MemberAssertionResult(memberName, result));
}
public MemberAssertionResult(string memberName, ValueAssertionResult childResult)
{
this.memberName = memberName;
this.childResult = childResult;
}
