Пример #1
0
 public object CreateObject(ExpressionCreationConditions conditions, ExpressionCreationContext context)
 {
     if (this.creationWithContextCallback != null) {
         return this.creationWithContextCallback(context);
     } else {
         return this.creationCallback();
     }
 }
        public void AddTypeToRepository()
        {
            // Arrange
            var conditions = new ExpressionCreationConditions(maxDepth: 10);
            var context = new ExpressionCreationContext { RequestedReturnType = typeof(DateTime) };
            var objectCreator = new DefaultObjectCreator();
            objectCreator.TypeRepository = GetMockRepository();

            // Act
            objectCreator.TypeRepository.AddType(typeof(DateTime));
            var created = objectCreator.CreateObject(conditions, context);

            // Assert
            Assert.IsInstanceOf<DateTime>(created);
        }
        public void AddParameterlessMethodToRepository()
        {
            // Arrange
            var conditions = new ExpressionCreationConditions(maxDepth: 10);
            var context = new ExpressionCreationContext { RequestedReturnType = typeof(int) };
            var objectCreator = new DefaultObjectCreator();
            objectCreator.TypeRepository = GetMockRepository();

            // Act
            objectCreator.TypeRepository.AddMethod(new Func<int>(() => { return 5; }));
            var created = objectCreator.CreateObject(conditions, context);

            // Assert
            Assert.AreEqual(5, created);
        }
        public void AddAssemblyToRepository()
        {
            // Arrange
            var conditions = new ExpressionCreationConditions(maxDepth: 3);
            var context = new ExpressionCreationContext { RequestedReturnType = typeof(GotoExpression) };
            var objectCreator = new DefaultObjectCreator();
            objectCreator.TypeRepository = GetMockRepository();

            // Act
            objectCreator.TypeRepository.AddAssembly(typeof(GotoExpression).Assembly); // System.Core
            var created = objectCreator.CreateObject(conditions, context);

            // Assert
            Assert.IsInstanceOf<GotoExpression>(created);
        }
        public void AddParameterMethodToRepository()
        {
            // Arrange
            var conditions = new ExpressionCreationConditions(maxDepth: 10);
            var context = new ExpressionCreationContext { RequestedReturnType = typeof(long) };
            var objectCreator = new DefaultObjectCreator();
            objectCreator.TypeRepository = GetMockRepository();

            // Act
            objectCreator.TypeRepository.AddMethod(new Func<DateTime, DateTime, long>((time1, time2) => { return time1.Ticks + time1.Ticks; }));
            objectCreator.TypeRepository.AddMethod(new Func<DateTime>(() => { return DateTime.Now; }));
            var created = objectCreator.CreateObject(conditions, context);

            // Assert
            Assert.IsInstanceOf<long>(created);
        }
        public void StopEvaluatingAppropriatelyWithContext()
        {
            // Arrange
            var conditions = new ExpressionCreationConditions(maxDepth: 3);
            var context = new ExpressionCreationContext { RequestedReturnType = typeof(int) };
            var objectCreator = new DefaultObjectCreator();
            objectCreator.TypeRepository = GetMockRepository();

            // Act
            objectCreator.TypeRepository.AddMethod(new Func<int, int, int>((int1, int2) => { return int1 + int2; }));
            objectCreator.TypeRepository.AddMethod(new Func<int>(() => { return 1; }));
            var created = objectCreator.CreateObject(conditions, context);

            // Assert
            // - - - - 4 - - - (Depth 1)
            // - - 2 - - - 2 - (Depth 2)
            // - 1 - 1 - 1 - 1 (Depth 3)
            Assert.AreEqual(4, created);
        }
        public void RecoverFromThrownException()
        {
            // Arrange
            var conditions = new ExpressionCreationConditions(maxDepth: 10);
            var context = new ExpressionCreationContext { RequestedReturnType = typeof(long) };
            var objectCreator = new DefaultObjectCreator();
            objectCreator.TypeRepository = GetMockRepository();

            // Act
            objectCreator.TypeRepository.AddMethod(new Func<long>(() => { throw new InvalidOperationException(); })); // Should recover
            objectCreator.TypeRepository.AddMethod(new Func<long>(() => { return 10; }));
            var created = objectCreator.CreateObject(conditions, context);

            // Assert
            Assert.AreEqual(10, created);
            Assert.IsInstanceOf<Exception>(context.EvaluationExceptions[0]);
        }
        public void NextTest()
        {
            // Arrange
            var conditions = new ExpressionCreationConditions(maxDepth: 3);
            var context = new ExpressionCreationContext { RequestedReturnType = typeof(int) };
            var objectCreator = new DefaultObjectCreator();
            objectCreator.TypeRepository = GetMockRepository();

            // Act

            // Assert
        }
        public void CreateObjectWithoutSufficientTypes()
        {
            // Arrange
            var conditions = new ExpressionCreationConditions(maxDepth: 10);
            var context = new ExpressionCreationContext { RequestedReturnType = typeof(int) };
            var objectCreator = new DefaultObjectCreator();
            objectCreator.TypeRepository = GetMockRepository();

            // Act
            objectCreator.TypeRepository.AddMethod(new Func<DateTime, int>((time) => { throw new InvalidOperationException(); }));
            var created = objectCreator.CreateObject(conditions, context);
        }
        public void CreateObjectWithoutAnyTypes()
        {
            // Arrange
            var conditions = new ExpressionCreationConditions(maxDepth: 10);
            var context = new ExpressionCreationContext { RequestedReturnType = typeof(DateTime) };
            var objectCreator = new DefaultObjectCreator();
            objectCreator.TypeRepository = GetMockRepository();

            // Act & Assert
            Assert.Throws<ObjectCreationException>(() =>
                {
                    var created = objectCreator.CreateObject(conditions, context);
                });
        }
        public void CreateObjectWithNullContext()
        {
            // Arrange
            var conditions = new ExpressionCreationConditions(maxDepth: 10);
            var objectCreator = new DefaultObjectCreator();
            objectCreator.TypeRepository = GetMockRepository();
            objectCreator.TypeRepository.AddType(typeof(DateTime));

            // Act
            Assert.Throws<ArgumentNullException>(() =>
                {
                    objectCreator.CreateObject(conditions, null);
                });
        }
        public void NewExpression_MaxDepth1FromBuilder_ShouldReturnDepth1()
        {
            // Arrange
            var builder = new RandomExpressionBuilder();
            MockTestObjectCreator objectCreator = new MockTestObjectCreator(() => { return 123; });
            builder.ExpressionCreator.NewObjectCreator = objectCreator;
            builder.CreationConditions = new ExpressionCreationConditions(maxDepth: 1);
            var creationConditions = new ExpressionCreationConditions(maxDepth: 1000);

            // Act
            var expression = (ConstantExpression)builder.NewExpression(ExpressionType.Add, creationConditions);

            // Assert
            Assert.AreEqual(123, expression.Value);
        }
        private void TestRequestReturnOfDoubleType(RandomExpressionBuilder builder, ExpressionCreationConditions conditions)
        {
            // Arrange
            MockTestObjectCreator objectCreator = new MockTestObjectCreator((context) => {
                if (context.RequestedReturnType == typeof(double)) {
                    return 2.5;
                }

                throw new InvalidOperationException();
            });
            builder.ExpressionCreator.NewObjectCreator = objectCreator;

            // Act
            var expression = builder.NewExpression(ExpressionType.Subtract, conditions);

            // Assert
            Assert.AreEqual(ExpressionType.Subtract, expression.NodeType);
            Assert.AreEqual(typeof(double), expression.Type);
            Assert.AreEqual(typeof(double), ((ConstantExpression)((BinaryExpression)expression).Left).Type);
            Assert.AreEqual(typeof(double), ((ConstantExpression)((BinaryExpression)expression).Right).Type);
        }
        public void NewExpression_RequestExpressionFromNewExpresssion_CreateSpecificType()
        {
            // Arrange
            var builder = new RandomExpressionBuilder();
            var conditions = new ExpressionCreationConditions(maxDepth: 2, requestedType: typeof(double));

            // Act
            // Assert
            this.TestRequestReturnOfDoubleType(builder, conditions);
        }
        public void NewExpression_RequestExpressionFromBothBuilderAndNewExpresssion_OverrideWithBuilderConditions()
        {
            // Arrange
            var builder = new RandomExpressionBuilder();
            builder.CreationConditions = new ExpressionCreationConditions(maxDepth: 2, requestedType: typeof(double));
            var conditions = new ExpressionCreationConditions(maxDepth: 50, requestedType: typeof(string));

            // Act
            // Assert
            this.TestRequestReturnOfDoubleType(builder, conditions);
        }
Пример #16
0
 public bool CanCreate(ExpressionCreationConditions conditions, ExpressionCreationContext context)
 {
     return true;
 }