public void Test004()
        {
            var xgr = new ExpressionGenerator();
            var xpr = new ExpressionReader();

            var expr = xgr.FromFunc(() => default(IQueryable <int>).Where(x => x > 10));

            var result = xpr.GetLambda(expr);

            Assert.AreEqual(expr, result);
            Assert.IsInstanceOfType(result, typeof(LambdaExpression));
        }
        public void Test001()
        {
            var xgr = new ExpressionGenerator();
            var xpr = new ExpressionReader();

            var expr = xgr.FromFunc(()=>default(IQueryable<int>).Where(x=>x > 10));
            var expr2 = ((MethodCallExpression)expr.Body).Arguments[1];

            var body = xpr.GetLambda(expr2);

            Assert.AreNotEqual(expr2, body);
            Assert.IsInstanceOfType(body, typeof(LambdaExpression));
        }
        public void Test001()
        {
            var xgr = new ExpressionGenerator();
            var xpr = new ExpressionReader();

            var expr  = xgr.FromFunc(() => default(IQueryable <int>).Where(x => x > 10));
            var expr2 = ((MethodCallExpression)expr.Body).Arguments[1];

            var body = xpr.GetLambda(expr2);

            Assert.AreNotEqual(expr2, body);
            Assert.IsInstanceOfType(body, typeof(LambdaExpression));
        }
        public void Test003()
        {
            var xgr = new ExpressionGenerator();
            var xpr = new ExpressionReader();

            var param1 = Expression.Parameter(typeof(int));
            var expr = Expression.Call(
                typeof(Queryable),
                "Where",
                new[] { typeof(int) },
                Expression.Default(typeof(IQueryable<int>)),
                Expression.Constant(
                    Expression.Lambda<Func<int, bool>>(
                        Expression.GreaterThan(param1, Expression.Constant(10)),
                        param1
                    )
                )
            );
            var result = xpr.GetLambda(expr);

            Assert.IsNull(result);
        }
        public void Test003()
        {
            var xgr = new ExpressionGenerator();
            var xpr = new ExpressionReader();

            var param1 = Expression.Parameter(typeof(int));
            var expr   = Expression.Call(
                typeof(Queryable),
                "Where",
                new[] { typeof(int) },
                Expression.Default(typeof(IQueryable <int>)),
                Expression.Constant(
                    Expression.Lambda <Func <int, bool> >(
                        Expression.GreaterThan(param1, Expression.Constant(10)),
                        param1
                        )
                    )
                );
            var result = xpr.GetLambda(expr);

            Assert.IsNull(result);
        }
        public void Test002()
        {
            var xgr = new ExpressionGenerator();
            var xpr = new ExpressionReader();

            var param1 = Expression.Parameter(typeof(int));
            var expr = Expression.Call(
                typeof(Queryable),
                "Where",
                new [] { typeof(int) },
                Expression.Default(typeof(IQueryable<int>)),
                Expression.Constant(
                    Expression.Lambda<Func<int, bool>>(
                        Expression.GreaterThan(param1, Expression.Constant(10)),
                        param1
                    )
                )
            );
            var expr2 = expr.Arguments[1];
            var result = xpr.GetLambda(expr2);

            Assert.AreNotEqual(expr2, result);
            Assert.IsInstanceOfType(result, typeof(LambdaExpression));
        }
        public void Test002()
        {
            var xgr = new ExpressionGenerator();
            var xpr = new ExpressionReader();

            var param1 = Expression.Parameter(typeof(int));
            var expr   = Expression.Call(
                typeof(Queryable),
                "Where",
                new [] { typeof(int) },
                Expression.Default(typeof(IQueryable <int>)),
                Expression.Constant(
                    Expression.Lambda <Func <int, bool> >(
                        Expression.GreaterThan(param1, Expression.Constant(10)),
                        param1
                        )
                    )
                );
            var expr2  = expr.Arguments[1];
            var result = xpr.GetLambda(expr2);

            Assert.AreNotEqual(expr2, result);
            Assert.IsInstanceOfType(result, typeof(LambdaExpression));
        }
        public void Test004()
        {
            var xgr = new ExpressionGenerator();
            var xpr = new ExpressionReader();

            var expr = xgr.FromFunc(() => default(IQueryable<int>).Where(x => x > 10));

            var result = xpr.GetLambda(expr);

            Assert.AreEqual(expr, result);
            Assert.IsInstanceOfType(result, typeof(LambdaExpression));
        }