public void CheckAndRecord(ConstraintsViolations violations)
        {
            RecordedAssertions.DoesNotThrow(() =>
            {
                var equatableEquality = TypeOf <T> .EquatableEquality();
                if (equatableEquality.HasValue)
                {
                    foreach (var factory1 in _equalInstances)
                    {
                        foreach (var factory2 in _equalInstances)
                        {
                            RecordedAssertions.DoesNotThrow(() =>
                                                            RecordedAssertions.True((bool)equatableEquality.Value().Evaluate(factory1(), factory2()),
                                                                                    "a.Equals(T b) should return true for equal objects", violations),
                                                            "a.Equals(T b) should return true for equal objects", violations);
                            RecordedAssertions.DoesNotThrow(() =>
                                                            RecordedAssertions.True((bool)equatableEquality.Value().Evaluate(factory2(), factory1()),
                                                                                    "b.Equals<T>(a) should return true for equal objects", violations),
                                                            "b.Equals(T a) should return true for equal objects", violations);

                            RecordedAssertions.DoesNotThrow(() =>
                                                            RecordedAssertions.True(factory1().Equals(factory2()),
                                                                                    "a.Equals(object b) should return true for equal objects", violations),
                                                            "a.Equals(object b) should return true for equal objects", violations);
                            RecordedAssertions.DoesNotThrow(() =>
                                                            RecordedAssertions.True(factory2().Equals(factory1()),
                                                                                    "b.Equals(object a) should return true for equal objects", violations),
                                                            "b.Equals(object a) should return true for equal objects", violations);
                        }
                    }
                }
            }, "Should be able to create an object of type " + typeof(T), violations);
        }
Пример #2
0
        public void CheckAndRecord(ConstraintsViolations violations)
        {
            var instance1 = _activator.CreateInstanceAsValueObjectWithFreshParameters();
            var instance3 = _activator.CreateInstanceAsValueObjectWithPreviousParameters();

            for (var i = 0; i < _activator.GetConstructorParametersCount(); ++i)
            {
                if (ArgumentIsPartOfValueIdentity(i))
                {
                    var instance2 = _activator.CreateInstanceAsValueObjectWithModifiedParameter(i);
                    RecordedAssertions.DoesNotThrow(() =>
                                                    RecordedAssertions.NotEqual(instance1.GetHashCode(), instance2.GetHashCode(),
                                                                                "b.GetHashCode() and b.GetHashCode() should return different values when both are created with different argument" + i, violations),
                                                    "b.GetHashCode() and b.GetHashCode() should return different values when both are created with different argument" + i, violations);
                }
            }

            RecordedAssertions.DoesNotThrow(() =>
                                            RecordedAssertions.Equal(instance1.GetHashCode(), instance3.GetHashCode(),
                                                                     "a.GetHashCode() and b.GetHashCode() should return same values when both are created with same arguments", violations),
                                            "a.GetHashCode() and b.GetHashCode() should return same values when both are created with same arguments", violations);
            RecordedAssertions.DoesNotThrow(() =>
                                            RecordedAssertions.Equal(instance1.GetHashCode(), instance3.GetHashCode(),
                                                                     "a.GetHashCode() and b.GetHashCode() should return same values when both are created with same arguments", violations),
                                            "a.GetHashCode() and b.GetHashCode() should return same values when both are created with same arguments", violations);
        }
        public void CheckAndRecord(ConstraintsViolations violations)
        {
            RecordedAssertions.DoesNotThrow(() =>
            {
                var instance1 = _activator.CreateInstanceAsValueObjectWithFreshParameters();
                var instance2 = _activator.CreateInstanceAsValueObjectWithPreviousParameters();

                //TODO how to test equatable???
                RecordedAssertions.DoesNotThrow(() =>
                                                RecordedAssertions.True(instance1.Equals(instance2),
                                                                        "a.Equals(b) should return true if both are created with the same arguments", violations),
                                                "a.Equals(b) should return true if both are created with the same arguments", violations);
                RecordedAssertions.DoesNotThrow(() =>
                                                RecordedAssertions.True(instance2.Equals(instance1),
                                                                        "b.Equals(a) should return true if both are created with the same arguments", violations),
                                                "b.Equals(a) should return true if both are created with the same arguments", violations);

                RecordedAssertions.DoesNotThrow(() =>
                                                RecordedAssertions.True(instance1.Equals(instance2),
                                                                        "(object)a.Equals((object)b) should return true if both are created with the same arguments", violations),
                                                "(object)a.Equals((object)b) should return true if both are created with the same arguments", violations);
                RecordedAssertions.DoesNotThrow(() =>
                                                RecordedAssertions.True(instance2.Equals(instance1),
                                                                        "(object)b.Equals((object)a) should return true if both are created with the same arguments", violations),
                                                "(object)b.Equals((object)a) should return true if both are created with the same arguments", violations);
            }, "Should be able to create an object of type " + _activator.TargetType, violations);
        }
Пример #4
0
        public void CheckAndRecord(ConstraintsViolations violations)
        {
            var instance1 = _activator.CreateInstanceAsValueObjectWithFreshParameters();

            for (var i = 0; i < _activator.GetConstructorParametersCount(); ++i)
            {
                var currentParamIndex = i;

                if (ArgumentIsPartOfValueIdentity(i))
                {
                    var instance2 = _activator.CreateInstanceAsValueObjectWithModifiedParameter(i);

                    RecordedAssertions.DoesNotThrow(() =>
                                                    RecordedAssertions.False(instance1.Equals(instance2),
                                                                             "a.Equals(b) should return false if both are created with different argument" + currentParamIndex, violations),
                                                    "a.Equals(b) should return false if both are created with different argument" + currentParamIndex, violations);
                    RecordedAssertions.DoesNotThrow(() =>
                                                    RecordedAssertions.False(instance2.Equals(instance1),
                                                                             "b.Equals(a) should return false if both are created with different argument" + currentParamIndex, violations),
                                                    "b.Equals(a) should return false if both are created with different argument" + currentParamIndex, violations);
                    RecordedAssertions.DoesNotThrow(() =>
                                                    RecordedAssertions.False(instance1.Equals(instance2),
                                                                             "(object)a.Equals((object)b) should return false if both are created with different argument" + currentParamIndex, violations),
                                                    "(object)a.Equals((object)b) should return false if both are created with different argument" + currentParamIndex, violations);
                    RecordedAssertions.DoesNotThrow(() =>
                                                    RecordedAssertions.False(instance2.Equals(instance1),
                                                                             "(object)b.Equals((object)a) should return false if both are created with different argument" + currentParamIndex, violations),
                                                    "(object)b.Equals((object)a) should return false if both are created with different argument" + currentParamIndex, violations);
                }
            }
        }
        public void CheckAndRecord(ConstraintsViolations violations)
        {
            foreach (var factory in _equalInstances.Concat(_otherInstances))
            {
                RecordedAssertions.DoesNotThrow(() =>
                {
                    var instance1 = factory();

                    RecordedAssertions.DoesNotThrow(() =>
                                                    RecordedAssertions.True(instance1.Equals(instance1),
                                                                            "a.Equals(object a) should return true", violations),
                                                    "a.Equals(object a) should return true", violations);
                }, "Should be able to create an object of type " + typeof(T), violations);

                var equatableEquals = TypeOf <T> .EquatableEquality();

                if (equatableEquals.HasValue)
                {
                    var instance1 = factory();
                    RecordedAssertions.DoesNotThrow(() =>
                                                    RecordedAssertions.True((bool)equatableEquals.Value().Evaluate(instance1, instance1),
                                                                            "a.Equals(a) should return true", violations),
                                                    "a.Equals(a) should return true", violations);
                }
            }
        }
Пример #6
0
        public void CheckAndRecord(ConstraintsViolations violations)
        {
            foreach (var factory1 in _equalInstances)
            {
                foreach (var factory2 in _otherInstances)
                {
                    RecordedAssertions.DoesNotThrow(() =>
                                                    RecordedAssertions.False(factory1().Equals(factory2()),
                                                                             "a.Equals(object b) should return false if they are not equal", violations),
                                                    "a.Equals(object b) should return false if they are not equal", violations);
                    RecordedAssertions.DoesNotThrow(() =>
                                                    RecordedAssertions.False(factory2().Equals(factory1()),
                                                                             "b.Equals(object a) should return false if they are not equal", violations),
                                                    "b.Equals(object a) should return false if they are not equal", violations);

                    var equatableEquals = TypeOf <T> .EquatableEquality();

                    if (equatableEquals.HasValue)
                    {
                        RecordedAssertions.DoesNotThrow(() =>
                                                        RecordedAssertions.False((bool)equatableEquals.Value().Evaluate(factory1(), factory2()),
                                                                                 "a.Equals(T b) should return false if they are not equal", violations),
                                                        "a.Equals(T b) should return false if they are not equal", violations);
                        RecordedAssertions.DoesNotThrow(() =>
                                                        RecordedAssertions.False((bool)equatableEquals.Value().Evaluate(factory2(), factory1()),
                                                                                 "b.Equals(T a) should return false if they are not equal", violations),
                                                        "b.Equals(T a) should return false if they are not equal", violations);
                    }
                }
            }
        }
Пример #7
0
        public void CheckAndRecord(ConstraintsViolations violations)
        {
            var instance1 = _activator.CreateInstanceAsValueObjectWithFreshParameters();

            RecordedAssertions.DoesNotThrow(() =>
                                            RecordedAssertions.True(Are.EqualInTermsOfEqualityOperator(_activator.TargetType, instance1, instance1),
                                                                    "a == a should return true", violations), "a == a should return true", violations);
        }
Пример #8
0
 public void CheckAndRecord(ConstraintsViolations violations)
 {
     RecordedAssertions.DoesNotThrow(() =>
                                     RecordedAssertions.True(_type.IsSealed,
                                                             $"{_type.Name} must be sealed, or derivatives will be able to override GetHashCode() with mutable code",
                                                             violations),
                                     $"{_type.Name} must be sealed, or derivatives will be able to override GetHashCode() with mutable code",
                                     violations);
 }
        public void CheckAndRecord(ConstraintsViolations violations)
        {
            var instance1 = _activator.CreateInstanceAsValueObjectWithFreshParameters();

            RecordedAssertions.DoesNotThrow(() =>
                                            RecordedAssertions.False(instance1.Equals(null),
                                                                     "a.Equals(null) should return false", violations),
                                            "a.Equals(null) should return false", violations);
        }
 public void CheckAndRecord(ConstraintsViolations violations)
 {
     foreach (var factory in _equalInstances.Concat(_otherInstances))
     {
         var instance = factory();
         RecordedAssertions.DoesNotThrow(() =>
                                         RecordedAssertions.False(Are.NotEqualInTermsOfInEqualityOperator(typeof(T), instance, instance),
                                                                  "a != a should return false", violations),
                                         "a != a should return false", violations);
     }
 }
 public void CheckAndRecord(ConstraintsViolations violations)
 {
     RecordedAssertions.DoesNotThrow(() =>
     {
         var instance1 = _activator.CreateInstanceAsValueObjectWithFreshParameters();
         RecordedAssertions.DoesNotThrow(() =>
                                         RecordedAssertions.True(instance1.Equals(instance1),
                                                                 "a.Equals(a) should return true", violations),
                                         "a.Equals(a) should return true", violations);
     }, "Should be able to create an object of type " + _activator.TargetType, violations);
 }
        public void ShouldAddErrorMessageWhenTruthAssertionFails()
        {
            //GIVEN
            var violations = Substitute.For <IConstraintsViolations>();
            var message    = Root.Any.String();

            //WHEN
            RecordedAssertions.True(false, message, violations);

            //THEN
            violations.Received(1).Add(message);
        }
Пример #13
0
        public static void TypeAdheresTo(IEnumerable <IConstraint> constraints)
        {
            var violations = ConstraintsViolations.Empty();

            foreach (var constraint in constraints)
            {
                RecordedAssertions.DoesNotThrow(() => constraint.CheckAndRecord(violations),
                                                "Did not expect exception", violations);
            }

            violations.AssertNone();
        }
        public void ShouldNotAddErrorMessageWhenTruthAssertionPasses()
        {
            //GIVEN
            var violations = Substitute.For <IConstraintsViolations>();
            var message    = Root.Any.String();

            //WHEN
            RecordedAssertions.True(true, message, violations);

            //THEN
            violations.DidNotReceive().Add(message);
        }
        public void CheckAndRecord(ConstraintsViolations violations)
        {
            var instance1 = _activator.CreateInstanceAsValueObjectWithFreshParameters();
            var instance2 = _activator.CreateInstanceAsValueObjectWithPreviousParameters();

            RecordedAssertions.DoesNotThrow(() =>
                                            RecordedAssertions.False(Are.NotEqualInTermsOfInEqualityOperator(_activator.TargetType, instance1, instance2),
                                                                     "a != b should return false if both are created with the same arguments", violations),
                                            "a != b should return false if both are created with the same arguments", violations);
            RecordedAssertions.DoesNotThrow(() =>
                                            RecordedAssertions.False(Are.NotEqualInTermsOfInEqualityOperator(_activator.TargetType, instance2, instance1),
                                                                     "b != a should return false if both are created with the same arguments", violations),
                                            "b != a should return false if both are created with the same arguments", violations);
        }
Пример #16
0
 public void CheckAndRecord(ConstraintsViolations violations)
 {
     foreach (var factory1 in _equalInstances)
     {
         foreach (var factory2 in _otherInstances)
         {
             RecordedAssertions.DoesNotThrow(() =>
                                             RecordedAssertions.True(Are.NotEqualInTermsOfInEqualityOperator(typeof(T), factory1(), factory2()),
                                                                     "a != b should return true if they are not equal", violations),
                                             "a != b should return true if they are not equal", violations);
             RecordedAssertions.DoesNotThrow(() =>
                                             RecordedAssertions.True(Are.NotEqualInTermsOfInEqualityOperator(typeof(T), factory1(), factory2()),
                                                                     "b != a should return true if if they are not equal", violations),
                                             "b != a should return true if if they are not equal", violations);
         }
     }
 }
        public void CheckAndRecord(ConstraintsViolations violations)
        {
            foreach (var factory in _equalInstances)
            {
                var instance1 = factory();
                var instance2 = factory();

                RecordedAssertions.DoesNotThrow(() =>
                                                RecordedAssertions.False(Are.NotEqualInTermsOfInEqualityOperator(typeof(T), instance1, instance2),
                                                                         "a != b should return false for equal values", violations),
                                                "a != b should return false for equal values", violations);
                RecordedAssertions.DoesNotThrow(() =>
                                                RecordedAssertions.False(Are.NotEqualInTermsOfInEqualityOperator(typeof(T), instance2, instance1),
                                                                         "b != a should return false for equal values", violations),
                                                "b != a should return false for equal values", violations);
            }
        }
 public void CheckAndRecord(ConstraintsViolations violations)
 {
     foreach (var factory1 in _equalInstances)
     {
         foreach (var factory2 in _otherInstances)
         {
             RecordedAssertions.DoesNotThrow(() =>
                                             RecordedAssertions.False(Are.EqualInTermsOfEqualityOperator(typeof(T), factory1(), factory2()),
                                                                      "a == b should return false for not equal values", violations),
                                             "a == b should return false for not equal values", violations
                                             );
             RecordedAssertions.DoesNotThrow(() =>
                                             RecordedAssertions.False(Are.EqualInTermsOfEqualityOperator(typeof(T), factory2(), factory1()),
                                                                      "b == a should return false for not equal values", violations),
                                             "b == a should return false for not equal values", violations
                                             );
         }
     }
 }
Пример #19
0
        public void CheckAndRecord(ConstraintsViolations violations)
        {
            if (!typeof(T).IsValueType)
            {
                foreach (var factory in _equalInstances.Concat(_otherInstances))
                {
                    var instance1 = factory();
                    RecordedAssertions.DoesNotThrow(() =>
                                                    RecordedAssertions.False(Are.EqualInTermsOfEqualityOperator(typeof(T), instance1, null),
                                                                             "a == null should return false", violations),
                                                    "a == null should return false", violations);

                    RecordedAssertions.DoesNotThrow(() =>
                                                    RecordedAssertions.False(Are.EqualInTermsOfEqualityOperator(typeof(T), null, instance1),
                                                                             "null == a should return false", violations),
                                                    "null == a should return false", violations);
                }
            }
        }
Пример #20
0
        public void CheckAndRecord(ConstraintsViolations violations)
        {
            foreach (var factory1 in _equalInstances)
            {
                foreach (var factory2 in _equalInstances)
                {
                    RecordedAssertions.DoesNotThrow(() =>
                                                    RecordedAssertions.True(Are.EqualInTermsOfEqualityOperator(typeof(T), factory1(), factory2()),
                                                                            "a == b should return true if both are created with the same arguments that define equality", violations),
                                                    "a == b should return true if both are created with the same arguments that define equality", violations
                                                    );

                    RecordedAssertions.DoesNotThrow(() =>
                                                    RecordedAssertions.True(Are.EqualInTermsOfEqualityOperator(typeof(T), factory2(), factory1()),
                                                                            "b == a should return true if both are created with the same arguments that define equality", violations),
                                                    "b == a should return true if both are created with the same arguments that define equality", violations
                                                    );
                }
            }
        }
Пример #21
0
        public void CheckAndRecord(ConstraintsViolations violations)
        {
            foreach (var factory1 in _equalInstances)
            {
                foreach (var factory2 in _otherInstances)
                {
                    RecordedAssertions.DoesNotThrow(() =>
                                                    RecordedAssertions.NotEqual(factory1().GetHashCode(), factory2().GetHashCode(),
                                                                                "b.GetHashCode() and b.GetHashCode() should return different values for not equal objects", violations),
                                                    "b.GetHashCode() and b.GetHashCode() should return different values for not equal objects", violations);
                }
            }

            foreach (var factory in _equalInstances.Concat(_otherInstances))
            {
                var instance = factory();
                RecordedAssertions.DoesNotThrow(() =>
                                                RecordedAssertions.Equal(instance.GetHashCode(), instance.GetHashCode(),
                                                                         "a.GetHashCode() should consistently return the same value", violations),
                                                "a.GetHashCode() should consistently return the same value", violations);
            }

            foreach (var factory1 in _equalInstances)
            {
                foreach (var factory2 in _equalInstances)
                {
                    RecordedAssertions.DoesNotThrow(() =>
                                                    RecordedAssertions.Equal(factory1().GetHashCode(), factory2().GetHashCode(),
                                                                             "a.GetHashCode() and b.GetHashCode() should be equal for equal objects",
                                                                             violations),
                                                    "a.GetHashCode() and b.GetHashCode() should be equal for equal objects",
                                                    violations);
                    RecordedAssertions.DoesNotThrow(() =>
                                                    RecordedAssertions.Equal(factory1().GetHashCode(), factory2().GetHashCode(),
                                                                             "a.GetHashCode() and b.GetHashCode() should be equal for equal objects",
                                                                             violations),
                                                    "a.GetHashCode() and b.GetHashCode() should be equal for equal objects",
                                                    violations);
                }
            }
        }
        public void CheckAndRecord(ConstraintsViolations violations)
        {
            var instance1 = _activator.CreateInstanceAsValueObjectWithFreshParameters();

            for (var i = 0; i < _activator.GetConstructorParametersCount(); ++i)
            {
                if (ArgumentIsPartOfValueIdentity(i))
                {
                    var instance2 = _activator.CreateInstanceAsValueObjectWithModifiedParameter(i);

                    RecordedAssertions.DoesNotThrow(() =>
                                                    RecordedAssertions.True(Are.NotEqualInTermsOfInEqualityOperator(_activator.TargetType, instance1, instance2),
                                                                            "a != b should return true if both are created with different argument" + i, violations),
                                                    "a != b should return true if both are created with different argument" + i, violations);
                    RecordedAssertions.DoesNotThrow(() =>
                                                    RecordedAssertions.True(Are.NotEqualInTermsOfInEqualityOperator(_activator.TargetType, instance1, instance2),
                                                                            "b != a should return true if both are created with different argument" + i, violations),
                                                    "b != a should return true if both are created with different argument" + i, violations);
                }
            }
        }
Пример #23
0
        public void CheckAndRecord(ConstraintsViolations violations)
        {
            var instance1 = _activator.CreateInstanceAsValueObjectWithFreshParameters();

            RecordedAssertions.DoesNotThrow(() =>
                                            RecordedAssertions.True(Are.NotEqualInTermsOfInEqualityOperator(_activator.TargetType, instance1, null),
                                                                    "a != null should return true", violations),
                                            "a != null should return true", violations);
            RecordedAssertions.DoesNotThrow(() =>
                                            RecordedAssertions.True(Are.NotEqualInTermsOfInEqualityOperator(_activator.TargetType, null, instance1),
                                                                    "null != a should return true", violations),
                                            "null != a should return true", violations);

            //TODO remove?
            object null1 = null;
            object null2 = null;

            RecordedAssertions.DoesNotThrow(() =>
                                            RecordedAssertions.False(null1 != null2,
                                                                     "null != null should be false", violations),
                                            "null != null should be false", violations);
        }
        public void CheckAndRecord(ConstraintsViolations violations)
        {
            if (!typeof(T).IsValueType)
            {
                foreach (var factory in _equalInstances.Concat(_otherInstances))
                {
                    var instance1 = factory();
                    RecordedAssertions.DoesNotThrow(() =>
                                                    RecordedAssertions.False(instance1.Equals(null),
                                                                             "a.Equals(null) should return false", violations),
                                                    "a.Equals(null) should return false", violations);

                    var equatableEquals = SmartType.ForTypeOf(instance1).EquatableEquality();
                    if (equatableEquals.HasValue)
                    {
                        RecordedAssertions.DoesNotThrow(() =>
                                                        RecordedAssertions.False((bool)equatableEquals.Value().Evaluate(instance1, null),
                                                                                 "a.Equals(null) should return false", violations),
                                                        "a.Equals(null) should return false", violations);
                    }
                }
            }
        }