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, "???");
}
