Пример #1
0
        public void DefaultValues()
        {
            var sut = new UnknownExpression();

            Assert.AreNotEqual(0, sut.GetHashCode());
            Assert.AreNotEqual(1, sut.GetHashCode());
        }
Пример #2
0
 public ForLoop()
 {
     Init      = Lists.NewList <IStatement>();
     Condition = new UnknownExpression();
     Step      = Lists.NewList <IStatement>();
     Body      = Lists.NewList <IStatement>();
 }
        public void VisitUnknownNonExtensionExpression()
        {
            var expression = new UnknownExpression(typeof(object));
            var result     = FormattingExpressionVisitor.Format(expression);

            Assert.That(result, Is.EqualTo("[-1]"));
        }
        public void VisitUnknownExpression_Ignored()
        {
            var expression = new UnknownExpression(typeof(object));
            var result     = EvaluatableTreeFindingExpressionTreeVisitor.Analyze(expression);

            Assert.That(result.IsEvaluatableExpression(expression), Is.False);
        }
        public void VisitUnknownNonExtensionExpression_Ignored()
        {
            var expression = new UnknownExpression(typeof(object));
            var result     = ReferenceReplacingExpressionTreeVisitor.ReplaceClauseReferences(expression, _querySourceMapping, true);

            Assert.That(result, Is.SameAs(expression));
        }
        public void ThrowOnUnknownExpressionType()
        {
            var m = new Module(null);
            var e = new UnknownExpression();

            Assert.Throws <InvalidOperationException>(() => ConstantSolver.Solve(e, m.Block));
        }
Пример #7
0
        public void Equality()
        {
            var a = new UnknownExpression();
            var b = new UnknownExpression();

            Assert.AreEqual(a, b);
            Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
        }
Пример #8
0
        public void Clone_VisitsUnknownExtensionExpression_Ignored()
        {
            var expression = new UnknownExpression(typeof(object));

            var queryModel = new QueryModel(_mainFromClause, new SelectClause(expression));
            var clone      = queryModel.Clone();

            Assert.That(clone.SelectClause.Selector, Is.SameAs(expression));
        }
Пример #9
0
        public IAssignableExpression ToAssignableExpr(ICSharpExpression csExpr, IList <IStatement> body)
        {
            IAssignableExpression result = new UnknownExpression();

            Execute.AndSupressExceptions(
                () =>
            {
                result = csExpr == null
                        ? new UnknownExpression()
                        : csExpr.Accept(this, body) ?? new UnknownExpression();
            });
            return(result);
        }
        public void GetTransformers_GenericTransformerRegistered_WithCustomExpressionType()
        {
            var expression = new UnknownExpression(typeof(int));

            var transformerStub = CreateTransformerStub <Expression> (2, null);

            _registry.Register(transformerStub);

            var result1 = _registry.GetTransformations(expression).ToArray();

            Assert.That(result1.Length, Is.EqualTo(1));
            CheckTransformationMatchesTransformer(result1[0], transformerStub);
        }
Пример #11
0
        public IAssignableExpression ToAssignableExpr(IVariableInitializer csExpr, IList <IStatement> body)
        {
            IAssignableExpression result = new UnknownExpression();

            Execute.AndSupressExceptions(
                () =>
            {
                var exprInit = csExpr as IExpressionInitializer;
                if (exprInit != null && exprInit.Value != null)
                {
                    result = exprInit.Value.Accept(this, body) ?? new UnknownExpression();
                }
            });
            return(result);
        }
Пример #12
0
        public void IsSupportedStandardExpression_False()
        {
            var extensionExpression = new TestExtensionExpression(Expression.Constant(0));

            Assert.That(ExpressionTreeVisitor.IsSupportedStandardExpression(extensionExpression), Is.False);

            var unknownExpression = new UnknownExpression(typeof(int));

            Assert.That(ExpressionTreeVisitor.IsSupportedStandardExpression(unknownExpression), Is.False);

            var querySourceReferenceExpression = new QuerySourceReferenceExpression(ExpressionHelper.CreateMainFromClause_Int());

            Assert.That(ExpressionTreeVisitor.IsSupportedStandardExpression(querySourceReferenceExpression), Is.False);

            var subQueryExpression = new SubQueryExpression(ExpressionHelper.CreateQueryModel <Cook>());

            Assert.That(ExpressionTreeVisitor.IsSupportedStandardExpression(subQueryExpression), Is.False);
        }
Пример #13
0
        public ISimpleExpression ToSimpleExpression(ICSharpExpression csExpr, IList <IStatement> body)
        {
            if (csExpr == null)
            {
                return(new UnknownExpression());
            }

            IAssignableExpression expr = new UnknownExpression();

            Execute.AndSupressExceptions(
                () => { expr = csExpr.Accept(this, body) ?? new UnknownExpression(); });

            var simpleExpression = expr as ISimpleExpression;

            if (simpleExpression != null)
            {
                return(simpleExpression);
            }

            var newRef = new VariableReference {
                Identifier = _nameGen.GetNextVariableName()
            };
            var exprIType = csExpr.GetExpressionType().ToIType();
            // TODO write test for this null check
            var exprType = exprIType == null ? Names.UnknownType : exprIType.GetName();

            body.Add(
                new VariableDeclaration
            {
                Reference = newRef,
                Type      = exprType
            });
            body.Add(
                new Assignment
            {
                Reference  = newRef,
                Expression = expr
            });
            return(new ReferenceExpression {
                Reference = newRef
            });
        }
Пример #14
0
 public IfElseExpression()
 {
     Condition      = new UnknownExpression();
     ThenExpression = new UnknownExpression();
     ElseExpression = new UnknownExpression();
 }
Пример #15
0
 public Assignment()
 {
     Reference  = new UnknownReference();
     Expression = new UnknownExpression();
 }
    public void VisitUnknownExpression_Ignored ()
    {
      var expression = new UnknownExpression (typeof (object));
      var result = EvaluatableTreeFindingExpressionVisitor.Analyze (expression, new FakeEvaluatableExpressionFilter());

      Assert.That (result.IsEvaluatableExpression (expression), Is.False);
    }
Пример #17
0
 public BinaryExpression()
 {
     LeftOperand  = new UnknownExpression();
     RightOperand = new UnknownExpression();
 }
 public ExpressionStatement()
 {
     Expression = new UnknownExpression();
 }
Пример #19
0
 public EventSubscriptionStatement()
 {
     Reference  = new UnknownReference();
     Expression = new UnknownExpression();
 }
Пример #20
0
 public CaseBlock()
 {
     Label = new UnknownExpression();
     Body  = Lists.NewList <IStatement>();
 }
Пример #21
0
        public void VisitorWithReturnIsImplemented()
        {
            var sut = new UnknownExpression();

            sut.Accept(23).VerifyWithReturn(v => v.Visit(sut, 23));
        }
Пример #22
0
 public IfElseBlock()
 {
     Condition = new UnknownExpression();
     Then      = Lists.NewList <IStatement>();
     Else      = Lists.NewList <IStatement>();
 }
Пример #23
0
 public DoLoop()
 {
     Condition = new UnknownExpression();
     Body      = Lists.NewList <IStatement>();
 }
        public void UnknownExpression()
        {
            var sst = new UnknownExpression();

            AssertPrint(sst, "???");
        }