public void UseCase_For_That()
{
var visitor = new Visitor
{
Programs = new[]
{
new Program
{
Name = "Some"
},
new Program
{
Active = false
},
}
};
//Assert.IsTrue(visitor.Programs.Exists(p => p.Active),
// "visitor should have at least one active program");
RuleAssert.That(() => visitor,
v => v.Programs.Exists(p => p.Active),
v => v.Programs.Length > 1);
RuleAssert.That(visitor,
v => v.Programs.Exists(p => p.Active),
v => v.Programs.Length > 1);
}
public void Invalid_property_collection()
{
RuleAssert.IsError(new Model()
{
Login = "******",
Name = "valid",
Names = new [] { "" }
}, ValidateModelExpression);
}
public void Invalid_field_collection()
{
RuleAssert.IsError(new Model()
{
Login = "******",
Name = "valid",
Logins = new[] { "non-email" }
}, ValidateModelExpression);
}
public void NotEqual_X()
{
RuleAssert.For(Is.NotEqual(Guid.Empty))
.ExpectNone(Guid.NewGuid())
.ExpectError(Guid.Empty);
RuleAssert.For(Is.NotEqual(3D))
.ExpectNone(1, 2, Math.PI)
.ExpectError(3, 3D);
}
public void NotDefault()
{
RuleAssert.For <Guid>(Is.NotDefault)
.ExpectNone(Guid.NewGuid())
.ExpectError(Guid.Empty);
RuleAssert.For <double>(Is.NotDefault)
.ExpectNone(1, 2)
.ExpectError(0, 0D);
}
public void Default()
{
RuleAssert.For <Guid>(Is.Default)
.ExpectNone(Guid.Empty)
.ExpectError(Guid.NewGuid());
RuleAssert.For <int>(Is.Default)
.ExpectNone(0)
.ExpectError(1, 2);
}
public void Within_X_Y()
{
RuleAssert.For(Is.Within(0, 20))
.ExpectNone(0, 12, 20)
.ExpectError(-1, 21, int.MaxValue);
RuleAssert.For(Is.Within(0D, 20D))
.ExpectNone(0, 12, 20)
.ExpectError(-1, 21, int.MaxValue);
}
public void Invalid_field()
{
var model = new Model()
{
Login = "******",
Name = ""
};
RuleAssert.IsError(model, ValidateModelExpression);
}
public void Invalid_property()
{
var model = new Model()
{
Login = "******",
Name = "valid"
};
RuleAssert.IsError(model, ValidateModelExpression);
}
public void Valid_model()
{
RuleAssert.IsNone(new Model()
{
Login = "******",
Name = "valid",
Logins = new[] { "*****@*****.**" },
Names = new [] { "Another name" }
}, ValidateModelExpression);
}
public void Between_X_Y()
{
RuleAssert.For(Is.Between(0, 20))
.ExpectNone(1, 15, 19)
.ExpectError(-1, 0, 20, int.MaxValue);
RuleAssert.For(Is.Between(0D, 20D))
.ExpectNone(1, 15, 19)
.ExpectError(-1, 0, 20, int.MaxValue);
}
public void WithoutUppercase()
{
RuleAssert.For(StringIs.WithoutUppercase)
.ExpectNone("", "valid", "another\tvalid")
.ExpectError("Fail", "\tthis should Fail");
}
public void WithoutTrailingWhiteSpace()
{
RuleAssert.For(StringIs.WithoutTrailingWhiteSpace)
.ExpectNone("", "non", " leading", "mid dle")
.ExpectError(null, "new line\r", "new line\n", "tab\t", "space ");
}
public void WithoutLeadingWhiteSpace()
{
RuleAssert.For(StringIs.WithoutLeadingWhiteSpace)
.ExpectNone("", "non", "trailing ", "mid dle")
.ExpectError(null, "\r new line", "\n new line", "\t tab", " space");
}
public void Limited()
{
RuleAssert.For(BufferIs.Limited(10))
.ExpectNone(new byte[10], new byte[9])
.ExpectError(null, new byte[11], new byte[12]);
}
public void Test()
{
RuleAssert.For <DateTime>(DateIs.SqlCompatible)
.ExpectNone(new DateTime(1753, 1, 1), DateTime.MaxValue)
.ExpectError(DateTime.MinValue, new DateTime(1753, 1, 1).AddSeconds(-1));
}
public void GreaterThen_X()
{
RuleAssert.For(Is.GreaterThan(5D))
.ExpectNone(6, 6D, 5.1D)
.ExpectError(5, 5D, 2);
}
public void ValidHost_Positives()
{
RuleAssert.For <string>(StringIs.ValidServerConnection)
.ExpectNone(Split(ValidHostNames));
}
public void LessThan_X()
{
RuleAssert.For(Is.LessThan(5D))
.ExpectNone(4.9, 4D, 3)
.ExpectError(5, 5D, 6);
}
public void ValidAnd()
{
RuleAssert.For(MaybeIs.ValidAnd(StringIs.WithoutUppercase))
.ExpectNone("lowercase")
.ExpectError(null, Maybe.String, "Uppercase");
}
public void EmptyOr()
{
RuleAssert.For(MaybeIs.EmptyOr(StringIs.WithoutUppercase))
.ExpectNone(Maybe <string> .Empty, "lowercase")
.ExpectError(null, "UpperCase");
}
public void ValidEmail_Positives()
{
RuleAssert.For <string>(StringIs.ValidEmail)
.ExpectNone(Split(ValidEmails));
}
public void ValidEmail_Negatives()
{
RuleAssert.For <string>(StringIs.ValidEmail)
.ExpectError(Split(InvalidEmails));
}
public void ValidHost_Negatives()
{
RuleAssert.For <string>(StringIs.ValidServerConnection)
.ExpectError(Split(InvalidHostNames));
}
public void UseCases()
{
RuleAssert.IsNone(1, Is.NotDefault);
RuleAssert.IsError(1, Is.Default);
RuleAssert.IsWarn(1, (i, scope) => scope.Warn("Warning"));
}
public void Limited_X()
{
RuleAssert.For(StringIs.Limited(3))
.ExpectNone("", "A", "AA", "AAA")
.ExpectError(null, "AAAA");
}
public void Expect()
{
RuleAssert.For <int>(Is.Default).ExpectNone(1);
}
public void Without_X()
{
RuleAssert.For(StringIs.Without('!'))
.ExpectNone("", "ABCD", "?@#")
.ExpectError(null, "!", "ABCD!");
}
public void Valid()
{
RuleAssert.For <double>(DoubleIs.Valid)
.ExpectError(double.NaN, 1 / 0D, double.PositiveInfinity, double.NegativeInfinity)
.ExpectNone(1D, 0D, Math.PI);
}
public void AtMost_X()
{
RuleAssert.For(Is.AtMost(5D))
.ExpectNone(-1, 4D, 5D, 5)
.ExpectError(5.000001, 6D);
}
