public void IsNotEqualTo_Expression_IEqualityComparer_succeeds_when_not_equal(
string candidate,
string value) =>
Invoking(() => Ensure.That(() => candidate).IsNotEqualTo(
() => value,
TestEqualityComparer <string> .NeverEqual()))
.Should().NotThrow();
public void TestGuardValueWithEqualityComparer()
{
var equalityComparer = new TestEqualityComparer();
var instance = Maybe.Just("test");
var result = instance.Guard("test", equalityComparer);
result.AssertJust("test");
result = instance.Guard("notTest", equalityComparer);
result.AssertNothing();
result = instance.Guard(default(string), equalityComparer);
result.AssertNothing();
result = instance.Guard(() => "test", equalityComparer);
result.AssertJust("test");
result = instance.Guard(() => "notTest", equalityComparer);
result.AssertNothing();
result = instance.Guard(() => default(string), equalityComparer);
result.AssertNothing();
Assert.Throws <ArgumentNullException>(() => instance.Guard("test", null));
Assert.Throws <ArgumentNullException>(() => instance.Guard(() => "test", null));
Assert.Throws <ArgumentNullException>(() => instance.Guard(default(Func <string>), equalityComparer));
Assert.Throws <ArgumentNullException>(() => instance.Guard(default(Func <string>), null));
}
public void IsEqualTo_T_IEqualityComparer_succeeds_when_equal(
string candidate,
string value) =>
Invoking(() => Ensure.That(() => candidate).IsEqualTo(
value,
TestEqualityComparer <string> .AlwaysEqual()))
.Should().NotThrow();
public void CapacityAndEqualityComparerWorks()
{
var c = new TestEqualityComparer();
var d = new Dictionary <string, string>(10, c);
Assert.AreEqual(d.Count, 0);
Assert.AreStrictEqual(d.Comparer, c);
}
public void EqualityComparerOnlyConstructorWorks()
{
var c = new TestEqualityComparer();
var d = new Dictionary <string, int>(c);
Assert.AreEqual(d.Count, 0);
Assert.AreStrictEqual(d.Comparer, c);
}
public void IsEqualTo_Expression_IEqualityComparer_fails_when_not_equal(
string candidate,
string value) =>
Invoking(() => Ensure.That(() => candidate).IsEqualTo(
() => value,
TestEqualityComparer <string> .NeverEqual()))
.Should().Throw <GuardClauseNotMetException>()
.WithMessage(nameof(candidate).ShouldEqual(nameof(value)));
public void IsNotEqualTo_T_IEqualityComparer_fails_when_equal(
string candidate,
string value) =>
Invoking(() =>
Ensure.That(() => candidate).IsNotEqualTo(
value,
TestEqualityComparer <string> .AlwaysEqual()))
.Should().Throw <GuardClauseNotMetException>()
.WithMessage(nameof(candidate).ShouldNotEqual(value));
public void JsDictionaryAndEqualityComparerConstructorWorks()
{
var c = new TestEqualityComparer();
var orig = JsDictionary <string, int> .GetDictionary(new { a = 1, b = 2 });
var d = new Dictionary <string, int>(orig, c);
Assert.IsFalse((object)d == (object)orig);
Assert.AreEqual(d.Count, 2);
Assert.AreEqual(d["a"], 1);
Assert.AreEqual(d["b"], 2);
Assert.AreStrictEqual(d.Comparer, c);
}
public void TestIsEqualityComparer()
{
var instance = Maybe.Just("test");
var equalityComparer = new TestEqualityComparer();
Assert.True(instance.Is("test", equalityComparer));
Assert.False(instance.Is("notTest", equalityComparer));
Assert.Throws <ArgumentNullException>(() => instance.Is("test", null));
Assert.Throws <ArgumentNullException>(() => instance.Is(default(Func <string>), equalityComparer));
Assert.Throws <ArgumentNullException>(() => instance.Is(default(Func <string>), null));
Assert.True(instance.Is(() => "test", equalityComparer));
Assert.False(instance.Is(() => "notTest", equalityComparer));
}
public void ConstructorWithBothDictionaryAndEqualityComparerWorks()
{
var c = new TestEqualityComparer();
var orig = new Dictionary <string, int>();
orig["a"] = 1;
orig["b"] = 2;
var d = new Dictionary <string, int>(orig);
var d2 = new Dictionary <string, int>(d, c);
Assert.False((object)d == (object)d2);
Assert.AreEqual(2, d2.Count);
Assert.AreEqual(1, d2["a"]);
Assert.AreEqual(2, d2["b"]);
Assert.AreStrictEqual(c, d2.Comparer);
}
public void TakeAroundTest()
{
IEnumerable <int> source;
IEnumerable <int> expected;
TestEqualityComparer <int> et;
int item;
int count;
int before;
int after;
source = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
expected = new int[] { 4, 5, 6, 7, 8 };
item = 6;
count = 2;
IEnumerable <int> actual;
actual = source.TakeAround(item, count);
Assert.IsTrue(actual.SequenceEqual(expected));
//------------------------------//
source = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
expected = new int[] { 4, 5, 6, 7 };
item = 6;
before = 2;
after = 1;
actual = source.TakeAround(item, before, after);
Assert.IsTrue(actual.SequenceEqual(expected));
//------------------------------//
source = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
expected = new int[] { 4, 5, 6, 7, 8 };
item = 6;
count = 2;
et = new TestEqualityComparer <int>();
actual = source.TakeAround(item, count, et);
Assert.IsTrue(actual.SequenceEqual(expected));
//------------------------------//
source = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
expected = new int[] { 4, 5, 6, 7, 8 };
item = 6;
count = 2;
actual = source.TakeAround(item, count);
Assert.IsTrue(actual.SequenceEqual(expected));
//------------------------------//
source = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
expected = new int[] { 4, 5, 6, 7 };
item = 6;
before = 2;
after = 1;
et = new TestEqualityComparer <int>();
actual = source.TakeAround(item, before, after, et);
Assert.IsTrue(actual.SequenceEqual(expected));
//------------------------------//
source = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
expected = new int[] { 4, 5, 6, 7 };
item = 6;
before = 2;
after = 1;
actual = source.TakeAround(item, before, after);
Assert.IsTrue(actual.SequenceEqual(expected));
}
public void TakeSelfAndAfterTest()
{
IEnumerable <int> source;
IEnumerable <int> expected;
IEnumerable <int> actual;
TestEqualityComparer <int> et;
int item;
int count;
source = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
expected = new int[] { 6, 7, 8, 9, 10 };
item = 6;
actual = source.TakeSelfAndAfter(item);
Assert.IsTrue(actual.SequenceEqual(expected));
//------------------------------//
source = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
expected = new int[] { 6, 7, 8 };
item = 6;
count = 2;
actual = source.TakeSelfAndAfter(item, count);
Assert.IsTrue(actual.SequenceEqual(expected));
//------------------------------//
source = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
expected = new int[] { 6, 7, 8, 9, 10 };
item = 6;
et = new TestEqualityComparer <int>();
actual = source.TakeSelfAndAfter(item, et);
Assert.IsTrue(actual.SequenceEqual(expected));
//------------------------------//
source = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
expected = new int[] { 6, 7, 8, 9, 10 };
item = 6;
actual = source.TakeSelfAndAfter(item);
Assert.IsTrue(actual.SequenceEqual(expected));
//------------------------------//
source = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
expected = new int[] { 5, 6, 7 };
item = 5;
count = 2;
et = new TestEqualityComparer <int>();
actual = source.TakeSelfAndAfter(item, count, et);
Assert.IsTrue(actual.SequenceEqual(expected));
//------------------------------//
source = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
expected = new int[] { 5, 6, 7 };
item = 5;
count = 2;
actual = source.TakeSelfAndAfter(item, count);
Assert.IsTrue(actual.SequenceEqual(expected));
}
