Beispiel #1
0
        public void Verify_NoObjectEqualsOverride_ShouldThrow()
        {
            var verifier = new EquatableVerifier <NoObjectEqualsOverride>()
            {
                UniqueItemsFactory = () => new[]
                {
                    new NoObjectEqualsOverride(1),
                    new NoObjectEqualsOverride(2),
                    new NoObjectEqualsOverride(3),
                },
            };

            try
            {
                verifier.Verify();
            }
            catch (AssertionException e)
            {
                e.ExpectMessage("EquatableVerifier failed.");
                e.ExpectInnerAssertion("Object.Equals must be overridden.");
                return;
            }

            Fail("EquatableVerifier did not throw.");
        }
Beispiel #2
0
        public void Verify_BrokenObjectEqualsTrue_ShouldThrow()
        {
            var verifier = new EquatableVerifier <BrokenObjectEquals>()
            {
                UniqueItemsFactory = () => new[]
                {
                    new BrokenObjectEquals(1, true),
                    new BrokenObjectEquals(2, true),
                    new BrokenObjectEquals(3, true),
                },
            };

            try
            {
                verifier.Verify();
            }
            catch (AssertionException e)
            {
                e.ExpectMessage("EquatableVerifier failed.");
                e.ExpectInnerAssertion("Object.Equals failed with values expected to not be equal at index 0. Expected: <2>. Actual: <1>.");
                return;
            }

            Fail("EquatableVerifier did not throw.");
        }
Beispiel #3
0
        public void Verify_UnstableGetHashCode_ShouldThrow()
        {
            var verifier = new EquatableVerifier <UnstableGetHashCode>()
            {
                UniqueItemsFactory = () => new[]
                {
                    new UnstableGetHashCode(1),
                    new UnstableGetHashCode(2),
                    new UnstableGetHashCode(3),
                },
            };

            try
            {
                verifier.Verify();
            }
            catch (AssertionException e)
            {
                e.ExpectMessage("EquatableVerifier failed.");
                e.ExpectInnerAssertion("GetHashCode is not stable.");
                return;
            }

            Fail("EquatableVerifier did not throw.");
        }
Beispiel #4
0
        public void Verify_NoEqualityOperators_ShouldThrow()
        {
            var verifier = new EquatableVerifier <NoEqualityOperators>()
            {
                UniqueItemsFactory = () => new[]
                {
                    new NoEqualityOperators(1),
                    new NoEqualityOperators(2),
                    new NoEqualityOperators(3),
                },
            };

            try
            {
                verifier.Verify();
            }
            catch (AssertionException e)
            {
                e.ExpectMessage("EquatableVerifier failed.");
                e.ExpectInnerAssertion("Equality operators must be defined.");
                return;
            }

            Fail("EquatableVerifier did not throw.");
        }
Beispiel #5
0
        public void Verify_BrokenOpInEquality_ShouldThrow()
        {
            var verifier = new EquatableVerifier <BrokenOpInequality>()
            {
                UniqueItemsFactory = () => new[]
                {
                    new BrokenOpInequality(1),
                    new BrokenOpInequality(2),
                    new BrokenOpInequality(3),
                },
            };

            try
            {
                verifier.Verify();
            }
            catch (AssertionException e)
            {
                e.ExpectMessage("EquatableVerifier failed.");
                e.ExpectInnerAssertion("op_Inequality failed with values expected to not be equal at index 0. Expected: <2>. Actual: <1>.");
                return;
            }

            Fail("EquatableVerifier did not throw.");
        }
Beispiel #6
0
        public void Verify_String_ShouldNotThrow()
        {
            var verifier = new EquatableVerifier <string>
            {
                UniqueItemsFactory = () => new[] { "foo", "bar", "baz", },
            };

            verifier.Verify();
        }
Beispiel #7
0
        public void Verify_Int32_ShouldNotThrow()
        {
            var verifier = new EquatableVerifier <int>
            {
                UniqueItemsFactory = () => new[] { 1, 2, 3, 4, },
            };

            verifier.Verify();
        }
Beispiel #8
0
        public void Verify_Correct_ShouldNotThrow()
        {
            var verifier = new EquatableVerifier <Correct>
            {
                UniqueItemsFactory = () => new[] { new Correct(1), new Correct(2), new Correct(3), },
            };

            verifier.Verify();
        }
Beispiel #9
0
        public void Verify_NoUniqueItemsFactory_ShouldThrow()
        {
            var verifier = new EquatableVerifier <int>();

            try
            {
                verifier.Verify();
            }
            catch (AssertionException e)
            {
                e.ExpectMessage("EquatableVerifier failed. UniqueItemsFactory is not set. IsNotNull failed.");
                return;
            }

            Fail("EquatableVerify did not throw.");
        }
Beispiel #10
0
        public void Verify_NullUniqueItems_ShouldThrow()
        {
            var verifier = new EquatableVerifier <int>
            {
                UniqueItemsFactory = () => null,
            };

            try
            {
                verifier.Verify();
            }
            catch (AssertionException e)
            {
                e.ExpectMessage("EquatableVerifier failed. UniqueItemsFactory did not produce any items. IsNotNull failed.");
                return;
            }

            Fail("EquatableVerify did not throw.");
        }
Beispiel #11
0
        public void Verify_NullUniqueItem_ShouldThrow()
        {
            var verifier = new EquatableVerifier <string>
            {
                UniqueItemsFactory = () => new[] { "foo", null, "bar", },
            };

            try
            {
                verifier.Verify();
            }
            catch (AssertionException e)
            {
                e.ExpectMessage("EquatableVerifier failed. UniqueItemsFactory should not produce null values. AllItemsAreNotNull failed.");
                return;
            }

            Fail("EquatableVerify did not throw.");
        }
Beispiel #12
0
        public void Verify_FewerThan3UniqueItems_ShouldThrow()
        {
            var verifier = new EquatableVerifier <int>
            {
                UniqueItemsFactory = () => new[] { 1, 2, },
            };

            try
            {
                verifier.Verify();
            }
            catch (AssertionException e)
            {
                e.ExpectMessage("EquatableVerifier failed. UniqueItemsFactory did not produce 3 or more items. IsTrue failed.");
                return;
            }

            Fail("EquatableVerify did not throw.");
        }
Beispiel #13
0
        public void Verify_UnstableUniqueItemsFactory_ShouldThrow()
        {
            var items    = new[] { 1, 2, 3 };
            var verifier = new EquatableVerifier <int>
            {
                UniqueItemsFactory = () => items = items.Concat(new[] { 1 }).ToArray(),
            };

            try
            {
                verifier.Verify();
            }
            catch (AssertionException e)
            {
                e.ExpectMessage("EquatableVerifier failed. UniqueItemsFactory is not stable. IsEqualTo failed. Expected: <4>. Actual: <5>.");
                return;
            }

            Fail("EquatableVerify did not throw.");
        }