public void Test002()
{
var xgr = new ExpressionGenerator();
var e1 = xgr.MultiProject(
() => new {
FieldOne = 1,
FieldTwo = "ABC"
},
x => x.FieldTwo + x.FieldOne,
x => "GHI" + x.FieldTwo + x.FieldTwo + "DEF",
(x, y) => new {
InitializerOneResult = x,
InitializerTwoResult = y
}
);
var inputPlaceholder = xgr.FromFunc(() => new {
FieldOne = 1,
FieldTwo = "ABC"
});
var expectations = xgr.FromFunc(inputPlaceholder, x => new {
InitializerOneResult = x.FieldTwo + x.FieldOne,
InitializerTwoResult = "GHI" + x.FieldTwo + x.FieldTwo + "DEF"
});
var inputParam = Expression.Parameter(inputPlaceholder.ReturnType);
var expected = Expression.Lambda(
ExpressionReplacer.Replace(expectations.Body, inputPlaceholder.Body, inputParam),
inputParam
);
var comparer = new ExpressionComparer();
Assert.IsTrue(comparer.AreEqual(expected, e1));
}
public void Test003()
{
var xgr = new ExpressionGenerator();
var l2 = Expression.Lambda<Func<int>>(Expression.Default(typeof(int)));
var l1 = xgr.FromFunc(l2, i2 => new MemberInitData()
{
FieldOne = i2
});
var e1 = (MemberInitExpression)l1.Body;
var e2 = e1.NewExpression;
var e3 = l2.Body;
var replace = new Dictionary<Expression, Expression>
{
{e3,Expression.Constant(1) },
};
var assert = ExpressionVisitorVerifierTool.Test(e1, replace);
assert.WasVisited(e1);
assert.WasNotProduced(e1);
assert.ProductionHas(e1, o1 => o1.NewExpression == e2);
assert.ProductionHas(e1, o1 => o1.Bindings.Count == e1.Bindings.Count);
assert.ProductionHas(e1, o1 => ((MemberAssignment)o1.Bindings[0]).Expression == replace[e3]);
assert.WasVisited(e2);
assert.WasProduced(e2);
assert.WasVisited(e3);
assert.WasProduced(replace[e3]);
assert.WasNotProduced(e3);
assert.TotalVisits(3);
assert.TotalProduced(3);
}
public virtual void Test007()
{
var xgr = new ExpressionGenerator();
var expr1 = xgr.FromFunc(() => new string[] { "A", "B", "C", "D" });
var expr2 = xgr.FromFunc(() => new string[] { "A", "B", "C", "D" });
_assert.AreEqual(expr1, expr2);
}
public virtual void Test002()
{
var xgr = new ExpressionGenerator();
var expr1 = xgr.FromFunc(() => new NewConstructorData(default(string)));
var expr2 = xgr.FromFunc(() => new NewConstructorData(default(int)));
_assert.AreNotEqual(expr1, expr2);
}
public virtual void Test003()
{
var xgr = new ExpressionGenerator();
var expr1 = Expression.Invoke(Expression.Lambda(Expression.Default(typeof(long))));
var expr2 = Expression.Invoke(Expression.Lambda(Expression.Default(typeof(int))));
_assert.AreNotEqual(expr1, expr2);
}
public virtual void Test007()
{
var xgr = new ExpressionGenerator();
var expr1 = xgr.FromFunc(() => default(MethodCallTestData).TwoArgMethod(default(string), default(string)));
var expr2 = xgr.FromFunc(() => default(MethodCallTestData).TwoArgMethod(default(string), default(string)));
_assert.AreEqual(expr1, expr2);
}
public virtual void Test007()
{
var xgr = new ExpressionGenerator();
var expr1 = xgr.FromFunc(() => default(MemberAccessTestData).IntOne);
var expr2 = xgr.FromFunc(() => default(MemberAccessTestData).StringOne);
_assert.AreNotEqual(expr1, expr2);
}
public virtual void Test004()
{
var xgr = new ExpressionGenerator();
var expr1 = Expression.Parameter(typeof(int));
var expr2 = Expression.Parameter(typeof(int));
_assert.AreNotEqual(expr1, expr2);
}
public virtual void Test002()
{
var xgr = new ExpressionGenerator();
var expr1 = xgr.FromFunc(() => new string[10]);
var expr2 = xgr.FromFunc(() => new string[10]);
_assert.AreEqual(expr1, expr2);
}
public virtual void Test003()
{
var xgr = new ExpressionGenerator();
var expr1 = xgr.FromFunc(() => default(MethodCallTestData).IntMethodTwo());
var expr2 = xgr.FromFunc(() => default(MethodCallTestData).IntMethodOne());
_assert.AreNotEqual(expr1, expr2);
}
public void Test001()
{
var xgr = new ExpressionGenerator();
var expr = Expression.Default(typeof(string));
var expr2 = xgr.WithType<string>(expr);
var expr3 = xgr.WithoutType(expr2);
var xcr = new ExpressionComparer();
Assert.IsTrue(xcr.AreEqual(expr, expr3));
}
public virtual void Test003()
{
var xgr = new ExpressionGenerator();
var p1 = xgr.FromFunc(()=>default(string));
var expr1 = xgr.FromFunc(p1, a => new NewConstructorData(a));
var expr2 = xgr.FromFunc(p1, a => new NewConstructorData(a));
_assert.AreEqual(expr1, expr2);
}
public void Test004()
{
var xgr = new ExpressionGenerator();
var xpr = new ExpressionReader();
var expr = xgr.FromFunc(() => default(IQueryable<int>).Where(x => x > 10));
var result = xpr.GetLambda(expr);
Assert.AreEqual(expr, result);
Assert.IsInstanceOfType(result, typeof(LambdaExpression));
}
public virtual void Test006()
{
var xgr = new ExpressionGenerator();
var p1 = Expression.Parameter(typeof(int));
var p2 = Expression.Parameter(typeof(int));
var expr1 = Expression.Invoke(Expression.Lambda(Expression.Default(typeof(int)), p1), Expression.Constant(0, typeof(int)));
var expr2 = Expression.Invoke(Expression.Lambda(Expression.Default(typeof(int)), p2), Expression.Default(typeof(int)));
_assert.AreNotEqual(expr1, expr2);
}
public void Test005()
{
var xgr = new ExpressionGenerator();
var e1 = xgr.FromFunc(() => default(long?));
var e2 = xgr.FromFunc(() => default(long?));
var result = xgr.ConvertExpressions(e1, e2);
Assert.AreEqual(e1.Body, result.Left);
Assert.AreEqual(e2.Body, result.Right);
}
public virtual void Test001()
{
var xgr = new ExpressionGenerator();
// this does not actually generate a ListInit expression
var expr1 = xgr.FromFunc(()=>new Dictionary<int, int> {
});
var expr2 = xgr.FromFunc(() => new Dictionary<int, int> {
});
_assert.AreEqual(expr1, expr2);
Assert.IsNotNull(expr1.Body as MemberInitExpression, "Expected this to be a memberInit");
}
public virtual void Test002()
{
var xgr = new ExpressionGenerator();
var expr1 = Expression.Parameter(typeof(int));
var expr2 = Expression.Parameter(typeof(long));
_assert.AreNotEqual(
new Dictionary<ParameterExpression, ParameterExpression> {
{ expr1, expr2 }
},
expr1, expr2);
}
public void Test001()
{
var xgr = new ExpressionGenerator();
var xpr = new ExpressionReader();
var expr = xgr.FromFunc(()=>default(IQueryable<int>).Where(x=>x > 10));
var expr2 = ((MethodCallExpression)expr.Body).Arguments[1];
var body = xpr.GetLambda(expr2);
Assert.AreNotEqual(expr2, body);
Assert.IsInstanceOfType(body, typeof(LambdaExpression));
}
public override void Generate(ExpressionGenerator gen, int level, Random rand)
{
int a = rand.Next(0, 100) > 15 ? level : 0;
int b = rand.Next(0, 100) > 15 ? level : 0;
if (rand.Next() % 2 == 0)
{
OperandA = Gen(gen, a, rand);
OperandB = Gen(gen, b, rand);
}
else
{
OperandB = Gen(gen, b, rand);
OperandA = Gen(gen, a, rand);
}
}
public virtual void Test002()
{
var xgr = new ExpressionGenerator();
var expr1 = xgr.FromFunc(() => new Dictionary<int, int>
{
{1, 1 }
});
var expr2 = xgr.FromFunc(() => new Dictionary<int, int>
{
{1, 1 }
});
_assert.AreEqual(expr1, expr2);
}
public void Test010()
{
var xgr = new ExpressionGenerator();
var args = GetIntArgs(8);
var actual = xgr.FromFunc(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7],
(a, b, c, d, e, f, g, h) => paramFunc(a, b, c, d, e, f, g, h));
var expected = Expression.Lambda <Func <int> >(
Expression.Call(
null,
typeof(ExpressionGeneratorFromFuncTests).GetMethod("paramFunc").MakeGenericMethod(typeof(int)),
Expression.NewArrayInit(typeof(int), args.Select(a => a.Body).ToArray())
)
);
var comparer = new ExpressionComparer();
Assert.IsTrue(comparer.AreEqual(expected, actual));
}
public virtual void Test006()
{
var xgr = new ExpressionGenerator();
var expr1 = xgr.FromFunc(() => new {
IntOne = default(int),
IntTwo = 1,
StringOne = default(string),
StringTwo = default(string),
});
var expr2 = xgr.FromFunc(() => new {
IntOne = default(int),
IntTwo = default(int),
StringOne = default(string),
StringTwo = default(string),
});
_assert.AreNotEqual(expr1, expr2);
}
public virtual void Test019()
{
var xgr = new ExpressionGenerator();
var expr1 = xgr.FromFunc(() => new Dictionary <int, int>
{
{ 4, 1 },
{ 2, 2 },
{ 3, 3 },
});
var expr2 = xgr.FromFunc(() => new Dictionary <int, int>
{
{ 1, 1 },
{ 2, 2 },
{ 3, 3 },
});
_assert.AreNotEqual(expr1, expr2);
}
public virtual void Test005()
{
var xgr = new ExpressionGenerator();
var expr1 = xgr.FromFunc(() => new {
IntOne = default(int),
IntTwo = default(int),
StringOne = default(string),
StringTwo = default(string),
});
var expr2 = xgr.FromFunc(() => new {
IntOne = default(int),
IntTwo = default(int),
StringOne = default(string),
StringTwo = default(string),
});
_assert.AreEqual(expr1, expr2);
}
public void Setup()
{
var typeMapper = new TypeMapper();
typeMapper.RegisterTypeWrapper <Wrapped.NpgsqlBinaryImporter>(typeof(Original.NpgsqlBinaryImporter));
typeMapper.RegisterTypeWrapper <Wrapped.NpgsqlDbType>(typeof(Original.NpgsqlDbType));
typeMapper.FinalizeMappings();
_wrappedImporter = typeMapper.Wrap <Wrapped.NpgsqlBinaryImporter>(_originalImporter);
var ed = MappingSchema.GetEntityDescriptor(typeof(TestEntity));
_columns = ed.Columns.ToArray();
var generator = new ExpressionGenerator(typeMapper);
var pMapping = Expression.Parameter(typeof(MappingSchema));
var pWriterIn = Expression.Parameter(typeof(Wrapped.NpgsqlBinaryImporter));
var pColumns = Expression.Parameter(typeof(ColumnDescriptor[]));
var pEntity = Expression.Parameter(typeof(TestEntity));
var pWriter = generator.AddVariable(Expression.Parameter(typeof(Original.NpgsqlBinaryImporter)));
generator.Assign(pWriter, Expression.Convert(Expression.PropertyOrField(pWriterIn, "instance_"), typeof(Original.NpgsqlBinaryImporter)));
generator.AddExpression(generator.MapAction((Wrapped.NpgsqlBinaryImporter importer) => importer.StartRow(), pWriter));
for (var i = 0; i < _columns.Length; i++)
{
generator.AddExpression(
Expression.Call(
pWriter,
"Write",
new[] { typeof(object) },
Expression.Call(Expression.ArrayIndex(pColumns, Expression.Constant(i)), "GetValue", Array <Type> .Empty, pEntity),
Expression.Convert(Expression.Constant(Wrapped.NpgsqlDbType.Test), typeof(Original.NpgsqlDbType))));
}
_rowWriter = Expression.Lambda <Action <MappingSchema, Wrapped.NpgsqlBinaryImporter, ColumnDescriptor[], TestEntity> >(
generator.Build(),
pMapping, pWriterIn, pColumns, pEntity)
.Compile();
}
public void Test013()
{
var xgr = new ExpressionGenerator();
var l3 = Expression.Lambda <Func <int> >(Expression.Default(typeof(int)));
var l4 = Expression.Lambda <Func <string> >(Expression.Default(typeof(string)));
var l5 = Expression.Lambda <Func <bool> >(Expression.Default(typeof(bool)));
var l1 = xgr.FromFunc(l3, l4, l5, (i3, i4, i5) => new MemberInitData()
{
FieldOne = i3,
FieldTwo = i4,
FieldThree = i5,
});
var e1 = (MemberInitExpression)l1.Body;
var e2 = e1.NewExpression;
var e3 = l3.Body;
var e4 = l4.Body;
var e5 = l5.Body;
var replace = new Dictionary <Expression, Expression>
{
};
var assert = ExpressionVisitorVerifierTool.Test(e1, replace);
assert.WasVisited(e1);
assert.WasProduced(e1);
assert.ProductionHas(e1, o1 => o1.NewExpression == e2);
assert.ProductionHas(e1, o1 => o1.Bindings.Count == e1.Bindings.Count);
assert.ProductionHas(e1, o1 => ((MemberAssignment)o1.Bindings[0]).Expression == e3);
assert.ProductionHas(e1, o1 => ((MemberAssignment)o1.Bindings[1]).Expression == e4);
assert.ProductionHas(e1, o1 => ((MemberAssignment)o1.Bindings[2]).Expression == e5);
assert.WasVisited(e2);
assert.WasProduced(e2);
assert.WasVisited(e3);
assert.WasProduced(e3);
assert.WasVisited(e4);
assert.WasProduced(e4);
assert.WasVisited(e5);
assert.WasProduced(e5);
assert.TotalVisits(5);
assert.TotalProduced(5);
}
public void Test012()
{
var xgr = new ExpressionGenerator();
var l3 = Expression.Lambda <Func <int> >(Expression.Default(typeof(int)));
var l4 = Expression.Lambda <Func <string> >(Expression.Default(typeof(string)));
var l1 = xgr.FromFunc(l3, l4, (i3, i4) => new MemberInitData()
{
FieldOne = i3,
FieldTwo = i4,
});
var e1 = (MemberInitExpression)l1.Body;
var e2 = e1.NewExpression;
var e3 = l3.Body;
var e4 = l4.Body;
var replace = new Dictionary <Expression, Expression>
{
{ e2, Expression.New(e2.Constructor) },
{ e3, Expression.Constant(1) },
{ e4, Expression.Constant("ABC") },
};
var assert = ExpressionVisitorVerifierTool.Test(e1, replace);
assert.WasVisited(e1);
assert.WasNotProduced(e1);
assert.ProductionHas(e1, o1 => o1.NewExpression == replace[e2]);
assert.ProductionHas(e1, o1 => o1.Bindings.Count == e1.Bindings.Count);
assert.ProductionHas(e1, o1 => ((MemberAssignment)o1.Bindings[0]).Expression == replace[e3]);
assert.ProductionHas(e1, o1 => ((MemberAssignment)o1.Bindings[1]).Expression == replace[e4]);
assert.WasVisited(e2);
assert.WasProduced(replace[e2]);
assert.WasNotProduced(e2);
assert.WasVisited(e3);
assert.WasProduced(replace[e3]);
assert.WasNotProduced(e3);
assert.WasVisited(e4);
assert.WasProduced(replace[e4]);
assert.WasNotProduced(e4);
assert.TotalVisits(4);
assert.TotalProduced(4);
}
public virtual void Test036()
{
var xgr = new ExpressionGenerator();
var expr1 = xgr.FromFunc(() => new CompareNewBaseTests.NewConstructorData
{
NestedList =
{
}
});
var expr2 = xgr.FromFunc(() => new CompareNewBaseTests.NewConstructorData
{
NestedList =
{
new CompareNewBaseTests.NewConstructorData()
}
});
_assert.AreNotEqual(expr1, expr2);
}
public override void Generate(ExpressionGenerator gen, int level, Random rand)
{
// if (AbsFunction == null)
// AbsFunction = gen.Module.Import(typeof(Math).GetMethod("Abs", new Type[] { typeof(Double) }));
int a = rand.Next(0, 100) > 15 ? level : 0;
int b = rand.Next(0, 100) > 15 ? level : 0;
// Random choice based on equal or not
if (rand.Next() % 2 == 0)
{
OperandA = Gen(gen, a, rand);
OperandB = Gen(gen, b, rand);
}
else
{
OperandB = Gen(gen, b, rand);
OperandA = Gen(gen, a, rand);
}
}
public virtual void Test007()
{
var xgr = new ExpressionGenerator();
var p1 = Expression.Parameter(typeof(int));
var p2 = Expression.Parameter(typeof(int));
var p3 = Expression.Parameter(typeof(int));
var p4 = Expression.Parameter(typeof(int));
var expr1 = Expression.Invoke(
Expression.Lambda(Expression.Default(typeof(int)), p1, p2),
Expression.Default(typeof(int)),
Expression.Default(typeof(int)));
var expr2 = Expression.Invoke(
Expression.Lambda(Expression.Default(typeof(int)), p3, p4),
Expression.Default(typeof(int)),
Expression.Default(typeof(int)));
_assert.AreEqual(expr1, expr2);
}
public virtual void Test009()
{
var xgr = new ExpressionGenerator();
var expr1 = xgr.FromFunc(() => new CompareNewBaseTests.NewConstructorData
{
StringTwo = default(string),
IntOne = default(int),
IntTwo = default(int),
});
var expr2 = xgr.FromFunc(() => new CompareNewBaseTests.NewConstructorData
{
StringOne = default(string),
StringTwo = default(string),
IntOne = default(int),
IntTwo = default(int),
});
_assert.AreNotEqual(expr1, expr2);
}
public virtual void Test008()
{
var xgr = new ExpressionGenerator();
var expr1 = xgr.FromFunc(() => new CompareNewBaseTests.NewConstructorData
{
StringOne = default(string),
StringTwo = default(string),
IntOne = default(int),
IntTwo = default(int),
});
var expr2 = xgr.FromFunc(() => new CompareNewBaseTests.NewConstructorData
{
StringOne = default(string),
StringTwo = default(string),
IntOne = default(int),
});
_assert.AreNotEqual(expr1, expr2);
}
public void FromString(string input)
{
var expressionGenerator = new ExpressionGenerator <SomeClass>(
new UnWeightedRandom(),
new []
{
new BoundValueExpression <SomeClass>(someClass => someClass.SomeValue, nameof(SomeClass.SomeValue)),
},
new []
{
new Operation((a, b) => a + b, "+"),
new Operation((a, b) => a - b, "-"),
new Operation((a, b) => a * b, "*"),
});
var fromString = expressionGenerator.FromString(input);
Console.WriteLine(fromString);
Assert.That(fromString.ToString(), Is.EqualTo(input));
}
public void Test011()
{
var xgr = new ExpressionGenerator();
var xc = new ExpressionComparer();
var e2 = xgr.WithType <int>(Expression.Default(typeof(int)));
var e3 = xgr.WithType <int?>(Expression.Default(typeof(int?)));
var e1 = xgr.MakeInequalityComparison(e2, e3);
var expected = Expression.Lambda <Func <bool> >(
Expression.MakeBinary(
ExpressionType.NotEqual,
Expression.Convert(Expression.Default(typeof(int)), typeof(int?)),
Expression.Default(typeof(int?))
)
);
Assert.IsTrue(xc.AreEqual(expected, e1));
}
public void Test011()
{
var xgr = new ExpressionGenerator();
var xc = new ExpressionComparer();
var e2 = xgr.WithType<int>(Expression.Default(typeof(int)));
var e3 = xgr.WithType<int?>(Expression.Default(typeof(int?)));
var e1 = xgr.MakeInequalityComparison(e2, e3);
var expected = Expression.Lambda<Func<bool>>(
Expression.MakeBinary(
ExpressionType.NotEqual,
Expression.Convert(Expression.Default(typeof(int)), typeof(int?)),
Expression.Default(typeof(int?))
)
);
Assert.IsTrue(xc.AreEqual(expected, e1));
}
public void Test063()
{
var xgr = new ExpressionGenerator();
var xc = new ExpressionComparer();
var e2 = xgr.WithType <int>(Expression.Default(typeof(int)));
var e3 = xgr.WithType <int>(Expression.Default(typeof(int)));
var e1 = xgr.MakeLessThanComparison(e2, e3);
var expected = Expression.Lambda <Func <bool> >(
Expression.MakeBinary(
ExpressionType.LessThan,
Expression.Default(typeof(int)),
Expression.Default(typeof(int))
)
);
Assert.IsTrue(xc.AreEqual(expected, e1));
}
public void Test004()
{
var xgr = new ExpressionGenerator();
var q = Enumerable.Range(0, 1).Select(x => new {
FieldOne = 1,
FieldTwo = "ABC"
}).AsQueryable();
var e1 = xgr.MultiProject(
q,
x => x.FieldTwo + x.FieldOne,
x => "GHI" + x.FieldTwo + x.FieldTwo + "DEF",
(x, y) => new {
InitializerOneResult = x,
InitializerTwoResult = y
}
);
var inputPlaceholder = xgr.FromFunc(() => new {
FieldOne = 1,
FieldTwo = "ABC"
});
var expectations = xgr.FromFunc(inputPlaceholder, x => new {
InitializerOneResult = x.FieldTwo + x.FieldOne,
InitializerTwoResult = "GHI" + x.FieldTwo + x.FieldTwo + "DEF"
});
var inputParam = Expression.Parameter(inputPlaceholder.ReturnType);
var expected = Expression.Lambda(
ExpressionReplacer.Replace(expectations.Body, inputPlaceholder.Body, inputParam),
inputParam
);
var inner1 = e1.Expression as MethodCallExpression;
var inner2 = inner1.Arguments[1] as UnaryExpression;
var inner3 = inner2.Operand as LambdaExpression;
var comparer = new ExpressionComparer();
Assert.IsTrue(comparer.AreEqual(expected, inner3));
}
public void Test041()
{
var xgr = new ExpressionGenerator();
Func <Expression, BinaryExpression> conv = x => (BinaryExpression)x;
var el = new Expression[] {
Expression.Default(typeof(int)),
Expression.Default(typeof(int)),
Expression.Default(typeof(int)),
};
var result = xgr.Join(el, ExpressionType.Add);
Assert.IsInstanceOfType(result, typeof(BinaryExpression));
Assert.AreEqual(ExpressionType.Add, result.NodeType);
Assert.IsInstanceOfType(conv(result).Left, typeof(BinaryExpression));
Assert.AreEqual(ExpressionType.Add, conv(result).Left.NodeType);
Assert.AreEqual(el[0], conv(conv(result).Left).Left);
Assert.AreEqual(el[1], conv(conv(result).Left).Right);
Assert.AreEqual(el[2], conv(result).Right);
}
public void Test026()
{
var xgr = new ExpressionGenerator();
var intArgs = GetIntArgs(4);
var stringArgs = GetStringArgs(4);
var args = intArgs.Zip(stringArgs, (a, b) => new { a = (Expression)a.Body, b = (Expression)b.Body }).SelectMany(a => new[] { a.a, a.b }).Concat(new[] { intArgs.Length != stringArgs.Length ? intArgs.Last().Body : null }).Where(a => a != null);
var actual = xgr.FromAction(
intArgs[0], stringArgs[0], intArgs[1], stringArgs[1], intArgs[2], stringArgs[2], intArgs[3], stringArgs[3],
(a, b, c, d, e, f, g, h) => interleaveFunc(a, b, c, d, e, f, g, h));
var expected = Expression.Call(
null,
typeof(ExpressionGeneratorFromActionTests).GetMethod("interleaveFunc"),
Expression.NewArrayInit(typeof(object), args.Select(a => a.Type == typeof(string) ? a : Expression.Convert(a, typeof(object))).ToArray())
);
var comparer = new ExpressionComparer();
Assert.IsTrue(comparer.AreEqual(expected, actual));
}
public static Expression <Func <T> > ActualToDisk <T>(this IAssertionTool tool, Expression <Func <T> > content, Func <T, byte[]> toDisk = null, int stackDepth = 2)
{
string filename = GenerateTestFilename(tool, stackDepth);
filename = string.Format("{3}{0}.{1}{2}", filename, GetFilesystemAssertionCount(tool), GetFilesystemAssertionActualSuffix(tool), GetFilesystemAssertionFilenamePrefix(tool));
filename = Path.Combine(GetFilesystemAssertionRepositoryPath(tool), filename);
EnsureDirectory(filename);
if (toDisk == null)
{
toDisk = d => Encoding.UTF8.GetBytes(Convert.ToString(d));
}
var xgr = new ExpressionGenerator();
var content2 = xgr.FromFunc(
content,
c => WriteActualToDisk <T>(filename, c, toDisk, tool)
);
return(content2);
}
public IEnumerable <Expression <Func <T, bool> > > GetFiltersFor <T>() where T : class
{
var gen = new ExpressionGenerator <T>();
List <Expression <Func <T, bool> > > opts = gen.ToStrongExpressions(Filters);
if (!string.IsNullOrEmpty(SearchTerm))
{
var ex = ExpressionStore.GetSearchExpression <T>(SearchTerm);
if (ex != null)
{
opts.Add(ex);
}
else if (typeof(T).Implements(typeof(INamed)))
{
Expression <Func <T, bool> > iex = e => ((INamed)e).Name.Contains(SearchTerm);
opts.Add(iex);
}
}
return(opts);
}
public static LoadResult LoadWith <T>(this IQueryable <T> q, GetOptions <T> opts) where T : class
{
LoadResult res = new LoadResult();
ExpressionGenerator <T> gen = new ExpressionGenerator <T>();
if (opts == null)
{
opts = new GetOptions <T>();
}
//Expression<Func<T, bool>> fil = null;
if (opts.Filters != null)
{
//fil = (Expression<Func<T, bool>>)opts.Filters[0];
for (int i = 0; i < opts.Filters.Count; i++)
{
Expression <Func <T, bool> > e = (Expression <Func <T, bool> >)opts.Filters[i];
//fil = fil.Combine(e);
q = q.Where(e);
}
}
res.TotalCount = q.Count(d => true);
if (!string.IsNullOrEmpty(opts.OrderProperty))
{
q = gen.SortWith(q, opts.OrderProperty, opts.Direction);
}
if (opts.Showing > 0)
{
q = q.Skip(opts.Skip).Take(opts.Showing);
}
res.List = q.ToList();
return(res);
}
Expression BuildExpression(int fieldIndex, ISqlExpression?sqlExpression)
{
Expression expr;
if (Sequence is DefaultIfEmptyBuilder.DefaultIfEmptyContext defaultIfEmpty)
{
expr = Builder.BuildSql(_returnType, fieldIndex, sqlExpression);
if (defaultIfEmpty.DefaultValue != null && expr is ConvertFromDataReaderExpression convert)
{
var generator = new ExpressionGenerator();
expr = convert.MakeNullable();
if (expr.Type.IsNullable())
{
var exprVar = generator.AssignToVariable(expr, "nullable");
var resultVar = generator.AssignToVariable(defaultIfEmpty.DefaultValue, "result");
generator.AddExpression(Expression.IfThen(
Expression.NotEqual(exprVar, Expression.Constant(null)),
Expression.Assign(resultVar, Expression.Convert(exprVar, resultVar.Type))));
generator.AddExpression(resultVar);
expr = generator.Build();
}
}
}
else
if (_returnType.IsClass || _methodName == "Sum" || _returnType.IsNullable())
{
expr = Builder.BuildSql(_returnType, fieldIndex, sqlExpression);
}
else
{
expr = Expression.Block(
Expression.Call(null, MemberHelper.MethodOf(() => CheckNullValue(false, null !)), Expression.Call(ExpressionBuilder.DataReaderParam, Methods.ADONet.IsDBNull, Expression.Constant(0)), Expression.Constant(_methodName)),
Builder.BuildSql(_returnType, fieldIndex, sqlExpression));
}
return(expr);
}
public static ExpressionGenerator <GameState> CreateExpressionGenerator()
{
var expressionGenerator = new ExpressionGenerator <GameState>(
new BellWeightedRandom(0.5),
new IExpression <GameState>[]
{
new BoundValueExpression <GameState>(game => game.HeroGold, nameof(GameState.HeroGold)),
new BoundValueExpression <GameState>(game => game.HeroHealth, nameof(GameState.HeroHealth)),
new BoundValueExpression <GameState>(game => game.HeroWeapon, nameof(GameState.HeroWeapon)),
new BoundValueExpression <GameState>(game => game.CardGold, nameof(GameState.CardGold)),
new BoundValueExpression <GameState>(game => game.MonsterHealth, nameof(GameState.MonsterHealth)),
new BoundValueExpression <GameState>(game => game.CardWeapon, nameof(GameState.CardWeapon)),
},
new[]
{
new Operation((a, b) => a + b, "+"),
new Operation((a, b) => a - b, "-"),
new Operation((a, b) => a * b, "*"),
});
return(expressionGenerator);
}
public void Test003()
{
var xgr = new ExpressionGenerator();
var xpr = new ExpressionReader();
var param1 = Expression.Parameter(typeof(int));
var expr = Expression.Call(
typeof(Queryable),
"Where",
new[] { typeof(int) },
Expression.Default(typeof(IQueryable <int>)),
Expression.Constant(
Expression.Lambda <Func <int, bool> >(
Expression.GreaterThan(param1, Expression.Constant(10)),
param1
)
)
);
var result = xpr.GetLambda(expr);
Assert.IsNull(result);
}
private UnaryFunc BuildUnaryFunc <TReturn>(string expressionName)
{
Contract.Requires(!string.IsNullOrEmpty(expressionName));
var tParam = typeof(TValue).CreateParameterExpression();
var expression = ExpressionGenerator.Generate(expressionName, tParam);
if (null == expression)
{
return(null);
}
if (typeof(TReturn) != typeof(void) && typeof(TReturn) != expression.Type)
{
expression = ExpressionGenerator.GenerateConversion(typeof(TReturn), expression);
if (null == expression)
{
return(null);
}
}
return(Expression.Lambda <UnaryFunc>(expression, tParam).Compile());
}
public void Test003()
{
var xgr = new ExpressionGenerator();
var xpr = new ExpressionReader();
var param1 = Expression.Parameter(typeof(int));
var expr = Expression.Call(
typeof(Queryable),
"Where",
new[] { typeof(int) },
Expression.Default(typeof(IQueryable<int>)),
Expression.Constant(
Expression.Lambda<Func<int, bool>>(
Expression.GreaterThan(param1, Expression.Constant(10)),
param1
)
)
);
var result = xpr.GetLambda(expr);
Assert.IsNull(result);
}
public void Test019()
{
var xgr = new ExpressionGenerator();
var intArgs = GetIntArgs(1);
var stringArgs = GetStringArgs(0);
var args = intArgs.Zip(stringArgs, (a, b) => new { a = (Expression)a.Body, b = (Expression)b.Body }).SelectMany(a => new[] { a.a, a.b }).Concat(new [] { intArgs.Length != stringArgs.Length ? intArgs.Last().Body : null }).Where(a => a != null);
var actual = xgr.FromFunc(
intArgs[0],
a => interleaveFunc(a));
var expected = Expression.Lambda <Func <object> >(
Expression.Call(
null,
typeof(ExpressionGeneratorFromFuncTests).GetMethod("interleaveFunc"),
Expression.NewArrayInit(typeof(object), args.Select(a => Expression.Convert(a, typeof(object))).ToArray())
)
);
var comparer = new ExpressionComparer();
Assert.IsTrue(comparer.AreEqual(expected, actual));
}
private TResult BuildBinaryFunc <TResult, TReturn>(string expressionName) where TResult : class
{
Contract.Requires(!string.IsNullOrEmpty(expressionName));
var tParam0 = typeof(TValue).CreateParameterExpression();
var tParam1 = typeof(TValue).CreateParameterExpression();
var expression = ExpressionGenerator.Generate(expressionName, tParam0, tParam1);
if (null == expression)
{
return(null);
}
if (typeof(TReturn) != typeof(void) && typeof(TReturn) != expression.Type)
{
expression = ExpressionGenerator.GenerateConversion(typeof(TReturn), expression);
if (null == expression)
{
return(null);
}
}
return(Expression.Lambda <TResult>(expression, tParam0, tParam1).Compile());
}
public virtual void Test057()
{
var xgr = new ExpressionGenerator();
var expr1 = xgr.FromFunc(() => new CompareNewBaseTests.NewConstructorData
{
IntOne = default(int),
NestedList =
{
new CompareNewBaseTests.NewConstructorData(),
},
ChildOne =
{
IntTwo = default(int),
IntOne = default(int),
StringTwo = default(string),
StringOne = default(string),
},
});
var expr2 = xgr.FromFunc(() => new CompareNewBaseTests.NewConstructorData
{
IntOne = default(int),
NestedList =
{
new CompareNewBaseTests.NewConstructorData(),
},
ChildOne =
{
IntTwo = default(int),
IntOne = default(int),
StringTwo = default(string),
StringOne = default(string),
},
});
_assert.AreEqual(expr1, expr2);
}
public Func<double> Compile(Block block)
{
ParameterExpression result = Expression.Parameter(typeof(int), "result");
var compiler = new ExpressionGenerator();
compiler.SetReturnType<double>();
foreach (var varDef in block.Variables.Values)
{
//var v = Expression.Variable(ExpressionCompiler.GetCsType(varDef.ValueType), varDef.Name.Name);
//expressions.Add(v);
compiler.AddVariable(varDef);
}
foreach (var statement in block.Statements)
{
compiler.AddExpression(statement);
}
BlockExpression blockExpression = compiler.Generate();
var lambda = Expression.Lambda<Func<double>>(blockExpression);
var compiled = lambda.Compile();
return compiled;
}
public Expression Build(IEventTraceOperand operand, ParameterExpression eventRecordReader, ParameterExpression eventRecordWriter, ParameterExpression eventMetadataTable, ParameterExpression runtimeMetadata)
{
var eventMetadata = Expression.Parameter(typeof(EventMetadata));
var properties = Expression.Parameter(typeof(PropertyMetadata[]));
var variables = new List<ParameterExpression>
{
eventMetadata,
properties
};
var expGenerator = new ExpressionGenerator(eventRecordReader, eventRecordWriter, properties);
var list = new List<Expression>
{
Expression.Assign(eventMetadata, Expression.ArrayAccess(eventMetadataTable, Expression.Constant(operand.EventMetadataTableIndex))),
Expression.Assign(properties, Expression.PropertyOrField(eventMetadata, "Properties")),
eventRecordWriter.Call("WriteEventBegin", eventMetadata, runtimeMetadata),
expGenerator.CodeGenerate(operand.EventPropertyOperands),
eventRecordWriter.Call("WriteEventEnd")
};
var returnExpression = Expression.Block(variables, list);
return returnExpression;
}
public void Test002()
{
var xgr = new ExpressionGenerator();
var xpr = new ExpressionReader();
var param1 = Expression.Parameter(typeof(int));
var expr = Expression.Call(
typeof(Queryable),
"Where",
new [] { typeof(int) },
Expression.Default(typeof(IQueryable<int>)),
Expression.Constant(
Expression.Lambda<Func<int, bool>>(
Expression.GreaterThan(param1, Expression.Constant(10)),
param1
)
)
);
var expr2 = expr.Arguments[1];
var result = xpr.GetLambda(expr2);
Assert.AreNotEqual(expr2, result);
Assert.IsInstanceOfType(result, typeof(LambdaExpression));
}
public void Test002()
{
var xgr = new ExpressionGenerator();
var xpr = new ExpressionReader();
var param1 = Expression.Parameter(typeof(int));
var expr = Expression.Call(
typeof(Queryable),
"Where",
new [] { typeof(int) },
Expression.Default(typeof(IQueryable <int>)),
Expression.Constant(
Expression.Lambda <Func <int, bool> >(
Expression.GreaterThan(param1, Expression.Constant(10)),
param1
)
)
);
var expr2 = expr.Arguments[1];
var result = xpr.GetLambda(expr2);
Assert.AreNotEqual(expr2, result);
Assert.IsInstanceOfType(result, typeof(LambdaExpression));
}
public void Test002()
{
var xgr = new ExpressionGenerator();
var e1 = xgr.MultiProject(
() => new {
FieldOne = 1,
FieldTwo = "ABC"
},
x => x.FieldTwo + x.FieldOne,
x => "GHI" + x.FieldTwo + x.FieldTwo + "DEF",
(x, y) => new {
InitializerOneResult = x,
InitializerTwoResult = y
}
);
var inputPlaceholder = xgr.FromFunc(() => new {
FieldOne = 1,
FieldTwo = "ABC"
});
var expectations = xgr.FromFunc(inputPlaceholder, x => new {
InitializerOneResult = x.FieldTwo + x.FieldOne,
InitializerTwoResult = "GHI" + x.FieldTwo + x.FieldTwo + "DEF"
});
var inputParam = Expression.Parameter(inputPlaceholder.ReturnType);
var expected = Expression.Lambda(
ExpressionReplacer.Replace(expectations.Body, inputPlaceholder.Body, inputParam),
inputParam
);
var comparer = new ExpressionComparer();
Assert.IsTrue(comparer.AreEqual(expected, e1));
}
/// <summary>
/// Constructs a new matching.
/// </summary>
public Matching()
{
_func = x => true;
_gen = GetExpression;
}
private static OracleProviderAdapter CreateAdapter(string assemblyName, string clientNamespace, string typesNamespace, string?factoryName)
{
var isNative = false;
#if NETFRAMEWORK
isNative = assemblyName == NativeAssemblyName;
#endif
var assembly = Common.Tools.TryLoadAssembly(assemblyName, factoryName);
if (assembly == null)
{
throw new InvalidOperationException($"Cannot load assembly {assemblyName}");
}
var connectionType = assembly.GetType($"{clientNamespace}.OracleConnection", true) !;
var parameterType = assembly.GetType($"{clientNamespace}.OracleParameter", true) !;
var dataReaderType = assembly.GetType($"{clientNamespace}.OracleDataReader", true) !;
var transactionType = assembly.GetType($"{clientNamespace}.OracleTransaction", true) !;
var dbType = assembly.GetType($"{clientNamespace}.OracleDbType", true) !;
var commandType = assembly.GetType($"{clientNamespace}.OracleCommand", true) !;
var mappingSchema = new MappingSchema();
// do not set default conversion for BFile as it could be converted to file name, byte[], Stream and we don't know what user needs
var oracleBFileType = loadType("OracleBFile", DataType.BFile, skipConvertExpression: true) !;
var oracleBinaryType = loadType("OracleBinary", DataType.VarBinary) !;
var oracleBlobType = loadType("OracleBlob", DataType.Blob) !;
var oracleClobType = loadType("OracleClob", DataType.NText) !;
var oracleDateType = loadType("OracleDate", DataType.DateTime) !;
var oracleDecimalType = loadType("OracleDecimal", DataType.Decimal) !;
var oracleIntervalDSType = loadType("OracleIntervalDS", DataType.Time) !;
var oracleIntervalYMType = loadType("OracleIntervalYM", DataType.Date) !;
var oracleStringType = loadType("OracleString", DataType.NVarChar) !;
var oracleTimeStampType = loadType("OracleTimeStamp", DataType.DateTime2) !;
var oracleTimeStampLTZType = loadType("OracleTimeStampLTZ", DataType.DateTimeOffset) !;
var oracleTimeStampTZType = loadType("OracleTimeStampTZ", DataType.DateTimeOffset) !;
var oracleXmlTypeType = loadType("OracleXmlType", DataType.Xml) !;
var oracleXmlStreamType = loadType("OracleXmlStream", DataType.Xml, true, false) !;
var oracleRefCursorType = loadType("OracleRefCursor", DataType.Binary, hasValue: false) !;
var oracleRefType = loadType("OracleRef", DataType.Binary, true);
BulkCopyAdapter?bulkCopy = null;
var typeMapper = new TypeMapper();
typeMapper.RegisterTypeWrapper <OracleConnection>(connectionType);
typeMapper.RegisterTypeWrapper <OracleParameter>(parameterType);
typeMapper.RegisterTypeWrapper <OracleDbType>(dbType);
typeMapper.RegisterTypeWrapper <OracleCommand>(commandType);
typeMapper.RegisterTypeWrapper <OracleDataReader>(dataReaderType);
typeMapper.RegisterTypeWrapper <OracleTimeStampTZ>(oracleTimeStampTZType);
typeMapper.RegisterTypeWrapper <OracleTimeStampLTZ>(oracleTimeStampLTZType);
typeMapper.RegisterTypeWrapper <OracleDecimal>(oracleDecimalType);
if (isNative)
{
var bulkCopyType = assembly.GetType($"{clientNamespace}.OracleBulkCopy", true) !;
var bulkCopyOptionsType = assembly.GetType($"{clientNamespace}.OracleBulkCopyOptions", true) !;
var bulkRowsCopiedEventHandlerType = assembly.GetType($"{clientNamespace}.OracleRowsCopiedEventHandler", true) !;
var bulkCopyColumnMappingType = assembly.GetType($"{clientNamespace}.OracleBulkCopyColumnMapping", true) !;
var bulkCopyColumnMappingCollectionType = assembly.GetType($"{clientNamespace}.OracleBulkCopyColumnMappingCollection", true) !;
var rowsCopiedEventArgsType = assembly.GetType($"{clientNamespace}.OracleRowsCopiedEventArgs", true) !;
// bulk copy types
typeMapper.RegisterTypeWrapper <OracleBulkCopy>(bulkCopyType);
typeMapper.RegisterTypeWrapper <OracleBulkCopyOptions>(bulkCopyOptionsType);
typeMapper.RegisterTypeWrapper <OracleRowsCopiedEventHandler>(bulkRowsCopiedEventHandlerType);
typeMapper.RegisterTypeWrapper <OracleBulkCopyColumnMapping>(bulkCopyColumnMappingType);
typeMapper.RegisterTypeWrapper <OracleBulkCopyColumnMappingCollection>(bulkCopyColumnMappingCollectionType);
typeMapper.RegisterTypeWrapper <OracleRowsCopiedEventArgs>(rowsCopiedEventArgsType);
typeMapper.FinalizeMappings();
bulkCopy = new BulkCopyAdapter(
typeMapper.BuildWrappedFactory((IDbConnection connection, OracleBulkCopyOptions options) => new OracleBulkCopy((OracleConnection)connection, options)),
typeMapper.BuildWrappedFactory((int source, string destination) => new OracleBulkCopyColumnMapping(source, destination)));
}
else
{
typeMapper.FinalizeMappings();
}
var paramMapper = typeMapper.Type <OracleParameter>();
var dbTypeBuilder = paramMapper.Member(p => p.OracleDbType);
var connectionMapper = typeMapper.Type <OracleConnection>();
var commandMapper = typeMapper.Type <OracleCommand>();
// data reader expressions
// rd.GetOracleTimeStampTZ(i) => DateTimeOffset
var generator = new ExpressionGenerator(typeMapper);
var rdParam = Expression.Parameter(typeof(IDataReader), "rd");
var indexParam = Expression.Parameter(typeof(int), "i");
var tstzExpr = generator.MapExpression((IDataReader rd, int i) => ((OracleDataReader)rd).GetOracleTimeStampTZ(i), rdParam, indexParam);
var tstzVariable = generator.AssignToVariable(tstzExpr, "tstz");
var expr = generator.MapExpression((OracleTimeStampTZ tstz) => new DateTimeOffset(
tstz.Year, tstz.Month, tstz.Day,
tstz.Hour, tstz.Minute, tstz.Second,
tstz.GetTimeZoneOffset()).AddTicks(tstz.Nanosecond / NanosecondsPerTick), tstzVariable);
generator.AddExpression(expr);
var body = generator.Build();
var readDateTimeOffsetFromOracleTimeStampTZ = (Expression <Func <IDataReader, int, DateTimeOffset> >)Expression.Lambda(body, rdParam, indexParam);
// rd.GetOracleTimeStampLTZ(i) => DateTimeOffset
generator = new ExpressionGenerator(typeMapper);
tstzExpr = generator.MapExpression((IDataReader rd, int i) => ((OracleDataReader)rd).GetOracleTimeStampLTZ(i).ToOracleTimeStampTZ(), rdParam, indexParam);
tstzVariable = generator.AssignToVariable(tstzExpr, "tstz");
expr = generator.MapExpression((OracleTimeStampTZ tstz) => new DateTimeOffset(
tstz.Year, tstz.Month, tstz.Day,
tstz.Hour, tstz.Minute, tstz.Second,
tstz.GetTimeZoneOffset()).AddTicks(tstz.Nanosecond / NanosecondsPerTick), tstzVariable);
generator.AddExpression(expr);
body = generator.Build();
var readDateTimeOffsetFromOracleTimeStampLTZ = (Expression <Func <IDataReader, int, DateTimeOffset> >)Expression.Lambda(body, rdParam, indexParam);
// rd.GetOracleDecimal(i) => decimal
generator = new ExpressionGenerator(typeMapper);
var decExpr = generator.MapExpression((IDataReader rd, int i) => ((OracleDataReader)rd).GetOracleDecimal(i), rdParam, indexParam);
var oracleDecimalVar = generator.AssignToVariable(decExpr, "dec");
var precision = generator.AssignToVariable(Expression.Constant(29), "precision");
var decimalVar = generator.AddVariable(Expression.Parameter(typeof(decimal), "dec"));
var label = Expression.Label(typeof(decimal));
generator.AddExpression(
Expression.Loop(
Expression.TryCatch(
Expression.Block(
Expression.Assign(oracleDecimalVar, generator.MapExpression((OracleDecimal d, int p) => OracleDecimal.SetPrecision(d, p), oracleDecimalVar, precision)),
Expression.Assign(decimalVar, Expression.Convert(oracleDecimalVar, typeof(decimal))),
Expression.Break(label, decimalVar)),
Expression.Catch(
typeof(OverflowException),
Expression.Block(
Expression.IfThen(
Expression.LessThanOrEqual(Expression.SubtractAssign(precision, Expression.Constant(1)), Expression.Constant(26)),
Expression.Rethrow())))),
label));
body = generator.Build();
var readOracleDecimalToDecimalAdv = (Expression <Func <IDataReader, int, decimal> >)Expression.Lambda(body, rdParam, indexParam);
// workaround for mapper issue with complex reader expressions handling
// https://github.com/linq2db/linq2db/issues/2032
var compiledReader = readOracleDecimalToDecimalAdv.Compile();
readOracleDecimalToDecimalAdv = (Expression <Func <IDataReader, int, decimal> >)Expression.Lambda(
Expression.Invoke(Expression.Constant(compiledReader), rdParam, indexParam),
rdParam,
indexParam);
var readOracleDecimalToInt = (Expression <Func <IDataReader, int, int> >)typeMapper.MapLambda <IDataReader, int, int>((rd, i) => (int)(decimal)OracleDecimal.SetPrecision(((OracleDataReader)rd).GetOracleDecimal(i), 27));
var readOracleDecimalToLong = (Expression <Func <IDataReader, int, long> >)typeMapper.MapLambda <IDataReader, int, long>((rd, i) => (long)(decimal)OracleDecimal.SetPrecision(((OracleDataReader)rd).GetOracleDecimal(i), 27));
var readOracleDecimalToDecimal = (Expression <Func <IDataReader, int, decimal> >)typeMapper.MapLambda <IDataReader, int, decimal>((rd, i) => (decimal)OracleDecimal.SetPrecision(((OracleDataReader)rd).GetOracleDecimal(i), 27));
return(new OracleProviderAdapter(
connectionType,
dataReaderType,
parameterType,
commandType,
transactionType,
mappingSchema,
oracleBFileType,
oracleBinaryType,
oracleBlobType,
oracleClobType,
oracleDateType,
oracleDecimalType,
oracleIntervalDSType,
oracleIntervalYMType,
oracleStringType,
oracleTimeStampType,
oracleTimeStampLTZType,
oracleTimeStampTZType,
oracleXmlTypeType,
oracleXmlStreamType,
oracleRefCursorType,
oracleRefType,
typeMapper.BuildWrappedFactory((string connectionString) => new OracleConnection(connectionString)),
typesNamespace,
dbTypeBuilder.BuildSetter <IDbDataParameter>(),
dbTypeBuilder.BuildGetter <IDbDataParameter>(),
connectionMapper.Member(c => c.HostName).BuildGetter <IDbConnection>(),
connectionMapper.Member(c => c.DatabaseName).BuildGetter <IDbConnection>(),
commandMapper.Member(p => p.BindByName).BuildSetter <IDbCommand>(),
commandMapper.Member(p => p.ArrayBindCount).BuildSetter <IDbCommand>(),
commandMapper.Member(p => p.InitialLONGFetchSize).BuildSetter <IDbCommand>(),
typeMapper.BuildFactory((DateTimeOffset dto, string offset) => new OracleTimeStampTZ(dto.Year, dto.Month, dto.Day, dto.Hour, dto.Minute, dto.Second, GetDateTimeOffsetNanoseconds(dto), offset)),
readDateTimeOffsetFromOracleTimeStampTZ,
readDateTimeOffsetFromOracleTimeStampLTZ,
readOracleDecimalToDecimalAdv,
readOracleDecimalToInt,
readOracleDecimalToLong,
readOracleDecimalToDecimal,
bulkCopy));
Type?loadType(string typeName, DataType dataType, bool optional = false, bool hasNull = true, bool hasValue = true, bool skipConvertExpression = false)
{
var type = assembly !.GetType($"{typesNamespace}.{typeName}", !optional);
if (type == null)
{
return(null);
}
if (hasNull)
{
// if native provider fails here, check that you have ODAC installed properly
var getNullValue = Expression.Lambda <Func <object> >(Expression.Convert(ExpressionHelper.Field(type, "Null"), typeof(object))).Compile();
mappingSchema.AddScalarType(type, getNullValue(), true, dataType);
}
else
{
mappingSchema.AddScalarType(type, null, true, dataType);
}
if (skipConvertExpression)
{
return(type);
}
// conversion from provider-specific type
var valueParam = Expression.Parameter(type);
Expression memberExpression;
if (!hasValue)
{
memberExpression = valueParam;
}
else
{
memberExpression = ExpressionHelper.Property(valueParam, "Value");
}
var condition = Expression.Condition(
Expression.Equal(valueParam, ExpressionHelper.Field(type, "Null")),
Expression.Constant(null, typeof(object)),
Expression.Convert(memberExpression, typeof(object)));
var convertExpression = Expression.Lambda(condition, valueParam);
mappingSchema.SetConvertExpression(type, typeof(object), convertExpression);
return(type);
}
}
public void Test005()
{
var xgr = new ExpressionGenerator();
var l3 = Expression.Lambda<Func<int>>(Expression.Default(typeof(int)));
var l4 = Expression.Lambda<Func<string>>(Expression.Default(typeof(string)));
var l1 = xgr.FromFunc(l3, l4, (i3, i4) => new MemberInitData()
{
FieldOne = i3,
FieldTwo = i4,
});
var e1 = (MemberInitExpression)l1.Body;
var e2 = e1.NewExpression;
var e3 = l3.Body;
var e4 = l4.Body;
var replace = new Dictionary<Expression, Expression>
{
};
var assert = ExpressionVisitorVerifierTool.Test(e1, replace);
assert.WasVisited(e1);
assert.WasProduced(e1);
assert.ProductionHas(e1, o1 => o1.NewExpression == e2);
assert.ProductionHas(e1, o1 => o1.Bindings.Count == e1.Bindings.Count);
assert.ProductionHas(e1, o1 => ((MemberAssignment)o1.Bindings[0]).Expression == e3);
assert.ProductionHas(e1, o1 => ((MemberAssignment)o1.Bindings[1]).Expression == e4);
assert.WasVisited(e2);
assert.WasProduced(e2);
assert.WasVisited(e3);
assert.WasProduced(e3);
assert.WasVisited(e4);
assert.WasProduced(e4);
assert.TotalVisits(4);
assert.TotalProduced(4);
}
public void Test023()
{
var xgr = new ExpressionGenerator();
var l3 = Expression.Lambda<Func<int>>(Expression.Default(typeof(int)));
var l4 = Expression.Lambda<Func<string>>(Expression.Default(typeof(string)));
var l5 = Expression.Lambda<Func<bool>>(Expression.Default(typeof(bool)));
var l1 = xgr.FromFunc(l3, l4, l5, (i3, i4, i5) => new MemberInitData()
{
FieldOne = i3,
FieldTwo = i4,
FieldThree = i5,
});
var e1 = (MemberInitExpression)l1.Body;
var e2 = e1.NewExpression;
var e3 = l3.Body;
var e4 = l4.Body;
var e5 = l5.Body;
var replace = new Dictionary<Expression, Expression>
{
{e2, Expression.New(e2.Constructor) },
{e3, Expression.Constant(1) },
{e4, Expression.Constant("ABC") },
{e5, Expression.Constant(true) },
};
var assert = ExpressionVisitorVerifierTool.Test(e1, replace);
assert.WasVisited(e1);
assert.WasNotProduced(e1);
assert.ProductionHas(e1, o1 => o1.NewExpression == replace[e2]);
assert.ProductionHas(e1, o1 => o1.Bindings.Count == e1.Bindings.Count);
assert.ProductionHas(e1, o1 => ((MemberAssignment)o1.Bindings[0]).Expression == replace[e3]);
assert.ProductionHas(e1, o1 => ((MemberAssignment)o1.Bindings[1]).Expression == replace[e4]);
assert.ProductionHas(e1, o1 => ((MemberAssignment)o1.Bindings[2]).Expression == replace[e5]);
assert.WasVisited(e2);
assert.WasProduced(replace[e2]);
assert.WasNotProduced(e2);
assert.WasVisited(e3);
assert.WasProduced(replace[e3]);
assert.WasNotProduced(e3);
assert.WasVisited(e4);
assert.WasProduced(replace[e4]);
assert.WasNotProduced(e4);
assert.WasVisited(e5);
assert.WasProduced(replace[e5]);
assert.WasNotProduced(e5);
assert.TotalVisits(5);
assert.TotalProduced(5);
}
public void Test004()
{
var xgr = new ExpressionGenerator();
var q = Enumerable.Range(0, 1).Select(x => new {
FieldOne = 1,
FieldTwo = "ABC"
}).AsQueryable();
var e1 = xgr.MultiProject(
q,
x => x.FieldTwo + x.FieldOne,
x => "GHI" + x.FieldTwo + x.FieldTwo + "DEF",
(x, y) => new {
InitializerOneResult = x,
InitializerTwoResult = y
}
);
var inputPlaceholder = xgr.FromFunc(() => new {
FieldOne = 1,
FieldTwo = "ABC"
});
var expectations = xgr.FromFunc(inputPlaceholder, x => new {
InitializerOneResult = x.FieldTwo + x.FieldOne,
InitializerTwoResult = "GHI" + x.FieldTwo + x.FieldTwo + "DEF"
});
var inputParam = Expression.Parameter(inputPlaceholder.ReturnType);
var expected = Expression.Lambda(
ExpressionReplacer.Replace(expectations.Body, inputPlaceholder.Body, inputParam),
inputParam
);
var inner1 = e1.Expression as MethodCallExpression;
var inner2 = inner1.Arguments[1] as UnaryExpression;
var inner3 = inner2.Operand as LambdaExpression;
var comparer = new ExpressionComparer();
Assert.IsTrue(comparer.AreEqual(expected, inner3));
}
