public void ast_loop_with_block_expression_return_block_expression_that_calcul_even_occurence_between_start_value_and_end_value()
{
int val1 = new Random().Next(0, 1000);
int val2;
do
{
val2 = new Random().Next(0, 5000);
} while (val1 > val2);
// Creating a parameter expression.
ParameterExpression startValue = Expression.Parameter(typeof(int), "startValue");
ParameterExpression endValue = Expression.Parameter(typeof(int), "endValue");
// Compile and run an expression tree.
BlockExpression block = (BlockExpression)NoMonkeyTree.AstLoopWithBlock(val1, startValue, endValue);
ExpressionType.Loop.Should().Be(block.Result.NodeType);
int result = Expression.Lambda <Func <int, int, int> >(block, startValue, endValue).Compile()(val1, val2);
int evenOccurence = 0;
for (int i = ++val1; i <= val2; i++)
{
if ((i & 1) != 1)
{
evenOccurence++;
}
}
evenOccurence.Should().Be(result);
}
public void ast_play_with_string_should_return_expression_concat_of_two_strings()
{
BinaryExpression stringExpr = NoMonkeyTree.AstStringOperator();
((ConstantExpression)stringExpr.Left).Value.Should().Be("toto");
((ConstantExpression)stringExpr.Right).Value.Should().Be("tata");
Expression.Lambda <Func <string> >(stringExpr).Compile()().Should().Be("tototata");
}
public void ast_return_expression_that_call_our_own_method_substract()
{
Random rand = new Random();
int c1 = rand.Next(Int32.MinValue, Int32.MaxValue);
int c2 = rand.Next(Int32.MinValue, Int32.MaxValue);
Expression expr = NoMonkeyTree.AstCallCustomFunctionSubstract(c1, c2);
var func = Expression.Lambda <Func <int> >(expr).Compile();
func.Invoke().Should().Be(c1 - c2);
}
public void ast_string_and_datetime_loop_should_return_toto_and_Me_for_even_date_else_You()
{
for (int i = 0; i < 500; i++)
{
var date = DateTime.UtcNow.Millisecond;
var expression = NoMonkeyTree.AstStringAndDateTime(date);
var shouldResult = ("toto" + ((date & 1) == 1 ? "You" : "Me"));
expression.Left.NodeType.Should().Be(ExpressionType.Constant);
expression.Right.NodeType.Should().Be(ExpressionType.Constant);
var result = Expression.Lambda <Func <string> >(expression).Compile()();
result.Should().Be(shouldResult);
}
}
public void ast_create_simple_expression_with_basic_operators_and_return_linqexpression_that_do_the_calcul()
{
BinaryExpression ast = NoMonkeyTree.AstSimpleOperator();
ast.NodeType.Should().Be(ExpressionType.Divide);
BinaryExpression astMultiply = (BinaryExpression)ast.Left;
ConstantExpression const1 = (ConstantExpression)ast.Right;
astMultiply.NodeType.Should().Be(ExpressionType.Multiply);
const1.Value.Should().Be(4);
BinaryExpression astAddition = (BinaryExpression)astMultiply.Left;
ConstantExpression const2 = (ConstantExpression)astMultiply.Right;
astAddition.NodeType.Should().Be(ExpressionType.Add);
const2.Value.Should().Be(3);
ConstantExpression const3 = (ConstantExpression)astAddition.Left;
ConstantExpression const4 = (ConstantExpression)astAddition.Right;
const3.Value.Should().Be(3);
const4.Value.Should().Be(5);
ast.ToString().Should().Be("(((3 + 5) * 3) / 4)");
var result = Expression.Lambda <Func <int> >(ast).Compile()();
result.Should().Be(6);
}
public void ast_usage_of_func_should_return_result_multiplication_of_two_numbers()
{
Expression <Func <int, int, int> > expr = (Expression <Func <int, int, int> >)NoMonkeyTree.AstFuncMultilplication();
expr.NodeType.Should().Be(ExpressionType.Lambda);
expr.Parameters[0].NodeType.Should().Be(ExpressionType.Parameter);
expr.Parameters[1].NodeType.Should().Be(ExpressionType.Parameter);
expr.Compile()(3, 5).Should().Be(15);
expr.Compile()(7, 5).Should().Be(35);
expr.Compile()(9, 9).Should().Be(81);
expr.Compile()(10, 5).Should().Be(50);
}