public void ShouldNotLeaveDoubleBlankLinesBetweenIfStatements() { var intVariable = Expression.Variable(typeof(int), "i"); var one = Expression.Constant(1); var intVariableEqualsOne = Expression.Equal(intVariable, one); var doNothing = Expression.Default(typeof(void)); var ifIntEqualsOneDoNothing = Expression.IfThen(intVariableEqualsOne, doNothing); var block = Expression.Block( new[] { intVariable }, ifIntEqualsOneDoNothing, ifIntEqualsOneDoNothing); const string EXPECTED = @" int i; if (i == 1) { } if (i == 1) { }"; var translated = ToReadableString(block); translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateAMultipleLineNonVoidIfElseStatements() { var intVariable = Expression.Variable(typeof(int), "i"); var zero = Expression.Constant(0); var intVariableEqualsZero = Expression.Equal(intVariable, zero); var writeHello = CreateLambda(() => Console.WriteLine("Hello")); var writeGoodbye = CreateLambda(() => Console.WriteLine("Goodbye")); var helloThenGoodbye = Expression.Block(writeHello.Body, writeGoodbye.Body, intVariable); var goodbyeThenHello = Expression.Block(writeGoodbye.Body, writeHello.Body, intVariable); var writeHelloAndGoodbye = Expression.IfThenElse(intVariableEqualsZero, helloThenGoodbye, goodbyeThenHello); var translated = ToReadableString(writeHelloAndGoodbye); const string EXPECTED = @" if (i == 0) { Console.WriteLine(""Hello""); Console.WriteLine(""Goodbye""); return i; } Console.WriteLine(""Goodbye""); Console.WriteLine(""Hello""); return i; "; translated.ShouldBe(EXPECTED.Trim()); }
public void ShouldTranslateAGotoReturnStatement() { var returnTarget = Expression.Label(typeof(int), "Return"); var numberParameter = Expression.Parameter(typeof(string), "i"); var numberEqualsOne = Expression.Equal(numberParameter, Expression.Constant("One")); var returnOne = Expression.Goto(returnTarget, Expression.Constant(1)); var ifOneReturnOne = Expression.IfThen(numberEqualsOne, returnOne); var returnLabel = Expression.Label(returnTarget, Expression.Constant(0)); var gotoBlock = Expression.Block(ifOneReturnOne, returnLabel); var gotoLambda = Expression.Lambda <Func <string, int> >(gotoBlock, numberParameter); gotoLambda.Compile(); var translated = ToReadableString(gotoLambda); const string EXPECTED = @" i => { if (i == ""One"") { return 1; } return 0; }"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldAbbreviateBooleanFalseComparisons() { var boolVariable = Expression.Variable(typeof(bool), "couldBe"); var boolIsFalse = Expression.Equal(Expression.Constant(false), boolVariable); var translated = ToReadableString(boolIsFalse); translated.ShouldBe("!couldBe"); }
public void ShouldAbbreviateBooleanTrueComparisons() { var boolVariable = Expression.Variable(typeof(bool), "couldBe"); var boolIsTrue = Expression.Equal(boolVariable, Expression.Constant(true)); var translated = ToReadableString(boolIsTrue); translated.ShouldBe("couldBe"); }
public void ShouldTranslateGotoStatements() { var labelTargetOne = Expression.Label(typeof(void), "One"); var labelOne = Expression.Label(labelTargetOne); var writeOne = CreateLambda(() => Console.Write("One")); var gotoOne = Expression.Goto(labelTargetOne); var labelTargetTwo = Expression.Label(typeof(void), "Two"); var labelTwo = Expression.Label(labelTargetTwo); var writeTwo = CreateLambda(() => Console.Write("Two")); var gotoTwo = Expression.Goto(labelTargetTwo); var intVariable = Expression.Variable(typeof(int), "i"); var intEqualsOne = Expression.Equal(intVariable, Expression.Constant(1)); var intEqualsTwo = Expression.Equal(intVariable, Expression.Constant(2)); var ifTwoGotoTwo = Expression.IfThen(intEqualsTwo, gotoTwo); var gotoOneOrTwo = Expression.IfThenElse(intEqualsOne, gotoOne, ifTwoGotoTwo); var writeNeither = CreateLambda(() => Console.Write("Neither")); var returnFromBlock = Expression.Return(Expression.Label()); var block = Expression.Block( gotoOneOrTwo, writeNeither.Body, returnFromBlock, labelOne, writeOne.Body, labelTwo, writeTwo.Body); var translated = ToReadableString(block); const string EXPECTED = @" if (i == 1) { goto One; } else if (i == 2) { goto Two; } Console.Write(""Neither""); return; One: Console.Write(""One""); Two: Console.Write(""Two""); "; translated.ShouldBe(EXPECTED.Trim()); }
public void ShouldTranslateEnumComparisonTests() { var flagParameter = Expression.Parameter(typeof(bool), "flag"); var one = Expression.Constant(Test.One); var two = Expression.Constant(Test.Two); var oneOrTwo = Expression.Condition(flagParameter, one, two); var oneOrTwoEqualsTwo = Expression.Equal(oneOrTwo, two); var testLambda = Expression.Lambda <Func <bool, bool> >(oneOrTwoEqualsTwo, flagParameter); var translated = ToReadableString(testLambda); translated.ShouldBe("flag => (flag ? Test.One : Test.Two) == Test.Two"); }
private static Expression GetReturnStatementBlock(out ParameterExpression existingInts) { existingInts = Expression.Variable(typeof(List <int>), "ints"); var existingIntsEnumerator = Expression.Variable(typeof(List <int> .Enumerator), "enumerator"); var getEnumeratorMethod = existingInts.Type.GetPublicInstanceMethod("GetEnumerator"); var getEnumeratorCall = Expression.Call(existingInts, getEnumeratorMethod); var enumeratorAssignment = Expression.Assign(existingIntsEnumerator, getEnumeratorCall); var enumeratorMoveNextMethod = existingIntsEnumerator.Type.GetPublicInstanceMethod("MoveNext"); var enumeratorMoveNextCall = Expression.Call(existingIntsEnumerator, enumeratorMoveNextMethod); var enumeratorItem = Expression.Variable(typeof(int), "item"); var enumeratorCurrent = Expression.Property(existingIntsEnumerator, "Current"); var itemAssignment = Expression.Assign(enumeratorItem, enumeratorCurrent); var intsAddMethod = existingInts.Type.GetPublicInstanceMethod("Add"); var intsAddCall = Expression.Call(existingInts, intsAddMethod, enumeratorItem); var addItemBlock = Expression.Block( new[] { enumeratorItem }, itemAssignment, intsAddCall); var loopBreakTarget = Expression.Label(typeof(void), "LoopBreak"); var conditionallyAddItems = Expression.Condition( Expression.IsTrue(enumeratorMoveNextCall), addItemBlock, Expression.Break(loopBreakTarget)); var addItemsLoop = Expression.Loop(conditionallyAddItems, loopBreakTarget); var populateExistingInts = Expression.Block( new[] { existingIntsEnumerator }, enumeratorAssignment, addItemsLoop); var conditionFalseBlock = Expression.Block( populateExistingInts, existingInts); var valueConditional = Expression.Condition( Expression.Equal(existingInts, Expression.Default(existingInts.Type)), Expression.New(conditionFalseBlock.Type), conditionFalseBlock); return(valueConditional); }
public void ShouldAssignAVariableInAConditionalTest() { var intVariable = Expression.Variable(typeof(int), "i"); var assignVariable = Expression.Assign(intVariable, Expression.Constant(10)); var isAssignmentFive = Expression.Equal(assignVariable, Expression.Constant(5)); var ifFiveDoNothing = Expression.IfThen(isAssignmentFive, Expression.Empty()); var translated = ToReadableString(ifFiveDoNothing); const string EXPECTED = @" if ((i = 10) == 5) { }"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateAConditionalBranchWithAComment() { var comment = ReadableExpression.Comment("Maths works"); var one = Expression.Constant(1); var oneEqualsOne = Expression.Equal(one, one); var ifOneEqualsOneComment = Expression.IfThen(oneEqualsOne, comment); var translated = ToReadableString(ifOneEqualsOneComment); const string EXPECTED = @" if (1 == 1) { // Maths works }"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldLeaveABlankLineBeforeAnIfStatement() { var intVariable = Expression.Variable(typeof(int), "i"); var zero = Expression.Constant(0); var intVariableEqualsZero = Expression.Equal(intVariable, zero); var doNothing = Expression.Default(typeof(void)); var ifIntEqualsZeroDoNothing = Expression.IfThen(intVariableEqualsZero, doNothing); var block = Expression.Block(new[] { intVariable }, ifIntEqualsZeroDoNothing); const string EXPECTED = @" int i; if (i == 0) { }"; var translated = ToReadableString(block); translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldNotVarAssignATernaryValueWithDifferingTypeBranches() { var intVariable = Expression.Variable(typeof(int), "i"); var intVariableEqualsOne = Expression.Equal(intVariable, Expression.Constant(1)); var newArray = Expression.NewArrayBounds(typeof(int?), Expression.Constant(0)); var newList = Expression.New(typeof(List <int?>)); var newArrayOrList = Expression.Condition( intVariableEqualsOne, newArray, newList, typeof(ICollection <int?>)); var resultVariable = Expression.Variable(typeof(ICollection <int?>), "result"); var assignResult = Expression.Assign(resultVariable, newArrayOrList); var assignBlock = Expression.Block(new[] { resultVariable }, assignResult); var translated = ToReadableString(assignBlock); translated.ShouldBe("ICollection<int?> result = (i == 1) ? new int?[0] : new List<int?>();"); }
public void ShouldOnlyRemoveParenthesesIfNecessary() { var intVariable = Expression.Variable(typeof(int), "i"); var intVariableIsOne = Expression.Equal(intVariable, Expression.Constant(1)); var objectVariable = Expression.Variable(typeof(object), "o"); var objectCastToInt = Expression.Convert(objectVariable, typeof(int)); var intToStringMethod = typeof(object).GetPublicInstanceMethod("ToString"); var intToStringCall = Expression.Call(objectCastToInt, intToStringMethod); var emptyString = CreateLambda(() => string.Empty); var toStringOrEmptyString = Expression.Condition( intVariableIsOne, emptyString.Body, intToStringCall); var translated = ToReadableString(toStringOrEmptyString); translated.ShouldBe("(i == 1) ? string.Empty : ((int)o).ToString()"); }
public void ShouldNotLeaveDoubleBlankLinesBetweenInitAndIfStatements() { var writeWat = CreateLambda(() => Console.WriteLine("Wat")); var read = CreateLambda <long>(() => Console.Read()); var newMemoryStream = Expression.New(typeof(MemoryStream)); var positionProperty = newMemoryStream.Type.GetProperty("Position"); var valueBlock = Expression.Block(writeWat.Body, read.Body); // ReSharper disable once AssignNullToNotNullAttribute var positionInit = Expression.Bind(positionProperty, valueBlock); var memoryStreamInit = Expression.MemberInit(newMemoryStream, positionInit); var intVariable = Expression.Variable(typeof(int), "i"); var one = Expression.Constant(1); var intVariableEqualsOne = Expression.Equal(intVariable, one); var doNothing = Expression.Default(typeof(void)); var ifIntEqualsOneDoNothing = Expression.IfThen(intVariableEqualsOne, doNothing); var block = Expression.Block(memoryStreamInit, ifIntEqualsOneDoNothing); const string EXPECTED = @" new MemoryStream { Position = { Console.WriteLine(""Wat""); return ((long)Console.Read()); } }; if (i == 1) { }"; var translated = ToReadableString(block); translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTerminateAMultipleLineMemberInitAssignment() { var writeWat = CreateLambda(() => Console.WriteLine("Wat")); var read = CreateLambda <long>(() => Console.Read()); var newMemoryStream = Expression.New(typeof(MemoryStream)); var positionProperty = newMemoryStream.Type.GetProperty("Position"); var valueBlock = Expression.Block(writeWat.Body, read.Body); // ReSharper disable once AssignNullToNotNullAttribute var positionInit = Expression.Bind(positionProperty, valueBlock); var memoryStreamInit = Expression.MemberInit(newMemoryStream, positionInit); var streamVariable = Expression.Variable(typeof(Stream), "stream"); var assignStream = Expression.Assign(streamVariable, memoryStreamInit); var streamIsNull = Expression.Equal(streamVariable, Expression.Default(typeof(Stream))); var ifNullAssign = Expression.IfThen(streamIsNull, assignStream); var translated = ToReadableString(ifNullAssign); const string EXPECTED = @" if (stream == null) { stream = new MemoryStream { Position = { Console.WriteLine(""Wat""); return ((long)Console.Read()); } }; }"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldSplitLongTernaryOptionsOntoMultipleLines() { var oneEqualsTwo = Expression.Equal(Expression.Constant(1), Expression.Constant(2)); var defaultInt = Expression.Default(typeof(int)); var threeIntsFunc = Expression.Variable(typeof(Func <int, int, int, int>), "threeIntsFunc"); var longVariable = Expression.Variable(typeof(int), "thisVariableReallyHasAVeryLongNameIndeed"); var threeIntsCall = Expression.Invoke(threeIntsFunc, longVariable, longVariable, longVariable); var ternary = Expression.Condition(oneEqualsTwo, defaultInt, threeIntsCall); var translated = ToReadableString(ternary); const string EXPECTED = @" (1 == 2) ? default(int) : threeIntsFunc.Invoke( thisVariableReallyHasAVeryLongNameIndeed, thisVariableReallyHasAVeryLongNameIndeed, thisVariableReallyHasAVeryLongNameIndeed)"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateAnIfElseIfStatement() { var intVariable = Expression.Variable(typeof(int), "i"); var intEqualsOne = Expression.Equal(intVariable, Expression.Constant(1)); var intEqualsTwo = Expression.Equal(intVariable, Expression.Constant(2)); var writeOne = CreateLambda(() => Console.WriteLine("One")); var writeTwo = CreateLambda(() => Console.WriteLine("Two")); var ifTwoWriteTwo = Expression.IfThen(intEqualsTwo, writeTwo.Body); var writeOneOrTwo = Expression.IfThenElse(intEqualsOne, writeOne.Body, ifTwoWriteTwo); var translated = ToReadableString(writeOneOrTwo); const string EXPECTED = @" if (i == 1) { Console.WriteLine(""One""); } else if (i == 2) { Console.WriteLine(""Two""); }"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateAMultipleLineTernaryAssignment() { var consoleRead = CreateLambda(() => Console.Read()); var variableOne = Expression.Variable(typeof(int), "one"); var variableTwo = Expression.Variable(typeof(int), "two"); var resultVariableOne = Expression.Variable(typeof(int), "resultOne"); var variableOneAssignment = Expression.Assign(variableOne, consoleRead.Body); var variableTwoAssignment = Expression.Assign(variableTwo, consoleRead.Body); var variableOneTimesTwo = Expression.Multiply(variableOne, variableTwo); var resultOneAssignment = Expression.Assign(resultVariableOne, variableOneTimesTwo); var ifTrueBlock = Expression.Block( new[] { variableOne, variableTwo, resultVariableOne }, variableOneAssignment, variableTwoAssignment, resultOneAssignment, resultVariableOne); var variableThree = Expression.Variable(typeof(int), "three"); var variableFour = Expression.Variable(typeof(int), "four"); var resultVariableTwo = Expression.Variable(typeof(int), "resultTwo"); var variableThreeAssignment = Expression.Assign(variableThree, consoleRead.Body); var variableFourAssignment = Expression.Assign(variableFour, consoleRead.Body); var variableThreeDivideFour = Expression.Divide(variableThree, variableFour); var resultTwoAssignment = Expression.Assign(resultVariableTwo, variableThreeDivideFour); var ifFalseBlock = Expression.Block( new[] { variableThree, variableFour, resultVariableTwo }, variableThreeAssignment, variableFourAssignment, resultTwoAssignment, resultVariableTwo); var dateTimeNow = Expression.Property(null, typeof(DateTime), "Now"); var nowHour = Expression.Property(dateTimeNow, "Hour"); var nowHourModuloTwo = Expression.Modulo(nowHour, Expression.Constant(2)); var nowHourIsEven = Expression.Equal(nowHourModuloTwo, Expression.Constant(0)); var conditional = Expression.Condition(nowHourIsEven, ifTrueBlock, ifFalseBlock); var resultVariable = Expression.Variable(typeof(int), "result"); var resultAssignment = Expression.Assign(resultVariable, conditional); var translated = ToReadableString(resultAssignment); const string EXPECTED = @" result = ((DateTime.Now.Hour % 2) == 0) ? { var one = Console.Read(); var two = Console.Read(); var resultOne = one * two; return resultOne; } : { var three = Console.Read(); var four = Console.Read(); var resultTwo = three / four; return resultTwo; }"; translated.ShouldBe(EXPECTED.TrimStart()); }