public void Run(RegressionEnvironment env)
{
var plainFilter = "@Name('s0') select count(*) as mycount from SupportBean";
tryCount(env, 2, 1000, plainFilter, GeneratorEnumerator.DEFAULT_SUPPORTEBEAN_CB);
tryCount(env, 4, 1000, plainFilter, GeneratorEnumerator.DEFAULT_SUPPORTEBEAN_CB);
ICollection <string> vals = Arrays.AsList("a", "b", "c", "d", "e", "f", "g", "h", "i", "j");
GeneratorEnumeratorCallback enumCallback = numEvent => {
var bean = new SupportCollection();
bean.Strvals = vals;
return(bean);
};
var enumFilter =
"@Name('s0') select count(*) as mycount from SupportCollection(Strvals.anyOf(v -> v = 'j'))";
tryCount(env, 4, 1000, enumFilter, enumCallback);
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0,c1".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportCollection");
builder.WithExpression(fields[0], "Strvals.mostFrequent()");
builder.WithExpression(fields[1], "Strvals.leastFrequent()");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(string)));
builder.WithAssertion(SupportCollection.MakeString("E2,E1,E2,E1,E3,E3,E4,E3")).Expect(fields, "E3", "E4");
builder.WithAssertion(SupportCollection.MakeString("E1")).Expect(fields, "E1", "E1");
builder.WithAssertion(SupportCollection.MakeString(null)).Expect(fields, null, null);
builder.WithAssertion(SupportCollection.MakeString("")).Expect(fields, null, null);
builder.Run(env);
}
public void TestParseSpecialAndMixedExprAndScript()
{
var listener = new SupportUpdateListener();
_epService.EPAdministrator.CreateEPL("create expression string jscript:myscript(p1) [return \"--\"+p1+\"--\"]");
_epService.EPAdministrator.CreateEPL("create expression myexpr {sb => '--'||TheString||'--'}");
// test mapped property syntax
var eplMapped = "select myscript('x') as c0, myexpr(sb) as c1 from SupportBean as sb";
var stmtMapped = _epService.EPAdministrator.CreateEPL(eplMapped);
stmtMapped.Events += listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), "c0,c1".Split(','), new Object[] { "--x--", "--E1--" });
stmtMapped.Dispose();
// test expression chained syntax
var eplExpr = "" +
"create expression scalarfilter {s => " +
" Strvals.where(y => y != 'E1') " +
"}";
_epService.EPAdministrator.CreateEPL(eplExpr);
var eplSelect = "select scalarfilter(t).where(x => x != 'E2') as val1 from SupportCollection as t";
_epService.EPAdministrator.CreateEPL(eplSelect).Events += listener.Update;
_epService.EPRuntime.SendEvent(SupportCollection.MakeString("E1,E2,E3,E4"));
LambdaAssertionUtil.AssertValuesArrayScalar(listener, "val1", "E3", "E4");
_epService.EPAdministrator.DestroyAllStatements();
listener.Reset();
// test script chained syntax
var beanType = typeof(SupportBean).FullName;
var eplScript = $"create expression {beanType} jscript:callIt() [ return host.newObj(host.resolveType('{beanType}'), 'E1', 10); ]";
_epService.EPAdministrator.CreateEPL(eplScript);
_epService.EPAdministrator.CreateEPL("select callIt() as val0, callIt().get_TheString() as val1 from SupportBean as sb").Events += listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean());
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), "val0.TheString,val0.IntPrimitive,val1".Split(','), new Object[] { "E1", 10, "E1" });
}
private void RunAssertionSetLogicWithScalar(EPServiceProvider epService)
{
string epl = "select " +
"Strvals.except(Strvalstwo) as val0," +
"Strvals.intersect(Strvalstwo) as val1, " +
"Strvals.union(Strvalstwo) as val2 " +
" from SupportCollection as bean";
EPStatement stmt = epService.EPAdministrator.CreateEPL(epl);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
LambdaAssertionUtil.AssertTypes(stmt.EventType, "val0".Split(','), new Type[] {
typeof(ICollection <string>)
});
epService.EPRuntime.SendEvent(SupportCollection.MakeString("E1,E2", "E3,E4"));
LambdaAssertionUtil.AssertValuesArrayScalar(listener, "val0", "E1", "E2");
LambdaAssertionUtil.AssertValuesArrayScalar(listener, "val1");
LambdaAssertionUtil.AssertValuesArrayScalar(listener, "val2", "E1", "E2", "E3", "E4");
listener.Reset();
epService.EPRuntime.SendEvent(SupportCollection.MakeString(null, "E3,E4"));
LambdaAssertionUtil.AssertValuesArrayScalar(listener, "val0", (object[])null);
LambdaAssertionUtil.AssertValuesArrayScalar(listener, "val1", (object[])null);
LambdaAssertionUtil.AssertValuesArrayScalar(listener, "val2", (object[])null);
listener.Reset();
epService.EPRuntime.SendEvent(SupportCollection.MakeString("", "E3,E4"));
LambdaAssertionUtil.AssertValuesArrayScalar(listener, "val0");
LambdaAssertionUtil.AssertValuesArrayScalar(listener, "val1");
LambdaAssertionUtil.AssertValuesArrayScalar(listener, "val2", "E3", "E4");
listener.Reset();
epService.EPRuntime.SendEvent(SupportCollection.MakeString("E1,E3,E5", "E3,E4"));
LambdaAssertionUtil.AssertValuesArrayScalar(listener, "val0", "E1", "E5");
LambdaAssertionUtil.AssertValuesArrayScalar(listener, "val1", "E3");
LambdaAssertionUtil.AssertValuesArrayScalar(listener, "val2", "E1", "E3", "E5", "E3", "E4");
listener.Reset();
stmt.Dispose();
}
public void TestWhereString()
{
String[] fields = "val0,val1".Split(',');
String eplFragment = "select " +
"Strvals.Where(x => x not like '%1%') as val0, " +
"Strvals.Where((x, i) => x not like '%1%' and i > 1) as val1 " +
"from SupportCollection";
EPStatement stmtFragment = _epService.EPAdministrator.CreateEPL(eplFragment);
stmtFragment.Events += _listener.Update;
LambdaAssertionUtil.AssertTypes(stmtFragment.EventType, fields, new Type[] { typeof(ICollection <object>), typeof(ICollection <object>) });
_epService.EPRuntime.SendEvent(SupportCollection.MakeString("E1,E2,E3"));
LambdaAssertionUtil.AssertValuesArrayScalar(_listener, "val0", "E2", "E3");
LambdaAssertionUtil.AssertValuesArrayScalar(_listener, "val1", "E3");
_listener.Reset();
_epService.EPRuntime.SendEvent(SupportCollection.MakeString("E4,E2,E1"));
LambdaAssertionUtil.AssertValuesArrayScalar(_listener, "val0", "E4", "E2");
LambdaAssertionUtil.AssertValuesArrayScalar(_listener, "val1", new String[0]);
_listener.Reset();
_epService.EPRuntime.SendEvent(SupportCollection.MakeString(""));
LambdaAssertionUtil.AssertValuesArrayScalar(_listener, "val0", new String[0]);
LambdaAssertionUtil.AssertValuesArrayScalar(_listener, "val1", new String[0]);
_listener.Reset();
stmtFragment.Dispose();
// test boolean
eplFragment = "select " +
"Boolvals.Where(x => x) as val0 " +
"from SupportCollection";
stmtFragment = _epService.EPAdministrator.CreateEPL(eplFragment);
stmtFragment.Events += _listener.Update;
LambdaAssertionUtil.AssertTypes(stmtFragment.EventType, "val0".Split(','), new Type[] { typeof(ICollection <object>) });
_epService.EPRuntime.SendEvent(SupportCollection.MakeBoolean("true,true,false"));
LambdaAssertionUtil.AssertValuesArrayScalar(_listener, "val0", true, true);
_listener.Reset();
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0,c1,c2,c3,c4,c5".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportCollection");
builder.WithExpression(fields[0], "Strvals.takeWhile(x => x != 'E1')");
builder.WithExpression(fields[1], "Strvals.takeWhileLast(x => x != 'E1')");
builder.WithExpression(fields[2], "Strvals.takeWhile( (x, i) => x != 'E1' and i<2)");
builder.WithExpression(fields[3], "Strvals.takeWhileLast( (x, i) => x != 'E1' and i<2)");
builder.WithExpression(fields[4], "Strvals.takeWhile( (x, i, s) => x != 'E1' and i<s-2)");
builder.WithExpression(fields[5], "Strvals.takeWhileLast( (x, i, s) => x != 'E1' and i<s-2)");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(ICollection <object>)));
builder.WithAssertion(SupportCollection.MakeString("E1,E2,E3,E4"))
.Verify("c0", val => AssertValuesArrayScalar(val))
.Verify("c1", val => AssertValuesArrayScalar(val, "E2", "E3", "E4"))
.Verify("c2", val => AssertValuesArrayScalar(val))
.Verify("c3", val => AssertValuesArrayScalar(val, "E3", "E4"))
.Verify("c4", val => AssertValuesArrayScalar(val))
.Verify("c5", val => AssertValuesArrayScalar(val, "E3", "E4"));
builder.WithAssertion(SupportCollection.MakeString("E2"))
.Verify("c0", val => AssertValuesArrayScalar(val, "E2"))
.Verify("c1", val => AssertValuesArrayScalar(val, "E2"))
.Verify("c2", val => AssertValuesArrayScalar(val, "E2"))
.Verify("c3", val => AssertValuesArrayScalar(val, "E2"))
.Verify("c4", val => AssertValuesArrayScalar(val))
.Verify("c5", val => AssertValuesArrayScalar(val));
builder.WithAssertion(SupportCollection.MakeString("E2,E3,E4,E5"))
.Verify("c0", val => AssertValuesArrayScalar(val, "E2", "E3", "E4", "E5"))
.Verify("c1", val => AssertValuesArrayScalar(val, "E2", "E3", "E4", "E5"))
.Verify("c2", val => AssertValuesArrayScalar(val, "E2", "E3"))
.Verify("c3", val => AssertValuesArrayScalar(val, "E4", "E5"))
.Verify("c4", val => AssertValuesArrayScalar(val, "E2", "E3"))
.Verify("c5", val => AssertValuesArrayScalar(val, "E4", "E5"));
builder.Run(env);
}
public void TestKeyValueSelector()
{
String eplFragment = "select contained.GroupBy(k => id, v => p00) as val from Bean";
EPStatement stmtFragment = _epService.EPAdministrator.CreateEPL(eplFragment);
stmtFragment.Events += _listener.Update;
EPAssertionUtil.AssertionCollectionValueString extractor = new EPAssertionUtil.ProxyAssertionCollectionValueString(
collectionItem => Convert.ToString((int)collectionItem));
_epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E1,1", "E1,2", "E2,5"));
EPAssertionUtil.AssertMapOfCollection(
(GroupMap)_listener.AssertOneGetNewAndReset().Get("val"),
new String[] { "E1", "E2" },
new String[] { "1,2", "5" },
extractor);
_epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value(null));
Assert.IsNull(_listener.AssertOneGetNewAndReset().Get("val"));
_epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value());
Assert.AreEqual(0, ((GroupMap)_listener.AssertOneGetNewAndReset().Get("val")).Count);
// test scalar
_epService.EPAdministrator.Configuration.AddPlugInSingleRowFunction("extractAfterUnderscore", this.GetType().FullName, "ExtractAfterUnderscore");
String eplScalar = "select Strvals.GroupBy(k => extractAfterUnderscore(k), v => v) as val from SupportCollection";
EPStatement stmtScalar = _epService.EPAdministrator.CreateEPL(eplScalar);
stmtScalar.Events += _listener.Update;
LambdaAssertionUtil.AssertTypes(stmtScalar.EventType, "val".Split(','), new Type[] { typeof(GroupMap) });
_epService.EPRuntime.SendEvent(SupportCollection.MakeString("E1_2,E2_1,E3_2"));
EPAssertionUtil.AssertMapOfCollection((GroupMap)_listener.AssertOneGetNewAndReset().Get("val"), "2,1".Split(','),
new String[] { "E1_2,E3_2", "E2_1" }, GetExtractorScalar());
_epService.EPRuntime.SendEvent(SupportCollection.MakeString(null));
Assert.IsNull(_listener.AssertOneGetNewAndReset().Get("val"));
_epService.EPRuntime.SendEvent(SupportCollection.MakeString(""));
Assert.AreEqual(0, ((GroupMap)_listener.AssertOneGetNewAndReset().Get("val")).Count);
}
public void TestDistinctScalar()
{
_epService.EPAdministrator.Configuration.AddPlugInSingleRowFunction("extractNum", typeof(TestEnumMinMax.MyService).FullName, "ExtractNum");
String[] fields = "val0,val1".Split(',');
String eplFragment = "select " +
"Strvals.distinctOf() as val0, " +
"Strvals.distinctOf(v => extractNum(v)) as val1 " +
"from SupportCollection";
EPStatement stmtFragment = _epService.EPAdministrator.CreateEPL(eplFragment);
stmtFragment.Events += _listener.Update;
LambdaAssertionUtil.AssertTypes(stmtFragment.EventType, fields, new Type[] { typeof(ICollection <object>), typeof(ICollection <object>) });
_epService.EPRuntime.SendEvent(SupportCollection.MakeString("E2,E1,E2,E2"));
LambdaAssertionUtil.AssertValuesArrayScalar(_listener, "val0", "E2", "E1");
LambdaAssertionUtil.AssertValuesArrayScalar(_listener, "val1", "E2", "E1");
_listener.Reset();
LambdaAssertionUtil.AssertSingleAndEmptySupportColl(_epService, _listener, fields);
stmtFragment.Dispose();
}
public void Run(RegressionEnvironment env)
{
string[] fields = "c0,c1,c2,c3".SplitCsv();
SupportEvalBuilder builder = new SupportEvalBuilder("SupportCollection");
builder.WithExpression(fields[0], "Strvals.countof()");
builder.WithExpression(fields[1], "Strvals.countof(x => x = 'E1')");
builder.WithExpression(fields[2], "Strvals.countof((x, i) => x = 'E1' and i >= 1)");
builder.WithExpression(fields[3], "Strvals.countof((x, i, s) => x = 'E1' and i >= 1 and s > 2)");
builder.WithStatementConsumer(stmt => AssertTypesAllSame(stmt.EventType, fields, typeof(int?)));
builder.WithAssertion(SupportCollection.MakeString("E1,E2")).Expect(fields, 2, 1, 0, 0);
builder.WithAssertion(SupportCollection.MakeString("E1,E2,E1,E3")).Expect(fields, 4, 2, 1, 1);
builder.WithAssertion(SupportCollection.MakeString("E1")).Expect(fields, 1, 1, 0, 0);
builder.WithAssertion(SupportCollection.MakeString("E1,E1")).Expect(fields, 2, 2, 1, 0);
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.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);
}
private void RunAssertionTakeScalar(EPServiceProvider epService)
{
string[] fields = "val0,val1,val2,val3".Split(',');
string epl = "select " +
"Strvals.take(2) as val0," +
"Strvals.take(1) as val1," +
"Strvals.takeLast(2) as val2," +
"Strvals.takeLast(1) as val3" +
" from SupportCollection";
EPStatement stmt = epService.EPAdministrator.CreateEPL(epl);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
LambdaAssertionUtil.AssertTypes(stmt.EventType, fields, new Type[] {
typeof(ICollection <string>),
typeof(ICollection <string>),
typeof(ICollection <string>),
typeof(ICollection <string>)
});
epService.EPRuntime.SendEvent(SupportCollection.MakeString("E1,E2,E3"));
LambdaAssertionUtil.AssertValuesArrayScalar(listener, "val0", "E1", "E2");
LambdaAssertionUtil.AssertValuesArrayScalar(listener, "val1", "E1");
LambdaAssertionUtil.AssertValuesArrayScalar(listener, "val2", "E2", "E3");
LambdaAssertionUtil.AssertValuesArrayScalar(listener, "val3", "E3");
listener.Reset();
epService.EPRuntime.SendEvent(SupportCollection.MakeString("E1,E2"));
LambdaAssertionUtil.AssertValuesArrayScalar(listener, "val0", "E1", "E2");
LambdaAssertionUtil.AssertValuesArrayScalar(listener, "val1", "E1");
LambdaAssertionUtil.AssertValuesArrayScalar(listener, "val2", "E1", "E2");
LambdaAssertionUtil.AssertValuesArrayScalar(listener, "val3", "E2");
listener.Reset();
LambdaAssertionUtil.AssertSingleAndEmptySupportColl(epService, listener, fields);
stmt.Dispose();
}
private void RunAssertionCountOfScalar(EPServiceProvider epService)
{
var fields = new string[] { "val0", "val1" };
string eplFragment = "select " +
"Strvals.countof() as val0, " +
"Strvals.countof(x => x = 'E1') as val1 " +
" from SupportCollection";
EPStatement stmtFragment = epService.EPAdministrator.CreateEPL(eplFragment);
var listener = new SupportUpdateListener();
stmtFragment.Events += listener.Update;
LambdaAssertionUtil.AssertTypes(stmtFragment.EventType, fields, new Type[] {
typeof(int), typeof(int)
});
epService.EPRuntime.SendEvent(SupportCollection.MakeString("E1,E2"));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { 2, 1 });
epService.EPRuntime.SendEvent(SupportCollection.MakeString("E1,E2,E1,E3"));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { 4, 2 });
stmtFragment.Dispose();
}
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 static void AssertSingleAndEmptySupportColl(EPServiceProvider epService, SupportUpdateListener listener, String[] fields)
{
epService.EPRuntime.SendEvent(SupportCollection.MakeString("E1"));
foreach (string field in fields)
{
LambdaAssertionUtil.AssertValuesArrayScalar(listener, field, "E1");
}
listener.Reset();
epService.EPRuntime.SendEvent(SupportCollection.MakeString(null));
foreach (string field in fields)
{
LambdaAssertionUtil.AssertValuesArrayScalar(listener, field, null);
}
listener.Reset();
epService.EPRuntime.SendEvent(SupportCollection.MakeString(""));
foreach (string field in fields)
{
LambdaAssertionUtil.AssertValuesArrayScalar(listener, field);
}
listener.Reset();
}
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)
{
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 TestTakeScalar()
{
String[] fields = "val0,val1,val2,val3".Split(',');
String epl = "select " +
"Strvals.Take(2) as val0," +
"Strvals.Take(1) as val1," +
"Strvals.TakeLast(2) as val2," +
"Strvals.TakeLast(1) as val3" +
" from SupportCollection";
EPStatement stmt = _epService.EPAdministrator.CreateEPL(epl);
stmt.Events += _listener.Update;
LambdaAssertionUtil.AssertTypes(stmt.EventType, fields, new Type[]
{
typeof(ICollection <string>),
typeof(ICollection <string>),
typeof(ICollection <string>),
typeof(ICollection <string>)
});
_epService.EPRuntime.SendEvent(SupportCollection.MakeString("E1,E2,E3"));
LambdaAssertionUtil.AssertValuesArrayScalar(_listener, "val0", "E1", "E2");
LambdaAssertionUtil.AssertValuesArrayScalar(_listener, "val1", "E1");
LambdaAssertionUtil.AssertValuesArrayScalar(_listener, "val2", "E2", "E3");
LambdaAssertionUtil.AssertValuesArrayScalar(_listener, "val3", "E3");
_listener.Reset();
_epService.EPRuntime.SendEvent(SupportCollection.MakeString("E1,E2"));
LambdaAssertionUtil.AssertValuesArrayScalar(_listener, "val0", "E1", "E2");
LambdaAssertionUtil.AssertValuesArrayScalar(_listener, "val1", "E1");
LambdaAssertionUtil.AssertValuesArrayScalar(_listener, "val2", "E1", "E2");
LambdaAssertionUtil.AssertValuesArrayScalar(_listener, "val3", "E2");
_listener.Reset();
LambdaAssertionUtil.AssertSingleAndEmptySupportColl(_epService, _listener, fields);
}
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 TestMinMaxScalar()
{
String[] fields = "val0,val1".Split(',');
String eplFragment = "select " +
"Strvals.min() as val0, " +
"Strvals.Max() as val1 " +
"from SupportCollection";
EPStatement stmtFragment = _epService.EPAdministrator.CreateEPL(eplFragment);
stmtFragment.Events += _listener.Update;
LambdaAssertionUtil.AssertTypes(stmtFragment.EventType, fields, new Type[] { typeof(string), typeof(string) });
_epService.EPRuntime.SendEvent(SupportCollection.MakeString("E2,E1,E5,E4"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "E1", "E5" });
_epService.EPRuntime.SendEvent(SupportCollection.MakeString("E1"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "E1", "E1" });
_epService.EPRuntime.SendEvent(SupportCollection.MakeString(null));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { null, null });
_epService.EPRuntime.SendEvent(SupportCollection.MakeString(""));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { null, null });
}
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 TestAggregateScalar()
{
String[] fields = "val0".Split(',');
String eplFragment = "select " +
"Strvals.Aggregate('', (result, item) => result || '+' || item) as val0 " +
"from SupportCollection";
EPStatement stmtFragment = _epService.EPAdministrator.CreateEPL(eplFragment);
stmtFragment.Events += _listener.Update;
LambdaAssertionUtil.AssertTypes(stmtFragment.EventType, fields, new Type[] { typeof(string) });
_epService.EPRuntime.SendEvent(SupportCollection.MakeString("E1,E2,E3"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "+E1+E2+E3" });
_epService.EPRuntime.SendEvent(SupportCollection.MakeString("E1"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "+E1" });
_epService.EPRuntime.SendEvent(SupportCollection.MakeString(""));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "" });
_epService.EPRuntime.SendEvent(SupportCollection.MakeString(null));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { null });
stmtFragment.Dispose();
}
private void RunAssertionSumOfScalar(EPServiceProvider epService)
{
string[] fields = "val0,val1".Split(',');
string eplFragment = "select " +
"Intvals.sumOf() as val0, " +
"Bdvals.sumOf() as val1 " +
"from SupportCollection";
EPStatement stmtFragment = epService.EPAdministrator.CreateEPL(eplFragment);
var listener = new SupportUpdateListener();
stmtFragment.Events += listener.Update;
LambdaAssertionUtil.AssertTypes(stmtFragment.EventType, fields, new Type[] {
typeof(int?), typeof(decimal?)
});
epService.EPRuntime.SendEvent(SupportCollection.MakeNumeric("1,4,5"));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { 1 + 4 + 5, 1m + 4m + 5m });
epService.EPRuntime.SendEvent(SupportCollection.MakeNumeric("3,4"));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { 3 + 4, 3m + 4m });
epService.EPRuntime.SendEvent(SupportCollection.MakeNumeric("3"));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { 3, 3m });
epService.EPRuntime.SendEvent(SupportCollection.MakeNumeric(""));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { null, null });
epService.EPRuntime.SendEvent(SupportCollection.MakeNumeric(null));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { null, null });
stmtFragment.Dispose();
// test average with lambda
epService.EPAdministrator.Configuration.AddPlugInSingleRowFunction("extractNum", typeof(ExecEnumMinMax.MyService), "ExtractNum");
epService.EPAdministrator.Configuration.AddPlugInSingleRowFunction("extractDecimal", typeof(ExecEnumMinMax.MyService), "ExtractDecimal");
// lambda with string-array input
string[] fieldsLambda = "val0,val1".Split(',');
string eplLambda = "select " +
"Strvals.sumOf(v => extractNum(v)) as val0, " +
"Strvals.sumOf(v => extractDecimal(v)) as val1 " +
"from SupportCollection";
EPStatement stmtLambda = epService.EPAdministrator.CreateEPL(eplLambda);
stmtLambda.Events += listener.Update;
LambdaAssertionUtil.AssertTypes(stmtLambda.EventType, fieldsLambda, new Type[] { typeof(int?), typeof(decimal?) });
epService.EPRuntime.SendEvent(SupportCollection.MakeString("E2,E1,E5,E4"));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fieldsLambda, new object[] { 2 + 1 + 5 + 4, 2m + 1m + 5m + 4m });
epService.EPRuntime.SendEvent(SupportCollection.MakeString("E1"));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fieldsLambda, new object[] { 1, 1m });
epService.EPRuntime.SendEvent(SupportCollection.MakeString(null));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fieldsLambda, new object[] { null, null });
epService.EPRuntime.SendEvent(SupportCollection.MakeString(""));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fieldsLambda, new object[] { null, null });
stmtLambda.Dispose();
}
public void TestMinMaxBy()
{
String[] fields = "val0,val1,val2,val3".SplitCsv();
String eplFragment = "select " +
"contained.MinBy(x => p00) as val0," +
"contained.MaxBy(x => p00) as val1," +
"contained.MinBy(x => p00).id as val2," +
"contained.MaxBy(x => p00).P00 as val3 " +
"from Bean";
EPStatement stmtFragment = _epService.EPAdministrator.CreateEPL(eplFragment);
stmtFragment.Events += _listener.Update;
LambdaAssertionUtil.AssertTypes(stmtFragment.EventType, fields, new Type[] { typeof(SupportBean_ST0), typeof(SupportBean_ST0), typeof(string), typeof(int?) });
SupportBean_ST0_Container bean = SupportBean_ST0_Container.Make2Value("E1,12", "E2,11", "E2,2");
_epService.EPRuntime.SendEvent(bean);
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields,
new Object[] { bean.Contained[2], bean.Contained[0], "E2", 12 });
bean = SupportBean_ST0_Container.Make2Value("E1,12");
_epService.EPRuntime.SendEvent(bean);
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields,
new Object[] { bean.Contained[0], bean.Contained[0], "E1", 12 });
_epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value(null));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields,
new Object[] { null, null, null, null });
_epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value());
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields,
new Object[] { null, null, null, null });
stmtFragment.Dispose();
// test scalar-coll with lambda
String[] fieldsLambda = "val0,val1".Split(',');
_epService.EPAdministrator.Configuration.AddPlugInSingleRowFunction("extractNum", typeof(TestEnumMinMax.MyService).FullName, "ExtractNum");
String eplLambda = "select " +
"Strvals.minBy(v => extractNum(v)) as val0, " +
"Strvals.maxBy(v => extractNum(v)) as val1 " +
"from SupportCollection";
EPStatement stmtLambda = _epService.EPAdministrator.CreateEPL(eplLambda);
stmtLambda.Events += _listener.Update;
LambdaAssertionUtil.AssertTypes(stmtLambda.EventType, fieldsLambda, new [] { typeof(string), typeof(string) });
_epService.EPRuntime.SendEvent(SupportCollection.MakeString("E2,E1,E5,E4"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsLambda, new Object[] { "E1", "E5" });
_epService.EPRuntime.SendEvent(SupportCollection.MakeString("E1"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsLambda, new Object[] { "E1", "E1" });
_listener.Reset();
_epService.EPRuntime.SendEvent(SupportCollection.MakeString(null));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsLambda, new Object[] { null, null });
_listener.Reset();
_epService.EPRuntime.SendEvent(SupportCollection.MakeString(""));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsLambda, new Object[] { null, null });
}
