public void Some_EqualTo()
{
var expression = Some.EqualTo(3);
Expect(expression, TypeOf <EqualConstraint>());
var constraint = Resolve(expression);
Expect(constraint, TypeOf <SomeItemsConstraint>());
Expect(constraint.ToString(), EqualTo("<some <equal 3>>"));
}
public void CollectionContainsTests()
{
int[] iarray = new int[] { 1, 2, 3 };
string[] sarray = new string[] { "a", "b", "c" };
// Classic syntax
Assert.Contains(3, iarray);
Assert.Contains("b", sarray);
CollectionAssert.Contains(iarray, 3);
CollectionAssert.Contains(sarray, "b");
CollectionAssert.DoesNotContain(sarray, "x");
// Showing that Contains uses object equality
CollectionAssert.DoesNotContain(iarray, 1.0d);
// Helper syntax
Assert.That(iarray, Has.Member(3));
Assert.That(sarray, Has.Member("b"));
Assert.That(sarray, Has.No.Member("x"));
// Showing that Contains uses object equality
Assert.That(iarray, Has.No.Member(1.0d));
// Only available using the new syntax
// Note that EqualTo and SameAs do NOT give
// identical results to Contains because
// Contains uses Object.Equals()
Assert.That(iarray, Has.Some.EqualTo(3));
Assert.That(iarray, Has.Member(3));
Assert.That(sarray, Has.Some.EqualTo("b"));
Assert.That(sarray, Has.None.EqualTo("x"));
Assert.That(iarray, Has.None.SameAs(1.0d));
Assert.That(iarray, Has.All.LessThan(10));
Assert.That(sarray, Has.All.Length(1));
Assert.That(sarray, Has.None.Property("Length").GreaterThan(3));
// Inherited syntax
Expect(iarray, Contains(3));
Expect(sarray, Contains("b"));
Expect(sarray, Not.Contains("x"));
// Only available using new syntax
// Note that EqualTo and SameAs do NOT give
// identical results to Contains because
// Contains uses Object.Equals()
Expect(iarray, Some.EqualTo(3));
Expect(sarray, Some.EqualTo("b"));
Expect(sarray, None.EqualTo("x"));
Expect(iarray, All.LessThan(10));
Expect(sarray, All.Length(1));
Expect(sarray, None.Property("Length").GreaterThan(3));
}
public void AllItemsTests()
{
object[] ints = new object[] { 1, 2, 3, 4 };
object[] doubles = new object[] { 0.99, 2.1, 3.0, 4.05 };
object[] strings = new object[] { "abc", "bad", "cab", "bad", "dad" };
// Classic syntax
Ensure.AllItemsAreNotNull(ints);
Ensure.AllItemsAreInstancesOfType(ints, typeof(int));
Ensure.AllItemsAreInstancesOfType(strings, typeof(string));
Ensure.AllItemsAreUnique(ints);
// Helper syntax
Ensure.That(ints, Is.All.Not.Null);
Ensure.That(ints, Has.None.Null);
Ensure.That(ints, Is.All.InstanceOfType(typeof(int)));
Ensure.That(ints, Has.All.InstanceOfType(typeof(int)));
Ensure.That(strings, Is.All.InstanceOfType(typeof(string)));
Ensure.That(strings, Has.All.InstanceOfType(typeof(string)));
Ensure.That(ints, Is.Unique);
// Only available using new syntax
Ensure.That(strings, Is.Not.Unique);
Ensure.That(ints, Is.All.GreaterThan(0));
Ensure.That(ints, Has.All.GreaterThan(0));
Ensure.That(ints, Has.None.LessThanOrEqualTo(0));
Ensure.That(strings, Text.All.Contains("a"));
Ensure.That(strings, Has.All.Contains("a"));
Ensure.That(strings, Has.Some.StartsWith("ba"));
Ensure.That(strings, Has.Some.Property("Length", 3));
Ensure.That(strings, Has.Some.StartsWith("BA").IgnoreCase);
Ensure.That(doubles, Has.Some.EqualTo(1.0).Within(.05));
// Inherited syntax
EnsuranceHelper.Expect(ints, All.Not.Null);
EnsuranceHelper.Expect(ints, None.Null);
EnsuranceHelper.Expect(ints, All.InstanceOfType(typeof(int)));
EnsuranceHelper.Expect(strings, All.InstanceOfType(typeof(string)));
EnsuranceHelper.Expect(ints, Unique);
// Only available using new syntax
EnsuranceHelper.Expect(strings, Not.Unique);
EnsuranceHelper.Expect(ints, All.GreaterThan(0));
EnsuranceHelper.Expect(ints, None.LessThanOrEqualTo(0));
EnsuranceHelper.Expect(strings, All.Contains("a"));
EnsuranceHelper.Expect(strings, Some.StartsWith("ba"));
EnsuranceHelper.Expect(strings, Some.StartsWith("BA").IgnoreCase);
EnsuranceHelper.Expect(doubles, Some.EqualTo(1.0).Within(.05));
}
/// <summary>
/// Returns a new <see cref="EqualConstraint"/> checking for the
/// presence of a particular object in the collection.
/// </summary>
public static EqualConstraint Member(object expected)
{
return(Some.EqualTo(expected));
}
