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(); } }