public void IsEvaluatableMemberAssignment()
        {
            var filter = new TestableEvaluatableExpressionFilterBase();
            var result = filter.IsEvaluatableMemberAssignment(ExpressionInstanceCreator.CreateMemberAssignment());

            Assert.That(result, Is.True);
        }
        public void IsEvaluatableMemberMemberBinding()
        {
            var filter = new TestableEvaluatableExpressionFilterBase();
            var result = filter.IsEvaluatableMemberMemberBinding(ExpressionInstanceCreator.CreateMemberMemberBinding(new MemberBinding[0]));

            Assert.That(result, Is.True);
        }
        public void IsEvaluatableCatchBlock()
        {
            var filter = new TestableEvaluatableExpressionFilterBase();
            var result = filter.IsEvaluatableCatchBlock(ExpressionInstanceCreator.CreateCatchBlock());

            Assert.That(result, Is.True);
        }
    public void IsEvaluatableElementInit ()
    {
      var filter = new TestableEvaluatableExpressionFilterBase();
      var result = filter.IsEvaluatableElementInit (ExpressionInstanceCreator.CreateElementInit());

      Assert.That (result, Is.True);
    }
        public void IsEvaluatableExpression()
        {
            var supportedExpressionTypeValues =
                Enum.GetValues(typeof(ExpressionType))
                .Cast <ExpressionType>()
                .Except(
                    new[]
            {
                ExpressionType.Parameter,
#if !NET_3_5
                ExpressionType.Extension,
                ExpressionType.RuntimeVariables,
#endif
            })
                .ToArray();

            foreach (var expressionType in supportedExpressionTypeValues)
            {
                var expressionInstance = ExpressionInstanceCreator.GetExpressionInstance(expressionType);
                if (expressionInstance == null)
                {
                    continue;
                }

                var methods = typeof(EvaluatableExpressionFilterBase).FindMembers(
                    MemberTypes.Method,
                    BindingFlags.Instance | BindingFlags.Public,
                    (memberInfo, criteria) => memberInfo.Name.StartsWith("IsEvaluatable") &&
                    ((MethodInfo)memberInfo).GetParameters().All(pi => pi.ParameterType.IsInstanceOfType(criteria)),
                    expressionInstance)
                              .Cast <MethodInfo>().ToArray();
                Assert.That(methods.Count(), Is.LessThan(2), "Found more than one method for ExpressionType '{0}'.", expressionType);
                Assert.That(methods, Is.Not.Empty, "Method for ExpressionType '{0}' was not found.", expressionType);
                var method = methods.Single();

                var filter = new TestableEvaluatableExpressionFilterBase();
                var result = (bool)method.Invoke(filter, new object[] { expressionInstance });

                Assert.That(result, Is.True);
            }
        }
    public void IsEvaluatableExpression ()
    {
      var supportedExpressionTypeValues =
          Enum.GetValues (typeof (ExpressionType))
              .Cast<ExpressionType>()
              .Except (
                  new[]
                  {
                      ExpressionType.Parameter,
#if !NET_3_5
                      ExpressionType.Extension,
                      ExpressionType.RuntimeVariables,
#endif
                  })
              .ToArray();

      foreach (var expressionType in supportedExpressionTypeValues)
      {
        var expressionInstance = ExpressionInstanceCreator.GetExpressionInstance (expressionType);
        if (expressionInstance == null)
          continue;

        var methods = typeof (EvaluatableExpressionFilterBase).FindMembers (
            MemberTypes.Method,
            BindingFlags.Instance | BindingFlags.Public,
            (memberInfo, criteria) => memberInfo.Name.StartsWith ("IsEvaluatable")
                                      && ((MethodInfo) memberInfo).GetParameters().All (pi => pi.ParameterType.IsInstanceOfType (criteria)),
            expressionInstance)
            .Cast<MethodInfo>().ToArray();
        Assert.That (methods.Count(), Is.LessThan (2), "Found more than one method for ExpressionType '{0}'.", expressionType);
        Assert.That (methods, Is.Not.Empty, "Method for ExpressionType '{0}' was not found.", expressionType);
        var method = methods.Single();

        var filter = new TestableEvaluatableExpressionFilterBase();
        var result = (bool) method.Invoke (filter, new object[] { expressionInstance });

        Assert.That (result, Is.True);
      }
    }
    public void IsEvaluatableMemberMemberBinding ()
    {
      var filter = new TestableEvaluatableExpressionFilterBase();
      var result = filter.IsEvaluatableMemberMemberBinding (ExpressionInstanceCreator.CreateMemberMemberBinding (new MemberBinding[0]));

      Assert.That (result, Is.True);
    }