public void GivenNullExpressionWhenGetEnumeratorCalledThenShouldReturnEmpty()
        {
            var target = new ExpressionEnumerator(null)
                         .ToList();

            Assert.Empty(target);
        }
        public void GivenBinaryWithConversionWhenGetEnumeratorCalledThenShouldIncludeConversion()
        {
            var target = new ExpressionEnumerator(BinaryWithConversion)
                         .ToList();
            var lamda = target.Single(t => t.NodeType == ExpressionType.Lambda);

            Assert.Equal(typeof(Func <int, int>), lamda.Type);
        }
        public void WhenGetEnumeratorCalledWithNewExpressionThenShouldReturnSubExpressions()
        {
            Expression <Func <object> > expr = () => new { id = 1, name = nameof(expr) };
            var target = new ExpressionEnumerator(expr).ToList();

            Assert.Single(target.OfType <NewExpression>());
            Assert.Equal(2, target.OfType <ConstantExpression>().Count());
        }
        public void GivenBinaryWhenGetEnumeratorCalledThenShouldReturnExpressions()
        {
            var target = new ExpressionEnumerator(Add)
                         .ToList();

            Assert.True(target.OfType <BinaryExpression>().Any());
            Assert.Equal(2, target.OfType <ConstantExpression>().Count());
        }
        public void GivenLambdaWhenEnumeratorCalledThenShouldReturnExpressions()
        {
            var target = new ExpressionEnumerator(Lambda)
                         .ToList();

            Assert.True(target.OfType <LambdaExpression>().Any());
            Assert.True(target.OfType <ParameterExpression>().Any());
        }
 public void GivenAnExpressionWithInitializationWhenGetEnumeratorCalledThenShouldReturnSubExpressions()
 {
     var query = new List <Foo>().AsQueryable().Select(f => new Bar(f.Id.ToString())
     {
         Other = f.Id
     });
     var tree = new ExpressionEnumerator(query.Expression).ToList();
 }
        public void WhenGetEnumeratorCalledWithConstantExpressionThenShouldReturnEnumerator()
        {
            var target = new ExpressionEnumerator(Forty)
                         .ToList();

            Assert.Single(target);
            Assert.True(target.OfType <ConstantExpression>()
                        .Any());
        }
        public void GivenDefaultWhenEnumeratorCalledThenShouldReturnExpressions()
        {
            var invocation = Expression.Invoke(
                Lambda, Expression.Constant(this));
            var target = new ExpressionEnumerator(invocation)
                         .ToList();

            Assert.True(target.OfType <InvocationExpression>().Any());
        }
        public void WhenGetEnumeratorCalledWithNestedConstantExpressionThenShouldReturnEnumerator()
        {
            var wrapped = Expression.Constant(Forty);
            var target  = new ExpressionEnumerator(wrapped)
                          .ToList();

            Assert.Equal(2, target.Count);
            Assert.True(target.All(t => t.NodeType ==
                                   ExpressionType.Constant));
        }
        public void GivenUnaryWhenEnumeratorCalledThenShouldReturnExpressions()
        {
            var unary = Expression.Convert(Expression.Constant(this),
                                           typeof(object));
            var target = new ExpressionEnumerator(unary)
                         .ToList();

            Assert.True(target.OfType <UnaryExpression>().Any());
            Assert.True(target.OfType <ConstantExpression>().Any());
        }
        public void WhenGetEnumeratorCalledWithInvocationExpressionThenShouldReturnSubExpressions()
        {
            Expression <Func <object> > expr = () => new { id = 1, name = nameof(expr) };
            var invocation = Expression.Invoke(expr, expr.Parameters);
            var target     = new ExpressionEnumerator(invocation).ToList();

            Assert.Single(target.OfType <InvocationExpression>());
            Assert.Single(target.OfType <LambdaExpression>());
            Assert.Single(target.OfType <NewExpression>());
            Assert.Equal(2, target.OfType <ConstantExpression>().Count());
        }
        public void GivenMemberAccessWhenEnumeratorCalledThenShouldReturnExpressions()
        {
            var member = Expression
                         .MakeMemberAccess(
                Expression.Constant(this),
                GetType().GetMember(nameof(Id)).First());
            var target = new ExpressionEnumerator(member).ToList();

            Assert.True(target.OfType <MemberExpression>().Any());
            Assert.True(target.OfType <ConstantExpression>().Any());
        }
        public void WhenGetEnumeratorToStringCalledThenShouldReturnExpressionTree()
        {
            var query = new List <IdType>().AsQueryable().Where(
                i => i.IdVal < int.MinValue || (i.Message.Contains("aa") &&
                                                !string.IsNullOrEmpty(i.Id)))
                        .OrderBy(i => i.IdVal)
                        .Select(i => new { hash = i.GetHashCode() });
            var target = new ExpressionEnumerator(query.Expression);
            var actual = target.ToString();

            Assert.NotEmpty(actual);
        }
        public void GivenMethodCallWhenEnumeratorCalledThenShouldReturnExpressions()
        {
            var method = Expression.Call(
                typeof(DateTime),
                nameof(DateTime.Parse),
                null,
                Expression.Parameter(typeof(string)));
            var target = new ExpressionEnumerator(method)
                         .ToList();

            Assert.True(target.OfType <MethodCallExpression>().Any());
            Assert.True(target.OfType <ParameterExpression>().Any());
        }
        public void WhenGetEnumeratorCalledWithNewArrayExpressionThenShouldReturnSubExpressions()
        {
            var numbers = new[]
            {
                Expression.Constant(1),
                Expression.Constant(2)
            };
            var source = Expression.NewArrayInit(typeof(int), numbers);
            var target = new ExpressionEnumerator(source).ToList();

            Assert.Single(target.OfType <NewArrayExpression>());
            Assert.Equal(2, target.OfType <ConstantExpression>().Count());
        }
Example #16
0
        public void HandlesMemberBindingsAreEquivalent()
        {
            Expression <Func <ExpressionEvaluatorTests> > makeTest =
                () => new ExpressionEvaluatorTests
            {
                Prop = 1
            };
            var members = new ExpressionEnumerator(makeTest)
                          .OfType <MemberInitExpression>()
                          .First()
                          .Bindings;

            Assert.True(evaluator.MemberBindingsAreEquivalent(
                            members[0], members[0]));
        }
Example #17
0
        static void Main(string[] args)
        {
            AssetEditable asset = GenerateSampleAsset();

            var enumerator = new ExpressionEnumerator(typeof(AssetEditable)).ToList();
            var evaluator = new ExpressionEvaluator();

            Console.WriteLine("Type of {0} : ", typeof(AssetEditable).AssemblyQualifiedName);
            foreach (KeyValuePair<string,string> k in enumerator)
            {
                Console.WriteLine("Property name : {0}", k.Key);
                Console.WriteLine("Value : {0}", evaluator.GetValue(asset, k.Key));
                Console.WriteLine();
            }
            Console.ReadLine();
        }
 public void ValidationConstraints_BasicCheckEnumerator()
 {
     var items = new ExpressionEnumerator(new AssetEditable().GetType()).ToList();
     Assert.IsNotNull(items);
     Assert.IsTrue(items.Any());
     var goesToSecondLevelAtLeast = false;
     items.ForEach(i =>
     {
         if (i.Key.Contains("."))
         {
             goesToSecondLevelAtLeast = true;
             return;
         }
     });
     if (!goesToSecondLevelAtLeast) Assert.Fail();
 }
        public void WhenGetEnumeratorCalledWithQueryExpressionThenShouldReturnQueryParts()
        {
            var query = new List <ExpressionEnumeratorTests>()
                        .AsQueryable()
                        .Where(item => item.Id.StartsWith("b"))
                        .Skip(1)
                        .Take(5)
                        .OrderBy(item => item.Id);
            var target = new ExpressionEnumerator(query.Expression)
                         .ToList();

            Assert.True(target.OfType <ConstantExpression>()
                        .Any());
            Assert.Contains(target, t =>
                            t is MethodCallExpression mc &&
                            mc.Method.Name == nameof(Enumerable.Take));
        }