public void TestObjectArrayTypeUpdate()
{
var configuration = SupportConfigFactory.GetConfiguration();
configuration.EngineDefaults.EventMetaConfig.DefaultEventRepresentation = EventRepresentation.OBJECTARRAY;
String[] names = { "base1", "base2" };
Object[] types = { typeof(String), MakeMap(new Object[][] { new Object[] { "n1", typeof(int) } }) };
configuration.AddEventType("MyOAEvent", names, types);
var epService = EPServiceProviderManager.GetDefaultProvider(configuration);
epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(epService, GetType(), GetType().FullName);
}
var statementOne = epService.EPAdministrator.CreateEPL(
"select base1 as v1, base2.n1 as v2, base3? as v3, base2.n2? as v4 from MyOAEvent");
Assert.AreEqual(typeof(Object[]), statementOne.EventType.UnderlyingType);
var statementOneSelectAll = epService.EPAdministrator.CreateEPL("select * from MyOAEvent");
Assert.AreEqual("[base1, base2]", statementOneSelectAll.EventType.PropertyNames.Render(", ", "[]"));
var listenerOne = new SupportUpdateListener();
statementOne.Events += listenerOne.Update;
var fields = "v1,v2,v3,v4".Split(',');
epService.EPRuntime.SendEvent(new Object[] { "abc", MakeMap(new Object[][] { new Object[] { "n1", 10 } }), "" }, "MyOAEvent");
EPAssertionUtil.AssertProps(listenerOne.AssertOneGetNewAndReset(), fields, new Object[] { "abc", 10, null, null });
// Update type
String[] namesNew = { "base3", "base2" };
var typesNew = new Object[] { typeof(long), MakeMap(new Object[][] { new Object[] { "n2", typeof(String) } }) };
epService.EPAdministrator.Configuration.UpdateObjectArrayEventType("MyOAEvent", namesNew, typesNew);
var statementTwo = epService.EPAdministrator.CreateEPL("select base1 as v1, base2.n1 as v2, base3 as v3, base2.n2 as v4 from MyOAEvent");
var statementTwoSelectAll = epService.EPAdministrator.CreateEPL("select * from MyOAEvent");
var listenerTwo = new SupportUpdateListener();
statementTwo.Events += listenerTwo.Update;
epService.EPRuntime.SendEvent(new Object[] { "def", MakeMap(new Object[][] { new Object[] { "n1", 9 }, new Object[] { "n2", "xyz" } }), 20L }, "MyOAEvent");
EPAssertionUtil.AssertProps(listenerOne.AssertOneGetNewAndReset(), fields, new Object[] { "def", 9, 20L, "xyz" });
EPAssertionUtil.AssertProps(listenerTwo.AssertOneGetNewAndReset(), fields, new Object[] { "def", 9, 20L, "xyz" });
// assert event type
Assert.AreEqual("[base1, base2, base3]", statementOneSelectAll.EventType.PropertyNames.Render(", ", "[]"));
Assert.AreEqual("[base1, base2, base3]", statementTwoSelectAll.EventType.PropertyNames.Render(", ", "[]"));
EPAssertionUtil.AssertEqualsAnyOrder(new [] {
new EventPropertyDescriptor("base3", typeof(long), null, false, false, false, false, false),
new EventPropertyDescriptor("base2", typeof(Map), null, false, false, false, true, false),
new EventPropertyDescriptor("base1", typeof(string), typeof(char), false, false, true, false, false),
}, statementTwoSelectAll.EventType.PropertyDescriptors);
try
{
epService.EPAdministrator.Configuration.UpdateObjectArrayEventType("dummy", new String[0], new Object[0]);
Assert.Fail();
}
catch (ConfigurationException ex)
{
Assert.AreEqual("Error updating Object-array event type: Event type named 'dummy' has not been declared", ex.Message);
}
epService.EPAdministrator.Configuration.AddEventType("SupportBean", typeof(SupportBean));
try
{
epService.EPAdministrator.Configuration.UpdateObjectArrayEventType("SupportBean", new String[0], new Object[0]);
Assert.Fail();
}
catch (ConfigurationException ex)
{
Assert.AreEqual("Error updating Object-array event type: Event type by name 'SupportBean' is not an Object-array event type", ex.Message);
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
public void TestInvalidConfig()
{
var properties = new Properties();
properties.Put("astring", "XXXX");
Configuration configuration = SupportConfigFactory.GetConfiguration();
configuration.AddEventType("MyInvalidEvent", properties);
try {
EPServiceProvider epServiceInner = EPServiceProviderManager.GetDefaultProvider(configuration);
epServiceInner.Initialize();
Assert.Fail();
} catch (ConfigurationException) {
// expected
}
EPServiceProvider epService = EPServiceProviderManager.GetDefaultProvider(SupportConfigFactory.GetConfiguration());
epService.Initialize();
}
public void SetUp()
{
_listener = new SupportUpdateListener();
_epService = EPServiceProviderManager.GetDefaultProvider(SupportConfigFactory.GetConfiguration());
_epService.Initialize();
}
public void TestMonthScoped()
{
EPServiceProvider epService = EPServiceProviderManager.GetDefaultProvider(SupportConfigFactory.GetConfiguration());
epService.Initialize();
epService.EPAdministrator.Configuration.AddEventType <SupportBean>();
SupportUpdateListener listener = new SupportUpdateListener();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(epService, GetType(), GetType().FullName);
}
SendCurrentTime(epService, "2002-02-01T9:00:00.000");
epService.EPAdministrator.CreateEPL("select * from pattern [timer:interval(1 month)]").Events += listener.Update;
SendCurrentTimeWithMinus(epService, "2002-03-01T9:00:00.000", 1);
Assert.IsFalse(listener.IsInvoked);
SendCurrentTime(epService, "2002-03-01T9:00:00.000");
Assert.IsTrue(listener.IsInvoked);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
private void TryExplicitOnlyAccessors(CodeGenerationEnum codeGeneration)
{
var config = SupportConfigFactory.GetConfiguration();
var legacyDef = new ConfigurationEventTypeLegacy();
legacyDef.AccessorStyle = AccessorStyleEnum.EXPLICIT;
legacyDef.CodeGeneration = codeGeneration;
legacyDef.AddFieldProperty("explicitFNested", "fieldNested");
legacyDef.AddMethodProperty("explicitMNested", "ReadLegacyNested");
config.AddEventType("MyLegacyEvent", typeof(SupportLegacyBean).FullName, legacyDef);
legacyDef = new ConfigurationEventTypeLegacy();
legacyDef.AccessorStyle = AccessorStyleEnum.EXPLICIT;
legacyDef.CodeGeneration = codeGeneration;
legacyDef.AddFieldProperty("fieldNestedClassValue", "fieldNestedValue");
legacyDef.AddMethodProperty("ReadNestedClassValue", "ReadNestedValue");
config.AddEventType("MyLegacyNestedEvent", typeof(SupportLegacyBean.LegacyNested).FullName, legacyDef);
legacyDef = new ConfigurationEventTypeLegacy();
legacyDef.AccessorStyle = AccessorStyleEnum.EXPLICIT;
legacyDef.CodeGeneration = codeGeneration;
config.AddEventType("MySupportBean", typeof(SupportBean).FullName, legacyDef);
_epService = EPServiceProviderManager.GetProvider(GetType().FullName + ".test2" + codeGeneration, config);
_epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(_epService, GetType(), GetType().FullName);
}
var statementText = "select " +
"explicitFNested.fieldNestedClassValue as fnested, " +
"explicitMNested.ReadNestedClassValue as mnested" +
" from MyLegacyEvent.win:length(5)";
var statement = _epService.EPAdministrator.CreateEPL(statementText);
var listener = new SupportUpdateListener();
statement.Events += listener.Update;
var eventType = statement.EventType;
Assert.AreEqual(typeof(string), eventType.GetPropertyType("fnested"));
Assert.AreEqual(typeof(string), eventType.GetPropertyType("mnested"));
_epService.EPRuntime.SendEvent(_legacyBean);
Assert.AreEqual(_legacyBean.fieldNested.ReadNestedValue(), listener.LastNewData[0].Get("fnested"));
Assert.AreEqual(_legacyBean.fieldNested.ReadNestedValue(), listener.LastNewData[0].Get("mnested"));
try
{
// invalid statement, JavaBean-style getters not exposed
statementText = "select IntPrimitive from MySupportBean.win:length(5)";
_epService.EPAdministrator.CreateEPL(statementText);
}
catch (EPStatementException ex)
{
// expected
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
_epService.Dispose();
}
public void SetUp()
{
epService = EPServiceProviderManager.GetDefaultProvider(SupportConfigFactory.GetConfiguration());
epService.Initialize();
}
public void TestIntervalSpecExpressionWithPropertyArray()
{
EPServiceProvider epService = EPServiceProviderManager.GetDefaultProvider(SupportConfigFactory.GetConfiguration());
epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(epService, GetType(), GetType().FullName);
}
epService.EPAdministrator.Configuration.AddEventType <SupportBean>();
// External clocking
SendTimer(0, epService);
// Set up a timer:within
EPStatement statement = epService.EPAdministrator.CreateEPL("select a[0].TheString as a0id, a[1].TheString as a1id from pattern [ [2] a=SupportBean -> timer:interval(a[0].IntPrimitive+a[1].IntPrimitive seconds)]");
SupportUpdateListener testListener = new SupportUpdateListener();
statement.Events += testListener.Update;
SendTimer(10000, epService);
epService.EPRuntime.SendEvent(new SupportBean("E1", 3));
epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
SendTimer(14999, epService);
Assert.IsFalse(testListener.IsInvoked);
SendTimer(15000, epService);
EPAssertionUtil.AssertProps(testListener.AssertOneGetNewAndReset(), "a0id,a1id".Split(','), "E1,E2".Split(','));
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
public void TestPartitionBy()
{
var config = SupportConfigFactory.GetConfiguration();
config.AddEventType("MyEvent", typeof(SupportRecogBean));
var epService = EPServiceProviderManager.GetDefaultProvider(config);
epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(epService, GetType(), GetType().FullName);
}
var fields = "a_string,a_value,b_value".Split(',');
var text = "select * from MyEvent#keepall " +
"match_recognize (" +
" partition by TheString" +
" measures A.TheString as a_string, A.value as a_value, B.value as b_value " +
" all matches pattern (A B) " +
" define B as (B.value > A.value)" +
")" +
" order by a_string";
var stmt = epService.EPAdministrator.CreateEPL(text);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
epService.EPRuntime.SendEvent(new SupportRecogBean("S1", 5));
epService.EPRuntime.SendEvent(new SupportRecogBean("S2", 6));
epService.EPRuntime.SendEvent(new SupportRecogBean("S3", 3));
epService.EPRuntime.SendEvent(new SupportRecogBean("S4", 4));
epService.EPRuntime.SendEvent(new SupportRecogBean("S1", 5));
epService.EPRuntime.SendEvent(new SupportRecogBean("S2", 5));
epService.EPRuntime.SendEvent(new SupportRecogBean("S1", 4));
epService.EPRuntime.SendEvent(new SupportRecogBean("S4", -1));
Assert.IsFalse(listener.IsInvoked);
Assert.IsFalse(stmt.HasFirst());
epService.EPRuntime.SendEvent(new SupportRecogBean("S1", 6));
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields,
new Object[][] { new Object[] { "S1", 4, 6 } });
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new Object[][] { new Object[] { "S1", 4, 6 } });
epService.EPRuntime.SendEvent(new SupportRecogBean("S4", 10));
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields,
new Object[][] { new Object[] { "S4", -1, 10 } });
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new Object[][] { new Object[] { "S1", 4, 6 }, new Object[] { "S4", -1, 10 } });
epService.EPRuntime.SendEvent(new SupportRecogBean("S4", 11));
Assert.IsFalse(listener.IsInvoked); // since skip past last row
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new Object[][] { new Object[] { "S1", 4, 6 }, new Object[] { "S4", -1, 10 } });
epService.EPRuntime.SendEvent(new SupportRecogBean("S3", 3));
epService.EPRuntime.SendEvent(new SupportRecogBean("S4", -2));
epService.EPRuntime.SendEvent(new SupportRecogBean("S3", 2));
epService.EPRuntime.SendEvent(new SupportRecogBean("S1", 4));
Assert.IsFalse(listener.IsInvoked);
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new Object[][] { new Object[] { "S1", 4, 6 }, new Object[] { "S4", -1, 10 } });
epService.EPRuntime.SendEvent(new SupportRecogBean("S1", 7));
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields,
new Object[][] { new Object[] { "S1", 4, 7 } });
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new Object[][] { new Object[] { "S1", 4, 6 }, new Object[] { "S1", 4, 7 }, new Object[] { "S4", -1, 10 } });
epService.EPRuntime.SendEvent(new SupportRecogBean("S4", 12));
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields,
new Object[][] { new Object[] { "S4", -2, 12 } });
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new Object[][] { new Object[] { "S1", 4, 6 }, new Object[] { "S1", 4, 7 }, new Object[] { "S4", -1, 10 }, new Object[] { "S4", -2, 12 } });
epService.EPRuntime.SendEvent(new SupportRecogBean("S4", 12));
epService.EPRuntime.SendEvent(new SupportRecogBean("S1", 7));
epService.EPRuntime.SendEvent(new SupportRecogBean("S2", 4));
epService.EPRuntime.SendEvent(new SupportRecogBean("S1", 5));
Assert.IsFalse(listener.IsInvoked);
epService.EPRuntime.SendEvent(new SupportRecogBean("S2", 5));
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields,
new Object[][] { new Object[] { "S2", 4, 5 } });
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new Object[][] { new Object[] { "S1", 4, 6 }, new Object[] { "S1", 4, 7 }, new Object[] { "S2", 4, 5 }, new Object[] { "S4", -1, 10 }, new Object[] { "S4", -2, 12 } });
stmt.Dispose();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
public void TestConcatenation()
{
var config = SupportConfigFactory.GetConfiguration();
config.AddEventType("MyEvent", typeof(SupportRecogBean));
var epService = EPServiceProviderManager.GetDefaultProvider(config);
epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(epService, GetType(), GetType().FullName);
}
var fields = "a_string,b_string".Split(',');
var text = "select * from MyEvent#keepall " +
"match_recognize (" +
" measures A.TheString as a_string, B.TheString as b_string " +
" all matches " +
" pattern (A B) " +
" define B as B.value > A.value" +
") " +
"order by a_string, b_string";
var stmt = epService.EPAdministrator.CreateEPL(text);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
epService.EPRuntime.SendEvent(new SupportRecogBean("E1", 5));
epService.EPRuntime.SendEvent(new SupportRecogBean("E2", 3));
Assert.IsFalse(listener.IsInvoked);
Assert.IsFalse(stmt.HasFirst());
epService.EPRuntime.SendEvent(new SupportRecogBean("E3", 6));
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields,
new Object[][] { new Object[] { "E2", "E3" } });
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new Object[][] { new Object[] { "E2", "E3" } });
epService.EPRuntime.SendEvent(new SupportRecogBean("E4", 4));
Assert.IsFalse(listener.IsInvoked);
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new Object[][] { new Object[] { "E2", "E3" } });
epService.EPRuntime.SendEvent(new SupportRecogBean("E5", 6));
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields,
new Object[][] { new Object[] { "E4", "E5" } });
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new Object[][] { new Object[] { "E2", "E3" }, new Object[] { "E4", "E5" } });
epService.EPRuntime.SendEvent(new SupportRecogBean("E6", 10));
Assert.IsFalse(listener.IsInvoked); // E5-E6 not a match since "skip past last row"
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new Object[][] { new Object[] { "E2", "E3" }, new Object[] { "E4", "E5" } });
epService.EPRuntime.SendEvent(new SupportRecogBean("E7", 9));
epService.EPRuntime.SendEvent(new SupportRecogBean("E8", 4));
Assert.IsFalse(listener.IsInvoked);
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new Object[][] { new Object[] { "E2", "E3" }, new Object[] { "E4", "E5" } });
stmt.Stop();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
public void TestZeroToMany()
{
var config = SupportConfigFactory.GetConfiguration();
config.AddEventType("MyEvent", typeof(SupportRecogBean));
var epService = EPServiceProviderManager.GetDefaultProvider(config);
epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(epService, GetType(), GetType().FullName);
}
var fields = "a_string,b0_string,b1_string,b2_string,c_string".Split(',');
var text = "select * from MyEvent#keepall " +
"match_recognize (" +
" measures A.TheString as a_string, " +
" B[0].TheString as b0_string, " +
" B[1].TheString as b1_string, " +
" B[2].TheString as b2_string, " +
" C.TheString as c_string" +
" all matches " +
" pattern (A B* C) " +
" define \n" +
" A as A.value = 10,\n" +
" B as B.value > 10,\n" +
" C as C.value < 10\n" +
") " +
"order by a_string, c_string";
var stmt = epService.EPAdministrator.CreateEPL(text);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
epService.EPRuntime.SendEvent(new SupportRecogBean("E1", 12));
epService.EPRuntime.SendEvent(new SupportRecogBean("E2", 10));
Assert.IsFalse(listener.IsInvoked);
Assert.IsFalse(stmt.HasFirst());
epService.EPRuntime.SendEvent(new SupportRecogBean("E3", 8));
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields,
new Object[][] { new Object[] { "E2", null, null, null, "E3" } });
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new Object[][] { new Object[] { "E2", null, null, null, "E3" } });
epService.EPRuntime.SendEvent(new SupportRecogBean("E4", 10));
epService.EPRuntime.SendEvent(new SupportRecogBean("E5", 12));
Assert.IsFalse(listener.IsInvoked);
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new Object[][] { new Object[] { "E2", null, null, null, "E3" } });
epService.EPRuntime.SendEvent(new SupportRecogBean("E6", 8));
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields,
new Object[][] { new Object[] { "E4", "E5", null, null, "E6" } });
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new Object[][] { new Object[] { "E2", null, null, null, "E3" }, new Object[] { "E4", "E5", null, null, "E6" } });
epService.EPRuntime.SendEvent(new SupportRecogBean("E7", 10));
epService.EPRuntime.SendEvent(new SupportRecogBean("E8", 12));
epService.EPRuntime.SendEvent(new SupportRecogBean("E9", 12));
epService.EPRuntime.SendEvent(new SupportRecogBean("E10", 12));
epService.EPRuntime.SendEvent(new SupportRecogBean("E11", 9));
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields,
new Object[][] { new Object[] { "E7", "E8", "E9", "E10", "E11" } });
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new Object[][] { new Object[] { "E2", null, null, null, "E3" }, new Object[] { "E4", "E5", null, null, "E6" }, new Object[] { "E7", "E8", "E9", "E10", "E11" } });
stmt.Stop();
// Zero-to-many unfiltered
var epl = "select * from MyEvent match_recognize (" +
"measures A as a, B as b, C as c " +
"pattern (A C*? B) " +
"define " +
"A as Typeof(A) = 'MyEventTypeA'," +
"B as Typeof(B) = 'MyEventTypeB'" +
")";
epService.EPAdministrator.CreateEPL(epl);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
public void TestZeroToOne()
{
var config = SupportConfigFactory.GetConfiguration();
config.AddEventType("MyEvent", typeof(SupportRecogBean));
var epService = EPServiceProviderManager.GetDefaultProvider(config);
epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(epService, GetType(), GetType().FullName);
}
var fields = "a_string,b_string,c_string".Split(',');
var text = "select * from MyEvent#keepall " +
"match_recognize (" +
" measures A.TheString as a_string, B.TheString as b_string, " +
" C.TheString as c_string" +
" all matches " +
" pattern (A B? C) " +
" define \n" +
" A as (A.value = 10),\n" +
" B as (B.value > 10),\n" +
" C as (C.value < 10)\n" +
") " +
"order by a_string";
var stmt = epService.EPAdministrator.CreateEPL(text);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
epService.EPRuntime.SendEvent(new SupportRecogBean("E1", 12));
epService.EPRuntime.SendEvent(new SupportRecogBean("E2", 10));
Assert.IsFalse(listener.IsInvoked);
Assert.IsFalse(stmt.HasFirst());
epService.EPRuntime.SendEvent(new SupportRecogBean("E3", 8));
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields,
new Object[][] { new Object[] { "E2", null, "E3" } });
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new Object[][] { new Object[] { "E2", null, "E3" } });
epService.EPRuntime.SendEvent(new SupportRecogBean("E4", 10));
epService.EPRuntime.SendEvent(new SupportRecogBean("E5", 12));
Assert.IsFalse(listener.IsInvoked);
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new Object[][] { new Object[] { "E2", null, "E3" } });
epService.EPRuntime.SendEvent(new SupportRecogBean("E6", 8));
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields,
new Object[][] { new Object[] { "E4", "E5", "E6" } });
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new Object[][] { new Object[] { "E2", null, "E3" }, new Object[] { "E4", "E5", "E6" } });
epService.EPRuntime.SendEvent(new SupportRecogBean("E7", 10));
epService.EPRuntime.SendEvent(new SupportRecogBean("E8", 12));
epService.EPRuntime.SendEvent(new SupportRecogBean("E9", 12));
epService.EPRuntime.SendEvent(new SupportRecogBean("E11", 9));
Assert.IsFalse(listener.IsInvoked);
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new Object[][] { new Object[] { "E2", null, "E3" }, new Object[] { "E4", "E5", "E6" } });
stmt.Stop();
// test optional event not defined
epService.EPAdministrator.Configuration.AddEventType("A", typeof(SupportBean_A));
epService.EPAdministrator.Configuration.AddEventType("B", typeof(SupportBean_B));
var epl = "select * from A match_recognize (" +
"measures A.id as id, B.id as b_id " +
"pattern (A B?) " +
"define " +
" A as Typeof(A) = 'A'" +
")";
epService.EPAdministrator.CreateEPL(epl).Events += listener.Update;
epService.EPRuntime.SendEvent(new SupportBean_A("A1"));
Assert.IsTrue(listener.IsInvoked);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
public void TestInvalid()
{
EPServiceProvider epService = EPServiceProviderManager.GetDefaultProvider(SupportConfigFactory.GetConfiguration());
epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(epService, GetType(), GetType().FullName);
}
epService.EPAdministrator.Configuration.AddEventType <SupportBean>();
TryInvalid(epService, "select * from pattern [every SupportBean while ('abc')]",
"Invalid parameter for pattern guard 'SupportBean while (\"abc\")': Expression pattern guard requires a single expression as a parameter returning a true or false (bool) value [select * from pattern [every SupportBean while ('abc')]]");
TryInvalid(epService, "select * from pattern [every SupportBean while (abc)]",
"Failed to validate pattern guard expression 'abc': Property named 'abc' is not valid in any stream [select * from pattern [every SupportBean while (abc)]]");
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
public void TestInstanceOfDynamicVariantStream()
{
Configuration config = SupportConfigFactory.GetConfiguration();
EPServiceProvider epService = EPServiceProviderManager.GetDefaultProvider(config);
epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(epService, GetType(), GetType().FullName);
}
epService.EPAdministrator.CreateEPL("create schema S0 as " + typeof(SupportBean_S0).FullName);
epService.EPAdministrator.CreateEPL("create schema S1 as " + typeof(SupportBean_S1).FullName);
epService.EPAdministrator.CreateEPL("create variant schema MyVariantType as S0, S1");
String[] fields = "a,b".Split(',');
String text = "select * from MyVariantType.win:keepall() " +
"match_recognize (" +
" measures A.id? as a, B.id? as b" +
" pattern (A B) " +
" define " +
" A as Typeof(A) = 'S0'," +
" B as Typeof(B) = 'S1'" +
")";
EPStatement stmt = epService.EPAdministrator.CreateEPL(text);
SupportUpdateListener listener = new SupportUpdateListener();
stmt.Events += listener.Update;
epService.EPAdministrator.CreateEPL("insert into MyVariantType select * from S0");
epService.EPAdministrator.CreateEPL("insert into MyVariantType select * from S1");
epService.EPRuntime.SendEvent(new SupportBean_S0(1, "S0"));
epService.EPRuntime.SendEvent(new SupportBean_S1(2, "S1"));
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields,
new Object[][] { new Object[] { 1, 2 } });
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new Object[][] { new Object[] { 1, 2 } });
String epl = "// Declare one sample type\n" +
"create schema ST0 as (col string)\n;" +
"// Declare second sample type\n" +
"create schema ST1 as (col string)\n;" +
"// Declare variant stream holding either type\n" +
"create variant schema MyVariantStream as ST0, ST1\n;" +
"// Populate variant stream\n" +
"insert into MyVariantStream select * from ST0\n;" +
"// Populate variant stream\n" +
"insert into MyVariantStream select * from ST1\n;" +
"// Simple pattern to match ST0 ST1 pairs\n" +
"select * from MyVariantType.win:time(1 min)\n" +
"match_recognize (\n" +
"measures A.id? as a, B.id? as b\n" +
"pattern (A B)\n" +
"define\n" +
"A as Typeof(A) = 'ST0',\n" +
"B as Typeof(B) = 'ST1'\n" +
");";
epService.EPAdministrator.DeploymentAdmin.ParseDeploy(epl);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
private void RunAssertion(bool useDefault, bool?preserve, ConfigurationEngineDefaults.Threading.Locking?locking)
{
var config = SupportConfigFactory.GetConfiguration();
if (!useDefault)
{
if (preserve != null)
{
config.EngineDefaults.ThreadingConfig.IsNamedWindowConsumerDispatchPreserveOrder = preserve.Value;
}
if (locking != null)
{
config.EngineDefaults.ThreadingConfig.NamedWindowConsumerDispatchLocking = locking.Value;
}
}
var epService = EPServiceProviderManager.GetDefaultProvider(config);
epService.Initialize();
epService.EPAdministrator.Configuration.AddEventType(typeof(EventOne));
epService.EPAdministrator.Configuration.AddEventType(typeof(EventTwo));
var epl =
"create window EventOneWindow.std:unique(key) as EventOne;\n" +
"insert into EventOneWindow select * from EventOne;\n" +
"create window EventTwoWindow.std:unique(key) as EventTwo;\n" +
"insert into EventTwoWindow select * from EventTwo;\n" +
"@Name('out') select * from EventOneWindow as e1, EventTwoWindow as e2 where e1.key = e2.key";
epService.EPAdministrator.DeploymentAdmin.ParseDeploy(epl);
var listener = new SupportMTUpdateListener();
epService.EPAdministrator.GetStatement("out").Events += listener.Update;
ThreadStart runnableOne = () =>
{
for (var i = 0; i < 33; i++)
{
var eventOne = new EventOne("TEST");
epService.EPRuntime.SendEvent(eventOne);
var eventTwo = new EventTwo("TEST");
epService.EPRuntime.SendEvent(eventTwo);
}
};
ThreadStart runnableTwo = () =>
{
for (var i = 0; i < 33; i++)
{
var eventTwo = new EventTwo("TEST");
epService.EPRuntime.SendEvent(eventTwo);
var eventOne = new EventOne("TEST");
epService.EPRuntime.SendEvent(eventOne);
}
};
ThreadStart runnableThree = () =>
{
for (var i = 0; i < 34; i++)
{
var eventTwo = new EventTwo("TEST");
epService.EPRuntime.SendEvent(eventTwo);
var eventOne = new EventOne("TEST");
epService.EPRuntime.SendEvent(eventOne);
}
};
var t1 = new Thread(runnableOne);
var t2 = new Thread(runnableTwo);
var t3 = new Thread(runnableThree);
t1.Start();
t2.Start();
t3.Start();
t1.Join();
t2.Join();
t3.Join();
var delivered = listener.GetNewDataList();
// count deliveries of multiple rows
var countMultiDeliveries = 0;
foreach (var events in delivered)
{
countMultiDeliveries += (events.Length > 1 ? 1 : 0);
}
// count deliveries where instance doesn't monotonically increase from previous row for one column
var countNotMonotone = 0;
long?previousIdE1 = null;
long?previousIdE2 = null;
foreach (var events in delivered)
{
var idE1 = events[0].Get("e1.instance").AsLong();
var idE2 = events[0].Get("e2.instance").AsLong();
// comment-in when needed: System.out.println("Received " + idE1 + " " + idE2);
if (previousIdE1 != null)
{
var incorrect = idE1 != previousIdE1 && idE2 != previousIdE2;
if (!incorrect)
{
incorrect = (idE1 == previousIdE1 && idE2 != (previousIdE2 + 1) ||
(idE2 == previousIdE2 && idE1 != (previousIdE1 + 1)));
}
if (incorrect)
{
// comment-in when needed: System.out.println("Non-Monotone increase (this is still correct but noteworthy)");
countNotMonotone++;
}
}
previousIdE1 = idE1;
previousIdE2 = idE2;
}
if (useDefault || preserve.Value)
{
Assert.AreEqual(0, countMultiDeliveries, "multiple row deliveries: " + countMultiDeliveries);
// the number of non-monotone delivers should be small but not zero
// this is because when the event get generated and when the event actually gets processed may not be in the same order
Assert.That(countNotMonotone, Is.LessThan(50), "count not monotone: " + countNotMonotone);
Assert.That(delivered.Count, Is.GreaterThanOrEqualTo(197)); // its possible to not have 199 since there may not be events on one side of the join
}
else
{
Assert.That(countMultiDeliveries, Is.GreaterThan(0), "multiple row deliveries: " + countMultiDeliveries);
Assert.That(countNotMonotone, Is.GreaterThan(5), "count not monotone: " + countNotMonotone);
}
}
public void TestEventTyped()
{
var config = SupportConfigFactory.GetConfiguration();
_epService = EPServiceProviderManager.GetDefaultProvider(config);
_epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(_epService, GetType(), GetType().FullName);
}
_listener = new SupportUpdateListener();
_listenerSet = new SupportUpdateListener();
_epService.EPAdministrator.Configuration.AddEventType("S0Type", typeof(SupportBean_S0));
_epService.EPAdministrator.Configuration.AddEventType("SupportBean", typeof(SupportBean));
// assign to properties of a variable
// assign: configuration runtime + config static
// SODA
_epService.EPAdministrator.CreateEPL("create variable Object varobject = null");
_epService.EPAdministrator.CreateEPL("create variable " + typeof(SupportBean_A).FullName + " varbean = null");
_epService.EPAdministrator.CreateEPL("create variable S0Type vartype = null");
var fields = "varobject,varbean,varbean.id,vartype,vartype.id".Split(',');
var stmt = _epService.EPAdministrator.CreateEPL("select varobject, varbean, varbean.id, vartype, vartype.id from SupportBean");
stmt.Events += _listener.Update;
// test null
_epService.EPRuntime.SendEvent(new SupportBean());
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { null, null, null, null, null });
// test objects
var a1objectOne = new SupportBean_A("A1");
var s0objectOne = new SupportBean_S0(1);
_epService.EPRuntime.SetVariableValue("varobject", "abc");
_epService.EPRuntime.SetVariableValue("varbean", a1objectOne);
_epService.EPRuntime.SetVariableValue("vartype", s0objectOne);
_epService.EPRuntime.SendEvent(new SupportBean());
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "abc", a1objectOne, a1objectOne.Id, s0objectOne, s0objectOne.Id });
// test on-set for Object and EventType
var fieldsTop = "varobject,vartype,varbean".Split(',');
var stmtSet = _epService.EPAdministrator.CreateEPL("on S0Type(p00='X') arrival set varobject=1, vartype=arrival, varbean=null");
stmtSet.Events += _listener.Update;
var s0objectTwo = new SupportBean_S0(2, "X");
_epService.EPRuntime.SendEvent(s0objectTwo);
Assert.AreEqual(1, _epService.EPRuntime.GetVariableValue("varobject"));
Assert.AreEqual(s0objectTwo, _epService.EPRuntime.GetVariableValue("vartype"));
Assert.AreEqual(s0objectTwo, _epService.EPRuntime.GetVariableValue(Collections.SingletonList("vartype")).Get("vartype"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsTop, new Object[] { 1, s0objectTwo, null });
EPAssertionUtil.AssertProps(stmtSet.First(), fieldsTop, new Object[] { 1, s0objectTwo, null });
// set via API to null
IDictionary <String, Object> newValues = new Dictionary <String, Object>();
newValues.Put("varobject", null);
newValues.Put("vartype", null);
newValues.Put("varbean", null);
_epService.EPRuntime.SetVariableValue(newValues);
_epService.EPRuntime.SendEvent(new SupportBean());
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { null, null, null, null, null });
// set via API to values
newValues.Put("varobject", 10L);
newValues.Put("vartype", s0objectTwo);
newValues.Put("varbean", a1objectOne);
_epService.EPRuntime.SetVariableValue(newValues);
_epService.EPRuntime.SendEvent(new SupportBean());
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { 10L, a1objectOne, a1objectOne.Id, s0objectTwo, s0objectTwo.Id });
// test on-set for Bean class
stmtSet = _epService.EPAdministrator.CreateEPL("on " + typeof(SupportBean_A).FullName + "(id='Y') arrival set varobject=null, vartype=null, varbean=arrival");
stmtSet.Events += _listener.Update;
var a1objectTwo = new SupportBean_A("Y");
_epService.EPRuntime.SendEvent(new SupportBean_A("Y"));
Assert.AreEqual(null, _epService.EPRuntime.GetVariableValue("varobject"));
Assert.AreEqual(null, _epService.EPRuntime.GetVariableValue("vartype"));
Assert.AreEqual(a1objectTwo, _epService.EPRuntime.GetVariableValue(Collections.SingletonList("varbean")).Get("varbean"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsTop, new Object[] { null, null, a1objectTwo });
EPAssertionUtil.AssertProps(stmtSet.First(), fieldsTop, new Object[] { null, null, a1objectTwo });
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
public void TestVariableMoreThenOnce()
{
var config = SupportConfigFactory.GetConfiguration();
config.AddEventType("MyEvent", typeof(SupportRecogBean));
var epService = EPServiceProviderManager.GetDefaultProvider(config);
epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(epService, GetType(), GetType().FullName);
}
var fields = "a0,b,a1".Split(',');
var text = "select * from MyEvent#keepall " +
"match_recognize (" +
" measures A[0].TheString as a0, B.TheString as b, A[1].TheString as a1 " +
" all matches pattern ( A B A ) " +
" define " +
" A as (A.value = 1)," +
" B as (B.value = 2)" +
")";
var stmt = epService.EPAdministrator.CreateEPL(text);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
epService.EPRuntime.SendEvent(new SupportRecogBean("E1", 3));
epService.EPRuntime.SendEvent(new SupportRecogBean("E2", 1));
epService.EPRuntime.SendEvent(new SupportRecogBean("E3", 2));
epService.EPRuntime.SendEvent(new SupportRecogBean("E4", 5));
epService.EPRuntime.SendEvent(new SupportRecogBean("E5", 1));
epService.EPRuntime.SendEvent(new SupportRecogBean("E6", 2));
Assert.IsFalse(listener.IsInvoked);
Assert.IsFalse(stmt.HasFirst());
epService.EPRuntime.SendEvent(new SupportRecogBean("E7", 1));
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields,
new Object[][] { new Object[] { "E5", "E6", "E7" } });
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new Object[][] { new Object[] { "E5", "E6", "E7" } });
epService.EPRuntime.SendEvent(new SupportRecogBean("E8", 2));
epService.EPRuntime.SendEvent(new SupportRecogBean("E9", 1));
Assert.IsFalse(listener.IsInvoked);
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new Object[][] { new Object[] { "E5", "E6", "E7" } });
epService.EPRuntime.SendEvent(new SupportRecogBean("E10", 2));
epService.EPRuntime.SendEvent(new SupportRecogBean("E11", 1));
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields,
new Object[][] { new Object[] { "E9", "E10", "E11" } });
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new Object[][] { new Object[] { "E5", "E6", "E7" }, new Object[] { "E9", "E10", "E11" } });
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
public void SetUp()
{
Configuration config = SupportConfigFactory.GetConfiguration();
_engine = EPServiceProviderManager.GetProvider("TestMTStmtFilter", config);
}
private void TrySendCountFollowedBy(int numThreads, int numEvents, ConfigurationEngineDefaults.ThreadingConfig.Locking locking)
{
Configuration config = SupportConfigFactory.GetConfiguration();
config.EngineDefaults.Threading.InsertIntoDispatchLocking = locking;
config.EngineDefaults.Threading.InsertIntoDispatchTimeout = 5000; // 5 second timeout
// This should fail all test in this class
// config.EngineDefaults.Threading.InsertIntoDispatchPreserveOrder = false;
EPServiceProvider engine = EPServiceProviderManager.GetProvider(
SupportContainer.Instance, this.GetType().Name, config);
engine.Initialize();
// setup statements
EPStatement stmtInsert = engine.EPAdministrator.CreateEPL("insert into MyStream select count(*) as cnt from " + typeof(SupportBean).FullName);
stmtInsert.Events += (sender, args) => Log.Debug(".update cnt=" + args.NewEvents[0].Get("cnt"));
var listeners = new SupportUpdateListener[numEvents];
for (int i = 0; i < numEvents; i++)
{
string text = "select * from pattern [MyStream(cnt=" + (i + 1) + ") -> MyStream(cnt=" + (i + 2) + ")]";
EPStatement stmt = engine.EPAdministrator.CreateEPL(text);
listeners[i] = new SupportUpdateListener();
stmt.Events += listeners[i].Update;
}
// execute
var threadPool = Executors.NewFixedThreadPool(numThreads);
var future = new Future <bool> [numThreads];
var sharedStartLock = SupportContainer.Instance.RWLockManager().CreateDefaultLock();
using (sharedStartLock.WriteLock.Acquire())
{
for (int i = 0; i < numThreads; i++)
{
future[i] = threadPool.Submit(
new SendEventRWLockCallable(i, sharedStartLock.WriteLock, engine, new GeneratorIterator(numEvents)));
}
Thread.Sleep(100);
}
threadPool.Shutdown();
threadPool.AwaitTermination(10, TimeUnit.SECONDS);
for (int i = 0; i < numThreads; i++)
{
Assert.IsTrue(future[i].GetValueOrDefault());
}
// assert result
for (int i = 0; i < numEvents - 1; i++)
{
Assert.AreEqual(1, listeners[i].NewDataList.Count, "Listener not invoked: #" + i);
}
engine.Dispose();
}
public void TestIntervalSpecExpression()
{
EPServiceProvider epService = EPServiceProviderManager.GetDefaultProvider(SupportConfigFactory.GetConfiguration());
epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(epService, GetType(), GetType().FullName);
}
// External clocking
SendTimer(0, epService);
// Set up a timer:within
epService.EPAdministrator.CreateEPL("create variable double M=1");
epService.EPAdministrator.CreateEPL("create variable double S=2");
EPStatement statement = epService.EPAdministrator.CreateEPL("select * from pattern [timer:interval(M*60+S seconds)]");
SupportUpdateListener testListener = new SupportUpdateListener();
statement.Events += testListener.Update;
SendTimer(62 * 1000 - 1, epService);
Assert.IsFalse(testListener.IsInvoked);
SendTimer(62 * 1000, epService);
Assert.IsTrue(testListener.IsInvoked);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
public void TestAndNotDefaultTrue()
{
// ESPER-402
EPServiceProvider engine = EPServiceProviderManager.GetDefaultProvider(SupportConfigFactory.GetConfiguration());
SupportUpdateListener listener = new SupportUpdateListener();
engine.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(engine, GetType(), GetType().FullName);
}
engine.EPAdministrator.Configuration.AddEventType("CallWaiting", typeof(SupportBean_A));
engine.EPAdministrator.Configuration.AddEventType("CallFinished", typeof(SupportBean_B));
engine.EPAdministrator.Configuration.AddEventType("CallPickedUp", typeof(SupportBean_C));
String pattern =
" insert into NumberOfWaitingCalls(calls) " +
" select count(*)" +
" from pattern[every call=CallWaiting ->" +
" (not CallFinished(id=call.id) and" +
" not CallPickedUp(id=call.id))]";
engine.EPAdministrator.CreateEPL(pattern).Events += listener.Update;
engine.EPRuntime.SendEvent(new SupportBean_A("A1"));
engine.EPRuntime.SendEvent(new SupportBean_B("B1"));
engine.EPRuntime.SendEvent(new SupportBean_C("C1"));
Assert.IsTrue(listener.IsInvoked);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
public void TestIntervalSpecPreparedStmt()
{
EPServiceProvider epService = EPServiceProviderManager.GetDefaultProvider(SupportConfigFactory.GetConfiguration());
epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(epService, GetType(), GetType().FullName);
}
// External clocking
SendTimer(0, epService);
// Set up a timer:within
EPPreparedStatement prepared = epService.EPAdministrator.PrepareEPL(
"select * from pattern [timer:interval(? minute ? seconds)]");
prepared.SetObject(1, 1);
prepared.SetObject(2, 2);
EPStatement statement = epService.EPAdministrator.Create(prepared);
SupportUpdateListener testListener = new SupportUpdateListener();
statement.Events += testListener.Update;
SendTimer(62 * 1000 - 1, epService);
Assert.IsFalse(testListener.IsInvoked);
SendTimer(62 * 1000, epService);
Assert.IsTrue(testListener.IsInvoked);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
private void RunAssertionWithinMayMaxMonthScoped(bool hasMax)
{
EPServiceProvider epService = EPServiceProviderManager.GetDefaultProvider(SupportConfigFactory.GetConfiguration());
epService.Initialize();
epService.EPAdministrator.Configuration.AddEventType <SupportBean>();
SupportUpdateListener listener = new SupportUpdateListener();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(epService, GetType(), GetType().FullName);
}
SendCurrentTime(epService, "2002-02-01T09:00:00.000");
epService.EPAdministrator.CreateEPL("select * from pattern [(every SupportBean) where " +
(hasMax ? "timer:withinmax(1 month, 10)" : "timer:within(1 month)") +
"]").Events += listener.Update;
epService.EPRuntime.SendEvent(new SupportBean("E1", 0));
Assert.IsTrue(listener.GetAndClearIsInvoked());
SendCurrentTimeWithMinus(epService, "2002-03-01T09:00:00.000", 1);
epService.EPRuntime.SendEvent(new SupportBean("E2", 0));
Assert.IsTrue(listener.GetAndClearIsInvoked());
SendCurrentTime(epService, "2002-03-01T09:00:00.000");
epService.EPRuntime.SendEvent(new SupportBean("E3", 0));
Assert.IsFalse(listener.GetAndClearIsInvoked());
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
private void TryPublicAccessors(CodeGenerationEnum codeGeneration)
{
var config = SupportConfigFactory.GetConfiguration();
_epService = EPServiceProviderManager.GetProvider(GetType().FullName + ".test1" + codeGeneration, config);
_epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(_epService, GetType(), GetType().FullName);
}
var legacyDef = new ConfigurationEventTypeLegacy();
legacyDef.AccessorStyle = AccessorStyleEnum.PUBLIC;
legacyDef.CodeGeneration = codeGeneration;
legacyDef.AddFieldProperty("explicitFSimple", "fieldLegacyVal");
legacyDef.AddFieldProperty("explicitFIndexed", "fieldStringArray");
legacyDef.AddFieldProperty("explicitFNested", "fieldNested");
legacyDef.AddMethodProperty("explicitMSimple", "ReadLegacyBeanVal");
legacyDef.AddMethodProperty("explicitMArray", "ReadStringArray");
legacyDef.AddMethodProperty("explicitMIndexed", "ReadStringIndexed");
legacyDef.AddMethodProperty("explicitMMapped", "ReadMapByKey");
_epService.EPAdministrator.Configuration.AddEventType("MyLegacyEvent", typeof(SupportLegacyBean).FullName, legacyDef);
legacyDef = new ConfigurationEventTypeLegacy();
legacyDef.AccessorStyle = AccessorStyleEnum.PUBLIC;
legacyDef.CodeGeneration = CodeGenerationEnum.DISABLED;
_epService.EPAdministrator.Configuration.AddEventType("MyLegacyNestedEvent", typeof(SupportLegacyBean.LegacyNested).FullName, legacyDef);
// assert type metadata
var type = (EventTypeSPI)((EPServiceProviderSPI)_epService).EventAdapterService.GetEventTypeByName("MyLegacyEvent");
Assert.AreEqual(ApplicationType.CLASS, type.Metadata.OptionalApplicationType);
Assert.AreEqual(1, type.Metadata.OptionalSecondaryNames.Count);
Assert.AreEqual(typeof(SupportLegacyBean).FullName, type.Metadata.OptionalSecondaryNames.First());
Assert.AreEqual("MyLegacyEvent", type.Metadata.PrimaryName);
Assert.AreEqual("MyLegacyEvent", type.Metadata.PublicName);
Assert.AreEqual(TypeClass.APPLICATION, type.Metadata.TypeClass);
Assert.AreEqual(true, type.Metadata.IsApplicationConfigured);
Assert.AreEqual(false, type.Metadata.IsApplicationPreConfigured);
Assert.AreEqual(false, type.Metadata.IsApplicationPreConfiguredStatic);
var statementText = "select " +
"fieldLegacyVal as fieldSimple," +
"fieldStringArray as fieldArr," +
"fieldStringArray[1] as fieldArrIndexed," +
"fieldMapped as fieldMap," +
"fieldNested as fieldNested," +
"fieldNested.ReadNestedValue as fieldNestedVal," +
"ReadLegacyBeanVal as simple," +
"ReadLegacyNested as nestedObject," +
"ReadLegacyNested.ReadNestedValue as nested," +
"ReadStringArray[0] as array," +
"ReadStringIndexed[1] as Indexed," +
"ReadMapByKey('key1') as mapped," +
"ReadMap as mapItself," +
"explicitFSimple, " +
"explicitFIndexed[0], " +
"explicitFNested, " +
"explicitMSimple, " +
"explicitMArray[0], " +
"explicitMIndexed[1], " +
"explicitMMapped('key2')" +
" from MyLegacyEvent.win:length(5)";
var statement = _epService.EPAdministrator.CreateEPL(statementText);
var listener = new SupportUpdateListener();
statement.Events += listener.Update;
var eventType = statement.EventType;
Assert.AreEqual(typeof(string), eventType.GetPropertyType("fieldSimple"));
Assert.AreEqual(typeof(String[]), eventType.GetPropertyType("fieldArr"));
Assert.AreEqual(typeof(string), eventType.GetPropertyType("fieldArrIndexed"));
Assert.AreEqual(typeof(IDictionary <string, string>), eventType.GetPropertyType("fieldMap"));
Assert.AreEqual(typeof(SupportLegacyBean.LegacyNested), eventType.GetPropertyType("fieldNested"));
Assert.AreEqual(typeof(string), eventType.GetPropertyType("fieldNestedVal"));
Assert.AreEqual(typeof(string), eventType.GetPropertyType("simple"));
Assert.AreEqual(typeof(SupportLegacyBean.LegacyNested), eventType.GetPropertyType("nestedObject"));
Assert.AreEqual(typeof(string), eventType.GetPropertyType("nested"));
Assert.AreEqual(typeof(string), eventType.GetPropertyType("array"));
Assert.AreEqual(typeof(string), eventType.GetPropertyType("Indexed"));
Assert.AreEqual(typeof(string), eventType.GetPropertyType("mapped"));
Assert.AreEqual(typeof(string), eventType.GetPropertyType("explicitFSimple"));
Assert.AreEqual(typeof(string), eventType.GetPropertyType("explicitFIndexed[0]"));
Assert.AreEqual(typeof(SupportLegacyBean.LegacyNested), eventType.GetPropertyType("explicitFNested"));
Assert.AreEqual(typeof(string), eventType.GetPropertyType("explicitMSimple"));
Assert.AreEqual(typeof(string), eventType.GetPropertyType("explicitMArray[0]"));
Assert.AreEqual(typeof(string), eventType.GetPropertyType("explicitMIndexed[1]"));
Assert.AreEqual(typeof(string), eventType.GetPropertyType("explicitMMapped('key2')"));
_epService.EPRuntime.SendEvent(_legacyBean);
Assert.AreEqual(_legacyBean.fieldLegacyVal, listener.LastNewData[0].Get("fieldSimple"));
Assert.AreEqual(_legacyBean.fieldStringArray, listener.LastNewData[0].Get("fieldArr"));
Assert.AreEqual(_legacyBean.fieldStringArray[1], listener.LastNewData[0].Get("fieldArrIndexed"));
Assert.AreEqual(_legacyBean.fieldMapped, listener.LastNewData[0].Get("fieldMap"));
Assert.AreEqual(_legacyBean.fieldNested, listener.LastNewData[0].Get("fieldNested"));
Assert.AreEqual(_legacyBean.fieldNested.ReadNestedValue(), listener.LastNewData[0].Get("fieldNestedVal"));
Assert.AreEqual(_legacyBean.ReadLegacyBeanVal(), listener.LastNewData[0].Get("simple"));
Assert.AreEqual(_legacyBean.ReadLegacyNested(), listener.LastNewData[0].Get("nestedObject"));
Assert.AreEqual(_legacyBean.ReadLegacyNested().ReadNestedValue(), listener.LastNewData[0].Get("nested"));
Assert.AreEqual(_legacyBean.ReadStringIndexed(0), listener.LastNewData[0].Get("array"));
Assert.AreEqual(_legacyBean.ReadStringIndexed(1), listener.LastNewData[0].Get("Indexed"));
Assert.AreEqual(_legacyBean.ReadMapByKey("key1"), listener.LastNewData[0].Get("mapped"));
Assert.AreEqual(_legacyBean.ReadMap(), listener.LastNewData[0].Get("mapItself"));
Assert.AreEqual(_legacyBean.ReadLegacyBeanVal(), listener.LastNewData[0].Get("explicitFSimple"));
Assert.AreEqual(_legacyBean.ReadLegacyBeanVal(), listener.LastNewData[0].Get("explicitMSimple"));
Assert.AreEqual(_legacyBean.ReadLegacyNested(), listener.LastNewData[0].Get("explicitFNested"));
Assert.AreEqual(_legacyBean.ReadStringIndexed(0), listener.LastNewData[0].Get("explicitFIndexed[0]"));
Assert.AreEqual(_legacyBean.ReadStringIndexed(0), listener.LastNewData[0].Get("explicitMArray[0]"));
Assert.AreEqual(_legacyBean.ReadStringIndexed(1), listener.LastNewData[0].Get("explicitMIndexed[1]"));
Assert.AreEqual(_legacyBean.ReadMapByKey("key2"), listener.LastNewData[0].Get("explicitMMapped('key2')"));
var stmtType = (EventTypeSPI)statement.EventType;
Assert.AreEqual(null, stmtType.Metadata.OptionalApplicationType);
Assert.AreEqual(null, stmtType.Metadata.OptionalSecondaryNames);
Assert.NotNull(stmtType.Metadata.PrimaryName);
Assert.NotNull(stmtType.Metadata.PublicName);
Assert.NotNull(stmtType.Name);
Assert.AreEqual(TypeClass.ANONYMOUS, stmtType.Metadata.TypeClass);
Assert.AreEqual(false, stmtType.Metadata.IsApplicationConfigured);
Assert.AreEqual(false, stmtType.Metadata.IsApplicationPreConfigured);
Assert.AreEqual(false, stmtType.Metadata.IsApplicationPreConfiguredStatic);
_epService.Dispose();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
public void TestFragment()
{
var config = SupportConfigFactory.GetConfiguration();
config.AddEventType("A", typeof(SupportBean_A).FullName);
config.AddEventType("B", typeof(SupportBean_B).FullName);
var epService = EPServiceProviderManager.GetDefaultProvider(config);
epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(epService, GetType(), GetType().FullName);
}
var stmtTxtOne = "select * from pattern [[2] a=A -> b=B]";
var stmt = epService.EPAdministrator.CreateEPL(stmtTxtOne);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
EPAssertionUtil.AssertEqualsAnyOrder(new [] {
new EventPropertyDescriptor("a", typeof(SupportBean_A[]), typeof(SupportBean_A), false, false, true, false, true),
new EventPropertyDescriptor("b", typeof(SupportBean_B), null, false, false, false, false, true)
}, stmt.EventType.PropertyDescriptors);
epService.EPRuntime.SendEvent(new SupportBean_A("A1"));
epService.EPRuntime.SendEvent(new SupportBean_A("A2"));
epService.EPRuntime.SendEvent(new SupportBean_B("B1"));
var theEvent = listener.AssertOneGetNewAndReset();
Assert.IsTrue(theEvent.Underlying is IDictionary <string, object>);
// test fragment B type and theEvent
var typeFragB = theEvent.EventType.GetFragmentType("b");
Assert.IsFalse(typeFragB.IsIndexed);
Assert.AreEqual("B", typeFragB.FragmentType.Name);
Assert.AreEqual(typeof(string), typeFragB.FragmentType.GetPropertyType("id"));
var eventFragB = (EventBean)theEvent.GetFragment("b");
Assert.AreEqual("B", eventFragB.EventType.Name);
// test fragment A type and event
var typeFragA = theEvent.EventType.GetFragmentType("a");
Assert.IsTrue(typeFragA.IsIndexed);
Assert.AreEqual("A", typeFragA.FragmentType.Name);
Assert.AreEqual(typeof(string), typeFragA.FragmentType.GetPropertyType("id"));
Assert.IsTrue(theEvent.GetFragment("a") is EventBean[]);
var eventFragA1 = (EventBean)theEvent.GetFragment("a[0]");
Assert.AreEqual("A", eventFragA1.EventType.Name);
Assert.AreEqual("A1", eventFragA1.Get("id"));
var eventFragA2 = (EventBean)theEvent.GetFragment("a[1]");
Assert.AreEqual("A", eventFragA2.EventType.Name);
Assert.AreEqual("A2", eventFragA2.Get("id"));
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
public void TestAddRemoveType()
{
var config = SupportConfigFactory.GetConfiguration();
_epService = EPServiceProviderManager.GetDefaultProvider(config);
_epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(_epService, GetType(), GetType().FullName);
}
var configOps = _epService.EPAdministrator.Configuration;
// test remove type with statement used (no force)
configOps.AddEventType("MyBeanEvent", typeof(SupportBean_A));
var stmt = _epService.EPAdministrator.CreateEPL("select id from MyBeanEvent", "stmtOne");
EPAssertionUtil.AssertEqualsExactOrder(configOps.GetEventTypeNameUsedBy("MyBeanEvent").ToArray(), new String[] { "stmtOne" });
try
{
configOps.RemoveEventType("MyBeanEvent", false);
}
catch (ConfigurationException ex)
{
Assert.IsTrue(ex.Message.Contains("MyBeanEvent"));
}
// destroy statement and type
stmt.Dispose();
Assert.IsTrue(configOps.GetEventTypeNameUsedBy("MyBeanEvent").IsEmpty());
Assert.IsTrue(configOps.IsEventTypeExists("MyBeanEvent"));
Assert.IsTrue(configOps.RemoveEventType("MyBeanEvent", false));
Assert.IsFalse(configOps.RemoveEventType("MyBeanEvent", false)); // try double-remove
Assert.IsFalse(configOps.IsEventTypeExists("MyBeanEvent"));
try
{
_epService.EPAdministrator.CreateEPL("select id from MyBeanEvent");
Assert.Fail();
}
catch (EPException ex)
{
// expected
}
// add back the type
configOps.AddEventType("MyBeanEvent", typeof(SupportBean));
Assert.IsTrue(configOps.IsEventTypeExists("MyBeanEvent"));
Assert.IsTrue(configOps.GetEventTypeNameUsedBy("MyBeanEvent").IsEmpty());
// compile
_epService.EPAdministrator.CreateEPL("select BoolPrimitive from MyBeanEvent", "stmtTwo");
EPAssertionUtil.AssertEqualsExactOrder(configOps.GetEventTypeNameUsedBy("MyBeanEvent").ToArray(), new String[] { "stmtTwo" });
try
{
_epService.EPAdministrator.CreateEPL("select id from MyBeanEvent");
Assert.Fail();
}
catch (EPException ex)
{
// expected
}
// remove with force
try
{
configOps.RemoveEventType("MyBeanEvent", false);
}
catch (ConfigurationException ex)
{
Assert.IsTrue(ex.Message.Contains("MyBeanEvent"));
}
Assert.IsTrue(configOps.RemoveEventType("MyBeanEvent", true));
Assert.IsFalse(configOps.IsEventTypeExists("MyBeanEvent"));
Assert.IsTrue(configOps.GetEventTypeNameUsedBy("MyBeanEvent").IsEmpty());
// add back the type
configOps.AddEventType("MyBeanEvent", typeof(SupportMarketDataBean));
Assert.IsTrue(configOps.IsEventTypeExists("MyBeanEvent"));
// compile
_epService.EPAdministrator.CreateEPL("select feed from MyBeanEvent");
try
{
_epService.EPAdministrator.CreateEPL("select BoolPrimitive from MyBeanEvent");
Assert.Fail();
}
catch (EPException ex)
{
// expected
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
public void TestObservationExampleXPathExpr()
{
var schemaUri = ResourceManager.ResolveResourceURL(CLASSLOADER_SCHEMA_URI).ToString();
var sensorcfg = new ConfigurationEventTypeXMLDOM();
sensorcfg.RootElementName = "Sensor";
sensorcfg.AddXPathProperty("countTags", "count(/ss:Sensor/ss:Observation/ss:Tag)", XPathResultType.Number);
sensorcfg.AddXPathProperty("countTagsInt", "count(/ss:Sensor/ss:Observation/ss:Tag)", XPathResultType.Number, "int");
sensorcfg.AddNamespacePrefix("ss", "SensorSchema");
sensorcfg.AddXPathProperty("idarray", "//ss:Tag/ss:ID", XPathResultType.NodeSet, "String[]");
sensorcfg.AddXPathPropertyFragment("tagArray", "//ss:Tag", XPathResultType.NodeSet, "TagEvent");
sensorcfg.AddXPathPropertyFragment("tagOne", "//ss:Tag[position() = 1]", XPathResultType.Any, "TagEvent");
sensorcfg.SchemaResource = schemaUri;
var configuration = SupportConfigFactory.GetConfiguration();
configuration.EngineDefaults.ViewResources.IsIterableUnbound = true;
configuration.AddEventType("SensorEvent", sensorcfg);
_epService = EPServiceProviderManager.GetDefaultProvider(configuration);
_epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(_epService, this.GetType(), this.GetType().FullName);
}
var tagcfg = new ConfigurationEventTypeXMLDOM();
tagcfg.RootElementName = "//Tag";
tagcfg.SchemaResource = schemaUri;
_epService.EPAdministrator.Configuration.AddEventType("TagEvent", tagcfg);
var stmtExampleOne = _epService.EPAdministrator.CreateEPL("select countTags, countTagsInt, idarray, tagArray, tagOne from SensorEvent");
var stmtExampleTwo_0 = _epService.EPAdministrator.CreateEPL("insert into TagOneStream select tagOne.* from SensorEvent");
var stmtExampleTwo_1 = _epService.EPAdministrator.CreateEPL("select ID from TagOneStream");
var stmtExampleTwo_2 = _epService.EPAdministrator.CreateEPL("insert into TagArrayStream select tagArray as mytags from SensorEvent");
var stmtExampleTwo_3 = _epService.EPAdministrator.CreateEPL("select mytags[1].ID from TagArrayStream");
var doc = SupportXML.GetDocument(XML);
_epService.EPRuntime.SendEvent(doc);
SupportEventTypeAssertionUtil.AssertConsistency(stmtExampleOne.First());
SupportEventTypeAssertionUtil.AssertConsistency(stmtExampleTwo_0.First());
SupportEventTypeAssertionUtil.AssertConsistency(stmtExampleTwo_1.First());
SupportEventTypeAssertionUtil.AssertConsistency(stmtExampleTwo_2.First());
SupportEventTypeAssertionUtil.AssertConsistency(stmtExampleTwo_3.First());
var resultArray = stmtExampleOne.First().Get("idarray");
EPAssertionUtil.AssertEqualsExactOrder((object[])resultArray, new string[] { "urn:epc:1:2.24.400", "urn:epc:1:2.24.401" });
EPAssertionUtil.AssertProps(stmtExampleOne.First(), "countTags,countTagsInt".SplitCsv(), new object[] { 2d, 2 });
Assert.AreEqual("urn:epc:1:2.24.400", stmtExampleTwo_1.First().Get("ID"));
Assert.AreEqual("urn:epc:1:2.24.401", stmtExampleTwo_3.First().Get("mytags[1].ID"));
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
public void TestAllAggFunctions()
{
var fields = "cavedev,cavg,cmax,cmedian,cmin,cstddev,csum,cfmaxever,cfminever".Split(',');
var stmt = (EPStatementSPI)_epService.EPAdministrator.CreateEPL("select " +
"avedev(IntBoxed, BoolPrimitive) as cavedev," +
"avg(IntBoxed, BoolPrimitive) as cavg, " +
"fmax(IntBoxed, BoolPrimitive) as cmax, " +
"median(IntBoxed, BoolPrimitive) as cmedian, " +
"fmin(IntBoxed, BoolPrimitive) as cmin, " +
"stddev(IntBoxed, BoolPrimitive) as cstddev, " +
"sum(IntBoxed, BoolPrimitive) as csum," +
"fmaxever(IntBoxed, BoolPrimitive) as cfmaxever, " +
"fminever(IntBoxed, BoolPrimitive) as cfminever " +
"from SupportBean.win:length(3)");
stmt.AddListener(_listener);
_epService.EPRuntime.SendEvent(MakeBean(100, false));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { null, null, null, null, null, null, null, null, null });
_epService.EPRuntime.SendEvent(MakeBean(10, true));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { 0.0d, 10.0, 10, 10.0, 10, null, 10, 10, 10 });
_epService.EPRuntime.SendEvent(MakeBean(11, false));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { 0.0d, 10.0, 10, 10.0, 10, null, 10, 10, 10 });
_epService.EPRuntime.SendEvent(MakeBean(20, true));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { 5.0d, 15.0, 20, 15.0, 10, 7.0710678118654755, 30, 20, 10 });
_epService.EPRuntime.SendEvent(MakeBean(30, true));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { 5.0d, 25.0, 30, 25.0, 20, 7.0710678118654755, 50, 30, 10 });
// Test all remaining types of "sum"
stmt.Dispose();
fields = "c1,c2,c3,c4".Split(',');
stmt = (EPStatementSPI)_epService.EPAdministrator.CreateEPL("select " +
"sum(FloatPrimitive, BoolPrimitive) as c1," +
"sum(DoublePrimitive, BoolPrimitive) as c2, " +
"sum(LongPrimitive, BoolPrimitive) as c3, " +
"sum(ShortPrimitive, BoolPrimitive) as c4 " +
"from SupportBean.win:length(2)");
stmt.AddListener(_listener);
_epService.EPRuntime.SendEvent(MakeBean(2f, 3d, 4L, (short)5, false));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { null, null, null, null });
_epService.EPRuntime.SendEvent(MakeBean(3f, 4d, 5L, (short)6, true));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { 3f, 4d, 5L, 6 });
_epService.EPRuntime.SendEvent(MakeBean(4f, 5d, 6L, (short)7, true));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { 7f, 9d, 11L, 13 });
_epService.EPRuntime.SendEvent(MakeBean(1f, 1d, 1L, (short)1, true));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { 5f, 6d, 7L, 8 });
// Test min/max-ever
stmt.Dispose();
fields = "c1,c2".Split(',');
stmt = (EPStatementSPI)_epService.EPAdministrator.CreateEPL("select " +
"fmax(IntBoxed, BoolPrimitive) as c1," +
"fmin(IntBoxed, BoolPrimitive) as c2 " +
"from SupportBean");
stmt.AddListener(_listener);
Assert.IsFalse(stmt.StatementContext.IsStatelessSelect);
_epService.EPRuntime.SendEvent(MakeBean(10, true));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { 10, 10 });
_epService.EPRuntime.SendEvent(MakeBean(20, true));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { 20, 10 });
_epService.EPRuntime.SendEvent(MakeBean(8, false));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { 20, 10 });
_epService.EPRuntime.SendEvent(MakeBean(7, true));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { 20, 7 });
_epService.EPRuntime.SendEvent(MakeBean(30, false));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { 20, 7 });
_epService.EPRuntime.SendEvent(MakeBean(40, true));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { 40, 7 });
// test decimal
stmt.Dispose();
fields = "c1,c2,c3".Split(',');
stmt = (EPStatementSPI)_epService.EPAdministrator.CreateEPL(
"select " +
"avg(DecimalOne, IntOne < 100) as c1," +
"sum(DecimalOne, IntOne < 100) as c2, " +
"sum(IntOne, IntOne < 100) as c3 " +
"from SupportBeanNumeric.win:length(2)");
stmt.AddListener(_listener);
_epService.EPRuntime.SendEvent(new SupportBeanNumeric(10, 20.0m));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { 20.0m, 20.0m, 10 });
_epService.EPRuntime.SendEvent(new SupportBeanNumeric(101, 101.0m));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { 20.0m, 20.0m, 10 });
_epService.EPRuntime.SendEvent(new SupportBeanNumeric(20, 40.0m));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { 40.0m, 40.0m, 20 });
_epService.EPRuntime.SendEvent(new SupportBeanNumeric(30, 50.0m));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { 45.0m, 90.0m, 50 });
stmt.Dispose();
var epl = "select " +
"avedev(distinct IntBoxed,BoolPrimitive) as cavedev, " +
"avg(distinct IntBoxed,BoolPrimitive) as cavg, " +
"fmax(distinct IntBoxed,BoolPrimitive) as cmax, " +
"median(distinct IntBoxed,BoolPrimitive) as cmedian, " +
"fmin(distinct IntBoxed,BoolPrimitive) as cmin, " +
"stddev(distinct IntBoxed,BoolPrimitive) as cstddev, " +
"sum(distinct IntBoxed,BoolPrimitive) as csum " +
"from SupportBean.win:length(3)";
stmt = (EPStatementSPI)_epService.EPAdministrator.CreateEPL(epl);
stmt.AddListener(_listener);
RunAssertionDistinct();
// test SODA
stmt.Dispose();
var model = _epService.EPAdministrator.CompileEPL(epl);
Assert.AreEqual(epl, model.ToEPL());
stmt = (EPStatementSPI)_epService.EPAdministrator.Create(model);
stmt.AddListener(_listener);
Assert.AreEqual(epl, stmt.Text);
RunAssertionDistinct();
// test math context for big decimal and average divide
var config = SupportConfigFactory.GetConfiguration();
config.EngineDefaults.ExpressionConfig.MathContext = new MathContext(MidpointRounding.ToEven, 2);
config.AddEventType(typeof(SupportBeanNumeric));
var engineMathCtx = EPServiceProviderManager.GetProvider(typeof(TestAggregateFiltered).Name, config);
engineMathCtx.EPAdministrator.CreateEPL("select avg(DecimalOne) as c0 from SupportBeanNumeric").Events += _listener.Update;
engineMathCtx.EPRuntime.SendEvent(new SupportBeanNumeric(null, MakeDecimal(0, 2, MidpointRounding.AwayFromZero)));
engineMathCtx.EPRuntime.SendEvent(new SupportBeanNumeric(null, MakeDecimal(0, 2, MidpointRounding.AwayFromZero)));
engineMathCtx.EPRuntime.SendEvent(new SupportBeanNumeric(null, MakeDecimal(1, 2, MidpointRounding.AwayFromZero)));
Assert.AreEqual(0.33d, _listener.GetAndResetLastNewData()[0].Get("c0").AsDouble());
engineMathCtx.Dispose();
}
public void TestEventTypedSetProp()
{
var config = SupportConfigFactory.GetConfiguration();
_epService = EPServiceProviderManager.GetDefaultProvider(config);
_epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(_epService, GetType(), GetType().FullName);
}
_listener = new SupportUpdateListener();
_listenerSet = new SupportUpdateListener();
_epService.EPAdministrator.Configuration.AddEventType("SupportBean", typeof(SupportBean));
_epService.EPAdministrator.Configuration.AddEventType("S0", typeof(SupportBean_S0));
_epService.EPAdministrator.Configuration.AddEventType("A", typeof(SupportBean_A));
_epService.EPAdministrator.CreateEPL("create variable SupportBean varbean");
var fields = "varbean.TheString,varbean.IntPrimitive,varbean.GetTheString()".Split(',');
var stmtSelect = _epService.EPAdministrator.CreateEPL("select varbean.TheString,varbean.IntPrimitive,varbean.GetTheString() from S0");
stmtSelect.Events += _listener.Update;
_epService.EPRuntime.SendEvent(new SupportBean_S0(1));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { null, null, null });
var stmtSet = _epService.EPAdministrator.CreateEPL("on A set varbean.TheString = 'A', varbean.IntPrimitive = 1");
stmtSet.Events += _listenerSet.Update;
_epService.EPRuntime.SendEvent(new SupportBean_A("E1"));
_listenerSet.Reset();
_epService.EPRuntime.SendEvent(new SupportBean_S0(2));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { null, null, null });
var setBean = new SupportBean();
_epService.EPRuntime.SetVariableValue("varbean", setBean);
_epService.EPRuntime.SendEvent(new SupportBean_A("E2"));
_epService.EPRuntime.SendEvent(new SupportBean_S0(3));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "A", 1, "A" });
Assert.AreNotSame(setBean, _epService.EPRuntime.GetVariableValue("varbean"));
Assert.AreEqual(1, ((SupportBean)_epService.EPRuntime.GetVariableValue("varbean")).IntPrimitive);
EPAssertionUtil.AssertProps(_listenerSet.AssertOneGetNewAndReset(), "varbean.TheString,varbean.IntPrimitive".Split(','), new Object[] { "A", 1 });
EPAssertionUtil.AssertProps(stmtSet.First(), "varbean.TheString,varbean.IntPrimitive".Split(','), new Object[] { "A", 1 });
// test self evaluate
stmtSet.Dispose();
stmtSet = _epService.EPAdministrator.CreateEPL("on A set varbean.TheString = A.id, varbean.TheString = '>'||varbean.TheString||'<'");
stmtSet.Events += _listenerSet.Update;
_epService.EPRuntime.SendEvent(new SupportBean_A("E3"));
Assert.AreEqual(">E3<", ((SupportBean)_epService.EPRuntime.GetVariableValue("varbean")).TheString);
// test widen
stmtSet.Dispose();
stmtSet = _epService.EPAdministrator.CreateEPL("on A set varbean.LongPrimitive = 1");
stmtSet.Events += _listenerSet.Update;
_epService.EPRuntime.SendEvent(new SupportBean_A("E4"));
Assert.AreEqual(1, ((SupportBean)_epService.EPRuntime.GetVariableValue("varbean")).LongPrimitive);
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
public void TestFollowedByWithNot()
{
Configuration config = SupportConfigFactory.GetConfiguration();
config.AddEventType("A", typeof(SupportBean_A).FullName);
config.AddEventType("B", typeof(SupportBean_B).FullName);
config.AddEventType("C", typeof(SupportBean_C).FullName);
EPServiceProvider epService = EPServiceProviderManager.GetDefaultProvider(config);
epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(epService, GetType(), GetType().FullName);
}
const string stmt = "select * from pattern [" +
" every a=A -> (timer:interval(10 seconds) and not (B(id=a.id) or C(id=a.id)))" +
"] ";
var listener = new SupportUpdateListener();
EPStatement statement = epService.EPAdministrator.CreateEPL(stmt);
Assert.AreEqual(StatementType.SELECT, ((EPStatementSPI)statement).StatementMetadata.StatementType);
statement.Events += listener.Update;
SendTimer(0, epService);
// test case where no Completed or Cancel event arrives
SupportBean_A eventA = SendA("A1", epService);
SendTimer(9999, epService);
Assert.IsFalse(listener.IsInvoked);
SendTimer(10000, epService);
EventBean received = listener.AssertOneGetNewAndReset();
Assert.AreEqual(eventA, received.Get("a"));
// test case where Completed event arrives within the time set
SendTimer(20000, epService);
eventA = SendA("A2", epService);
SendTimer(29999, epService);
SendB("A2", epService);
SendTimer(30000, epService);
Assert.IsFalse(listener.IsInvoked);
// test case where Cancelled event arrives within the time set
SendTimer(30000, epService);
eventA = SendA("A3", epService);
SendTimer(30000, epService);
SendC("A3", epService);
SendTimer(40000, epService);
Assert.IsFalse(listener.IsInvoked);
// test case where no matching Completed or Cancel event arrives
eventA = SendA("A4", epService);
SendB("B4", epService);
SendC("A5", epService);
SendTimer(50000, epService);
received = listener.AssertOneGetNewAndReset();
Assert.AreEqual(eventA, received.Get("a"));
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
public void TestNamedWindowOutOfSequenceDelete()
{
Configuration config = SupportConfigFactory.GetConfiguration();
config.AddEventType("SupportRecogBean", typeof(SupportRecogBean));
config.AddEventType <SupportBean>();
EPServiceProvider epService = EPServiceProviderManager.GetDefaultProvider(config);
epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(epService, GetType(), GetType().FullName);
}
epService.EPAdministrator.CreateEPL("create window MyWindow.win:keepall() as SupportRecogBean");
epService.EPAdministrator.CreateEPL("insert into MyWindow select * from SupportRecogBean");
epService.EPAdministrator.CreateEPL(
"on SupportBean as s delete from MyWindow as w where s.TheString = w.TheString");
String[] fields = "a0,a1,b0,b1,c".Split(',');
String text = "select * from MyWindow " +
"match_recognize (" +
" measures A[0].TheString as a0, A[1].TheString as a1, B[0].TheString as b0, B[1].TheString as b1, C.TheString as c" +
" pattern ( A+ B* C ) " +
" define " +
" A as (A.Value = 1)," +
" B as (B.Value = 2)," +
" C as (C.Value = 3)" +
")";
EPStatement stmt = epService.EPAdministrator.CreateEPL(text);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
epService.EPRuntime.SendEvent(new SupportRecogBean("E1", 1));
epService.EPRuntime.SendEvent(new SupportRecogBean("E2", 1));
epService.EPRuntime.SendEvent(new SupportBean("E2", 0)); // deletes E2
epService.EPRuntime.SendEvent(new SupportRecogBean("E3", 3));
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields,
new[] { new Object[] { "E1", null, null, null, "E3" } });
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new[] { new Object[] { "E1", null, null, null, "E3" } });
epService.EPRuntime.SendEvent(new SupportBean("E1", 0)); // deletes E1
epService.EPRuntime.SendEvent(new SupportBean("E4", 0)); // deletes E4
epService.EPRuntime.SendEvent(new SupportRecogBean("E4", 1));
epService.EPRuntime.SendEvent(new SupportRecogBean("E5", 1));
epService.EPRuntime.SendEvent(new SupportBean("E4", 0)); // deletes E4
epService.EPRuntime.SendEvent(new SupportRecogBean("E6", 3));
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields,
new[] { new Object[] { "E5", null, null, null, "E6" } });
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new[] { new Object[] { "E5", null, null, null, "E6" } });
epService.EPRuntime.SendEvent(new SupportRecogBean("E7", 1));
epService.EPRuntime.SendEvent(new SupportRecogBean("E8", 1));
epService.EPRuntime.SendEvent(new SupportRecogBean("E9", 2));
epService.EPRuntime.SendEvent(new SupportRecogBean("E10", 2));
epService.EPRuntime.SendEvent(new SupportRecogBean("E11", 2));
epService.EPRuntime.SendEvent(new SupportBean("E9", 0)); // deletes E9
epService.EPRuntime.SendEvent(new SupportRecogBean("E12", 3));
EPAssertionUtil.AssertPropsPerRow(listener.GetAndResetLastNewData(), fields,
new[] { new Object[] { "E7", "E8", "E10", "E11", "E12" } });
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new Object[][]
{
new Object[] { "E5", null, null, null, "E6" },
new Object[] { "E7", "E8", "E10", "E11", "E12" }
});
// note interranking among per-event result
epService.EPRuntime.SendEvent(new SupportRecogBean("E13", 1));
epService.EPRuntime.SendEvent(new SupportRecogBean("E14", 1));
epService.EPRuntime.SendEvent(new SupportRecogBean("E15", 2));
epService.EPRuntime.SendEvent(new SupportRecogBean("E16", 2));
epService.EPRuntime.SendEvent(new SupportBean("E14", 0)); // deletes E14
epService.EPRuntime.SendEvent(new SupportBean("E15", 0)); // deletes E15
epService.EPRuntime.SendEvent(new SupportBean("E16", 0)); // deletes E16
epService.EPRuntime.SendEvent(new SupportBean("E13", 0)); // deletes E17
epService.EPRuntime.SendEvent(new SupportRecogBean("E18", 3));
Assert.IsFalse(listener.IsInvoked);
EPAssertionUtil.AssertPropsPerRow(stmt.GetEnumerator(), fields,
new Object[][]
{
new Object[] { "E5", null, null, null, "E6" },
new Object[] { "E7", "E8", "E10", "E11", "E12" }
});
// note interranking among per-event result
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
