public void IsConstant_UseVariableStringExpression_ShouldReturnFalse()
        {
            //Setup
            var expr = Lambda.Expr((object x) => x.ToString());

            //Exercise
            var actual = expr.Body.IsConstant("");

            //Verify
            actual.Should().BeFalse();
        }
        public void ToLambda_FromLambdaExpression_ShouldBeTheSame()
        {
            //Setup
            var expected = Lambda.Expr((DateTime x) => x.TimeOfDay);

            //Exercise
            var actual = expected.ToLambda();

            //Verify
            actual.Should().BeSameAs(expected);
        }
        public void IsConstant_UseConstantStringExpressionAndPassDifferentValue_ShouldReturnFalse()
        {
            //Setup
            var expr = Lambda.Expr(() => "true");

            //Exercise
            var actual = expr.Body.IsConstant("true ");

            //Verify
            actual.Should().BeFalse();
        }
        public void IsConstant_UseConstantBoolExpressionAndPassStringValue_ShouldReturnFalse()
        {
            //Setup
            var expr = Lambda.Expr(() => true);

            //Exercise
            var actual = expr.Body.IsConstant(true.ToString());

            //Verify
            actual.Should().BeFalse();
        }
        public void IsConstant_UseConstantNullExpression_ShouldReturnTrue()
        {
            //Setup
            var expr = Lambda.Expr <string>(() => null);

            //Exercise
            var actual = expr.Body.IsConstant(null);

            //Verify
            actual.Should().BeTrue();
        }
        public void IsConstant_UseConstantStringExpression_ShouldReturnTrue()
        {
            //Setup
            var expr = Lambda.Expr(() => "true");

            //Exercise
            var actual = expr.Body.IsConstant("true");

            //Verify
            actual.Should().BeTrue();
        }
        public void RemoveConvert_FromLambdaExpressionWithAndAlsoOperationAndAutoCast_ShouldBeAndAlsoBinaryExpression()
        {
            //Setup
            var expr = Lambda.Expr <string, object>(x => x.IsNormalized() && x.Length == 1);

            //Exercise
            var actual = expr.RemoveConvert();

            //Verify
            actual.Should().NotBeNull().And.BeAssignableTo <BinaryExpression>()
            .Which.NodeType.Should().Be(ExpressionType.AndAlso);
        }
        public void RemoveConvert_FromConstantLambdaExpressionWithAutoCast_ShouldBeConstantExpression()
        {
            //Setup
            var expr = Lambda.Expr <object>(() => true);

            //Exercise
            var actual = expr.RemoveConvert();

            //Verify
            actual.Should().NotBeNull().And.BeOfType <ConstantExpression>()
            .Which.Value.Should().Be(true);
        }
 public NestedMethodExpressionWithoutParamAttribute()
     : base(Lambda.Expr(() => 1.ToString().ToLower()))
 {
 }
 public SingleMethodExpressionWithTwoParamsAttribute()
     : base(Lambda.Expr((DateTime x, string format) => x.ToString(format)))
 {
 }
 public NestedMemberExpressionWithOneParamAttribute()
     : base(Lambda.Expr((DateTime x) => x.TimeOfDay.Minutes))
 {
 }
 public SingleMemberExpressionWithOneParamAttribute()
     : base(Lambda.Expr((DateTime x) => x.TimeOfDay))
 {
 }
Пример #13
0
 public AutoDataAttribute()
 {
     Fixture.Register(() => new MyFixture());
     Fixture.Register(() => Lambda.Expr <A, int>(x => x.Prop1));
     Fixture.Register(() => Lambda.Expr <B, int>(x => x.Prop2));
 }