public void ForEachException()
{
var enumerable_counter = new EnumerableCounter(0, 100);
var ec = Expression.Parameter(typeof(EnumerableCounter), "ec");
var item = Expression.Variable(typeof(int), "i");
var hitcounter = Expression.Lambda <Action <EnumerableCounter> > (
CustomExpression.ForEach(
item,
ec,
Expression.Block(
Expression.Condition(
Expression.LessThanOrEqual(item, Expression.Constant(10)),
Expression.Call(ec, typeof(EnumerableCounter).GetMethod("Hit", Type.EmptyTypes)),
Expression.Throw(Expression.New(typeof(TestException)))))),
ec).Compile();
try {
hitcounter(enumerable_counter);
Assert.Fail();
} catch (TestException) {}
Assert.AreEqual(10, enumerable_counter.Count);
Assert.IsTrue(enumerable_counter.Disposed);
}
public void ForEachBreakAfterUpdate()
{
var enumerable_counter = new EnumerableCounter(0, 100);
var ec = Expression.Parameter(typeof(EnumerableCounter), "ec");
var item = Expression.Variable(typeof(int), "i");
var foreach_break = Expression.Label("foreach_break");
var foreach_continue = Expression.Label("foreach_continue");
var foreach_body = Expression.Block(
Expression.Call(ec, typeof(EnumerableCounter).GetMethod("Hit", Type.EmptyTypes)),
Expression.IfThen(
Expression.GreaterThanOrEqual(item, Expression.Constant(10)),
Expression.Goto(foreach_break)
));
var foreach_expr = CustomExpression.ForEach(
item,
ec,
foreach_body,
foreach_break,
foreach_continue);
foreach_expr = foreach_expr.Update(item, ec, foreach_body, foreach_break, null);
var hitcounter = Expression.Lambda <Action <EnumerableCounter> >(
foreach_expr,
ec).Compile();
hitcounter(enumerable_counter);
Assert.AreEqual(10, enumerable_counter.Count);
Assert.IsTrue(enumerable_counter.Disposed);
}
public void ForEachContinue()
{
var enumerable_counter = new EnumerableCounter(0, 10);
var ec = Expression.Parameter(typeof(EnumerableCounter), "ec");
var item = Expression.Variable(typeof(int), "i");
var foreach_break = Expression.Label("foreach_break");
var foreach_continue = Expression.Label("foreach_continue");
var hitcounter = Expression.Lambda <Action <EnumerableCounter> > (
CustomExpression.ForEach(
item,
ec,
Expression.Block(
Expression.Condition(
Expression.Equal(Expression.Modulo(item, Expression.Constant(2)), Expression.Constant(0)),
Expression.Call(ec, typeof(EnumerableCounter).GetMethod("Hit", Type.EmptyTypes)),
Expression.Goto(foreach_continue))),
foreach_break,
foreach_continue),
ec).Compile();
hitcounter(enumerable_counter);
Assert.AreEqual(5, enumerable_counter.Count);
Assert.IsTrue(enumerable_counter.Disposed);
}
public ForEachExpression Update(ParameterExpression variable, Expression enumerable, Expression body, LabelTarget breakTarget, LabelTarget continueTarget)
{
if (this.variable == variable && this.enumerable == enumerable && this.body == body && break_target == breakTarget && continue_target == continueTarget)
{
return(this);
}
return(CustomExpression.ForEach(variable, enumerable, body, continueTarget, breakTarget));
}
public void ForEachNonGeneric()
{
var enumerable_counter = new NonGenericEnumerableCounter(0, 10);
var ec = Expression.Parameter(typeof(NonGenericEnumerableCounter), "ec");
var item = Expression.Variable(typeof(int), "i");
var hitcounter = Expression.Lambda <Action <NonGenericEnumerableCounter> > (
CustomExpression.ForEach(
item,
ec,
Expression.Call(ec, typeof(NonGenericEnumerableCounter).GetMethod("Hit", Type.EmptyTypes))),
ec).Compile();
hitcounter(enumerable_counter);
Assert.AreEqual(10, enumerable_counter.Count);
}
public void ForEachEnumerable()
{
var enumerable_counter = new EnumerableCounter(0, 10);
var ec = Expression.Parameter(typeof(EnumerableCounter), "ec");
var item = Expression.Variable(typeof(int), "i");
var hitcounter = Expression.Lambda <Action <EnumerableCounter> > (
CustomExpression.ForEach(
item,
ec,
Expression.Call(ec, typeof(EnumerableCounter).GetMethod("Hit", Type.EmptyTypes))),
ec).Compile();
hitcounter(enumerable_counter);
Assert.AreEqual(10, enumerable_counter.Count);
Assert.IsTrue(enumerable_counter.Disposed);
Assert.IsFalse(enumerable_counter.DisposedIncorrectly);
}
public void ForEachArray()
{
var counters = Enumerable.Range(0, 3).Select(_ => new Counter()).ToArray();
var cs = Expression.Parameter(typeof(Counter[]), "cs");
var c = Expression.Variable(typeof(Counter), "i");
var hitcounter = Expression.Lambda <Action <Counter[]> > (
CustomExpression.ForEach(
c,
cs,
Expression.Call(c, typeof(Counter).GetMethod("Hit", Type.EmptyTypes))),
cs).Compile();
hitcounter(counters);
foreach (var counter in counters)
{
Assert.AreEqual(1, counter.Count);
}
}
public void ForEach()
{
var args = Expression.Parameter(typeof(string []), "args");
var s = Expression.Variable(typeof(string), "s");
var lambda = Expression.Lambda <Action <string []> > (
CustomExpression.ForEach(
s,
args,
Expression.Call(typeof(Console).GetMethod("WriteLine", new [] { typeof(string) }), s)),
args);
AssertExpression(@"
void (string[] args)
{
foreach (string s in args)
{
Console.WriteLine(s);
}
}
", lambda);
}
public void ForEachNonGenericStructEnumerator()
{
var counters = new [] { new Counter(), new Counter(), new Counter() };
var enumerable_counter = new NonGenericStructEnumerableCounter(counters);
var ec = Expression.Parameter(typeof(NonGenericStructEnumerableCounter), "ec");
var item = Expression.Variable(typeof(Counter), "c");
var hitcounter = Expression.Lambda <Action <NonGenericStructEnumerableCounter> > (
CustomExpression.ForEach(
item,
ec,
Expression.Call(item, "Hit", Type.EmptyTypes)),
ec).Compile();
hitcounter(enumerable_counter);
foreach (var counter in counters)
{
Assert.AreEqual(1, counter.Count);
Assert.IsFalse(counter.Disposed);
}
}
