public void DefaultValues() { var sut = new UnknownExpression(); Assert.AreNotEqual(0, sut.GetHashCode()); Assert.AreNotEqual(1, sut.GetHashCode()); }
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)); }
public void Equality() { var a = new UnknownExpression(); var b = new UnknownExpression(); Assert.AreEqual(a, b); Assert.AreEqual(a.GetHashCode(), b.GetHashCode()); }
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)); }
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); }
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); }
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); }
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 }); }
public IfElseExpression() { Condition = new UnknownExpression(); ThenExpression = new UnknownExpression(); ElseExpression = new UnknownExpression(); }
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); }
public BinaryExpression() { LeftOperand = new UnknownExpression(); RightOperand = new UnknownExpression(); }
public ExpressionStatement() { Expression = new UnknownExpression(); }
public EventSubscriptionStatement() { Reference = new UnknownReference(); Expression = new UnknownExpression(); }
public CaseBlock() { Label = new UnknownExpression(); Body = Lists.NewList <IStatement>(); }
public void VisitorWithReturnIsImplemented() { var sut = new UnknownExpression(); sut.Accept(23).VerifyWithReturn(v => v.Visit(sut, 23)); }
public IfElseBlock() { Condition = new UnknownExpression(); Then = Lists.NewList <IStatement>(); Else = Lists.NewList <IStatement>(); }
public DoLoop() { Condition = new UnknownExpression(); Body = Lists.NewList <IStatement>(); }
public void UnknownExpression() { var sst = new UnknownExpression(); AssertPrint(sst, "???"); }