public void ShouldTranslateALoopWithABreakStatement()
        {
            var intVariable           = Expression.Variable(typeof(int), "i");
            var intGreaterThanTwo     = Expression.GreaterThan(intVariable, Expression.Constant(2));
            var breakLoop             = Expression.Break(Expression.Label());
            var ifGreaterThanTwoBreak = Expression.IfThen(intGreaterThanTwo, breakLoop);
            var writeLine             = CreateLambda(() => Console.WriteLine());
            var incrementVariable     = Expression.Increment(intVariable);
            var loopBody = Expression.Block(ifGreaterThanTwoBreak, writeLine.Body, incrementVariable);
            var loop     = Expression.Loop(loopBody, breakLoop.Target);

            var translated = ToReadableString(loop);

            const string EXPECTED = @"
while (true)
{
    if (i > 2)
    {
        break;
    }

    Console.WriteLine();
    ++i;
}";

            translated.ShouldBe(EXPECTED.TrimStart());
        }
Пример #2
0
        public void ShouldTranslateAMultipleLineIfStatementTest()
        {
            var intVariable             = Expression.Variable(typeof(int), "i");
            var one                     = Expression.Constant(1);
            var intVariableLessThanOne  = Expression.LessThan(intVariable, one);
            var returnLabel             = Expression.Label(typeof(bool), "Return");
            var returnTrue              = Expression.Return(returnLabel, Expression.Constant(true));
            var ifLessThanOneReturnTrue = Expression.IfThen(intVariableLessThanOne, returnTrue);
            var five                    = Expression.Constant(5);
            var intVariableMoreThanFive = Expression.GreaterThan(intVariable, five);
            var returnMoreThanFive      = Expression.Label(returnLabel, intVariableMoreThanFive);
            var testBlock               = Expression.Block(ifLessThanOneReturnTrue, returnMoreThanFive);

            var writeHello            = CreateLambda(() => Console.WriteLine("Hello"));
            var writeVariable         = Expression.Variable(writeHello.Type, "write");
            var assignWrite           = Expression.Assign(writeVariable, writeHello);
            var ifTestPassesThenWrite = Expression.IfThen(testBlock, assignWrite);

            var translated = ToReadableString(ifTestPassesThenWrite);

            const string EXPECTED = @"
if ({
        if (i < 1)
        {
            return true;
        }

        return i > 5;
    })
{
    write = () => Console.WriteLine(""Hello"");
}";

            translated.ShouldBe(EXPECTED.TrimStart());
        }
        public void ShouldWrapAnAssignmentTernaryTestInParentheses()
        {
            var intVariable1 = Expression.Variable(typeof(int), "i");
            var intVariable2 = Expression.Variable(typeof(int), "j");

            var intVariable2GreaterThanOne = Expression.GreaterThan(intVariable2, Expression.Constant(1));

            var threeOrDefault = Expression.Condition(
                intVariable2GreaterThanOne,
                Expression.Constant(3),
                Expression.Default(typeof(int)));

            var assignment = Expression.Assign(intVariable1, threeOrDefault);

            var translated = ToReadableString(assignment);

            translated.ShouldBe("i = (j > 1) ? 3 : default(int)");
        }
Пример #4
0
        public void ShouldTranslateAMultipleClauseIfStatement()
        {
            var intVariable            = Expression.Variable(typeof(int), "i");
            var one                    = Expression.Constant(1);
            var intVariableLessThanOne = Expression.LessThan(intVariable, one);
            var intVariableMoreThanOne = Expression.GreaterThan(intVariable, one);
            var intVariableInRange     = Expression.AndAlso(intVariableLessThanOne, intVariableMoreThanOne);
            var writeHello             = CreateLambda(() => Console.WriteLine("Hello"));
            var ifLessThanOneThenWrite = Expression.IfThen(intVariableInRange, writeHello.Body);

            var translated = ToReadableString(ifLessThanOneThenWrite);

            const string EXPECTED = @"
if ((i < 1) && (i > 1))
{
    Console.WriteLine(""Hello"");
}";

            translated.ShouldBe(EXPECTED.TrimStart());
        }
Пример #5
0
        public void ShouldBreakLongMultipleConditionsOntoMultipleLines()
        {
            var intVariable1          = Expression.Variable(typeof(int), "thisVariableHasALongName");
            var intVariable2          = Expression.Variable(typeof(int), "thisOtherVariableHasALongNameToo");
            var int1IsGreaterThanInt2 = Expression.GreaterThan(intVariable1, intVariable2);
            var int1IsNotEqualToInt2  = Expression.NotEqual(intVariable1, intVariable2);

            var intIsInRange     = Expression.AndAlso(int1IsGreaterThanInt2, int1IsNotEqualToInt2);
            var writeYo          = CreateLambda(() => Console.WriteLine("Yo!"));
            var ifInRangeWriteYo = Expression.IfThen(intIsInRange, writeYo.Body);


            var translated = ToReadableString(ifInRangeWriteYo);

            const string EXPECTED = @"
if ((thisVariableHasALongName > thisOtherVariableHasALongNameToo) &&
    (thisVariableHasALongName != thisOtherVariableHasALongNameToo))
{
    Console.WriteLine(""Yo!"");
}";

            translated.ShouldBe(EXPECTED.TrimStart());
        }