private void RunAssertionRecurringLimitedWithPeriod(string parameters)
{
EPServiceProviderIsolated iso = _epService.GetEPServiceIsolated("E1");
// Fire 3 times after 2 seconds from current time
SendCurrentTime(iso, "2012-10-01T05:52:00.000GMT-0:00");
string epl = "select * from pattern[every timer:schedule(" + parameters + ")]";
iso.EPAdministrator.CreateEPL(epl, null, null).AddListener(_listener);
AssertReceivedAtTime(iso, "2012-10-01T05:52:02.000GMT-0:00");
AssertReceivedAtTime(iso, "2012-10-01T05:52:04.000GMT-0:00");
AssertReceivedAtTime(iso, "2012-10-01T05:52:06.000GMT-0:00");
AssertSendNoMoreCallback(iso, "2012-10-01T05:52:08.000GMT-0:00");
_epService.EPAdministrator.DestroyAllStatements();
iso.Dispose();
}
private void RunAssertion_Astar()
{
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);
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 RunAssertion_A_Bstar_or_Cstar(EPServiceProvider epService)
{
EPServiceProviderIsolated isolated = epService.GetEPServiceIsolated("I1");
SendTimer(isolated, 0);
string[] fields = "a,b0,b1,c0,c1".Split(',');
string text = "select * from MyEvent#keepall " +
"match_recognize (" +
" measures A.TheString as a, " +
"B[0].TheString as b0, B[1].TheString as b1, " +
"C[0].TheString as c0, C[1].TheString as c1 " +
" 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("X1"));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { "A1", null, null, null, null });
isolated.EPRuntime.SendEvent(new SupportRecogBean("A2"));
isolated.EPRuntime.SendEvent(new SupportRecogBean("C1"));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { "A2", null, null, null, null });
isolated.EPRuntime.SendEvent(new SupportRecogBean("B1"));
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields,
new object[][] { new object[] { "A2", null, null, "C1", null } });
isolated.EPRuntime.SendEvent(new SupportRecogBean("C2"));
Assert.IsFalse(listener.IsInvoked);
// destroy
stmt.Dispose();
isolated.Dispose();
}
private void RunAssertion_A_Bplus(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;
isolated.EPRuntime.SendEvent(new SupportRecogBean("A1"));
isolated.EPRuntime.SendEvent(new SupportRecogBean("X1"));
isolated.EPRuntime.SendEvent(new SupportRecogBean("A2"));
isolated.EPRuntime.SendEvent(new SupportRecogBean("B2"));
Assert.IsFalse(listener.IsInvoked);
isolated.EPRuntime.SendEvent(new SupportRecogBean("X2"));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { "A2", "B2", null, null });
isolated.EPRuntime.SendEvent(new SupportRecogBean("A3"));
isolated.EPRuntime.SendEvent(new SupportRecogBean("A4"));
isolated.EPRuntime.SendEvent(new SupportRecogBean("B3"));
isolated.EPRuntime.SendEvent(new SupportRecogBean("B4"));
Assert.IsFalse(listener.IsInvoked);
isolated.EPRuntime.SendEvent(new SupportRecogBean("X3", -1));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { "A4", "B3", "B4", null });
// destroy
stmt.Dispose();
isolated.Dispose();
}
private void RunAssertionFullFormLimitedFutureDated(bool audit, string parameters)
{
EPServiceProviderIsolated iso = _epService.GetEPServiceIsolated("E1");
SendCurrentTime(iso, "2012-10-01T05:51:00.000GMT-0:00");
// Repeat 3 times, starting "2012-10-01T05:52:00Z" (UTC), period of 2 seconds
string epl = (audit ? "@Audit " : "") + "select * from pattern[every timer:schedule(" + parameters + ")]";
iso.EPAdministrator.CreateEPL(epl, null, null).AddListener(_listener);
AssertReceivedAtTime(iso, "2012-10-01T05:52:00.000GMT-0:00");
AssertReceivedAtTime(iso, "2012-10-01T05:52:02.000GMT-0:00");
AssertReceivedAtTime(iso, "2012-10-01T05:52:04.000GMT-0:00");
AssertSendNoMoreCallback(iso, "2012-10-01T05:52:06.000GMT-0:00");
_epService.EPAdministrator.DestroyAllStatements();
iso.Dispose();
}
private void RunAssertionFullFormUnlimitedFutureDated(EPServiceProvider epService)
{
EPServiceProviderIsolated iso = epService.GetEPServiceIsolated("E1");
// Repeat unlimited number of times, reference-dated to future date, period of 1 day
SendCurrentTime(iso, "2012-10-01T05:52:00.000GMT-0:00");
string epl = "select * from pattern[every timer:schedule(iso: 'R/2013-01-01T02:00:05Z/P1D')]";
var listener = new SupportUpdateListener();
iso.EPAdministrator.CreateEPL(epl, null, null).Events += listener.Update;
AssertReceivedAtTime(listener, iso, "2013-01-01T02:00:05.000GMT-0:00");
AssertReceivedAtTime(listener, iso, "2013-01-02T02:00:05.000GMT-0:00");
AssertReceivedAtTime(listener, iso, "2013-01-03T02:00:05.000GMT-0:00");
AssertReceivedAtTime(listener, iso, "2013-01-04T02:00:05.000GMT-0:00");
epService.EPAdministrator.DestroyAllStatements();
iso.Dispose();
}
private void RunAssertionRecurringUnlimitedWithPeriod(EPServiceProvider epService)
{
EPServiceProviderIsolated iso = epService.GetEPServiceIsolated("E1");
// Fire 3 times after 2 seconds from current time
SendCurrentTime(iso, "2012-10-01T05:52:00.000GMT-0:00");
string epl = "select * from pattern[every timer:schedule(iso:'R/PT1M10S')]";
var listener = new SupportUpdateListener();
iso.EPAdministrator.CreateEPL(epl, null, null).Events += listener.Update;
AssertReceivedAtTime(listener, iso, "2012-10-01T05:53:10.000GMT-0:00");
AssertReceivedAtTime(listener, iso, "2012-10-01T05:54:20.000GMT-0:00");
AssertReceivedAtTime(listener, iso, "2012-10-01T05:55:30.000GMT-0:00");
AssertReceivedAtTime(listener, iso, "2012-10-01T05:56:40.000GMT-0:00");
epService.EPAdministrator.DestroyAllStatements();
iso.Dispose();
}
private void RunAssertionTimeWindow(EPServiceProvider epService, long startTime, string size, long flipTime)
{
EPServiceProviderIsolated isolated = epService.GetEPServiceIsolated("isolated");
isolated.EPRuntime.SendEvent(new CurrentTimeEvent(startTime));
string[] fields = "TheString".Split(',');
EPStatement stmt = isolated.EPAdministrator.CreateEPL("select * from SupportBean#time(" + size + ")", "s0", 0);
isolated.EPRuntime.SendEvent(new SupportBean("E1", 1));
isolated.EPRuntime.SendEvent(new CurrentTimeEvent(flipTime - 1));
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, new object[][] { new object[] { "E1" } });
isolated.EPRuntime.SendEvent(new CurrentTimeEvent(flipTime));
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, null);
isolated.Dispose();
}
private static void RunAssertionEventTime(EPServiceProvider epService, long tsB, long flipTimeEndtsA)
{
EPServiceProviderIsolated isolated = epService.GetEPServiceIsolated("isolated");
isolated.EPRuntime.SendEvent(new CurrentTimeEvent(0));
EPStatement stmt = isolated.EPAdministrator.CreateEPL("select * from MyEvent(id='A') as a unidirectional, MyEvent(id='B')#lastevent as b where a.withDate(2002, 5, 30).before(b)", "s0", null);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
isolated.EPRuntime.SendEvent(new object[] { "B", tsB, tsB }, "MyEvent");
isolated.EPRuntime.SendEvent(new object[] { "A", flipTimeEndtsA - 1, flipTimeEndtsA - 1 }, "MyEvent");
Assert.IsTrue(listener.IsInvokedAndReset());
isolated.EPRuntime.SendEvent(new object[] { "A", flipTimeEndtsA, flipTimeEndtsA }, "MyEvent");
Assert.IsFalse(listener.IsInvokedAndReset());
isolated.Dispose();
}
private static void RunAssertionEventTime(EPServiceProvider epService, long flipTime)
{
EPServiceProviderIsolated isolated = epService.GetEPServiceIsolated("isolated");
isolated.EPRuntime.SendEvent(new CurrentTimeEvent(0));
string epl = "@Hint('reclaim_group_aged=1,reclaim_group_freq=5') select * from SupportBean#groupwin(TheString)#keepall";
EPStatement stmt = isolated.EPAdministrator.CreateEPL(epl, "s0", null);
isolated.EPRuntime.SendEvent(new SupportBean("E1", 0));
AssertCount(stmt, 1);
isolated.EPRuntime.SendEvent(new CurrentTimeEvent(flipTime - 1));
isolated.EPRuntime.SendEvent(new SupportBean("E2", 0));
AssertCount(stmt, 2);
isolated.EPRuntime.SendEvent(new CurrentTimeEvent(flipTime));
isolated.EPRuntime.SendEvent(new SupportBean("E3", 0));
AssertCount(stmt, 2);
isolated.Dispose();
}
public void TestCurrentTimeWTime()
{
EPServiceProviderIsolated iso = _epService.GetEPServiceIsolated("E1");
SendCurrentTime(iso, "2012-10-01T8:59:00.000GMT-04:00");
string epl = "select * from pattern[timer:schedule(date: current_timestamp.withTime(9, 0, 0, 0))]";
iso.EPAdministrator.CreateEPL(epl, null, null).AddListener(_listener);
SendCurrentTime(iso, "2012-10-01T8:59:59.999GMT-4:00");
Assert.IsFalse(_listener.IsInvokedAndReset());
SendCurrentTime(iso, "2012-10-01T9:00:00.000GMT-4:00");
Assert.IsTrue(_listener.IsInvokedAndReset());
SendCurrentTime(iso, "2012-10-03T9:00:00.000GMT-4:00");
Assert.IsFalse(_listener.IsInvokedAndReset());
_epService.EPAdministrator.DestroyAllStatements();
iso.Dispose();
}
private void RunAssertionDocSample(EPServiceProvider epService)
{
EPServiceProviderIsolated isolated = epService.GetEPServiceIsolated("I1");
SendTimer(isolated, 0);
string[] fields = "a_id,count_b,first_b,last_b".Split(',');
string text = "select * from TemperatureSensorEvent\n" +
"match_recognize (\n" +
" partition by device\n" +
" measures A.id as a_id, count(B.id) as count_b, first(B.id) as first_b, last(B.id) as last_b\n" +
" pattern (A B*)\n" +
" interval 5 seconds or terminated\n" +
" define\n" +
" A as A.temp > 100,\n" +
" B as B.temp > 100)";
EPStatement stmt = isolated.EPAdministrator.CreateEPL(text, "stmt1", null);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
SendTemperatureEvent(isolated, "E1", 1, 98);
SendTemperatureEvent(isolated, "E2", 1, 101);
SendTemperatureEvent(isolated, "E3", 1, 102);
SendTemperatureEvent(isolated, "E4", 1, 101); // falls below
Assert.IsFalse(listener.IsInvoked);
SendTemperatureEvent(isolated, "E5", 1, 100); // falls below
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { "E2", 2L, "E3", "E4" });
SendTimer(isolated, int.MaxValue);
Assert.IsFalse(listener.IsInvoked);
// destroy
stmt.Dispose();
isolated.Dispose();
}
public override void Run(EPServiceProvider epService)
{
EPServiceProviderIsolated iso = epService.GetEPServiceIsolated("E1");
SendCurrentTime(iso, "2012-10-01T08:59:00.000GMT-04:00");
string epl = "select * from pattern[timer:schedule(date: current_timestamp.WithTime(9, 0, 0, 0))]";
var listener = new SupportUpdateListener();
iso.EPAdministrator.CreateEPL(epl, null, null).Events += listener.Update;
SendCurrentTime(iso, "2012-10-01T08:59:59.999GMT-4:00");
Assert.IsFalse(listener.IsInvokedAndReset());
SendCurrentTime(iso, "2012-10-01T09:00:00.000GMT-4:00");
Assert.IsTrue(listener.IsInvokedAndReset());
SendCurrentTime(iso, "2012-10-03T09:00:00.000GMT-4:00");
Assert.IsFalse(listener.IsInvokedAndReset());
epService.EPAdministrator.DestroyAllStatements();
iso.Dispose();
}
private void RunAssertionFollowedByDynamicallyComputed()
{
_epService.EPAdministrator.Configuration.AddPlugInSingleRowFunction("computeISO8601String", this.GetType().FullName, "ComputeISO8601String");
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: computeISO8601String(sb))]";
iso.EPAdministrator.CreateEPL(epl, null, null).AddListener(_listener);
SupportBean b1 = MakeSendEvent(iso, "E1", 5);
SendCurrentTime(iso, "2012-10-01T05:51:09.999GMT-0:00");
Assert.IsFalse(_listener.IsInvokedAndReset());
SendCurrentTime(iso, "2012-10-01T05:51:10.000GMT-0:00");
Assert.AreEqual(b1, _listener.AssertOneGetNewAndReset().Get("sb"));
_epService.EPAdministrator.DestroyAllStatements();
iso.Dispose();
}
private void RunAssertionCreateStmt(EPServiceProvider epService)
{
if (SupportConfigFactory.SkipTest(typeof(ExecClientIsolationUnit)))
{
return;
}
EPServiceProviderIsolated unit = epService.GetEPServiceIsolated("i1");
SendTimerUnisolated(epService, 100000);
SendTimerIso(1000, unit);
var fields = new string[] { "ct" };
EPStatement stmt = unit.EPAdministrator.CreateEPL("select current_timestamp() as ct from pattern[every timer:interval(10)]", null, null);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
SendTimerIso(10999, unit);
Assert.IsFalse(listener.IsInvoked);
SendTimerIso(11000, unit);
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { 11000L });
SendTimerIso(15000, unit);
unit.EPAdministrator.RemoveStatement(stmt);
SendTimerIso(21000, unit);
Assert.IsFalse(listener.IsInvoked);
SendTimerUnisolated(epService, 106000);
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { 106000L });
unit.Dispose();
epService.EPAdministrator.DestroyAllStatements();
}
private void RunAssertion_A_Bstar(bool allMatches)
{
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" +
(allMatches ? " all matches" : "") +
" 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;
// 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"));
if (!allMatches)
{
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "A1", "B1", null, null });
}
else
{
EPAssertionUtil.AssertPropsPerRowAnyOrder(_listener.GetAndResetLastNewData(), fields,
new Object[][] { new Object[] { "A1", "B1", null, null }, new Object[] { "A1", null, 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);
if (!allMatches)
{
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "A2", "B2", null, null });
}
else
{
EPAssertionUtil.AssertPropsPerRowAnyOrder(_listener.GetAndResetLastNewData(), fields,
new Object[][] { new Object[] { "A2", "B2", null, null }, new Object[] { "A2", null, null, null } });
}
// destroy
stmt.Dispose();
isolated.Dispose();
EPStatement stmtFromModel = SupportModelHelper.CompileCreate(_epService, text);
stmtFromModel.Dispose();
}
private void RunAssertionSuspend(EPServiceProvider epService)
{
if (SupportConfigFactory.SkipTest(typeof(ExecClientIsolationUnit)))
{
return;
}
SendTimerUnisolated(epService, 1000);
var fields = new string[] { "TheString" };
string epl = "select irstream TheString from SupportBean#time(10)";
EPStatement stmt = epService.EPAdministrator.CreateEPL(epl);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
SendTimerUnisolated(epService, 2000);
epService.EPRuntime.SendEvent(new SupportBean("E1", 0));
SendTimerUnisolated(epService, 3000);
epService.EPRuntime.SendEvent(new SupportBean("E2", 0));
SendTimerUnisolated(epService, 7000);
epService.EPRuntime.SendEvent(new SupportBean("E3", 0));
SendTimerUnisolated(epService, 8000);
EPStatement stmtTwo = epService.EPAdministrator.CreateEPL("select 'x' as TheString from pattern [timer:interval(10)]");
stmtTwo.Events += listener.Update;
EPServiceProviderIsolated unit = epService.GetEPServiceIsolated("i1");
unit.EPAdministrator.AddStatement(new EPStatement[] { stmt, stmtTwo });
EPAssertionUtil.AssertEqualsAnyOrder(new string[] { stmt.Name, stmtTwo.Name }, unit.EPAdministrator.StatementNames);
Assert.AreEqual("i1", stmt.ServiceIsolated);
Assert.AreEqual("i1", stmt.ServiceIsolated);
listener.Reset();
epService.EPRuntime.SendEvent(new SupportBean("E4", 0));
SendTimerUnisolated(epService, 15000);
Assert.IsFalse(listener.IsInvoked);
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, new object[][] { new object[] { "E1" }, new object[] { "E2" }, new object[] { "E3" } });
unit.EPAdministrator.RemoveStatement(new EPStatement[] { stmt, stmtTwo });
EPAssertionUtil.AssertEqualsAnyOrder(new string[0], unit.EPAdministrator.StatementNames);
Assert.IsNull(stmt.ServiceIsolated);
Assert.IsNull(stmt.ServiceIsolated);
SendTimerUnisolated(epService, 18999);
Assert.IsFalse(listener.IsInvoked);
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, new object[][] { new object[] { "E1" }, new object[] { "E2" }, new object[] { "E3" } });
SendTimerUnisolated(epService, 19000);
EPAssertionUtil.AssertProps(listener.AssertOneGetOldAndReset(), fields, new object[] { "E1" });
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, new object[][] { new object[] { "E2" }, new object[] { "E3" } });
SendTimerUnisolated(epService, 23999);
EPAssertionUtil.AssertProps(listener.AssertOneGetOldAndReset(), fields, new object[] { "E2" });
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, new object[][] { new object[] { "E3" } });
SendTimerUnisolated(epService, 24000);
EPAssertionUtil.AssertProps(listener.AssertOneGetOldAndReset(), fields, new object[] { "E3" });
EPAssertionUtil.AssertPropsPerRowAnyOrder(stmt.GetEnumerator(), fields, null);
SendTimerUnisolated(epService, 25000);
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { "x" });
unit.Dispose();
epService.EPAdministrator.DestroyAllStatements();
}
private void RunAssertionIsolateMultiple(EPServiceProvider epService)
{
if (SupportConfigFactory.SkipTest(typeof(ExecClientIsolationUnit)))
{
return;
}
var fields = new string[] { "TheString", "sumi" };
int count = 4;
var listeners = new SupportUpdateListener[count];
for (int i = 0; i < count; i++)
{
string epl = "@Name('S" + i + "') select TheString, sum(IntPrimitive) as sumi from SupportBean(TheString='" + i + "')#time(10)";
listeners[i] = new SupportUpdateListener();
epService.EPAdministrator.CreateEPL(epl).Events += listeners[i].Update;
}
var statements = new EPStatement[2];
statements[0] = epService.EPAdministrator.GetStatement("S0");
statements[1] = epService.EPAdministrator.GetStatement("S2");
EPServiceProviderIsolated unit = epService.GetEPServiceIsolated("i1");
unit.EPAdministrator.AddStatement(statements);
// send to unisolated
for (int i = 0; i < count; i++)
{
epService.EPRuntime.SendEvent(new SupportBean(Convert.ToString(i), i));
}
Assert.IsFalse(listeners[0].IsInvoked);
Assert.IsFalse(listeners[2].IsInvoked);
EPAssertionUtil.AssertProps(listeners[1].AssertOneGetNewAndReset(), fields, new object[] { "1", 1 });
EPAssertionUtil.AssertProps(listeners[3].AssertOneGetNewAndReset(), fields, new object[] { "3", 3 });
// send to isolated
for (int i = 0; i < count; i++)
{
unit.EPRuntime.SendEvent(new SupportBean(Convert.ToString(i), i));
}
Assert.IsFalse(listeners[1].IsInvoked);
Assert.IsFalse(listeners[3].IsInvoked);
EPAssertionUtil.AssertProps(listeners[0].AssertOneGetNewAndReset(), fields, new object[] { "0", 0 });
EPAssertionUtil.AssertProps(listeners[2].AssertOneGetNewAndReset(), fields, new object[] { "2", 2 });
unit.EPRuntime.SendEvent(new SupportBean(Convert.ToString(2), 2));
EPAssertionUtil.AssertProps(listeners[2].AssertOneGetNewAndReset(), fields, new object[] { "2", 4 });
// return
unit.EPAdministrator.RemoveStatement(statements);
// send to unisolated
for (int i = 0; i < count; i++)
{
epService.EPRuntime.SendEvent(new SupportBean(Convert.ToString(i), i));
}
EPAssertionUtil.AssertProps(listeners[0].AssertOneGetNewAndReset(), fields, new object[] { "0", 0 });
EPAssertionUtil.AssertProps(listeners[1].AssertOneGetNewAndReset(), fields, new object[] { "1", 2 });
EPAssertionUtil.AssertProps(listeners[2].AssertOneGetNewAndReset(), fields, new object[] { "2", 6 });
EPAssertionUtil.AssertProps(listeners[3].AssertOneGetNewAndReset(), fields, new object[] { "3", 6 });
// send to isolated
for (int i = 0; i < count; i++)
{
unit.EPRuntime.SendEvent(new SupportBean(Convert.ToString(i), i));
Assert.IsFalse(listeners[i].IsInvoked);
}
unit.Dispose();
epService.EPAdministrator.DestroyAllStatements();
}
