Example #1
0
        public void ShouldDifferentiateLambdas()
        {
            //Although the 2 expressions are very similar, the comparer should not be fooled.
            var exp1 = ExpressionHelper.New <Foo, int>(a => a.Value);
            var exp2 = ExpressionHelper.New <Foo2, int>(a => a.Value);

            AssertNotEqual(exp1, exp2, CreateComparer());
        }
Example #2
0
        public void ShouldShortCircuit()
        {
            var en2 = new Engine(_en1);

            en2.For <Member>()
            .MustPassGenericRule(m => { throw new AssertFailedException("Should have short-circuited."); });

            var member1       = new Member(null);
            var memberNameExp = ExpressionHelper.New <Member, string>(mm => mm.Name);
            var report        = new ValidationReport();

            //Only short-circuit here would work...Others would throw exception...
            _en1.Validate(member1, report, ValidationReportDepth.ShortCircuit);
        }
Example #3
0
        public void ShouldValidateAllItemsInEnumeration()
        {
            var member1 = new Member(null);
            var member2 = new Member(null);
            var club    = new Club(new Member("president"), member1, member2);
            var report  = new ValidationReport();

            _en1.Validate(club, report, ValidationReportDepth.FieldShortCircuit);

            var memberNameExp = new EquatableExpression(ExpressionHelper.New <Member, string>(mm => mm.Name));

            Assert.IsTrue(report.HasError(member1, memberNameExp), "Expected validation failure for member1. Name was null...");
            Assert.IsTrue(report.HasError(member2, memberNameExp), "Expected validation failure for member2. Name was null...");
        }
Example #4
0
        public void ShouldSkipValidationWhenShortCircuiting()
        {
            var president     = new Member(null);
            var club          = new Club(president);
            var report        = new ValidationReport();
            var memberNameExp = new EquatableExpression(ExpressionHelper.New <Member, string>(mm => mm.Name));
            var presidentExp  = new EquatableExpression(ExpressionHelper.New <Club, Member>(cc => cc.President));

            //Report an error on the President expression...
            report.AddError(new ValidationError(new EqualRule <int>(2), presidentExp, new object[0], club));
            _en1.Validate(club, report, ValidationReportDepth.FieldShortCircuit);
            //because an error has already been reported on the club's president, the member's name rule would not have been invoked
            Assert.IsFalse(report.HasError(president, memberNameExp));

            //Now try this again without short-circuiting
            _en1.Validate(club, report, ValidationReportDepth.All);
            Assert.IsTrue(report.HasError(president, memberNameExp));
        }
 public void ShouldThrowArgumentException()
 {
     //NOTE: Can only accept Func's with 1 parameter.
     new EquatableExpression(ExpressionHelper.New <ClassA, int, int>((a, b) => 123));
 }