public void Run(RegressionEnvironment env)
{
string[] fields = "c0,c1,c2".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportCollection");
builder.WithExpression(fields[0], "Strvals.groupBy(c => extractAfterUnderscore(c))");
builder.WithExpression(fields[1], "Strvals.groupBy((c, i) => extractAfterUnderscore(c) || '_' || Convert.ToString(i))");
builder.WithExpression(
fields[2],
"Strvals.groupBy((c, i, s) => extractAfterUnderscore(c) || '_' || Convert.ToString(i) || '_' || Convert.ToString(s))");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(IDictionary <object, object>)));
builder.WithAssertion(SupportCollection.MakeString("E1_2,E2_1,E3_2"))
.Verify("c0", val => CompareMaps(val, "2,1", new[] { "E1_2,E3_2", "E2_1" }, GetExtractorScalar()))
.Verify("c1", val => CompareMaps(val, "2_0,1_1,2_2", new[] { "E1_2", "E2_1", "E3_2" }, GetExtractorScalar()))
.Verify("c2", val => CompareMaps(val, "2_0_3,1_1_3,2_2_3", new[] { "E1_2", "E2_1", "E3_2" }, GetExtractorScalar()));
SupportEvalAssertionBuilder assertionNull = builder.WithAssertion(SupportCollection.MakeString(null));
foreach (string field in fields)
{
assertionNull.Verify(field, Assert.IsNull);
}
SupportEvalAssertionBuilder assertionEmpty = builder.WithAssertion(SupportCollection.MakeString(""));
foreach (string field in fields)
{
assertionEmpty.Verify(field, val => CompareMaps(val, "", new string[0], GetExtractorScalar()));
}
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
var fields = "c0,c1,c2,c3,c4,c5".SplitCsv();
var builder = new SupportEvalBuilder("SupportCollection");
builder.WithExpression(fields[0], "Strvals.minBy(v => extractNum(v))");
builder.WithExpression(fields[1], "Strvals.maxBy(v => extractNum(v))");
builder.WithExpression(fields[2], "Strvals.minBy( (v, i) => extractNum(v) + i*10)");
builder.WithExpression(fields[3], "Strvals.maxBy( (v, i) => extractNum(v) + i*10)");
builder.WithExpression(fields[4], "Strvals.minBy( (v, i, s) => extractNum(v) + (case when s > 2 then i*10 else 0 end))");
builder.WithExpression(fields[5], "Strvals.maxBy( (v, i, s) => extractNum(v) + (case when s > 2 then i*10 else 0 end))");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(String)));
builder.WithAssertion(SupportCollection.MakeString("E2,E1,E5,E4")).Expect(fields, "E1", "E5", "E2", "E4", "E2", "E4");
builder.WithAssertion(SupportCollection.MakeString("E1")).Expect(fields, "E1", "E1", "E1", "E1", "E1", "E1");
builder.WithAssertion(SupportCollection.MakeString(null)).Expect(fields, null, null, null, null, null, null);
builder.WithAssertion(SupportCollection.MakeString("")).Expect(fields, null, null, null, null, null, null);
builder.WithAssertion(SupportCollection.MakeString("E8,E2")).Expect(fields, "E2", "E8", "E8", "E2", "E2", "E8");
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0,c1".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportCollection");
builder.WithExpression(fields[0], "Strvals.selectFrom( (v, i) => v || '_' || Convert.ToString(i))");
builder.WithExpression(fields[1], "Strvals.selectFrom( (v, i, s) => v || '_' || Convert.ToString(i) || '_' || Convert.ToString(s))");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(ICollection <object>)));
builder.WithAssertion(SupportCollection.MakeString("E1,E2,E3"))
.Verify(fields[0], value => AssertValuesArrayScalar(value, "E1_0", "E2_1", "E3_2"))
.Verify(fields[1], value => AssertValuesArrayScalar(value, "E1_0_3", "E2_1_3", "E3_2_3"));
builder.WithAssertion(SupportCollection.MakeString(""))
.Verify(fields[0], value => AssertValuesArrayScalar(value))
.Verify(fields[1], value => AssertValuesArrayScalar(value));
builder.WithAssertion(SupportCollection.MakeString("E1"))
.Verify(fields[0], value => AssertValuesArrayScalar(value, "E1_0"))
.Verify(fields[1], value => AssertValuesArrayScalar(value, "E1_0_1"));
builder.WithAssertion(SupportCollection.MakeString(null))
.Verify(fields[0], Assert.IsNull)
.Verify(fields[1], Assert.IsNull);
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0,c1,c2,c3,c4,c5,c6,c7".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportCollection");
builder.WithExpression(fields[0], "Strvals.min(v => extractNum(v))");
builder.WithExpression(fields[1], "Strvals.max(v => extractNum(v))");
builder.WithExpression(fields[2], "Strvals.min(v => v)");
builder.WithExpression(fields[3], "Strvals.max(v => v)");
builder.WithExpression(fields[4], "Strvals.min( (v, i) => extractNum(v) + i*10)");
builder.WithExpression(fields[5], "Strvals.max( (v, i) => extractNum(v) + i*10)");
builder.WithExpression(fields[6], "Strvals.min( (v, i, s) => extractNum(v) + i*10 + s*100)");
builder.WithExpression(fields[7], "Strvals.max( (v, i, s) => extractNum(v) + i*10 + s*100)");
builder.WithStatementConsumer(
stmt => AssertTypes(
stmt.EventType,
fields,
new[] {
typeof(int?), typeof(int?), typeof(string), typeof(string),
typeof(int?), typeof(int?), typeof(int?), typeof(int?)
}));
builder.WithAssertion(SupportCollection.MakeString("E2,E1,E5,E4")).Expect(fields, 1, 5, "E1", "E5", 2, 34, 402, 434);
builder.WithAssertion(SupportCollection.MakeString("E1")).Expect(fields, 1, 1, "E1", "E1", 1, 1, 101, 101);
builder.WithAssertion(SupportCollection.MakeString(null)).Expect(fields, null, null, null, null, null, null, null, null);
builder.WithAssertion(SupportCollection.MakeString("")).Expect(fields, null, null, null, null, null, null, null, null);
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportBean_ST0_Container");
builder.WithExpression(fields[0], "Contained.reverse()");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(ICollection <object>)));
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,1", "E2,9", "E3,1"))
.Verify("c0", val => AssertST0Id(val, "E3,E2,E1"));
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E2,9", "E1,1"))
.Verify("c0", val => AssertST0Id(val, "E1,E2"));
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,1"))
.Verify("c0", val => AssertST0Id(val, "E1"));
builder.WithAssertion(SupportBean_ST0_Container.Make2ValueNull())
.Verify("c0", val => AssertST0Id(val, null));
builder.WithAssertion(SupportBean_ST0_Container.Make2Value())
.Verify("c0", val => AssertST0Id(val, ""));
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
var fields = "c0,c1,c2".SplitCsv();
var builder = new SupportEvalBuilder("SupportCollection");
builder.WithExpression(fields[0], "Strvals.where(x => x not like '%1%')");
builder.WithExpression(fields[1], "Strvals.where((x, i) => x not like '%1%' and i >= 1)");
builder.WithExpression(fields[2], "Strvals.where((x, i, s) => x not like '%1%' and i >= 1 and s >= 3)");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(ICollection<object>)));
builder.WithAssertion(SupportCollection.MakeString("E1,E2,E3"))
.Verify("c0", val => AssertValuesArrayScalar(val, "E2", "E3"))
.Verify("c1", val => AssertValuesArrayScalar(val, "E2", "E3"))
.Verify("c2", val => AssertValuesArrayScalar(val, "E2", "E3"));
builder.WithAssertion(SupportCollection.MakeString("E4,E2,E1"))
.Verify("c0", val => AssertValuesArrayScalar(val, "E4", "E2"))
.Verify("c1", val => AssertValuesArrayScalar(val, "E2"))
.Verify("c2", val => AssertValuesArrayScalar(val, "E2"));
builder.WithAssertion(SupportCollection.MakeString(""))
.Verify("c0", val => AssertValuesArrayScalar(val))
.Verify("c1", val => AssertValuesArrayScalar(val))
.Verify("c2", val => AssertValuesArrayScalar(val));
builder.WithAssertion(SupportCollection.MakeString("E4,E2"))
.Verify("c0", val => AssertValuesArrayScalar(val, "E4", "E2"))
.Verify("c1", val => AssertValuesArrayScalar(val, "E2"))
.Verify("c2", val => AssertValuesArrayScalar(val));
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0,c1,c2".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportBean_ST0_Container");
builder.WithExpression(fields[0], "Contained.arrayOf(x => x.P00)");
builder.WithExpression(fields[1], "Contained.arrayOf((x, i) => x.P00 + i*10)");
builder.WithExpression(fields[2], "Contained.arrayOf((x, i, s) => x.P00 + i*10 + s*100)");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(int?[])));
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,1", "E2,9", "E2,2"))
.Expect(fields, IntArray(1, 9, 2), IntArray(1, 19, 22), IntArray(301, 319, 322));
builder.WithAssertion(SupportBean_ST0_Container.Make2ValueNull())
.Expect(fields, null, null, null);
builder.WithAssertion(SupportBean_ST0_Container.Make2Value())
.Expect(fields, IntArray(), IntArray(), IntArray());
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,9"))
.Expect(fields, IntArray(9), IntArray(9), IntArray(109));
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0,c1,c2,c3,c4,c5".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportBean_ST0_Container");
builder.WithExpression(fields[0], "Contained.mostFrequent(x => P00)");
builder.WithExpression(fields[1], "Contained.leastFrequent(x => P00)");
builder.WithExpression(fields[2], "Contained.mostFrequent( (x, i) => P00 + i*2)");
builder.WithExpression(fields[3], "Contained.leastFrequent( (x, i) => P00 + i*2)");
builder.WithExpression(fields[4], "Contained.mostFrequent( (x, i, s) => P00 + i*2 + s*4)");
builder.WithExpression(fields[5], "Contained.leastFrequent( (x, i, s) => P00 + i*2 + s*4)");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(int?)));
SupportBean_ST0_Container bean = SupportBean_ST0_Container.Make2Value("E1,12", "E2,11", "E2,2", "E3,12");
builder.WithAssertion(bean).Expect(fields, 12, 11, 12, 12, 28, 28);
bean = SupportBean_ST0_Container.Make2Value("E1,12");
builder.WithAssertion(bean).Expect(fields, 12, 12, 12, 12, 16, 16);
bean = SupportBean_ST0_Container.Make2Value("E1,12", "E2,11", "E2,2", "E3,12", "E1,12", "E2,11", "E3,11");
builder.WithAssertion(bean).Expect(fields, 12, 2, 12, 12, 40, 40);
bean = SupportBean_ST0_Container.Make2Value("E2,11", "E1,12", "E2,15", "E3,12", "E1,12", "E2,11", "E3,11");
builder.WithAssertion(bean).Expect(fields, 11, 15, 11, 11, 39, 39);
builder.WithAssertion(SupportBean_ST0_Container.Make2ValueNull()).Expect(fields, null, null, null, null, null, null);
builder.WithAssertion(SupportBean_ST0_Container.Make2Value()).Expect(fields, null, null, null, null, null, null);
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0,c1,c2".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportCollection");
builder.WithExpression(fields[0], "Strvals.toMap(k => k, v => extractNum(v))");
builder.WithExpression(fields[1], "Strvals.toMap((k, i) => k || '_' || Convert.ToString(i), (v, idx) => extractNum(v) + 10*idx)");
builder.WithExpression(
fields[2],
"Strvals.toMap((k, i, s) => k || '_' || Convert.ToString(i) || '_' || Convert.ToString(s), (v, idx, sz) => extractNum(v) + 10*idx + 100*sz)");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(IDictionary <object, object>)));
builder.WithAssertion(SupportCollection.MakeString("E2,E1,E3"))
.Verify("c0", val => CompareMap(val, "E1,E2,E3", 1, 2, 3))
.Verify("c1", val => CompareMap(val, "E1_1,E2_0,E3_2", 11, 2, 23))
.Verify("c2", val => CompareMap(val, "E1_1_3,E2_0_3,E3_2_3", 311, 302, 323));
builder.WithAssertion(SupportCollection.MakeString("E1"))
.Verify("c0", val => CompareMap(val, "E1", 1))
.Verify("c1", val => CompareMap(val, "E1_0", 1))
.Verify("c2", val => CompareMap(val, "E1_0_1", 101));
builder.WithAssertion(SupportCollection.MakeString(null))
.Verify("c0", Assert.IsNull)
.Verify("c1", Assert.IsNull)
.Verify("c2", Assert.IsNull);
builder.WithAssertion(SupportCollection.MakeString(""))
.Verify("c0", val => CompareMap(val, ""))
.Verify("c1", val => CompareMap(val, ""))
.Verify("c2", val => CompareMap(val, ""));
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
var fields = "c0,c1,c2".SplitCsv();
var builder = new SupportEvalBuilder("SupportBean_Container");
builder.WithExpression(fields[0], "Beans.sumOf(x => IntBoxed)");
builder.WithExpression(fields[1], "Beans.sumOf( (x, i) => IntBoxed + i*10)");
builder.WithExpression(fields[2], "Beans.sumOf( (x, i, s) => IntBoxed + i*10 + s*100)");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(int?)));
builder.WithAssertion(new SupportBean_Container(null)).Expect(fields, null, null, null);
builder.WithAssertion(new SupportBean_Container(EmptyList <SupportBean> .Instance)).Expect(fields, null, null, null);
IList <SupportBean> listOne = new List <SupportBean>()
{
MakeSB("E1", 10)
};
builder.WithAssertion(new SupportBean_Container(listOne)).Expect(fields, 10, 10, 110);
IList <SupportBean> listTwo = new List <SupportBean>()
{
MakeSB("E1", 10), MakeSB("E2", 11)
};
builder.WithAssertion(new SupportBean_Container(listTwo)).Expect(fields, 21, 31, 431);
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0,c1,c2,c3,c4".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportBean_ST0_Container");
builder.WithExpression(fields[0], "Contained.aggregate(0, (result, item) => result + item.P00)");
builder.WithExpression(fields[1], "Contained.aggregate('', (result, item) => result || ', ' || item.Id)");
builder.WithExpression(fields[2], "Contained.aggregate('', (result, item) => result || (case when result='' then '' else ',' end) || item.Id)");
builder.WithExpression(fields[3], "Contained.aggregate(0, (result, item, i) => result + item.P00 + i*10)");
builder.WithExpression(fields[4], "Contained.aggregate(0, (result, item, i, s) => result + item.P00 + i*10 + s*100)");
builder.WithStatementConsumer(
stmt => LambdaAssertionUtil.AssertTypes(
stmt.EventType,
fields,
new[] { typeof(int?), typeof(string), typeof(string), typeof(int?), typeof(int?) }));
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,12", "E2,11", "E2,2"))
.Expect(fields, 25, ", E1, E2, E2", "E1,E2,E2", 12 + 21 + 22, 312 + 321 + 322);
builder.WithAssertion(SupportBean_ST0_Container.Make2ValueNull())
.Expect(fields, null, null, null, null, null);
builder.WithAssertion(SupportBean_ST0_Container.Make2Value(new string[0]))
.Expect(fields, 0, "", "", 0, 0);
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,12"))
.Expect(fields, 12, ", E1", "E1", 12, 112);
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0,c1,c2,c3".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportBean_ST0_Container");
builder.WithExpression(fields[0], "Contained.countof()");
builder.WithExpression(fields[1], "Contained.countof(x => x.P00 = 9)");
builder.WithExpression(fields[2], "Contained.countof((x, i) => x.P00 + i = 10)");
builder.WithExpression(fields[3], "Contained.countof((x, i, s) => x.P00 + i + s = 100)");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(int?)));
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,1", "E2,9", "E2,9")).Expect(fields, 3, 2, 1, 0);
builder.WithAssertion(SupportBean_ST0_Container.Make2ValueNull()).Expect(fields, null, null, null, null);
builder.WithAssertion(SupportBean_ST0_Container.Make2Value()).Expect(fields, 0, 0, 0, 0);
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,9")).Expect(fields, 1, 1, 0, 0);
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,1")).Expect(fields, 1, 0, 0, 0);
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,10", "E2,9")).Expect(fields, 2, 1, 2, 0);
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,98", "E2,97")).Expect(fields, 2, 0, 0, 2);
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0,c1,c2,c3".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportCollection");
builder.WithExpression(fields[0], "Strvals.take(2)");
builder.WithExpression(fields[1], "Strvals.take(1)");
builder.WithExpression(fields[2], "Strvals.takeLast(2)");
builder.WithExpression(fields[3], "Strvals.takeLast(1)");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(ICollection <object>)));
builder.WithAssertion(SupportCollection.MakeString("E1,E2,E3"))
.Verify("c0", val => AssertValuesArrayScalar(val, "E1", "E2"))
.Verify("c1", val => AssertValuesArrayScalar(val, "E1"))
.Verify("c2", val => AssertValuesArrayScalar(val, "E2", "E3"))
.Verify("c3", val => AssertValuesArrayScalar(val, "E3"));
builder.WithAssertion(SupportCollection.MakeString("E1,E2"))
.Verify("c0", val => AssertValuesArrayScalar(val, "E1", "E2"))
.Verify("c1", val => AssertValuesArrayScalar(val, "E1"))
.Verify("c2", val => AssertValuesArrayScalar(val, "E1", "E2"))
.Verify("c3", val => AssertValuesArrayScalar(val, "E2"));
AssertSingleAndEmptySupportColl(builder, fields);
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0,c1,c2".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportBean_ST0_Container");
builder.WithExpression(fields[0], "Contained.toMap(c => Id, d => P00)");
builder.WithExpression(fields[1], "Contained.toMap((c, index) => Id || '_' || Convert.ToString(index), (d, index) => P00 + 10*index)");
builder.WithExpression(
fields[2],
"Contained.toMap((c, index, size) => Id || '_' || Convert.ToString(index) || '_' || Convert.ToString(size), (d, index, size) => P00 + 10*index + 100*size)");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(IDictionary <object, object>)));
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,1", "E3,12", "E2,5"))
.Verify("c0", val => CompareMap(val, "E1,E3,E2", 1, 12, 5))
.Verify("c1", val => CompareMap(val, "E1_0,E3_1,E2_2", 1, 22, 25))
.Verify("c2", val => CompareMap(val, "E1_0_3,E3_1_3,E2_2_3", 301, 322, 325));
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,1", "E3,4", "E2,7", "E1,2"))
.Verify("c0", val => CompareMap(val, "E1,E3,E2", 2, 4, 7))
.Verify("c1", val => CompareMap(val, "E1_0,E3_1,E2_2,E1_3", 1, 14, 27, 32))
.Verify("c2", val => CompareMap(val, "E1_0_4,E3_1_4,E2_2_4,E1_3_4", 401, 414, 427, 432));
builder.WithAssertion(new SupportBean_ST0_Container(Collections.SingletonList(new SupportBean_ST0(null, null))))
.Verify("c0", val => CompareMap(val, "E1,E2,E3", null, null, null))
.Verify("c1", val => CompareMap(val, "E1,E2,E3", null, null, null))
.Verify("c2", val => CompareMap(val, "E1,E2,E3", null, null, null));
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
var fields = "c0,c1,c2,c3,c4,c5,c6,c7".SplitCsv();
var builder = new SupportEvalBuilder("SupportBean")
.WithExpression(fields[0], "instanceof(TheString, string)")
.WithExpression(fields[1], "instanceof(IntBoxed, int)")
.WithExpression(fields[2], "instanceof(FloatBoxed, System.Single)")
.WithExpression(fields[3], "instanceof(TheString, System.Single, char, byte)")
.WithExpression(fields[4], "instanceof(IntPrimitive, System.Int32)")
.WithExpression(fields[5], "instanceof(IntPrimitive, long)")
.WithExpression(fields[6], "instanceof(IntPrimitive, long, long, System.Object)")
.WithExpression(fields[7], "instanceof(FloatBoxed, long, float)");
builder.WithStatementConsumer(
stmt => {
for (var i = 0; i < fields.Length; i++)
{
Assert.AreEqual(typeof(bool?), stmt.EventType.GetPropertyType(fields[i]));
}
});
var bean = new SupportBean("abc", 100);
bean.FloatBoxed = 100F;
builder.WithAssertion(bean).Expect(fields, true, false, true, false, true, false, true, true);
bean = new SupportBean(null, 100);
bean.FloatBoxed = null;
builder.WithAssertion(bean).Expect(fields, false, false, false, false, true, false, true, false);
builder.Run(env);
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
var fields = "c0,c1,c2,c3,c4".SplitCsv();
var builder = new SupportEvalBuilder("SupportBean")
.WithExpressions(
fields,
"exists(TheString)",
"exists(IntBoxed?)",
"exists(dummy?)",
"exists(IntPrimitive?)",
"exists(IntPrimitive)");
builder.WithStatementConsumer(
stmt => {
for (var i = 0; i < 5; i++)
{
Assert.AreEqual(typeof(bool?), stmt.EventType.GetPropertyType("c" + i));
}
});
var bean = new SupportBean("abc", 100);
bean.FloatBoxed = 9.5f;
bean.IntBoxed = 3;
builder.WithAssertion(bean).Expect(fields, true, true, false, true, true);
builder.Run(env);
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0,c1,c2,c3".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportCollection");
builder.WithExpression(fields[0], "Strvals.arrayOf()");
builder.WithExpression(fields[1], "Strvals.arrayOf(v => v)");
builder.WithExpression(fields[2], "Strvals.arrayOf( (v, i) => v || '_' || Convert.ToString(i))");
builder.WithExpression(fields[3], "Strvals.arrayOf( (v, i, s) => v || '_' || Convert.ToString(i) || '_' || Convert.ToString(s))");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(string[])));
builder.WithAssertion(SupportCollection.MakeString("A,B,C"))
.Expect(fields, Csv("A,B,C"), Csv("A,B,C"), Csv("A_0,B_1,C_2"), Csv("A_0_3,B_1_3,C_2_3"));
builder.WithAssertion(SupportCollection.MakeString(""))
.Expect(fields, Csv(""), Csv(""), Csv(""), Csv(""));
builder.WithAssertion(SupportCollection.MakeString("A"))
.Expect(fields, Csv("A"), Csv("A"), Csv("A_0"), Csv("A_0_1"));
builder.WithAssertion(SupportCollection.MakeString(null))
.Expect(fields, null, null, null, null);
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0,c1,c2,c3".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportBean_ST0_Container");
builder.WithExpression(fields[0], "Contained.orderBy( (x, i) => case when i <= 2 then P00 else i-10 end)");
builder.WithExpression(fields[1], "Contained.orderByDesc( (x, i) => case when i <= 2 then P00 else i-10 end)");
builder.WithExpression(fields[2], "Contained.orderBy( (x, i, s) => case when s <= 2 then P00 else i-10 end)");
builder.WithExpression(fields[3], "Contained.orderByDesc( (x, i, s) => case when s <= 2 then P00 else i-10 end)");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(ICollection <object>)));
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,1", "E2,2"))
.Verify("c0", val => AssertST0Id(val, "E1,E2"))
.Verify("c1", val => AssertST0Id(val, "E2,E1"))
.Verify("c2", val => AssertST0Id(val, "E1,E2"))
.Verify("c3", val => AssertST0Id(val, "E2,E1"));
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,1", "E2,2", "E3,3", "E4,4"))
.Verify("c0", val => AssertST0Id(val, "E4,E1,E2,E3"))
.Verify("c1", val => AssertST0Id(val, "E3,E2,E1,E4"))
.Verify("c2", val => AssertST0Id(val, "E1,E2,E3,E4"))
.Verify("c3", val => AssertST0Id(val, "E4,E3,E2,E1"));
builder.WithAssertion(SupportBean_ST0_Container.Make2ValueNull()).Expect(fields, null, null, null, null);
builder.WithAssertion(SupportBean_ST0_Container.Make2Value())
.Verify("c0", val => AssertST0Id(val, ""))
.Verify("c1", val => AssertST0Id(val, ""))
.Verify("c2", val => AssertST0Id(val, ""))
.Verify("c3", val => AssertST0Id(val, ""));
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
var fields = "new double[1],c1,c2,new double[1][2],c4".SplitCsv();
var builder = new SupportEvalBuilder("SupportBean")
.WithExpression(fields[0], "new double[1]")
.WithExpression(fields[1], "new `System.Nullable<System.Int32>`[2*2]")
.WithExpression(fields[2], "new " + typeof(DateTimeEx).FullName + "[IntPrimitive]")
.WithExpression(fields[3], "new double[1][2]")
.WithExpression(fields[4], "new " + typeof(DateTimeEx).FullName + "[IntPrimitive][IntPrimitive]");
builder.WithStatementConsumer(
stmt => {
var @out = stmt.EventType;
Assert.AreEqual(typeof(double[]), @out.GetPropertyType("new double[1]"));
Assert.AreEqual(typeof(int?[]), @out.GetPropertyType("c1"));
Assert.AreEqual(typeof(DateTimeEx[]), @out.GetPropertyType("c2"));
Assert.AreEqual(typeof(double[][]), @out.GetPropertyType("new double[1][2]"));
Assert.AreEqual(typeof(DateTimeEx[][]), @out.GetPropertyType("c4"));
});
builder
.WithAssertion(new SupportBean("E1", 2))
.Expect(
fields,
new double[1],
new int?[4],
new DateTimeEx[2],
new double[1][],
new DateTimeEx[2][]);
builder.Run(env, soda);
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0,c1,c2,c3,c4,c5".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportCollection");
builder.WithExpression(fields[0], "Strvals.orderBy(v => extractNum(v))");
builder.WithExpression(fields[1], "Strvals.orderByDesc(v => extractNum(v))");
builder.WithExpression(fields[2], "Strvals.orderBy( (v, i) => case when i <= 2 then extractNum(v) else i-10 end)");
builder.WithExpression(fields[3], "Strvals.orderByDesc( (v, i) => case when i <= 2 then extractNum(v) else i-10 end)");
builder.WithExpression(fields[4], "Strvals.orderBy( (v, i, s) => case when s <= 2 then extractNum(v) else i-10 end)");
builder.WithExpression(fields[5], "Strvals.orderByDesc( (v, i, s) => case when s <= 2 then extractNum(v) else i-10 end)");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(ICollection <object>)));
builder.WithAssertion(SupportCollection.MakeString("E2,E1,E5,E4"))
.Verify("c0", val => AssertValuesArrayScalar(val, "E1", "E2", "E4", "E5"))
.Verify("c1", val => AssertValuesArrayScalar(val, "E5", "E4", "E2", "E1"))
.Verify("c2", val => AssertValuesArrayScalar(val, "E4", "E1", "E2", "E5"))
.Verify("c3", val => AssertValuesArrayScalar(val, "E5", "E2", "E1", "E4"))
.Verify("c4", val => AssertValuesArrayScalar(val, "E2", "E1", "E5", "E4"))
.Verify("c5", val => AssertValuesArrayScalar(val, "E4", "E5", "E1", "E2"));
builder.WithAssertion(SupportCollection.MakeString("E2,E1"))
.Verify("c0", val => AssertValuesArrayScalar(val, "E1", "E2"))
.Verify("c1", val => AssertValuesArrayScalar(val, "E2", "E1"))
.Verify("c2", val => AssertValuesArrayScalar(val, "E1", "E2"))
.Verify("c3", val => AssertValuesArrayScalar(val, "E2", "E1"))
.Verify("c4", val => AssertValuesArrayScalar(val, "E1", "E2"))
.Verify("c5", val => AssertValuesArrayScalar(val, "E2", "E1"));
LambdaAssertionUtil.AssertSingleAndEmptySupportColl(builder, fields);
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0,c1,c2".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportCollection");
builder.WithExpression(fields[0], "Strvals.except(Strvalstwo)");
builder.WithExpression(fields[1], "Strvals.intersect(Strvalstwo)");
builder.WithExpression(fields[2], "Strvals.union(Strvalstwo)");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(ICollection <object>)));
builder.WithAssertion(SupportCollection.MakeString("E1,E2", "E3,E4"))
.Verify("c0", val => AssertValuesArrayScalar(val, "E1", "E2"))
.Verify("c1", val => AssertValuesArrayScalar(val))
.Verify("c2", val => AssertValuesArrayScalar(val, "E1", "E2", "E3", "E4"));
builder.WithAssertion(SupportCollection.MakeString(null, "E3,E4"))
.Verify("c0", val => AssertValuesArrayScalar(val, (object[])null))
.Verify("c1", val => AssertValuesArrayScalar(val, (object[])null))
.Verify("c2", val => AssertValuesArrayScalar(val, (object[])null));
builder.WithAssertion(SupportCollection.MakeString("", "E3,E4"))
.Verify("c0", val => AssertValuesArrayScalar(val))
.Verify("c1", val => AssertValuesArrayScalar(val))
.Verify("c2", val => AssertValuesArrayScalar(val, "E3", "E4"));
builder.WithAssertion(SupportCollection.MakeString("E1,E3,E5", "E3,E4"))
.Verify("c0", val => AssertValuesArrayScalar(val, "E1", "E5"))
.Verify("c1", val => AssertValuesArrayScalar(val, "E3"))
.Verify("c2", val => AssertValuesArrayScalar(val, "E1", "E3", "E5", "E3", "E4"));
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0,c1,c2,c3,c4,c5,c6,c7".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportCollection");
builder.WithExpression(fields[0], "Strvals.firstOf()");
builder.WithExpression(fields[1], "Strvals.lastOf()");
builder.WithExpression(fields[2], "Strvals.firstOf(x => x like '%1%')");
builder.WithExpression(fields[3], "Strvals.lastOf(x => x like '%1%')");
builder.WithExpression(fields[4], "Strvals.firstOf((x, i) => x like '%1%' and i >= 1)");
builder.WithExpression(fields[5], "Strvals.lastOf((x, i) => x like '%1%' and i >= 1)");
builder.WithExpression(fields[6], "Strvals.firstOf((x, i, s) => x like '%1%' and i >= 1 and s > 2)");
builder.WithExpression(fields[7], "Strvals.lastOf((x, i, s) => x like '%1%' and i >= 1 and s > 2)");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(string)));
builder.WithAssertion(SupportCollection.MakeString("E1,E2,E3")).Expect(fields, "E1", "E3", "E1", "E1", null, null, null, null);
builder.WithAssertion(SupportCollection.MakeString("E1")).Expect(fields, "E1", "E1", "E1", "E1", null, null, null, null);
builder.WithAssertion(SupportCollection.MakeString("E2,E3,E4")).Expect(fields, "E2", "E4", null, null, null, null, null, null);
builder.WithAssertion(SupportCollection.MakeString("")).Expect(fields, null, null, null, null, null, null, null, null);
builder.WithAssertion(SupportCollection.MakeString(null)).Expect(fields, null, null, null, null, null, null, null, null);
builder.WithAssertion(SupportCollection.MakeString("E5,E2,E3,A1,B1")).Expect(fields, "E5", "B1", "A1", "B1", "A1", "B1", "A1", "B1");
builder.WithAssertion(SupportCollection.MakeString("A1,B1,E5,E2,E3")).Expect(fields, "A1", "E3", "A1", "B1", "B1", "B1", "B1", "B1");
builder.WithAssertion(SupportCollection.MakeString("A1,B1")).Expect(fields, "A1", "B1", "A1", "B1", "B1", "B1", null, null);
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0,c1,c2,c3,c4,c5".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportBean_ST0_Container");
builder.WithExpression(fields[0], "Contained.firstOf(x => P00 = 9)");
builder.WithExpression(fields[1], "Contained.lastOf(x => P00 = 9)");
builder.WithExpression(fields[2], "Contained.firstOf( (x, i) => P00 = 9 and i >= 1)");
builder.WithExpression(fields[3], "Contained.lastOf( (x, i) => P00 = 9 and i >= 1)");
builder.WithExpression(fields[4], "Contained.firstOf( (x, i, s) => P00 = 9 and i >= 1 and s > 2)");
builder.WithExpression(fields[5], "Contained.lastOf((x, i, s) => P00 = 9 and i >= 1 and s > 2)");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(SupportBean_ST0)));
SupportBean_ST0_Container beanOne = SupportBean_ST0_Container.Make2Value("E1,1", "E2,9", "E2,9");
builder.WithAssertion(beanOne)
.Expect(
fields,
beanOne.Contained[1],
beanOne.Contained[2],
beanOne.Contained[1],
beanOne.Contained[2],
beanOne.Contained[1],
beanOne.Contained[2]);
builder.WithAssertion(SupportBean_ST0_Container.Make2ValueNull()).Expect(fields, null, null, null, null, null, null);
builder.WithAssertion(SupportBean_ST0_Container.Make2Value()).Expect(fields, null, null, null, null, null, null);
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,1", "E2,1", "E2,1")).Expect(fields, null, null, null, null, null, null);
SupportBean_ST0_Container beanTwo = SupportBean_ST0_Container.Make2Value("E1,1", "E2,9");
builder.WithAssertion(beanTwo)
.Expect(
fields,
beanTwo.Contained[1],
beanTwo.Contained[1],
beanTwo.Contained[1],
beanTwo.Contained[1],
null,
null);
SupportBean_ST0_Container beanThree = SupportBean_ST0_Container.Make2Value("E2,9", "E1,1");
builder.WithAssertion(beanThree)
.Expect(
fields,
beanThree.Contained[0],
beanThree.Contained[0],
null,
null,
null,
null);
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
var fields = "c0,c1,c2,c3,c4,c5,c6,c7".SplitCsv();
var builder = new SupportEvalBuilder("SupportBean_Container");
builder.WithExpression(fields[0], "Beans.average(x => IntBoxed)");
builder.WithExpression(fields[1], "Beans.average(x => DoubleBoxed)");
builder.WithExpression(fields[2], "Beans.average(x => LongBoxed)");
builder.WithExpression(fields[3], "Beans.average(x => DecimalBoxed)");
builder.WithExpression(fields[4], "Beans.average( (x, i) => IntBoxed + i*10)");
builder.WithExpression(fields[5], "Beans.average( (x, i) => DecimalBoxed + i*10)");
builder.WithExpression(fields[6], "Beans.average( (x, i, s) => IntBoxed + i*10 + s*100)");
builder.WithExpression(fields[7], "Beans.average( (x, i, s) => DecimalBoxed + i*10 + s*100)");
builder.WithStatementConsumer(
stmt => AssertTypes(
stmt.EventType,
fields,
new[] {
typeof(double?), typeof(double?), typeof(double?), typeof(decimal?), typeof(double?), typeof(decimal?), typeof(double?),
typeof(decimal?)
}));
builder.WithAssertion(new SupportBean_Container(null))
.Expect(fields, null, null, null, null, null, null, null, null);
builder.WithAssertion(new SupportBean_Container(EmptyList <SupportBean> .Instance))
.Expect(fields, null, null, null, null, null, null, null, null);
var listOne = new List <SupportBean>()
{
Make(2, 3d, 4L, 5)
};
builder.WithAssertion(new SupportBean_Container(listOne))
.Expect(fields, 2d, 3d, 4d, 5.0m, 2d, 5.0m, 102d, 105.0m);
var listTwo = new List <SupportBean>()
{
Make(2, 3d, 4L, 5),
Make(4, 6d, 8L, 10)
};
builder.WithAssertion(new SupportBean_Container(listTwo))
.Expect(
fields,
(2 + 4) / 2d,
(3d + 6d) / 2d,
(4L + 8L) / 2d,
(5m + 10m) / 2m,
(2 + 14) / 2d,
(5m + 20m) / 2m,
(202 + 214) / 2d,
(205m + 220m) / 2m);
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
var fields = "c0,c1,c2,c3,c4,c5,c6,c7,c8,c9,c10,c11,c12".SplitCsv();
var builder = new SupportEvalBuilder("SupportBean")
.WithExpression(fields[0], "new char[] {}")
.WithExpression(fields[1], "new double[] {1}")
.WithExpression(fields[2], "new int[] {1,IntPrimitive,10}")
.WithExpression(fields[3], "new float[] {1,2.0f}")
.WithExpression(fields[4], "new long[] {1L,Int64.MaxValue,-1L}")
.WithExpression(fields[5], "new String[] {}")
.WithExpression(fields[6], "new String[] {\"x\"}")
.WithExpression(fields[7], "new String[] {\"x\",\"y\"}")
.WithExpression(fields[8], "new Int32[] {IntPrimitive,IntPrimitive+1,IntPrimitive+2,IntPrimitive+3}")
.WithExpression(fields[9], "new " + typeof(DateTimeEx).FullName + "[] {}")
.WithExpression(fields[10], "new Object[] {}")
.WithExpression(fields[11], "new Object[] {1}")
.WithExpression(fields[12], "new Object[] {\"x\",1,10L}");
builder.WithStatementConsumer(
stmt => {
var @out = stmt.EventType;
Assert.AreEqual(typeof(char[]), @out.GetPropertyType("c0"));
Assert.AreEqual(typeof(double[]), @out.GetPropertyType("c1"));
Assert.AreEqual(typeof(int[]), @out.GetPropertyType("c2"));
Assert.AreEqual(typeof(float[]), @out.GetPropertyType("c3"));
Assert.AreEqual(typeof(long[]), @out.GetPropertyType("c4"));
Assert.AreEqual(typeof(string[]), @out.GetPropertyType("c5"));
Assert.AreEqual(typeof(string[]), @out.GetPropertyType("c6"));
Assert.AreEqual(typeof(string[]), @out.GetPropertyType("c7"));
Assert.AreEqual(typeof(int[]), @out.GetPropertyType("c8"));
Assert.AreEqual(typeof(DateTimeEx[]), @out.GetPropertyType("c9"));
Assert.AreEqual(typeof(object[]), @out.GetPropertyType("c10"));
Assert.AreEqual(typeof(object[]), @out.GetPropertyType("c11"));
Assert.AreEqual(typeof(object[]), @out.GetPropertyType("c12"));
});
builder.WithAssertion(new SupportBean("E1", 2))
.Expect(
fields,
new char[0],
new double[] { 1 },
new[] { 1, 2, 10 },
new float[] { 1, 2 },
new[] { 1, long.MaxValue, -1 },
new string[0],
new[] { "x" },
new[] { "x", "y" },
new int?[] { 2, 3, 4, 5 },
new DateTimeEx[0],
new object[0],
new object[] { 1 },
new object[] { "x", 1, 10L });
builder.Run(env, soda);
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0,c1".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportBean_ST0_Container");
builder.WithExpression(fields[0], "Contained.selectFrom( (v, i) => new {v0=v.Id,v1=i})");
builder.WithExpression(fields[1], "Contained.selectFrom( (v, i, s) => new {v0=v.Id,v1=i + 100*s})");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(ICollection <object>)));
builder.WithAssertion(SupportBean_ST0_Container.Make3Value("E1,12,0", "E2,11,0", "E3,2,0"))
.Verify(
fields[0],
value => AssertRows(
value,
new object[][] {
new object[] { "E1", 0 },
new object[] { "E2", 1 },
new object[] { "E3", 2 }
}))
.Verify(
fields[1],
value => AssertRows(
value,
new object[][] {
new object[] { "E1", 300 },
new object[] { "E2", 301 },
new object[] { "E3", 302 }
}));
builder.WithAssertion(SupportBean_ST0_Container.Make3Value("E4,0,1"))
.Verify(
fields[0],
value => AssertRows(
value,
new object[][] {
new object[] { "E4", 0 }
}))
.Verify(
fields[1],
value => AssertRows(
value,
new object[][] {
new object[] { "E4", 100 }
}));
builder.WithAssertion(SupportBean_ST0_Container.Make3ValueNull())
.Verify(fields[0], value => AssertRows(value, null))
.Verify(fields[1], value => AssertRows(value, null));
builder.WithAssertion(SupportBean_ST0_Container.Make3Value())
.Verify(fields[0], value => AssertRows(value, new object[0][]))
.Verify(fields[1], value => AssertRows(value, new object[0][]));
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
var fields = "c0,c1,c2,c3,c4,c5,c6,c7".SplitCsv();
var builder = new SupportEvalBuilder("SupportBean")
.WithExpression(fields[0], "cast(TheString as string)")
.WithExpression(fields[1], "cast(IntBoxed, int)")
.WithExpression(fields[2], "cast(FloatBoxed, System.Single)")
.WithExpression(fields[3], "cast(TheString, System.String)")
.WithExpression(fields[4], "cast(IntPrimitive, System.Int32)")
.WithExpression(fields[5], "cast(IntPrimitive, long)")
.WithExpression(fields[6], "cast(IntPrimitive, System.Object)")
.WithExpression(fields[7], "cast(FloatBoxed, long)");
builder.WithStatementConsumer(
stmt => {
var type = stmt.EventType;
Assert.AreEqual(typeof(string), type.GetPropertyType("c0"));
Assert.AreEqual(typeof(int?), type.GetPropertyType("c1"));
Assert.AreEqual(typeof(float?), type.GetPropertyType("c2"));
Assert.AreEqual(typeof(string), type.GetPropertyType("c3"));
Assert.AreEqual(typeof(int?), type.GetPropertyType("c4"));
Assert.AreEqual(typeof(long?), type.GetPropertyType("c5"));
Assert.AreEqual(typeof(object), type.GetPropertyType("c6"));
Assert.AreEqual(typeof(long?), type.GetPropertyType("c7"));
});
var bean = new SupportBean("abc", 100);
bean.FloatBoxed = 9.5f;
bean.IntBoxed = 3;
builder.WithAssertion(bean).Expect(fields, "abc", 3, 9.5f, "abc", 100, 100L, 100, 9L);
bean = new SupportBean(null, 100);
bean.FloatBoxed = null;
bean.IntBoxed = null;
builder.WithAssertion(bean).Expect(fields, null, null, null, null, 100, 100L, 100, null);
builder.Run(env);
env.UndeployAll();
// test cast with chained and null
var epl =
"@Name('s0') select" +
" cast(One as " + typeof(SupportBean).FullName + ").GetTheString() as t0," +
" cast(null, " + typeof(SupportBean).FullName + ") as t1" +
" from SupportBeanObject";
env.CompileDeploy(epl).AddListener("s0");
env.SendEventBean(new SupportBeanObject(new SupportBean("E1", 1)));
EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), "t0,t1".SplitCsv(), "E1", null);
Assert.AreEqual(typeof(SupportBean), env.Statement("s0").EventType.GetPropertyType("t1"));
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0,c1,c2,c3,c4,c5".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportBean_ST0_Container");
builder.WithExpression(fields[0], "Contained.take(2)");
builder.WithExpression(fields[1], "Contained.take(1)");
builder.WithExpression(fields[2], "Contained.take(0)");
builder.WithExpression(fields[3], "Contained.take(-1)");
builder.WithExpression(fields[4], "Contained.takeLast(2)");
builder.WithExpression(fields[5], "Contained.takeLast(1)");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(ICollection <object>)));
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,1", "E2,2", "E3,3"))
.Verify("c0", val => AssertST0Id(val, "E1,E2"))
.Verify("c1", val => AssertST0Id(val, "E1"))
.Verify("c2", val => AssertST0Id(val, ""))
.Verify("c3", val => AssertST0Id(val, ""))
.Verify("c4", val => AssertST0Id(val, "E2,E3"))
.Verify("c5", val => AssertST0Id(val, "E3"));
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,1", "E2,2"))
.Verify("c0", val => AssertST0Id(val, "E1,E2"))
.Verify("c1", val => AssertST0Id(val, "E1"))
.Verify("c2", val => AssertST0Id(val, ""))
.Verify("c3", val => AssertST0Id(val, ""))
.Verify("c4", val => AssertST0Id(val, "E1,E2"))
.Verify("c5", val => AssertST0Id(val, "E2"));
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,1"))
.Verify("c0", val => AssertST0Id(val, "E1"))
.Verify("c1", val => AssertST0Id(val, "E1"))
.Verify("c2", val => AssertST0Id(val, ""))
.Verify("c3", val => AssertST0Id(val, ""))
.Verify("c4", val => AssertST0Id(val, "E1"))
.Verify("c5", val => AssertST0Id(val, "E1"));
SupportEvalAssertionBuilder assertionEmpty = builder.WithAssertion(SupportBean_ST0_Container.Make2Value());
foreach (string field in fields)
{
assertionEmpty.Verify(field, val => AssertST0Id(val, ""));
}
SupportEvalAssertionBuilder assertionNull = builder.WithAssertion(SupportBean_ST0_Container.Make2ValueNull());
foreach (string field in fields)
{
assertionNull.Verify(field, val => AssertST0Id(val, null));
}
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
var fields = "c0".SplitCsv();
var builder = new SupportEvalBuilder("SupportCollection");
builder.WithExpression(fields[0], "Boolvals.where(x => x)");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(ICollection<object>)));
builder.WithAssertion(SupportCollection.MakeBoolean("true,true,false"))
.Verify("c0", val => AssertValuesArrayScalar(val, true, true));
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
var fields = "c0,c1".SplitCsv();
var builder = new SupportEvalBuilder("SupportCollection");
builder.WithExpression(fields[0], "Intvals.sumOf()");
builder.WithExpression(fields[1], "Bdvals.sumOf()");
builder.WithStatementConsumer(stmt => AssertTypes(stmt.EventType, fields, new[] { typeof(int?), typeof(decimal?) }));
builder.WithAssertion(SupportCollection.MakeNumeric("1,4,5")).Expect(fields, 1 + 4 + 5, 1m + 4m + 5m);
builder.WithAssertion(SupportCollection.MakeNumeric("3,4")).Expect(fields, 3 + 4, 3m + 4m);
builder.WithAssertion(SupportCollection.MakeNumeric("3")).Expect(fields, 3, 3m);
builder.WithAssertion(SupportCollection.MakeNumeric("")).Expect(fields, null, null);
builder.WithAssertion(SupportCollection.MakeNumeric(null)).Expect(fields, null, null);
builder.Run(env);
}
