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());
}
