public void Run(RegressionEnvironment env)
{
string[] fields = "c0,c1,c2,c3".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportCollection");
builder.WithExpression(fields[0], "Strvals.distinctOf()");
builder.WithExpression(fields[1], "Strvals.distinctOf(v => extractNum(v))");
builder.WithExpression(fields[2], "Strvals.distinctOf((v, i) => case when i<2 then extractNum(v) else 0 end)");
builder.WithExpression(fields[3], "Strvals.distinctOf((v, i, s) => case when s<=2 then extractNum(v) else 0 end)");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(ICollection <object>)));
builder.WithAssertion(SupportCollection.MakeString("E2,E1,E2,E2"))
.Verify("c0", val => AssertValuesArrayScalar(val, "E2", "E1"))
.Verify("c1", val => AssertValuesArrayScalar(val, "E2", "E1"))
.Verify("c2", val => AssertValuesArrayScalar(val, "E2", "E1", "E2"))
.Verify("c3", val => AssertValuesArrayScalar(val, "E2"));
LambdaAssertionUtil.AssertSingleAndEmptySupportColl(builder, fields);
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportCollection");
builder.WithExpression(fields[0], "Strvals.sequenceEqual(Strvalstwo)");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(bool?)));
builder.WithAssertion(SupportCollection.MakeString("E1,E2,E3", "E1,E2,E3")).Expect(fields, true);
builder.WithAssertion(SupportCollection.MakeString("E1,E3", "E1,E2,E3")).Expect(fields, false);
builder.WithAssertion(SupportCollection.MakeString("E1,E3", "E1,E3")).Expect(fields, true);
builder.WithAssertion(SupportCollection.MakeString("E1,E2,E3", "E1,E3")).Expect(fields, false);
builder.WithAssertion(SupportCollection.MakeString("E1,E2,null,E3", "E1,E2,null,E3")).Expect(fields, true);
builder.WithAssertion(SupportCollection.MakeString("E1,E2,E3", "E1,E2,null")).Expect(fields, false);
builder.WithAssertion(SupportCollection.MakeString("E1,E2,null", "E1,E2,E3")).Expect(fields, false);
builder.WithAssertion(SupportCollection.MakeString("E1", "")).Expect(fields, false);
builder.WithAssertion(SupportCollection.MakeString("", "E1")).Expect(fields, false);
builder.WithAssertion(SupportCollection.MakeString("E1", "E1")).Expect(fields, true);
builder.WithAssertion(SupportCollection.MakeString("", "")).Expect(fields, true);
builder.WithAssertion(SupportCollection.MakeString(null, "")).Expect(fields, new object[] { null });
builder.WithAssertion(SupportCollection.MakeString("", null)).Expect(fields, false);
builder.WithAssertion(SupportCollection.MakeString(null, null)).Expect(fields, new object[] { null });
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
var fields = "c0,c1,c2,c3,c4,c5,c6,c7".SplitCsv();
var builder = new SupportEvalBuilder("SupportEventWithManyArray")
.WithExpression("c0", "IntOne=IntTwo")
.WithExpression("c1", "IntOne is IntTwo")
.WithExpression("c2", "IntBoxedOne=IntBoxedTwo")
.WithExpression("c3", "IntBoxedOne is IntBoxedTwo")
.WithExpression("c4", "Int2DimOne=Int2DimTwo")
.WithExpression("c5", "Int2DimOne is Int2DimTwo")
.WithExpression("c6", "ObjectOne=ObjectTwo")
.WithExpression("c7", "ObjectOne is ObjectTwo");
var array = new SupportEventWithManyArray("E1")
.WithIntOne(new[] { 1, 2 })
.WithIntTwo(new[] { 1, 2 })
.WithIntBoxedOne(new int?[] { 1, 2 })
.WithIntBoxedTwo(new int?[] { 1, 2 })
.WithObjectOne(new object[] { 'a', new object[] { 1 } })
.WithObjectTwo(new object[] { 'a', new object[] { 1 } })
.WithInt2DimOne(new[] { new[] { 1, 2 }, new[] { 3, 4 } })
.WithInt2DimTwo(new[] { new[] { 1, 2 }, new[] { 3, 4 } });
builder.WithAssertion(array).Expect(fields, true, true, true, true, true, true, true, true);
array = new SupportEventWithManyArray("E1")
.WithIntOne(new[] { 1, 2 })
.WithIntTwo(new[] { 1 })
.WithIntBoxedOne(new int?[] { 1, 2 })
.WithIntBoxedTwo(new int?[] { 1 })
.WithObjectOne(new object[] { 'a', 2 })
.WithObjectTwo(new object[] { 'a' })
.WithInt2DimOne(new[] { new[] { 1, 2 }, new[] { 3, 4 } })
.WithInt2DimTwo(new[] { new[] { 1, 2 }, new[] { 3 } });
builder.WithAssertion(array).Expect(fields, false, false, false, false, false, false, false, false);
builder.Run(env);
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
var fields = "c0,c1,c2,c3,c4,c5,c6,c7,c8".SplitCsv();
var builder = new SupportEvalBuilder("SupportBean")
.WithExpression(fields[0], "cast(IntPrimitive, float)")
.WithExpression(fields[1], "cast(IntPrimitive, short)")
.WithExpression(fields[2], "cast(IntPrimitive, byte)")
.WithExpression(fields[3], "cast(TheString, char)")
.WithExpression(fields[4], "cast(TheString, boolean)")
.WithExpression(fields[5], "cast(IntPrimitive, BigInteger)")
.WithExpression(fields[6], "cast(IntPrimitive, decimal)")
.WithExpression(fields[7], "cast(DoublePrimitive, decimal)")
.WithExpression(fields[8], "cast(TheString, char)");
builder.WithStatementConsumer(
stmt => {
AssertTypes(
stmt,
fields,
typeof(float?),
typeof(short?),
typeof(byte?),
typeof(char?),
typeof(bool?),
typeof(BigInteger?),
typeof(decimal?),
typeof(decimal?),
typeof(char?));
});
var bean = new SupportBean("true", 1);
bean.DoublePrimitive = 1;
builder.WithAssertion(bean).Expect(fields, 1.0f, (short)1, (byte)1, 't', true, new BigInteger(1), 1.0m, 1m, 't');
builder.Run(env);
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0,c1,c2".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportBean_ST0_Container");
builder.WithExpression(fields[0], "Contained.distinctOf(x => P00)");
builder.WithExpression(fields[1], "Contained.distinctOf( (x, i) => case when i<2 then P00 else -1*P00 end)");
builder.WithExpression(fields[2], "Contained.distinctOf( (x, i, s) => case when s<=2 then P00 else 0 end)");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(ICollection <object>)));
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,1", "E2,2", "E3,1"))
.Verify("c0", val => AssertST0Id(val, "E1,E2"))
.Verify("c1", val => AssertST0Id(val, "E1,E2,E3"))
.Verify("c2", val => AssertST0Id(val, "E1"));
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E3,1", "E2,2", "E4,1", "E1,2"))
.Verify("c0", val => AssertST0Id(val, "E3,E2"))
.Verify("c1", val => AssertST0Id(val, "E3,E2,E4,E1"))
.Verify("c2", val => AssertST0Id(val, "E3"));
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E3,1", "E2,2"))
.Verify("c0", val => AssertST0Id(val, "E3,E2"))
.Verify("c1", val => AssertST0Id(val, "E3,E2"))
.Verify("c2", val => AssertST0Id(val, "E3,E2"));
builder.WithAssertion(SupportBean_ST0_Container.Make2ValueNull())
.Verify("c0", val => AssertST0Id(val, null))
.Verify("c1", val => AssertST0Id(val, null))
.Verify("c2", val => AssertST0Id(val, null));
builder.WithAssertion(SupportBean_ST0_Container.Make2Value())
.Verify("c0", val => AssertST0Id(val, ""))
.Verify("c1", val => AssertST0Id(val, ""))
.Verify("c2", val => AssertST0Id(val, ""));
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
var fields = "eq,neq,sqlneq,nneq".SplitCsv();
var eplReference = new Atomic <string>();
var builder = new SupportEvalBuilder("SupportBean")
.WithExpression(fields[0], "IntPrimitive=any(1,IntBoxed)")
.WithExpression(fields[1], "IntPrimitive!=any(1,IntBoxed)")
.WithExpression(fields[2], "IntPrimitive<>any(1,IntBoxed)")
.WithExpression(fields[3], "not IntPrimitive=any(1,IntBoxed)")
.WithStatementConsumer(stmt => eplReference.Set(stmt.GetProperty(StatementProperty.EPL).ToString()));
// in the format IntPrimitive, IntBoxed
int[][] testdata =
{
new[] { 1, 1 },
new[] { 1, 2 },
new[] { 2, 2 },
new[] { 2, 1 },
};
object[][] result =
{
new object[] { true, false, false, false }, // 1, 1
new object[] { true, true, true, false }, // 1, 2
new object[] { true, true, true, false }, // 2, 2
new object[] { false, true, true, true } // 2, 1
};
for (var i = 0; i < testdata.Length; i++)
{
var bean = new SupportBean("E", testdata[i][0]);
bean.IntBoxed = testdata[i][1];
builder.WithAssertion(bean).Expect(fields, result[i]);
}
builder.Run(env);
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportCollection");
builder.WithExpression(fields[0], "Strvals.selectfrom(v => Int32.Parse(v)).arrayOf()");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(int?[])));
builder.WithAssertion(MakeString("1,2,3"))
.Verify(fields[0], val => AssertArrayEquals(new int?[] { 1, 2, 3 }, val));
builder.WithAssertion(MakeString("1"))
.Verify(fields[0], val => AssertArrayEquals(new int?[] { 1 }, val));
builder.WithAssertion(MakeString(""))
.Verify(fields[0], val => AssertArrayEquals(new int?[] { }, val));
builder.WithAssertion(MakeString(null))
.Verify(fields[0], Assert.IsNull);
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
string field = "c0";
SupportEvalBuilder builder = new SupportEvalBuilder("SupportCollection");
builder.WithExpression(field, "Strvals.selectFrom(v => extractNum(v))");
builder.WithStatementConsumer(stmt => AssertTypes(stmt.EventType, field, typeof(ICollection <object>)));
builder.WithAssertion(SupportCollection.MakeString("E2,E1,E5,E4"))
.Verify(field, value => AssertValuesArrayScalar(value, 2, 1, 5, 4));
builder.WithAssertion(SupportCollection.MakeString("E1"))
.Verify(field, value => AssertValuesArrayScalar(value, 1));
builder.WithAssertion(SupportCollection.MakeString(null))
.Verify(field, Assert.IsNull);
builder.WithAssertion(SupportCollection.MakeString(""))
.Verify(field, value => AssertValuesArrayScalar(value));
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportBean_ST0_Container");
builder.WithExpression(fields[0], "Contained.selectFrom(v => v.Id).arrayOf()");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(string[])));
builder.WithAssertion(Make2Value("E1,12", "E2,11", "E3,2"))
.Verify(fields[0], val => AssertArrayEquals(new[] { "E1", "E2", "E3" }, val));
builder.WithAssertion(Make2Value("E4,14"))
.Verify(fields[0], val => AssertArrayEquals(new[] { "E4" }, val));
builder.WithAssertion(Make2Value())
.Verify(fields[0], val => AssertArrayEquals(new string[0], val));
builder.WithAssertion(Make2ValueNull())
.Verify(fields[0], Assert.IsNull);
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportCollection");
builder.WithExpression(fields[0], "Strvals.selectfrom((v, i) => v || '-' || Convert.ToString(i)).arrayOf()");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(string[])));
builder.WithAssertion(MakeString("E1,E2,E3"))
.Verify(fields[0], val => AssertArrayEquals(new[] { "E1-0", "E2-1", "E3-2" }, val));
builder.WithAssertion(MakeString("E4"))
.Verify(fields[0], val => AssertArrayEquals(new[] { "E4-0" }, val));
builder.WithAssertion(MakeString(""))
.Verify(fields[0], val => AssertArrayEquals(new string[0], val));
builder.WithAssertion(MakeString(null))
.Verify(fields[0], Assert.IsNull);
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.average(v => extractNum(v))");
builder.WithExpression(fields[1], "Strvals.average(v => extractDecimal(v))");
builder.WithExpression(fields[2], "Strvals.average( (v, i) => extractNum(v) + i*10)");
builder.WithExpression(fields[3], "Strvals.average( (v, i) => extractDecimal(v) + i*10)");
builder.WithExpression(fields[4], "Strvals.average( (v, i, s) => extractNum(v) + i*10 + s*100)");
builder.WithExpression(fields[5], "Strvals.average( (v, i, s) => extractDecimal(v) + i*10 + s*100)");
builder.WithStatementConsumer(
stmt => AssertTypes(
stmt.EventType,
fields,
new[] { typeof(double?), typeof(decimal?), typeof(double?), typeof(decimal?), typeof(double?), typeof(decimal?) }));
builder.WithAssertion(SupportCollection.MakeString("E2,E1,E5,E4"))
.Expect(
fields,
(2 + 1 + 5 + 4) / 4d,
(2 + 1 + 5 + 4) / 4m,
(2 + 11 + 25 + 34) / 4d,
(2 + 11 + 25 + 34) / 4m,
(402 + 411 + 425 + 434) / 4d,
(402 + 411 + 425 + 434) / 4m);
builder.WithAssertion(SupportCollection.MakeString("E1"))
.Expect(fields, 1d, 1m, 1d, 1m, 101d, 101m);
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.Run(env);
}
public void Run(RegressionEnvironment env)
{
var fields = "c0,c1,c2,c3,c4".SplitCsv();
var builder = new SupportEvalBuilder("SupportBean_Container");
builder.WithExpression(fields[0], "Beans.sumOf(x => IntBoxed)");
builder.WithExpression(fields[1], "Beans.sumOf(x => DoubleBoxed)");
builder.WithExpression(fields[2], "Beans.sumOf(x => LongBoxed)");
builder.WithExpression(fields[3], "Beans.sumOf(x => DecimalBoxed)");
builder.WithExpression(fields[4], "Beans.sumOf(x => BigInteger)");
builder.WithStatementConsumer(
stmt => AssertTypes(
stmt.EventType,
fields,
new[] { typeof(int?), typeof(double?), typeof(long?), typeof(decimal?), typeof(BigInteger?) }));
builder.WithAssertion(new SupportBean_Container(null)).Expect(fields, null, null, null, null, null);
builder.WithAssertion(new SupportBean_Container(EmptyList <SupportBean> .Instance)).Expect(fields, null, null, null, null, null);
IList <SupportBean> listOne = new List <SupportBean>()
{
Make(2, 3d, 4L, 5, 6)
};
builder.WithAssertion(new SupportBean_Container(listOne)).Expect(fields, 2, 3d, 4L, 5m, new BigInteger(6));
IList <SupportBean> listTwo = new List <SupportBean>()
{
Make(2, 3d, 4L, 5, 6), Make(4, 6d, 8L, 10, 12)
};
builder.WithAssertion(new SupportBean_Container(listTwo)).Expect(fields, 2 + 4, 3d + 6d, 4L + 8L, 5m + 10m, new BigInteger(18));
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0,c1,c2,c3,c4,c5".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportCollection");
builder.WithExpression(fields[0], "Strvals.allof(v => v='A')");
builder.WithExpression(fields[1], "Strvals.anyof(v => v='A')");
builder.WithExpression(fields[2], "Strvals.allof((v, i) => (v='A' and i < 2) or (v='C' and i >= 2))");
builder.WithExpression(fields[3], "Strvals.anyof((v, i) => (v='A' and i < 2) or (v='C' and i >= 2))");
builder.WithExpression(fields[4], "Strvals.allof((v, i, s) => (v='A' and i < s - 2) or (v='C' and i >= s - 2))");
builder.WithExpression(fields[5], "Strvals.anyof((v, i, s) => (v='A' and i < s - 2) or (v='C' and i >= s - 2))");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(bool?)));
builder.WithAssertion(SupportCollection.MakeString("B,A,C"))
.Expect(fields, false, true, false, true, false, true);
builder.WithAssertion(SupportCollection.MakeString(null))
.Expect(fields, null, null, null, null, null, null);
builder.WithAssertion(SupportCollection.MakeString("A,A"))
.Expect(fields, true, true, true, true, false, false);
builder.WithAssertion(SupportCollection.MakeString("B"))
.Expect(fields, false, false, false, false, false, false);
builder.WithAssertion(SupportCollection.MakeString(""))
.Expect(fields, true, false, true, false, true, false);
builder.WithAssertion(SupportCollection.MakeString("B,B,B"))
.Expect(fields, false, false, false, false, false, false);
builder.WithAssertion(SupportCollection.MakeString("A,A,C,C"))
.Expect(fields, false, true, true, true, true, true);
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.allof(v => P00 = 7)");
builder.WithExpression(fields[1], "Contained.anyof(v => P00 = 7)");
builder.WithExpression(fields[2], "Contained.allof((v, i) => P00 = (7 + i*10))");
builder.WithExpression(fields[3], "Contained.anyof((v, i) => P00 = (7 + i*10))");
builder.WithExpression(fields[4], "Contained.allof((v, i, s) => P00 = (7 + i*10 + s*100))");
builder.WithExpression(fields[5], "Contained.anyof((v, i, s) => P00 = (7 + i*10 + s*100))");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(bool?)));
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,1", "E2,7", "E3,2"))
.Expect(fields, false, true, false, false, false, false);
builder.WithAssertion(SupportBean_ST0_Container.Make2ValueNull())
.Expect(fields, null, null, null, null, null, null);
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,7", "E2,7", "E3,7"))
.Expect(fields, true, true, false, true, false, false);
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,0", "E2,0", "E3,0"))
.Expect(fields, false, false, false, false, false, false);
builder.WithAssertion(SupportBean_ST0_Container.Make2Value())
.Expect(fields, true, false, true, false, true, false);
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,1", "E2,2", "E3,327"))
.Expect(fields, false, false, false, false, false, true);
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,307", "E2,317", "E3,327"))
.Expect(fields, false, false, false, false, true, true);
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.groupBy(c => Id)");
builder.WithExpression(fields[1], "Contained.groupBy((c, i) => Id || '_' || Convert.ToString(i))");
builder.WithExpression(fields[2], "Contained.groupBy((c, i, s) => Id || '_' || Convert.ToString(i) || '_' || Convert.ToString(s))");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(IDictionary <object, object>)));
EPAssertionUtil.AssertionCollectionValueString extractorEvents = collectionItem => {
int p00 = ((SupportBean_ST0)collectionItem).P00;
return(Convert.ToString(p00));
};
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,1", "E1,2", "E2,5"))
.Verify("c0", val => CompareMaps(val, "E1,E2", new[] { "1,2", "5" }, extractorEvents))
.Verify("c1", val => CompareMaps(val, "E1_0,E1_1,E2_2", new[] { "1", "2", "5" }, extractorEvents))
.Verify("c2", val => CompareMaps(val, "E1_0_3,E1_1_3,E2_2_3", new[] { "1", "2", "5" }, extractorEvents));
SupportEvalAssertionBuilder assertionNull = builder.WithAssertion(SupportBean_ST0_Container.Make2ValueNull());
foreach (string field in fields)
{
assertionNull.Verify(field, Assert.IsNull);
}
SupportEvalAssertionBuilder assertionEmpty = builder.WithAssertion(SupportBean_ST0_Container.Make2Value());
foreach (string field in fields)
{
assertionEmpty.Verify(field, val => CompareMaps(val, "", new string[0], extractorEvents));
}
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
string field = "c0";
SupportEvalBuilder builder = new SupportEvalBuilder("SupportBean_ST0_Container");
builder.WithExpression(field, "Contained.selectFrom(x => new {c0 = Id||'x', c1 = Key0||'y'})");
builder.WithStatementConsumer(stmt => AssertTypes(stmt.EventType, field, typeof(ICollection <object>)));
builder.WithAssertion(SupportBean_ST0_Container.Make3Value("E1,12,0", "E2,11,0", "E3,2,0"))
.Verify(
field,
value => AssertRows(
value,
new object[][] {
new object[] { "E1x", "12y" },
new object[] { "E2x", "11y" },
new object[] { "E3x", "2y" }
}));
builder.WithAssertion(SupportBean_ST0_Container.Make3Value("E4,0,1"))
.Verify(
field,
value => AssertRows(
value,
new object[][] {
new object[] { "E4x", "0y" }
}));
builder.WithAssertion(SupportBean_ST0_Container.Make3ValueNull())
.Verify(field, value => AssertRows(value, null));
builder.WithAssertion(SupportBean_ST0_Container.Make3Value())
.Verify(field, value => AssertRows(value, new object[0][]));
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0,c1,c2,c3,c4,c5".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportCollection");
builder.WithExpression(fields[0], "Strvals.mostFrequent(v => extractNum(v))");
builder.WithExpression(fields[1], "Strvals.leastFrequent(v => extractNum(v))");
builder.WithExpression(fields[2], "Strvals.mostFrequent( (v, i) => extractNum(v) + i*10)");
builder.WithExpression(fields[3], "Strvals.leastFrequent( (v, i) => extractNum(v) + i*10)");
builder.WithExpression(fields[4], "Strvals.mostFrequent( (v, i, s) => extractNum(v) + i*10 + s*100)");
builder.WithExpression(fields[5], "Strvals.leastFrequent( (v, i, s) => extractNum(v) + i*10 + s*100)");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(int?)));
builder.WithAssertion(SupportCollection.MakeString("E2,E1,E2,E1,E3,E3,E4,E3")).Expect(fields, 3, 4, 2, 2, 802, 802);
builder.WithAssertion(SupportCollection.MakeString("E1")).Expect(fields, 1, 1, 1, 1, 101, 101);
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.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.min(x => P00)");
builder.WithExpression(fields[1], "Contained.max(x => P00)");
builder.WithExpression(fields[2], "Contained.min( (x, i) => P00 + i*10)");
builder.WithExpression(fields[3], "Contained.max( (x, i) => P00 + i*10)");
builder.WithExpression(fields[4], "Contained.min( (x, i, s) => P00 + i*10 + s*100)");
builder.WithExpression(fields[5], "Contained.max( (x, i, s) => P00 + i*10 + s*100)");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(int?)));
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,12", "E2,11", "E2,2")).Expect(fields, 2, 12, 12, 22, 312, 322);
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,12", "E2,0", "E2,2")).Expect(fields, 0, 12, 10, 22, 310, 322);
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.groupBy(k => extractAfterUnderscore(k), v => v)");
builder.WithExpression(
fields[1],
"Strvals.groupBy((k, i) => extractAfterUnderscore(k) || '_' || Convert.ToString(i), (v, i) => v || '_' || Convert.ToString(i))");
builder.WithExpression(
fields[2],
"Strvals.groupBy((k, i, s) => extractAfterUnderscore(k) || '_' || Convert.ToString(i) || '_' || Convert.ToString(s), (v, i, s) => v || '_' || 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_0", "E2_1_1", "E3_2_2" }, GetExtractorScalar()))
.Verify("c2", val => CompareMaps(val, "2_0_3,1_1_3,2_2_3", new[] { "E1_2_0_3", "E2_1_1_3", "E3_2_2_3" }, 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)
{
string[] fields = "c0,c1,c2".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportCollection");
builder.WithExpression(fields[0], "Strvals.aggregate('', (result, item) => result || '+' || item)");
builder.WithExpression(fields[1], "Strvals.aggregate('', (result, item, i) => result || '+' || item || '_' || Convert.ToString(i))");
builder.WithExpression(
fields[2],
"Strvals.aggregate('', (result, item, i, s) => result || '+' || item || '_' || Convert.ToString(i) || '_' || Convert.ToString(s))");
builder.WithStatementConsumer(stmt => LambdaAssertionUtil.AssertTypesAllSame(stmt.EventType, fields, typeof(string)));
builder.WithAssertion(SupportCollection.MakeString("E1,E2,E3"))
.Expect(fields, "+E1+E2+E3", "+E1_0+E2_1+E3_2", "+E1_0_3+E2_1_3+E3_2_3");
builder.WithAssertion(SupportCollection.MakeString("E1")).Expect(fields, "+E1", "+E1_0", "+E1_0_1");
builder.WithAssertion(SupportCollection.MakeString("")).Expect(fields, "", "", "");
builder.WithAssertion(SupportCollection.MakeString(null)).Expect(fields, null, null, null);
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0,c1".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportBean_ST0_Container");
builder.WithExpression(fields[0], "Contained.firstOf()");
builder.WithExpression(fields[1], "Contained.lastOf()");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(SupportBean_ST0)));
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,1", "E3,9", "E2,9"))
.Verify("c0", value => AssertId(value, "E1"))
.Verify("c1", value => AssertId(value, "E2"));
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E2,2"))
.Verify("c0", value => AssertId(value, "E2"))
.Verify("c1", value => AssertId(value, "E2"));
builder.WithAssertion(SupportBean_ST0_Container.Make2ValueNull()).Expect(fields, null, null);
builder.WithAssertion(SupportBean_ST0_Container.Make2Value()).Expect(fields, null, null);
builder.Run(env);
}
public void Run(RegressionEnvironment env)
{
var fields = "c0".SplitCsv();
var builder = new SupportEvalBuilder("SupportBean")
.WithExpressions(fields, "coalesce(null, ByteBoxed, ShortBoxed, IntBoxed, LongBoxed, FloatBoxed, DoubleBoxed)")
.WithStatementConsumer(stmt => Assert.AreEqual(typeof(double?), stmt.EventType.GetPropertyType("c0")));
builder.WithAssertion(MakeEventWithDouble(env, null, null, null, null, null, null)).Expect(fields, new object[] { null });
builder.WithAssertion(MakeEventWithDouble(env, null, short.Parse("2"), null, null, null, 1d)).Expect(fields, 2d);
builder.WithAssertion(MakeEventWithDouble(env, null, null, null, null, null, 100d)).Expect(fields, 100d);
builder.WithAssertion(MakeEventWithDouble(env, null, null, null, null, 10f, 100d)).Expect(fields, 10d);
builder.WithAssertion(MakeEventWithDouble(env, null, null, 1, 5L, 10f, 100d)).Expect(fields, 1d);
builder.WithAssertion(MakeEventWithDouble(env, byte.Parse("3"), null, null, null, null, null)).Expect(fields, 3d);
builder.WithAssertion(MakeEventWithDouble(env, null, null, null, 5L, 10f, 100d)).Expect(fields, 5d);
builder.Run(env);
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
var fields = "myMax,myMaxEx,myMin,myMinEx".SplitCsv();
var builder = new SupportEvalBuilder("SupportBean")
.WithExpression(fields[0], "max(LongBoxed,IntBoxed)")
.WithExpression(fields[1], "max(LongBoxed,IntBoxed,ShortBoxed)")
.WithExpression(fields[2], "min(LongBoxed,IntBoxed)")
.WithExpression(fields[3], "min(LongBoxed,IntBoxed,ShortBoxed)");
builder.WithStatementConsumer(
stmt => {
var type = stmt.EventType;
Assert.AreEqual(typeof(long?), type.GetPropertyType("myMax"));
Assert.AreEqual(typeof(long?), type.GetPropertyType("myMin"));
Assert.AreEqual(typeof(long?), type.GetPropertyType("myMinEx"));
Assert.AreEqual(typeof(long?), type.GetPropertyType("myMaxEx"));
});
builder.WithAssertion(MakeBoxedEvent(10L, 20, 4)).Expect(fields, 20L, 20L, 10L, 4L);
builder.WithAssertion(MakeBoxedEvent(-10L, -20, -30)).Expect(fields, -10L, -10L, -20L, -30L);
builder.Run(env);
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.takeWhile(x => x.P00 > 0)");
builder.WithExpression(fields[1], "Contained.takeWhileLast(x => x.P00 > 0)");
builder.WithExpression(fields[2], "Contained.takeWhile( (x, i) => x.P00 > 0 and i<2)");
builder.WithExpression(fields[3], "Contained.takeWhileLast( (x, i) => x.P00 > 0 and i<2)");
builder.WithExpression(fields[4], "Contained.takeWhile( (x, i, s) => x.P00 > 0 and i<s-2)");
builder.WithExpression(fields[5], "Contained.takeWhileLast( (x, i,s) => x.P00 > 0 and i<s-2)");
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,E3"))
.Verify("c1", val => AssertST0Id(val, "E1,E2,E3"))
.Verify("c2", val => AssertST0Id(val, "E1,E2"))
.Verify("c3", val => AssertST0Id(val, "E2,E3"))
.Verify("c4", val => AssertST0Id(val, "E1"))
.Verify("c5", val => AssertST0Id(val, "E3"));
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,0", "E2,2", "E3,3"))
.Verify("c0", val => AssertST0Id(val, ""))
.Verify("c1", val => AssertST0Id(val, "E2,E3"))
.Verify("c2", val => AssertST0Id(val, ""))
.Verify("c3", val => AssertST0Id(val, "E2,E3"))
.Verify("c4", val => AssertST0Id(val, ""))
.Verify("c5", val => AssertST0Id(val, "E3"));
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,1", "E2,0", "E3,3"))
.Verify("c0", val => AssertST0Id(val, "E1"))
.Verify("c1", val => AssertST0Id(val, "E3"))
.Verify("c2", val => AssertST0Id(val, "E1"))
.Verify("c3", val => AssertST0Id(val, "E3"))
.Verify("c4", val => AssertST0Id(val, "E1"))
.Verify("c5", val => AssertST0Id(val, "E3"));
builder.WithAssertion(SupportBean_ST0_Container.Make2Value("E1,1", "E2,1", "E3,0"))
.Verify("c0", val => AssertST0Id(val, "E1,E2"))
.Verify("c1", val => AssertST0Id(val, ""))
.Verify("c2", val => AssertST0Id(val, "E1,E2"))
.Verify("c3", val => AssertST0Id(val, ""))
.Verify("c4", val => AssertST0Id(val, "E1"))
.Verify("c5", val => AssertST0Id(val, ""));
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, "E1"))
.Verify("c3", val => AssertST0Id(val, "E1"))
.Verify("c4", val => AssertST0Id(val, ""))
.Verify("c5", val => AssertST0Id(val, ""));
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);
}
