public void TestGroupByEventPerGroupBatchContextProp()
{
_epService.EPAdministrator.CreateEPL("@Name('context') create context SegmentedByString partition by TheString from SupportBean");
var fieldsOne = "IntPrimitive,count(*)".Split(',');
var stmtOne = _epService.EPAdministrator.CreateEPL("@Name('A') context SegmentedByString select IntPrimitive, Count(*) from SupportBean.win:length_batch(2) group by IntPrimitive order by IntPrimitive asc");
stmtOne.Events += _listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean("G1", 10));
_epService.EPRuntime.SendEvent(new SupportBean("G2", 200));
Assert.IsFalse(_listener.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportBean("G1", 11));
EPAssertionUtil.AssertProps(_listener.LastNewData[0], fieldsOne, new Object[] { 10, 1L });
EPAssertionUtil.AssertProps(_listener.GetAndResetLastNewData()[1], fieldsOne, new Object[] { 11, 1L });
_epService.EPRuntime.SendEvent(new SupportBean("G1", 10));
Assert.IsFalse(_listener.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportBean("G2", 200));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsOne, new Object[] { 200, 2L });
_epService.EPRuntime.SendEvent(new SupportBean("G1", 10));
EPAssertionUtil.AssertProps(_listener.LastNewData[0], fieldsOne, new Object[] { 10, 2L });
EPAssertionUtil.AssertProps(_listener.GetAndResetLastNewData()[1], fieldsOne, new Object[] { 11, 0L });
_epService.EPRuntime.SendEvent(new SupportBean("G2", 10));
_epService.EPRuntime.SendEvent(new SupportBean("G2", 10));
EPAssertionUtil.AssertProps(_listener.LastNewData[0], fieldsOne, new Object[] { 10, 2L });
EPAssertionUtil.AssertProps(_listener.GetAndResetLastNewData()[1], fieldsOne, new Object[] { 200, 0L });
stmtOne.Dispose();
// add "string" : add context property
var fieldsTwo = "TheString,IntPrimitive,count(*)".Split(',');
var stmtTwo = _epService.EPAdministrator.CreateEPL("@Name('B') context SegmentedByString select TheString, IntPrimitive, Count(*) from SupportBean.win:length_batch(2) group by IntPrimitive order by TheString, IntPrimitive asc");
stmtTwo.Events += _listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean("G1", 10));
_epService.EPRuntime.SendEvent(new SupportBean("G2", 200));
Assert.IsFalse(_listener.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportBean("G1", 11));
EPAssertionUtil.AssertProps(_listener.LastNewData[0], fieldsTwo, new Object[] { "G1", 10, 1L });
EPAssertionUtil.AssertProps(_listener.GetAndResetLastNewData()[1], fieldsTwo, new Object[] { "G1", 11, 1L });
_epService.EPRuntime.SendEvent(new SupportBean("G1", 10));
Assert.IsFalse(_listener.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportBean("G2", 200));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsTwo, new Object[] { "G2", 200, 2L });
_epService.EPRuntime.SendEvent(new SupportBean("G1", 10));
EPAssertionUtil.AssertProps(_listener.LastNewData[0], fieldsTwo, new Object[] { "G1", 10, 2L });
EPAssertionUtil.AssertProps(_listener.GetAndResetLastNewData()[1], fieldsTwo, new Object[] { "G1", 11, 0L });
_epService.EPRuntime.SendEvent(new SupportBean("G2", 10));
_epService.EPRuntime.SendEvent(new SupportBean("G2", 10));
EPAssertionUtil.AssertProps(_listener.LastNewData[0], fieldsTwo, new Object[] { "G2", 10, 2L });
EPAssertionUtil.AssertProps(_listener.GetAndResetLastNewData()[1], fieldsTwo, new Object[] { "G2", 200, 0L });
}
public void TestAggregation()
{
String[] fields = new String[] { "TheString" };
// Test un-grouped
EPStatement stmtUngrouped = _epService.EPAdministrator.CreateEPL("select irstream TheString from SupportBean.win:expr_batch(sum(IntPrimitive) > 100)");
stmtUngrouped.Events += _listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
_epService.EPRuntime.SendEvent(new SupportBean("E2", 90));
Assert.IsFalse(_listener.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportBean("E3", 10));
EPAssertionUtil.AssertPropsPerRow(_listener.GetAndResetDataListsFlattened(), fields, new Object[][] { new Object[] { "E1" }, new Object[] { "E2" }, new Object[] { "E3" } }, null);
_epService.EPRuntime.SendEvent(new SupportBean("E4", 101));
EPAssertionUtil.AssertPropsPerRow(_listener.GetAndResetDataListsFlattened(), fields, new Object[][] { new Object[] { "E4" } }, new Object[][] { new Object[] { "E1" }, new Object[] { "E2" }, new Object[] { "E3" } });
_epService.EPRuntime.SendEvent(new SupportBean("E5", 1));
_epService.EPRuntime.SendEvent(new SupportBean("E6", 99));
Assert.IsFalse(_listener.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportBean("E7", 1));
EPAssertionUtil.AssertPropsPerRow(_listener.GetAndResetDataListsFlattened(), fields, new Object[][] { new Object[] { "E5" }, new Object[] { "E6" }, new Object[] { "E7" } }, new Object[][] { new Object[] { "E4" } });
stmtUngrouped.Dispose();
// Test grouped
EPStatement stmtGrouped = _epService.EPAdministrator.CreateEPL("select irstream TheString from SupportBean.std:groupwin(IntPrimitive).win:expr_batch(sum(LongPrimitive) > 100)");
stmtGrouped.Events += _listener.Update;
SendEvent("E1", 1, 10);
SendEvent("E2", 2, 10);
SendEvent("E3", 1, 90);
SendEvent("E4", 2, 80);
SendEvent("E5", 2, 10);
Assert.IsFalse(_listener.IsInvoked);
SendEvent("E6", 2, 1);
EPAssertionUtil.AssertPropsPerRow(_listener.GetAndResetDataListsFlattened(), fields, new Object[][] { new Object[] { "E2" }, new Object[] { "E4" }, new Object[] { "E5" }, new Object[] { "E6" } }, null);
SendEvent("E7", 2, 50);
Assert.IsFalse(_listener.IsInvoked);
SendEvent("E8", 1, 2);
EPAssertionUtil.AssertPropsPerRow(_listener.GetAndResetDataListsFlattened(), fields, new Object[][] { new Object[] { "E1" }, new Object[] { "E3" }, new Object[] { "E8" } }, null);
SendEvent("E9", 2, 50);
SendEvent("E10", 1, 101);
EPAssertionUtil.AssertPropsPerRow(_listener.GetAndResetDataListsFlattened(), fields, new Object[][] { new Object[] { "E10" } }, new Object[][] { new Object[] { "E1" }, new Object[] { "E3" }, new Object[] { "E8" } });
SendEvent("E11", 2, 1);
EPAssertionUtil.AssertPropsPerRow(_listener.GetAndResetDataListsFlattened(), fields, new Object[][] { new Object[] { "E7" }, new Object[] { "E9" }, new Object[] { "E11" } }, new Object[][] { new Object[] { "E2" }, new Object[] { "E4" }, new Object[] { "E5" }, new Object[] { "E6" } });
SendEvent("E12", 1, 102);
EPAssertionUtil.AssertPropsPerRow(_listener.GetAndResetDataListsFlattened(), fields, new Object[][] { new Object[] { "E12" } }, new Object[][] { new Object[] { "E10" } });
stmtGrouped.Dispose();
// Test on-delete
_epService.EPAdministrator.Configuration.AddEventType <SupportBean_A>();
EPStatement stmt = _epService.EPAdministrator.CreateEPL("create window NW.win:expr_batch(sum(IntPrimitive) >= 10) as SupportBean");
stmt.Events += _listener.Update;
_epService.EPAdministrator.CreateEPL("insert into NW select * from SupportBean");
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
_epService.EPRuntime.SendEvent(new SupportBean("E2", 8));
_epService.EPAdministrator.CreateEPL("on SupportBean_A delete from NW where TheString = id");
_epService.EPRuntime.SendEvent(new SupportBean_A("E2"));
_epService.EPRuntime.SendEvent(new SupportBean("E3", 8));
Assert.IsFalse(_listener.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportBean("E4", 1));
EPAssertionUtil.AssertPropsPerRow(_listener.GetAndResetDataListsFlattened(), fields, new Object[][] { new Object[] { "E1" }, new Object[] { "E3" }, new Object[] { "E4" } }, null);
}
public void Run(RegressionEnvironment env)
{
var epl = "@Name('s0') select irstream * from SupportBean#sort(3, IntPrimitive desc, LongPrimitive)";
env.CompileDeployAddListenerMileZero(epl, "s0");
var fields = new[] {"TheString", "IntPrimitive", "LongPrimitive"};
env.SendEventBean(MakeEvent("E1", 100, 0L));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {"E1", 100, 0L});
EPAssertionUtil.AssertPropsPerRow(
env.Statement("s0").GetEnumerator(),
fields,
new[] {new object[] {"E1", 100, 0L}});
env.SendEventBean(MakeEvent("E2", 99, 5L));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {"E2", 99, 5L});
EPAssertionUtil.AssertPropsPerRow(
env.Statement("s0").GetEnumerator(),
fields,
new[] {new object[] {"E1", 100, 0L}, new object[] {"E2", 99, 5L}});
env.SendEventBean(MakeEvent("E3", 100, -1L));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {"E3", 100, -1L});
EPAssertionUtil.AssertPropsPerRow(
env.Statement("s0").GetEnumerator(),
fields,
new[] {new object[] {"E3", 100, -1L}, new object[] {"E1", 100, 0L}, new object[] {"E2", 99, 5L}});
env.SendEventBean(MakeEvent("E4", 100, 1L));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertPairGetIRAndReset(),
fields,
new object[] {"E4", 100, 1L},
new object[] {"E2", 99, 5L});
EPAssertionUtil.AssertPropsPerRow(
env.Statement("s0").GetEnumerator(),
fields,
new[] {new object[] {"E3", 100, -1L}, new object[] {"E1", 100, 0L}, new object[] {"E4", 100, 1L}});
env.SendEventBean(MakeEvent("E5", 101, 10L));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertPairGetIRAndReset(),
fields,
new object[] {"E5", 101, 10L},
new object[] {"E4", 100, 1L});
EPAssertionUtil.AssertPropsPerRow(
env.Statement("s0").GetEnumerator(),
fields,
new[] {new object[] {"E5", 101, 10L}, new object[] {"E3", 100, -1L}, new object[] {"E1", 100, 0L}});
env.SendEventBean(MakeEvent("E6", 101, 11L));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertPairGetIRAndReset(),
fields,
new object[] {"E6", 101, 11L},
new object[] {"E1", 100, 0L});
EPAssertionUtil.AssertPropsPerRow(
env.Statement("s0").GetEnumerator(),
fields,
new[] {
new object[] {"E5", 101, 10L}, new object[] {"E6", 101, 11L}, new object[] {"E3", 100, -1L}
});
env.SendEventBean(MakeEvent("E6", 100, 0L));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertPairGetIRAndReset(),
fields,
new object[] {"E6", 100, 0L},
new object[] {"E6", 100, 0L});
EPAssertionUtil.AssertPropsPerRow(
env.Statement("s0").GetEnumerator(),
fields,
new[] {
new object[] {"E5", 101, 10L}, new object[] {"E6", 101, 11L}, new object[] {"E3", 100, -1L}
});
env.UndeployAll();
}
public void TestViewPush()
{
// Set up a feed for the view under test - it will have a depth of 3 trades
SupportStreamImpl stream = new SupportStreamImpl(typeof(SupportBean_A), 3);
stream.AddView(_myView);
IDictionary <String, EventBean> events = EventFactoryHelper.MakeEventMap(
new String[] { "a0", "b0", "b1", "c0", "c1", "d0", "e0", "e1", "e2", "f0", "f1",
"g0", "g1", "g2", "g3", "g4",
"h0", "h1", "h2", "h3", "h4", "h5", "h6",
"i0" });
// Fill the window with events up to the depth of 5
stream.Insert(MakeArray(events, new String[] { "a0" }));
SupportViewDataChecker.CheckOldData(_childView, null);
SupportViewDataChecker.CheckNewData(_childView, MakeArray(events, new String[] { "a0" }));
EPAssertionUtil.AssertEqualsExactOrder(MakeArray(events, new String[] { "a0" }), _myView.GetEnumerator());
stream.Insert(MakeArray(events, new String[] { "b0", "b1" }));
SupportViewDataChecker.CheckOldData(_childView, null);
SupportViewDataChecker.CheckNewData(_childView, MakeArray(events, new String[] { "b0", "b1" }));
EPAssertionUtil.AssertEqualsExactOrder(MakeArray(events, new String[] { "a0", "b0", "b1" }), _myView.GetEnumerator());
stream.Insert(MakeArray(events, new String[] { "c0", "c1" }));
SupportViewDataChecker.CheckOldData(_childView, null);
SupportViewDataChecker.CheckNewData(_childView, MakeArray(events, new String[] { "c0", "c1" }));
EPAssertionUtil.AssertEqualsExactOrder(MakeArray(events, new String[] { "a0", "b0", "b1", "c0", "c1" }), _myView.GetEnumerator());
// Send further events, expect to get events back that fall out of the window (a0)
stream.Insert(MakeArray(events, new String[] { "d0" }));
SupportViewDataChecker.CheckOldData(_childView, MakeArray(events, new String[] { "a0" }));
SupportViewDataChecker.CheckNewData(_childView, MakeArray(events, new String[] { "d0" }));
EPAssertionUtil.AssertEqualsExactOrder(MakeArray(events, new String[] { "b0", "b1", "c0", "c1", "d0" }), _myView.GetEnumerator());
stream.Insert(MakeArray(events, new String[] { "e0", "e1", "e2" }));
SupportViewDataChecker.CheckOldData(_childView, MakeArray(events, new String[] { "b0", "b1", "c0" }));
SupportViewDataChecker.CheckNewData(_childView, MakeArray(events, new String[] { "e0", "e1", "e2" }));
EPAssertionUtil.AssertEqualsExactOrder(MakeArray(events, new String[] { "c1", "d0", "e0", "e1", "e2" }), _myView.GetEnumerator());
stream.Insert(MakeArray(events, new String[] { "f0", "f1" }));
SupportViewDataChecker.CheckOldData(_childView, MakeArray(events, new String[] { "c1", "d0" }));
SupportViewDataChecker.CheckNewData(_childView, MakeArray(events, new String[] { "f0", "f1" }));
EPAssertionUtil.AssertEqualsExactOrder(MakeArray(events, new String[] { "e0", "e1", "e2", "f0", "f1" }), _myView.GetEnumerator());
// Push as many events as the window takes
stream.Insert(MakeArray(events, new String[] { "g0", "g1", "g2", "g3", "g4" }));
SupportViewDataChecker.CheckOldData(_childView, MakeArray(events, new String[] { "e0", "e1", "e2", "f0", "f1" }));
SupportViewDataChecker.CheckNewData(_childView, MakeArray(events, new String[] { "g0", "g1", "g2", "g3", "g4" }));
EPAssertionUtil.AssertEqualsExactOrder(MakeArray(events, new String[] { "g0", "g1", "g2", "g3", "g4" }), _myView.GetEnumerator());
// Push 2 more events then the window takes
stream.Insert(MakeArray(events, new String[] { "h0", "h1", "h2", "h3", "h4", "h5", "h6" }));
SupportViewDataChecker.CheckOldData(_childView, MakeArray(events, new String[] { "g0", "g1", "g2", "g3", "g4", "h0", "h1" }));
SupportViewDataChecker.CheckNewData(_childView, MakeArray(events, new String[] { "h0", "h1", "h2", "h3", "h4", "h5", "h6" }));
EPAssertionUtil.AssertEqualsExactOrder(MakeArray(events, new String[] { "h2", "h3", "h4", "h5", "h6" }), _myView.GetEnumerator());
// Push 1 last event to make sure the last overflow was handled correctly
stream.Insert(MakeArray(events, new String[] { "i0" }));
SupportViewDataChecker.CheckOldData(_childView, MakeArray(events, new String[] { "h2" }));
SupportViewDataChecker.CheckNewData(_childView, MakeArray(events, new String[] { "i0" }));
EPAssertionUtil.AssertEqualsExactOrder(MakeArray(events, new String[] { "h3", "h4", "h5", "h6", "i0" }), _myView.GetEnumerator());
}
private void RunAssertionSubscribeAndIterate(EPServiceProvider epService)
{
string stmtCreateTextOne = "create variable long var1SAI = null";
EPStatement stmtCreateOne = epService.EPAdministrator.CreateEPL(stmtCreateTextOne);
Assert.AreEqual(StatementType.CREATE_VARIABLE, ((EPStatementSPI)stmtCreateOne).StatementMetadata.StatementType);
var listenerCreateOne = new SupportUpdateListener();
stmtCreateOne.Events += listenerCreateOne.Update;
var fieldsVar1 = new string[] { "var1SAI" };
EPAssertionUtil.AssertPropsPerRow(stmtCreateOne.GetEnumerator(), fieldsVar1, new object[][] { new object[] { null } });
Assert.IsFalse(listenerCreateOne.IsInvoked);
EventType typeSet = stmtCreateOne.EventType;
Assert.AreEqual(typeof(long?), typeSet.GetPropertyType("var1SAI"));
Assert.AreEqual(typeof(Map), typeSet.UnderlyingType);
Assert.IsTrue(Collections.AreEqual(typeSet.PropertyNames, new string[] { "var1SAI" }));
string stmtCreateTextTwo = "create variable long var2SAI = 20";
EPStatement stmtCreateTwo = epService.EPAdministrator.CreateEPL(stmtCreateTextTwo);
var listenerCreateTwo = new SupportUpdateListener();
stmtCreateTwo.Events += listenerCreateTwo.Update;
var fieldsVar2 = new string[] { "var2SAI" };
EPAssertionUtil.AssertPropsPerRow(stmtCreateTwo.GetEnumerator(), fieldsVar2, new object[][] { new object[] { 20L } });
Assert.IsFalse(listenerCreateTwo.IsInvoked);
string stmtTextSet = "on " + typeof(SupportBean).FullName + " set var1SAI = IntPrimitive * 2, var2SAI = var1SAI + 1";
epService.EPAdministrator.CreateEPL(stmtTextSet);
SendSupportBean(epService, "E1", 100);
EPAssertionUtil.AssertProps(listenerCreateOne.LastNewData[0], fieldsVar1, new object[] { 200L });
EPAssertionUtil.AssertProps(listenerCreateOne.LastOldData[0], fieldsVar1, new object[] { null });
listenerCreateOne.Reset();
EPAssertionUtil.AssertProps(listenerCreateTwo.LastNewData[0], fieldsVar2, new object[] { 201L });
EPAssertionUtil.AssertProps(listenerCreateTwo.LastOldData[0], fieldsVar2, new object[] { 20L });
listenerCreateOne.Reset();
EPAssertionUtil.AssertPropsPerRow(stmtCreateOne.GetEnumerator(), fieldsVar1, new object[][] { new object[] { 200L } });
EPAssertionUtil.AssertPropsPerRow(stmtCreateTwo.GetEnumerator(), fieldsVar2, new object[][] { new object[] { 201L } });
SendSupportBean(epService, "E2", 200);
EPAssertionUtil.AssertProps(listenerCreateOne.LastNewData[0], fieldsVar1, new object[] { 400L });
EPAssertionUtil.AssertProps(listenerCreateOne.LastOldData[0], fieldsVar1, new object[] { 200L });
listenerCreateOne.Reset();
EPAssertionUtil.AssertProps(listenerCreateTwo.LastNewData[0], fieldsVar2, new object[] { 401L });
EPAssertionUtil.AssertProps(listenerCreateTwo.LastOldData[0], fieldsVar2, new object[] { 201L });
listenerCreateOne.Reset();
EPAssertionUtil.AssertPropsPerRow(stmtCreateOne.GetEnumerator(), fieldsVar1, new object[][] { new object[] { 400L } });
EPAssertionUtil.AssertPropsPerRow(stmtCreateTwo.GetEnumerator(), fieldsVar2, new object[][] { new object[] { 401L } });
stmtCreateTwo.Stop();
stmtCreateTwo.Start();
EPAssertionUtil.AssertPropsPerRow(stmtCreateOne.GetEnumerator(), fieldsVar1, new object[][] { new object[] { 400L } });
EPAssertionUtil.AssertPropsPerRow(stmtCreateTwo.GetEnumerator(), fieldsVar2, new object[][] { new object[] { 20L } });
epService.EPAdministrator.DestroyAllStatements();
}
public void TestLeftOuterJoin()
{
EPStatement outerJoinView = SetupStatement("left");
// Send S1 events, no events expected
SendEvent(_eventsS1[0]);
SendEvent(_eventsS1[1]);
SendEvent(_eventsS1[3]);
Assert.IsNull(_listener.LastNewData); // No events expected
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields, null);
// Send S0 event, expect event back from outer join
SendEvent(_eventsS0[2]);
EventBean theEvent = _listener.AssertOneGetNewAndReset();
CompareEvent(theEvent, 102, "2", null, null);
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields,
new[] { new Object[] { 102, "2", null, null } });
// Send S1 event matching S0, expect event back
SendEvent(_eventsS1[2]);
theEvent = _listener.AssertOneGetNewAndReset();
CompareEvent(theEvent, 102, "2", 202, "2");
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields,
new[] { new Object[] { 102, "2", 202, "2" } });
// Send some more unmatched events
SendEvent(_eventsS1[4]);
SendEvent(_eventsS1[5]);
SendEvent(_eventsS1[6]);
Assert.IsNull(_listener.LastNewData); // No events expected
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields,
new[] { new Object[] { 102, "2", 202, "2" } });
// Send event, expect a join result
SendEvent(_eventsS0[5]);
theEvent = _listener.AssertOneGetNewAndReset();
CompareEvent(theEvent, 105, "5", 205, "5");
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields,
new[]
{
new Object[] { 102, "2", 202, "2" },
new Object[] { 105, "5", 205, "5" }
});
// Let S1[2] go out of the window (lenght 5), expected old join event
SendEvent(_eventsS1[7]);
SendEvent(_eventsS1[8]);
theEvent = _listener.AssertOneGetOldAndReset();
CompareEvent(theEvent, 102, "2", 202, "2");
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields,
new[]
{
new Object[] { 102, "2", null, null },
new Object[] { 105, "5", 205, "5" }
});
// S0[9] should generate an outer join event
SendEvent(_eventsS0[9]);
theEvent = _listener.AssertOneGetNewAndReset();
CompareEvent(theEvent, 109, "9", null, null);
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields,
new[]
{
new Object[] { 102, "2", null, null },
new Object[] { 109, "9", null, null },
new Object[] { 105, "5", 205, "5" }
});
// S0[2] Should leave the window (length 3), should get OLD and NEW event
SendEvent(_eventsS0[10]);
EventBean oldEvent = _listener.LastOldData[0];
EventBean newEvent = _listener.LastNewData[0];
CompareEvent(oldEvent, 102, "2", null, null); // S1[2] has left the window already
CompareEvent(newEvent, 110, "10", null, null);
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields,
new[]
{
new Object[] { 110, "10", null, null },
new Object[] { 109, "9", null, null },
new Object[] { 105, "5", 205, "5" }
});
}
public void TestMath()
{
var stmt = _epService.EPAdministrator.CreateEPL("select * from SupportBeanNumeric " +
"where DecimalOne+BigInt=100 or DecimalOne+1=2 or DecimalOne+2d=5.0 or BigInt+5L=8 or BigInt+5d=9.0");
stmt.AddListener(_listener);
SendBigNumEvent(50, 49);
Assert.IsFalse(_listener.GetAndClearIsInvoked());
SendBigNumEvent(50, 50);
Assert.IsTrue(_listener.GetAndClearIsInvoked());
SendBigNumEvent(0, 1);
Assert.IsTrue(_listener.GetAndClearIsInvoked());
SendBigNumEvent(0, 2);
Assert.IsFalse(_listener.GetAndClearIsInvoked());
SendBigNumEvent(0, 3);
Assert.IsTrue(_listener.GetAndClearIsInvoked());
SendBigNumEvent(0, 0);
Assert.IsFalse(_listener.GetAndClearIsInvoked());
SendBigNumEvent(3, 0);
Assert.IsTrue(_listener.GetAndClearIsInvoked());
SendBigNumEvent(4, 0);
Assert.IsTrue(_listener.GetAndClearIsInvoked());
stmt.Dispose();
stmt = _epService.EPAdministrator.CreateEPL(
"select DecimalOne+BigInt as v1, DecimalOne+2 as v2, DecimalOne+3d as v3, BigInt+5L as v4, BigInt+5d as v5 " +
" from SupportBeanNumeric");
stmt.AddListener(_listener);
_listener.Reset();
Assert.AreEqual(typeof(decimal?), stmt.EventType.GetPropertyType("v1"));
Assert.AreEqual(typeof(decimal?), stmt.EventType.GetPropertyType("v2"));
Assert.AreEqual(typeof(decimal?), stmt.EventType.GetPropertyType("v3"));
Assert.AreEqual(typeof(BigInteger?), stmt.EventType.GetPropertyType("v4"));
Assert.AreEqual(typeof(decimal?), stmt.EventType.GetPropertyType("v5"));
SendBigNumEvent(1, 2);
var theEvent = _listener.AssertOneGetNewAndReset();
EPAssertionUtil.AssertProps(theEvent, "v1,v2,v3,v4,v5".Split(','),
new object[] { 3m, 4m, 5m, new BigInteger(6), 6m });
// test aggregation-sum, multiplication and division all together; test for ESPER-340
stmt.Dispose();
stmt = _epService.EPAdministrator.CreateEPL(
"select (sum(DecimalTwo * DecimalOne)/sum(DecimalOne)) as avgRate from SupportBeanNumeric");
stmt.AddListener(_listener);
_listener.Reset();
Assert.AreEqual(typeof(decimal?), stmt.EventType.GetPropertyType("avgRate"));
SendBigNumEvent(0, 5);
var avgRate = _listener.AssertOneGetNewAndReset().Get("avgRate");
Assert.IsTrue(avgRate is decimal);
Assert.AreEqual(5m, avgRate);
}
public void TestRevision()
{
EPStatement consumerOne = _epService.EPAdministrator.CreateEPL("select * from RevQuote");
consumerOne.Events += _listenerOne.Update;
EPStatement consumerTwo = _epService.EPAdministrator.CreateEPL("select K0, count(*) as count, sum(Int64.Parse(P0)) as sum from RevQuote group by K0");
consumerTwo.Events += _listenerTwo.Update;
EPStatement consumerThree = _epService.EPAdministrator.CreateEPL("select * from RevQuote output every 2 events");
consumerThree.Events += _listenerThree.Update;
String[] agg = "K0,count,sum".Split(',');
_epService.EPRuntime.SendEvent(new SupportRevisionFull("K00", "01", "P10", "20", "P30", "40", "50"));
EPAssertionUtil.AssertProps(_listenerOne.AssertOneGetNewAndReset(), _fields, new Object[] { "K00", "01", "P10", "20", "P30", "40", "50" });
EPAssertionUtil.AssertProps(_stmtCreateWin.First(), _fields, new Object[] { "K00", "01", "P10", "20", "P30", "40", "50" });
EPAssertionUtil.AssertProps(_listenerTwo.AssertOneGetNewAndReset(), agg, new Object[] { "K00", 1L, 1L });
Assert.IsFalse(_listenerThree.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportDeltaThree("K00", "03", "41"));
EPAssertionUtil.AssertProps(_listenerOne.AssertOneGetNewAndReset(), _fields, new Object[] { "K00", "03", "P10", "20", "P30", "41", "50" });
EPAssertionUtil.AssertProps(_stmtCreateWin.First(), _fields, new Object[] { "K00", "03", "P10", "20", "P30", "41", "50" });
EPAssertionUtil.AssertProps(_listenerTwo.AssertOneGetNewAndReset(), agg, new Object[] { "K00", 1L, 3L });
EPAssertionUtil.AssertProps(_listenerThree.LastNewData[0], _fields, new Object[] { "K00", "01", "P10", "20", "P30", "40", "50" });
EPAssertionUtil.AssertProps(_listenerThree.LastNewData[1], _fields, new Object[] { "K00", "03", "P10", "20", "P30", "41", "50" });
_listenerThree.Reset();
_epService.EPRuntime.SendEvent(new SupportDeltaOne("K00", "P11", "51"));
EPAssertionUtil.AssertProps(_listenerOne.AssertOneGetNewAndReset(), _fields, new Object[] { "K00", "03", "P11", "20", "P30", "41", "51" });
EPAssertionUtil.AssertProps(_stmtCreateWin.First(), _fields, new Object[] { "K00", "03", "P11", "20", "P30", "41", "51" });
EPAssertionUtil.AssertProps(_listenerTwo.AssertOneGetNewAndReset(), agg, new Object[] { "K00", 1L, 3L });
Assert.IsFalse(_listenerThree.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportDeltaTwo("K00", "04", "21", "P31"));
EPAssertionUtil.AssertProps(_listenerOne.AssertOneGetNewAndReset(), _fields, new Object[] { "K00", "04", "P11", "21", "P31", "41", "51" });
EPAssertionUtil.AssertProps(_stmtCreateWin.First(), _fields, new Object[] { "K00", "04", "P11", "21", "P31", "41", "51" });
EPAssertionUtil.AssertProps(_listenerTwo.AssertOneGetNewAndReset(), agg, new Object[] { "K00", 1L, 4L });
EPAssertionUtil.AssertProps(_listenerThree.LastNewData[0], _fields, new Object[] { "K00", "03", "P11", "20", "P30", "41", "51" });
EPAssertionUtil.AssertProps(_listenerThree.LastNewData[1], _fields, new Object[] { "K00", "04", "P11", "21", "P31", "41", "51" });
_listenerThree.Reset();
_epService.EPRuntime.SendEvent(new SupportDeltaFour("K00", "05", "22", "52"));
EPAssertionUtil.AssertProps(_listenerOne.AssertOneGetNewAndReset(), _fields, new Object[] { "K00", "05", "P11", "22", "P31", "41", "52" });
EPAssertionUtil.AssertProps(_stmtCreateWin.First(), _fields, new Object[] { "K00", "05", "P11", "22", "P31", "41", "52" });
EPAssertionUtil.AssertProps(_listenerTwo.AssertOneGetNewAndReset(), agg, new Object[] { "K00", 1L, 5L });
Assert.IsFalse(_listenerThree.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportDeltaFive("K00", "P12", "53"));
EPAssertionUtil.AssertProps(_listenerOne.AssertOneGetNewAndReset(), _fields, new Object[] { "K00", "05", "P12", "22", "P31", "41", "53" });
EPAssertionUtil.AssertProps(_stmtCreateWin.First(), _fields, new Object[] { "K00", "05", "P12", "22", "P31", "41", "53" });
EPAssertionUtil.AssertProps(_listenerTwo.AssertOneGetNewAndReset(), agg, new Object[] { "K00", 1L, 5L });
EPAssertionUtil.AssertProps(_listenerThree.LastNewData[0], _fields, new Object[] { "K00", "05", "P11", "22", "P31", "41", "52" });
EPAssertionUtil.AssertProps(_listenerThree.LastNewData[1], _fields, new Object[] { "K00", "05", "P12", "22", "P31", "41", "53" });
_listenerThree.Reset();
_epService.EPRuntime.SendEvent(new SupportRevisionFull("K00", "06", "P13", "23", "P32", "42", "54"));
EPAssertionUtil.AssertProps(_listenerOne.AssertOneGetNewAndReset(), _fields, new Object[] { "K00", "06", "P13", "23", "P32", "42", "54" });
EPAssertionUtil.AssertProps(_stmtCreateWin.First(), _fields, new Object[] { "K00", "06", "P13", "23", "P32", "42", "54" });
EPAssertionUtil.AssertProps(_listenerTwo.AssertOneGetNewAndReset(), agg, new Object[] { "K00", 1L, 6L });
Assert.IsFalse(_listenerThree.IsInvoked);
_epService.EPRuntime.SendEvent(new SupportDeltaOne("K00", "P14", "55"));
EPAssertionUtil.AssertProps(_listenerOne.AssertOneGetNewAndReset(), _fields, new Object[] { "K00", "06", "P14", "23", "P32", "42", "55" });
EPAssertionUtil.AssertProps(_stmtCreateWin.First(), _fields, new Object[] { "K00", "06", "P14", "23", "P32", "42", "55" });
EPAssertionUtil.AssertProps(_listenerTwo.AssertOneGetNewAndReset(), agg, new Object[] { "K00", 1L, 6L });
EPAssertionUtil.AssertProps(_listenerThree.LastNewData[0], _fields, new Object[] { "K00", "06", "P13", "23", "P32", "42", "54" });
EPAssertionUtil.AssertProps(_listenerThree.LastNewData[1], _fields, new Object[] { "K00", "06", "P14", "23", "P32", "42", "55" });
_listenerThree.Reset();
}
public void TestOnDelete()
{
EPStatement consumerOne = _epService.EPAdministrator.CreateEPL("select irstream * from RevQuote");
consumerOne.Events += _listenerOne.Update;
_epService.EPAdministrator.CreateEPL("on SupportBean(IntPrimitive=2) as sb delete from RevQuote where TheString = P2");
Log.Debug("a00");
_epService.EPRuntime.SendEvent(new SupportRevisionFull("a", "a00", "a10", "a20", "a30", "a40", "a50"));
EPAssertionUtil.AssertProps(_listenerOne.AssertOneGetNewAndReset(), _fields, new Object[] { "a", "a00", "a10", "a20", "a30", "a40", "a50" });
_epService.EPRuntime.SendEvent(new SupportDeltaThree("x", "03", "41"));
Assert.IsFalse(_listenerOne.IsInvoked);
_epService.EPAdministrator.CreateEPL("on SupportBean(IntPrimitive=3) as sb delete from RevQuote where TheString = P3");
Log.Debug("b00");
_epService.EPRuntime.SendEvent(new SupportRevisionFull("b", "b00", "b10", "b20", "b30", "b40", "b50"));
EPAssertionUtil.AssertProps(_listenerOne.AssertOneGetNewAndReset(), _fields, new Object[] { "b", "b00", "b10", "b20", "b30", "b40", "b50" });
Log.Debug("a01");
_epService.EPRuntime.SendEvent(new SupportDeltaThree("a", "a01", "a41"));
EPAssertionUtil.AssertProps(_listenerOne.LastNewData[0], _fields, new Object[] { "a", "a01", "a10", "a20", "a30", "a41", "a50" });
EPAssertionUtil.AssertProps(_listenerOne.LastOldData[0], _fields, new Object[] { "a", "a00", "a10", "a20", "a30", "a40", "a50" });
_listenerOne.Reset();
Log.Debug("c00");
_epService.EPRuntime.SendEvent(new SupportRevisionFull("c", "c00", "c10", "c20", "c30", "c40", "c50"));
EPAssertionUtil.AssertProps(_listenerOne.AssertOneGetNewAndReset(), _fields, new Object[] { "c", "c00", "c10", "c20", "c30", "c40", "c50" });
_epService.EPAdministrator.CreateEPL("on SupportBean(IntPrimitive=0) as sb delete from RevQuote where TheString = P0");
Log.Debug("c11");
_epService.EPRuntime.SendEvent(new SupportDeltaFive("c", "c11", "c51"));
EPAssertionUtil.AssertProps(_listenerOne.LastNewData[0], _fields, new Object[] { "c", "c00", "c11", "c20", "c30", "c40", "c51" });
EPAssertionUtil.AssertProps(_listenerOne.LastOldData[0], _fields, new Object[] { "c", "c00", "c10", "c20", "c30", "c40", "c50" });
_listenerOne.Reset();
_epService.EPAdministrator.CreateEPL("on SupportBean(IntPrimitive=1) as sb delete from RevQuote where TheString = P1");
Log.Debug("d00");
_epService.EPRuntime.SendEvent(new SupportRevisionFull("d", "d00", "d10", "d20", "d30", "d40", "d50"));
EPAssertionUtil.AssertProps(_listenerOne.AssertOneGetNewAndReset(), _fields, new Object[] { "d", "d00", "d10", "d20", "d30", "d40", "d50" });
Log.Debug("d01");
_epService.EPRuntime.SendEvent(new SupportDeltaFour("d", "d01", "d21", "d51"));
EPAssertionUtil.AssertProps(_listenerOne.LastNewData[0], _fields, new Object[] { "d", "d01", "d10", "d21", "d30", "d40", "d51" });
EPAssertionUtil.AssertProps(_listenerOne.LastOldData[0], _fields, new Object[] { "d", "d00", "d10", "d20", "d30", "d40", "d50" });
_listenerOne.Reset();
EPAssertionUtil.AssertPropsPerRow(_stmtCreateWin.GetEnumerator(), _fields,
new Object[][] { new Object[] { "b", "b00", "b10", "b20", "b30", "b40", "b50" }, new Object[] { "a", "a01", "a10", "a20", "a30", "a41", "a50" },
new Object[] { "c", "c00", "c11", "c20", "c30", "c40", "c51" }, new Object[] { "d", "d01", "d10", "d21", "d30", "d40", "d51" } });
_epService.EPAdministrator.CreateEPL("on SupportBean(IntPrimitive=4) as sb delete from RevQuote where TheString = P4");
_epService.EPRuntime.SendEvent(new SupportBean("abc", 1));
Assert.IsFalse(_listenerOne.IsInvoked);
Log.Debug("delete b");
_epService.EPRuntime.SendEvent(new SupportBean("b40", 4)); // delete b
EPAssertionUtil.AssertProps(_listenerOne.AssertOneGetOldAndReset(), _fields, new Object[] { "b", "b00", "b10", "b20", "b30", "b40", "b50" });
EPAssertionUtil.AssertPropsPerRow(_stmtCreateWin.GetEnumerator(), _fields,
new Object[][] { new Object[] { "a", "a01", "a10", "a20", "a30", "a41", "a50" }, new Object[] { "c", "c00", "c11", "c20", "c30", "c40", "c51" }, new Object[] { "d", "d01", "d10", "d21", "d30", "d40", "d51" } });
Log.Debug("delete d");
_epService.EPRuntime.SendEvent(new SupportBean("d21", 2)); // delete d
EPAssertionUtil.AssertProps(_listenerOne.AssertOneGetOldAndReset(), _fields, new Object[] { "d", "d01", "d10", "d21", "d30", "d40", "d51" });
EPAssertionUtil.AssertPropsPerRow(_stmtCreateWin.GetEnumerator(), _fields,
new Object[][] { new Object[] { "a", "a01", "a10", "a20", "a30", "a41", "a50" }, new Object[] { "c", "c00", "c11", "c20", "c30", "c40", "c51" } });
Log.Debug("delete a");
_epService.EPRuntime.SendEvent(new SupportBean("a30", 3)); // delete a
EPAssertionUtil.AssertProps(_listenerOne.AssertOneGetOldAndReset(), _fields, new Object[] { "a", "a01", "a10", "a20", "a30", "a41", "a50" });
EPAssertionUtil.AssertPropsPerRow(_stmtCreateWin.GetEnumerator(), _fields, new Object[][] { new Object[] { "c", "c00", "c11", "c20", "c30", "c40", "c51" } });
Log.Debug("delete c");
_epService.EPRuntime.SendEvent(new SupportBean("c11", 1)); // delete c
EPAssertionUtil.AssertProps(_listenerOne.AssertOneGetOldAndReset(), _fields, new Object[] { "c", "c00", "c11", "c20", "c30", "c40", "c51" });
EPAssertionUtil.AssertPropsPerRow(_stmtCreateWin.GetEnumerator(), _fields, null);
_epService.EPRuntime.SendEvent(new SupportBean("c11", 1));
Assert.IsFalse(_listenerOne.IsInvoked);
}
public void TestMinMaxBy()
{
String[] fields = "val0,val1,val2,val3".SplitCsv();
String eplFragment = "select " +
"contained.MinBy(x => p00) as val0," +
"contained.MaxBy(x => p00) as val1," +
"contained.MinBy(x => p00).id as val2," +
"contained.MaxBy(x => p00).P00 as val3 " +
"from Bean";
EPStatement stmtFragment = _epService.EPAdministrator.CreateEPL(eplFragment);
stmtFragment.Events += _listener.Update;
LambdaAssertionUtil.AssertTypes(stmtFragment.EventType, fields, new Type[] { typeof(SupportBean_ST0), typeof(SupportBean_ST0), typeof(string), typeof(int?) });
SupportBean_ST0_Container bean = SupportBean_ST0_Container.Make2Value("E1,12", "E2,11", "E2,2");
_epService.EPRuntime.SendEvent(bean);
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields,
new Object[] { bean.Contained[2], bean.Contained[0], "E2", 12 });
bean = SupportBean_ST0_Container.Make2Value("E1,12");
_epService.EPRuntime.SendEvent(bean);
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields,
new Object[] { bean.Contained[0], bean.Contained[0], "E1", 12 });
_epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value(null));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields,
new Object[] { null, null, null, null });
_epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value());
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields,
new Object[] { null, null, null, null });
stmtFragment.Dispose();
// test scalar-coll with lambda
String[] fieldsLambda = "val0,val1".Split(',');
_epService.EPAdministrator.Configuration.AddPlugInSingleRowFunction("extractNum", typeof(TestEnumMinMax.MyService).FullName, "ExtractNum");
String eplLambda = "select " +
"Strvals.minBy(v => extractNum(v)) as val0, " +
"Strvals.maxBy(v => extractNum(v)) as val1 " +
"from SupportCollection";
EPStatement stmtLambda = _epService.EPAdministrator.CreateEPL(eplLambda);
stmtLambda.Events += _listener.Update;
LambdaAssertionUtil.AssertTypes(stmtLambda.EventType, fieldsLambda, new [] { typeof(string), typeof(string) });
_epService.EPRuntime.SendEvent(SupportCollection.MakeString("E2,E1,E5,E4"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsLambda, new Object[] { "E1", "E5" });
_epService.EPRuntime.SendEvent(SupportCollection.MakeString("E1"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsLambda, new Object[] { "E1", "E1" });
_listener.Reset();
_epService.EPRuntime.SendEvent(SupportCollection.MakeString(null));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsLambda, new Object[] { null, null });
_listener.Reset();
_epService.EPRuntime.SendEvent(SupportCollection.MakeString(""));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsLambda, new Object[] { null, null });
}
public void TestMultiPropertyMapMixin()
{
String[] fields = "K0,P1,P5,m0".Split(',');
_stmtCreateWin =
_epService.EPAdministrator.CreateEPL("create window RevMap#length(3) as select * from RevisableMap");
_epService.EPAdministrator.CreateEPL("insert into RevMap select * from MyMap");
_epService.EPAdministrator.CreateEPL("insert into RevMap select * from D1");
_epService.EPAdministrator.CreateEPL("insert into RevMap select * from D5");
EPStatement consumerOne = _epService.EPAdministrator.CreateEPL("select irstream * from RevMap order by K0");
consumerOne.Events += _listenerOne.Update;
_epService.EPRuntime.SendEvent(
MakeMap(new Object[][]
{
new Object[] { "P5", "P5_1" }, new Object[] { "P1", "P1_1" }, new Object[] { "K0", "E1" },
new Object[] { "m0", "M0" }
}), "MyMap");
EPAssertionUtil.AssertProps(_listenerOne.AssertOneGetNewAndReset(), fields,
new Object[] { "E1", "P1_1", "P5_1", "M0" });
_epService.EPRuntime.SendEvent(new SupportDeltaFive("E2", "P1_1", "P5_1"));
EPAssertionUtil.AssertProps(_listenerOne.LastNewData[0], fields,
new Object[] { "E2", "P1_1", "P5_1", "M0" });
EPAssertionUtil.AssertProps(_listenerOne.LastOldData[0], fields,
new Object[] { "E1", "P1_1", "P5_1", "M0" });
EPAssertionUtil.AssertProps(_stmtCreateWin.First(), fields, new Object[] { "E2", "P1_1", "P5_1", "M0" });
_listenerOne.Reset();
_epService.EPRuntime.SendEvent(
MakeMap(new Object[][]
{
new Object[] { "P5", "P5_1" }, new Object[] { "P1", "P1_2" }, new Object[] { "K0", "E3" },
new Object[] { "m0", "M1" }
}), "MyMap");
EPAssertionUtil.AssertPropsPerRow(_stmtCreateWin.GetEnumerator(), fields,
new Object[][]
{
new Object[] { "E2", "P1_1", "P5_1", "M0" },
new Object[] { "E3", "P1_2", "P5_1", "M1" }
});
_epService.EPRuntime.SendEvent(new SupportDeltaFive("E4", "P1_1", "P5_1"));
EPAssertionUtil.AssertProps(_listenerOne.LastNewData[0], fields,
new Object[] { "E4", "P1_1", "P5_1", "M0" });
EPAssertionUtil.AssertProps(_listenerOne.LastOldData[0], fields,
new Object[] { "E2", "P1_1", "P5_1", "M0" });
EPAssertionUtil.AssertPropsPerRow(_stmtCreateWin.GetEnumerator(), fields,
new Object[][]
{
new Object[] { "E3", "P1_2", "P5_1", "M1" },
new Object[] { "E4", "P1_1", "P5_1", "M0" }
});
_listenerOne.Reset();
_epService.EPRuntime.SendEvent(
MakeMap(new Object[][]
{
new Object[] { "P5", "P5_2" }, new Object[] { "P1", "P1_1" }, new Object[] { "K0", "E5" },
new Object[] { "m0", "M2" }
}), "MyMap");
EPAssertionUtil.AssertProps(_listenerOne.AssertOneGetNewAndReset(), fields,
new Object[] { "E5", "P1_1", "P5_2", "M2" });
EPAssertionUtil.AssertPropsPerRow(_stmtCreateWin.GetEnumerator(), fields,
new Object[][]
{
new Object[] { "E3", "P1_2", "P5_1", "M1" },
new Object[] { "E4", "P1_1", "P5_1", "M0" },
new Object[] { "E5", "P1_1", "P5_2", "M2" }
});
_epService.EPRuntime.SendEvent(new SupportDeltaOne("E6", "P1_1", "P5_2"));
EPAssertionUtil.AssertProps(_listenerOne.AssertPairGetIRAndReset(), fields,
new Object[] { "E6", "P1_1", "P5_2", "M2" },
new Object[] { "E5", "P1_1", "P5_2", "M2" });
}
private void AssertReceived(SupportUpdateListener testListener, long newTrendCount, long?oldTrendCount)
{
EPAssertionUtil.AssertPropsPerRow(testListener.AssertInvokedAndReset(), "trendcount", new object[] { newTrendCount }, new object[] { oldTrendCount });
}
public void TestGroupDelivery()
{
SendTimer(0);
EPStatement stmt = _epService.EPAdministrator.CreateEPL("select * from SupportBean#time_batch(1) for grouped_delivery (IntPrimitive)");
stmt.Events += _listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
_epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
_epService.EPRuntime.SendEvent(new SupportBean("E3", 1));
SendTimer(1000);
Assert.AreEqual(2, _listener.NewDataList.Count);
Assert.AreEqual(2, _listener.NewDataList[0].Length);
EPAssertionUtil.AssertPropsPerRow(_listener.NewDataList[0], "TheString,IntPrimitive".Split(','), new Object[][] { new Object[] { "E1", 1 }, new Object[] { "E3", 1 } });
Assert.AreEqual(1, _listener.NewDataList[1].Length);
EPAssertionUtil.AssertPropsPerRow(_listener.NewDataList[1], "TheString,IntPrimitive".Split(','), new Object[][] { new Object[] { "E2", 2 } });
// test sorted
stmt.Dispose();
stmt = _epService.EPAdministrator.CreateEPL("select * from SupportBean#time_batch(1) order by IntPrimitive desc for grouped_delivery (IntPrimitive)");
stmt.Events += _listener.Update;
_listener.Reset();
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
_epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
_epService.EPRuntime.SendEvent(new SupportBean("E3", 1));
SendTimer(2000);
Assert.AreEqual(2, _listener.NewDataList.Count);
Assert.AreEqual(1, _listener.NewDataList[0].Length);
EPAssertionUtil.AssertPropsPerRow(_listener.NewDataList[0], "TheString,IntPrimitive".Split(','), new Object[][] { new Object[] { "E2", 2 } });
Assert.AreEqual(2, _listener.NewDataList[1].Length);
EPAssertionUtil.AssertPropsPerRow(_listener.NewDataList[1], "TheString,IntPrimitive".Split(','), new Object[][] { new Object[] { "E1", 1 }, new Object[] { "E3", 1 } });
// test multiple criteria
stmt.Dispose();
String stmtText = "select TheString, DoubleBoxed, EnumValue from SupportBean#time_batch(1) order by TheString, DoubleBoxed, EnumValue for grouped_delivery(DoubleBoxed, EnumValue)";
stmt = _epService.EPAdministrator.CreateEPL(stmtText);
stmt.Events += _listener.Update;
_listener.Reset();
SendEvent("E1", 10d, SupportEnum.ENUM_VALUE_2); // A (1)
SendEvent("E2", 11d, SupportEnum.ENUM_VALUE_1); // B (2)
SendEvent("E3", 9d, SupportEnum.ENUM_VALUE_2); // C (3)
SendEvent("E4", 10d, SupportEnum.ENUM_VALUE_2); // A
SendEvent("E5", 10d, SupportEnum.ENUM_VALUE_1); // D (4)
SendEvent("E6", 10d, SupportEnum.ENUM_VALUE_1); // D
SendEvent("E7", 11d, SupportEnum.ENUM_VALUE_1); // B
SendEvent("E8", 10d, SupportEnum.ENUM_VALUE_1); // D
SendTimer(3000);
Assert.AreEqual(4, _listener.NewDataList.Count);
String[] fields = "TheString,DoubleBoxed,EnumValue".Split(',');
EPAssertionUtil.AssertPropsPerRow(_listener.NewDataList[0], fields,
new Object[][] { new Object[] { "E1", 10d, SupportEnum.ENUM_VALUE_2 }, new Object[] { "E4", 10d, SupportEnum.ENUM_VALUE_2 } });
EPAssertionUtil.AssertPropsPerRow(_listener.NewDataList[1], fields,
new Object[][] { new Object[] { "E2", 11d, SupportEnum.ENUM_VALUE_1 }, new Object[] { "E7", 11d, SupportEnum.ENUM_VALUE_1 } });
EPAssertionUtil.AssertPropsPerRow(_listener.NewDataList[2], fields,
new Object[][] { new Object[] { "E3", 9d, SupportEnum.ENUM_VALUE_2 } });
EPAssertionUtil.AssertPropsPerRow(_listener.NewDataList[3], fields,
new Object[][] { new Object[] { "E5", 10d, SupportEnum.ENUM_VALUE_1 }, new Object[] { "E6", 10d, SupportEnum.ENUM_VALUE_1 }, new Object[] { "E8", 10d, SupportEnum.ENUM_VALUE_1 } });
// test SODA
stmt.Dispose();
_listener.Reset();
EPStatementObjectModel model = _epService.EPAdministrator.CompileEPL(stmtText);
Assert.AreEqual(stmtText, model.ToEPL());
stmt = _epService.EPAdministrator.Create(model);
stmt.Events += _listener.Update;
SendEvent("E1", 10d, SupportEnum.ENUM_VALUE_2); // A (1)
SendEvent("E2", 11d, SupportEnum.ENUM_VALUE_1); // B (2)
SendEvent("E3", 11d, SupportEnum.ENUM_VALUE_1); // B (2)
SendTimer(4000);
Assert.AreEqual(2, _listener.NewDataList.Count);
EPAssertionUtil.AssertPropsPerRow(_listener.NewDataList[0], fields,
new Object[][] { new Object[] { "E1", 10d, SupportEnum.ENUM_VALUE_2 } });
EPAssertionUtil.AssertPropsPerRow(_listener.NewDataList[1], fields,
new Object[][] { new Object[] { "E2", 11d, SupportEnum.ENUM_VALUE_1 }, new Object[] { "E3", 11d, SupportEnum.ENUM_VALUE_1 } });
}
public void TestGroupByEventForAll()
{
_epService.EPAdministrator.CreateEPL("@Name('context') create context SegmentedByString partition by TheString from SupportBean");
// test aggregation-only (no access)
var fieldsOne = "col1".Split(',');
var stmtOne = _epService.EPAdministrator.CreateEPL("@Name('A') context SegmentedByString " +
"select Sum(IntPrimitive) as col1 " +
"from SupportBean");
stmtOne.Events += _listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean("G1", 3));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsOne, new Object[] { 3 });
_epService.EPRuntime.SendEvent(new SupportBean("G2", 2));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsOne, new Object[] { 2 });
_epService.EPRuntime.SendEvent(new SupportBean("G1", 4));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsOne, new Object[] { 7 });
_epService.EPRuntime.SendEvent(new SupportBean("G2", 1));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsOne, new Object[] { 3 });
_epService.EPRuntime.SendEvent(new SupportBean("G3", -1));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsOne, new Object[] { -1 });
stmtOne.Dispose();
// test mixed with access
var fieldsTwo = "col1,col2".Split(',');
var stmtTwo = _epService.EPAdministrator.CreateEPL("@Name('A') context SegmentedByString " +
"select Sum(IntPrimitive) as col1, ToArray(window(*).SelectFrom(v=>v.IntPrimitive)) as col2 " +
"from SupportBean.win:keepall()");
stmtTwo.Events += _listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean("G1", 8));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsTwo, new Object[] { 8, new Object[] { 8 } });
_epService.EPRuntime.SendEvent(new SupportBean("G2", 5));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsTwo, new Object[] { 5, new Object[] { 5 } });
_epService.EPRuntime.SendEvent(new SupportBean("G1", 1));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsTwo, new Object[] { 9, new Object[] { 8, 1 } });
_epService.EPRuntime.SendEvent(new SupportBean("G2", 2));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsTwo, new Object[] { 7, new Object[] { 5, 2 } });
stmtTwo.Dispose();
// test only access
var fieldsThree = "col1".Split(',');
var stmtThree = _epService.EPAdministrator.CreateEPL("@Name('A') context SegmentedByString " +
"select ToArray(window(*).SelectFrom(v=>v.IntPrimitive)) as col1 " +
"from SupportBean.win:keepall()");
stmtThree.Events += _listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean("G1", 8));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsThree, new Object[] { new Object[] { 8 } });
_epService.EPRuntime.SendEvent(new SupportBean("G2", 5));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsThree, new Object[] { new Object[] { 5 } });
_epService.EPRuntime.SendEvent(new SupportBean("G1", 1));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsThree, new Object[] { new Object[] { 8, 1 } });
_epService.EPRuntime.SendEvent(new SupportBean("G2", 2));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsThree, new Object[] { new Object[] { 5, 2 } });
stmtThree.Dispose();
// test subscriber
var stmtFour = _epService.EPAdministrator.CreateEPL("@Name('A') context SegmentedByString " +
"select Count(*) as col1 " +
"from SupportBean");
var subs = new SupportSubscriber();
stmtFour.Subscriber = subs;
_epService.EPRuntime.SendEvent(new SupportBean("G1", 1));
Assert.AreEqual(1L, subs.AssertOneGetNewAndReset());
_epService.EPRuntime.SendEvent(new SupportBean("G1", 1));
Assert.AreEqual(2L, subs.AssertOneGetNewAndReset());
_epService.EPRuntime.SendEvent(new SupportBean("G2", 2));
Assert.AreEqual(1L, subs.AssertOneGetNewAndReset());
}
private void RunQueryAssertion(string epl, string[] fields, object[][] expected)
{
var result = _epService.EPRuntime.ExecuteQuery(epl);
EPAssertionUtil.AssertPropsPerRow(result.Array, fields, expected);
}
public void SetUp()
{
Configuration config = SupportConfigFactory.GetConfiguration();
config.AddEventType("SupportBean", typeof(SupportBean));
config.AddEventType("FullEvent", typeof(SupportRevisionFull));
config.AddEventType("D1", typeof(SupportDeltaOne));
config.AddEventType("D2", typeof(SupportDeltaTwo));
config.AddEventType("D3", typeof(SupportDeltaThree));
config.AddEventType("D4", typeof(SupportDeltaFour));
config.AddEventType("D5", typeof(SupportDeltaFive));
ConfigurationRevisionEventType configRev = new ConfigurationRevisionEventType();
configRev.KeyPropertyNames = (new String[] { "K0" });
configRev.AddNameBaseEventType("FullEvent");
configRev.AddNameDeltaEventType("D1");
configRev.AddNameDeltaEventType("D2");
configRev.AddNameDeltaEventType("D3");
configRev.AddNameDeltaEventType("D4");
configRev.AddNameDeltaEventType("D5");
config.AddRevisionEventType("RevisableQuote", configRev);
_epService = EPServiceProviderManager.GetDefaultProvider(config);
_epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(_epService, GetType(), GetType().FullName);
}
_listenerOne = new SupportUpdateListener();
_listenerTwo = new SupportUpdateListener();
_listenerThree = new SupportUpdateListener();
_stmtCreateWin = _epService.EPAdministrator.CreateEPL("create window RevQuote.win:keepall() as select * from RevisableQuote");
_epService.EPAdministrator.CreateEPL("insert into RevQuote select * from FullEvent");
_epService.EPAdministrator.CreateEPL("insert into RevQuote select * from D1");
_epService.EPAdministrator.CreateEPL("insert into RevQuote select * from D2");
_epService.EPAdministrator.CreateEPL("insert into RevQuote select * from D3");
_epService.EPAdministrator.CreateEPL("insert into RevQuote select * from D4");
_epService.EPAdministrator.CreateEPL("insert into RevQuote select * from D5");
// assert type metadata
EventTypeSPI type = (EventTypeSPI)((EPServiceProviderSPI)_epService).ValueAddEventService.GetValueAddProcessor("RevQuote").ValueAddEventType;
Assert.AreEqual(null, type.Metadata.OptionalApplicationType);
Assert.AreEqual(null, type.Metadata.OptionalSecondaryNames);
Assert.AreEqual("RevisableQuote", type.Metadata.PrimaryName);
Assert.AreEqual("RevisableQuote", type.Metadata.PublicName);
Assert.AreEqual("RevisableQuote", type.Name);
Assert.AreEqual(TypeClass.REVISION, type.Metadata.TypeClass);
Assert.AreEqual(true, type.Metadata.IsApplicationConfigured);
Assert.AreEqual(true, type.Metadata.IsApplicationPreConfigured);
Assert.AreEqual(true, type.Metadata.IsApplicationPreConfiguredStatic);
EventType[] valueAddTypes = ((EPServiceProviderSPI)_epService).ValueAddEventService.ValueAddedTypes;
Assert.AreEqual(1, valueAddTypes.Length);
Assert.AreSame(type, valueAddTypes[0]);
EPAssertionUtil.AssertEqualsAnyOrder(new [] {
new EventPropertyDescriptor("K0", typeof(string), typeof(char), false, false, true, false, false),
new EventPropertyDescriptor("P0", typeof(string), typeof(char), false, false, true, false, false),
new EventPropertyDescriptor("P1", typeof(string), typeof(char), false, false, true, false, false),
new EventPropertyDescriptor("P2", typeof(string), typeof(char), false, false, true, false, false),
new EventPropertyDescriptor("P3", typeof(string), typeof(char), false, false, true, false, false),
new EventPropertyDescriptor("P4", typeof(string), typeof(char), false, false, true, false, false),
new EventPropertyDescriptor("P5", typeof(string), typeof(char), false, false, true, false, false)
}, type.PropertyDescriptors);
}
public void TestFullOuterJoin()
{
EPStatement outerJoinView = SetupStatement("full");
// Send S0[0]
SendEvent(_eventsS0[0]);
CompareEvent(_listener.AssertOneGetNewAndReset(), 100, "0", null, null);
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields,
new[] { new Object[] { 100, "0", null, null } });
// Send S1[1]
SendEvent(_eventsS1[1]);
CompareEvent(_listener.AssertOneGetNewAndReset(), null, null, 201, "1");
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields,
new[]
{
new Object[] { 100, "0", null, null },
new Object[] { null, null, 201, "1" }
});
// Send S1[2] and S0[2]
SendEvent(_eventsS1[2]);
CompareEvent(_listener.AssertOneGetNewAndReset(), null, null, 202, "2");
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields,
new[]
{
new Object[] { 100, "0", null, null },
new Object[] { null, null, 201, "1" },
new Object[] { null, null, 202, "2" }
});
SendEvent(_eventsS0[2]);
CompareEvent(_listener.AssertOneGetNewAndReset(), 102, "2", 202, "2");
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields,
new[]
{
new Object[] { 100, "0", null, null },
new Object[] { null, null, 201, "1" },
new Object[] { 102, "2", 202, "2" }
});
// Send S0[3] and S1[3]
SendEvent(_eventsS0[3]);
CompareEvent(_listener.AssertOneGetNewAndReset(), 103, "3", null, null);
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields,
new[]
{
new Object[] { 100, "0", null, null },
new Object[] { null, null, 201, "1" },
new Object[] { 102, "2", 202, "2" },
new Object[] { 103, "3", null, null }
});
SendEvent(_eventsS1[3]);
CompareEvent(_listener.AssertOneGetNewAndReset(), 103, "3", 203, "3");
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields,
new[]
{
new Object[] { 100, "0", null, null },
new Object[] { null, null, 201, "1" },
new Object[] { 102, "2", 202, "2" },
new Object[] { 103, "3", 203, "3" }
});
// Send S0[4], pushes S0[0] out of window
SendEvent(_eventsS0[4]);
EventBean oldEvent = _listener.LastOldData[0];
EventBean newEvent = _listener.LastNewData[0];
CompareEvent(oldEvent, 100, "0", null, null);
CompareEvent(newEvent, 104, "4", null, null);
_listener.Reset();
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields,
new[]
{
new Object[] { null, null, 201, "1" },
new Object[] { 102, "2", 202, "2" },
new Object[] { 103, "3", 203, "3" },
new Object[] { 104, "4", null, null }
});
// Send S1[4]
SendEvent(_eventsS1[4]);
CompareEvent(_listener.AssertOneGetNewAndReset(), 104, "4", 204, "4");
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields,
new[]
{
new Object[] { null, null, 201, "1" },
new Object[] { 102, "2", 202, "2" },
new Object[] { 103, "3", 203, "3" },
new Object[] { 104, "4", 204, "4" }
});
// Send S1[5]
SendEvent(_eventsS1[5]);
CompareEvent(_listener.AssertOneGetNewAndReset(), null, null, 205, "5");
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields,
new[]
{
new Object[] { null, null, 201, "1" },
new Object[] { 102, "2", 202, "2" },
new Object[] { 103, "3", 203, "3" },
new Object[] { 104, "4", 204, "4" },
new Object[] { null, null, 205, "5" }
});
// Send S1[6], pushes S1[1] out of window
SendEvent(_eventsS1[5]);
oldEvent = _listener.LastOldData[0];
newEvent = _listener.LastNewData[0];
CompareEvent(oldEvent, null, null, 201, "1");
CompareEvent(newEvent, null, null, 205, "5");
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields,
new[]
{
new Object[] { 102, "2", 202, "2" },
new Object[] { 103, "3", 203, "3" },
new Object[] { 104, "4", 204, "4" },
new Object[] { null, null, 205, "5" },
new Object[] { null, null, 205, "5" }
});
}
public void Run(RegressionEnvironment env)
{
// test 2-stream left outer join and SODA
//
var milestone = new AtomicLong();
env.AdvanceTime(1000);
var stmtTextLO = "@Name('s0') select sum(IntPrimitive) as c0, count(*) as c1 " +
"from pattern [every timer:interval(1)] unidirectional " +
"left outer join " +
"SupportBean#keepall";
env.CompileDeployAddListenerMile(stmtTextLO, "s0", milestone.GetAndIncrement());
TryAssertionPatternUniOuterJoinNoOn(env, 0);
env.UndeployAll();
env.EplToModelCompileDeploy(stmtTextLO).AddListener("s0").Milestone(milestone.GetAndIncrement());
TryAssertionPatternUniOuterJoinNoOn(env, 100000);
env.UndeployAll();
// test 2-stream inner join
//
var fieldsIJ = new[] {"c0", "c1"};
var stmtTextIJ = "@Name('s0') select sum(IntPrimitive) as c0, count(*) as c1 " +
"from SupportBean_S0 unidirectional " +
"inner join " +
"SupportBean#keepall";
env.CompileDeployAddListenerMile(stmtTextIJ, "s0", milestone.GetAndIncrement());
env.SendEventBean(new SupportBean_S0(1, "S0_1"));
env.SendEventBean(new SupportBean("E1", 100));
Assert.IsFalse(env.Listener("s0").IsInvoked);
env.SendEventBean(new SupportBean_S0(2, "S0_2"));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fieldsIJ,
new object[] {100, 1L});
env.SendEventBean(new SupportBean("E2", 200));
env.SendEventBean(new SupportBean_S0(3, "S0_3"));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fieldsIJ,
new object[] {300, 2L});
env.UndeployAll();
// test 2-stream inner join with group-by
TryAssertion2StreamInnerWGroupBy(env);
// test 3-stream inner join
//
var fields3IJ = new[] {"c0", "c1"};
var stmtText3IJ = "@Name('s0') select sum(IntPrimitive) as c0, count(*) as c1 " +
"from " +
"SupportBean_S0#keepall " +
"inner join " +
"SupportBean_S1#keepall " +
"inner join " +
"SupportBean#keepall";
env.CompileDeployAddListenerMile(stmtText3IJ, "s0", milestone.GetAndIncrement());
env.SendEventBean(new SupportBean_S0(1, "S0_1"));
env.SendEventBean(new SupportBean("E1", 50));
Assert.IsFalse(env.Listener("s0").IsInvoked);
env.SendEventBean(new SupportBean_S1(10, "S1_1"));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields3IJ,
new object[] {50, 1L});
env.SendEventBean(new SupportBean("E2", 51));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields3IJ,
new object[] {101, 2L});
env.UndeployAll();
// test 3-stream full outer join
//
var fields3FOJ = new[] {"P00", "P10", "TheString"};
var stmtText3FOJ = "@Name('s0') select P00, P10, TheString " +
"from " +
"SupportBean_S0#keepall " +
"full outer join " +
"SupportBean_S1#keepall " +
"full outer join " +
"SupportBean#keepall";
env.CompileDeployAddListenerMile(stmtText3FOJ, "s0", milestone.GetAndIncrement());
env.SendEventBean(new SupportBean_S0(1, "S0_1"));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields3FOJ,
new object[] {"S0_1", null, null});
env.SendEventBean(new SupportBean("E10", 0));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields3FOJ,
new object[] {null, null, "E10"});
env.SendEventBean(new SupportBean_S0(2, "S0_2"));
EPAssertionUtil.AssertPropsPerRow(
env.Listener("s0").GetAndResetLastNewData(),
fields3FOJ,
new[] {new object[] {"S0_2", null, null}});
env.SendEventBean(new SupportBean_S1(1, "S1_0"));
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.Listener("s0").GetAndResetLastNewData(),
fields3FOJ,
new[] {new object[] {"S0_1", "S1_0", "E10"}, new object[] {"S0_2", "S1_0", "E10"}});
env.SendEventBean(new SupportBean_S0(2, "S0_3"));
EPAssertionUtil.AssertPropsPerRow(
env.Listener("s0").GetAndResetLastNewData(),
fields3FOJ,
new[] {new object[] {"S0_3", "S1_0", "E10"}});
env.SendEventBean(new SupportBean("E11", 0));
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.Listener("s0").GetAndResetLastNewData(),
fields3FOJ,
new[] {
new object[] {"S0_1", "S1_0", "E11"}, new object[] {"S0_2", "S1_0", "E11"},
new object[] {"S0_3", "S1_0", "E11"}
});
Assert.AreEqual(6, EPAssertionUtil.EnumeratorCount(env.GetEnumerator("s0")));
env.UndeployAll();
// test 3-stream full outer join with where-clause
//
var fields3FOJW = new[] {"P00", "P10", "TheString"};
var stmtText3FOJW = "@Name('s0') select P00, P10, TheString " +
"from " +
"SupportBean_S0#keepall as S0 " +
"full outer join " +
"SupportBean_S1#keepall as S1 " +
"full outer join " +
"SupportBean#keepall as sb " +
"where S0.P00 = S1.P10";
env.CompileDeployAddListenerMile(stmtText3FOJW, "s0", milestone.GetAndIncrement());
env.SendEventBean(new SupportBean_S0(1, "X1"));
Assert.IsFalse(env.Listener("s0").IsInvoked);
env.SendEventBean(new SupportBean_S1(1, "Y1"));
Assert.IsFalse(env.Listener("s0").IsInvoked);
env.SendEventBean(new SupportBean_S0(1, "Y1"));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields3FOJW,
new object[] {"Y1", "Y1", null});
env.UndeployAll();
}
public void TestRightOuterJoin()
{
EPStatement outerJoinView = SetupStatement("right");
// Send S0 events, no events expected
SendEvent(_eventsS0[0]);
SendEvent(_eventsS0[1]);
Assert.IsFalse(_listener.IsInvoked);
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields, null);
// Send S1[2]
SendEvent(_eventsS1[2]);
EventBean theEvent = _listener.AssertOneGetNewAndReset();
CompareEvent(theEvent, null, null, 202, "2");
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields,
new[] { new Object[] { null, null, 202, "2" } });
// Send S0[2] events, joined event expected
SendEvent(_eventsS0[2]);
theEvent = _listener.AssertOneGetNewAndReset();
CompareEvent(theEvent, 102, "2", 202, "2");
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields,
new[] { new Object[] { 102, "2", 202, "2" } });
// Send S1[3]
SendEvent(_eventsS1[3]);
theEvent = _listener.AssertOneGetNewAndReset();
CompareEvent(theEvent, null, null, 203, "3");
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields,
new[]
{
new Object[] { 102, "2", 202, "2" },
new Object[] { null, null, 203, "3" }
});
// Send some more S0 events
SendEvent(_eventsS0[3]);
theEvent = _listener.AssertOneGetNewAndReset();
CompareEvent(theEvent, 103, "3", 203, "3");
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields,
new[]
{
new Object[] { 102, "2", 202, "2" },
new Object[] { 103, "3", 203, "3" }
});
// Send some more S0 events
SendEvent(_eventsS0[4]);
Assert.IsFalse(_listener.IsInvoked);
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields,
new[]
{
new Object[] { 102, "2", 202, "2" },
new Object[] { 103, "3", 203, "3" }
});
// Push S0[2] out of the window
SendEvent(_eventsS0[5]);
theEvent = _listener.AssertOneGetOldAndReset();
CompareEvent(theEvent, 102, "2", 202, "2");
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields,
new[]
{
new Object[] { null, null, 202, "2" },
new Object[] { 103, "3", 203, "3" }
});
// Some more S1 events
SendEvent(_eventsS1[6]);
CompareEvent(_listener.AssertOneGetNewAndReset(), null, null, 206, "6");
SendEvent(_eventsS1[7]);
CompareEvent(_listener.AssertOneGetNewAndReset(), null, null, 207, "7");
SendEvent(_eventsS1[8]);
CompareEvent(_listener.AssertOneGetNewAndReset(), null, null, 208, "8");
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields,
new[]
{
new Object[] { null, null, 202, "2" },
new Object[] { 103, "3", 203, "3" },
new Object[] { null, null, 206, "6" },
new Object[] { null, null, 207, "7" },
new Object[] { null, null, 208, "8" }
});
// Push S1[2] out of the window
SendEvent(_eventsS1[9]);
EventBean oldEvent = _listener.LastOldData[0];
EventBean newEvent = _listener.LastNewData[0];
CompareEvent(oldEvent, null, null, 202, "2");
CompareEvent(newEvent, null, null, 209, "9");
EPAssertionUtil.AssertPropsPerRowAnyOrder(outerJoinView.GetEnumerator(), Fields,
new[]
{
new Object[] { 103, "3", 203, "3" },
new Object[] { null, null, 206, "6" },
new Object[] { null, null, 207, "7" },
new Object[] { null, null, 208, "8" },
new Object[] { null, null, 209, "9" }
});
}
public void Run(RegressionEnvironment env)
{
var stmtText = "@Name('s0') select irstream Symbol, count(*) as cnt " +
"from SupportMarketDataBean unidirectional, SupportBean#keepall " +
"where TheString = Symbol group by TheString, Symbol";
env.CompileDeployAddListenerMileZero(stmtText, "s0");
// send event, expect result
SendEventMD(env, "E1", 1L);
var fields = new[] {"Symbol", "cnt"};
Assert.IsFalse(env.Listener("s0").IsInvoked);
SendEvent(env, "E1", 10);
Assert.IsFalse(env.Listener("s0").IsInvoked);
SendEventMD(env, "E1", 2L);
EPAssertionUtil.AssertProps(
env.Listener("s0").LastNewData[0],
fields,
new object[] {"E1", 1L});
EPAssertionUtil.AssertProps(
env.Listener("s0").LastOldData[0],
fields,
new object[] {"E1", 0L});
env.Listener("s0").Reset();
SendEvent(env, "E1", 20);
Assert.IsFalse(env.Listener("s0").IsInvoked);
SendEventMD(env, "E1", 3L);
EPAssertionUtil.AssertProps(
env.Listener("s0").LastNewData[0],
fields,
new object[] {"E1", 2L});
EPAssertionUtil.AssertProps(
env.Listener("s0").LastOldData[0],
fields,
new object[] {"E1", 0L});
env.Listener("s0").Reset();
try {
env.Statement("s0").GetEnumerator();
Assert.Fail();
}
catch (UnsupportedOperationException ex) {
Assert.AreEqual("Iteration over a unidirectional join is not supported", ex.Message);
}
// assure lock given up by sending more events
SendEvent(env, "E2", 40);
SendEventMD(env, "E2", 4L);
EPAssertionUtil.AssertProps(
env.Listener("s0").LastNewData[0],
fields,
new object[] {"E2", 1L});
EPAssertionUtil.AssertProps(
env.Listener("s0").LastOldData[0],
fields,
new object[] {"E2", 0L});
env.Listener("s0").Reset();
env.UndeployAll();
}
public void TestReservedKeywordEscape()
{
var configuration = SupportConfigFactory.GetConfiguration();
configuration.EngineDefaults.EventMetaConfig.ClassPropertyResolutionStyle =
PropertyResolutionStyle.DEFAULT;
configuration.EngineDefaults.EventMetaConfig.DefaultAccessorStyle =
AccessorStyleEnum.NATIVE;
_epService = EPServiceProviderManager.GetDefaultProvider(configuration);
_epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(_epService, GetType(), GetType().FullName);
}
_epService.EPAdministrator.Configuration.AddEventType <SupportBeanReservedKeyword>("SomeKeywords");
_epService.EPAdministrator.Configuration.AddEventType <SupportBeanReservedKeyword>("Order");
var listener = new SupportUpdateListener();
var stmt = _epService.EPAdministrator.CreateEPL("select `seconds`, `order` from SomeKeywords");
stmt.Events += listener.Update;
var theEvent = new SupportBeanReservedKeyword(1, 2);
_epService.EPRuntime.SendEvent(theEvent);
var eventBean = listener.AssertOneGetNewAndReset();
Assert.AreEqual(1, eventBean.Get("seconds"));
Assert.AreEqual(2, eventBean.Get("order"));
stmt.Dispose();
stmt = _epService.EPAdministrator.CreateEPL("select * from `Order`");
stmt.Events += listener.Update;
_epService.EPRuntime.SendEvent(theEvent);
eventBean = listener.AssertOneGetNewAndReset();
Assert.AreEqual(1, eventBean.Get("seconds"));
Assert.AreEqual(2, eventBean.Get("order"));
stmt.Dispose();
stmt = _epService.EPAdministrator.CreateEPL(
"select timestamp.`hour` as val from SomeKeywords");
stmt.Events += listener.Update;
var bean = new SupportBeanReservedKeyword(1, 2);
bean.Timestamp = new SupportBeanReservedKeyword.Inner();
bean.Timestamp.Hour = 10;
_epService.EPRuntime.SendEvent(bean);
eventBean = listener.AssertOneGetNewAndReset();
Assert.AreEqual(10, eventBean.Get("val"));
// test back-tick with spaces etc
var defType = new Dictionary <string, object>();
defType["candidate book"] = typeof(string);
defType["XML Message Type"] = typeof(string);
defType["select"] = typeof(int);
defType["children's books"] = typeof(int[]);
defType["my <> map"] = typeof(Map);
_epService.EPAdministrator.Configuration.AddEventType("MyType", defType);
_epService.EPAdministrator.CreateEPL("select `candidate book` as c0, `XML Message Type` as c1, `select` as c2, `children's books`[0] as c3, `my <> map`('xx') as c4 from MyType")
.Events += listener.Update;
var defValues = new Dictionary <string, object>();
defValues["candidate book"] = "Enders Game";
defValues["XML Message Type"] = "book";
defValues["select"] = 100;
defValues["children's books"] = new int[] { 50, 51 };
defValues["my <> map"] = Collections.SingletonMap("xx", "abc");
_epService.EPRuntime.SendEvent(defValues, "MyType");
EPAssertionUtil.AssertProps(
listener.AssertOneGetNewAndReset(),
"c0,c1,c2,c3,c4".Split(','), new Object[]
{
"Enders Game", "book", 100, 50, "abc"
});
try {
_epService.EPAdministrator.CreateEPL("select `select` from " + typeof(SupportBean).FullName);
Assert.Fail();
} catch (EPException ex) {
Assert.AreEqual(
"Error starting statement: Failed to validate select-clause expression 'select': Property named 'select' is not valid in any stream [select `select` from com.espertech.esper.support.bean.SupportBean]",
ex.Message);
}
try {
_epService.EPAdministrator.CreateEPL("select `ab cd` from " + typeof(SupportBean).FullName);
Assert.Fail();
} catch (EPException ex) {
SupportMessageAssertUtil.AssertMessage(ex, "Error starting statement: Failed to validate select-clause expression 'ab cd': Failed to find property 'ab cd', the property name does not parse (are you sure?): Incorrect syntax near 'cd' at line 1 column 3 [ab cd] [select `ab cd` from com.espertech.esper.support.bean.SupportBean]");
}
// test resolution as nested property
_epService.EPAdministrator.CreateEPL("create schema MyEvent as (customer string, `from` string)");
_epService.EPAdministrator.CreateEPL("insert into DerivedStream select customer,`from` from MyEvent");
_epService.EPAdministrator.CreateEPL("create window TheWindow.std:firstunique(customer,`from`) as DerivedStream");
_epService.EPAdministrator.CreateEPL("on pattern [a=TheWindow -> timer:interval(12 hours)] as s0 delete from TheWindow as s1 where s0.a.`from`=s1.`from`");
// test escape in column name
_epService.EPAdministrator.Configuration.AddEventType <SupportBean>();
EPStatement stmtTwo = _epService.EPAdministrator.CreateEPL("select TheString as `order`, TheString as `price.for.goods` from SupportBean");
stmtTwo.Events += listener.Update;
Assert.AreEqual(typeof(string), stmtTwo.EventType.GetPropertyType("order"));
Assert.AreEqual("price.for.goods", stmtTwo.EventType.PropertyDescriptors[1].PropertyName);
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
var @out = (Map)listener.AssertOneGetNew().Underlying;
Assert.AreEqual("E1", @out.Get("order"));
Assert.AreEqual("E1", @out.Get("price.for.goods"));
// try control character
TryInvalidControlCharacter(listener.AssertOneGetNew());
// try enum with keyword
TryEnumWithKeyword();
TryEnumItselfReserved();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
public void TestEmpty()
{
IEnumerator <EventBean> enumerator = testMap.GetMultiLevelEnumerator();
EPAssertionUtil.AssertEqualsExactOrder(null, enumerator);
}
private void RunAssertion(bool namedWindow, bool enableIndexShareCreate, bool disableIndexShareConsumer, bool createExplicitIndex)
{
_epService.EPAdministrator.CreateEPL("create schema EventSchema(e0 string, e1 int, e2 string)");
_epService.EPAdministrator.CreateEPL("create schema WindowSchema(col0 string, col1 long, col2 string)");
string createEpl = namedWindow ?
"create window MyInfra.win:keepall() as WindowSchema" :
"create table MyInfra (col0 string primary key, col1 long, col2 string)";
if (enableIndexShareCreate)
{
createEpl = "@Hint('enable_window_subquery_indexshare') " + createEpl;
}
_epService.EPAdministrator.CreateEPL(createEpl);
_epService.EPAdministrator.CreateEPL("insert into MyInfra select * from WindowSchema");
EPStatement stmtIndex = null;
if (createExplicitIndex)
{
stmtIndex = _epService.EPAdministrator.CreateEPL("create index MyIndex on MyInfra (col2, col1)");
}
string[] fields = "e0,val".Split(',');
string consumeEpl = "select e0, (select col0 from MyInfra where col2 = es.e2 and col1 = es.e1) as val from EventSchema es";
if (disableIndexShareConsumer)
{
consumeEpl = "@Hint('disable_window_subquery_indexshare') " + consumeEpl;
}
EPStatement consumeStmt = _epService.EPAdministrator.CreateEPL(consumeEpl);
consumeStmt.AddListener(_listener);
SendWindow("W1", 10L, "c31");
SendEvent("E1", 10, "c31");
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { "E1", "W1" });
SendEvent("E2", 11, "c32");
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { "E2", null });
SendWindow("W2", 11L, "c32");
SendEvent("E3", 11, "c32");
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { "E3", "W2" });
SendWindow("W3", 11L, "c31");
SendWindow("W4", 10L, "c32");
SendEvent("E4", 11, "c31");
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { "E4", "W3" });
SendEvent("E5", 10, "c31");
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { "E5", "W1" });
SendEvent("E6", 10, "c32");
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { "E6", "W4" });
// test late start
consumeStmt.Dispose();
consumeStmt = _epService.EPAdministrator.CreateEPL(consumeEpl);
consumeStmt.AddListener(_listener);
SendEvent("E6", 10, "c32");
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { "E6", "W4" });
if (stmtIndex != null)
{
stmtIndex.Dispose();
}
consumeStmt.Dispose();
_epService.EPAdministrator.DestroyAllStatements();
_epService.EPAdministrator.Configuration.RemoveEventType("MyInfra", false);
}
public void TestTransposeSingleColumnInsert()
{
_epService.EPAdministrator.Configuration.AddEventType <SupportBean>();
_epService.EPAdministrator.Configuration.AddEventType <SupportBeanNumeric>();
_epService.EPAdministrator.Configuration.AddPlugInSingleRowFunction("customOne", typeof(SupportStaticMethodLib).FullName, "MakeSupportBean");
_epService.EPAdministrator.Configuration.AddPlugInSingleRowFunction("customTwo", typeof(SupportStaticMethodLib).FullName, "MakeSupportBeanNumeric");
// with transpose and same input and output
String stmtTextOne = "insert into SupportBean select Transpose(customOne('O' || TheString, 10)) from SupportBean(TheString like 'I%')";
EPStatement stmtOne = _epService.EPAdministrator.CreateEPL(stmtTextOne);
Assert.AreEqual(typeof(SupportBean), stmtOne.EventType.UnderlyingType);
stmtOne.Events += _listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean("I1", 1));
EventBean resultOne = _listener.AssertOneGetNewAndReset();
EPAssertionUtil.AssertProps(resultOne, "TheString,IntPrimitive".Split(','), new Object[] { "OI1", 10 });
Assert.AreEqual("OI1", ((SupportBean)resultOne.Underlying).TheString);
stmtOne.Dispose();
// with transpose but different input and output (also test ignore column name)
String stmtTextTwo = "insert into SupportBeanNumeric select Transpose(customTwo(IntPrimitive, IntPrimitive+1)) as col1 from SupportBean(TheString like 'I%')";
EPStatement stmtTwo = _epService.EPAdministrator.CreateEPL(stmtTextTwo);
Assert.AreEqual(typeof(SupportBeanNumeric), stmtTwo.EventType.UnderlyingType);
stmtTwo.Events += _listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean("I2", 10));
EventBean resultTwo = _listener.AssertOneGetNewAndReset();
EPAssertionUtil.AssertProps(resultTwo, "intOne,intTwo".Split(','), new Object[] { 10, 11 });
Assert.AreEqual(11, (int)((SupportBeanNumeric)resultTwo.Underlying).IntTwo);
stmtTwo.Dispose();
// invalid wrong-bean target
try
{
_epService.EPAdministrator.CreateEPL("insert into SupportBeanNumeric select Transpose(customOne('O', 10)) from SupportBean");
Assert.Fail();
}
catch (EPStatementException ex)
{
Assert.AreEqual("Error starting statement: Expression-returned value of type 'com.espertech.esper.support.bean.SupportBean' cannot be converted to target event type 'SupportBeanNumeric' with underlying type 'com.espertech.esper.support.bean.SupportBeanNumeric' [insert into SupportBeanNumeric select Transpose(customOne('O', 10)) from SupportBean]", ex.Message);
}
// invalid additional properties
try
{
_epService.EPAdministrator.CreateEPL("insert into SupportBean select 1 as dummy, Transpose(customOne('O', 10)) from SupportBean");
Assert.Fail();
}
catch (EPStatementException ex)
{
Assert.AreEqual("Error starting statement: Cannot transpose additional properties in the select-clause to target event type 'SupportBean' with underlying type 'com.espertech.esper.support.bean.SupportBean', the transpose function must occur alone in the select clause [insert into SupportBean select 1 as dummy, Transpose(customOne('O', 10)) from SupportBean]", ex.Message);
}
// invalid occurs twice
try
{
_epService.EPAdministrator.CreateEPL("insert into SupportBean select Transpose(customOne('O', 10)), Transpose(customOne('O', 11)) from SupportBean");
Assert.Fail();
}
catch (EPStatementException ex)
{
Assert.AreEqual("Error starting statement: A column name must be supplied for all but one stream if multiple streams are selected via the stream.* notation [insert into SupportBean select Transpose(customOne('O', 10)), Transpose(customOne('O', 11)) from SupportBean]", ex.Message);
}
// invalid wrong-type target
try
{
_epService.EPAdministrator.Configuration.AddEventType("SomeOtherStream", new Dictionary <String, Object>());
_epService.EPAdministrator.CreateEPL("insert into SomeOtherStream select Transpose(customOne('O', 10)) from SupportBean");
Assert.Fail();
}
catch (EPStatementException ex)
{
Assert.AreEqual("Error starting statement: Expression-returned value of type 'com.espertech.esper.support.bean.SupportBean' cannot be converted to target event type 'SomeOtherStream' with underlying type '" + Name.Of <IDictionary <string, object> >() + "' [insert into SomeOtherStream select Transpose(customOne('O', 10)) from SupportBean]", ex.Message);
}
// invalid two parameters
try
{
_epService.EPAdministrator.CreateEPL("select transpose(customOne('O', 10), customOne('O', 10)) from SupportBean");
Assert.Fail();
}
catch (EPStatementException ex)
{
Assert.AreEqual("Error starting statement: Failed to validate select-clause expression 'transpose(customOne(\"O\",10),customO...(46 chars)': The transpose function requires a single parameter expression [select transpose(customOne('O', 10), customOne('O', 10)) from SupportBean]", ex.Message);
}
// test not a top-level function or used in where-clause (possible but not useful)
_epService.EPAdministrator.CreateEPL("select * from SupportBean where Transpose(customOne('O', 10)) is not null");
_epService.EPAdministrator.CreateEPL("select Transpose(customOne('O', 10)) is not null from SupportBean");
// invalid insert of object-array into undefined stream
try
{
_epService.EPAdministrator.CreateEPL("insert into SomeOther select transpose(generateOA('a', 1)) from SupportBean");
Assert.Fail();
}
catch (EPStatementException ex)
{
Assert.AreEqual("Error starting statement: Invalid expression return type '" + Name.Clean <object[]>() + "' for transpose function [insert into SomeOther select transpose(generateOA('a', 1)) from SupportBean]", ex.Message);
}
}
private static void RunFollowedByOp(
RegressionEnvironment env,
AtomicLong milestone,
string pattern,
bool matchDiscard)
{
var fields = new[] {"a1.Id", "a2.Id"};
var epl = "@Name('s0') select * from pattern " +
(matchDiscard ? GetText(TargetEnum.DISCARD_ONLY) : "") +
"[" +
pattern +
"]";
env.CompileDeploy(epl).AddListener("s0");
SendAEvent(env, "E1");
SendAEvent(env, "E2");
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {"E1", "E2"});
env.MilestoneInc(milestone);
SendAEvent(env, "E3");
if (matchDiscard) {
Assert.IsFalse(env.Listener("s0").IsInvoked);
}
else {
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {"E2", "E3"});
}
env.MilestoneInc(milestone);
SendAEvent(env, "E4");
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {"E3", "E4"});
env.MilestoneInc(milestone);
SendAEvent(env, "E5");
if (matchDiscard) {
Assert.IsFalse(env.Listener("s0").IsInvoked);
}
else {
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {"E4", "E5"});
}
SendAEvent(env, "E6");
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {"E5", "E6"});
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
var fields = "ro,rc,rho,rhc,nro,nrc,nrho,nrhc".SplitCsv();
var eplOne =
"@Name('s0') select" +
" IntPrimitive in (2:4) as ro," +
" IntPrimitive in [2:4] as rc," +
" IntPrimitive in [2:4) as rho," +
" IntPrimitive in (2:4] as rhc," +
" IntPrimitive not in (2:4) as nro," +
" IntPrimitive not in [2:4] as nrc," +
" IntPrimitive not in [2:4) as nrho," +
" IntPrimitive not in (2:4] as nrhc " +
"from SupportBean";
env.CompileDeploy(eplOne).AddListener("s0");
env.SendEventBean(new SupportBean("E1", 1));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
false,
false,
false,
false,
true,
true,
true,
true);
env.SendEventBean(new SupportBean("E1", 2));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
false,
true,
true,
false,
true,
false,
false,
true);
env.SendEventBean(new SupportBean("E1", 3));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
true,
true,
true,
true,
false,
false,
false,
false);
env.SendEventBean(new SupportBean("E1", 4));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
false,
true,
false,
true,
true,
false,
true,
false);
env.SendEventBean(new SupportBean("E1", 5));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
false,
false,
false,
false,
true,
true,
true,
true);
env.UndeployAll();
var model = env.EplToModel(eplOne);
var epl = model.ToEPL();
epl = epl.Replace("IntPrimitive between 2 and 4 as rc", "IntPrimitive in [2:4] as rc");
epl = epl.Replace("IntPrimitive not between 2 and 4 as nrc", "IntPrimitive not in [2:4] as nrc");
Assert.That(epl, Is.EqualTo(eplOne));
// test range reversed
var eplTwo = "@Name('s1') select IntPrimitive between 4 and 2 as r1, IntPrimitive in [4:2] as r2 from SupportBean";
env.CompileDeployAddListenerMile(eplTwo, "s1", 1);
fields = "r1,r2".SplitCsv();
env.SendEventBean(new SupportBean("E1", 3));
EPAssertionUtil.AssertProps(env.Listener("s1").AssertOneGetNewAndReset(), fields, true, true);
env.UndeployAll();
// test string type;
fields = "ro".SplitCsv();
var eplThree = "@Name('s2') select TheString in ('a':'d') as ro from SupportBean";
env.CompileDeployAddListenerMile(eplThree, "s2", 2);
env.SendEventBean(new SupportBean("a", 5));
EPAssertionUtil.AssertProps(env.Listener("s2").AssertOneGetNewAndReset(), fields, false);
env.SendEventBean(new SupportBean("b", 5));
EPAssertionUtil.AssertProps(env.Listener("s2").AssertOneGetNewAndReset(), fields, true);
env.SendEventBean(new SupportBean("c", 5));
EPAssertionUtil.AssertProps(env.Listener("s2").AssertOneGetNewAndReset(), fields, true);
env.SendEventBean(new SupportBean("d", 5));
EPAssertionUtil.AssertProps(env.Listener("s2").AssertOneGetNewAndReset(), fields, false);
env.UndeployAll();
}
private void RunAsserts()
{
object[] s0Events;
object[] s1Events;
object[] s2Events;
object[] s3Events;
object[] s4Events;
object[] s5Events;
// Test s0 and s1=0, s2=0, s3=0, s4=0, s5=0
//
s0Events = SupportBean_S0.MakeS0("A", new string[] { "A-s0-1" });
SendEvent(s0Events);
Assert.IsFalse(_updateListener.IsInvoked);
// Test s0 and s1=1, s2=0, s3=0, s4=0, s5=0
//
s1Events = SupportBean_S1.MakeS1("B", new string[] { "B-s1-1" });
SendEvent(s1Events);
Assert.IsFalse(_updateListener.IsInvoked);
s0Events = SupportBean_S0.MakeS0("B", new string[] { "B-s0-1" });
SendEvent(s0Events);
Assert.IsFalse(_updateListener.IsInvoked);
// Test s0 and s1=1, s2=1, s3=0, s4=0, s5=0
//
s1Events = SupportBean_S1.MakeS1("C", new string[] { "C-s1-1" });
SendEvent(s1Events);
s2Events = SupportBean_S2.MakeS2("C", new string[] { "C-s2-1" });
SendEvent(s2Events);
Assert.IsFalse(_updateListener.IsInvoked);
s0Events = SupportBean_S0.MakeS0("C", new string[] { "C-s0-1" });
SendEvent(s0Events);
Assert.IsFalse(_updateListener.IsInvoked);
// Test s0 and s1=1, s2=1, s3=1, s4=0, s5=0
//
s1Events = SupportBean_S1.MakeS1("D", new string[] { "D-s1-1" });
SendEvent(s1Events);
s2Events = SupportBean_S2.MakeS2("D", new string[] { "D-s2-1" });
SendEvent(s2Events);
s3Events = SupportBean_S3.MakeS3("D", new string[] { "D-s2-1" });
SendEvent(s3Events);
EPAssertionUtil.AssertSameAnyOrder(new object[][] {
new object[] { null, s1Events[0], null, s3Events[0], null, null }
}, GetAndResetNewEvents());
s0Events = SupportBean_S0.MakeS0("D", new string[] { "D-s0-1" });
SendEvent(s0Events);
Assert.IsFalse(_updateListener.IsInvoked);
// Test s0 and s1=1, s2=1, s3=1, s4=1, s5=0
//
s1Events = SupportBean_S1.MakeS1("E", new string[] { "E-s1-1" });
SendEvent(s1Events);
s2Events = SupportBean_S2.MakeS2("E", new string[] { "E-s2-1" });
SendEvent(s2Events);
s3Events = SupportBean_S3.MakeS3("E", new string[] { "E-s2-1" });
SendEvent(s3Events);
EPAssertionUtil.AssertSameAnyOrder(new object[][] {
new object[] { null, s1Events[0], null, s3Events[0], null, null }
}, GetAndResetNewEvents());
s4Events = SupportBean_S4.MakeS4("E", new string[] { "E-s2-1" });
SendEvent(s4Events);
EPAssertionUtil.AssertSameAnyOrder(new object[][] {
new object[] { null, null, null, null, s4Events[0], null }
}, GetAndResetNewEvents());
s0Events = SupportBean_S0.MakeS0("E", new string[] { "E-s0-1" });
SendEvent(s0Events);
Assert.IsFalse(_updateListener.IsInvoked);
// Test s0 and s1=2, s2=1, s3=1, s4=1, s5=1
//
s1Events = SupportBean_S1.MakeS1("F", new string[] { "F-s1-1" });
SendEvent(s1Events);
Assert.IsFalse(_updateListener.IsInvoked);
s2Events = SupportBean_S2.MakeS2("F", new string[] { "F-s2-1" });
SendEvent(s2Events);
Assert.IsFalse(_updateListener.IsInvoked);
s3Events = SupportBean_S3.MakeS3("F", new string[] { "F-s3-1" });
SendEvent(s3Events);
EPAssertionUtil.AssertSameAnyOrder(new object[][] {
new object[] { null, s1Events[0], null, s3Events[0], null, null }
}, GetAndResetNewEvents());
s4Events = SupportBean_S4.MakeS4("F", new string[] { "F-s2-1" });
SendEvent(s4Events);
EPAssertionUtil.AssertSameAnyOrder(new object[][] {
new object[] { null, null, null, null, s4Events[0], null }
}, GetAndResetNewEvents());
s5Events = SupportBean_S5.MakeS5("F", new string[] { "F-s2-1" });
SendEvent(s5Events);
EPAssertionUtil.AssertSameAnyOrder(new object[][] {
new object[] { null, null, s2Events[0], null, s4Events[0], s5Events[0] }
}, GetAndResetNewEvents());
s0Events = SupportBean_S0.MakeS0("F", new string[] { "F-s0-1" });
SendEvent(s0Events);
EPAssertionUtil.AssertSameAnyOrder(new object[][] {
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[0], s4Events[0], s5Events[0] }
}, GetAndResetNewEvents());
// Test s0 and s1=2, s2=2, s3=1, s4=1, s5=2
//
s1Events = SupportBean_S1.MakeS1("G", new string[] { "G-s1-1", "G-s1-2" });
SendEventsAndReset(s1Events);
s2Events = SupportBean_S2.MakeS2("G", new string[] { "G-s2-1", "G-s2-2" });
SendEventsAndReset(s2Events);
s3Events = SupportBean_S3.MakeS3("G", new string[] { "G-s3-1" });
SendEventsAndReset(s3Events);
s4Events = SupportBean_S4.MakeS4("G", new string[] { "G-s2-1" });
SendEventsAndReset(s4Events);
s5Events = SupportBean_S5.MakeS5("G", new string[] { "G-s5-1", "G-s5-2" });
SendEventsAndReset(s5Events);
s0Events = SupportBean_S0.MakeS0("G", new string[] { "G-s0-1" });
SendEvent(s0Events);
EPAssertionUtil.AssertSameAnyOrder(new object[][] {
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[0], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[1], s2Events[0], s3Events[0], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[0], s4Events[0], s5Events[1] },
new object[] { s0Events[0], s1Events[1], s2Events[0], s3Events[0], s4Events[0], s5Events[1] },
new object[] { s0Events[0], s1Events[0], s2Events[1], s3Events[0], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[1], s2Events[1], s3Events[0], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[0], s2Events[1], s3Events[0], s4Events[0], s5Events[1] },
new object[] { s0Events[0], s1Events[1], s2Events[1], s3Events[0], s4Events[0], s5Events[1] }
}, GetAndResetNewEvents());
// Test s0 and s1=2, s2=2, s3=2, s4=2, s5=2
//
s1Events = SupportBean_S1.MakeS1("H", new string[] { "H-s1-1", "H-s1-2" });
SendEventsAndReset(s1Events);
s2Events = SupportBean_S2.MakeS2("H", new string[] { "H-s2-1", "H-s2-2" });
SendEventsAndReset(s2Events);
s3Events = SupportBean_S3.MakeS3("H", new string[] { "H-s3-1", "H-s3-2" });
SendEventsAndReset(s3Events);
s4Events = SupportBean_S4.MakeS4("H", new string[] { "H-s4-1", "H-s4-2" });
SendEventsAndReset(s4Events);
s5Events = SupportBean_S5.MakeS5("H", new string[] { "H-s5-1", "H-s5-2" });
SendEventsAndReset(s5Events);
s0Events = SupportBean_S0.MakeS0("H", new string[] { "H-s0-1" });
SendEvent(s0Events);
EPAssertionUtil.AssertSameAnyOrder(new object[][] {
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[0], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[1], s2Events[0], s3Events[0], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[0], s4Events[0], s5Events[1] },
new object[] { s0Events[0], s1Events[1], s2Events[0], s3Events[0], s4Events[0], s5Events[1] },
new object[] { s0Events[0], s1Events[0], s2Events[1], s3Events[0], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[1], s2Events[1], s3Events[0], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[0], s2Events[1], s3Events[0], s4Events[0], s5Events[1] },
new object[] { s0Events[0], s1Events[1], s2Events[1], s3Events[0], s4Events[0], s5Events[1] },
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[0], s4Events[1], s5Events[0] },
new object[] { s0Events[0], s1Events[1], s2Events[0], s3Events[0], s4Events[1], s5Events[0] },
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[0], s4Events[1], s5Events[1] },
new object[] { s0Events[0], s1Events[1], s2Events[0], s3Events[0], s4Events[1], s5Events[1] },
new object[] { s0Events[0], s1Events[0], s2Events[1], s3Events[0], s4Events[1], s5Events[0] },
new object[] { s0Events[0], s1Events[1], s2Events[1], s3Events[0], s4Events[1], s5Events[0] },
new object[] { s0Events[0], s1Events[0], s2Events[1], s3Events[0], s4Events[1], s5Events[1] },
new object[] { s0Events[0], s1Events[1], s2Events[1], s3Events[0], s4Events[1], s5Events[1] },
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[1], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[1], s2Events[0], s3Events[1], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[1], s4Events[0], s5Events[1] },
new object[] { s0Events[0], s1Events[1], s2Events[0], s3Events[1], s4Events[0], s5Events[1] },
new object[] { s0Events[0], s1Events[0], s2Events[1], s3Events[1], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[1], s2Events[1], s3Events[1], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[0], s2Events[1], s3Events[1], s4Events[0], s5Events[1] },
new object[] { s0Events[0], s1Events[1], s2Events[1], s3Events[1], s4Events[0], s5Events[1] },
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[1], s4Events[1], s5Events[0] },
new object[] { s0Events[0], s1Events[1], s2Events[0], s3Events[1], s4Events[1], s5Events[0] },
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[1], s4Events[1], s5Events[1] },
new object[] { s0Events[0], s1Events[1], s2Events[0], s3Events[1], s4Events[1], s5Events[1] },
new object[] { s0Events[0], s1Events[0], s2Events[1], s3Events[1], s4Events[1], s5Events[0] },
new object[] { s0Events[0], s1Events[1], s2Events[1], s3Events[1], s4Events[1], s5Events[0] },
new object[] { s0Events[0], s1Events[0], s2Events[1], s3Events[1], s4Events[1], s5Events[1] },
new object[] { s0Events[0], s1Events[1], s2Events[1], s3Events[1], s4Events[1], s5Events[1] }
}, GetAndResetNewEvents());
// Test s0 and s1=2, s2=1, s3=1, s4=3, s5=1
//
s1Events = SupportBean_S1.MakeS1("I", new string[] { "I-s1-1", "I-s1-2" });
SendEventsAndReset(s1Events);
s2Events = SupportBean_S2.MakeS2("I", new string[] { "I-s2-1" });
SendEventsAndReset(s2Events);
s3Events = SupportBean_S3.MakeS3("I", new string[] { "I-s3-1" });
SendEventsAndReset(s3Events);
s4Events = SupportBean_S4.MakeS4("I", new string[] { "I-s4-1", "I-s4-2", "I-s4-3" });
SendEventsAndReset(s4Events);
s5Events = SupportBean_S5.MakeS5("I", new string[] { "I-s5-1" });
SendEventsAndReset(s5Events);
s0Events = SupportBean_S0.MakeS0("I", new string[] { "I-s0-1" });
SendEvent(s0Events);
EPAssertionUtil.AssertSameAnyOrder(new object[][] {
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[0], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[1], s2Events[0], s3Events[0], s4Events[1], s5Events[0] },
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[0], s4Events[2], s5Events[0] },
new object[] { s0Events[0], s1Events[1], s2Events[0], s3Events[0], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[0], s4Events[1], s5Events[0] },
new object[] { s0Events[0], s1Events[1], s2Events[0], s3Events[0], s4Events[2], s5Events[0] }
}, GetAndResetNewEvents());
// Test s1 and s3=0
//
s1Events = SupportBean_S1.MakeS1("J", new string[] { "J-s1-1" });
SendEvent(s1Events);
Assert.IsFalse(_updateListener.IsInvoked);
// Test s1 and s0=1, s2=0, s3=1, s4=1, s5=0
//
s0Events = SupportBean_S0.MakeS0("K", new string[] { "K-s0-1" });
SendEvent(s0Events);
s3Events = SupportBean_S3.MakeS3("K", new string[] { "K-s3-1" });
SendEventsAndReset(s3Events);
s1Events = SupportBean_S1.MakeS1("K", new string[] { "K-s1-1" });
SendEvent(s1Events);
EPAssertionUtil.AssertSameAnyOrder(new object[][] {
new object[] { null, s1Events[0], null, s3Events[0], null, null }
}, GetAndResetNewEvents());
// Test s1 and s0=1, s2=1, s3=1, s4=0, s5=1
//
s0Events = SupportBean_S0.MakeS0("L", new string[] { "L-s0-1" });
SendEvent(s0Events);
Assert.IsFalse(_updateListener.IsInvoked);
s2Events = SupportBean_S2.MakeS2("L", new string[] { "L-s2-1" });
SendEvent(s2Events);
Assert.IsFalse(_updateListener.IsInvoked);
s3Events = SupportBean_S3.MakeS3("L", new string[] { "L-s3-1" });
SendEventsAndReset(s3Events);
s5Events = SupportBean_S5.MakeS5("L", new string[] { "L-s5-1" });
SendEventsAndReset(s5Events);
s1Events = SupportBean_S1.MakeS1("L", new string[] { "L-s1-1" });
SendEvent(s1Events);
EPAssertionUtil.AssertSameAnyOrder(new object[][] {
new object[] { null, s1Events[0], null, s3Events[0], null, null }
}, GetAndResetNewEvents());
// Test s1 and s0=1, s2=1, s3=1, s4=2, s5=1
//
s0Events = SupportBean_S0.MakeS0("M", new string[] { "M-s0-1" });
SendEvent(s0Events);
s2Events = SupportBean_S2.MakeS2("M", new string[] { "M-s2-1" });
SendEventsAndReset(s2Events);
s3Events = SupportBean_S3.MakeS3("M", new string[] { "M-s3-1" });
SendEventsAndReset(s3Events);
s4Events = SupportBean_S4.MakeS4("M", new string[] { "M-s4-1", "M-s4-2" });
SendEventsAndReset(s4Events);
s5Events = SupportBean_S5.MakeS5("M", new string[] { "M-s5-1" });
SendEventsAndReset(s5Events);
s1Events = SupportBean_S1.MakeS1("M", new string[] { "M-s1-1" });
SendEvent(s1Events);
EPAssertionUtil.AssertSameAnyOrder(new object[][] {
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[0], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[0], s4Events[1], s5Events[0] }
}, GetAndResetNewEvents());
// Test s2 and s0=1, s1=0, s3=0, s4=1, s5=2
//
s0Events = SupportBean_S0.MakeS0("N", new string[] { "N-s0-1" });
SendEvent(s0Events);
s4Events = SupportBean_S4.MakeS4("N", new string[] { "N-s4-1" });
SendEventsAndReset(s4Events);
s5Events = SupportBean_S5.MakeS5("N", new string[] { "N-s5-1", "N-s5-2" });
SendEventsAndReset(s5Events);
s2Events = SupportBean_S2.MakeS2("N", new string[] { "N-s2-1" });
SendEvent(s2Events);
EPAssertionUtil.AssertSameAnyOrder(new object[][] {
new object[] { null, null, s2Events[0], null, s4Events[0], s5Events[0] },
new object[] { null, null, s2Events[0], null, s4Events[0], s5Events[1] }
}, GetAndResetNewEvents());
// Test s2 and s0=1, s1=1, s3=3, s4=1, s5=2
//
s0Events = SupportBean_S0.MakeS0("O", new string[] { "O-s0-1" });
SendEvent(s0Events);
s1Events = SupportBean_S1.MakeS1("O", new string[] { "O-s1-1" });
SendEvent(s1Events);
s3Events = SupportBean_S3.MakeS3("O", new string[] { "O-s3-1", "O-s3-2", "O-s3-3" });
SendEventsAndReset(s3Events);
s4Events = SupportBean_S4.MakeS4("O", new string[] { "O-s4-1" });
SendEventsAndReset(s4Events);
s5Events = SupportBean_S5.MakeS5("O", new string[] { "O-s5-1", "O-s5-2" });
SendEventsAndReset(s5Events);
s2Events = SupportBean_S2.MakeS2("O", new string[] { "O-s2-1" });
SendEvent(s2Events);
EPAssertionUtil.AssertSameAnyOrder(new object[][] {
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[0], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[1], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[2], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[0], s4Events[0], s5Events[1] },
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[1], s4Events[0], s5Events[1] },
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[2], s4Events[0], s5Events[1] }
}, GetAndResetNewEvents());
// Test s3 and s0=0, s1=0, s2=0, s4=0, s5=0
//
s3Events = SupportBean_S3.MakeS3("P", new string[] { "P-s1-1" });
SendEvent(s3Events);
EPAssertionUtil.AssertSameAnyOrder(new object[][] {
new object[] { null, null, null, s3Events[0], null, null }
}, GetAndResetNewEvents());
// Test s3 and s0=0, s1=1, s2=0, s4=0, s5=0
//
s1Events = SupportBean_S1.MakeS1("Q", new string[] { "Q-s1-1" });
SendEvent(s1Events);
s3Events = SupportBean_S3.MakeS3("Q", new string[] { "Q-s1-1" });
SendEvent(s3Events);
EPAssertionUtil.AssertSameAnyOrder(new object[][] {
new object[] { null, s1Events[0], null, s3Events[0], null, null }
}, GetAndResetNewEvents());
// Test s3 and s0=1, s1=2, s2=2, s4=0, s5=0
//
s0Events = SupportBean_S0.MakeS0("R", new string[] { "R-s0-1" });
SendEvent(s0Events);
s1Events = SupportBean_S1.MakeS1("R", new string[] { "R-s1-1", "R-s1-2" });
SendEvent(s1Events);
s2Events = SupportBean_S2.MakeS2("R", new string[] { "R-s2-1", "R-s2-1" });
SendEventsAndReset(s2Events);
s3Events = SupportBean_S3.MakeS3("R", new string[] { "R-s3-1" });
SendEvent(s3Events);
EPAssertionUtil.AssertSameAnyOrder(new object[][] {
new object[] { null, s1Events[0], null, s3Events[0], null, null },
new object[] { null, s1Events[1], null, s3Events[0], null, null }
}, GetAndResetNewEvents());
// Test s3 and s0=2, s1=2, s2=1, s4=2, s5=2
//
s0Events = SupportBean_S0.MakeS0("S", new string[] { "S-s0-1", "S-s0-2" });
SendEvent(s0Events);
s1Events = SupportBean_S1.MakeS1("S", new string[] { "S-s1-1", "S-s1-2" });
SendEvent(s1Events);
s2Events = SupportBean_S2.MakeS2("S", new string[] { "S-s2-1", "S-s2-1" });
SendEventsAndReset(s2Events);
s4Events = SupportBean_S4.MakeS4("S", new string[] { "S-s4-1", "S-s4-2" });
SendEventsAndReset(s4Events);
s5Events = SupportBean_S5.MakeS5("S", new string[] { "S-s5-1", "S-s5-2" });
SendEventsAndReset(s5Events);
s3Events = SupportBean_S3.MakeS3("S", new string[] { "s-s3-1" });
SendEvent(s3Events);
EPAssertionUtil.AssertSameAnyOrder(new object[][] {
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[0], s4Events[0], s5Events[0] },
new object[] { s0Events[1], s1Events[0], s2Events[0], s3Events[0], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[0], s4Events[0], s5Events[1] },
new object[] { s0Events[1], s1Events[0], s2Events[0], s3Events[0], s4Events[0], s5Events[1] },
new object[] { s0Events[0], s1Events[0], s2Events[1], s3Events[0], s4Events[0], s5Events[0] },
new object[] { s0Events[1], s1Events[0], s2Events[1], s3Events[0], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[0], s2Events[1], s3Events[0], s4Events[0], s5Events[1] },
new object[] { s0Events[1], s1Events[0], s2Events[1], s3Events[0], s4Events[0], s5Events[1] },
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[0], s4Events[1], s5Events[0] },
new object[] { s0Events[1], s1Events[0], s2Events[0], s3Events[0], s4Events[1], s5Events[0] },
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[0], s4Events[1], s5Events[1] },
new object[] { s0Events[1], s1Events[0], s2Events[0], s3Events[0], s4Events[1], s5Events[1] },
new object[] { s0Events[0], s1Events[0], s2Events[1], s3Events[0], s4Events[1], s5Events[0] },
new object[] { s0Events[1], s1Events[0], s2Events[1], s3Events[0], s4Events[1], s5Events[0] },
new object[] { s0Events[0], s1Events[0], s2Events[1], s3Events[0], s4Events[1], s5Events[1] },
new object[] { s0Events[1], s1Events[0], s2Events[1], s3Events[0], s4Events[1], s5Events[1] },
new object[] { s0Events[0], s1Events[1], s2Events[0], s3Events[0], s4Events[0], s5Events[0] },
new object[] { s0Events[1], s1Events[1], s2Events[0], s3Events[0], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[1], s2Events[0], s3Events[0], s4Events[0], s5Events[1] },
new object[] { s0Events[1], s1Events[1], s2Events[0], s3Events[0], s4Events[0], s5Events[1] },
new object[] { s0Events[0], s1Events[1], s2Events[1], s3Events[0], s4Events[0], s5Events[0] },
new object[] { s0Events[1], s1Events[1], s2Events[1], s3Events[0], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[1], s2Events[1], s3Events[0], s4Events[0], s5Events[1] },
new object[] { s0Events[1], s1Events[1], s2Events[1], s3Events[0], s4Events[0], s5Events[1] },
new object[] { s0Events[0], s1Events[1], s2Events[0], s3Events[0], s4Events[1], s5Events[0] },
new object[] { s0Events[1], s1Events[1], s2Events[0], s3Events[0], s4Events[1], s5Events[0] },
new object[] { s0Events[0], s1Events[1], s2Events[0], s3Events[0], s4Events[1], s5Events[1] },
new object[] { s0Events[1], s1Events[1], s2Events[0], s3Events[0], s4Events[1], s5Events[1] },
new object[] { s0Events[0], s1Events[1], s2Events[1], s3Events[0], s4Events[1], s5Events[0] },
new object[] { s0Events[1], s1Events[1], s2Events[1], s3Events[0], s4Events[1], s5Events[0] },
new object[] { s0Events[0], s1Events[1], s2Events[1], s3Events[0], s4Events[1], s5Events[1] },
new object[] { s0Events[1], s1Events[1], s2Events[1], s3Events[0], s4Events[1], s5Events[1] }
}, GetAndResetNewEvents());
// Test s4 and s0=1, s1=0, s2=1, s3=0, s5=0
//
s0Events = SupportBean_S0.MakeS0("U", new string[] { "U-s0-1" });
SendEventsAndReset(s0Events);
s2Events = SupportBean_S2.MakeS2("U", new string[] { "U-s1-1" });
SendEventsAndReset(s2Events);
s4Events = SupportBean_S4.MakeS4("U", new string[] { "U-s4-1" });
SendEvent(s4Events);
EPAssertionUtil.AssertSameAnyOrder(new object[][] {
new object[] { null, null, null, null, s4Events[0], null }
}, GetAndResetNewEvents());
// Test s4 and s0=1, s1=0, s2=1, s3=0, s5=1
//
s0Events = SupportBean_S0.MakeS0("V", new string[] { "V-s0-1" });
SendEventsAndReset(s0Events);
s2Events = SupportBean_S2.MakeS2("V", new string[] { "V-s1-1" });
SendEventsAndReset(s2Events);
s5Events = SupportBean_S5.MakeS5("V", new string[] { "V-s5-1" });
SendEventsAndReset(s5Events);
s4Events = SupportBean_S4.MakeS4("V", new string[] { "V-s4-1" });
SendEvent(s4Events);
EPAssertionUtil.AssertSameAnyOrder(new object[][] {
new object[] { null, null, s2Events[0], null, s4Events[0], s5Events[0] }
}, GetAndResetNewEvents());
// Test s4 and s0=1, s1=1, s2=1, s3=1, s5=2
//
s0Events = SupportBean_S0.MakeS0("W", new string[] { "W-s0-1" });
SendEvent(s0Events);
s1Events = SupportBean_S1.MakeS1("W", new string[] { "W-s1-1" });
SendEventsAndReset(s1Events);
s2Events = SupportBean_S2.MakeS2("W", new string[] { "W-s2-1" });
SendEventsAndReset(s2Events);
s3Events = SupportBean_S3.MakeS3("W", new string[] { "W-s3-1" });
SendEventsAndReset(s3Events);
s5Events = SupportBean_S5.MakeS5("W", new string[] { "W-s5-1", "W-s5-2" });
SendEventsAndReset(s5Events);
s4Events = SupportBean_S4.MakeS4("W", new string[] { "W-s4-1" });
SendEvent(s4Events);
EPAssertionUtil.AssertSameAnyOrder(new object[][] {
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[0], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[0], s4Events[0], s5Events[1] }
}, GetAndResetNewEvents());
// Test s5 and s0=1, s1=2, s2=2, s3=1, s4=1
//
s0Events = SupportBean_S0.MakeS0("X", new string[] { "X-s0-1" });
SendEvent(s0Events);
s1Events = SupportBean_S1.MakeS1("X", new string[] { "X-s1-1", "X-s1-2" });
SendEventsAndReset(s1Events);
s2Events = SupportBean_S2.MakeS2("X", new string[] { "X-s2-1", "X-s2-2" });
SendEvent(s2Events);
s3Events = SupportBean_S3.MakeS3("X", new string[] { "X-s3-1" });
SendEventsAndReset(s3Events);
s4Events = SupportBean_S4.MakeS4("X", new string[] { "X-s4-1" });
SendEventsAndReset(s4Events);
s5Events = SupportBean_S5.MakeS5("X", new string[] { "X-s5-1" });
SendEvent(s5Events);
EPAssertionUtil.AssertSameAnyOrder(new object[][] {
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[0], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[0], s2Events[1], s3Events[0], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[1], s2Events[0], s3Events[0], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[1], s2Events[1], s3Events[0], s4Events[0], s5Events[0] }
}, GetAndResetNewEvents());
// Test s5 and s0=2, s1=1, s2=1, s3=1, s4=1
//
s0Events = SupportBean_S0.MakeS0("Y", new string[] { "Y-s0-1", "Y-s0-2" });
SendEvent(s0Events);
s1Events = SupportBean_S1.MakeS1("Y", new string[] { "Y-s1-1" });
SendEventsAndReset(s1Events);
s2Events = SupportBean_S2.MakeS2("Y", new string[] { "Y-s2-1" });
SendEvent(s2Events);
s3Events = SupportBean_S3.MakeS3("Y", new string[] { "Y-s3-1" });
SendEventsAndReset(s3Events);
s4Events = SupportBean_S4.MakeS4("Y", new string[] { "Y-s4-1" });
SendEventsAndReset(s4Events);
s5Events = SupportBean_S5.MakeS5("Y", new string[] { "X-s5-1" });
SendEvent(s5Events);
EPAssertionUtil.AssertSameAnyOrder(new object[][] {
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[0], s4Events[0], s5Events[0] },
new object[] { s0Events[1], s1Events[0], s2Events[0], s3Events[0], s4Events[0], s5Events[0] }
}, GetAndResetNewEvents());
// Test s5 and s0=1, s1=1, s2=1, s3=2, s4=2
//
s0Events = SupportBean_S0.MakeS0("Z", new string[] { "Z-s0-1" });
SendEvent(s0Events);
s1Events = SupportBean_S1.MakeS1("Z", new string[] { "Z-s1-1" });
SendEventsAndReset(s1Events);
s2Events = SupportBean_S2.MakeS2("Z", new string[] { "Z-s2-1" });
SendEventsAndReset(s2Events);
s3Events = SupportBean_S3.MakeS3("Z", new string[] { "Z-s3-1", "Z-s3-2" });
SendEventsAndReset(s3Events);
s4Events = SupportBean_S4.MakeS4("Z", new string[] { "Z-s4-1", "Z-s4-2" });
SendEventsAndReset(s4Events);
s5Events = SupportBean_S5.MakeS5("Z", new string[] { "Z-s5-1" });
SendEvent(s5Events);
EPAssertionUtil.AssertSameAnyOrder(new object[][] {
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[0], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[0], s4Events[1], s5Events[0] },
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[1], s4Events[0], s5Events[0] },
new object[] { s0Events[0], s1Events[0], s2Events[0], s3Events[1], s4Events[1], s5Events[0] }
}, GetAndResetNewEvents());
}
public void RunAssertionHashBTreeWidening(bool isNamedWindow)
{
_epService.EPAdministrator.Configuration.AddEventType <SupportBean>();
_epService.EPAdministrator.Configuration.AddEventType <SupportBean_A>();
// widen to long
var eplCreate = isNamedWindow ?
"create window MyInfra.win:keepall() as (f1 long, f2 string)" :
"create table MyInfra as (f1 long primary key, f2 string primary key)";
_epService.EPAdministrator.CreateEPL(eplCreate);
var eplInsert = "insert into MyInfra(f1, f2) select LongPrimitive, TheString from SupportBean";
_epService.EPAdministrator.CreateEPL(eplInsert);
_epService.EPAdministrator.CreateEPL("create index MyInfraIndex1 on MyInfra(f1 btree)");
var fields = "f1,f2".Split(',');
SendEventLong("E1", 10L);
var result = _epService.EPRuntime.ExecuteQuery("select * from MyInfra where f1>9");
EPAssertionUtil.AssertPropsPerRow(result.Array, fields, new object[][] { new object[] { 10L, "E1" } });
// SODA
var epl = "create index IX1 on MyInfra(f1, f2 btree)";
var model = _epService.EPAdministrator.CompileEPL(epl);
Assert.AreEqual(model.ToEPL(), epl);
var stmt = _epService.EPAdministrator.CreateEPL(epl);
Assert.AreEqual(epl, stmt.Text);
// SODA with unique
var eplUnique = "create unique index IX2 on MyInfra(f1)";
var modelUnique = _epService.EPAdministrator.CompileEPL(eplUnique);
Assert.AreEqual(eplUnique, modelUnique.ToEPL());
var stmtUnique = _epService.EPAdministrator.CreateEPL(eplUnique);
Assert.AreEqual(eplUnique, stmtUnique.Text);
// coerce to short
var eplCreateTwo = isNamedWindow ?
"create window MyInfraTwo.win:keepall() as (f1 short, f2 string)" :
"create table MyInfraTwo as (f1 short primary key, f2 string primary key)";
_epService.EPAdministrator.CreateEPL(eplCreateTwo);
var eplInsertTwo = "insert into MyInfraTwo(f1, f2) select ShortPrimitive, TheString from SupportBean";
_epService.EPAdministrator.CreateEPL(eplInsertTwo);
_epService.EPAdministrator.CreateEPL("create index MyInfraTwoIndex1 on MyInfraTwo(f1 btree)");
SendEventShort("E1", (short)2);
result = _epService.EPRuntime.ExecuteQuery("select * from MyInfraTwo where f1>=2");
EPAssertionUtil.AssertPropsPerRow(result.Array, fields, new object[][] { new object[] { (short)2, "E1" } });
_epService.EPAdministrator.DestroyAllStatements();
_epService.EPAdministrator.Configuration.RemoveEventType("MyInfra", false);
_epService.EPAdministrator.Configuration.RemoveEventType("MyInfraTwo", false);
}
public void Run(RegressionEnvironment env)
{
var fields = new[] {"TheString", "IntPrimitive"};
var epl = "@Name('s0') select irstream * from SupportBean#sort(3, TheString)";
env.CompileDeployAddListenerMileZero(epl, "s0");
EPAssertionUtil.AssertPropsPerRow(env.GetEnumerator("s0"), fields, null);
SendSupportBean(env, "G", 1);
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {"G", 1});
env.Milestone(1);
EPAssertionUtil.AssertPropsPerRow(
env.GetEnumerator("s0"),
fields,
new[] {new object[] {"G", 1}});
SendSupportBean(env, "E", 2);
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {"E", 2});
env.Milestone(2);
EPAssertionUtil.AssertPropsPerRow(
env.GetEnumerator("s0"),
fields,
new[] {new object[] {"E", 2}, new object[] {"G", 1}});
SendSupportBean(env, "H", 3);
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {"H", 3});
env.Milestone(3);
EPAssertionUtil.AssertPropsPerRow(
env.GetEnumerator("s0"),
fields,
new[] {new object[] {"E", 2}, new object[] {"G", 1}, new object[] {"H", 3}});
SendSupportBean(env, "I", 4);
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertGetAndResetIRPair(),
fields,
new object[] {"I", 4},
new object[] {"I", 4});
env.Milestone(4);
EPAssertionUtil.AssertPropsPerRow(
env.GetEnumerator("s0"),
fields,
new[] {new object[] {"E", 2}, new object[] {"G", 1}, new object[] {"H", 3}});
SendSupportBean(env, "A", 5);
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertGetAndResetIRPair(),
fields,
new object[] {"A", 5},
new object[] {"H", 3});
env.Milestone(5);
EPAssertionUtil.AssertPropsPerRow(
env.GetEnumerator("s0"),
fields,
new[] {new object[] {"A", 5}, new object[] {"E", 2}, new object[] {"G", 1}});
SendSupportBean(env, "C", 6);
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertGetAndResetIRPair(),
fields,
new object[] {"C", 6},
new object[] {"G", 1});
env.Milestone(6);
EPAssertionUtil.AssertPropsPerRow(
env.GetEnumerator("s0"),
fields,
new[] {new object[] {"A", 5}, new object[] {"C", 6}, new object[] {"E", 2}});
SendSupportBean(env, "C", 7);
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertGetAndResetIRPair(),
fields,
new object[] {"C", 7},
new object[] {"E", 2});
env.Milestone(7);
EPAssertionUtil.AssertPropsPerRow(
env.GetEnumerator("s0"),
fields,
new[] {new object[] {"A", 5}, new object[] {"C", 7}, new object[] {"C", 6}});
SendSupportBean(env, "C", 8);
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertGetAndResetIRPair(),
fields,
new object[] {"C", 8},
new object[] {"C", 6});
EPAssertionUtil.AssertPropsPerRow(
env.GetEnumerator("s0"),
fields,
new[] {new object[] {"A", 5}, new object[] {"C", 8}, new object[] {"C", 7}});
env.UndeployAll();
}
internal static void AssertFileConfig(Configuration config)
{
// assert name for class
Assert.AreEqual(2, config.EventTypeAutoNamePackages.Count);
Assert.AreEqual("com.mycompany.eventsone", config.EventTypeAutoNamePackages.ToArray()[0]);
Assert.AreEqual("com.mycompany.eventstwo", config.EventTypeAutoNamePackages.ToArray()[1]);
// assert name for class
Assert.AreEqual(3, config.EventTypeNames.Count);
Assert.AreEqual("com.mycompany.myapp.MySampleEventOne", config.EventTypeNames.Get("MySampleEventOne"));
Assert.AreEqual("com.mycompany.myapp.MySampleEventTwo", config.EventTypeNames.Get("MySampleEventTwo"));
Assert.AreEqual("com.mycompany.package.MyLegacyTypeEvent", config.EventTypeNames.Get("MyLegacyTypeEvent"));
// assert auto imports
Assert.AreEqual(10, config.Imports.Count);
Assert.IsTrue(config.Imports.Contains(new AutoImportDesc(typeof(NameAttribute).Namespace)));
Assert.IsTrue(config.Imports.Contains(new AutoImportDesc("com.espertech.esper.client.annotation")));
Assert.IsTrue(config.Imports.Contains(new AutoImportDesc("com.espertech.esper.dataflow.ops")));
Assert.IsTrue(config.Imports.Contains(new AutoImportDesc("com.mycompany.myapp")));
Assert.IsTrue(config.Imports.Contains(new AutoImportDesc("com.mycompany.myapp.ClassOne")));
Assert.IsTrue(config.Imports.Contains(new AutoImportDesc("com.mycompany.myapp", "AssemblyA")));
Assert.IsTrue(config.Imports.Contains(new AutoImportDesc("com.mycompany.myapp", "AssemblyB.dll")));
Assert.IsTrue(config.Imports.Contains(new AutoImportDesc("com.mycompany.myapp.ClassTwo", "AssemblyB.dll")));
// assert XML DOM - no schema
Assert.AreEqual(2, config.EventTypesXMLDOM.Count);
var noSchemaDesc = config.EventTypesXMLDOM.Get("MyNoSchemaXMLEventName");
Assert.AreEqual("MyNoSchemaEvent", noSchemaDesc.RootElementName);
Assert.AreEqual("/myevent/element1", noSchemaDesc.XPathProperties.Get("element1").XPath);
Assert.AreEqual(XPathResultType.Number, noSchemaDesc.XPathProperties.Get("element1").ResultType);
Assert.AreEqual(null, noSchemaDesc.XPathProperties.Get("element1").OptionalCastToType);
Assert.IsNull(noSchemaDesc.XPathFunctionResolver);
Assert.IsNull(noSchemaDesc.XPathVariableResolver);
Assert.IsFalse(noSchemaDesc.IsXPathPropertyExpr);
// assert XML DOM - with schema
var schemaDesc = config.EventTypesXMLDOM.Get("MySchemaXMLEventName");
Assert.AreEqual("MySchemaEvent", schemaDesc.RootElementName);
Assert.AreEqual("MySchemaXMLEvent.xsd", schemaDesc.SchemaResource);
Assert.AreEqual("actual-xsd-text-here", schemaDesc.SchemaText);
Assert.AreEqual("samples:schemas:simpleSchema", schemaDesc.RootElementNamespace);
Assert.AreEqual("default-name-space", schemaDesc.DefaultNamespace);
Assert.AreEqual("/myevent/element2", schemaDesc.XPathProperties.Get("element2").XPath);
Assert.AreEqual(XPathResultType.String, schemaDesc.XPathProperties.Get("element2").ResultType);
Assert.AreEqual(typeof(long), schemaDesc.XPathProperties.Get("element2").OptionalCastToType);
Assert.AreEqual("/bookstore/book", schemaDesc.XPathProperties.Get("element3").XPath);
Assert.AreEqual(XPathResultType.NodeSet, schemaDesc.XPathProperties.Get("element3").ResultType);
Assert.AreEqual(null, schemaDesc.XPathProperties.Get("element3").OptionalCastToType);
Assert.AreEqual("MyOtherXMLNodeEvent", schemaDesc.XPathProperties.Get("element3").OptionalEventTypeName);
Assert.AreEqual(1, schemaDesc.NamespacePrefixes.Count);
Assert.AreEqual("samples:schemas:simpleSchema", schemaDesc.NamespacePrefixes.Get("ss"));
Assert.IsFalse(schemaDesc.IsXPathResolvePropertiesAbsolute);
Assert.AreEqual("com.mycompany.OptionalFunctionResolver", schemaDesc.XPathFunctionResolver);
Assert.AreEqual("com.mycompany.OptionalVariableResolver", schemaDesc.XPathVariableResolver);
Assert.IsTrue(schemaDesc.IsXPathPropertyExpr);
Assert.IsFalse(schemaDesc.IsEventSenderValidatesRoot);
Assert.IsFalse(schemaDesc.IsAutoFragment);
Assert.AreEqual("startts", schemaDesc.StartTimestampPropertyName);
Assert.AreEqual("endts", schemaDesc.EndTimestampPropertyName);
// assert mapped events
Assert.AreEqual(1, config.EventTypesMapEvents.Count);
Assert.IsTrue(config.EventTypesMapEvents.Keys.Contains("MyMapEvent"));
Properties expectedProps = new Properties();
expectedProps.Put("myInt", "int");
expectedProps.Put("myString", "string");
Assert.AreEqual(expectedProps, config.EventTypesMapEvents.Get("MyMapEvent"));
Assert.AreEqual(1, config.MapTypeConfigurations.Count);
var superTypes = config.MapTypeConfigurations.Get("MyMapEvent").SuperTypes;
EPAssertionUtil.AssertEqualsExactOrder(new Object[] { "MyMapSuperType1", "MyMapSuperType2" }, superTypes.ToArray());
Assert.AreEqual("startts", config.MapTypeConfigurations.Get("MyMapEvent").StartTimestampPropertyName);
Assert.AreEqual("endts", config.MapTypeConfigurations.Get("MyMapEvent").EndTimestampPropertyName);
// assert objectarray events
Assert.AreEqual(1, config.EventTypesNestableObjectArrayEvents.Count);
Assert.IsTrue(config.EventTypesNestableObjectArrayEvents.ContainsKey("MyObjectArrayEvent"));
IDictionary <string, object> expectedPropsObjectArray = new Dictionary <string, object>();
expectedPropsObjectArray.Put("myInt", "int");
expectedPropsObjectArray.Put("myString", "string");
Assert.That(config.EventTypesNestableObjectArrayEvents.Get("MyObjectArrayEvent"),
Is.InstanceOf <IDictionary <string, object> >());
Assert.That(config.EventTypesNestableObjectArrayEvents.Get("MyObjectArrayEvent").AsBasicDictionary <string, object>(),
Is.EqualTo(expectedPropsObjectArray));
Assert.AreEqual(expectedPropsObjectArray, config.EventTypesNestableObjectArrayEvents.Get("MyObjectArrayEvent"));
Assert.AreEqual(1, config.ObjectArrayTypeConfigurations.Count);
var superTypesOA = config.ObjectArrayTypeConfigurations.Get("MyObjectArrayEvent").SuperTypes;
EPAssertionUtil.AssertEqualsExactOrder(new Object[] { "MyObjectArraySuperType1", "MyObjectArraySuperType2" }, superTypesOA.ToArray());
Assert.AreEqual("startts", config.ObjectArrayTypeConfigurations.Get("MyObjectArrayEvent").StartTimestampPropertyName);
Assert.AreEqual("endts", config.ObjectArrayTypeConfigurations.Get("MyObjectArrayEvent").EndTimestampPropertyName);
// assert legacy type declaration
Assert.AreEqual(1, config.EventTypesLegacy.Count);
var legacy = config.EventTypesLegacy.Get("MyLegacyTypeEvent");
Assert.AreEqual(CodeGenerationEnum.ENABLED, legacy.CodeGeneration);
Assert.AreEqual(AccessorStyleEnum.PUBLIC, legacy.AccessorStyle);
Assert.AreEqual(1, legacy.FieldProperties.Count);
Assert.AreEqual("myFieldName", legacy.FieldProperties[0].AccessorFieldName);
Assert.AreEqual("myfieldprop", legacy.FieldProperties[0].Name);
Assert.AreEqual(1, legacy.MethodProperties.Count);
Assert.AreEqual("myAccessorMethod", legacy.MethodProperties[0].AccessorMethodName);
Assert.AreEqual("mymethodprop", legacy.MethodProperties[0].Name);
Assert.AreEqual(PropertyResolutionStyle.CASE_INSENSITIVE, legacy.PropertyResolutionStyle);
Assert.AreEqual("com.mycompany.myapp.MySampleEventFactory.createMyLegacyTypeEvent", legacy.FactoryMethod);
Assert.AreEqual("myCopyMethod", legacy.CopyMethod);
Assert.AreEqual("startts", legacy.StartTimestampPropertyName);
Assert.AreEqual("endts", legacy.EndTimestampPropertyName);
// assert database reference - data source config
Assert.AreEqual(2, config.DatabaseReferences.Count);
ConfigurationDBRef configDBRef = config.DatabaseReferences.Get("mydb1");
DbDriverFactoryConnection dsDef = (DbDriverFactoryConnection)configDBRef.ConnectionFactoryDesc;
Assert.AreEqual("com.espertech.esper.epl.db.drivers.DbDriverMySQL", dsDef.Driver.GetType().FullName);
Assert.AreEqual("Server=localhost;Database=tempdb;Trusted_Connection=True;", dsDef.Driver.ConnectionString);
Assert.AreEqual(ConnectionLifecycleEnum.POOLED, configDBRef.ConnectionLifecycle);
Assert.IsNull(configDBRef.ConnectionSettings.AutoCommit);
Assert.IsNull(configDBRef.ConnectionSettings.Catalog);
Assert.IsNull(configDBRef.ConnectionSettings.TransactionIsolation);
var lruCache = (ConfigurationLRUCache)configDBRef.DataCacheDesc;
Assert.AreEqual(10, lruCache.Size);
Assert.AreEqual(ConfigurationDBRef.ColumnChangeCaseEnum.LOWERCASE, configDBRef.ColumnChangeCase);
Assert.AreEqual(ConfigurationDBRef.MetadataOriginEnum.SAMPLE, configDBRef.MetadataRetrievalEnum);
//Assert.AreEqual(2, configDBRef.SqlTypesMapping.Count);
//Assert.AreEqual("int", configDBRef.SqlTypesMapping[2]);
//Assert.AreEqual("float", configDBRef.SqlTypesMapping[6]);
// assert database reference - driver manager config
configDBRef = config.DatabaseReferences.Get("mydb2");
DbDriverFactoryConnection dmDef = (DbDriverFactoryConnection)configDBRef.ConnectionFactoryDesc;
Assert.AreEqual("com.espertech.esper.epl.db.drivers.DbDriverODBC", dmDef.Driver.GetType().FullName);
Assert.AreEqual(
"Driver={MySQL ODBC 5.1 Driver};Server=localhost;Database=test;User=esper;Password=Esp3rP@ssw0rd;Option=3",
dmDef.Driver.ConnectionString);
Assert.AreEqual(ConnectionLifecycleEnum.RETAIN, configDBRef.ConnectionLifecycle);
Assert.AreEqual(false, configDBRef.ConnectionSettings.AutoCommit);
Assert.AreEqual("test", configDBRef.ConnectionSettings.Catalog);
Assert.AreEqual(IsolationLevel.ReadCommitted, configDBRef.ConnectionSettings.TransactionIsolation);
ConfigurationExpiryTimeCache expCache = (ConfigurationExpiryTimeCache)configDBRef.DataCacheDesc;
Assert.AreEqual(60.5, expCache.MaxAgeSeconds);
Assert.AreEqual(120.1, expCache.PurgeIntervalSeconds);
Assert.AreEqual(ConfigurationCacheReferenceType.HARD, expCache.CacheReferenceType);
Assert.AreEqual(ConfigurationDBRef.ColumnChangeCaseEnum.UPPERCASE, configDBRef.ColumnChangeCase);
Assert.AreEqual(ConfigurationDBRef.MetadataOriginEnum.METADATA, configDBRef.MetadataRetrievalEnum);
//Assert.AreEqual(1, configDBRef.SqlTypesMapping.Count);
//Assert.AreEqual("System.String", configDBRef.SqlTypesMapping.Get(99));
// assert custom view implementations
var configViews = config.PlugInViews;
Assert.AreEqual(2, configViews.Count);
for (var i = 0; i < configViews.Count; i++)
{
var entry = configViews[i];
Assert.AreEqual("ext" + i, entry.Namespace);
Assert.AreEqual("myview" + i, entry.Name);
Assert.AreEqual("com.mycompany.MyViewFactory" + i, entry.FactoryClassName);
}
// assert custom virtual data window implementations
var configVDW = config.PlugInVirtualDataWindows;
Assert.AreEqual(2, configVDW.Count);
for (var i = 0; i < configVDW.Count; i++)
{
var entry = configVDW[i];
Assert.AreEqual("vdw" + i, entry.Namespace);
Assert.AreEqual("myvdw" + i, entry.Name);
Assert.AreEqual("com.mycompany.MyVdwFactory" + i, entry.FactoryClassName);
if (i == 1)
{
Assert.AreEqual("abc", entry.Config);
}
}
// assert adapter loaders parsed
var plugins = config.PluginLoaders;
Assert.AreEqual(2, plugins.Count);
var pluginOne = plugins[0];
Assert.AreEqual("Loader1", pluginOne.LoaderName);
Assert.AreEqual("com.espertech.esper.support.plugin.SupportLoaderOne", pluginOne.TypeName);
Assert.AreEqual(2, pluginOne.ConfigProperties.Count);
Assert.AreEqual("val1", pluginOne.ConfigProperties.Get("name1"));
Assert.AreEqual("val2", pluginOne.ConfigProperties.Get("name2"));
Assert.AreEqual("<?xml version=\"1.0\" encoding=\"utf-16\"?><sample-initializer xmlns=\"http://www.espertech.com/schema/esper\"><some-any-xml-can-be-here>This section for use by a plugin loader.</some-any-xml-can-be-here></sample-initializer>", pluginOne.ConfigurationXML);
var pluginTwo = plugins[1];
Assert.AreEqual("Loader2", pluginTwo.LoaderName);
Assert.AreEqual("com.espertech.esper.support.plugin.SupportLoaderTwo", pluginTwo.TypeName);
Assert.AreEqual(0, pluginTwo.ConfigProperties.Count);
// assert plug-in aggregation function loaded
Assert.AreEqual(2, config.PlugInAggregationFunctions.Count);
var pluginAgg = config.PlugInAggregationFunctions[0];
Assert.AreEqual("func1a", pluginAgg.Name);
Assert.AreEqual("com.mycompany.MyMatrixAggregationMethod0Factory", pluginAgg.FactoryClassName);
pluginAgg = config.PlugInAggregationFunctions[1];
Assert.AreEqual("func2a", pluginAgg.Name);
Assert.AreEqual("com.mycompany.MyMatrixAggregationMethod1Factory", pluginAgg.FactoryClassName);
// assert plug-in aggregation multi-function loaded
Assert.AreEqual(1, config.PlugInAggregationMultiFunctions.Count);
var pluginMultiAgg = config.PlugInAggregationMultiFunctions[0];
EPAssertionUtil.AssertEqualsExactOrder(new String[] { "func1", "func2" }, pluginMultiAgg.FunctionNames);
Assert.AreEqual("com.mycompany.MyAggregationMultiFunctionFactory", pluginMultiAgg.MultiFunctionFactoryClassName);
Assert.AreEqual(1, pluginMultiAgg.AdditionalConfiguredProperties.Count);
Assert.AreEqual("value1", pluginMultiAgg.AdditionalConfiguredProperties.Get("prop1"));
// assert plug-in singlerow function loaded
Assert.AreEqual(2, config.PlugInSingleRowFunctions.Count);
var pluginSingleRow = config.PlugInSingleRowFunctions[0];
Assert.AreEqual("com.mycompany.MyMatrixSingleRowMethod0", pluginSingleRow.FunctionClassName);
Assert.AreEqual("method1", pluginSingleRow.FunctionMethodName);
Assert.AreEqual("func3", pluginSingleRow.Name);
Assert.AreEqual(ValueCache.DISABLED, pluginSingleRow.ValueCache);
Assert.AreEqual(FilterOptimizable.ENABLED, pluginSingleRow.FilterOptimizable);
Assert.IsFalse(pluginSingleRow.RethrowExceptions);
pluginSingleRow = config.PlugInSingleRowFunctions[1];
Assert.AreEqual("com.mycompany.MyMatrixSingleRowMethod1", pluginSingleRow.FunctionClassName);
Assert.AreEqual("func4", pluginSingleRow.Name);
Assert.AreEqual("method2", pluginSingleRow.FunctionMethodName);
Assert.AreEqual(ValueCache.ENABLED, pluginSingleRow.ValueCache);
Assert.AreEqual(FilterOptimizable.DISABLED, pluginSingleRow.FilterOptimizable);
Assert.IsTrue(pluginSingleRow.RethrowExceptions);
// assert plug-in guard objects loaded
Assert.AreEqual(4, config.PlugInPatternObjects.Count);
var pluginPattern = config.PlugInPatternObjects[0];
Assert.AreEqual("com.mycompany.MyGuardFactory0", pluginPattern.FactoryClassName);
Assert.AreEqual("ext0", pluginPattern.Namespace);
Assert.AreEqual("guard1", pluginPattern.Name);
Assert.AreEqual(ConfigurationPlugInPatternObject.PatternObjectTypeEnum.GUARD, pluginPattern.PatternObjectType);
pluginPattern = config.PlugInPatternObjects[1];
Assert.AreEqual("com.mycompany.MyGuardFactory1", pluginPattern.FactoryClassName);
Assert.AreEqual("ext1", pluginPattern.Namespace);
Assert.AreEqual("guard2", pluginPattern.Name);
Assert.AreEqual(ConfigurationPlugInPatternObject.PatternObjectTypeEnum.GUARD, pluginPattern.PatternObjectType);
pluginPattern = config.PlugInPatternObjects[2];
Assert.AreEqual("com.mycompany.MyObserverFactory0", pluginPattern.FactoryClassName);
Assert.AreEqual("ext0", pluginPattern.Namespace);
Assert.AreEqual("observer1", pluginPattern.Name);
Assert.AreEqual(ConfigurationPlugInPatternObject.PatternObjectTypeEnum.OBSERVER, pluginPattern.PatternObjectType);
pluginPattern = config.PlugInPatternObjects[3];
Assert.AreEqual("com.mycompany.MyObserverFactory1", pluginPattern.FactoryClassName);
Assert.AreEqual("ext1", pluginPattern.Namespace);
Assert.AreEqual("observer2", pluginPattern.Name);
Assert.AreEqual(ConfigurationPlugInPatternObject.PatternObjectTypeEnum.OBSERVER, pluginPattern.PatternObjectType);
// assert engine defaults
Assert.IsFalse(config.EngineDefaults.ThreadingConfig.IsInsertIntoDispatchPreserveOrder);
Assert.AreEqual(3000, config.EngineDefaults.ThreadingConfig.InsertIntoDispatchTimeout);
Assert.AreEqual(ConfigurationEngineDefaults.Threading.Locking.SUSPEND, config.EngineDefaults.ThreadingConfig.InsertIntoDispatchLocking);
Assert.IsFalse(config.EngineDefaults.ThreadingConfig.IsListenerDispatchPreserveOrder);
Assert.AreEqual(2000, config.EngineDefaults.ThreadingConfig.ListenerDispatchTimeout);
Assert.AreEqual(ConfigurationEngineDefaults.Threading.Locking.SUSPEND, config.EngineDefaults.ThreadingConfig.ListenerDispatchLocking);
Assert.IsTrue(config.EngineDefaults.ThreadingConfig.IsThreadPoolInbound);
Assert.IsTrue(config.EngineDefaults.ThreadingConfig.IsThreadPoolOutbound);
Assert.IsTrue(config.EngineDefaults.ThreadingConfig.IsThreadPoolRouteExec);
Assert.IsTrue(config.EngineDefaults.ThreadingConfig.IsThreadPoolTimerExec);
Assert.AreEqual(1, config.EngineDefaults.ThreadingConfig.ThreadPoolInboundNumThreads);
Assert.AreEqual(2, config.EngineDefaults.ThreadingConfig.ThreadPoolOutboundNumThreads);
Assert.AreEqual(3, config.EngineDefaults.ThreadingConfig.ThreadPoolTimerExecNumThreads);
Assert.AreEqual(4, config.EngineDefaults.ThreadingConfig.ThreadPoolRouteExecNumThreads);
Assert.AreEqual(1000, (int)config.EngineDefaults.ThreadingConfig.ThreadPoolInboundCapacity);
Assert.AreEqual(1500, (int)config.EngineDefaults.ThreadingConfig.ThreadPoolOutboundCapacity);
Assert.AreEqual(null, config.EngineDefaults.ThreadingConfig.ThreadPoolTimerExecCapacity);
Assert.AreEqual(2000, (int)config.EngineDefaults.ThreadingConfig.ThreadPoolRouteExecCapacity);
Assert.IsFalse(config.EngineDefaults.ThreadingConfig.IsInternalTimerEnabled);
Assert.AreEqual(1234567, config.EngineDefaults.ThreadingConfig.InternalTimerMsecResolution);
Assert.IsFalse(config.EngineDefaults.ViewResourcesConfig.IsShareViews);
Assert.IsTrue(config.EngineDefaults.ViewResourcesConfig.IsAllowMultipleExpiryPolicies);
Assert.IsTrue(config.EngineDefaults.ViewResourcesConfig.IsIterableUnbound);
Assert.AreEqual(PropertyResolutionStyle.DISTINCT_CASE_INSENSITIVE, config.EngineDefaults.EventMetaConfig.ClassPropertyResolutionStyle);
Assert.AreEqual(AccessorStyleEnum.PUBLIC, config.EngineDefaults.EventMetaConfig.DefaultAccessorStyle);
Assert.AreEqual(EventRepresentation.MAP, config.EngineDefaults.EventMetaConfig.DefaultEventRepresentation);
Assert.AreEqual(100, config.EngineDefaults.EventMetaConfig.AnonymousCacheSize);
Assert.IsTrue(config.EngineDefaults.LoggingConfig.IsEnableExecutionDebug);
Assert.IsFalse(config.EngineDefaults.LoggingConfig.IsEnableTimerDebug);
Assert.IsTrue(config.EngineDefaults.LoggingConfig.IsEnableQueryPlan);
Assert.IsTrue(config.EngineDefaults.LoggingConfig.IsEnableADO);
Assert.AreEqual("[%u] %m", config.EngineDefaults.LoggingConfig.AuditPattern);
Assert.AreEqual(30000, config.EngineDefaults.VariablesConfig.MsecVersionRelease);
Assert.AreEqual(3L, (long)config.EngineDefaults.PatternsConfig.MaxSubexpressions);
Assert.AreEqual(false, config.EngineDefaults.PatternsConfig.IsMaxSubexpressionPreventStart);
Assert.AreEqual(3L, (long)config.EngineDefaults.MatchRecognizeConfig.MaxStates);
Assert.AreEqual(false, config.EngineDefaults.MatchRecognizeConfig.IsMaxStatesPreventStart);
Assert.AreEqual(StreamSelector.RSTREAM_ISTREAM_BOTH, config.EngineDefaults.StreamSelectionConfig.DefaultStreamSelector);
Assert.AreEqual(ConfigurationEngineDefaults.TimeSourceType.NANO, config.EngineDefaults.TimeSourceConfig.TimeSourceType);
Assert.IsTrue(config.EngineDefaults.ExecutionConfig.IsPrioritized);
Assert.IsTrue(config.EngineDefaults.ExecutionConfig.IsFairlock);
Assert.IsTrue(config.EngineDefaults.ExecutionConfig.IsDisableLocking);
Assert.IsTrue(config.EngineDefaults.ExecutionConfig.IsAllowIsolatedService);
Assert.AreEqual(ConfigurationEngineDefaults.ThreadingProfile.LARGE, config.EngineDefaults.ExecutionConfig.ThreadingProfile);
Assert.AreEqual(ConfigurationEngineDefaults.FilterServiceProfile.READWRITE, config.EngineDefaults.ExecutionConfig.FilterServiceProfile);
Assert.AreEqual(100, config.EngineDefaults.ExecutionConfig.FilterServiceMaxFilterWidth);
var metrics = config.EngineDefaults.MetricsReportingConfig;
Assert.IsTrue(metrics.IsEnableMetricsReporting);
Assert.AreEqual(4000L, metrics.EngineInterval);
Assert.AreEqual(500L, metrics.StatementInterval);
Assert.IsFalse(metrics.IsThreading);
Assert.AreEqual(2, metrics.StatementGroups.Count);
//Assert.IsTrue(metrics.IsJmxEngineMetrics);
var def = metrics.StatementGroups.Get("MyStmtGroup");
Assert.AreEqual(5000, def.Interval);
Assert.IsTrue(def.IsDefaultInclude);
Assert.AreEqual(50, def.NumStatements);
Assert.IsTrue(def.IsReportInactive);
Assert.AreEqual(5, def.Patterns.Count);
Assert.AreEqual(def.Patterns[0], new Pair <StringPatternSet, Boolean>(new StringPatternSetRegex(".*"), true));
Assert.AreEqual(def.Patterns[1], new Pair <StringPatternSet, Boolean>(new StringPatternSetRegex(".*test.*"), false));
Assert.AreEqual(def.Patterns[2], new Pair <StringPatternSet, Boolean>(new StringPatternSetLike("%MyMetricsStatement%"), false));
Assert.AreEqual(def.Patterns[3], new Pair <StringPatternSet, Boolean>(new StringPatternSetLike("%MyFraudAnalysisStatement%"), true));
Assert.AreEqual(def.Patterns[4], new Pair <StringPatternSet, Boolean>(new StringPatternSetLike("%SomerOtherStatement%"), true));
def = metrics.StatementGroups.Get("MyStmtGroupTwo");
Assert.AreEqual(200, def.Interval);
Assert.IsFalse(def.IsDefaultInclude);
Assert.AreEqual(100, def.NumStatements);
Assert.IsFalse(def.IsReportInactive);
Assert.AreEqual(0, def.Patterns.Count);
Assert.IsTrue(config.EngineDefaults.LanguageConfig.IsSortUsingCollator);
Assert.IsTrue(config.EngineDefaults.ExpressionConfig.IsIntegerDivision);
Assert.IsTrue(config.EngineDefaults.ExpressionConfig.IsDivisionByZeroReturnsNull);
Assert.IsFalse(config.EngineDefaults.ExpressionConfig.IsSelfSubselectPreeval);
Assert.IsFalse(config.EngineDefaults.ExpressionConfig.IsUdfCache);
Assert.IsFalse(config.EngineDefaults.ExpressionConfig.IsExtendedAggregation);
Assert.IsTrue(config.EngineDefaults.ExpressionConfig.IsDuckTyping);
Assert.AreEqual(2, config.EngineDefaults.ExpressionConfig.MathContext.Precision);
Assert.AreEqual(MidpointRounding.ToEven, config.EngineDefaults.ExpressionConfig.MathContext.RoundingMode);
Assert.AreEqual(TimeZoneHelper.GetTimeZoneInfo("GMT-4:00"), config.EngineDefaults.ExpressionConfig.TimeZone);
Assert.AreEqual(2, config.EngineDefaults.ExceptionHandlingConfig.HandlerFactories.Count);
Assert.AreEqual("my.company.cep.LoggingExceptionHandlerFactory", config.EngineDefaults.ExceptionHandlingConfig.HandlerFactories[0]);
Assert.AreEqual("my.company.cep.AlertExceptionHandlerFactory", config.EngineDefaults.ExceptionHandlingConfig.HandlerFactories[1]);
Assert.AreEqual(2, config.EngineDefaults.ConditionHandlingConfig.HandlerFactories.Count);
Assert.AreEqual("my.company.cep.LoggingConditionHandlerFactory", config.EngineDefaults.ConditionHandlingConfig.HandlerFactories[0]);
Assert.AreEqual("my.company.cep.AlertConditionHandlerFactory", config.EngineDefaults.ConditionHandlingConfig.HandlerFactories[1]);
Assert.AreEqual("abc", config.EngineDefaults.ScriptsConfig.DefaultDialect);
// variables
Assert.AreEqual(3, config.Variables.Count);
var variable = config.Variables.Get("var1");
Assert.AreEqual(typeof(int).FullName, variable.VariableType);
Assert.AreEqual("1", variable.InitializationValue);
Assert.IsFalse(variable.IsConstant);
variable = config.Variables.Get("var2");
Assert.AreEqual(typeof(string).FullName, variable.VariableType);
Assert.AreEqual(null, variable.InitializationValue);
Assert.IsFalse(variable.IsConstant);
variable = config.Variables.Get("var3");
Assert.IsTrue(variable.IsConstant);
// method references
Assert.AreEqual(2, config.MethodInvocationReferences.Count);
var methodRef = config.MethodInvocationReferences.Get("abc");
expCache = (ConfigurationExpiryTimeCache)methodRef.DataCacheDesc;
Assert.AreEqual(91.0, expCache.MaxAgeSeconds);
Assert.AreEqual(92.2, expCache.PurgeIntervalSeconds);
Assert.AreEqual(ConfigurationCacheReferenceType.WEAK, expCache.CacheReferenceType);
methodRef = config.MethodInvocationReferences.Get("def");
lruCache = (ConfigurationLRUCache)methodRef.DataCacheDesc;
Assert.AreEqual(20, lruCache.Size);
// plug-in event representations
Assert.AreEqual(2, config.PlugInEventRepresentation.Count);
var rep = config.PlugInEventRepresentation.Get(new Uri("type://format/rep/name"));
Assert.AreEqual("com.mycompany.MyPlugInEventRepresentation", rep.EventRepresentationTypeName);
Assert.AreEqual("<?xml version=\"1.0\" encoding=\"utf-16\"?><anyxml>test string event rep init</anyxml>", rep.Initializer);
rep = config.PlugInEventRepresentation.Get(new Uri("type://format/rep/name2"));
Assert.AreEqual("com.mycompany.MyPlugInEventRepresentation2", rep.EventRepresentationTypeName);
Assert.AreEqual(null, rep.Initializer);
// plug-in event types
Assert.AreEqual(2, config.PlugInEventTypes.Count);
var type = config.PlugInEventTypes.Get("MyEvent");
Assert.AreEqual(2, type.EventRepresentationResolutionURIs.Count);
Assert.AreEqual("type://format/rep", type.EventRepresentationResolutionURIs[0].ToString());
Assert.AreEqual("type://format/rep2", type.EventRepresentationResolutionURIs[1].ToString());
Assert.AreEqual("<?xml version=\"1.0\" encoding=\"utf-16\"?><anyxml>test string event type init</anyxml>", type.Initializer);
type = config.PlugInEventTypes.Get("MyEvent2");
Assert.AreEqual(1, type.EventRepresentationResolutionURIs.Count);
Assert.AreEqual("type://format/rep2", type.EventRepresentationResolutionURIs[0].ToString());
Assert.AreEqual(null, type.Initializer);
// plug-in event representation resolution URIs when using a new name in a statement
Assert.AreEqual(2, config.PlugInEventTypeResolutionURIs.Count);
Assert.AreEqual("type://format/rep", config.PlugInEventTypeResolutionURIs[0].ToString());
Assert.AreEqual("type://format/rep2", config.PlugInEventTypeResolutionURIs[1].ToString());
// revision types
Assert.AreEqual(1, config.RevisionEventTypes.Count);
var configRev = config.RevisionEventTypes.Get("MyRevisionEvent");
Assert.AreEqual(1, configRev.NameBaseEventTypes.Count);
Assert.IsTrue(configRev.NameBaseEventTypes.Contains("MyBaseEventName"));
Assert.IsTrue(configRev.NameDeltaEventTypes.Contains("MyDeltaEventNameOne"));
Assert.IsTrue(configRev.NameDeltaEventTypes.Contains("MyDeltaEventNameTwo"));
EPAssertionUtil.AssertEqualsAnyOrder(new String[] { "id", "id2" }, configRev.KeyPropertyNames);
Assert.AreEqual(PropertyRevisionEnum.MERGE_NON_NULL, configRev.PropertyRevision);
// variance types
Assert.AreEqual(1, config.VariantStreams.Count);
var configVStream = config.VariantStreams.Get("MyVariantStream");
Assert.AreEqual(2, configVStream.VariantTypeNames.Count);
Assert.IsTrue(configVStream.VariantTypeNames.Contains("MyEvenTypetNameOne"));
Assert.IsTrue(configVStream.VariantTypeNames.Contains("MyEvenTypetNameTwo"));
Assert.AreEqual(TypeVarianceEnum.ANY, configVStream.TypeVariance);
}
