private void SendEventAssert( EPServiceProviderIsolated isolated, SupportUpdateListener listener, string theString, int intPrimitive, string[] fields, object[] expected) { isolated.EPRuntime.SendEvent(new SupportBean(theString, intPrimitive)); EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, expected); }
private void AssertSendNoMoreCallback(EPServiceProviderIsolated iso, string time) { SendCurrentTime(iso, time); Assert.IsFalse(_listener.IsInvokedAndReset()); SendCurrentTime(iso, "2999-01-01T00:00:00.000GMT-0:00"); Assert.IsFalse(_listener.IsInvokedAndReset()); }
private void RunAssertion_A_B_Cstar(EPServiceProvider epService) { EPServiceProviderIsolated isolated = epService.GetEPServiceIsolated("I1"); SendTimer(isolated, 0); string[] fields = "a,b,c0,c1,c2".Split(','); string text = "select * from MyEvent#keepall " + "match_recognize (" + " measures A.TheString as a, B.TheString as b, " + "C[0].TheString as c0, C[1].TheString as c1, C[2].TheString as c2 " + " pattern (A B C*)" + " interval 10 seconds or terminated" + " define" + " A as A.TheString like 'A%'," + " B as B.TheString like 'B%'," + " C as C.TheString like 'C%'" + ")"; EPStatement stmt = isolated.EPAdministrator.CreateEPL(text, "stmt1", null); var listener = new SupportUpdateListener(); stmt.Events += listener.Update; isolated.EPRuntime.SendEvent(new SupportRecogBean("A1")); isolated.EPRuntime.SendEvent(new SupportRecogBean("B1")); isolated.EPRuntime.SendEvent(new SupportRecogBean("C1")); isolated.EPRuntime.SendEvent(new SupportRecogBean("C2")); Assert.IsFalse(listener.IsInvoked); isolated.EPRuntime.SendEvent(new SupportRecogBean("B2")); EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { "A1", "B1", "C1", "C2", null }); isolated.EPRuntime.SendEvent(new SupportRecogBean("A2")); isolated.EPRuntime.SendEvent(new SupportRecogBean("X1")); isolated.EPRuntime.SendEvent(new SupportRecogBean("B3")); isolated.EPRuntime.SendEvent(new SupportRecogBean("X2")); Assert.IsFalse(listener.IsInvoked); isolated.EPRuntime.SendEvent(new SupportRecogBean("A3")); isolated.EPRuntime.SendEvent(new SupportRecogBean("B4")); isolated.EPRuntime.SendEvent(new SupportRecogBean("X3")); EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { "A3", "B4", null, null, null }); SendTimer(isolated, 20000); isolated.EPRuntime.SendEvent(new SupportRecogBean("A4")); isolated.EPRuntime.SendEvent(new SupportRecogBean("B5")); isolated.EPRuntime.SendEvent(new SupportRecogBean("C3")); Assert.IsFalse(listener.IsInvoked); SendTimer(isolated, 30000); EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { "A4", "B5", "C3", null, null }); SendTimer(isolated, int.MaxValue); Assert.IsFalse(listener.IsInvoked); // destroy stmt.Dispose(); isolated.Dispose(); }
private void RunAssertion_A_B() { EPServiceProviderIsolated isolated = _epService.GetEPServiceIsolated("I1"); SendTimer(isolated, 0); // the interval is not effective String[] fields = "a,b".Split(','); String text = "select * from MyEvent#keepall " + "match_recognize (" + " measures A.TheString as a, B.TheString as b" + " pattern (A B)" + " interval 10 seconds or terminated" + " define" + " A as A.TheString like 'A%'," + " B as B.TheString like 'B%'" + ")"; EPStatement stmt = isolated.EPAdministrator.CreateEPL(text, "stmt1", null); stmt.Events += _listener.Update; isolated.EPRuntime.SendEvent(new SupportRecogBean("A1")); isolated.EPRuntime.SendEvent(new SupportRecogBean("B1")); EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "A1", "B1" }); isolated.EPRuntime.SendEvent(new SupportRecogBean("A2")); isolated.EPRuntime.SendEvent(new SupportRecogBean("A3")); isolated.EPRuntime.SendEvent(new SupportRecogBean("B2")); EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "A3", "B2" }); // destroy stmt.Dispose(); isolated.Dispose(); }
private void RunAssertionDestroy(EPServiceProvider epService) { if (SupportConfigFactory.SkipTest(typeof(ExecClientIsolationUnit))) { return; } EPStatement stmtOne = epService.EPAdministrator.CreateEPL("@Name('A') select * from SupportBean", null, null); var listener = new SupportUpdateListener(); stmtOne.Events += listener.Update; EPServiceProviderIsolated unit = epService.GetEPServiceIsolated("i1"); EPStatement stmtTwo = unit.EPAdministrator.CreateEPL("@Name('B') select * from SupportBean", null, null); stmtTwo.Events += listener.Update; unit.EPAdministrator.AddStatement(stmtOne); unit.EPRuntime.SendEvent(new SupportBean()); Assert.AreEqual(2, listener.GetNewDataListFlattened().Length); listener.Reset(); unit.Dispose(); unit.EPRuntime.SendEvent(new SupportBean()); Assert.AreEqual(0, listener.GetNewDataListFlattened().Length); listener.Reset(); epService.EPRuntime.SendEvent(new SupportBean()); Assert.AreEqual(2, listener.GetNewDataListFlattened().Length); stmtOne.Dispose(); stmtTwo.Dispose(); }
public void TestDestroy() { EPStatement stmtOne = _epService.EPAdministrator.CreateEPL( "@Name('A') select * from SupportBean", null, null); stmtOne.Events += _listener.Update; EPServiceProviderIsolated unit = _epService.GetEPServiceIsolated("i1"); EPStatement stmtTwo = unit.EPAdministrator.CreateEPL( "@Name('B') select * from SupportBean", null, null); stmtTwo.Events += _listener.Update; unit.EPAdministrator.AddStatement(stmtOne); unit.EPRuntime.SendEvent(new SupportBean()); Assert.AreEqual(2, _listener.GetNewDataListFlattened().Length); _listener.Reset(); unit.Dispose(); unit.EPRuntime.SendEvent(new SupportBean()); Assert.AreEqual(0, _listener.GetNewDataListFlattened().Length); _listener.Reset(); _epService.EPRuntime.SendEvent(new SupportBean()); Assert.AreEqual(2, _listener.GetNewDataListFlattened().Length); _listener.Reset(); }
private void RunAssertionOutputLimit(EPServiceProvider epService, long startTime, string size, long flipTime, long repeatTime) { EPServiceProviderIsolated isolated = epService.GetEPServiceIsolated("isolated"); isolated.EPRuntime.SendEvent(new CurrentTimeEvent(startTime)); var listener = new SupportUpdateListener(); EPStatement stmt = isolated.EPAdministrator.CreateEPL("select * from SupportBean output every " + size + " seconds", "s0", null); stmt.Events += listener.Update; isolated.EPRuntime.SendEvent(new SupportBean("E1", 10)); isolated.EPRuntime.SendEvent(new CurrentTimeEvent(flipTime - 1)); Assert.IsFalse(listener.IsInvoked); isolated.EPRuntime.SendEvent(new CurrentTimeEvent(flipTime)); Assert.IsTrue(listener.IsInvokedAndReset()); isolated.EPRuntime.SendEvent(new SupportBean("E2", 10)); isolated.EPRuntime.SendEvent(new CurrentTimeEvent(repeatTime + flipTime - 1)); Assert.IsFalse(listener.IsInvoked); isolated.EPRuntime.SendEvent(new CurrentTimeEvent(repeatTime + flipTime)); Assert.IsTrue(listener.IsInvokedAndReset()); isolated.Dispose(); }
private void RunAssertionRecurringAnchoring() { EPServiceProviderIsolated iso = _epService.GetEPServiceIsolated("E1"); // Repeat unlimited number of times, reference-dated to "1980-01-01T00:00:00Z" (UTC), period of 1 second SendCurrentTime(iso, "2012-01-01T00:00:00.000GMT-0:00"); string epl = "select * from pattern[every timer:schedule(iso: 'R/PT10S')]"; iso.EPAdministrator.CreateEPL(epl, null, null).AddListener(_listener); SendCurrentTime(iso, "2012-01-01T00:00:15.000GMT-0:00"); Assert.IsTrue(_listener.IsInvokedAndReset()); SendCurrentTime(iso, "2012-01-01T00:00:20.000GMT-0:00"); Assert.IsTrue(_listener.IsInvokedAndReset()); AssertReceivedAtTime(iso, "2012-01-01T00:00:30.000GMT-0:00"); SendCurrentTime(iso, "2012-01-01T00:00:55.000GMT-0:00"); Assert.IsTrue(_listener.IsInvokedAndReset()); AssertReceivedAtTime(iso, "2012-01-01T00:01:00.000GMT-0:00"); _epService.EPAdministrator.DestroyAllStatements(); iso.Dispose(); }
private SupportBean MakeSendEvent(EPServiceProviderIsolated iso, string theString, int intPrimitive) { SupportBean b = new SupportBean(theString, intPrimitive); iso.EPRuntime.SendEvent(b); return(b); }
private void RunAssertionPattern(EPServiceProvider epService, long startTime, string patternExpr, params long[] flipTimes) { EPServiceProviderIsolated isolated = epService.GetEPServiceIsolated("iso"); isolated.EPRuntime.SendEvent(new CurrentTimeEvent(startTime)); SupportUpdateListener listener = new SupportUpdateListener(); EPStatement stmt = isolated.EPAdministrator.CreateEPL("select * from pattern[" + patternExpr + "]", "s0", null); stmt.AddListener(listener); int count = 0; foreach (long flipTime in flipTimes) { isolated.EPRuntime.SendEvent(new CurrentTimeEvent(flipTime - 1)); Assert.IsFalse(listener.GetAndClearIsInvoked(), "Failed for flip " + count); isolated.EPRuntime.SendEvent(new CurrentTimeEvent(flipTime)); Assert.IsTrue(listener.GetAndClearIsInvoked(), "Failed for flip " + count); count++; } isolated.EPRuntime.SendEvent(new CurrentTimeEvent(long.MaxValue)); Assert.IsFalse(listener.GetAndClearIsInvoked()); isolated.Dispose(); }
private void RunAssertionFollowedBy() { EPServiceProviderIsolated iso = _epService.GetEPServiceIsolated("E1"); SendCurrentTime(iso, "2012-10-01T05:51:07.000GMT-0:00"); string epl = "select * from pattern[every sb=SupportBean -> timer:schedule(iso: 'R/1980-01-01T00:00:00Z/PT15S')]"; iso.EPAdministrator.CreateEPL(epl, null, null).AddListener(_listener); SupportBean b1 = MakeSendEvent(iso, "E1"); SendCurrentTime(iso, "2012-10-01T05:51:14.999GMT-0:00"); Assert.IsFalse(_listener.IsInvokedAndReset()); SendCurrentTime(iso, "2012-10-01T05:51:15.000GMT-0:00"); Assert.AreEqual(b1, _listener.AssertOneGetNewAndReset().Get("sb")); SendCurrentTime(iso, "2012-10-01T05:51:16.000GMT-0:00"); SupportBean b2 = MakeSendEvent(iso, "E2"); SendCurrentTime(iso, "2012-10-01T05:51:18.000GMT-0:00"); SupportBean b3 = MakeSendEvent(iso, "E3"); SendCurrentTime(iso, "2012-10-01T05:51:30.000GMT-0:00"); EPAssertionUtil.AssertPropsPerRow(_listener.GetAndResetLastNewData(), "sb".Split(','), new object[][] { new object[] { b2 }, new object[] { b3 } }); _epService.EPAdministrator.DestroyAllStatements(); iso.Dispose(); }
private void RunAssertionWithTime(EPServiceProvider epService, long startTime, long flipTime) { EPServiceProviderIsolated isolated = epService.GetEPServiceIsolated("isolated"); isolated.EPRuntime.SendEvent(new CurrentTimeEvent(startTime)); string text = "select * from SupportBean " + "match_recognize (" + " measures A as a" + " pattern (A*)" + " interval 10 seconds" + ")"; EPStatement stmt = isolated.EPAdministrator.CreateEPL(text, "s0", null); var listener = new SupportUpdateListener(); stmt.Events += listener.Update; isolated.EPRuntime.SendEvent(new SupportBean("E1", 1)); isolated.EPRuntime.SendEvent(new CurrentTimeEvent(flipTime - 1)); Assert.IsFalse(listener.IsInvokedAndReset()); isolated.EPRuntime.SendEvent(new CurrentTimeEvent(flipTime)); Assert.IsTrue(listener.IsInvokedAndReset()); isolated.Dispose(); }
private void RunAssertionFullFormUnlimitedPastDatedAnchoring(EPServiceProvider epService) { EPServiceProviderIsolated iso = epService.GetEPServiceIsolated("E1"); // Repeat unlimited number of times, reference-dated to "1980-01-01T00:00:00Z" (UTC), period of 1 second SendCurrentTime(iso, "2012-01-01T00:0:00.000GMT-0:00"); string epl = "select * from pattern[every timer:schedule(iso:'R/1980-01-01T00:00:00Z/PT10S')]"; var listener = new SupportUpdateListener(); iso.EPAdministrator.CreateEPL(epl, null, null).Events += listener.Update; SendCurrentTime(iso, "2012-01-01T00:0:15.000GMT-0:00"); Assert.IsTrue(listener.IsInvokedAndReset()); SendCurrentTime(iso, "2012-01-01T00:0:20.000GMT-0:00"); Assert.IsTrue(listener.IsInvokedAndReset()); AssertReceivedAtTime(listener, iso, "2012-01-01T00:0:30.000GMT-0:00"); SendCurrentTime(iso, "2012-01-01T00:0:55.000GMT-0:00"); Assert.IsTrue(listener.IsInvokedAndReset()); AssertReceivedAtTime(listener, iso, "2012-01-01T00:1:00.000GMT-0:00"); epService.EPAdministrator.DestroyAllStatements(); iso.Dispose(); }
public void TestIsolateFilter() { EPStatement stmt = _epService.EPAdministrator.CreateEPL( "select * from pattern [every a=SupportBean -> b=SupportBean(TheString=a.TheString)]"); stmt.Events += _listener.Update; _epService.EPRuntime.SendEvent(new SupportBean("E1", 1)); Assert.IsFalse(_listener.GetAndClearIsInvoked()); EPServiceProviderIsolated unit = _epService.GetEPServiceIsolated("i1"); EPAssertionUtil.AssertEqualsAnyOrder(new string[] { "i1" }, _epService.EPServiceIsolatedNames); // send fake to wrong place unit.EPRuntime.SendEvent(new SupportBean("E1", -1)); unit.EPAdministrator.AddStatement(stmt); // send to 'wrong' engine _epService.EPRuntime.SendEvent(new SupportBean("E1", 2)); Assert.IsFalse(_listener.GetAndClearIsInvoked()); // send to 'right' engine unit.EPRuntime.SendEvent(new SupportBean("E1", 3)); EPAssertionUtil.AssertProps( _listener.AssertOneGetNewAndReset(), "a.TheString,a.IntPrimitive,b.IntPrimitive".Split(','), new Object[] { "E1", 1, 3 } ); // send second pair, and a fake to the wrong place unit.EPRuntime.SendEvent(new SupportBean("E2", 4)); _epService.EPRuntime.SendEvent(new SupportBean("E2", -1)); unit.EPAdministrator.RemoveStatement(stmt); // send to 'wrong' engine unit.EPRuntime.SendEvent(new SupportBean("E2", 5)); Assert.IsFalse(_listener.GetAndClearIsInvoked()); // send to 'right' engine _epService.EPRuntime.SendEvent(new SupportBean("E2", 6)); EPAssertionUtil.AssertProps( _listener.AssertOneGetNewAndReset(), "a.TheString,a.IntPrimitive,b.IntPrimitive".Split(','), new Object[] { "E2", 4, 6 } ); _epService.EPAdministrator.DestroyAllStatements(); EPAssertionUtil.AssertEqualsAnyOrder(new string[] { "i1" }, _epService.EPServiceIsolatedNames); _epService.GetEPServiceIsolated("i1").Dispose(); EPAssertionUtil.AssertEqualsAnyOrder(new string[0], _epService.EPServiceIsolatedNames); }
private void RunAssertionCurrentTimestamp(EPServiceProvider epService) { if (SupportConfigFactory.SkipTest(typeof(ExecClientIsolationUnit))) { return; } SendTimerUnisolated(epService, 5000); var fields = new string[] { "ct" }; EPStatement stmt = epService.EPAdministrator.CreateEPL("select current_timestamp() as ct from SupportBean"); var listener = new SupportUpdateListener(); stmt.Events += listener.Update; epService.EPRuntime.SendEvent(new SupportBean()); EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { 5000L }); EPServiceProviderIsolated unit = epService.GetEPServiceIsolated("i1"); SendTimerIso(100000, unit); unit.EPAdministrator.AddStatement(new EPStatement[] { stmt }); unit.EPRuntime.SendEvent(new SupportBean()); EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { 100000L }); epService.EPAdministrator.DestroyAllStatements(); stmt = epService.EPAdministrator.CreateEPL("select TheString as ct from SupportBean where current_timestamp() >= 10000"); stmt.Events += listener.Update; unit.EPRuntime.SendEvent(new SupportBean()); Assert.IsFalse(listener.IsInvoked); SendTimerUnisolated(epService, 10000); epService.EPRuntime.SendEvent(new SupportBean("E1", 1)); EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { "E1" }); unit.EPAdministrator.AddStatement(stmt); unit.EPRuntime.SendEvent(new SupportBean("E2", 1)); EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { "E2" }); stmt.Dispose(); stmt = epService.EPAdministrator.CreateEPL("select TheString as ct from SupportBean where current_timestamp() >= 120000"); stmt.Events += listener.Update; unit.EPAdministrator.AddStatement(new EPStatement[] { stmt }); unit.EPRuntime.SendEvent(new SupportBean("E3", 1)); Assert.IsFalse(listener.IsInvoked); SendTimerIso(120000, unit); unit.EPRuntime.SendEvent(new SupportBean("E4", 1)); EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { "E4" }); unit.Dispose(); epService.EPAdministrator.DestroyAllStatements(); }
public void TestEventSender() { EPServiceProviderIsolated unit = _epService.GetEPServiceIsolated("i1"); EventSender sender = unit.EPRuntime.GetEventSender("SupportBean"); _epService.EPAdministrator.CreateEPL("select * from SupportBean").Events += _listener.Update; sender.SendEvent(new SupportBean()); var testProp = _listener.IsInvoked; }
private void RunAssertionNamedWindowTakeCreate(EPServiceProvider epService) { if (SupportConfigFactory.SkipTest(typeof(ExecClientIsolationUnit))) { return; } var fields = new string[] { "TheString" }; EPStatement stmtCreate = epService.EPAdministrator.CreateEPL("@Name('create') create window MyWindow#keepall as SupportBean"); EPStatement stmtInsert = epService.EPAdministrator.CreateEPL("@Name('insert') insert into MyWindow select * from SupportBean"); EPStatement stmtDelete = epService.EPAdministrator.CreateEPL("@Name('delete') on SupportBean_A delete from MyWindow where TheString = id"); EPStatement stmtConsume = epService.EPAdministrator.CreateEPL("@Name('consume') select irstream * from MyWindow"); var listener = new SupportUpdateListener(); stmtConsume.Events += listener.Update; epService.EPRuntime.SendEvent(new SupportBean("E1", 0)); EPAssertionUtil.AssertPropsPerRowAnyOrder(stmtCreate.GetEnumerator(), fields, new object[][] { new object[] { "E1" } }); EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { "E1" }); EPServiceProviderIsolated unit = epService.GetEPServiceIsolated("i1"); unit.EPAdministrator.AddStatement(epService.EPAdministrator.GetStatement("create")); epService.EPRuntime.SendEvent(new SupportBean("E2", 0)); unit.EPRuntime.SendEvent(new SupportBean("E3", 0)); EPAssertionUtil.AssertPropsPerRowAnyOrder(stmtCreate.GetEnumerator(), fields, new object[][] { new object[] { "E1" } }); Assert.IsFalse(listener.IsInvoked); unit.EPAdministrator.AddStatement(stmtInsert); epService.EPRuntime.SendEvent(new SupportBean("E4", 0)); unit.EPRuntime.SendEvent(new SupportBean("E5", 0)); EPAssertionUtil.AssertPropsPerRowAnyOrder(stmtCreate.GetEnumerator(), fields, new object[][] { new object[] { "E1" }, new object[] { "E5" } }); EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { "E5" }); // yes receives it // Note: Named window is global across isolation units: they are a relation and not a stream. // The insert-into to a named window is a stream that can be isolated from the named window. // The streams of on-select and on-delete can be isolated, however they select or change the named window even if that is isolated. // Consumers to a named window always receive all changes to a named window (regardless of whether the consuming statement is isolated or not), even if the window itself was isolated. // epService.EPRuntime.SendEvent(new SupportBean_A("E1")); EPAssertionUtil.AssertPropsPerRowAnyOrder(stmtCreate.GetEnumerator(), fields, new object[][] { new object[] { "E5" } }); unit.EPAdministrator.AddStatement(stmtDelete); epService.EPRuntime.SendEvent(new SupportBean_A("E5")); EPAssertionUtil.AssertPropsPerRowAnyOrder(stmtCreate.GetEnumerator(), fields, new object[][] { new object[] { "E5" } }); unit.EPRuntime.SendEvent(new SupportBean_A("E5")); EPAssertionUtil.AssertPropsPerRowAnyOrder(stmtCreate.GetEnumerator(), fields, null); unit.Dispose(); epService.EPAdministrator.DestroyAllStatements(); }
public void TestUpdate() { SendTimerUnisolated(5000); var fields = new String[] { "TheString" }; EPStatement stmtInsert = _epService.EPAdministrator.CreateEPL( "insert into NewStream select * from SupportBean"); EPStatement stmtUpd = _epService.EPAdministrator.CreateEPL( "Update istream NewStream set TheString = 'X'"); EPStatement stmtSelect = _epService.EPAdministrator.CreateEPL( "select * from NewStream"); stmtSelect.Events += _listener.Update; _epService.EPRuntime.SendEvent(new SupportBean()); EPAssertionUtil.AssertProps( _listener.AssertOneGetNewAndReset(), fields, new Object[] { "X" }); EPServiceProviderIsolated unit = _epService.GetEPServiceIsolated("i1"); unit.EPAdministrator.AddStatement(new EPStatement[] { stmtSelect }); unit.EPRuntime.SendEvent(new SupportBean()); Assert.IsFalse(_listener.IsInvoked); // Update statements apply to a stream even if the statement is not isolated. unit.EPAdministrator.AddStatement(new EPStatement[] { stmtInsert }); unit.EPRuntime.SendEvent(new SupportBean("E1", 0)); EPAssertionUtil.AssertProps( _listener.AssertOneGetNewAndReset(), fields, new Object[] { "X" }); unit.EPAdministrator.AddStatement(stmtUpd); unit.EPRuntime.SendEvent(new SupportBean("E2", 0)); EPAssertionUtil.AssertProps( _listener.AssertOneGetNewAndReset(), fields, new Object[] { "X" }); stmtUpd.Stop(); unit.EPRuntime.SendEvent(new SupportBean("E3", 0)); EPAssertionUtil.AssertProps( _listener.AssertOneGetNewAndReset(), fields, new Object[] { "E3" }); _epService.EPAdministrator.DestroyAllStatements(); }
private void RunAssertionInvalid(EPServiceProvider epService) { if (SupportConfigFactory.SkipTest(typeof(ExecClientIsolationUnit))) { return; } EPStatement stmt = epService.EPAdministrator.CreateEPL("@Name('A') select * from SupportBean"); EPServiceProviderIsolated unitOne = epService.GetEPServiceIsolated("i1"); EPServiceProviderIsolated unitTwo = epService.GetEPServiceIsolated("i2"); unitOne.EPRuntime.SendEvent(new TimerControlEvent(TimerControlEvent.ClockTypeEnum.CLOCK_INTERNAL)); unitOne.EPRuntime.SendEvent(new TimerControlEvent(TimerControlEvent.ClockTypeEnum.CLOCK_EXTERNAL)); unitOne.EPAdministrator.AddStatement(stmt); try { unitTwo.EPAdministrator.AddStatement(stmt); Assert.Fail(); } catch (EPServiceIsolationException ex) { Assert.AreEqual("Statement named 'A' already in service isolation under 'i1'", ex.Message); } try { unitTwo.EPAdministrator.RemoveStatement(stmt); Assert.Fail(); } catch (EPServiceIsolationException ex) { Assert.AreEqual("Statement named 'A' not in this service isolation but under service isolation 'A'", ex.Message); } unitOne.EPAdministrator.RemoveStatement(stmt); try { unitOne.EPAdministrator.RemoveStatement(stmt); Assert.Fail(); } catch (EPServiceIsolationException ex) { Assert.AreEqual("Statement named 'A' is not currently in service isolation", ex.Message); } try { unitTwo.EPAdministrator.RemoveStatement(new EPStatement[] { null }); Assert.Fail(); } catch (EPServiceIsolationException ex) { Assert.AreEqual("Illegal argument, a null value was provided in the statement list", ex.Message); } try { unitTwo.EPAdministrator.AddStatement(new EPStatement[] { null }); Assert.Fail(); } catch (EPServiceIsolationException ex) { Assert.AreEqual("Illegal argument, a null value was provided in the statement list", ex.Message); } stmt.Dispose(); unitOne.Dispose(); unitTwo.Dispose(); }
private void AssertReceivedAtTime(EPServiceProviderIsolated iso, string time) { long msec = DateTimeParser.ParseDefaultMSecWZone(time); iso.EPRuntime.SendEvent(new CurrentTimeEvent(msec - 1)); Assert.IsFalse(_listener.IsInvokedAndReset()); iso.EPRuntime.SendEvent(new CurrentTimeEvent(msec)); Assert.IsTrue(_listener.IsInvokedAndReset(), "expected but not received at " + time); }
private void RunSequenceIsolated(EPServiceProvider epService, String startTime, String epl, String[] times) { EPServiceProviderIsolated isolated = epService.GetEPServiceIsolated("i1"); SendTime(isolated, startTime); isolated.EPAdministrator.CreateEPL(epl, "S0", null).Events += _listener.Update; RunSequence(isolated, times); epService.EPAdministrator.DestroyAllStatements(); isolated.Dispose(); }
private void RunAssertionNextScheduledTime(EPServiceProvider epService) { EPRuntimeSPI runtimeSPI = (EPRuntimeSPI)epService.EPRuntime; epService.EPRuntime.SendEvent(new CurrentTimeEvent(0)); Assert.IsNull(epService.EPRuntime.NextScheduledTime); AssertSchedules(runtimeSPI.StatementNearestSchedules, new Object[0][]); EPStatement stmtOne = epService.EPAdministrator.CreateEPL("select * from pattern[timer:interval(2 sec)]"); Assert.AreEqual(2000L, (long)epService.EPRuntime.NextScheduledTime); AssertSchedules(runtimeSPI.StatementNearestSchedules, new object[][] { new object[] { stmtOne.Name, 2000L } }); EPStatement stmtTwo = epService.EPAdministrator.CreateEPL("@Name('s2') select * from pattern[timer:interval(150 msec)]"); Assert.AreEqual(150L, (long)epService.EPRuntime.NextScheduledTime); AssertSchedules(runtimeSPI.StatementNearestSchedules, new object[][] { new object[] { "s2", 150L }, new object[] { stmtOne.Name, 2000L } }); stmtTwo.Dispose(); Assert.AreEqual(2000L, (long)epService.EPRuntime.NextScheduledTime); AssertSchedules(runtimeSPI.StatementNearestSchedules, new object[][] { new object[] { stmtOne.Name, 2000L } }); EPStatement stmtThree = epService.EPAdministrator.CreateEPL("select * from pattern[timer:interval(3 sec) and timer:interval(4 sec)]"); Assert.AreEqual(2000L, (long)epService.EPRuntime.NextScheduledTime); AssertSchedules(runtimeSPI.StatementNearestSchedules, new object[][] { new object[] { stmtOne.Name, 2000L }, new object[] { stmtThree.Name, 3000L } }); epService.EPRuntime.SendEvent(new CurrentTimeEvent(2500)); Assert.AreEqual(3000L, (long)epService.EPRuntime.NextScheduledTime); AssertSchedules(runtimeSPI.StatementNearestSchedules, new object[][] { new object[] { stmtThree.Name, 3000L } }); epService.EPRuntime.SendEvent(new CurrentTimeEvent(3500)); Assert.AreEqual(4000L, (long)epService.EPRuntime.NextScheduledTime); AssertSchedules(runtimeSPI.StatementNearestSchedules, new object[][] { new object[] { stmtThree.Name, 4000L } }); epService.EPRuntime.SendEvent(new CurrentTimeEvent(4500)); Assert.AreEqual(null, epService.EPRuntime.NextScheduledTime); AssertSchedules(runtimeSPI.StatementNearestSchedules, new Object[0][]); // test isolated service EPServiceProviderIsolated isolated = epService.GetEPServiceIsolated("I1"); EPRuntimeIsolatedSPI isolatedSPI = (EPRuntimeIsolatedSPI)isolated.EPRuntime; isolated.EPRuntime.SendEvent(new CurrentTimeEvent(0)); Assert.IsNull(isolated.EPRuntime.NextScheduledTime); AssertSchedules(isolatedSPI.StatementNearestSchedules, new Object[0][]); EPStatement stmtFour = isolated.EPAdministrator.CreateEPL("select * from pattern[timer:interval(2 sec)]", null, null); Assert.AreEqual(2000L, (long)isolatedSPI.NextScheduledTime); AssertSchedules(isolatedSPI.StatementNearestSchedules, new object[][] { new object[] { stmtFour.Name, 2000L } }); isolated.Dispose(); epService.EPAdministrator.DestroyAllStatements(); }
public void TestMovePattern() { EPServiceProviderIsolated isolatedService = _epService.GetEPServiceIsolated("Isolated"); EPStatement stmt = isolatedService.EPAdministrator.CreateEPL("select * from pattern [every (a=SupportBean -> b=SupportBean(theString=a.theString)) where timer:within(1 day)]", "TestStatement", null); isolatedService.EPRuntime.SendEvent(new CurrentTimeEvent(DateTimeHelper.CurrentTimeMillis + 1000)); isolatedService.EPRuntime.SendEvent(new SupportBean("E1", 1)); stmt.AddListener(_listener); isolatedService.EPAdministrator.RemoveStatement(stmt); _epService.EPRuntime.SendEvent(new SupportBean("E1", 2)); Assert.IsTrue(_listener.IsInvokedAndReset()); }
public void TestIsolatedSchedule() { SendTimerUnisolated(100000); EPStatement stmt = _epService.EPAdministrator.CreateEPL( "select * from pattern [every a=SupportBean -> timer:interval(10)]"); stmt.Events += _listener.Update; SendTimerUnisolated(105000); _epService.EPRuntime.SendEvent(new SupportBean("E1", 1)); EPServiceProviderIsolated unit = _epService.GetEPServiceIsolated("i1"); SendTimerIso(0, unit); unit.EPAdministrator.AddStatement(stmt); SendTimerIso(9999, unit); Assert.IsFalse(_listener.IsInvoked); SendTimerIso(10000, unit); EPAssertionUtil.AssertProps( _listener.AssertOneGetNewAndReset(), "a.TheString".Split(','), new Object[] { "E1" } ); SendTimerIso(11000, unit); unit.EPRuntime.SendEvent(new SupportBean("E2", 1)); SendTimerUnisolated(120000); Assert.IsFalse(_listener.IsInvoked); unit.EPAdministrator.RemoveStatement(stmt); SendTimerUnisolated(129999); Assert.IsFalse(_listener.IsInvoked); SendTimerUnisolated(130000); EPAssertionUtil.AssertProps( _listener.AssertOneGetNewAndReset(), "a.TheString".Split(','), new Object[] { "E2" } ); SendTimerIso(30000, unit); Assert.IsFalse(_listener.IsInvoked); _epService.EPAdministrator.DestroyAllStatements(); }
private void RunAssertionSendTimeSpanIsolated(EPServiceProvider epService) { EPServiceProviderIsolated isolated = epService.GetEPServiceIsolated("I1"); isolated.EPRuntime.SendEvent(new CurrentTimeEvent(0)); EPStatement stmtOne = isolated.EPAdministrator.CreateEPL("select current_timestamp() as ct from pattern[every timer:interval(1.5 sec)]", null, null); var listener = new SupportUpdateListener(); stmtOne.Events += listener.Update; isolated.EPRuntime.SendEvent(new CurrentTimeSpanEvent(3500)); Assert.AreEqual(2, listener.NewDataList.Count); Assert.AreEqual(1500L, listener.NewDataList[0][0].Get("ct")); Assert.AreEqual(3000L, listener.NewDataList[1][0].Get("ct")); listener.Reset(); isolated.EPRuntime.SendEvent(new CurrentTimeSpanEvent(4500)); Assert.AreEqual(1, listener.NewDataList.Count); Assert.AreEqual(4500L, listener.NewDataList[0][0].Get("ct")); listener.Reset(); isolated.EPRuntime.SendEvent(new CurrentTimeSpanEvent(9000)); Assert.AreEqual(3, listener.NewDataList.Count); Assert.AreEqual(6000L, listener.NewDataList[0][0].Get("ct")); Assert.AreEqual(7500L, listener.NewDataList[1][0].Get("ct")); Assert.AreEqual(9000L, listener.NewDataList[2][0].Get("ct")); listener.Reset(); isolated.EPRuntime.SendEvent(new CurrentTimeSpanEvent(10499)); Assert.AreEqual(0, listener.NewDataList.Count); isolated.EPRuntime.SendEvent(new CurrentTimeSpanEvent(10499)); Assert.AreEqual(10499, isolated.EPRuntime.CurrentTime); Assert.AreEqual(0, listener.NewDataList.Count); isolated.EPRuntime.SendEvent(new CurrentTimeSpanEvent(10500)); Assert.AreEqual(1, listener.NewDataList.Count); Assert.AreEqual(10500L, listener.NewDataList[0][0].Get("ct")); listener.Reset(); isolated.EPRuntime.SendEvent(new CurrentTimeSpanEvent(10500)); Assert.AreEqual(0, listener.NewDataList.Count); isolated.EPRuntime.SendEvent(new CurrentTimeSpanEvent(14000, 200)); Assert.AreEqual(14000, isolated.EPRuntime.CurrentTime); Assert.AreEqual(2, listener.NewDataList.Count); Assert.AreEqual(12100L, listener.NewDataList[0][0].Get("ct")); Assert.AreEqual(13700L, listener.NewDataList[1][0].Get("ct")); isolated.Dispose(); epService.EPAdministrator.DestroyAllStatements(); }
private void RunAssertionInsertInto(EPServiceProvider epService) { if (SupportConfigFactory.SkipTest(typeof(ExecClientIsolationUnit))) { return; } EPStatement stmtInsert = epService.EPAdministrator.CreateEPL("insert into MyStream select * from SupportBean"); var listenerInsert = new SupportUpdateListener(); stmtInsert.Events += listenerInsert.Update; EPStatement stmtSelect = epService.EPAdministrator.CreateEPL("select * from MyStream"); var listenerSelect = new SupportUpdateListener(); stmtSelect.Events += listenerSelect.Update; // unit takes "insert" EPServiceProviderIsolated unit = epService.GetEPServiceIsolated("i1"); unit.EPAdministrator.AddStatement(stmtInsert); epService.EPRuntime.SendEvent(new SupportBean("E1", 1)); Assert.IsFalse(listenerSelect.GetAndClearIsInvoked()); Assert.IsFalse(listenerInsert.GetAndClearIsInvoked()); unit.EPRuntime.SendEvent(new SupportBean("E2", 2)); Assert.IsFalse(listenerSelect.GetAndClearIsInvoked()); EPAssertionUtil.AssertProps(listenerInsert.AssertOneGetNewAndReset(), "TheString".Split(','), new object[] { "E2" }); epService.EPRuntime.SendEvent(new SupportBean("E3", 3)); Assert.IsFalse(listenerSelect.GetAndClearIsInvoked()); Assert.IsFalse(listenerInsert.GetAndClearIsInvoked()); // is there a remaining event that gets flushed with the last one? // unit returns insert unit.EPAdministrator.RemoveStatement(stmtInsert); epService.EPRuntime.SendEvent(new SupportBean("E4", 4)); EPAssertionUtil.AssertProps(listenerInsert.AssertOneGetNewAndReset(), "TheString".Split(','), new object[] { "E4" }); EPAssertionUtil.AssertProps(listenerSelect.AssertOneGetNewAndReset(), "TheString".Split(','), new object[] { "E4" }); unit.EPRuntime.SendEvent(new SupportBean("E5", 5)); Assert.IsFalse(listenerSelect.GetAndClearIsInvoked()); Assert.IsFalse(listenerInsert.GetAndClearIsInvoked()); epService.EPRuntime.SendEvent(new SupportBean("E6", 6)); EPAssertionUtil.AssertProps(listenerInsert.AssertOneGetNewAndReset(), "TheString".Split(','), new object[] { "E6" }); EPAssertionUtil.AssertProps(listenerSelect.AssertOneGetNewAndReset(), "TheString".Split(','), new object[] { "E6" }); unit.Dispose(); epService.EPAdministrator.DestroyAllStatements(); }
private void RunAssertionIsolateFilter(EPServiceProvider epService) { if (SupportConfigFactory.SkipTest(typeof(ExecClientIsolationUnit))) { return; } EPStatement stmt = epService.EPAdministrator.CreateEPL("select * from pattern [every a=SupportBean -> b=SupportBean(TheString=a.TheString)]"); var listener = new SupportUpdateListener(); stmt.Events += listener.Update; epService.EPRuntime.SendEvent(new SupportBean("E1", 1)); Assert.IsFalse(listener.GetAndClearIsInvoked()); EPServiceProviderIsolated unit = epService.GetEPServiceIsolated("i1"); EPAssertionUtil.AssertEqualsAnyOrder(new string[] { "i1" }, epService.EPServiceIsolatedNames); // send fake to wrong place unit.EPRuntime.SendEvent(new SupportBean("E1", -1)); unit.EPAdministrator.AddStatement(stmt); // send to 'wrong' engine epService.EPRuntime.SendEvent(new SupportBean("E1", 2)); Assert.IsFalse(listener.GetAndClearIsInvoked()); // send to 'right' engine unit.EPRuntime.SendEvent(new SupportBean("E1", 3)); EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), "a.TheString,a.IntPrimitive,b.IntPrimitive".Split(','), new object[] { "E1", 1, 3 }); // send second pair, and a fake to the wrong place unit.EPRuntime.SendEvent(new SupportBean("E2", 4)); epService.EPRuntime.SendEvent(new SupportBean("E2", -1)); unit.EPAdministrator.RemoveStatement(stmt); // send to 'wrong' engine unit.EPRuntime.SendEvent(new SupportBean("E2", 5)); Assert.IsFalse(listener.GetAndClearIsInvoked()); // send to 'right' engine epService.EPRuntime.SendEvent(new SupportBean("E2", 6)); EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), "a.TheString,a.IntPrimitive,b.IntPrimitive".Split(','), new object[] { "E2", 4, 6 }); epService.EPAdministrator.DestroyAllStatements(); EPAssertionUtil.AssertEqualsAnyOrder(new string[] { "i1" }, epService.EPServiceIsolatedNames); epService.GetEPServiceIsolated("i1").Dispose(); EPAssertionUtil.AssertEqualsAnyOrder(new string[0], epService.EPServiceIsolatedNames); }
private void RunAssertionNamedWindowTimeCatchup(EPServiceProvider epService) { if (SupportConfigFactory.SkipTest(typeof(ExecClientIsolationUnit))) { return; } SendTimerUnisolated(epService, 100000); var fields = new string[] { "TheString" }; EPStatement stmtCreate = epService.EPAdministrator.CreateEPL("@Name('create') create window MyWindow#time(10) as SupportBean"); EPStatement stmtInsert = epService.EPAdministrator.CreateEPL("@Name('insert') insert into MyWindow select * from SupportBean"); EPServiceProviderIsolated unit = epService.GetEPServiceIsolated("i1"); SendTimerIso(0, unit); unit.EPAdministrator.AddStatement(new EPStatement[] { stmtCreate, stmtInsert }); SendTimerIso(1000, unit); unit.EPRuntime.SendEvent(new SupportBean("E1", 1)); SendTimerIso(2000, unit); unit.EPRuntime.SendEvent(new SupportBean("E2", 2)); SendTimerIso(9000, unit); unit.EPRuntime.SendEvent(new SupportBean("E3", 3)); EPAssertionUtil.AssertPropsPerRowAnyOrder(stmtCreate.GetEnumerator(), fields, new object[][] { new object[] { "E1" }, new object[] { "E2" }, new object[] { "E3" } }); unit.EPAdministrator.RemoveStatement(new EPStatement[] { stmtCreate }); SendTimerUnisolated(epService, 101000); // equivalent to 10000 (E3 is 1 seconds old) SendTimerUnisolated(epService, 102000); // equivalent to 11000 (E3 is 2 seconds old) EPAssertionUtil.AssertPropsPerRowAnyOrder(stmtCreate.GetEnumerator(), fields, new object[][] { new object[] { "E2" }, new object[] { "E3" } }); SendTimerUnisolated(epService, 103000); // equivalent to 12000 (E3 is 3 seconds old) EPAssertionUtil.AssertPropsPerRowAnyOrder(stmtCreate.GetEnumerator(), fields, new object[][] { new object[] { "E3" } }); SendTimerUnisolated(epService, 109000); // equivalent to 18000 (E3 is 9 seconds old) EPAssertionUtil.AssertPropsPerRowAnyOrder(stmtCreate.GetEnumerator(), fields, new object[][] { new object[] { "E3" } }); unit.EPAdministrator.AddStatement(new EPStatement[] { stmtCreate }); SendTimerIso(9999, unit); EPAssertionUtil.AssertPropsPerRowAnyOrder(stmtCreate.GetEnumerator(), fields, new object[][] { new object[] { "E3" } }); SendTimerIso(10000, unit); EPAssertionUtil.AssertPropsPerRowAnyOrder(stmtCreate.GetEnumerator(), fields, null); unit.Dispose(); epService.EPAdministrator.DestroyAllStatements(); }
private void RunSequence(EPServiceProviderIsolated epService, String[] times) { foreach (String next in times) { // send right-before time long nextLong = DateTimeParser.ParseDefaultMSec(next); epService.EPRuntime.SendEvent(new CurrentTimeEvent(nextLong - 1001)); Assert.IsFalse(_listener.IsInvoked, "unexpected callback at " + next); // send right-after time epService.EPRuntime.SendEvent(new CurrentTimeEvent(nextLong + 1000)); Assert.IsTrue(_listener.GetAndClearIsInvoked(), "missing callback at " + next); } }
private void RunAssertionStartStop(EPServiceProvider epService) { if (SupportConfigFactory.SkipTest(typeof(ExecClientIsolationUnit))) { return; } var fields = new string[] { "TheString" }; string epl = "select TheString from SupportBean#time(60)"; EPStatement stmt = epService.EPAdministrator.CreateEPL(epl); var listener = new SupportUpdateListener(); stmt.Events += listener.Update; EPServiceProviderIsolated unit = epService.GetEPServiceIsolated("i1"); unit.EPAdministrator.AddStatement(stmt); epService.EPRuntime.SendEvent(new SupportBean("E1", 0)); unit.EPRuntime.SendEvent(new SupportBean("E2", 0)); EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, new object[][] { new object[] { "E2" } }); stmt.Stop(); unit.EPAdministrator.RemoveStatement(stmt); stmt.Start(); EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, null); epService.EPRuntime.SendEvent(new SupportBean("E3", 0)); unit.EPRuntime.SendEvent(new SupportBean("E4", 0)); EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, new object[][] { new object[] { "E3" } }); unit.EPAdministrator.AddStatement(stmt); epService.EPRuntime.SendEvent(new SupportBean("E5", 0)); unit.EPRuntime.SendEvent(new SupportBean("E6", 0)); EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, new object[][] { new object[] { "E3" }, new object[] { "E6" } }); unit.EPAdministrator.RemoveStatement(stmt); epService.EPRuntime.SendEvent(new SupportBean("E7", 0)); unit.EPRuntime.SendEvent(new SupportBean("E8", 0)); EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, new object[][] { new object[] { "E3" }, new object[] { "E6" }, new object[] { "E7" } }); stmt.Stop(); unit.Dispose(); epService.EPAdministrator.DestroyAllStatements(); }