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 ShouldIgnoreADefaultVoidExpression()
{
var defaultVoid = Expression.Default(typeof(void));
var translated = ToReadableString(defaultVoid);
translated.ShouldBeNull();
}
public void ShouldAssignTheResultOfATryCatch()
{
var intVariable = Expression.Variable(typeof(int), "i");
var read = CreateLambda(() => Console.Read());
var returnDefault = Expression.Catch(typeof(IOException), Expression.Default(typeof(int)));
var readOrDefault = Expression.TryCatch(read.Body, returnDefault);
var assignReadOrDefault = Expression.Assign(intVariable, readOrDefault);
var translated = ToReadableString(assignReadOrDefault);
const string EXPECTED = @"
i =
{
try
{
return Console.Read();
}
catch (IOException)
{
return default(int);
}
}";
translated.ShouldBe(EXPECTED.TrimStart());
}
public void ShouldTranslateAComplexMethodArgument()
{
var intVariable = Expression.Variable(typeof(int), "intValue");
var dictionaryVariable = Expression.Variable(typeof(Dictionary <string, int>), "dictionary_String_IntValues");
var tryGetValueMethod = dictionaryVariable.Type.GetPublicInstanceMethod("TryGetValue", 2);
var key = Expression.Constant("NumberThatIWantToGet");
var tryGetValueCall = Expression.Call(dictionaryVariable, tryGetValueMethod, key, intVariable);
var defaultInt = Expression.Default(typeof(int));
var valueOrDefault = Expression.Condition(tryGetValueCall, intVariable, defaultInt);
var valueOrDefaultBlock = Expression.Block(new[] { intVariable }, valueOrDefault);
var helperCtor = typeof(HelperClass).GetPublicInstanceConstructors().First();
var helper = Expression.New(helperCtor, defaultInt, defaultInt, defaultInt);
var intsMethod = helper.Type.GetPublicInstanceMethod(nameof(HelperClass.GiveMeSomeInts));
var methodCall = Expression.Call(helper, intsMethod, defaultInt, valueOrDefaultBlock, defaultInt);
var translated = ToReadableString(methodCall);
const string EXPECTED = @"
new HelperClass(default(int), default(int), default(int)).GiveMeSomeInts(
default(int),
{
int intValue;
return dictionary_String_IntValues.TryGetValue(""NumberThatIWantToGet"", out intValue)
? intValue
: default(int);
},
default(int))";
translated.ShouldBe(EXPECTED.TrimStart());
}
public void ShouldTranslateADefaultExpression()
{
var defaultInt = Expression.Default(typeof(uint));
var translated = ToReadableString(defaultInt);
translated.ShouldBe("default(uint)");
}
public void ShouldIndentParamsArrayArgumentsInAnIfTest()
{
var stringTest = CreateLambda(() =>
JoinStrings(",", "[", "i", "]", "[", "j", "]", "[", "k", "]") != string.Empty);
var doNothing = Expression.Default(typeof(void));
var ifTestDoNothing = Expression.IfThen(stringTest.Body, doNothing);
const string EXPECTED = @"
if (WhenFormattingCode.JoinStrings(
"","",
""["",
""i"",
""]"",
""["",
""j"",
""]"",
""["",
""k"",
""]"") != string.Empty)
{
}";
var translated = ToReadableString(ifTestDoNothing);
translated.ShouldBe(EXPECTED.TrimStart());
}
public void ShouldNotVarAssignAVariableAssignedInATryButUsedInACatch()
{
var exceptionFactory = CreateLambda((int number) => new Exception(number.ToString()));
var intVariable = exceptionFactory.Parameters.First();
var newException = exceptionFactory.Body;
var assignment = Expression.Assign(intVariable, Expression.Constant(10));
var assignmentBlock = Expression.Block(assignment, Expression.Default(typeof(void)));
var catchBlock = Expression.Catch(typeof(Exception), Expression.Throw(newException));
var tryCatch = Expression.TryCatch(assignmentBlock, catchBlock);
var tryCatchBlock = Expression.Block(new[] { intVariable }, tryCatch);
var translated = ToReadableString(tryCatchBlock);
const string EXPECTED = @"
int number;
try
{
number = 10;
}
catch
{
throw new Exception(number.ToString());
}";
translated.ShouldBe(EXPECTED.TrimStart());
}
public void ShouldTranslateADefaultString()
{
var nullStringConstant = Expression.Default(typeof(string));
var translated = ToReadableString(nullStringConstant);
translated.ShouldBe("null");
}
public void ShouldNameAnUnnamedVariable()
{
var intVariable = Expression.Variable(typeof(int));
var assignDefaultToInt = Expression.Assign(intVariable, Expression.Default(typeof(int)));
var translated = ToReadableString(assignDefaultToInt);
translated.ShouldBe("@int = default(int)");
}
public void ShouldAbbreviateDefaultBooleanComparisons()
{
var boolVariable = Expression.Variable(typeof(bool), "couldBe");
var boolIsFalse = Expression.Equal(Expression.Default(typeof(bool)), boolVariable);
var translated = ToReadableString(boolIsFalse);
translated.ShouldBe("!couldBe");
}
public void ShouldTranslateAnAssignment()
{
var intVariable = Expression.Variable(typeof(int), "i");
var assignDefaultToInt = Expression.Assign(intVariable, Expression.Default(typeof(int)));
var translated = ToReadableString(assignDefaultToInt);
translated.ShouldBe("i = default(int)");
}
public void ShouldUseFriendlyNamesForArrays()
{
var intArrayVariable = Expression.Variable(typeof(int[]), "ints");
var assignNull = Expression.Assign(intArrayVariable, Expression.Default(intArrayVariable.Type));
var assignNullBlock = Expression.Block(new[] { intArrayVariable }, assignNull);
var translated = ToReadableString(assignNullBlock);
translated.ShouldBe("var ints = default(int[]);");
}
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 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 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)");
}
public void ShouldTranslateAssignmentOutcomeTests()
{
var intVariable = Expression.Variable(typeof(int), "i");
var intValue = Expression.Constant(123);
var intAssignment = Expression.Assign(intVariable, intValue);
var intDefault = Expression.Default(typeof(int));
var assignmentResultNotDefault = Expression.NotEqual(intAssignment, intDefault);
var doNothing = Expression.Default(typeof(void));
var ifNotdefaultDoNothing = Expression.IfThen(assignmentResultNotDefault, doNothing);
var translated = ToReadableString(ifNotdefaultDoNothing);
const string EXPECTED = @"
if ((i = 123) != default(int))
{
}";
translated.ShouldBe(EXPECTED.TrimStart());
}
public void ShouldAssignAVariableInAMethodCallArgument()
{
var stringVariable = Expression.Variable(typeof(string), "value");
var setStringVariableToNull = Expression.Assign(stringVariable, Expression.Default(typeof(string)));
var intVariable = Expression.Variable(typeof(int), "i");
var intToStringMethod = typeof(int)
.GetMethods()
.First(m =>
(m.Name == "ToString") &&
(m.GetParameters().FirstOrDefault()?.ParameterType == typeof(string)));
var intToString = Expression.Call(intVariable, intToStringMethod, setStringVariableToNull);
var translated = ToReadableString(intToString);
translated.ShouldBe("i.ToString(value = null)");
}
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 ShouldTranslateAVariableBlockWithNoReturnValue()
{
var countVariable = Expression.Variable(typeof(int), "count");
var assignZeroToCount = Expression.Assign(countVariable, Expression.Constant(0));
var incrementCount = Expression.Increment(countVariable);
var returnVoid = Expression.Default(typeof(void));
var countBlock = Expression.Block(
new[] { countVariable },
assignZeroToCount,
incrementCount,
returnVoid);
var translated = ToReadableString(countBlock);
const string EXPECTED = @"
var count = 0;
++count;";
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 ShouldTranslateMultilineConstructorParameters()
{
var consoleRead = CreateLambda(() => Console.Read());
var catchAll = Expression.Catch(typeof(Exception), Expression.Default(typeof(int)));
var tryReadInt = Expression.TryCatch(consoleRead.Body, catchAll);
var createStringBuilder = Expression.New(
typeof(StringBuilder).GetPublicInstanceConstructor(typeof(int), typeof(int)),
tryReadInt,
tryReadInt);
const string EXPECTED = @"
new StringBuilder(
{
try
{
return Console.Read();
}
catch
{
return default(int);
}
},
{
try
{
return Console.Read();
}
catch
{
return default(int);
}
})";
var translated = ToReadableString(createStringBuilder);
translated.ShouldBe(EXPECTED.TrimStart());
}
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 ShouldTranslateAnIfStatementWithAConditional()
{
var guidVariable = Expression.Variable(typeof(Guid), "guid");
var defaultGuid = Expression.Default(typeof(Guid));
var guidNotDefault = Expression.NotEqual(guidVariable, defaultGuid);
var guidEmpty = Expression.Field(null, typeof(Guid), "Empty");
var guidNotEmpty = Expression.NotEqual(guidVariable, guidEmpty);
var falseConstant = Expression.Constant(false);
var guidNotEmptyOrFalse = Expression.Condition(guidNotDefault, guidNotEmpty, falseConstant);
var writeGuidFun = CreateLambda(() => Console.Write("GUID FUN!"));
var ifNotEmptyThenWrite = Expression.IfThen(guidNotEmptyOrFalse, writeGuidFun.Body);
var translated = ToReadableString(ifNotEmptyThenWrite);
const string EXPECTED = @"
if ((guid != default(Guid)) ? guid != Guid.Empty : false)
{
Console.Write(""GUID FUN!"");
}";
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 ShouldTranslateAVariableAssignmentWithinACondition()
{
var countVariable = Expression.Variable(typeof(int), "count");
var assignFiveToCount = Expression.Assign(countVariable, Expression.Constant(5));
var isResultLessThanTen = Expression.LessThan(assignFiveToCount, Expression.Constant(10));
var ifResultIsLessThanTenDoNothing = Expression.IfThen(isResultLessThanTen, Expression.Default(typeof(void)));
var countBlock = Expression.Block(new[] { countVariable }, ifResultIsLessThanTenDoNothing);
var countLambda = Expression.Lambda <Action>(countBlock);
var translated = ToReadableString(countLambda);
const string EXPECTED = @"() =>
{
int count;
if ((count = 5) < 10)
{
}
}";
translated.ShouldBe(EXPECTED.TrimStart());
}
public void ShouldVarAssignAVariableUsedInNestedConstructs()
{
var returnLabel = Expression.Label(typeof(long), "Return");
var streamVariable = Expression.Variable(typeof(Stream), "stream");
var memoryStreamVariable = Expression.Variable(typeof(MemoryStream), "memoryStream");
var streamAsMemoryStream = Expression.TypeAs(streamVariable, typeof(MemoryStream));
var memoryStreamAssignment = Expression.Assign(memoryStreamVariable, streamAsMemoryStream);
var nullMemoryStream = Expression.Default(memoryStreamVariable.Type);
var memoryStreamNotNull = Expression.NotEqual(memoryStreamVariable, nullMemoryStream);
var msLengthVariable = Expression.Variable(typeof(long), "msLength");
var memoryStreamLength = Expression.Property(memoryStreamVariable, "Length");
var msLengthAssignment = Expression.Assign(msLengthVariable, memoryStreamLength);
var msTryBlock = Expression.Block(new[] { msLengthVariable }, msLengthAssignment, msLengthVariable);
var newNotSupportedException = Expression.New(typeof(NotSupportedException));
var throwMsException = Expression.Throw(newNotSupportedException, typeof(long));
var msCatchBlock = Expression.Catch(typeof(Exception), throwMsException);
var memoryStreamTryCatch = Expression.TryCatch(msTryBlock, msCatchBlock);
var returnMemoryStreamResult = Expression.Return(returnLabel, memoryStreamTryCatch);
var ifMemoryStreamTryCatch = Expression.IfThen(memoryStreamNotNull, returnMemoryStreamResult);
var fileStreamVariable = Expression.Variable(typeof(FileStream), "fileStream");
var streamAsFileStream = Expression.TypeAs(streamVariable, typeof(FileStream));
var fileStreamAssignment = Expression.Assign(fileStreamVariable, streamAsFileStream);
var nullFileStream = Expression.Default(fileStreamVariable.Type);
var fileStreamNotNull = Expression.NotEqual(fileStreamVariable, nullFileStream);
var fsLengthVariable = Expression.Variable(typeof(long), "fsLength");
var fileStreamLength = Expression.Property(fileStreamVariable, "Length");
var fsLengthAssignment = Expression.Assign(fsLengthVariable, fileStreamLength);
var fsTryBlock = Expression.Block(new[] { fsLengthVariable }, fsLengthAssignment, fsLengthVariable);
var newIoException = Expression.New(typeof(IOException));
var throwIoException = Expression.Throw(newIoException, typeof(long));
var fsCatchBlock = Expression.Catch(typeof(Exception), throwIoException);
var fileStreamTryCatch = Expression.TryCatch(fsTryBlock, fsCatchBlock);
var returnFileStreamResult = Expression.Return(returnLabel, fileStreamTryCatch);
var ifFileStreamTryCatch = Expression.IfThen(fileStreamNotNull, returnFileStreamResult);
var overallBlock = Expression.Block(
new[] { memoryStreamVariable, fileStreamVariable },
memoryStreamAssignment,
ifMemoryStreamTryCatch,
fileStreamAssignment,
ifFileStreamTryCatch,
Expression.Label(returnLabel, Expression.Constant(0L)));
var overallCatchBlock = Expression.Catch(typeof(Exception), Expression.Constant(-1L));
var overallTryCatch = Expression.TryCatch(overallBlock, overallCatchBlock);
const string EXPECTED = @"
try
{
var memoryStream = stream as MemoryStream;
if (memoryStream != null)
{
return
{
try
{
var msLength = memoryStream.Length;
return msLength;
}
catch
{
throw new NotSupportedException();
}
};
}
var fileStream = stream as FileStream;
if (fileStream != null)
{
return
{
try
{
var fsLength = fileStream.Length;
return fsLength;
}
catch
{
throw new IOException();
}
};
}
return 0L;
}
catch
{
return -1L;
}";
var translated = ToReadableString(overallTryCatch);
translated.ShouldBe(EXPECTED.TrimStart());
}
