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 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);
}
public void TestSendTimeSpanIsolated()
{
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);
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"));
_listener.Reset();
}
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 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 RunAssertionRecurringAnchoring(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/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();
}
private void RunAssertionFollowedBy(EPServiceProvider epService)
{
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')]";
var listener = new SupportUpdateListener();
iso.EPAdministrator.CreateEPL(epl, null, null).Events += listener.Update;
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 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();
}
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 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 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 override void Run(EPServiceProvider epService)
{
try {
epService.GetEPServiceIsolated("i1");
Assert.Fail();
} catch (EPServiceNotAllowedException ex) {
Assert.AreEqual("Isolated runtime requires execution setting to allow isolated services, please change execution settings under engine defaults", ex.Message);
}
}
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();
}
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();
}
private void RunAssertion_A_Bstar_or_C()
{
EPServiceProviderIsolated isolated = _epService.GetEPServiceIsolated("I1");
SendTimer(isolated, 0);
String[] fields = "a,b0,b1,b2,c".Split(',');
String text = "select * from MyEvent#keepall " +
"match_recognize (" +
" measures A.TheString as a, B[0].TheString as b0, B[1].TheString as b1, B[2].TheString as b2, C.TheString as c " +
" 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);
stmt.Events += _listener.Update;
isolated.EPRuntime.SendEvent(new SupportRecogBean("A1"));
isolated.EPRuntime.SendEvent(new SupportRecogBean("C1"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "A1", null, null, null, "C1" });
isolated.EPRuntime.SendEvent(new SupportRecogBean("A2"));
Assert.IsFalse(_listener.IsInvoked);
isolated.EPRuntime.SendEvent(new SupportRecogBean("B1"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "A2", null, null, null, null });
isolated.EPRuntime.SendEvent(new SupportRecogBean("B2"));
Assert.IsFalse(_listener.IsInvoked);
isolated.EPRuntime.SendEvent(new SupportRecogBean("X1"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "A2", "B1", "B2", null, null });
isolated.EPRuntime.SendEvent(new SupportRecogBean("A3"));
SendTimer(isolated, 10000);
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "A3", null, null, null, null });
SendTimer(isolated, int.MaxValue);
Assert.IsFalse(_listener.IsInvoked);
// destroy
stmt.Dispose();
isolated.Dispose();
}
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 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 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();
}
private void RunAssertion_A_parenthesisBstar(EPServiceProvider epService)
{
EPServiceProviderIsolated isolated = epService.GetEPServiceIsolated("I1");
SendTimer(isolated, 0);
string[] fields = "a,b0,b1,b2".Split(',');
string text = "select * from MyEvent#keepall " +
"match_recognize (" +
" measures A.TheString as a, B[0].TheString as b0, B[1].TheString as b1, B[2].TheString as b2" +
" 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);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
// test output by terminated because of misfit event
isolated.EPRuntime.SendEvent(new SupportRecogBean("A1"));
isolated.EPRuntime.SendEvent(new SupportRecogBean("B1"));
Assert.IsFalse(listener.IsInvoked);
isolated.EPRuntime.SendEvent(new SupportRecogBean("X1"));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { "A1", "B1", null, null });
SendTimer(isolated, 20000);
Assert.IsFalse(listener.IsInvoked);
// test output by timer expiry
isolated.EPRuntime.SendEvent(new SupportRecogBean("A2"));
isolated.EPRuntime.SendEvent(new SupportRecogBean("B2"));
Assert.IsFalse(listener.IsInvoked);
SendTimer(isolated, 29999);
SendTimer(isolated, 30000);
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { "A2", "B2", null, null });
// destroy
stmt.Dispose();
isolated.Dispose();
EPStatement stmtFromModel = SupportModelHelper.CompileCreate(epService, text);
stmtFromModel.Dispose();
}
private void RunAssertionMovePattern(EPServiceProvider epService)
{
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));
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
isolatedService.EPAdministrator.RemoveStatement(stmt);
epService.EPRuntime.SendEvent(new SupportBean("E1", 2));
Assert.IsTrue(listener.IsInvokedAndReset());
stmt.Dispose();
isolatedService.Dispose();
}
private void RunAssertionLongProperty(EPServiceProvider epService, long startTime, SupportDateTime @event, string select, string[] fields, object[] expected)
{
EPServiceProviderIsolated isolated = epService.GetEPServiceIsolated("isolated");
isolated.EPRuntime.SendEvent(new CurrentTimeEvent(startTime));
EPStatement stmt = isolated.EPAdministrator.CreateEPL("select " + select + " from SupportDateTime", "s0", null);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
isolated.EPRuntime.SendEvent(@event);
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, expected);
isolated.Dispose();
}
private void RunAssertionIsolatedSchedule(EPServiceProvider epService)
{
if (SupportConfigFactory.SkipTest(typeof(ExecClientIsolationUnit)))
{
return;
}
SendTimerUnisolated(epService, 100000);
EPStatement stmt = epService.EPAdministrator.CreateEPL("select * from pattern [every a=SupportBean -> timer:interval(10)]");
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
SendTimerUnisolated(epService, 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(epService, 120000);
Assert.IsFalse(listener.IsInvoked);
unit.EPAdministrator.RemoveStatement(stmt);
SendTimerUnisolated(epService, 129999);
Assert.IsFalse(listener.IsInvoked);
SendTimerUnisolated(epService, 130000);
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), "a.TheString".Split(','), new object[] { "E2" });
SendTimerIso(30000, unit);
Assert.IsFalse(listener.IsInvoked);
unit.Dispose();
epService.EPAdministrator.DestroyAllStatements();
}
private void TryAssertionEquivalent(EPServiceProvider epService, string epl)
{
EPServiceProviderIsolated iso = epService.GetEPServiceIsolated("E1");
SendCurrentTime(iso, "2001-10-01T05:51:00.000GMT-0:00");
var listener = new SupportUpdateListener();
iso.EPAdministrator.CreateEPL(epl, null, null).Events += listener.Update;
AssertReceivedAtTime(listener, iso, "2008-03-01T13:00:00.000GMT-0:00");
AssertReceivedAtTime(listener, iso, "2009-05-11T15:30:00.000GMT-0:00");
AssertSendNoMoreCallback(listener, iso, "2012-10-01T05:52:04.000GMT-0:00");
epService.EPAdministrator.DestroyAllStatements();
iso.Dispose();
}
private void TryAssertionJustPastDate(EPServiceProvider epService, bool hasEvery)
{
EPServiceProviderIsolated iso = epService.GetEPServiceIsolated("E1");
SendCurrentTime(iso, "2012-10-01T05:51:00.000GMT-0:00");
// Fire once at "2012-10-01T05:52:00Z" (UTC)
string epl = "select * from pattern[" + (hasEvery ? "every " : "") + "timer:schedule(iso: '2010-10-01T05:52:00Z')]";
var listener = new SupportUpdateListener();
iso.EPAdministrator.CreateEPL(epl, null, null).Events += listener.Update;
AssertSendNoMoreCallback(listener, iso, "2012-10-01T05:53:00.000GMT-0:00");
epService.EPAdministrator.DestroyAllStatements();
iso.Dispose();
}
private void RunAssertionFullFormLimitedPastDated(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-10-01T05:52:00.000GMT-0:00");
string epl = "select * from pattern[every timer:schedule(iso: 'R8/2012-10-01T05:51:00Z/PT10S')]";
var listener = new SupportUpdateListener();
iso.EPAdministrator.CreateEPL(epl, null, null).Events += listener.Update;
AssertReceivedAtTime(listener, iso, "2012-10-01T05:52:10.000GMT-0:00");
AssertSendNoMoreCallback(listener, iso, "2012-10-01T05:52:20.000GMT-0:00");
epService.EPAdministrator.DestroyAllStatements();
iso.Dispose();
}
private void RunAssertion_Astar(EPServiceProvider epService)
{
EPServiceProviderIsolated isolated = epService.GetEPServiceIsolated("I1");
SendTimer(isolated, 0);
string[] fields = "a0,a1,a2,a3,a4".Split(',');
string text = "select * from MyEvent#keepall " +
"match_recognize (" +
" measures A[0].TheString as a0, A[1].TheString as a1, A[2].TheString as a2, A[3].TheString as a3, A[4].TheString as a4" +
" pattern (A*)" +
" interval 10 seconds or terminated" +
" define" +
" A as TheString like 'A%'" +
")";
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("A2"));
Assert.IsFalse(listener.IsInvoked);
isolated.EPRuntime.SendEvent(new SupportRecogBean("B1"));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { "A1", "A2", null, null, null });
SendTimer(isolated, 2000);
isolated.EPRuntime.SendEvent(new SupportRecogBean("A3"));
isolated.EPRuntime.SendEvent(new SupportRecogBean("A4"));
isolated.EPRuntime.SendEvent(new SupportRecogBean("A5"));
Assert.IsFalse(listener.IsInvoked);
SendTimer(isolated, 12000);
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { "A3", "A4", "A5", null, null });
isolated.EPRuntime.SendEvent(new SupportRecogBean("A6"));
isolated.EPRuntime.SendEvent(new SupportRecogBean("B2"));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { "A3", "A4", "A5", "A6", null });
isolated.EPRuntime.SendEvent(new SupportRecogBean("B3"));
Assert.IsFalse(listener.IsInvoked);
// destroy
stmt.Dispose();
isolated.Dispose();
}
private void RunAssertionUpdate(EPServiceProvider epService)
{
if (SupportConfigFactory.SkipTest(typeof(ExecClientIsolationUnit)))
{
return;
}
SendTimerUnisolated(epService, 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");
var listener = new SupportUpdateListener();
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);
/// <summary>
/// Update statements apply to a stream even if the statement is not isolated.
/// </summary>
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" });
unit.Dispose();
epService.EPAdministrator.DestroyAllStatements();
}
private void RunAssertionEventSender(EPServiceProvider epService)
{
if (SupportConfigFactory.SkipTest(typeof(ExecClientIsolationUnit)))
{
return;
}
EPServiceProviderIsolated unit = epService.GetEPServiceIsolated("other1");
EventSender sender = unit.EPRuntime.GetEventSender("SupportBean");
var listener = new SupportUpdateListener();
unit.EPAdministrator.CreateEPL("select * from SupportBean", null, null).Events += listener.Update;
sender.SendEvent(new SupportBean());
Assert.IsTrue(listener.IsInvoked);
unit.Dispose();
epService.EPAdministrator.DestroyAllStatements();
}
