public void Accessor_Guard_String()
{
Assert.Equal(
$"IIF(((t == null) OrElse (t.String == null)), null, {Compat.ExpectedConvert("t.String.Length", "Nullable`1")})",
CompileAccessor(true, "String.Length")
);
}
public void GroupInterval_Numeric()
{
string Compile <T>(string selector, bool guardNulls)
{
var compiler = new RemoteGroupExpressionCompiler <T>(
guardNulls,
new[] {
new GroupingInfo {
Selector = selector, GroupInterval = "123"
}
},
null, null
);
return(compiler.Compile(CreateTargetParam <T>()).ToString());
}
Assert.Contains("I0 = (obj - (obj % 123)", Compile <double>("this", false));
Assert.Contains("I0 = (obj - (obj % 123)", Compile <double?>("this", false));
Assert.Contains(
$"I0 = IIF(((obj == null) OrElse (obj.Item1 == null)), null, {Compat.ExpectedConvert("(obj.Item1.Length - (obj.Item1.Length % 123))", "Nullable`1")})",
Compile <Tuple <string> >("Item1.Length", true)
);
}
public void Accessor_Guard_NullInStruct()
{
Assert.Equal(
$"IIF(((t == null) OrElse (t.StructWithRef.Ref == null)), null, {Compat.ExpectedConvert("t.StructWithRef.Ref.Value", "Nullable`1")})",
CompileAccessor(true, "StructWithRef.Ref.Value")
);
}
public void Accessor_Guard_Nullable()
{
Assert.Equal("IIF((t == null), null, t.Nullable)", CompileAccessor(true, "Nullable"));
Assert.Equal(
$"IIF(((t == null) OrElse (t.Nullable == null)), null, {Compat.ExpectedConvert("t.Nullable.Value.Year", "Nullable`1")})",
CompileAccessor(true, "Nullable.Year")
);
}
static string FormatExpectedSelectorExpr(bool convertToNullable, bool guardNulls)
{
var result = "obj.Item1.Value.Year";
if (convertToNullable)
{
result = Compat.ExpectedConvert(result, "Nullable`1");
}
if (guardNulls)
{
result = $"IIF(((obj == null) OrElse (obj.Item1 == null)), null, {result})";
}
return(result);
}
public void ValueTypeAndNull()
{
// Part of https://devexpress.com/issue=T616169 fix
string CompileOperation(string op)
{
return(Compile <Tuple <int> >(new[] { "Item1", op, null }).Body.ToString());
}
var expectedConvert = Compat.ExpectedConvert("obj.Item1", "Nullable`1");
Assert.Equal($"({expectedConvert} == null)", CompileOperation("="));
Assert.Equal($"({expectedConvert} != null)", CompileOperation("<>"));
// https://stackoverflow.com/q/4399932
Assert.Equal("False", CompileOperation(">"));
Assert.Equal("False", CompileOperation(">="));
Assert.Equal("False", CompileOperation("<"));
Assert.Equal("False", CompileOperation("<="));
}
public void Struct()
{
TestFilter(
new[] {
new DataItemStruct {
Value = 1
},
new DataItemStruct {
Value = 2
},
},
"=", new DataItemStruct {
Value = 1
},
".Where(obj => Equals("
+ Compat.ExpectedConvert("obj", "Object") + ", "
+ Compat.ExpectedConvert("{1}", "Object")
+ "))"
);
}
public void GroupInterval_Date()
{
string Compile <T>(string selector, bool guardNulls)
{
var compiler = new RemoteGroupExpressionCompiler <T>(
guardNulls,
new[] {
new GroupingInfo {
Selector = selector, GroupInterval = "year"
},
new GroupingInfo {
Selector = selector, GroupInterval = "quarter"
},
new GroupingInfo {
Selector = selector, GroupInterval = "month"
},
new GroupingInfo {
Selector = selector, GroupInterval = "day"
},
new GroupingInfo {
Selector = selector, GroupInterval = "dayOfWeek"
},
new GroupingInfo {
Selector = selector, GroupInterval = "hour"
},
new GroupingInfo {
Selector = selector, GroupInterval = "minute"
},
new GroupingInfo {
Selector = selector, GroupInterval = "second"
}
},
null, null
);
return(compiler.Compile(CreateTargetParam <T>()).ToString());
}
{
var expr = Compile <DateTime>("this", false);
Assert.Contains("I0 = obj.Year", expr);
Assert.Contains("I1 = ((obj.Month + 2) / 3)", expr);
Assert.Contains("I2 = obj.Month", expr);
Assert.Contains("I3 = obj.Day", expr);
Assert.Contains("I4 = " + Compat.ExpectedConvert("obj.DayOfWeek", "Int32"), expr);
Assert.Contains("I5 = obj.Hour", expr);
Assert.Contains("I6 = obj.Minute", expr);
Assert.Contains("I7 = obj.Second", expr);
}
{
var expr = Compile <DateTime?>("this", false);
string Wrap(string coreSelector)
{
return(Compat.ExpectedConvert(coreSelector, "Nullable`1"));
}
Assert.Contains("I0 = " + Wrap("obj.Value.Year"), expr);
Assert.Contains("I1 = " + Wrap("((obj.Value.Month + 2) / 3)"), expr);
Assert.Contains("I2 = " + Wrap("obj.Value.Month"), expr);
Assert.Contains("I3 = " + Wrap("obj.Value.Day"), expr);
Assert.Contains("I4 = " + Wrap("obj.Value.DayOfWeek"), expr);
Assert.Contains("I5 = " + Wrap("obj.Value.Hour"), expr);
Assert.Contains("I6 = " + Wrap("obj.Value.Minute"), expr);
Assert.Contains("I7 = " + Wrap("obj.Value.Second"), expr);
}
{
var expr = Compile <Tuple <DateTime?> >("Item1", true);
string Wrap(string coreSelector)
{
return($"IIF(((obj == null) OrElse (obj.Item1 == null)), null, {Compat.ExpectedConvert(coreSelector, "Nullable`1")})");
}
Assert.Contains("I0 = " + Wrap("obj.Item1.Value.Year"), expr);
Assert.Contains("I1 = " + Wrap("((obj.Item1.Value.Month + 2) / 3)"), expr);
Assert.Contains("I2 = " + Wrap("obj.Item1.Value.Month"), expr);
Assert.Contains("I3 = " + Wrap("obj.Item1.Value.Day"), expr);
Assert.Contains("I4 = " + Wrap("obj.Item1.Value.DayOfWeek"), expr);
Assert.Contains("I5 = " + Wrap("obj.Item1.Value.Hour"), expr);
Assert.Contains("I6 = " + Wrap("obj.Item1.Value.Minute"), expr);
Assert.Contains("I7 = " + Wrap("obj.Item1.Value.Second"), expr);
}
}
public void ExpandLinqSumType()
{
var sourceItem = new {
SByte = SByte.MaxValue,
Byte = Byte.MaxValue,
Int16 = Int16.MaxValue,
UInt16 = UInt16.MaxValue,
Int32 = Int32.MaxValue,
UInt32 = UInt32.MaxValue,
Int64 = Int64.MaxValue / 2,
UInt64 = UInt64.MaxValue,
Single = Single.MaxValue,
Double = Double.MaxValue / 2,
Decimal = (Decimal.MaxValue - 1) / 2,
SByteN = (SByte?)SByte.MaxValue,
ByteN = (Byte?)Byte.MaxValue,
Int16N = (Int16?)Int16.MaxValue,
UInt16N = (UInt16?)UInt16.MaxValue,
Int32N = (Int32?)Int32.MaxValue,
UInt32N = (UInt32?)UInt32.MaxValue,
Int64N = (Int64?)Int64.MaxValue / 2,
UInt64N = (UInt64?)UInt64.MaxValue,
SingleN = (Single?)Single.MaxValue,
DoubleN = (Double?)Double.MaxValue / 2,
DecimalN = ((Decimal?)Decimal.MaxValue - 1) / 2
};
var loadOptions = new SampleLoadOptions {
GuardNulls = false,
TotalSummary = new[] {
nameof(sourceItem.SByte),
nameof(sourceItem.Byte),
nameof(sourceItem.Int16),
nameof(sourceItem.UInt16),
nameof(sourceItem.Int32),
nameof(sourceItem.UInt32),
nameof(sourceItem.Int64),
nameof(sourceItem.UInt64),
nameof(sourceItem.Single),
nameof(sourceItem.Double),
nameof(sourceItem.Decimal),
nameof(sourceItem.SByteN),
nameof(sourceItem.ByteN),
nameof(sourceItem.Int16N),
nameof(sourceItem.UInt16N),
nameof(sourceItem.Int32N),
nameof(sourceItem.UInt32N),
nameof(sourceItem.Int64N),
nameof(sourceItem.UInt64N),
nameof(sourceItem.SingleN),
nameof(sourceItem.DoubleN),
nameof(sourceItem.DecimalN),
}
.Select(i => new SummaryInfo {
Selector = i, SummaryType = "sum"
})
.ToArray(),
RemoteGrouping = true,
ExpandLinqSumType = true
};
var summary = DataSourceLoader.Load(new[] { sourceItem, sourceItem }, loadOptions).summary;
var exprText = loadOptions.ExpressionLog.First(line => line.Contains("GroupBy"));
Assert.Contains("Sum(obj => " + Compat.ExpectedConvert("obj.SByte", "Int64"), exprText);
Assert.Contains("Sum(obj => " + Compat.ExpectedConvert("obj.Byte", "Int64"), exprText);
Assert.Contains("Sum(obj => " + Compat.ExpectedConvert("obj.Int16", "Int64"), exprText);
Assert.Contains("Sum(obj => " + Compat.ExpectedConvert("obj.UInt16", "Int64"), exprText);
Assert.Contains("Sum(obj => " + Compat.ExpectedConvert("obj.Int32", "Int64"), exprText);
Assert.Contains("Sum(obj => " + Compat.ExpectedConvert("obj.UInt32", "Int64"), exprText);
Assert.Contains("Sum(obj => obj.Int64", exprText);
Assert.Contains("Sum(obj => " + Compat.ExpectedConvert("obj.UInt64", "Decimal"), exprText);
Assert.Contains("Sum(obj => " + Compat.ExpectedConvert("obj.Single", "Double"), exprText);
Assert.Contains("Sum(obj => obj.Double", exprText);
Assert.Contains("Sum(obj => obj.Decimal", exprText);
Assert.Equal(2m * sourceItem.SByte, summary[0]);
Assert.Equal(2m * sourceItem.Byte, summary[1]);
Assert.Equal(2m * sourceItem.Int16, summary[2]);
Assert.Equal(2m * sourceItem.UInt16, summary[3]);
Assert.Equal(2m * sourceItem.Int32, summary[4]);
Assert.Equal(2m * sourceItem.UInt32, summary[5]);
Assert.Equal(2m * sourceItem.Int64, summary[6]);
Assert.Equal(2m * sourceItem.UInt64, summary[7]);
Assert.Equal(2d * sourceItem.Single, summary[8]);
Assert.Equal(2d * sourceItem.Double, summary[9]);
Assert.Equal(2m * sourceItem.Decimal, summary[10]);
Assert.Equal(2m * sourceItem.SByteN, summary[11]);
Assert.Equal(2m * sourceItem.ByteN, summary[12]);
Assert.Equal(2m * sourceItem.Int16N, summary[13]);
Assert.Equal(2m * sourceItem.UInt16N, summary[14]);
Assert.Equal(2m * sourceItem.Int32N, summary[15]);
Assert.Equal(2m * sourceItem.UInt32N, summary[16]);
Assert.Equal(2m * sourceItem.Int64N, summary[17]);
Assert.Equal(2m * sourceItem.UInt64N, summary[18]);
Assert.Equal(2d * sourceItem.SingleN, summary[19]);
Assert.Equal(2d * sourceItem.DoubleN, summary[20]);
Assert.Equal(2m * sourceItem.DecimalN, summary[21]);
}
public void Accessor_Guard_SingleComponent()
{
Assert.Equal($"IIF((t == null), null, {Compat.ExpectedConvert("t.Value", "Nullable`1")})", CompileAccessor(true, "Value"));
Assert.Equal("IIF((t == null), null, t.Ref)", CompileAccessor(true, "Ref"));
}
