public void ShouldTranslateADeclaredBlockVariableKeyword() { var variable = Expression.Variable(typeof(string), "string"); var writeLine = CreateLambda(() => Console.WriteLine("La la la")); var block = Expression.Block(new[] { variable }, writeLine.Body); var translated = ToReadableString(block); const string EXPECTED = @" string @string; Console.WriteLine(""La la la"");"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateALambdaConstant() { var lambda = CreateLambda((int num) => Enumerable.Range(num, 10).Select(i => new { Index = i }).Sum(d => d.Index)); var lambdaConstant = Expression.Constant(lambda, lambda.GetType()); var translated = ToReadableString(lambdaConstant); const string EXPECTED = @"num => Enumerable.Range(num, 10).Select(i => new { Index = i }).Sum(d => d.Index)"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateAMultipleLineComment() { var comment = ReadableExpression.Comment(@" Not worth commenting on but I will anyway"); var translated = ToReadableString(comment); const string EXPECTED = @" // Not worth commenting on // but I will anyway"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateAnExplicitOperator() { var toIntExplicitOperator = typeof(CustomAdder).GetExplicitOperator(o => o.To <int>()); var translated = toIntExplicitOperator.ToReadableString(); const string EXPECTED = @" public static explicit operator int ( WhenTranslatingMethodInfos.CustomAdder adder )"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateAnInfiniteLoop() { var writeLine = CreateLambda(() => Console.WriteLine()); var loop = Loop(writeLine.Body); var translated = loop.ToReadableString(); const string EXPECTED = @" while (true) { Console.WriteLine(); }"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateAnOutParameter() { var method = typeof(Helper) .GetPublicStaticMethod(nameof(Helper.StaticOutParameter)); var translated = method.ToReadableString(); const string EXPECTED = @" public static string WhenTranslatingMethodInfos.Helper.StaticOutParameter ( out int value )"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateABlockWithAComment() { var comment = ReadableExpression.Comment("Anyone listening?"); var beep = CreateLambda(() => Console.Beep()); var commentedBeep = Block(comment, beep.Body); var translated = ToReadableString(commentedBeep); const string EXPECTED = @" // Anyone listening? Console.Beep();"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateMultilineBlockSingleMethodArguments() { var intVariable = Variable(typeof(int), "i"); var variableInit = Assign(intVariable, Constant(3)); var variableMultiplyFive = Multiply(intVariable, Constant(5)); var variableAdditionOne = Assign(intVariable, variableMultiplyFive); var variableDivideThree = Divide(intVariable, Constant(3)); var variableAdditionTwo = Assign(intVariable, variableDivideThree); var argumentBlock = Block( new[] { intVariable }, variableInit, variableAdditionOne, variableAdditionTwo, intVariable); var catchBlock = Catch( typeof(Exception), Block(ReadableExpression.Comment("So what!"), Constant(0))); var tryCatch = TryCatch(argumentBlock, catchBlock); var collectionVariable = Variable(typeof(ICollection <int>), "ints"); var addMethod = collectionVariable.Type.GetPublicInstanceMethod("Add"); var addMethodCall = Call(collectionVariable, addMethod, tryCatch); var translated = ToReadableString(addMethodCall); const string EXPECTED = @" ints.Add( { try { var i = 3; i = i * 5; i = i / 3; return i; } catch { // So what! return 0; } })"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateAParamsParameter() { var method = typeof(ParamsHelper) .GetPublicStaticMethod(nameof(ParamsHelper.OptionalParams)); var translated = method.ToReadableString(); const string EXPECTED = @" public static string ParamsHelper.OptionalParams ( string value, params string[] stringsToAdd )"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateARefParameter() { var method = typeof(Helper) .GetPublicStaticMethod(nameof(Helper.StaticRefParameter)) .MakeGenericMethod(typeof(List <List <int> >)); var translated = method.ToReadableString(); const string EXPECTED = @" public static void WhenTranslatingMethodInfos.Helper.StaticRefParameter<List<List<int>>> ( ref List<List<int>> value )"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldSplitLongTernariesOntoMultipleLines() { var longTernary = CreateLambda((int veryLongNamedVariable) => veryLongNamedVariable > 10 ? veryLongNamedVariable * veryLongNamedVariable : veryLongNamedVariable * veryLongNamedVariable * veryLongNamedVariable); var translated = ToReadableString(longTernary); const string EXPECTED = @" veryLongNamedVariable => (veryLongNamedVariable > 10) ? veryLongNamedVariable * veryLongNamedVariable : (veryLongNamedVariable * veryLongNamedVariable) * veryLongNamedVariable"; translated.ShouldBe(EXPECTED.TrimStart()); }
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 ShouldTranslateANewDictionaryExpressionWithAdditions() { var createList = CreateLambda(() => new Dictionary <int, decimal> { { 1, 1.0m }, { 2, 2.0m } }); var translated = ToReadableString(createList.Body); const string EXPECTED = @" new Dictionary<int, decimal> { { 1, 1m }, { 2, 2m } }"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateNestedBlocks() { var writeLine = CreateLambda(() => Console.WriteLine()); var beep = CreateLambda(() => Console.Beep()); var innerBlock = Expression.Block(writeLine.Body, beep.Body); var outerBlock = Expression.Block(innerBlock, writeLine.Body); var translated = ToReadableString(outerBlock); const string EXPECTED = @" Console.WriteLine(); Console.Beep(); Console.WriteLine();"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateACustomEnumerableAddInitialiser() { var customAdder = CreateLambda((int intOne, int intTwo, int intThree) => new CustomAdder { { intOne, intTwo, intThree } }); var translated = ToReadableString(customAdder.Body); const string EXPECTED = @" new CustomAdder { { intOne, intTwo, intThree } }"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateAConditionalBranchWithAComment() { var comment = ReadableExpression.Comment("Maths works"); var one = Constant(1); var oneEqualsOne = Equal(one, one); var ifOneEqualsOneComment = IfThen(oneEqualsOne, comment); var translated = ToReadableString(ifOneEqualsOneComment); const string EXPECTED = @" if (1 == 1) { // Maths works }"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateANoVariableBlockWithNoReturnValue() { var writeLine = CreateLambda(() => Console.WriteLine()); var beep = CreateLambda(() => Console.Beep()); var read = CreateLambda(() => Console.Read()); var consoleBlock = Expression.Block(writeLine.Body, read.Body, beep.Body); var translated = ToReadableString(consoleBlock); const string EXPECTED = @" Console.WriteLine(); Console.Read(); Console.Beep();"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldFormatAConditionalBranchWithAComment() { var comment = ReadableExpression.Comment("Maths works"); var one = Constant(1); var oneEqualsOne = Equal(one, one); var ifOneEqualsOneComment = IfThen(oneEqualsOne, comment); var translated = ToReadableHtmlString(ifOneEqualsOneComment); const string EXPECTED = @" <span class=""cs"">if </span>(<span class=""nm"">1</span> == <span class=""nm"">1</span>) { <span class=""cm"">// Maths works</span> }"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateAssignmentsOfNestedVariableBlocksWithANestedTernaryReturnValue() { var objectVariable = Expression.Variable(typeof(object), "id"); var objectValue = Expression.Variable(typeof(object), "value"); var longVariable = Expression.Variable(typeof(long), "number"); var longValue = Expression.Variable(typeof(long), "numberValue"); var longTryParse = Expression.Call( null, typeof(long).GetPublicStaticMethod("TryParse", parameterCount: 2), Expression.Call(objectVariable, typeof(object).GetPublicInstanceMethod("ToString")), longValue); var objectNotNull = Expression.NotEqual(objectVariable, Expression.Default(typeof(object))); var defaultlong = Expression.Default(typeof(long)); var objectAslongOrDefault = Expression.Condition( objectNotNull, Expression.Condition(longTryParse, longValue, defaultlong), defaultlong); var longParseInnerBlock = Expression.Block(new[] { longValue }, objectAslongOrDefault); var longParseOuterBlock = Expression.Block( new[] { objectVariable }, Expression.Assign(objectVariable, objectValue), longParseInnerBlock); var longAssignment = Expression.Assign(longVariable, longParseOuterBlock); var translated = ToReadableString(longAssignment); const string EXPECTED = @" number = { var id = value; long numberValue; return (id != null) ? long.TryParse(id.ToString(), out numberValue) ? numberValue : default(long) : default(long); }"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateMultiStatementValueBlockAssignments() { var valueConditional = GetReturnStatementBlock(out var existingInts); var consoleRead = CreateLambda(() => Console.Read()); var multiStatementValueBlock = Expression.Block( new[] { existingInts }, consoleRead.Body, valueConditional); var resultVariable = Expression.Variable(multiStatementValueBlock.Type, "result"); var resultOneAssignment = Expression.Assign(resultVariable, multiStatementValueBlock); var translated = ToReadableString(resultOneAssignment); const string EXPECTED = @" result = { List<int> ints; Console.Read(); return (ints == null) ? new List<int>() : { var enumerator = ints.GetEnumerator(); while (true) { if (enumerator.MoveNext()) { var item = enumerator.Current; ints.Add(item); } else { break; } } return ints; }; }"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateANewExpressionWithMultipleInitialisations() { var createMemoryStream = CreateLambda(() => new MemoryStream { Capacity = 10000, Position = 100 }); var translated = ToReadableString(createMemoryStream.Body); const string EXPECTED = @" new MemoryStream { Capacity = 10000, Position = 100L }"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateASingleLineIfStatement() { var intVariable = Variable(typeof(int), "i"); var one = Constant(1); var intVariableLessThanOne = LessThan(intVariable, one); var writeLessThan = CreateLambda(() => Console.Write("Less than")); var ifLessThanOneThenWrite = IfThen(intVariableLessThanOne, writeLessThan.Body); var translated = ifLessThanOneThenWrite.ToReadableString(); const string EXPECTED = @" if (i < 1) { Console.Write(""Less than""); }"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateANoVariableBlockLambdaWithAReturnValue() { var writeLine = CreateLambda(() => Console.WriteLine()); var read = CreateLambda(() => Console.Read()); var returnReadResult = Expression.Return(Expression.Label(typeof(int)), read.Body, typeof(int)); var consoleBlock = Expression.Block(writeLine.Body, returnReadResult); var consoleLambda = Expression.Lambda <Func <int> >(consoleBlock); var translated = ToReadableString(consoleLambda); const string EXPECTED = @"() => { Console.WriteLine(); return Console.Read(); }"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateAnExplicitTypeNewArrayExpressionWithAdditions() { var createDisposables = CreateLambda(() => new IDisposable[] { new StreamReader(File.OpenRead(@"C:\temp\my-file.txt")), new MemoryStream() }); var translated = createDisposables.Body.ToReadableString(); const string EXPECTED = @" new IDisposable[] { new StreamReader(File.OpenRead(""C:\\temp\\my-file.txt"")), new MemoryStream() }"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateAssignmentOutcomeTests() { var intVariable = Variable(typeof(int), "i"); var intValue = Constant(123); var intAssignment = Assign(intVariable, intValue); var intDefault = Default(typeof(int)); var assignmentResultNotDefault = NotEqual(intAssignment, intDefault); var doNothing = Default(typeof(void)); var ifNotdefaultDoNothing = IfThen(assignmentResultNotDefault, doNothing); var translated = ifNotdefaultDoNothing.ToReadableString(); const string EXPECTED = @" if ((i = 123) != default(int)) { }"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateAMultipleAccessVariableBlockWithNoReturnValue() { var countVariable = Expression.Variable(typeof(ulong), "count"); var assignTenToCount = Expression.Assign(countVariable, Expression.Constant((ulong)10)); var addTwoToCount = Expression.AddAssign(countVariable, Expression.Constant((ulong)2)); var countBlock = Expression.Block( new[] { countVariable }, assignTenToCount, addTwoToCount); var translated = ToReadableString(countBlock); const string EXPECTED = @" var count = 10; count += 2;"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldSplitLongArgumentListsOntoMultipleLines() { var intsMethod = typeof(HelperClass) .GetPublicInstanceMethod("GiveMeSomeInts"); var helperVariable = Variable(typeof(HelperClass), "helper"); var longVariable = Variable(typeof(int), "thisVariableReallyHasAVeryLongNameIndeed"); var intsMethodCall = Call(helperVariable, intsMethod, longVariable, longVariable, longVariable); var translated = ToReadableString(intsMethodCall); const string EXPECTED = @" helper.GiveMeSomeInts( thisVariableReallyHasAVeryLongNameIndeed, thisVariableReallyHasAVeryLongNameIndeed, thisVariableReallyHasAVeryLongNameIndeed)"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateAnExplicitTypeNewArrayExpressionWithAdditions() { var createDisposables = CreateLambda(() => new IDisposable[] { new StreamReader(string.Empty), new MemoryStream() }); var translated = ToReadableString(createDisposables.Body); const string EXPECTED = @" new IDisposable[] { new StreamReader(string.Empty), new MemoryStream() }"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateAssignmentsOfNestedVariableBlocksWithATernaryReturnValue() { var objectVariable = Expression.Variable(typeof(object), "id"); var objectValue = Expression.Variable(typeof(object), "value"); var intVariable = Expression.Variable(typeof(int), "num"); var intValue = Expression.Variable(typeof(int), "numValue"); var objectNotNull = Expression.NotEqual(objectVariable, Expression.Default(typeof(object))); var defaultInt = Expression.Default(typeof(int)); var intTryParse = Expression.Call( typeof(int).GetPublicStaticMethod("TryParse", parameterCount: 2), Expression.Condition( objectNotNull, Expression.Call(objectVariable, typeof(object).GetPublicInstanceMethod("ToString")), Expression.Default(typeof(string))), intValue); var objectAsIntOrDefault = Expression.Condition(intTryParse, intValue, defaultInt); var intParseInnerBlock = Expression.Block(new[] { intValue }, objectAsIntOrDefault); var intParseOuterBlock = Expression.Block( new[] { objectVariable }, Expression.Assign(objectVariable, objectValue), intParseInnerBlock); var intAssignment = Expression.Assign(intVariable, intParseOuterBlock); var translated = ToReadableString(intAssignment); const string EXPECTED = @" num = { var id = value; int numValue; return int.TryParse((id != null) ? id.ToString() : null, out numValue) ? numValue : default(int); }"; translated.ShouldBe(EXPECTED.TrimStart()); }
public void ShouldTranslateASwitchStatementWithADefault() { var intVariable = Variable(typeof(int), "i"); var writeOne = CreateLambda(() => Console.WriteLine("One")); var writeTwo = CreateLambda(() => Console.WriteLine("Two")); var writeThree = CreateLambda(() => Console.WriteLine("Three")); var writeOneTwoThree = Block(writeOne.Body, writeTwo.Body, writeThree.Body); var switchStatement = Switch( intVariable, writeOneTwoThree, SwitchCase(writeOne.Body, Constant(1)), SwitchCase(writeTwo.Body, Constant(2)), SwitchCase(writeThree.Body, Constant(3))); var translated = switchStatement.ToReadableString(); const string EXPECTED = @" switch (i) { case 1: Console.WriteLine(""One""); break; case 2: Console.WriteLine(""Two""); break; case 3: Console.WriteLine(""Three""); break; default: Console.WriteLine(""One""); Console.WriteLine(""Two""); Console.WriteLine(""Three""); break; }"; translated.ShouldBe(EXPECTED.TrimStart()); }