public void MethodGroupAsExtensionMethod()
{
Assert.AreEqual(
"() => (Func<bool>)new[] { 2000, 2004, 2008, 2012 }.Any"
,
ExpressionToCode.ToCode(() => (Func <bool>) new[] { 2000, 2004, 2008, 2012 }.Any));
}
public void AvoidsImplicitBoxingWhenTargetTypeIsAGenericArgument()
{
Assert.AreEqual(
@"() => StaticTestClass.TwoArgsTwoGeneric(3, new object())",
ExpressionToCode.ToCode(() => StaticTestClass.TwoArgsTwoGeneric(3, new object()))
);
}
static void AppendTo(
ExpressionToCodeConfiguration config,
StringBuilder sb,
List <SubExpressionInfo> nodeInfos,
StringifiedExpression node,
ref bool ignoreInitialSpace,
bool showTopExpressionValue)
{
if (node.Text != null)
{
var trimmedText = ignoreInitialSpace ? node.Text.TrimStart() : node.Text;
var pos0 = sb.Length;
sb.Append(trimmedText);
ignoreInitialSpace = node.Text.Any() && ExpressionToCode.ShouldIgnoreSpaceAfter(node.Text[node.Text.Length - 1]);
if (showTopExpressionValue)
{
var valueString = node.OptionalValue == null ? null : ObjectToCodeImpl.ExpressionValueAsCode(config, node.OptionalValue, 0);
if (valueString != null)
{
nodeInfos.Add(new SubExpressionInfo {
Location = pos0 + trimmedText.Length / 2, Value = valueString
});
}
}
}
foreach (var kid in node.Children)
{
AppendTo(config, sb, nodeInfos, kid, ref ignoreInitialSpace, showTopExpressionValue || kid.IsConceptualChild);
}
}
public void NestedLambda_UncertainOverload()
{
Assert.Equal(
@"() => Fizz((int x) => true)",
ExpressionToCode.ToCode(() => Fizz((int x) => true))
); //hard case!
}
public void NestedLambda_TwoParameters()
{
Assert.Equal(
@"() => new[] { 37, 42 }.Select((x, i) => x * 2)",
ExpressionToCode.ToCode(() => new[] { 37, 42 }.Select((x, i) => x * 2))
);
}
public void MembersDefault()
{
Assert.Equal(
@"() => default(DateTime).Ticks == 0L",
ExpressionToCode.ToCode(() => default(DateTime).Ticks == 0L));
Assert.Equal(
@"() => default(int[]).Length == 0",
ExpressionToCode.ToCode(() => default(int[]).Length == 0));
Assert.Equal(
@"() => default(Type).GetTypeInfo().IsLayoutSequential",
ExpressionToCode.ToCode(() => default(Type).GetTypeInfo().IsLayoutSequential));
Assert.Equal(
@"() => default(List<int>).Count",
ExpressionToCode.ToCode(() => default(List <int>).Count));
Assert.Equal(
@"() => default(int[]).Clone() == null",
ExpressionToCode.ToCode(() => default(int[]).Clone() == null));
//default(Type).IsInstanceOfType(new object()) is not compiled as extension method in .net core!
Assert.Equal(
@"() => default(IEnumerable<Type>).Any()",
ExpressionToCode.ToCode(() => default(IEnumerable <Type>).Any()));
Assert.Equal(
@"() => default(List<int>).AsReadOnly()",
ExpressionToCode.ToCode(() => default(List <int>).AsReadOnly()));
}
public void StaticMembers()
{
Assert.AreEqual(
@"() => (DateTime.Now > DateTime.Now + TimeSpan.FromMilliseconds(10.001)).ToString() == ""False""",
ExpressionToCode.ToCode(
() => (DateTime.Now > DateTime.Now + TimeSpan.FromMilliseconds(10.001)).ToString() == "False"));
}
public void TheVariable_ToNameOf()
{
var theVariable = "theValue";
var actual = ExpressionToCode.GetNameIn(() => theVariable);
Assert.Equal("theVariable", actual);
}
public void ListInitializer2()
=> Assert.Equal(
@"() => new List<int>(50) { 1, 2, 3 }.Count == 3",
ExpressionToCode.ToCode(() => new List <int>(50)
{
1, 2, 3
}.Count == 3));
void AssertInGenericMethodWithIntArg <T>()
{
//The expression no longer has any reference to the unbound argument T, so we can't generate the exactly correct code here.
Assert.AreEqual(
"() => new List<int>()",
ExpressionToCode.ToCode(() => new List <T>()));
}
public void TypeParameters3()
{
Assert.AreEqual(
@"() => new[] { 1, 2, 3 }.Cast<int>()",
ExpressionToCode.ToCode(() => new[] { 1, 2, 3 }.Cast <int>())
); //should not remove type parameters where these cannot be inferred!
}
public void StraightforwardInference()
{
Assert.AreEqual(
@"() => StaticTestClass.Identity(3)",
ExpressionToCode.ToCode(() => StaticTestClass.Identity(3))
);
}
public void CannotInferOneParam()
{
Assert.AreEqual(
@"() => StaticTestClass.IsType<int, int>(3)",
ExpressionToCode.ToCode(() => StaticTestClass.IsType <int, int>(3))
);
}
public void ArrayLength()
{
var arr = new[] { 1 };
var actual = ExpressionToCode.ToValuedCode(() => arr.Length);
Assert.Equal("arr.Length = 1", actual);
}
public void TheStringVariable()
{
var theVariable = "theValue";
var actual = ExpressionToCode.ToValuedCode(() => theVariable);
Assert.Equal("theVariable = theValue", actual);
}
public void MembersDefault()
{
#pragma warning disable CS8602 // Dereference of a possibly null reference. - these are false positives, because the code isn't executed, it's stringified.
#pragma warning disable CS8625 // Cannot convert null literal to non-nullable reference type. - these are false positives, because the code isn't executed, it's stringified.
Assert.Equal(
@"() => default(DateTime).Ticks == 0L",
ExpressionToCode.ToCode(() => default(DateTime).Ticks == 0L));
Assert.Equal(
@"() => default(int[]).Length == 0",
ExpressionToCode.ToCode(() => default(int[]).Length == 0));
Assert.Equal(
@"() => default(Type).GetTypeInfo().IsLayoutSequential",
ExpressionToCode.ToCode(() => default(Type).GetTypeInfo().IsLayoutSequential));
Assert.Equal(
@"() => default(List<int>).Count",
ExpressionToCode.ToCode(() => default(List <int>).Count));
Assert.Equal(
@"() => default(int[]).Clone() == null",
ExpressionToCode.ToCode(() => default(int[]).Clone() == null));
//default(Type).IsInstanceOfType(new object()) is not compiled as extension method in .net core!
Assert.Equal(
@"() => default(IEnumerable<Type>).Any()",
ExpressionToCode.ToCode(() => default(IEnumerable <Type>).Any()));
Assert.Equal(
@"() => default(List<int>).AsReadOnly()",
ExpressionToCode.ToCode(() => default(List <int>).AsReadOnly()));
#pragma warning restore CS8602 // Dereference of a possibly null reference.
#pragma warning restore CS8625 // Cannot convert null literal to non-nullable reference type.
}
public void BlockVariablesTest()
{
var p = Expression.Parameter(typeof(int), "p");
var x = Expression.Parameter(typeof(int), "x");
Expression assignment = Expression.Assign(p, x);
Assert.Equal(@"{ int p; int x; p = x; }", ExpressionToCode.ToCode(Expression.Block(typeof(void), new[] { p, x }, assignment)));
}
public void MultipleStatementsBlockTest()
{
var p = Expression.Parameter(typeof(int), "p");
Expression assignment = Expression.Assign(p, Expression.Constant(1));
Expression addAssignment = Expression.AddAssign(p, Expression.Constant(5));
Assert.Equal(@"{ int p; p = 1; p += 5; }", ExpressionToCode.ToCode(Expression.Block(typeof(void), new[] { p }, assignment, addAssignment)));
}
public void FormattableStringFactory_IsRenderedAsInterpolation()
{
Assert.Equal(
@"() => Interpolation($""abc"")",
ExpressionToCode.ToCode(
() => Interpolation(FormattableStringFactory.Create("abc", new object[] { }))
));
}
public void AddOperator()
{
var x = 0;
Assert.Equal(
@"() => 1 + x + 2 == 4",
ExpressionToCode.ToCode(() => 1 + x + 2 == 4));
}
public void NullableFlagsEnumComplexConstant()
{
SomeFlagsEnum?abc = SomeFlagsEnum.A | SomeFlagsEnum.B | SomeFlagsEnum.C;
Assert.AreEqual(
@"() => abc == (SomeFlagsEnum?)(SomeFlagsEnum.AB | SomeFlagsEnum.C)",
ExpressionToCode.ToCode(() => abc == (SomeFlagsEnum.AB | SomeFlagsEnum.C)));
}
public void NullableFlagsEnumConstant()
{
SomeFlagsEnum?ab = SomeFlagsEnum.A | SomeFlagsEnum.B;
Assert.AreEqual(
@"() => ab == (SomeFlagsEnum?)SomeFlagsEnum.AB",
ExpressionToCode.ToCode(() => ab == SomeFlagsEnum.AB));
}
public void IndexerAccess()
{
var dict = Enumerable.Range(1, 20).ToDictionary(n => n.ToString());
Assert.Equal(
@"() => dict[""3""] == 3",
ExpressionToCode.ToCode(() => dict["3"] == 3));
}
public void TheMethod_ToNameOf()
{
var x = 1;
var y = "";
var actual = ExpressionToCode.GetNameIn(() => TheComplexMethod(x, y));
Assert.Equal("TheComplexMethod", actual);
}
public void ToValuedCode_ofNull_fails()
{
ExpressionToCodeLibTest obj = null;
Assert.ThrowsAny <InvalidOperationException>(
() =>
ExpressionToCode.ToValuedCode(() => obj.TheProperty));
}
private void BuildQuery(QueryContext c)
{
_builder.AppendLine("public " + c.OutputType.GetCompilableTypeName(_rewrittenTypes)
+ " " + c.Name + "(" + c.InputType.GetCompilableTypeName(_rewrittenTypes) + " request)");
_builder.AppendLine("{");
_builder++;
_builder.AppendLine("Console.Write(\".\");");
// local vars
foreach (var s in c.TempSymbolsByAlias)
{
_builder.AppendLine(s.Value.Type.GetCompilableTypeName(_rewrittenTypes) + " " + s.Key + ";");
}
if (c.TempSymbolsByAlias.Count > 0)
_builder.AppendLine();
// final query
var codeBuilder = new ExpressionToCode(c.RootExpression, c);
var code = codeBuilder.GenCode(_builder.Indent);
_builder.AppendLine(code + ";");
_builder--;
_builder.AppendLine("}");
_builder.AppendLine();
}
