private void RunAssertionSchemaCopyProperties(EventRepresentationEnum eventRepresentationEnum)
{
_epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema BaseOne (prop1 String, prop2 int)");
_epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema BaseTwo (prop3 long)");
// test define and send
_epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema E1 () copyfrom BaseOne");
EPStatement stmtOne = _epService.EPAdministrator.CreateEPL("select * from E1");
stmtOne.Events += _listener.Update;
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), stmtOne.EventType.UnderlyingType);
Assert.AreEqual(typeof(string), stmtOne.EventType.GetPropertyType("prop1"));
Assert.AreEqual(typeof(int), stmtOne.EventType.GetPropertyType("prop2"));
IDictionary <String, Object> eventE1 = new LinkedHashMap <String, Object>();
eventE1.Put("prop1", "v1");
eventE1.Put("prop2", 2);
if (eventRepresentationEnum.IsObjectArrayEvent())
{
_epService.EPRuntime.SendEvent(eventE1.Values.ToArray(), "E1");
}
else
{
_epService.EPRuntime.SendEvent(eventE1, "E1");
}
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), "prop1,prop2".Split(','), new Object[] { "v1", 2 });
// test two copy-from types
_epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema E2 () copyfrom BaseOne, BaseTwo");
EPStatement stmtTwo = _epService.EPAdministrator.CreateEPL("select * from E2");
Assert.AreEqual(typeof(string), stmtTwo.EventType.GetPropertyType("prop1"));
Assert.AreEqual(typeof(int), stmtTwo.EventType.GetPropertyType("prop2"));
Assert.AreEqual(typeof(long), stmtTwo.EventType.GetPropertyType("prop3"));
// test API-defined type
IDictionary <String, Object> def = new Dictionary <String, Object>();
def.Put("a", "string");
def.Put("b", typeof(String));
def.Put("c", "BaseOne");
def.Put("d", "BaseTwo[]");
_epService.EPAdministrator.Configuration.AddEventType("MyType", def);
_epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema E3(e long, f BaseOne) copyfrom MyType");
EPStatement stmtThree = _epService.EPAdministrator.CreateEPL("select * from E3");
Assert.AreEqual(typeof(String), stmtThree.EventType.GetPropertyType("a"));
Assert.AreEqual(typeof(String), stmtThree.EventType.GetPropertyType("b"));
if (eventRepresentationEnum.IsObjectArrayEvent())
{
Assert.AreEqual(typeof(Object[]), stmtThree.EventType.GetPropertyType("c"));
Assert.AreEqual(typeof(Object[][]), stmtThree.EventType.GetPropertyType("d"));
Assert.AreEqual(typeof(Object[]), stmtThree.EventType.GetPropertyType("f"));
}
else
{
Assert.AreEqual(typeof(DataMap), stmtThree.EventType.GetPropertyType("c"));
Assert.AreEqual(typeof(DataMap[]), stmtThree.EventType.GetPropertyType("d"));
Assert.AreEqual(typeof(DataMap), stmtThree.EventType.GetPropertyType("f"));
}
Assert.AreEqual(typeof(long), stmtThree.EventType.GetPropertyType("e"));
// invalid tests
TryInvalid(eventRepresentationEnum.GetAnnotationText() + " create schema E4(a long) copyFrom MyType",
"Error starting statement: Type by name 'MyType' contributes property 'a' defined as 'System.String' which overides the same property of type '" + typeof(long).FullName + "' [");
TryInvalid(eventRepresentationEnum.GetAnnotationText() + " create schema E4(c BaseTwo) copyFrom MyType",
"Error starting statement: Property by name 'c' is defined twice by adding type 'MyType' [");
TryInvalid(eventRepresentationEnum.GetAnnotationText() + " create schema E4(c BaseTwo) copyFrom XYZ",
"Error starting statement: Type by name 'XYZ' could not be located [");
TryInvalid(eventRepresentationEnum.GetAnnotationText() + " create schema E4 as " + typeof(SupportBean).FullName + " copyFrom XYZ",
"Error starting statement: Copy-from types are not allowed with class-provided types [");
TryInvalid(eventRepresentationEnum.GetAnnotationText() + " create variant schema E4(c BaseTwo) copyFrom XYZ",
"Error starting statement: Copy-from types are not allowed with variant types [");
// test SODA
String createEPL = eventRepresentationEnum.GetAnnotationText() + " create schema EX as () copyFrom BaseOne, BaseTwo";
EPStatementObjectModel model = _epService.EPAdministrator.CompileEPL(createEPL);
Assert.AreEqual(createEPL.Trim(), model.ToEPL());
EPStatement stmt = _epService.EPAdministrator.Create(model);
Assert.AreEqual(createEPL.Trim(), stmt.Text);
_epService.Initialize();
}
public void TestPatternUnidirectionalOuterJoinNoOn()
{
// test 2-stream left outer join and SODA
//
_epService.EPAdministrator.Configuration.AddEventType("SupportBean", typeof(SupportBean));
_epService.EPAdministrator.Configuration.AddEventType("SupportBean_S0", typeof(SupportBean_S0));
_epService.EPAdministrator.Configuration.AddEventType("SupportBean_S1", typeof(SupportBean_S1));
_epService.EPRuntime.SendEvent(new CurrentTimeEvent(1000));
String stmtTextLO = "select sum(IntPrimitive) as c0, count(*) as c1 " +
"from pattern [every timer:interval(1 seconds)] unidirectional " +
"left outer join " +
"SupportBean.win:keepall()";
EPStatement stmtLO = _epService.EPAdministrator.CreateEPL(stmtTextLO);
stmtLO.Events += _listener.Update;
RunAssertionPatternUniOuterJoinNoOn(0);
stmtLO.Dispose();
EPStatementObjectModel model = _epService.EPAdministrator.CompileEPL(stmtTextLO);
Assert.AreEqual(stmtTextLO, model.ToEPL());
stmtLO = _epService.EPAdministrator.Create(model);
Assert.AreEqual(stmtTextLO, stmtLO.Text);
stmtLO.Events += _listener.Update;
RunAssertionPatternUniOuterJoinNoOn(100000);
stmtLO.Dispose();
// test 2-stream inner join
//
String[] fieldsIJ = "c0,c1".Split(',');
String stmtTextIJ = "select sum(IntPrimitive) as c0, count(*) as c1 " +
"from SupportBean_S0 unidirectional " +
"inner join " +
"SupportBean.win:keepall()";
EPStatement stmtIJ = _epService.EPAdministrator.CreateEPL(stmtTextIJ);
stmtIJ.Events += _listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean_S0(1, "S0_1"));
_epService.EPRuntime.SendEvent(new SupportBean("E1", 100));
Assert.IsFalse(_listener.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportBean_S0(2, "S0_2"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsIJ, new Object[] { 100, 1L });
_epService.EPRuntime.SendEvent(new SupportBean("E2", 200));
_epService.EPRuntime.SendEvent(new SupportBean_S0(3, "S0_3"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsIJ, new Object[] { 300, 2L });
stmtIJ.Dispose();
// test 2-stream inner join with group-by
RunAssertion2StreamInnerWGroupBy();
// test 3-stream inner join
//
String[] fields3IJ = "c0,c1".Split(',');
String stmtText3IJ = "select sum(IntPrimitive) as c0, count(*) as c1 " +
"from " +
"SupportBean_S0.win:keepall()" +
"inner join " +
"SupportBean_S1.win:keepall()" +
"inner join " +
"SupportBean.win:keepall()";
EPStatement stmt3IJ = _epService.EPAdministrator.CreateEPL(stmtText3IJ);
stmt3IJ.Events += _listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean_S0(1, "S0_1"));
_epService.EPRuntime.SendEvent(new SupportBean("E1", 50));
Assert.IsFalse(_listener.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportBean_S1(10, "S1_1"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields3IJ, new Object[] { 50, 1L });
_epService.EPRuntime.SendEvent(new SupportBean("E2", 51));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields3IJ, new Object[] { 101, 2L });
stmt3IJ.Dispose();
// test 3-stream full outer join
//
String[] fields3FOJ = "P00,P10,TheString".Split(',');
String stmtText3FOJ = "select P00, P10, TheString " +
"from " +
"SupportBean_S0.win:keepall()" +
"full outer join " +
"SupportBean_S1.win:keepall()" +
"full outer join " +
"SupportBean.win:keepall()";
EPStatement stmt3FOJ = _epService.EPAdministrator.CreateEPL(stmtText3FOJ);
stmt3FOJ.Events += _listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean_S0(1, "S0_1"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields3FOJ, new Object[] { "S0_1", null, null });
_epService.EPRuntime.SendEvent(new SupportBean("E10", 0));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields3FOJ, new Object[] { null, null, "E10" });
_epService.EPRuntime.SendEvent(new SupportBean_S0(2, "S0_2"));
EPAssertionUtil.AssertPropsPerRow(_listener.GetAndResetLastNewData(), fields3FOJ, new Object[][] { new Object[] { "S0_2", null, null } });
_epService.EPRuntime.SendEvent(new SupportBean_S1(1, "S1_0"));
EPAssertionUtil.AssertPropsPerRowAnyOrder(_listener.GetAndResetLastNewData(), fields3FOJ, new Object[][] { new Object[] { "S0_1", "S1_0", "E10" }, new Object[] { "S0_2", "S1_0", "E10" } });
_epService.EPRuntime.SendEvent(new SupportBean_S0(2, "S0_3"));
EPAssertionUtil.AssertPropsPerRow(_listener.GetAndResetLastNewData(), fields3FOJ, new Object[][] { new Object[] { "S0_3", "S1_0", "E10" } });
_epService.EPRuntime.SendEvent(new SupportBean("E11", 0));
EPAssertionUtil.AssertPropsPerRowAnyOrder(_listener.GetAndResetLastNewData(), fields3FOJ, new Object[][] { new Object[] { "S0_1", "S1_0", "E11" }, new Object[] { "S0_2", "S1_0", "E11" }, new Object[] { "S0_3", "S1_0", "E11" } });
Assert.AreEqual(6, EPAssertionUtil.EnumeratorCount(stmt3FOJ.GetEnumerator()));
stmt3FOJ.Dispose();
// test 3-stream full outer join with where-clause
//
String[] fields3FOJW = "P00,P10,TheString".Split(',');
String stmtText3FOJW = "select P00, P10, TheString " +
"from " +
"SupportBean_S0.win:keepall() as s0 " +
"full outer join " +
"SupportBean_S1.win:keepall() as s1 " +
"full outer join " +
"SupportBean.win:keepall() as sb " +
"where s0.P00 = s1.P10";
EPStatement stmt3FOJW = _epService.EPAdministrator.CreateEPL(stmtText3FOJW);
stmt3FOJW.Events += _listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean_S0(1, "X1"));
Assert.IsFalse(_listener.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportBean_S1(1, "Y1"));
Assert.IsFalse(_listener.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportBean_S0(1, "Y1"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields3FOJW, new Object[] { "Y1", "Y1", null });
}
public void TestStartTurnedOff()
{
SendTimeEvent("2002-05-01 08:00:00.000");
String contextEPL = "@Name('context') create context NineToFive as start (0, 9, *, *, *) end (0, 17, *, *, *)";
EPStatement stmtContext = _epService.EPAdministrator.CreateEPL("@Name('context') create context NineToFive as start (0, 9, *, *, *) end (0, 17, *, *, *)");
AssertContextEventType(stmtContext.EventType);
SupportUpdateListener contextListener = new SupportUpdateListener();
stmtContext.Events += contextListener.Update;
stmtContext.Subscriber = new MiniSubscriber();
EPStatement stmtOne = _epService.EPAdministrator.CreateEPL("@Name('A') context NineToFive " +
"select * from SupportBean");
stmtOne.Events += new SupportUpdateListener().Update;
SendTimeAndAssert("2002-05-01 08:59:30.000", false, 1);
SendTimeAndAssert("2002-05-01 08:59:59.999", false, 1);
SendTimeAndAssert("2002-05-01 09:00:00.000", true, 1);
EPStatement stmtTwo = _epService.EPAdministrator.CreateEPL("@Name('B') context NineToFive select * from SupportBean");
stmtTwo.Events += new SupportUpdateListener().Update;
SendTimeAndAssert("2002-05-01 16:59:59.000", true, 2);
SendTimeAndAssert("2002-05-01 17:00:00.000", false, 2);
EPStatement stmtThree = _epService.EPAdministrator.CreateEPL("@Name('C') context NineToFive select * from SupportBean");
stmtThree.Events += new SupportUpdateListener().Update;
SendTimeAndAssert("2002-05-02 08:59:59.999", false, 3);
SendTimeAndAssert("2002-05-02 09:00:00.000", true, 3);
SendTimeAndAssert("2002-05-02 16:59:59.000", true, 3);
SendTimeAndAssert("2002-05-02 17:00:00.000", false, 3);
Assert.IsFalse(contextListener.IsInvoked);
_epService.EPAdministrator.DestroyAllStatements();
// test SODA
SendTimeEvent("2002-05-03 16:59:59.000");
EPStatementObjectModel model = _epService.EPAdministrator.CompileEPL(contextEPL);
Assert.AreEqual(contextEPL, model.ToEPL());
EPStatement stmt = _epService.EPAdministrator.Create(model);
Assert.AreEqual(contextEPL, stmt.Text);
// test built-in properties
EPStatement stmtLast = _epService.EPAdministrator.CreateEPL("@Name('A') context NineToFive " +
"select context.name as c1, context.startTime as c2, context.endTime as c3, TheString as c4 from SupportBean");
SupportUpdateListener listener = new SupportUpdateListener();
stmtLast.Events += listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean("E1", 10));
EventBean theEvent = listener.AssertOneGetNewAndReset();
Assert.AreEqual("NineToFive", theEvent.Get("c1"));
Assert.AreEqual("2002-05-03 16:59:59.000", theEvent.Get("c2").AsLong().Print());
Assert.AreEqual("2002-05-03 17:00:00.000", theEvent.Get("c3").AsLong().Print());
Assert.AreEqual("E1", theEvent.Get("c4"));
}
public void TestOp()
{
EventCollection events = EventCollectionFactory.GetEventSetOne(0, 1000);
CaseList testCaseList = new CaseList();
EventExpressionCase testCase;
// The wait is done when 2 seconds passed
testCase = new EventExpressionCase("timer:interval(1999 msec)");
testCase.Add("B1");
testCaseList.AddTest(testCase);
String text = "select * from pattern [timer:interval(1.999)]";
EPStatementObjectModel model = new EPStatementObjectModel();
model.SelectClause = SelectClause.CreateWildcard();
PatternExpr pattern = Patterns.TimerInterval(1.999d);
model.FromClause = FromClause.Create(PatternStream.Create(pattern));
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
Assert.AreEqual(text, model.ToEPL());
testCase = new EventExpressionCase(model);
testCase.Add("B1");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:interval(2 sec)");
testCase.Add("B1");
testCaseList.AddTest(testCase);
// 3 seconds (>2001 microseconds) passed
testCase = new EventExpressionCase("timer:interval(2.001)");
testCase.Add("C1");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:interval(2999 milliseconds)");
testCase.Add("C1");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:interval(3 seconds)");
testCase.Add("C1");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:interval(3.001 seconds)");
testCase.Add("B2");
testCaseList.AddTest(testCase);
// Try with an all ... repeated timer every 3 seconds
testCase = new EventExpressionCase("every timer:interval(3.001 sec)");
testCase.Add("B2");
testCase.Add("F1");
testCase.Add("D3");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every timer:interval(5000 msec)");
testCase.Add("A2");
testCase.Add("B3");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:interval(3.999 second) -> b=" + EVENT_B_CLASS);
testCase.Add("B2", "b", events.GetEvent("B2"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:interval(4 sec) -> b=" + EVENT_B_CLASS);
testCase.Add("B2", "b", events.GetEvent("B2"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:interval(4.001 sec) -> b=" + EVENT_B_CLASS);
testCase.Add("B3", "b", events.GetEvent("B3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:interval(0) -> b=" + EVENT_B_CLASS);
testCase.Add("B1", "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
// Try with an followed-by as a second argument
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + " -> timer:interval(0.001)");
testCase.Add("C1", "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + " -> timer:interval(0)");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + " -> timer:interval(1 sec)");
testCase.Add("C1", "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + " -> timer:interval(1.001)");
testCase.Add("B2", "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
// Try in a 3-way followed by
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + "() -> timer:interval(6.000) -> d=" + EVENT_D_CLASS);
testCase.Add("D2", "b", events.GetEvent("B1"), "d", events.GetEvent("D2"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every (b=" + EVENT_B_CLASS + "() -> timer:interval(2.001) -> d=" + EVENT_D_CLASS + "())");
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every (b=" + EVENT_B_CLASS + "() -> timer:interval(2.000) -> d=" + EVENT_D_CLASS + "())");
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCase.Add("D3", "b", events.GetEvent("B3"), "d", events.GetEvent("D3"));
testCaseList.AddTest(testCase);
// Try with an "or"
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + "() or timer:interval(1.001)");
testCase.Add("B1");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + "() or timer:interval(2.001)");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + "(Id='B3') or timer:interval(8.500)");
testCase.Add("D2");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:interval(8.500) or timer:interval(7.500)");
testCase.Add("F1");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:interval(999999 msec) or g=" + EVENT_G_CLASS);
testCase.Add("G1", "g", events.GetEvent("G1"));
testCaseList.AddTest(testCase);
// Try with an "and"
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + "() and timer:interval(4000 msec)");
testCase.Add("B2", "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + "() and timer:interval(4001 msec)");
testCase.Add("A2", "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:interval(9999999 msec) and b=" + EVENT_B_CLASS);
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:interval(1 msec) and b=" + EVENT_B_CLASS + "(Id=\"B2\")");
testCase.Add("B2", "b", events.GetEvent("B2"));
testCaseList.AddTest(testCase);
// Try with an "within"
testCase = new EventExpressionCase("timer:interval(3.000) where timer:within(2.000)");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:interval(3.000) where timer:within (3.000)");
testCaseList.AddTest(testCase);
// Run all tests
PatternTestHarness util = new PatternTestHarness(events, testCaseList, GetType(), GetType().FullName);
util.RunTest();
}
public void TestDistinctOverlappingMultiKey()
{
String epl = "create context MyContext as " +
"initiated by distinct(TheString, IntPrimitive) SupportBean as sb " +
"terminated SupportBean_S1"; // any S1 ends the contexts
EPStatementObjectModel model = _epService.EPAdministrator.CompileEPL(epl);
Assert.AreEqual(epl, model.ToEPL());
EPStatement stmtContext = _epService.EPAdministrator.Create(model);
Assert.AreEqual(stmtContext.Text, model.ToEPL());
String[] fields = "id,p00,p01,cnt".Split(',');
EPStatement stmt = _epService.EPAdministrator.CreateEPL(
"context MyContext " +
"select id, p00, p01, count(*) as cnt " +
"from SupportBean_S0(id = context.sb.IntPrimitive and p00 = context.sb.TheString)");
stmt.Events += _listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean_S0(1, "A"));
_epService.EPRuntime.SendEvent(new SupportBean("A", 1));
Assert.IsFalse(_listener.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportBean_S0(1, "A", "E1"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { 1, "A", "E1", 1L });
_epService.EPRuntime.SendEvent(new SupportBean_S0(1, "A", "E2"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { 1, "A", "E2", 2L });
_epService.EPRuntime.SendEvent(new SupportBean_S1(-1)); // terminate all
_epService.EPRuntime.SendEvent(new SupportBean_S0(1, "A", "E3"));
_epService.EPRuntime.SendEvent(new SupportBean("A", 1));
_epService.EPRuntime.SendEvent(new SupportBean("B", 2));
_epService.EPRuntime.SendEvent(new SupportBean("B", 1));
Assert.IsFalse(_listener.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportBean_S0(1, "A", "E4"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { 1, "A", "E4", 1L });
_epService.EPRuntime.SendEvent(new SupportBean_S0(2, "B", "E5"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { 2, "B", "E5", 1L });
_epService.EPRuntime.SendEvent(new SupportBean_S0(1, "B", "E6"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { 1, "B", "E6", 1L });
_epService.EPRuntime.SendEvent(new SupportBean_S0(2, "B", "E7"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { 2, "B", "E7", 2L });
_epService.EPRuntime.SendEvent(new SupportBean_S1(-1)); // terminate all
_epService.EPRuntime.SendEvent(new SupportBean_S0(2, "B", "E8"));
_epService.EPRuntime.SendEvent(new SupportBean("B", 2));
Assert.IsFalse(_listener.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportBean_S0(2, "B", "E9"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { 2, "B", "E9", 1L });
_epService.EPRuntime.SendEvent(new SupportBean_S0(2, "B", "E10"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { 2, "B", "E10", 2L });
// destroy context partition, should forget about the distinct key
GetSpi(_epService).DestroyContextPartitions("MyContext", new ContextPartitionSelectorAll());
_epService.EPRuntime.SendEvent(new SupportBean_S0(2, "B", "E11"));
_epService.EPRuntime.SendEvent(new SupportBean("B", 2));
Assert.IsFalse(_listener.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportBean_S0(2, "B", "E12"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { 2, "B", "E12", 1L });
}
public void TestOp()
{
var dateTime = MakeDateTime(2005, 3, 9, 8, 0, 0, 0);
var startTime = dateTime.TimeInMillis();
// Start a 2004-12-09 8:00:00am and send events every 10 minutes
// "A1" 8:10
// "B1" 8:20
// "C1" 8:30
// "B2" 8:40
// "A2" 8:50
// "D1" 9:00
// "E1" 9:10
// "F1" 9:20
// "D2" 9:30
// "B3" 9:40
// "G1" 9:50
// "D3" 10:00
var testData = EventCollectionFactory.GetEventSetOne(startTime, 1000 * 60 * 10);
var testCaseList = new CaseList();
EventExpressionCase testCase = null;
testCase = new EventExpressionCase("timer:at(10, 8, *, *, *)");
testCase.Add("A1");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:at(10, 8, *, *, *, 1)");
testCase.Add("B1");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:at(5, 8, *, *, *)");
testCase.Add("A1");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:at(10, 8, *, *, *, *)");
testCase.Add("A1");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:at(25, 9, *, *, *)");
testCase.Add("D2");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:at(11, 8, *, *, *)");
testCase.Add("B1");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:at(19, 8, *, *, *, 59)");
testCase.Add("B1");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every timer:at(* / 5, *, *, *, *, *)");
AddAll(testCase);
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every timer:at(*, *, *, *, *, * / 10)");
AddAll(testCase);
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:at(20, 8, *, *, *, 20)");
testCase.Add("C1");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every timer:at(*, *, *, *, *)");
AddAll(testCase);
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every timer:at(*, *, *, *, *, *)");
AddAll(testCase);
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every timer:at(* / 9, *, *, *, *, *)");
AddAll(testCase);
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every timer:at(* / 10, *, *, *, *, *)");
AddAll(testCase);
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every timer:at(* / 30, *, *, *, *)");
testCase.Add("C1");
testCase.Add("D1");
testCase.Add("D2");
testCase.Add("D3");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:at(10, 9, *, *, *, 10) or timer:at(30, 9, *, *, *, *)");
testCase.Add("F1");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + "(id='B3') -> timer:at(20, 9, *, *, *, *)");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + "(id='B3') -> timer:at(45, 9, *, *, *, *)");
testCase.Add("G1", "b", testData.GetEvent("B3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:at(59, 8, *, *, *, 59) -> d=" + EVENT_D_CLASS);
testCase.Add("D1", "d", testData.GetEvent("D1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:at(*, 9, *, *, *, 59) -> d=" + EVENT_D_CLASS);
testCase.Add("D2", "d", testData.GetEvent("D2"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:at(22, 8, *, *, *) -> b=" + EVENT_B_CLASS + "(id='B3') -> timer:at(55, *, *, *, *)");
testCase.Add("D3", "b", testData.GetEvent("B3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:at(40, *, *, *, *, 1) and b=" + EVENT_B_CLASS);
testCase.Add("A2", "b", testData.GetEvent("B1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:at(40, 9, *, *, *, 1) or d=" + EVENT_D_CLASS + "(id=\"D3\")");
testCase.Add("G1");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:at(22, 8, *, *, *) -> b=" + EVENT_B_CLASS + "() -> timer:at(55, 8, *, *, *)");
testCase.Add("D1", "b", testData.GetEvent("B2"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:at(22, 8, *, *, *, 1) where timer:within(1 second)");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:at(22, 8, *, *, *, 1) where timer:within(31 minutes)");
testCase.Add("C1");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:at(*, 9, *, *, *) and timer:at(55, *, *, *, *)");
testCase.Add("D1");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:at(40, 8, *, *, *, 1) and b=" + EVENT_B_CLASS);
testCase.Add("A2", "b", testData.GetEvent("B1"));
testCaseList.AddTest(testCase);
const string text = "select * from pattern [timer:at(10,8,*,*,*,*)]";
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.CreateWildcard();
var pattern = Patterns.TimerAt(10, 8, null, null, null, null);
model.FromClause = FromClause.Create(PatternStream.Create(pattern));
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
Assert.AreEqual(text, model.ToEPL());
testCase = new EventExpressionCase(model);
testCase.Add("A1");
testCaseList.AddTest(testCase);
// As of release 1.6 this no longer updates listeners when the statement is started.
// The reason is that the dispatch view only gets attached after a pattern started,
// therefore ZeroDepthEventStream looses the event. There should be no use case requiring this:
//
// testCase = new EventExpressionCase("not timer:at(22, 8, *, *, *, 1)");
// testCase.Add(EventCollection.ON_START_EVENT_ID);
// testCaseList.AddTest(testCase);
// Run all tests
var util = new PatternTestHarness(testData, testCaseList, GetType(), GetType().FullName);
util.RunTest();
}
private PatternExpr GetPatternRootExpr(EPStatementObjectModel model)
{
PatternStream patternStrema = (PatternStream)model.FromClause.Streams[0];
return(patternStrema.Expression);
}
public EventExpressionCase(EPStatementObjectModel objectModel)
{
this.objectModel = objectModel;
this.expectedResults = new LinkedHashMap <String, LinkedList <EventDescriptor> >();
}
/// <summary>Ctor. </summary>
/// <param name="model">is the statement object model</param>
/// <param name="subParams">is the substitution parameter list</param>
/// <param name="optionalEPL">the EPL provided if any</param>
public EPPreparedStatementImpl(EPStatementObjectModel model, IList <SubstitutionParameterExpressionBase> subParams, String optionalEPL)
{
_model = model;
_subParams = subParams;
_optionalEPL = optionalEPL;
}
public EPStatement Create(EPStatementObjectModel sodaStatement, string statementName, object userobject)
{
return(Create(sodaStatement, statementName, userobject, null));
}
/// <summary>
/// Initializes a new instance of the <see cref="EsperQuery<T>"/> class.
/// </summary>
/// <param name="serviceProvider">The service provider.</param>
/// <param name="objectModel">The object model.</param>
public EsperQuery(EPServiceProvider serviceProvider, EPStatementObjectModel objectModel)
{
ServiceProvider = serviceProvider;
ObjectModel = objectModel;
}
public EPStatement CreateModelStatementId(EPStatementObjectModel sodaStatement, string statementName, object userobject, int statementId)
{
return(Create(sodaStatement, statementName, userobject, statementId));
}
public EPStatement Create(EPStatementObjectModel sodaStatement)
{
return(Create(sodaStatement, null));
}
private void RunAssertionColDefPlain(EventRepresentationEnum eventRepresentationEnum)
{
EPStatement stmtCreate = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema MyEventType as (col1 string, col2 int, sbean " + typeof(SupportBean).FullName + ", col3.col4 int)");
AssertTypeColDef(stmtCreate.EventType);
EPStatement stmtSelect = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " select * from MyEventType");
AssertTypeColDef(stmtSelect.EventType);
stmtSelect.Dispose();
stmtCreate.Dispose();
// destroy and create differently
stmtCreate = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema MyEventType as (col3 string, col4 int)");
Assert.AreEqual(typeof(int), stmtCreate.EventType.GetPropertyType("col4"));
Assert.AreEqual(2, stmtCreate.EventType.PropertyDescriptors.Count);
stmtCreate.Stop();
// destroy and create differently
stmtCreate = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " create schema MyEventType as (col5 string, col6 int)");
Assert.AreEqual(stmtCreate.EventType.UnderlyingType, eventRepresentationEnum.GetOutputClass());
Assert.AreEqual(typeof(int), stmtCreate.EventType.GetPropertyType("col6"));
Assert.AreEqual(2, stmtCreate.EventType.PropertyDescriptors.Count);
stmtSelect = _epService.EPAdministrator.CreateEPL(eventRepresentationEnum.GetAnnotationText() + " select * from MyEventType");
stmtSelect.Events += _listener.Update;
Assert.AreEqual(stmtSelect.EventType.UnderlyingType, eventRepresentationEnum.GetOutputClass());
// send event
IDictionary <String, Object> data = new LinkedHashMap <String, Object>();
data.Put("col5", "abc");
data.Put("col6", 1);
if (eventRepresentationEnum.IsObjectArrayEvent())
{
_epService.EPRuntime.SendEvent(data.Values.ToArray(), "MyEventType");
}
else
{
_epService.EPRuntime.SendEvent(data, "MyEventType");
}
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), "col5,col6".Split(','), new Object[] { "abc", 1 });
// assert type information
EventTypeSPI typeSPI = (EventTypeSPI)stmtSelect.EventType;
Assert.AreEqual(TypeClass.APPLICATION, typeSPI.Metadata.TypeClass);
Assert.AreEqual(typeSPI.Name, typeSPI.Metadata.PublicName);
Assert.IsTrue(typeSPI.Metadata.IsApplicationConfigured);
Assert.IsFalse(typeSPI.Metadata.IsApplicationPreConfigured);
Assert.IsFalse(typeSPI.Metadata.IsApplicationPreConfiguredStatic);
Assert.AreEqual(typeSPI.Name, typeSPI.Metadata.PrimaryName);
// test non-enum create-schema
String epl = "create" + eventRepresentationEnum.GetOutputTypeCreateSchemaName() + " schema MyEventTypeTwo as (col1 string, col2 int, sbean " + typeof(SupportBean).FullName + ", col3.col4 int)";
EPStatement stmtCreateTwo = _epService.EPAdministrator.CreateEPL(epl);
AssertTypeColDef(stmtCreateTwo.EventType);
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), stmtCreateTwo.EventType.UnderlyingType);
stmtCreateTwo.Dispose();
_epService.EPAdministrator.Configuration.RemoveEventType("MyEventTypeTwo", true);
EPStatementObjectModel model = _epService.EPAdministrator.CompileEPL(epl);
Assert.AreEqual(model.ToEPL(), epl);
stmtCreateTwo = _epService.EPAdministrator.Create(model);
AssertTypeColDef(stmtCreateTwo.EventType);
Assert.AreEqual(eventRepresentationEnum.GetOutputClass(), stmtCreateTwo.EventType.UnderlyingType);
_epService.Initialize();
}
private void AssertCompileSODA(EPServiceProvider epService, string epl)
{
EPStatementObjectModel model = epService.EPAdministrator.CompileEPL(epl);
Assert.AreEqual(epl, model.ToEPL());
}
public void TestOp()
{
var events = EventCollectionFactory.GetEventSetOne(0, 1000);
var testCaseList = new CaseList();
var testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + "(Id=\"B1\") where timer:withinmax(2 sec,100)");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + "(Id=\"B1\") where timer:withinmax(2001 msec,1)");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + "(Id=\"B1\") where timer:withinmax(1999 msec,10)");
testCaseList.AddTest(testCase);
var text = "select * from pattern [b=" + EVENT_B_CLASS + "(Id=\"B3\") where timer:withinmax(10.001,1)]";
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.CreateWildcard();
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
var filter = Expressions.Eq("Id", "B3");
var pattern = Patterns.TimerWithinMax(10.001, 1, Patterns.Filter(Filter.Create(EVENT_B_CLASS, filter), "b"));
model.FromClause = FromClause.Create(PatternStream.Create(pattern));
Assert.AreEqual(text, model.ToEPL());
testCase = new EventExpressionCase(model);
testCase.Add("B3", "b", events.GetEvent("B3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("(every b=" + EVENT_B_CLASS + ") where timer:withinmax(4.001, 0)");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("(every b=" + EVENT_B_CLASS + ") where timer:withinmax(4.001, 1)");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("(every b=" + EVENT_B_CLASS + ") where timer:withinmax(4.001, 2)");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCase.Add("B2", "b", events.GetEvent("B2"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every b=" + EVENT_B_CLASS + " where timer:withinmax(2.001, 4)");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCase.Add("B2", "b", events.GetEvent("B2"));
testCase.Add("B3", "b", events.GetEvent("B3"));
testCaseList.AddTest(testCase);
// Note how every restarts the max
testCase = new EventExpressionCase("every (b=" + EVENT_B_CLASS + " where timer:withinmax(2001 msec, 2))");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCase.Add("B2", "b", events.GetEvent("B2"));
testCase.Add("B3", "b", events.GetEvent("B3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every (b=" + EVENT_B_CLASS + " where timer:withinmax(2001 msec, 3))");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCase.Add("B2", "b", events.GetEvent("B2"));
testCase.Add("B3", "b", events.GetEvent("B3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every (b=" + EVENT_B_CLASS + " where timer:withinmax(2001 msec, 1))");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCase.Add("B2", "b", events.GetEvent("B2"));
testCase.Add("B3", "b", events.GetEvent("B3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every (b=" + EVENT_B_CLASS + " where timer:withinmax(2001 msec, 0))");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every b=" + EVENT_B_CLASS + " -> d=" + EVENT_D_CLASS + " where timer:withinmax(4000 msec, 1)");
testCase.Add("D1", "b", events.GetEvent("B2"), "d", events.GetEvent("D1"));
testCase.Add("D3", "b", events.GetEvent("B3"), "d", events.GetEvent("D3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every b=" + EVENT_B_CLASS + "() -> every d=" + EVENT_D_CLASS + " where timer:withinmax(4000 msec, 1)");
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCase.Add("D1", "b", events.GetEvent("B2"), "d", events.GetEvent("D1"));
testCase.Add("D2", "b", events.GetEvent("B1"), "d", events.GetEvent("D2"));
testCase.Add("D2", "b", events.GetEvent("B2"), "d", events.GetEvent("D2"));
testCase.Add("D3", "b", events.GetEvent("B1"), "d", events.GetEvent("D3"));
testCase.Add("D3", "b", events.GetEvent("B2"), "d", events.GetEvent("D3"));
testCase.Add("D3", "b", events.GetEvent("B3"), "d", events.GetEvent("D3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every b=" + EVENT_B_CLASS + "() -> (every d=" + EVENT_D_CLASS + ") where timer:withinmax(1 day, 3)");
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCase.Add("D1", "b", events.GetEvent("B2"), "d", events.GetEvent("D1"));
testCase.Add("D2", "b", events.GetEvent("B1"), "d", events.GetEvent("D2"));
testCase.Add("D2", "b", events.GetEvent("B2"), "d", events.GetEvent("D2"));
testCase.Add("D3", "b", events.GetEvent("B1"), "d", events.GetEvent("D3"));
testCase.Add("D3", "b", events.GetEvent("B2"), "d", events.GetEvent("D3"));
testCase.Add("D3", "b", events.GetEvent("B3"), "d", events.GetEvent("D3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every b=" + EVENT_B_CLASS + "() -> (every d=" + EVENT_D_CLASS + ") where timer:withinmax(1 day, 2)");
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCase.Add("D1", "b", events.GetEvent("B2"), "d", events.GetEvent("D1"));
testCase.Add("D2", "b", events.GetEvent("B1"), "d", events.GetEvent("D2"));
testCase.Add("D2", "b", events.GetEvent("B2"), "d", events.GetEvent("D2"));
testCase.Add("D3", "b", events.GetEvent("B3"), "d", events.GetEvent("D3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every b=" + EVENT_B_CLASS + "() -> (every d=" + EVENT_D_CLASS + ") where timer:withinmax(1 day, 1)");
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCase.Add("D1", "b", events.GetEvent("B2"), "d", events.GetEvent("D1"));
testCase.Add("D3", "b", events.GetEvent("B3"), "d", events.GetEvent("D3"));
testCaseList.AddTest(testCase);
var util = new PatternTestHarness(events, testCaseList, GetType(), GetType().FullName);
util.RunTest();
}
/// <summary>
/// Initializes a new instance of the <see cref="ModuleItem"/> class.
/// </summary>
/// <param name="model">The model.</param>
public ModuleItem(EPStatementObjectModel model)
{
Model = model;
}
public void TestOp()
{
EventCollection events = EventCollectionFactory.GetEventSetOne(0, 1000);
CaseList testCaseList = new CaseList();
EventExpressionCase testCase;
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + " and every d=" + EVENT_D_CLASS);
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCase.Add("D2", "b", events.GetEvent("B1"), "d", events.GetEvent("D2"));
testCase.Add("D3", "b", events.GetEvent("B1"), "d", events.GetEvent("D3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every b=" + EVENT_B_CLASS + " and d=" + EVENT_D_CLASS);
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCase.Add("D1", "b", events.GetEvent("B2"), "d", events.GetEvent("D1"));
testCase.Add("B3", "b", events.GetEvent("B3"), "d", events.GetEvent("D1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + " and d=" + EVENT_D_CLASS);
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every(b=" + EVENT_B_CLASS + " and d=" + EVENT_D_CLASS + ")");
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCase.Add("B3", "b", events.GetEvent("B3"), "d", events.GetEvent("D2"));
testCaseList.AddTest(testCase);
EPStatementObjectModel model = new EPStatementObjectModel();
model.SelectClause = SelectClause.CreateWildcard();
PatternExpr pattern = Patterns.Every(Patterns.And(Patterns.Filter(EVENT_B_CLASS, "b"), Patterns.Filter(EVENT_D_CLASS, "d")));
model.FromClause = FromClause.Create(PatternStream.Create(pattern));
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
Assert.AreEqual("select * from pattern [every (b=" + EVENT_B_CLASS + " and d=" + EVENT_D_CLASS + ")]", model.ToEPL());
testCase = new EventExpressionCase(model);
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCase.Add("B3", "b", events.GetEvent("B3"), "d", events.GetEvent("D2"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every( b=" + EVENT_B_CLASS + " and every d=" + EVENT_D_CLASS + ")");
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCase.Add("D2", "b", events.GetEvent("B1"), "d", events.GetEvent("D2"));
testCase.Add("B3", "b", events.GetEvent("B3"), "d", events.GetEvent("D2"));
testCase.Add("D3", "b", events.GetEvent("B1"), "d", events.GetEvent("D3"));
testCase.Add("D3", "b", events.GetEvent("B3"), "d", events.GetEvent("D3"));
testCase.Add("D3", "b", events.GetEvent("B3"), "d", events.GetEvent("D3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every b=" + EVENT_B_CLASS + " and every d=" + EVENT_D_CLASS);
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCase.Add("D1", "b", events.GetEvent("B2"), "d", events.GetEvent("D1"));
testCase.Add("D2", "b", events.GetEvent("B1"), "d", events.GetEvent("D2"));
testCase.Add("D2", "b", events.GetEvent("B2"), "d", events.GetEvent("D2"));
testCase.Add("B3", "b", events.GetEvent("B3"), "d", events.GetEvent("D1"));
testCase.Add("B3", "b", events.GetEvent("B3"), "d", events.GetEvent("D2"));
testCase.Add("D3", "b", events.GetEvent("B1"), "d", events.GetEvent("D3"));
testCase.Add("D3", "b", events.GetEvent("B2"), "d", events.GetEvent("D3"));
testCase.Add("D3", "b", events.GetEvent("B3"), "d", events.GetEvent("D3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every( every b=" + EVENT_B_CLASS + " and d=" + EVENT_D_CLASS + ")");
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCase.Add("D1", "b", events.GetEvent("B2"), "d", events.GetEvent("D1"));
testCase.Add("B3", "b", events.GetEvent("B3"), "d", events.GetEvent("D1"));
testCase.Add("B3", "b", events.GetEvent("B3"), "d", events.GetEvent("D2"));
testCase.Add("B3", "b", events.GetEvent("B3"), "d", events.GetEvent("D2"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every a=" + EVENT_A_CLASS + " and d=" + EVENT_D_CLASS + " and b=" + EVENT_B_CLASS);
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"), "a", events.GetEvent("A1"));
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"), "a", events.GetEvent("A2"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every( every b=" + EVENT_B_CLASS + " and every d=" + EVENT_D_CLASS + ")");
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCase.Add("D1", "b", events.GetEvent("B2"), "d", events.GetEvent("D1"));
testCase.Add("D2", "b", events.GetEvent("B1"), "d", events.GetEvent("D2"));
testCase.Add("D2", "b", events.GetEvent("B2"), "d", events.GetEvent("D2"));
testCase.Add("B3", "b", events.GetEvent("B3"), "d", events.GetEvent("D1"));
for (int i = 0; i < 3; i++)
{
testCase.Add("B3", "b", events.GetEvent("B3"), "d", events.GetEvent("D2"));
}
testCase.Add("D3", "b", events.GetEvent("B1"), "d", events.GetEvent("D3"));
testCase.Add("D3", "b", events.GetEvent("B2"), "d", events.GetEvent("D3"));
for (int i = 0; i < 5; i++)
{
testCase.Add("D3", "b", events.GetEvent("B3"), "d", events.GetEvent("D3"));
}
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("a=" + EVENT_A_CLASS + " and d=" + EVENT_D_CLASS + " and b=" + EVENT_B_CLASS);
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"), "a", events.GetEvent("A1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every a=" + EVENT_A_CLASS + " and every d=" + EVENT_D_CLASS + " and b=" + EVENT_B_CLASS);
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"), "a", events.GetEvent("A1"));
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"), "a", events.GetEvent("A2"));
testCase.Add("D2", "b", events.GetEvent("B1"), "d", events.GetEvent("D2"), "a", events.GetEvent("A1"));
testCase.Add("D2", "b", events.GetEvent("B1"), "d", events.GetEvent("D2"), "a", events.GetEvent("A2"));
testCase.Add("D3", "b", events.GetEvent("B1"), "d", events.GetEvent("D3"), "a", events.GetEvent("A1"));
testCase.Add("D3", "b", events.GetEvent("B1"), "d", events.GetEvent("D3"), "a", events.GetEvent("A2"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + " and b=" + EVENT_B_CLASS);
testCase.Add("B1", "b", events.GetEvent("B1"), "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every a=" + EVENT_A_CLASS + " and every d=" + EVENT_D_CLASS + " and every b=" + EVENT_B_CLASS);
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"), "a", events.GetEvent("A1"));
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"), "a", events.GetEvent("A2"));
testCase.Add("D1", "b", events.GetEvent("B2"), "d", events.GetEvent("D1"), "a", events.GetEvent("A1"));
testCase.Add("D1", "b", events.GetEvent("B2"), "d", events.GetEvent("D1"), "a", events.GetEvent("A2"));
testCase.Add("D2", "b", events.GetEvent("B1"), "d", events.GetEvent("D2"), "a", events.GetEvent("A1"));
testCase.Add("D2", "b", events.GetEvent("B1"), "d", events.GetEvent("D2"), "a", events.GetEvent("A2"));
testCase.Add("D2", "b", events.GetEvent("B2"), "d", events.GetEvent("D2"), "a", events.GetEvent("A1"));
testCase.Add("D2", "b", events.GetEvent("B2"), "d", events.GetEvent("D2"), "a", events.GetEvent("A2"));
testCase.Add("B3", "b", events.GetEvent("B3"), "d", events.GetEvent("D1"), "a", events.GetEvent("A1"));
testCase.Add("B3", "b", events.GetEvent("B3"), "d", events.GetEvent("D1"), "a", events.GetEvent("A2"));
testCase.Add("B3", "b", events.GetEvent("B3"), "d", events.GetEvent("D2"), "a", events.GetEvent("A1"));
testCase.Add("B3", "b", events.GetEvent("B3"), "d", events.GetEvent("D2"), "a", events.GetEvent("A2"));
testCase.Add("D3", "b", events.GetEvent("B1"), "d", events.GetEvent("D3"), "a", events.GetEvent("A1"));
testCase.Add("D3", "b", events.GetEvent("B1"), "d", events.GetEvent("D3"), "a", events.GetEvent("A2"));
testCase.Add("D3", "b", events.GetEvent("B2"), "d", events.GetEvent("D3"), "a", events.GetEvent("A1"));
testCase.Add("D3", "b", events.GetEvent("B2"), "d", events.GetEvent("D3"), "a", events.GetEvent("A2"));
testCase.Add("D3", "b", events.GetEvent("B3"), "d", events.GetEvent("D3"), "a", events.GetEvent("A1"));
testCase.Add("D3", "b", events.GetEvent("B3"), "d", events.GetEvent("D3"), "a", events.GetEvent("A2"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every (a=" + EVENT_A_CLASS + " and every d=" + EVENT_D_CLASS + " and b=" + EVENT_B_CLASS + ")");
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"), "a", events.GetEvent("A1"));
testCase.Add("D2", "b", events.GetEvent("B1"), "d", events.GetEvent("D2"), "a", events.GetEvent("A1"));
testCase.Add("D3", "b", events.GetEvent("B1"), "d", events.GetEvent("D3"), "a", events.GetEvent("A1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every (b=" + EVENT_B_CLASS + " and b=" + EVENT_B_CLASS + ")");
testCase.Add("B1", "b", events.GetEvent("B1"), "b", events.GetEvent("B1"));
testCase.Add("B2", "b", events.GetEvent("B2"), "b", events.GetEvent("B2"));
testCase.Add("B3", "b", events.GetEvent("B3"), "b", events.GetEvent("B3"));
testCaseList.AddTest(testCase);
PatternTestHarness util = new PatternTestHarness(events, testCaseList, GetType(), GetType().FullName);
util.RunTest();
}
private void RunAssertionAllAggFunctions(EPServiceProvider epService)
{
string[] fields = "cavedev,cavg,cmax,cmedian,cmin,cstddev,csum,cfmaxever,cfminever".Split(',');
EPStatementSPI stmt = (EPStatementSPI)epService.EPAdministrator.CreateEPL("select " +
"avedev(IntBoxed, BoolPrimitive) as cavedev," +
"avg(IntBoxed, BoolPrimitive) as cavg, " +
"fmax(IntBoxed, BoolPrimitive) as cmax, " +
"median(IntBoxed, BoolPrimitive) as cmedian, " +
"fmin(IntBoxed, BoolPrimitive) as cmin, " +
"stddev(IntBoxed, BoolPrimitive) as cstddev, " +
"sum(IntBoxed, BoolPrimitive) as csum," +
"fmaxever(IntBoxed, BoolPrimitive) as cfmaxever, " +
"fminever(IntBoxed, BoolPrimitive) as cfminever " +
"from SupportBean#length(3)");
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
epService.EPRuntime.SendEvent(MakeBean(100, false));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { null, null, null, null, null, null, null, null, null });
epService.EPRuntime.SendEvent(MakeBean(10, true));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { 0.0d, 10.0, 10, 10.0, 10, null, 10, 10, 10 });
epService.EPRuntime.SendEvent(MakeBean(11, false));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { 0.0d, 10.0, 10, 10.0, 10, null, 10, 10, 10 });
epService.EPRuntime.SendEvent(MakeBean(20, true));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { 5.0d, 15.0, 20, 15.0, 10, 7.0710678118654755, 30, 20, 10 });
epService.EPRuntime.SendEvent(MakeBean(30, true));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { 5.0d, 25.0, 30, 25.0, 20, 7.0710678118654755, 50, 30, 10 });
// Test all remaining types of "sum"
stmt.Dispose();
fields = "c1,c2,c3,c4".Split(',');
stmt = (EPStatementSPI)epService.EPAdministrator.CreateEPL("select " +
"sum(FloatPrimitive, BoolPrimitive) as c1," +
"sum(DoublePrimitive, BoolPrimitive) as c2, " +
"sum(LongPrimitive, BoolPrimitive) as c3, " +
"sum(ShortPrimitive, BoolPrimitive) as c4 " +
"from SupportBean#length(2)");
stmt.Events += listener.Update;
epService.EPRuntime.SendEvent(MakeBean(2f, 3d, 4L, (short)5, false));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { null, null, null, null });
epService.EPRuntime.SendEvent(MakeBean(3f, 4d, 5L, (short)6, true));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { 3f, 4d, 5L, 6 });
epService.EPRuntime.SendEvent(MakeBean(4f, 5d, 6L, (short)7, true));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { 7f, 9d, 11L, 13 });
epService.EPRuntime.SendEvent(MakeBean(1f, 1d, 1L, (short)1, true));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { 5f, 6d, 7L, 8 });
// Test min/max-ever
stmt.Dispose();
fields = "c1,c2".Split(',');
stmt = (EPStatementSPI)epService.EPAdministrator.CreateEPL("select " +
"fmax(IntBoxed, BoolPrimitive) as c1," +
"fmin(IntBoxed, BoolPrimitive) as c2 " +
"from SupportBean");
stmt.Events += listener.Update;
Assert.IsFalse(stmt.StatementContext.IsStatelessSelect);
epService.EPRuntime.SendEvent(MakeBean(10, true));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { 10, 10 });
epService.EPRuntime.SendEvent(MakeBean(20, true));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { 20, 10 });
epService.EPRuntime.SendEvent(MakeBean(8, false));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { 20, 10 });
epService.EPRuntime.SendEvent(MakeBean(7, true));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { 20, 7 });
epService.EPRuntime.SendEvent(MakeBean(30, false));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { 20, 7 });
epService.EPRuntime.SendEvent(MakeBean(40, true));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { 40, 7 });
// test big decimal big integer
stmt.Dispose();
fields = "c1,c2,c3".Split(',');
stmt = (EPStatementSPI)epService.EPAdministrator.CreateEPL("select " +
"avg(DecimalOne, BigInt < 100) as c1," +
"sum(DecimalOne, BigInt < 100) as c2, " +
"sum(BigInt, BigInt < 100) as c3 " +
"from SupportBeanNumeric#length(2)");
stmt.Events += listener.Update;
epService.EPRuntime.SendEvent(new SupportBeanNumeric(new BigInteger(10), new decimal(20)));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { new decimal(20), new decimal(20), new BigInteger(10) });
epService.EPRuntime.SendEvent(new SupportBeanNumeric(new BigInteger(101), new decimal(101)));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { new decimal(20), new decimal(20), new BigInteger(10) });
epService.EPRuntime.SendEvent(new SupportBeanNumeric(new BigInteger(20), new decimal(40)));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { new decimal(40), new decimal(40), new BigInteger(20) });
epService.EPRuntime.SendEvent(new SupportBeanNumeric(new BigInteger(30), new decimal(50)));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { new decimal(45), new decimal(90), new BigInteger(50) });
stmt.Dispose();
string epl = "select " +
"avedev(distinct IntBoxed,BoolPrimitive) as cavedev, " +
"avg(distinct IntBoxed,BoolPrimitive) as cavg, " +
"fmax(distinct IntBoxed,BoolPrimitive) as cmax, " +
"median(distinct IntBoxed,BoolPrimitive) as cmedian, " +
"fmin(distinct IntBoxed,BoolPrimitive) as cmin, " +
"stddev(distinct IntBoxed,BoolPrimitive) as cstddev, " +
"sum(distinct IntBoxed,BoolPrimitive) as csum " +
"from SupportBean#length(3)";
stmt = (EPStatementSPI)epService.EPAdministrator.CreateEPL(epl);
stmt.Events += listener.Update;
TryAssertionDistinct(epService, listener);
// test SODA
stmt.Dispose();
EPStatementObjectModel model = epService.EPAdministrator.CompileEPL(epl);
Assert.AreEqual(epl, model.ToEPL());
stmt = (EPStatementSPI)epService.EPAdministrator.Create(model);
stmt.Events += listener.Update;
Assert.AreEqual(epl, stmt.Text);
TryAssertionDistinct(epService, listener);
stmt.Dispose();
}
public void Run(RegressionEnvironment env)
{
var fields = new [] { "TheString" };
var stmtText = "@Name('s0') select TheString from SupportBean#keepall output after 3 events";
env.CompileDeploy(stmtText).AddListener("s0");
SendEvent(env, "E1");
env.Milestone(0);
SendEvent(env, "E2");
SendEvent(env, "E3");
Assert.IsFalse(env.Listener("s0").IsInvoked);
env.Milestone(1);
SendEvent(env, "E4");
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {"E4"});
SendEvent(env, "E5");
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {"E5"});
env.UndeployAll();
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create("TheString");
model.FromClause = FromClause.Create(FilterStream.Create("SupportBean").AddView("keepall"));
model.OutputLimitClause = OutputLimitClause.CreateAfter(3);
Assert.AreEqual("select TheString from SupportBean#keepall output after 3 events ", model.ToEPL());
model.Annotations = Collections.SingletonList(AnnotationPart.NameAnnotation("s0"));
env.CompileDeploy(model).AddListener("s0");
SendEvent(env, "E1");
SendEvent(env, "E2");
SendEvent(env, "E3");
Assert.IsFalse(env.Listener("s0").IsInvoked);
SendEvent(env, "E4");
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {"E4"});
SendEvent(env, "E5");
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {"E5"});
model = env.EplToModel("select TheString from SupportBean#keepall output after 3 events");
Assert.AreEqual("select TheString from SupportBean#keepall output after 3 events ", model.ToEPL());
env.UndeployAll();
}
public void TestGroupDelivery()
{
SendTimer(0);
EPStatement stmt = _epService.EPAdministrator.CreateEPL("select * from SupportBean.win:time_batch(1) for grouped_delivery (IntPrimitive)");
stmt.Events += _listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
_epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
_epService.EPRuntime.SendEvent(new SupportBean("E3", 1));
SendTimer(1000);
Assert.AreEqual(2, _listener.NewDataList.Count);
Assert.AreEqual(2, _listener.NewDataList[0].Length);
EPAssertionUtil.AssertPropsPerRow(_listener.NewDataList[0], "TheString,IntPrimitive".Split(','), new Object[][] { new Object[] { "E1", 1 }, new Object[] { "E3", 1 } });
Assert.AreEqual(1, _listener.NewDataList[1].Length);
EPAssertionUtil.AssertPropsPerRow(_listener.NewDataList[1], "TheString,IntPrimitive".Split(','), new Object[][] { new Object[] { "E2", 2 } });
// test sorted
stmt.Dispose();
stmt = _epService.EPAdministrator.CreateEPL("select * from SupportBean.win:time_batch(1) order by IntPrimitive desc for grouped_delivery (IntPrimitive)");
stmt.Events += _listener.Update;
_listener.Reset();
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
_epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
_epService.EPRuntime.SendEvent(new SupportBean("E3", 1));
SendTimer(2000);
Assert.AreEqual(2, _listener.NewDataList.Count);
Assert.AreEqual(1, _listener.NewDataList[0].Length);
EPAssertionUtil.AssertPropsPerRow(_listener.NewDataList[0], "TheString,IntPrimitive".Split(','), new Object[][] { new Object[] { "E2", 2 } });
Assert.AreEqual(2, _listener.NewDataList[1].Length);
EPAssertionUtil.AssertPropsPerRow(_listener.NewDataList[1], "TheString,IntPrimitive".Split(','), new Object[][] { new Object[] { "E1", 1 }, new Object[] { "E3", 1 } });
// test multiple criteria
stmt.Dispose();
String stmtText = "select TheString, DoubleBoxed, EnumValue from SupportBean.win:time_batch(1) order by TheString, DoubleBoxed, EnumValue for grouped_delivery(DoubleBoxed, EnumValue)";
stmt = _epService.EPAdministrator.CreateEPL(stmtText);
stmt.Events += _listener.Update;
_listener.Reset();
SendEvent("E1", 10d, SupportEnum.ENUM_VALUE_2); // A (1)
SendEvent("E2", 11d, SupportEnum.ENUM_VALUE_1); // B (2)
SendEvent("E3", 9d, SupportEnum.ENUM_VALUE_2); // C (3)
SendEvent("E4", 10d, SupportEnum.ENUM_VALUE_2); // A
SendEvent("E5", 10d, SupportEnum.ENUM_VALUE_1); // D (4)
SendEvent("E6", 10d, SupportEnum.ENUM_VALUE_1); // D
SendEvent("E7", 11d, SupportEnum.ENUM_VALUE_1); // B
SendEvent("E8", 10d, SupportEnum.ENUM_VALUE_1); // D
SendTimer(3000);
Assert.AreEqual(4, _listener.NewDataList.Count);
String[] fields = "TheString,DoubleBoxed,EnumValue".Split(',');
EPAssertionUtil.AssertPropsPerRow(_listener.NewDataList[0], fields,
new Object[][] { new Object[] { "E1", 10d, SupportEnum.ENUM_VALUE_2 }, new Object[] { "E4", 10d, SupportEnum.ENUM_VALUE_2 } });
EPAssertionUtil.AssertPropsPerRow(_listener.NewDataList[1], fields,
new Object[][] { new Object[] { "E2", 11d, SupportEnum.ENUM_VALUE_1 }, new Object[] { "E7", 11d, SupportEnum.ENUM_VALUE_1 } });
EPAssertionUtil.AssertPropsPerRow(_listener.NewDataList[2], fields,
new Object[][] { new Object[] { "E3", 9d, SupportEnum.ENUM_VALUE_2 } });
EPAssertionUtil.AssertPropsPerRow(_listener.NewDataList[3], fields,
new Object[][] { new Object[] { "E5", 10d, SupportEnum.ENUM_VALUE_1 }, new Object[] { "E6", 10d, SupportEnum.ENUM_VALUE_1 }, new Object[] { "E8", 10d, SupportEnum.ENUM_VALUE_1 } });
// test SODA
stmt.Dispose();
_listener.Reset();
EPStatementObjectModel model = _epService.EPAdministrator.CompileEPL(stmtText);
Assert.AreEqual(stmtText, model.ToEPL());
stmt = _epService.EPAdministrator.Create(model);
stmt.Events += _listener.Update;
SendEvent("E1", 10d, SupportEnum.ENUM_VALUE_2); // A (1)
SendEvent("E2", 11d, SupportEnum.ENUM_VALUE_1); // B (2)
SendEvent("E3", 11d, SupportEnum.ENUM_VALUE_1); // B (2)
SendTimer(4000);
Assert.AreEqual(2, _listener.NewDataList.Count);
EPAssertionUtil.AssertPropsPerRow(_listener.NewDataList[0], fields,
new Object[][] { new Object[] { "E1", 10d, SupportEnum.ENUM_VALUE_2 } });
EPAssertionUtil.AssertPropsPerRow(_listener.NewDataList[1], fields,
new Object[][] { new Object[] { "E2", 11d, SupportEnum.ENUM_VALUE_1 }, new Object[] { "E3", 11d, SupportEnum.ENUM_VALUE_1 } });
}
public void TestOutputWhenThenExpression()
{
SendTimeEvent(1, 8, 0, 0, 0);
_epService.EPAdministrator.Configuration.AddVariable("myvar", typeof(int), 0);
_epService.EPAdministrator.Configuration.AddVariable("count_insert_var", typeof(int), 0);
_epService.EPAdministrator.CreateEPL("on SupportBean set myvar = IntPrimitive");
var expression = "select Symbol from MarketData.win:length(2) output when myvar=1 then set myvar=0, count_insert_var=count_insert";
var stmt = _epService.EPAdministrator.CreateEPL(expression);
RunAssertion(1, stmt);
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.Create("Symbol");
model.FromClause = FromClause.Create(FilterStream.Create("MarketData").AddView("win", "length", Expressions.Constant(2)));
model.OutputLimitClause = OutputLimitClause.Create(Expressions.Eq("myvar", 1))
.AddThenAssignment(Expressions.Eq(Expressions.Property("myvar"), Expressions.Constant(0)))
.AddThenAssignment(Expressions.Eq(Expressions.Property("count_insert_var"), Expressions.Property("count_insert")));
var epl = model.ToEPL();
Assert.AreEqual(expression, epl);
stmt = _epService.EPAdministrator.Create(model);
RunAssertion(2, stmt);
model = _epService.EPAdministrator.CompileEPL(expression);
Assert.AreEqual(expression, model.ToEPL());
stmt = _epService.EPAdministrator.Create(model);
RunAssertion(3, stmt);
var outputLast = "select Symbol from MarketData.win:length(2) output last when myvar=1 ";
model = _epService.EPAdministrator.CompileEPL(outputLast);
Assert.AreEqual(outputLast.Trim(), model.ToEPL().Trim());
// test same variable referenced multiple times JIRA-386
SendTimer(0);
var listenerOne = new SupportUpdateListener();
var listenerTwo = new SupportUpdateListener();
var stmtOne = _epService.EPAdministrator.CreateEPL("select * from MarketData output last when myvar=100");
stmtOne.AddListener(listenerOne);
var stmtTwo = _epService.EPAdministrator.CreateEPL("select * from MarketData output last when myvar=100");
stmtTwo.AddListener(listenerTwo);
_epService.EPRuntime.SendEvent(new SupportMarketDataBean("ABC", "E1", 100));
_epService.EPRuntime.SendEvent(new SupportMarketDataBean("ABC", "E2", 100));
SendTimer(1000);
Assert.IsFalse(listenerOne.IsInvoked);
Assert.IsFalse(listenerTwo.IsInvoked);
_epService.EPRuntime.SetVariableValue("myvar", 100);
SendTimer(2000);
Assert.IsTrue(listenerTwo.IsInvoked);
Assert.IsTrue(listenerOne.IsInvoked);
stmtOne.Dispose();
stmtTwo.Dispose();
// test when-then with condition triggered by output events
SendTimeEvent(2, 8, 0, 0, 0);
var eplToDeploy = "create variable boolean varOutputTriggered = false\n;" +
"@Audit @Name('out') select * from SupportBean.std:lastevent() output snapshot when (count_insert > 1 and varOutputTriggered = false) then set varOutputTriggered = true;";
_epService.EPAdministrator.DeploymentAdmin.ParseDeploy(eplToDeploy);
_epService.EPAdministrator.GetStatement("out").AddListener(_listener);
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
Assert.IsFalse(_listener.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
Assert.AreEqual("E2", _listener.AssertOneGetNewAndReset().Get("TheString"));
_epService.EPRuntime.SendEvent(new SupportBean("E3", 3));
_epService.EPRuntime.SendEvent(new SupportBean("E4", 4));
Assert.IsFalse(_listener.IsInvoked);
_epService.EPRuntime.SetVariableValue("varOutputTriggered", false); // turns true right away as triggering output
_epService.EPRuntime.SendEvent(new SupportBean("E5", 5));
SendTimeEvent(2, 8, 0, 1, 0);
Assert.AreEqual("E5", _listener.AssertOneGetNewAndReset().Get("TheString"));
_epService.EPRuntime.SendEvent(new SupportBean("E6", 6));
Assert.IsFalse(_listener.IsInvoked);
_epService.EPAdministrator.DestroyAllStatements();
// test count_total for insert and remove
_epService.EPAdministrator.CreateEPL("create variable int var_cnt_total = 3");
var expressionTotal = "select TheString from SupportBean.win:length(2) output when count_insert_total = var_cnt_total or count_remove_total > 2";
var stmtTotal = _epService.EPAdministrator.CreateEPL(expressionTotal);
stmtTotal.AddListener(_listener);
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
_epService.EPRuntime.SendEvent(new SupportBean("E2", 1));
Assert.IsFalse(_listener.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportBean("E3", 1));
EPAssertionUtil.AssertPropsPerRow(_listener.GetAndResetLastNewData(), "TheString".Split(','), new object[][] { new object[] { "E1" }, new object[] { "E2" }, new object[] { "E3" } });
_epService.EPRuntime.SetVariableValue("var_cnt_total", -1);
_epService.EPRuntime.SendEvent(new SupportBean("E4", 1));
Assert.IsFalse(_listener.GetAndClearIsInvoked());
_epService.EPRuntime.SendEvent(new SupportBean("E5", 1));
EPAssertionUtil.AssertPropsPerRow(_listener.GetAndResetLastNewData(), "TheString".Split(','), new object[][] { new object[] { "E4" }, new object[] { "E5" } });
_epService.EPAdministrator.DestroyAllStatements();
}
public void TestOp()
{
EventCollection events = EventCollectionFactory.GetEventSetOne(0, 1000);
CaseList testCaseList = new CaseList();
EventExpressionCase testCase = null;
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + "(Id=\"B1\") where timer:within(2 sec)");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + "(Id=\"B1\") where timer:within(2001 msec)");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + "(Id=\"B1\") where timer:within(1999 msec)");
testCaseList.AddTest(testCase);
String text = "select * from pattern [b=" + EVENT_B_CLASS + "(Id=\"B3\") where timer:within(10.001)]";
EPStatementObjectModel model = new EPStatementObjectModel();
model.SelectClause = SelectClause.CreateWildcard();
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(model);
Expression filter = Expressions.Eq("Id", "B3");
PatternExpr pattern = Patterns.TimerWithin(10.001, Patterns.Filter(Filter.Create(EVENT_B_CLASS, filter), "b"));
model.FromClause = FromClause.Create(PatternStream.Create(pattern));
Assert.AreEqual(text, model.ToEPL());
testCase = new EventExpressionCase(model);
testCase.Add("B3", "b", events.GetEvent("B3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + "(Id=\"B3\") where timer:within(10001 msec)");
testCase.Add("B3", "b", events.GetEvent("B3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + "(Id=\"B3\") where timer:within(10 sec)");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + "(Id=\"B3\") where timer:within(9.999)");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("(every b=" + EVENT_B_CLASS + ") where timer:within(2.001)");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("(every b=" + EVENT_B_CLASS + ") where timer:within(4.001)");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCase.Add("B2", "b", events.GetEvent("B2"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every b=" + EVENT_B_CLASS + " where timer:within(2.001)");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCase.Add("B2", "b", events.GetEvent("B2"));
testCase.Add("B3", "b", events.GetEvent("B3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every (b=" + EVENT_B_CLASS + " where timer:within(2001 msec))");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCase.Add("B2", "b", events.GetEvent("B2"));
testCase.Add("B3", "b", events.GetEvent("B3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every ((every b=" + EVENT_B_CLASS + ") where timer:within(2.001))");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCase.Add("B2", "b", events.GetEvent("B2"));
testCase.Add("B2", "b", events.GetEvent("B2"));
testCase.Add("B3", "b", events.GetEvent("B3"));
testCase.Add("B3", "b", events.GetEvent("B3"));
testCase.Add("B3", "b", events.GetEvent("B3"));
testCase.Add("B3", "b", events.GetEvent("B3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every ((every b=" + EVENT_B_CLASS + ") where timer:within(6.001))");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCase.Add("B2", "b", events.GetEvent("B2"));
testCase.Add("B2", "b", events.GetEvent("B2"));
testCase.Add("B3", "b", events.GetEvent("B3"));
testCase.Add("B3", "b", events.GetEvent("B3"));
testCase.Add("B3", "b", events.GetEvent("B3"));
testCase.Add("B3", "b", events.GetEvent("B3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("(every b=" + EVENT_B_CLASS + ") where timer:within(11.001)");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCase.Add("B2", "b", events.GetEvent("B2"));
testCase.Add("B3", "b", events.GetEvent("B3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("(every b=" + EVENT_B_CLASS + ") where timer:within(4001 milliseconds)");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCase.Add("B2", "b", events.GetEvent("B2"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every (b=" + EVENT_B_CLASS + ") where timer:within(6.001)");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCase.Add("B2", "b", events.GetEvent("B2"));
testCase.Add("B3", "b", events.GetEvent("B3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + " -> d=" + EVENT_D_CLASS + " where timer:within(4001 milliseconds)");
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + "() -> d=" + EVENT_D_CLASS + "() where timer:within(4 sec)");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every (b=" + EVENT_B_CLASS + "() where timer:within (4.001) and d=" + EVENT_D_CLASS + "() where timer:within(6.001))");
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCase.Add("B3", "b", events.GetEvent("B3"), "d", events.GetEvent("D2"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + "() where timer:within (2001 msec) and d=" + EVENT_D_CLASS + "() where timer:within(6001 msec)");
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + "() where timer:within (2001 msec) and d=" + EVENT_D_CLASS + "() where timer:within(6000 msec)");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + "() where timer:within (2000 msec) and d=" + EVENT_D_CLASS + "() where timer:within(6001 msec)");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every b=" + EVENT_B_CLASS + " -> d=" + EVENT_D_CLASS + " where timer:within(4000 msec)");
testCase.Add("D1", "b", events.GetEvent("B2"), "d", events.GetEvent("D1"));
testCase.Add("D3", "b", events.GetEvent("B3"), "d", events.GetEvent("D3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every b=" + EVENT_B_CLASS + "() -> every d=" + EVENT_D_CLASS + " where timer:within(4000 msec)");
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCase.Add("D1", "b", events.GetEvent("B2"), "d", events.GetEvent("D1"));
testCase.Add("D2", "b", events.GetEvent("B1"), "d", events.GetEvent("D2"));
testCase.Add("D2", "b", events.GetEvent("B2"), "d", events.GetEvent("D2"));
testCase.Add("D3", "b", events.GetEvent("B1"), "d", events.GetEvent("D3"));
testCase.Add("D3", "b", events.GetEvent("B2"), "d", events.GetEvent("D3"));
testCase.Add("D3", "b", events.GetEvent("B3"), "d", events.GetEvent("D3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + "() -> d=" + EVENT_D_CLASS + "() where timer:within(3999 msec)");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every b=" + EVENT_B_CLASS + "() -> (every d=" + EVENT_D_CLASS + ") where timer:within(2001 msec)");
testCase.Add("D1", "b", events.GetEvent("B2"), "d", events.GetEvent("D1"));
testCase.Add("D3", "b", events.GetEvent("B3"), "d", events.GetEvent("D3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every (b=" + EVENT_B_CLASS + "() -> d=" + EVENT_D_CLASS + "()) where timer:within(6001 msec)");
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCase.Add("D3", "b", events.GetEvent("B3"), "d", events.GetEvent("D3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + "() where timer:within (2000 msec) or d=" + EVENT_D_CLASS + "() where timer:within(6000 msec)");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("(b=" + EVENT_B_CLASS + "() where timer:within (2000 msec) or d=" + EVENT_D_CLASS + "() where timer:within(6000 msec)) where timer:within (1999 msec)");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every (b=" + EVENT_B_CLASS + "() where timer:within (2001 msec) and d=" + EVENT_D_CLASS + "() where timer:within(6001 msec))");
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCase.Add("B3", "b", events.GetEvent("B3"), "d", events.GetEvent("D2"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + "() where timer:within (2001 msec) or d=" + EVENT_D_CLASS + "() where timer:within(6001 msec)");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + "() where timer:within (2000 msec) or d=" + EVENT_D_CLASS + "() where timer:within(6001 msec)");
testCase.Add("D1", "d", events.GetEvent("D1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every b=" + EVENT_B_CLASS + "() where timer:within (2001 msec) and every d=" + EVENT_D_CLASS + "() where timer:within(6001 msec)");
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCase.Add("D1", "b", events.GetEvent("B2"), "d", events.GetEvent("D1"));
testCase.Add("D2", "b", events.GetEvent("B1"), "d", events.GetEvent("D2"));
testCase.Add("D2", "b", events.GetEvent("B2"), "d", events.GetEvent("D2"));
testCase.Add("B3", "b", events.GetEvent("B3"), "d", events.GetEvent("D1"));
testCase.Add("B3", "b", events.GetEvent("B3"), "d", events.GetEvent("D2"));
testCase.Add("D3", "b", events.GetEvent("B1"), "d", events.GetEvent("D3"));
testCase.Add("D3", "b", events.GetEvent("B2"), "d", events.GetEvent("D3"));
testCase.Add("D3", "b", events.GetEvent("B3"), "d", events.GetEvent("D3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("(every b=" + EVENT_B_CLASS + ") where timer:within (2000 msec) and every d=" + EVENT_D_CLASS + "() where timer:within(6001 msec)");
testCaseList.AddTest(testCase);
PatternTestHarness util = new PatternTestHarness(events, testCaseList, GetType(), GetType().FullName);
util.RunTest();
}
private void RunTest(PatternTestStyle testStyle)
{
Configuration config = SupportConfigFactory.GetConfiguration();
config.AddEventType("A", typeof(SupportBean_A));
config.AddEventType("B", typeof(SupportBean_B));
config.AddEventType("C", typeof(SupportBean_C));
config.AddEventType("D", typeof(SupportBean_D));
config.AddEventType("E", typeof(SupportBean_E));
config.AddEventType("F", typeof(SupportBean_F));
config.AddEventType("G", typeof(SupportBean_G));
EPServiceProvider serviceProvider = EPServiceProviderManager.GetDefaultProvider(config);
serviceProvider.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(serviceProvider, _testClass, _testMethodName);
}
EPRuntime runtime = serviceProvider.EPRuntime;
// Send the start time to the runtime
if (_sendEventCollection.GetTime(EventCollection.ON_START_EVENT_ID) != null)
{
TimerEvent startTime = new CurrentTimeEvent(_sendEventCollection.GetTime(EventCollection.ON_START_EVENT_ID).Value);
runtime.SendEvent(startTime);
Log.Debug("RunTest: Start time is " + startTime);
}
// Set up expression filters and match listeners
int index = 0;
foreach (EventExpressionCase descriptor in _caseList.Results)
{
String expressionText = descriptor.ExpressionText;
EPStatementObjectModel model = descriptor.ObjectModel;
EPStatement statement = null;
try
{
if (model != null)
{
statement = serviceProvider.EPAdministrator.Create(model, "name--" + expressionText);
}
else
{
if (testStyle == PatternTestStyle.USE_PATTERN_LANGUAGE)
{
statement = serviceProvider.EPAdministrator.CreatePattern(expressionText, "name--" + expressionText);
}
else if (testStyle == PatternTestStyle.USE_EPL)
{
String text = "@Audit('pattern') @Audit('pattern-instances') select * from pattern [" + expressionText + "]";
statement = serviceProvider.EPAdministrator.CreateEPL(text);
expressionText = text;
}
else if (testStyle == PatternTestStyle.USE_EPL_AND_CONSUME_NOCHECK)
{
String text = "select * from pattern @DiscardPartialsOnMatch @SuppressOverlappingMatches [" + expressionText + "]";
statement = serviceProvider.EPAdministrator.CreateEPL(text);
expressionText = text;
}
else if (testStyle == PatternTestStyle.COMPILE_TO_MODEL)
{
String text = "select * from pattern [" + expressionText + "]";
EPStatementObjectModel mymodel = serviceProvider.EPAdministrator.CompileEPL(text);
statement = serviceProvider.EPAdministrator.Create(mymodel);
expressionText = text;
}
else if (testStyle == PatternTestStyle.COMPILE_TO_EPL)
{
String text = "select * from pattern [" + expressionText + "]";
EPStatementObjectModel mymodel = serviceProvider.EPAdministrator.CompileEPL(text);
String reverse = mymodel.ToEPL();
statement = serviceProvider.EPAdministrator.CreateEPL(reverse);
expressionText = reverse;
}
else
{
throw new ArgumentException("Unknown test style");
}
}
}
catch (Exception ex)
{
String text = expressionText;
if (model != null)
{
text = "Model: " + model.ToEPL();
}
Log.Error(".runTest Failed to create statement for style " + testStyle + " pattern expression=" + text, ex);
Assert.Fail(".runTest Failed to create statement for style " + testStyle + " pattern expression=" + text);
}
// We stop the statement again and start after the first listener was added.
// Thus we can handle patterns that fireStatementStopped on startup.
statement.Stop();
_expressions[index] = statement;
_expressions[index].Events += _listeners[index].Update;
// Start the statement again: listeners now got called for on-start events such as for a "not"
statement.Start();
index++;
}
// Some expressions may fireStatementStopped as soon as they are started, such as a "not b()" expression, for example.
// Check results for any such listeners/expressions.
// NOTE: For EPL statements we do not support calling listeners when a pattern that fires upon start.
// Reason is that this should not be a relevant functionality of a pattern, the start pattern
// event itself cannot carry any information and is thus ignore. Note subsequent events
// generated by the same pattern are fine.
int totalEventsReceived = 0;
if (testStyle != PatternTestStyle.USE_PATTERN_LANGUAGE)
{
ClearListenerEvents();
totalEventsReceived += CountExpectedEvents(EventCollection.ON_START_EVENT_ID);
}
else // Patterns do need to handle event publishing upon pattern expression start (patterns that turn true right away)
{
CheckResults(testStyle, EventCollection.ON_START_EVENT_ID);
totalEventsReceived += CountListenerEvents();
ClearListenerEvents();
}
// Send actual test events
var entryCollection = _sendEventCollection.ToArray();
for (int ii = 0; ii < entryCollection.Length; ii++)
{
var entry = entryCollection[ii];
var eventId = entry.Key;
// Manipulate the time when this event was send
if (_sendEventCollection.GetTime(eventId) != null)
{
TimerEvent currentTimeEvent = new CurrentTimeEvent(_sendEventCollection.GetTime(eventId).Value);
runtime.SendEvent(currentTimeEvent);
Log.Debug("RunTest: Sending event {0} = {1} timed {2}", entry.Key, entry.Value, currentTimeEvent);
}
// Send event itself
runtime.SendEvent(entry.Value);
// Check expected results for this event
if (testStyle != PatternTestStyle.USE_EPL_AND_CONSUME_NOCHECK)
{
CheckResults(testStyle, eventId);
// Count and clear the list of events that each listener has received
totalEventsReceived += CountListenerEvents();
}
ClearListenerEvents();
}
// Count number of expected matches
int totalExpected = 0;
foreach (EventExpressionCase descriptor in _caseList.Results)
{
totalExpected += descriptor.ExpectedResults.Values.Sum(events => events.Count);
}
if (totalExpected != totalEventsReceived && testStyle != PatternTestStyle.USE_EPL_AND_CONSUME_NOCHECK)
{
Log.Debug(".test Count expected does not match count received, expected=" + totalExpected +
" received=" + totalEventsReceived);
Assert.Fail();
}
// Kill all expressions
foreach (EPStatement expression in _expressions)
{
expression.RemoveAllEventHandlers();
}
// Send test events again to also test that all were indeed killed
foreach (var entry in _sendEventCollection)
{
runtime.SendEvent(entry.Value);
}
// Make sure all listeners are still at zero
foreach (SupportUpdateListener listener in _listeners)
{
if (listener.NewDataList.Count > 0)
{
Log.Debug(".test A match was received after stopping all expressions");
Assert.Fail();
}
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
public void Run(RegressionEnvironment env)
{
var events = EventCollectionFactory.GetEventSetOne(0, 1000);
var testCaseList = new CaseList();
EventExpressionCase testCase;
testCase = new EventExpressionCase("b=SupportBean_B(Id='B1') where timer:withinmax(2 sec,100)");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=SupportBean_B(Id='B1') where timer:withinmax(2001 msec,1)");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=SupportBean_B(Id='B1') where timer:withinmax(1999 msec,10)");
testCaseList.AddTest(testCase);
var text = "select * from pattern [b=SupportBean_B(Id='B3') where timer:withinmax(10.001d,1)]";
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.CreateWildcard();
model = env.CopyMayFail(model);
Expression filter = Expressions.Eq("Id", "B3");
PatternExpr pattern = Patterns.TimerWithinMax(
10.001,
1,
Patterns.Filter(Filter.Create("SupportBean_B", filter), "b"));
model.FromClause = FromClause.Create(PatternStream.Create(pattern));
Assert.AreEqual(text, model.ToEPL().Replace("\"", "'"));
testCase = new EventExpressionCase(model);
testCase.Add("B3", "b", events.GetEvent("B3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("(every b=SupportBean_B) where timer:withinmax(4.001, 0)");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("(every b=SupportBean_B) where timer:withinmax(4.001, 1)");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("(every b=SupportBean_B) where timer:withinmax(4.001, 2)");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCase.Add("B2", "b", events.GetEvent("B2"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every b=SupportBean_B where timer:withinmax(2.001, 4)");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCase.Add("B2", "b", events.GetEvent("B2"));
testCase.Add("B3", "b", events.GetEvent("B3"));
testCaseList.AddTest(testCase);
// Note how every restarts the max
testCase = new EventExpressionCase("every (b=SupportBean_B where timer:withinmax(2001 msec, 2))");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCase.Add("B2", "b", events.GetEvent("B2"));
testCase.Add("B3", "b", events.GetEvent("B3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every (b=SupportBean_B where timer:withinmax(2001 msec, 3))");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCase.Add("B2", "b", events.GetEvent("B2"));
testCase.Add("B3", "b", events.GetEvent("B3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every (b=SupportBean_B where timer:withinmax(2001 msec, 1))");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCase.Add("B2", "b", events.GetEvent("B2"));
testCase.Add("B3", "b", events.GetEvent("B3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every (b=SupportBean_B where timer:withinmax(2001 msec, 0))");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase(
"every b=SupportBean_B -> d=SupportBean_D where timer:withinmax(4000 msec, 1)");
testCase.Add("D1", "b", events.GetEvent("B2"), "d", events.GetEvent("D1"));
testCase.Add("D3", "b", events.GetEvent("B3"), "d", events.GetEvent("D3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase(
"every b=SupportBean_B() -> every d=SupportBean_D where timer:withinmax(4000 msec, 1)");
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCase.Add("D1", "b", events.GetEvent("B2"), "d", events.GetEvent("D1"));
testCase.Add("D2", "b", events.GetEvent("B1"), "d", events.GetEvent("D2"));
testCase.Add("D2", "b", events.GetEvent("B2"), "d", events.GetEvent("D2"));
testCase.Add("D3", "b", events.GetEvent("B1"), "d", events.GetEvent("D3"));
testCase.Add("D3", "b", events.GetEvent("B2"), "d", events.GetEvent("D3"));
testCase.Add("D3", "b", events.GetEvent("B3"), "d", events.GetEvent("D3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase(
"every b=SupportBean_B() -> (every d=SupportBean_D) where timer:withinmax(1 day, 3)");
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCase.Add("D1", "b", events.GetEvent("B2"), "d", events.GetEvent("D1"));
testCase.Add("D2", "b", events.GetEvent("B1"), "d", events.GetEvent("D2"));
testCase.Add("D2", "b", events.GetEvent("B2"), "d", events.GetEvent("D2"));
testCase.Add("D3", "b", events.GetEvent("B1"), "d", events.GetEvent("D3"));
testCase.Add("D3", "b", events.GetEvent("B2"), "d", events.GetEvent("D3"));
testCase.Add("D3", "b", events.GetEvent("B3"), "d", events.GetEvent("D3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase(
"every b=SupportBean_B() -> (every d=SupportBean_D) where timer:withinmax(1 day, 2)");
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCase.Add("D1", "b", events.GetEvent("B2"), "d", events.GetEvent("D1"));
testCase.Add("D2", "b", events.GetEvent("B1"), "d", events.GetEvent("D2"));
testCase.Add("D2", "b", events.GetEvent("B2"), "d", events.GetEvent("D2"));
testCase.Add("D3", "b", events.GetEvent("B3"), "d", events.GetEvent("D3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase(
"every b=SupportBean_B() -> (every d=SupportBean_D) where timer:withinmax(1 day, 1)");
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCase.Add("D1", "b", events.GetEvent("B2"), "d", events.GetEvent("D1"));
testCase.Add("D3", "b", events.GetEvent("B3"), "d", events.GetEvent("D3"));
testCaseList.AddTest(testCase);
var util = new PatternTestHarness(events, testCaseList, GetType());
util.RunTest(env);
}
public void Run(RegressionEnvironment env)
{
var events = EventCollectionFactory.GetEventSetOne(0, 1000);
var testCaseList = new CaseList();
EventExpressionCase testCase;
// The wait is done when 2 seconds passed
testCase = new EventExpressionCase("timer:interval(1999 msec)");
testCase.Add("B1");
testCaseList.AddTest(testCase);
var text = "select * from pattern [timer:interval(1.999d)]";
var model = new EPStatementObjectModel();
model.SetSelect(SelectClause.CreateWildcard());
PatternExpr pattern = Patterns.TimerInterval(1.999d);
model.SetFrom(FromClause.Create(PatternStream.Create(pattern)));
model = env.CopyMayFail(model);
Assert.AreEqual(text, model.ToEPL());
testCase = new EventExpressionCase(model);
testCase.Add("B1");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:interval(2 sec)");
testCase.Add("B1");
testCaseList.AddTest(testCase);
// 3 seconds (>2001 microseconds) passed
testCase = new EventExpressionCase("timer:interval(2.001)");
testCase.Add("C1");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:interval(2999 milliseconds)");
testCase.Add("C1");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:interval(3 seconds)");
testCase.Add("C1");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:interval(3.001 seconds)");
testCase.Add("B2");
testCaseList.AddTest(testCase);
// Try with an all ... repeated timer every 3 seconds
testCase = new EventExpressionCase("every timer:interval(3.001 sec)");
testCase.Add("B2");
testCase.Add("F1");
testCase.Add("D3");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every timer:interval(5000 msec)");
testCase.Add("A2");
testCase.Add("B3");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:interval(3.999 second) -> b=SupportBean_B");
testCase.Add("B2", "b", events.GetEvent("B2"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:interval(4 sec) -> b=SupportBean_B");
testCase.Add("B2", "b", events.GetEvent("B2"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:interval(4.001 sec) -> b=SupportBean_B");
testCase.Add("B3", "b", events.GetEvent("B3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:interval(0) -> b=SupportBean_B");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
// Try with an followed-by as a second argument
testCase = new EventExpressionCase("b=SupportBean_B -> timer:interval(0.001)");
testCase.Add("C1", "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=SupportBean_B -> timer:interval(0)");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=SupportBean_B -> timer:interval(1 sec)");
testCase.Add("C1", "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=SupportBean_B -> timer:interval(1.001)");
testCase.Add("B2", "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
// Try in a 3-way followed by
testCase = new EventExpressionCase("b=SupportBean_B() -> timer:interval(6.000) -> d=SupportBean_D");
testCase.Add("D2", "b", events.GetEvent("B1"), "d", events.GetEvent("D2"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase(
"every (b=SupportBean_B() -> timer:interval(2.001) -> d=SupportBean_D())");
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase(
"every (b=SupportBean_B() -> timer:interval(2.000) -> d=SupportBean_D())");
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCase.Add("D3", "b", events.GetEvent("B3"), "d", events.GetEvent("D3"));
testCaseList.AddTest(testCase);
// Try with an "or"
testCase = new EventExpressionCase("b=SupportBean_B() or timer:interval(1.001)");
testCase.Add("B1");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=SupportBean_B() or timer:interval(2.001)");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=SupportBean_B(Id='B3') or timer:interval(8.500)");
testCase.Add("D2");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:interval(8.500) or timer:interval(7.500)");
testCase.Add("F1");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:interval(999999 msec) or g=SupportBean_G");
testCase.Add("G1", "g", events.GetEvent("G1"));
testCaseList.AddTest(testCase);
// Try with an "and"
testCase = new EventExpressionCase("b=SupportBean_B() and timer:interval(4000 msec)");
testCase.Add("B2", "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=SupportBean_B() and timer:interval(4001 msec)");
testCase.Add("A2", "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:interval(9999999 msec) and b=SupportBean_B");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:interval(1 msec) and b=SupportBean_B(Id='B2')");
testCase.Add("B2", "b", events.GetEvent("B2"));
testCaseList.AddTest(testCase);
// Try with an "within"
testCase = new EventExpressionCase("timer:interval(3.000) where timer:within(2.000)");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("timer:interval(3.000) where timer:within (3.000)");
testCaseList.AddTest(testCase);
// Run all tests
var util = new PatternTestHarness(events, testCaseList, GetType());
util.RunTest(env);
}
private void RunAssertionOp(EPServiceProvider epService)
{
EventCollection events = EventCollectionFactory.GetEventSetOne(0, 1000);
var testCaseList = new CaseList();
EventExpressionCase testCase;
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + " and not d=" + EVENT_D_CLASS);
testCase.Add("B1", "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
string text = "select * from pattern [every b=" + EVENT_B_CLASS + " and not g=" + EVENT_G_CLASS + "]";
var model = new EPStatementObjectModel();
model.SelectClause = SelectClause.CreateWildcard();
PatternExpr pattern = Patterns.And()
.Add(Patterns.EveryFilter(EVENT_B_CLASS, "b"))
.Add(Patterns.NotFilter(EVENT_G_CLASS, "g"));
model.FromClause = FromClause.Create(PatternStream.Create(pattern));
model = (EPStatementObjectModel)SerializableObjectCopier.Copy(epService.Container, model);
Assert.AreEqual(text, model.ToEPL());
testCase = new EventExpressionCase(model);
testCase.Add("B1", "b", events.GetEvent("B1"));
testCase.Add("B2", "b", events.GetEvent("B2"));
testCase.Add("B3", "b", events.GetEvent("B3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every b=" + EVENT_B_CLASS + " and not g=" + EVENT_G_CLASS);
testCase.Add("B1", "b", events.GetEvent("B1"));
testCase.Add("B2", "b", events.GetEvent("B2"));
testCase.Add("B3", "b", events.GetEvent("B3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every b=" + EVENT_B_CLASS + " and not d=" + EVENT_D_CLASS);
testCase.Add("B1", "b", events.GetEvent("B1"));
testCase.Add("B2", "b", events.GetEvent("B2"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + " and not a=" + EVENT_A_CLASS + "(id='A1')");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("b=" + EVENT_B_CLASS + " and not a2=" + EVENT_A_CLASS + "(id='A2')");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every (b=" + EVENT_B_CLASS + " and not b3=" + EVENT_B_CLASS + "(id='B3'))");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCase.Add("B2", "b", events.GetEvent("B2"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every (b=" + EVENT_B_CLASS + " or not " + EVENT_D_CLASS + "())");
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every (every b=" + EVENT_B_CLASS + " and not " + EVENT_B_CLASS + "(id='B2'))");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCase.Add("B3", "b", events.GetEvent("B3"));
testCase.Add("B3", "b", events.GetEvent("B3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every (b=" + EVENT_B_CLASS + " and not " + EVENT_B_CLASS + "(id='B2'))");
testCase.Add("B1", "b", events.GetEvent("B1"));
testCase.Add("B3", "b", events.GetEvent("B3"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("(b=" + EVENT_B_CLASS + " -> d=" + EVENT_D_CLASS + ") and " +
" not " + EVENT_A_CLASS);
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("(b=" + EVENT_B_CLASS + " -> d=" + EVENT_D_CLASS + ") and " +
" not " + EVENT_G_CLASS);
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every (b=" + EVENT_B_CLASS + " -> d=" + EVENT_D_CLASS + ") and " +
" not " + EVENT_G_CLASS);
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCaseList.AddTest(testCase);
testCase = new EventExpressionCase("every (b=" + EVENT_B_CLASS + " -> d=" + EVENT_D_CLASS + ") and " +
" not " + EVENT_G_CLASS + "(id='x')");
testCase.Add("D1", "b", events.GetEvent("B1"), "d", events.GetEvent("D1"));
testCase.Add("D3", "b", events.GetEvent("B3"), "d", events.GetEvent("D3"));
testCaseList.AddTest(testCase);
var util = new PatternTestHarness(events, testCaseList, this.GetType());
util.RunTest(epService);
}
/// <summary>Ctor.</summary>
/// <param name="objectModel">of the statement</param>
/// <param name="substitutionParams">a map of parameter index and parameter</param>
public StatementSpecUnMapResult(EPStatementObjectModel objectModel, IList <SubstitutionParameterExpressionBase> substitutionParams)
{
_objectModel = objectModel;
_substitutionParams = substitutionParams;
}
private EPStatement TryAssertsVariant(EPServiceProvider epService, string stmtText, EPStatementObjectModel model, string typeName)
{
// Attach listener to feed
EPStatement stmt;
if (model != null)
{
stmt = epService.EPAdministrator.Create(model, "s1");
}
else
{
stmt = epService.EPAdministrator.CreateEPL(stmtText);
}
var feedListener = new SupportUpdateListener();
stmt.Events += feedListener.Update;
// send event for joins to match on
epService.EPRuntime.SendEvent(new SupportBean_A("myId"));
// Attach delta statement to statement and add listener
stmtText = "select MIN(delta) as minD, max(delta) as maxD " +
"from " + typeName + "#time(60)";
EPStatement stmtTwo = epService.EPAdministrator.CreateEPL(stmtText);
var resultListenerDelta = new SupportUpdateListener();
stmtTwo.Events += resultListenerDelta.Update;
// Attach prodict statement to statement and add listener
stmtText = "select min(product) as minP, max(product) as maxP " +
"from " + typeName + "#time(60)";
EPStatement stmtThree = epService.EPAdministrator.CreateEPL(stmtText);
var resultListenerProduct = new SupportUpdateListener();
stmtThree.Events += resultListenerProduct.Update;
epService.EPRuntime.SendEvent(new CurrentTimeEvent(0)); // Set the time to 0 seconds
// send events
SendEvent(epService, 20, 10);
AssertReceivedFeed(feedListener, 10, 200);
AssertReceivedMinMax(resultListenerDelta, resultListenerProduct, 10, 10, 200, 200);
SendEvent(epService, 50, 25);
AssertReceivedFeed(feedListener, 25, 25 * 50);
AssertReceivedMinMax(resultListenerDelta, resultListenerProduct, 10, 25, 200, 1250);
SendEvent(epService, 5, 2);
AssertReceivedFeed(feedListener, 3, 2 * 5);
AssertReceivedMinMax(resultListenerDelta, resultListenerProduct, 3, 25, 10, 1250);
epService.EPRuntime.SendEvent(new CurrentTimeEvent(10 * 1000)); // Set the time to 10 seconds
SendEvent(epService, 13, 1);
AssertReceivedFeed(feedListener, 12, 13);
AssertReceivedMinMax(resultListenerDelta, resultListenerProduct, 3, 25, 10, 1250);
epService.EPRuntime.SendEvent(new CurrentTimeEvent(61 * 1000)); // Set the time to 61 seconds
AssertReceivedMinMax(resultListenerDelta, resultListenerProduct, 12, 12, 13, 13);
return(stmt);
}
private void RunAssertionHashSegmented(EPServiceProvider epService)
{
// Comment-in to see CRC32 code.
for (int i = 0; i < 10; i++)
{
string key = "E" + i;
long code = SupportHashCodeFuncGranularCRC32.ComputeCrc32(key) % 4;
int hashCode = i.GetHashCode() % 4;
//Log.Info(key + " code " + code + " hashCode " + hashCode);
}
// test CRC32 Hash
FilterServiceSPI filterSPI = (FilterServiceSPI)((EPServiceProviderSPI)epService).FilterService;
string ctx = "HashSegmentedContext";
string eplCtx = "@Name('context') create context " + ctx + " as " +
"coalesce consistent_hash_crc32(TheString) from SupportBean " +
"granularity 4 " +
"preallocate";
epService.EPAdministrator.CreateEPL(eplCtx);
string eplStmt = "context " + ctx + " " +
"select context.name as c0, TheString as c1, sum(IntPrimitive) as c2 from SupportBean#keepall group by TheString";
EPStatementSPI statement = (EPStatementSPI)epService.EPAdministrator.CreateEPL(eplStmt);
var listener = new SupportUpdateListener();
statement.Events += listener.Update;
Assert.AreEqual(4, filterSPI.FilterCountApprox);
AgentInstanceAssertionUtil.AssertInstanceCounts(statement.StatementContext, 4, 0, 0, 0);
TryAssertionHash(epService, listener, ctx, statement, new SupportHashCodeFuncGranularCRC32(4).CodeFor);
Assert.AreEqual(0, filterSPI.FilterCountApprox);
// test same with SODA
EPStatementObjectModel modelCtx = epService.EPAdministrator.CompileEPL(eplCtx);
Assert.AreEqual(eplCtx, modelCtx.ToEPL());
EPStatement stmtCtx = epService.EPAdministrator.Create(modelCtx);
Assert.AreEqual(eplCtx, stmtCtx.Text);
statement = (EPStatementSPI)epService.EPAdministrator.CreateEPL(eplStmt);
statement.Events += listener.Update;
TryAssertionHash(epService, listener, ctx, statement, new SupportHashCodeFuncGranularCRC32(4).CodeFor);
// test with Java-hashCode string hash
epService.EPAdministrator.CreateEPL("@Name('context') create context " + ctx + " " +
"coalesce hash_code(TheString) from SupportBean " +
"granularity 6 " +
"preallocate");
statement = (EPStatementSPI)epService.EPAdministrator.CreateEPL("context " + ctx + " " +
"select context.name as c0, TheString as c1, sum(IntPrimitive) as c2 from SupportBean#keepall group by TheString");
statement.Events += listener.Update;
Assert.AreEqual(6, filterSPI.FilterCountApprox);
AgentInstanceAssertionUtil.AssertInstanceCounts(statement.StatementContext, 6, 0, 0, 0);
TryAssertionHash(epService, listener, ctx, statement, HashCodeFuncGranularInternalHash(6));
Assert.AreEqual(0, filterSPI.FilterCountApprox);
// test no pre-allocate
epService.EPAdministrator.CreateEPL("@Name('context') create context " + ctx + " " +
"coalesce hash_code(TheString) from SupportBean " +
"granularity 16 ");
statement = (EPStatementSPI)epService.EPAdministrator.CreateEPL("context " + ctx + " " +
"select context.name as c0, TheString as c1, sum(IntPrimitive) as c2 from SupportBean#keepall group by TheString");
statement.Events += listener.Update;
Assert.AreEqual(1, filterSPI.FilterCountApprox);
AgentInstanceAssertionUtil.AssertInstanceCounts(statement.StatementContext, 0, 0, 0, 0);
TryAssertionHash(epService, listener, ctx, statement, HashCodeFuncGranularInternalHash(16));
Assert.AreEqual(0, filterSPI.FilterCountApprox);
}
