private static void VerifyNullableStructWithStringConstant(Sc?value)
{
Expression <Func <Sc?> > e =
Expression.Lambda <Func <Sc?> >(
Expression.Constant(value, typeof(Sc?)),
Enumerable.Empty <ParameterExpression>());
Func <Sc?> f = e.Compile();
Assert.Equal(value, f());
}
private static Sc?[] GenerateNullableStructWithStringArray(int size)
{
Sc?[] array = new Sc?[] { default(Sc), new Sc(), new Sc(null) };
Sc?[] result = new Sc?[size];
for (int i = 0; i < size; i++)
{
result[i] = array[i % array.Length];
}
return(result);
}
public static void CheckNullableStructWithStringCoalesceTest()
{
Sc?[] array1 = new Sc?[] { null, default(Sc), new Sc(), new Sc(null) };
Sc?[] array2 = new Sc?[] { null, default(Sc), new Sc(), new Sc(null) };
for (int i = 0; i < array1.Length; i++)
{
for (int j = 0; j < array2.Length; j++)
{
VerifyNullableStructWithStringCoalesce(array1[i], array2[j]);
}
}
}
private static void VerifyStructWithStringCoalesce(Sc?a, Sc b, bool useInterpreter)
{
Expression <Func <Sc> > e =
Expression.Lambda <Func <Sc> >(
Expression.Coalesce(
Expression.Constant(a, typeof(Sc?)),
Expression.Constant(b, typeof(Sc))),
Enumerable.Empty <ParameterExpression>());
Func <Sc> f = e.Compile(useInterpreter);
Assert.Equal(a ?? b, f());
}
public static void CheckStructWithStringCoalesceTest(bool useInterpreter)
{
Sc?[] array1 = new Sc?[] { null, default(Sc), new Sc(), new Sc(null) };
Sc[] array2 = new Sc[] { default(Sc), new Sc(), new Sc(null) };
for (int i = 0; i < array1.Length; i++)
{
for (int j = 0; j < array2.Length; j++)
{
VerifyStructWithStringCoalesce(array1[i], array2[j], useInterpreter);
}
}
}
private static void VerifyNullableStructWithString(bool condition, Sc?a, Sc?b, bool useInterpreter)
{
Expression <Func <Sc?> > e =
Expression.Lambda <Func <Sc?> >(
Expression.Condition(
Expression.Constant(condition, typeof(bool)),
Expression.Constant(a, typeof(Sc?)),
Expression.Constant(b, typeof(Sc?))),
Enumerable.Empty <ParameterExpression>());
Func <Sc?> f = e.Compile(useInterpreter);
Assert.Equal(condition ? a : b, f());
}
public static void CheckTernaryNullableStructWithStringTest()
{
bool[] array1 = new bool[] { false, true };
Sc?[] array2 = new Sc?[] { null, default(Sc), new Sc(), new Sc(null) };
for (int i = 0; i < array1.Length; i++)
{
for (int j = 0; j < array2.Length; j++)
{
for (int k = 0; k < array2.Length; k++)
{
VerifyNullableStructWithString(array1[i], array2[j], array2[k]);
}
}
}
}
public static void CheckTernaryArrayNullableStructWithStringArrayTest(bool useInterpreter)
{
bool[] array1 = new bool[] { false, true };
Sc?[][] array2 = new Sc?[][] { null, new Sc?[0], new Sc?[] { default(Sc), new Sc(), new Sc(null) }, new Sc?[100] };
for (int i = 0; i < array1.Length; i++)
{
for (int j = 0; j < array2.Length; j++)
{
for (int k = 0; k < array2.Length; k++)
{
VerifyArrayNullableStructWithStringArray(array1[i], array2[j], array2[k], useInterpreter);
}
}
}
}
private static void VerifyNullableStructWithStringCoalesce(Sc?a, Sc?b)
{
Expression <Func <Sc?> > e =
Expression.Lambda <Func <Sc?> >(
Expression.Coalesce(
Expression.Constant(a, typeof(Sc?)),
Expression.Constant(b, typeof(Sc?))),
Enumerable.Empty <ParameterExpression>());
Func <Sc?> f = e.Compile();
// compute with expression tree
Sc? etResult = default(Sc?);
Exception etException = null;
try
{
etResult = f();
}
catch (Exception ex)
{
etException = ex;
}
// compute with real IL
Sc? csResult = default(Sc?);
Exception csException = null;
try
{
csResult = a ?? b;
}
catch (Exception ex)
{
csException = ex;
}
// either both should have failed the same way or they should both produce the same result
if (etException != null || csException != null)
{
Assert.NotNull(etException);
Assert.NotNull(csException);
Assert.Equal(csException.GetType(), etException.GetType());
}
else
{
Assert.Equal(csResult, etResult);
}
}
private static void VerifyNullableStructWithString(bool condition, Sc?a, Sc?b)
{
Expression <Func <Sc?> > e =
Expression.Lambda <Func <Sc?> >(
Expression.Condition(
Expression.Constant(condition, typeof(bool)),
Expression.Constant(a, typeof(Sc?)),
Expression.Constant(b, typeof(Sc?))),
Enumerable.Empty <ParameterExpression>());
Func <Sc?> f = e.Compile();
Sc? result = default(Sc?);
Exception fEx = null;
try
{
result = f();
}
catch (Exception ex)
{
fEx = ex;
}
Sc? expected = default(Sc?);
Exception csEx = null;
try
{
expected = condition ? a : b;
}
catch (Exception ex)
{
csEx = ex;
}
if (fEx != null || csEx != null)
{
Assert.NotNull(fEx);
Assert.NotNull(csEx);
Assert.Equal(csEx.GetType(), fEx.GetType());
}
else
{
Assert.Equal(expected, result);
}
}
public static void CheckNullableStructWithStringArrayListTest()
{
Sc?[][] array = new Sc?[][]
{
new Sc?[] { },
new Sc?[] { default(Sc) },
new Sc?[] { default(Sc), new Sc(), new Sc(null) }
};
Expression[][] exprs = new Expression[array.Length][];
for (int i = 0; i < array.Length; i++)
{
exprs[i] = new Expression[array[i].Length];
for (int j = 0; j < array[i].Length; j++)
{
Sc?val = array[i][j];
exprs[i][j] = Expression.Constant(val, typeof(Sc?));
}
}
for (int i = 0; i < array.Length; i++)
{
VerifyNullableStructWithStringArrayList(array[i], exprs[i]);
}
}