private void RunAssertionVariantOneWildcard(EPServiceProvider epService) { string stmtText = "insert into Event_1W (delta, product) " + "select * from " + typeof(SupportBean).FullName + "#length(100)"; try { epService.EPAdministrator.CreateEPL(stmtText); Assert.Fail(); } catch (EPStatementException) { // Expected } // assert statement-type reference EPServiceProviderSPI spi = (EPServiceProviderSPI)epService; Assert.IsFalse(spi.StatementEventTypeRef.IsInUse("Event_1W")); // test insert wildcard to wildcard epService.EPAdministrator.Configuration.AddEventType <SupportBean>(); var listener = new SupportUpdateListener(); string stmtSelectText = "insert into ABCStream select * from SupportBean"; EPStatement stmtSelect = epService.EPAdministrator.CreateEPL(stmtSelectText, "resilient i0"); stmtSelect.Events += listener.Update; Assert.IsTrue(stmtSelect.EventType is BeanEventType); epService.EPRuntime.SendEvent(new SupportBean("E1", 1)); Assert.AreEqual("E1", listener.AssertOneGetNew().Get("TheString")); Assert.IsTrue(listener.AssertOneGetNew().Underlying is SupportBean); stmtSelect.Dispose(); }
private void RunAssertionReclaimTimeWindow(EPServiceProvider epService) { SendTimer(epService, 0); epService.EPAdministrator.Configuration.AddEventType <SupportBean>(); epService.EPAdministrator.CreateEPL("@Hint('reclaim_group_aged=30,reclaim_group_freq=5') " + "select LongPrimitive, count(*) from SupportBean#groupwin(TheString)#time(3000000)"); for (int i = 0; i < 10; i++) { var theEvent = new SupportBean(Convert.ToString(i), i); epService.EPRuntime.SendEvent(theEvent); } EPServiceProviderSPI spi = (EPServiceProviderSPI)epService; int handleCountBefore = spi.SchedulingService.ScheduleHandleCount; Assert.AreEqual(10, handleCountBefore); SendTimer(epService, 1000000); epService.EPRuntime.SendEvent(new SupportBean("E1", 1)); int handleCountAfter = spi.SchedulingService.ScheduleHandleCount; Assert.AreEqual(1, handleCountAfter); epService.EPAdministrator.DestroyAllStatements(); }
public static Pair <ExprNode, string> CompileValidateStatementFilterExpr( EPServiceProviderSPI engine, string filterExpression) { ExprNode exprNode; try { var spi = (EPAdministratorSPI)engine.EPAdministrator; exprNode = spi.CompileExpression(filterExpression); } catch (Exception ex) { return(new Pair <ExprNode, string>(null, "Error compiling expression: " + ex.Message)); } try { var streamTypeService = new StreamTypeServiceImpl(STATEMENT_META_EVENT_TYPE, null, true, engine.URI); exprNode = ExprNodeUtility.GetValidatedSubtree( ExprNodeOrigin.SCRIPTPARAMS, exprNode, new ExprValidationContext( streamTypeService, engine.EngineImportService, null, null, engine.TimeProvider, null, null, null, engine.EventAdapterService, "no-name-assigned", -1, null, null, null, true, false, false, false, null, true)); } catch (Exception ex) { return(new Pair <ExprNode, string>(null, "Error validating expression: " + ex.Message)); } return(new Pair <ExprNode, string>(exprNode, null)); }
private void AssertTypeExists(EPServiceProvider epService, String typeName, bool isPreconfigured) { EPServiceProviderSPI spi = (EPServiceProviderSPI)epService; EventTypeSPI type = (EventTypeSPI)spi.EventAdapterService.GetEventTypeByName(typeName); Assert.IsTrue(type.Metadata.IsApplicationConfigured); Assert.AreEqual(isPreconfigured, type.Metadata.IsApplicationPreConfigured); Assert.IsFalse(type.Metadata.IsApplicationPreConfiguredStatic); }
public void TestStartStop() { String viewExpr = "@IterableUnbound every tag=" + typeof(SupportBean).FullName; EPStatement patternStmt = _epService.EPAdministrator.CreatePattern(viewExpr, "MyPattern"); Assert.AreEqual(StatementType.PATTERN, ((EPStatementSPI)patternStmt).StatementMetadata.StatementType); // Pattern started when created Assert.IsFalse(patternStmt.HasFirst()); using (IEnumerator <EventBean> safe = patternStmt.GetSafeEnumerator()) { Assert.IsFalse(safe.MoveNext()); } // Stop pattern patternStmt.Stop(); SendEvent(); Assert.That(patternStmt.GetEnumerator(), Is.InstanceOf <NullEnumerator <EventBean> >()); // Start pattern patternStmt.Start(); Assert.IsFalse(patternStmt.HasFirst()); // Send event SupportBean theEvent = SendEvent(); Assert.AreSame(theEvent, patternStmt.First().Get("tag")); using (var safe = patternStmt.GetSafeEnumerator()) { Assert.That(safe.MoveNext(), Is.True); Assert.AreSame(theEvent, safe.Current.Get("tag")); } // Stop pattern patternStmt.Stop(); Assert.That(patternStmt.GetEnumerator(), Is.InstanceOf <NullEnumerator <EventBean> >()); // Start again, iterator is zero patternStmt.Start(); Assert.IsFalse(patternStmt.HasFirst()); // assert statement-eventtype reference info EPServiceProviderSPI spi = (EPServiceProviderSPI)_epService; Assert.IsTrue(spi.StatementEventTypeRef.IsInUse(typeof(SupportBean).FullName)); ICollection <String> stmtNames = spi.StatementEventTypeRef.GetStatementNamesForType(typeof(SupportBean).FullName); Assert.IsTrue(stmtNames.Contains("MyPattern")); patternStmt.Dispose(); Assert.IsFalse(spi.StatementEventTypeRef.IsInUse(typeof(SupportBean).FullName)); stmtNames = spi.StatementEventTypeRef.GetStatementNamesForType(typeof(SupportBean).FullName); Assert.IsFalse(stmtNames.Contains("MyPattern")); }
private void RunAssertionStartStop(EPServiceProvider epService) { string epl = "@IterableUnbound every tag=" + typeof(SupportBean).FullName; EPStatement patternStmt = epService.EPAdministrator.CreatePattern(epl, "MyPattern"); Assert.AreEqual(StatementType.PATTERN, ((EPStatementSPI)patternStmt).StatementMetadata.StatementType); // Pattern started when created Assert.IsFalse(patternStmt.HasFirst()); var safe = patternStmt.GetSafeEnumerator(); Assert.IsFalse(safe.MoveNext()); safe.Dispose(); // Stop pattern patternStmt.Stop(); SendEvent(epService); //Assert.IsNull(patternStmt.GetEnumerator()); // Start pattern patternStmt.Start(); Assert.IsFalse(patternStmt.HasFirst()); // Send event SupportBean theEvent = SendEvent(epService); Assert.AreSame(theEvent, patternStmt.First().Get("tag")); safe = patternStmt.GetSafeEnumerator(); Assert.IsTrue(safe.MoveNext()); Assert.AreSame(theEvent, safe.Current.Get("tag")); safe.Dispose(); // Stop pattern patternStmt.Stop(); //Assert.IsNull(patternStmt.GetEnumerator()); // Start again, iterator is zero patternStmt.Start(); Assert.IsFalse(patternStmt.HasFirst()); // assert statement-eventtype reference info EPServiceProviderSPI spi = (EPServiceProviderSPI)epService; Assert.IsTrue(spi.StatementEventTypeRef.IsInUse(typeof(SupportBean).FullName)); var stmtNames = spi.StatementEventTypeRef.GetStatementNamesForType(typeof(SupportBean).FullName); Assert.IsTrue(stmtNames.Contains("MyPattern")); patternStmt.Dispose(); Assert.IsFalse(spi.StatementEventTypeRef.IsInUse(typeof(SupportBean).FullName)); stmtNames = spi.StatementEventTypeRef.GetStatementNamesForType(typeof(SupportBean).FullName); Assert.IsFalse(stmtNames.Contains("MyPattern")); }
public void SetUp() { Configuration config = SupportConfigFactory.GetConfiguration(); _epService = (EPServiceProviderSPI)EPServiceProviderManager.GetDefaultProvider(config); _epService.Initialize(); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.StartTest(_epService, this.GetType(), GetType().FullName); } }
private void RunAssertionVariantTwoWildcard(EPServiceProvider epService) { string stmtText = "insert into event1 select * from " + typeof(SupportBean).FullName + "#length(100)"; string otherText = "select * from default.event1#length(10)"; // Attach listener to feed EPStatement stmtOne = epService.EPAdministrator.CreateEPL(stmtText, "stmt1"); Assert.AreEqual(StatementType.INSERT_INTO, ((EPStatementSPI)stmtOne).StatementMetadata.StatementType); var listenerOne = new SupportUpdateListener(); stmtOne.Events += listenerOne.Update; EPStatement stmtTwo = epService.EPAdministrator.CreateEPL(otherText, "stmt2"); var listenerTwo = new SupportUpdateListener(); stmtTwo.Events += listenerTwo.Update; SupportBean theEvent = SendEvent(epService, 10, 11); Assert.IsTrue(listenerOne.GetAndClearIsInvoked()); Assert.AreEqual(1, listenerOne.LastNewData.Length); Assert.AreEqual(10, listenerOne.LastNewData[0].Get("IntPrimitive")); Assert.AreEqual(11, listenerOne.LastNewData[0].Get("IntBoxed")); Assert.AreEqual(20, listenerOne.LastNewData[0].EventType.PropertyNames.Length); Assert.AreSame(theEvent, listenerOne.LastNewData[0].Underlying); Assert.IsTrue(listenerTwo.GetAndClearIsInvoked()); Assert.AreEqual(1, listenerTwo.LastNewData.Length); Assert.AreEqual(10, listenerTwo.LastNewData[0].Get("IntPrimitive")); Assert.AreEqual(11, listenerTwo.LastNewData[0].Get("IntBoxed")); Assert.AreEqual(20, listenerTwo.LastNewData[0].EventType.PropertyNames.Length); Assert.AreSame(theEvent, listenerTwo.LastNewData[0].Underlying); // assert statement-type reference EPServiceProviderSPI spi = (EPServiceProviderSPI)epService; Assert.IsTrue(spi.StatementEventTypeRef.IsInUse("event1")); var stmtNames = spi.StatementEventTypeRef.GetStatementNamesForType("event1"); EPAssertionUtil.AssertEqualsAnyOrder(stmtNames.ToArray(), new string[] { "stmt1", "stmt2" }); Assert.IsTrue(spi.StatementEventTypeRef.IsInUse(typeof(SupportBean).FullName)); stmtNames = spi.StatementEventTypeRef.GetStatementNamesForType(typeof(SupportBean).FullName); EPAssertionUtil.AssertEqualsAnyOrder(stmtNames.ToArray(), new string[] { "stmt1" }); stmtOne.Dispose(); Assert.IsTrue(spi.StatementEventTypeRef.IsInUse("event1")); stmtNames = spi.StatementEventTypeRef.GetStatementNamesForType("event1"); EPAssertionUtil.AssertEqualsAnyOrder(new string[] { "stmt2" }, stmtNames.ToArray()); Assert.IsFalse(spi.StatementEventTypeRef.IsInUse(typeof(SupportBean).FullName)); stmtTwo.Dispose(); Assert.IsFalse(spi.StatementEventTypeRef.IsInUse("event1")); }
public static void AddTypeConfiguration(EPServiceProviderSPI epService) { var propertyTypes = new LinkedHashMap <String, Object>(); propertyTypes.Put("myDouble", typeof(Double)); propertyTypes.Put("myInt", typeof(int)); propertyTypes.Put("myString", typeof(String)); epService.EPAdministrator.Configuration.AddEventType("MyMapEvent", propertyTypes); epService.EPAdministrator.Configuration.AddEventType("MyOAEvent", "myDouble,myInt,myString".Split(','), new Object[] { typeof(double), typeof(int), typeof(string) }); epService.EPAdministrator.Configuration.AddEventType(typeof(MyEvent)); epService.EPAdministrator.Configuration.AddEventType("MyXMLEvent", GetConfig( epService.ServicesContext.ResourceManager)); }
public void SetUp() { Configuration config = SupportConfigFactory.GetConfiguration(); config.EngineDefaults.LoggingConfig.IsEnableQueryPlan = true; _epService = (EPServiceProviderSPI)EPServiceProviderManager.GetDefaultProvider(config); _epService.Initialize(); _listenerWindow = new SupportUpdateListener(); _listenerSelect = new SupportUpdateListener(); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.StartTest(_epService, this.GetType(), GetType().FullName); } }
public void SetUp() { Configuration config = SupportConfigFactory.GetConfiguration(); config.EngineDefaults.LoggingConfig.IsEnableQueryPlan = true; epService = (EPServiceProviderSPI) EPServiceProviderManager.GetDefaultProvider(config); epService.Initialize(); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.StartTest(epService, this.GetType(), GetType().FullName);} listenerInfra = new SupportUpdateListener(); listenerDelete = new SupportUpdateListener(); listenerSelect = new SupportUpdateListener(); foreach (Type clazz in new Type[] {typeof(SupportBean), typeof(SupportBean_A), typeof(SupportBean_B)}) { epService.EPAdministrator.Configuration.AddEventType(clazz); } }
public void SetUp() { Configuration config = SupportConfigFactory.GetConfiguration(); config.EngineDefaults.Logging.IsEnableQueryPlan = true; epService = (EPServiceProviderSPI)EPServiceProviderManager.GetDefaultProvider(config); epService.Initialize(); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.StartTest(epService, this.GetType(), GetType().FullName); } epService.EPAdministrator.Configuration.AddEventType <SupportBean>(); epService.EPAdministrator.Configuration.AddEventType(typeof(OrderBean)); }
public void SetUp() { Configuration config = SupportConfigFactory.GetConfiguration(); _epService = (EPServiceProviderSPI)EPServiceProviderManager.GetDefaultProvider(config); _epService.Initialize(); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.StartTest(_epService, this.GetType(), GetType().FullName); } _epService.EPAdministrator.Configuration.AddEventType(typeof(SupportBean_S0)); _epService.EPAdministrator.Configuration.AddEventType(typeof(MyCountAccessEvent)); _listener = new SupportUpdateListener(); }
public void TestJoinUniquePerId() { String joinStatement = "select * from " + typeof(SupportMarketDataBean).FullName + "(Symbol='IBM').win:length(3) s0, " + typeof(SupportMarketDataBean).FullName + "(Symbol='CSCO').win:length(3) s1" + " where s0.Volume=s1.Volume"; EPStatement joinView = _epService.EPAdministrator.CreateEPL(joinStatement, "MyJoin"); joinView.Events += _updateListener.Update; SendEvent(setOne[0]); SendEvent(setTwo[0]); Assert.NotNull(_updateListener.LastNewData); _updateListener.Reset(); joinView.Stop(); SendEvent(setOne[1]); SendEvent(setTwo[1]); Assert.IsFalse(_updateListener.IsInvoked); joinView.Start(); SendEvent(setOne[2]); Assert.IsFalse(_updateListener.IsInvoked); joinView.Stop(); SendEvent(setOne[3]); SendEvent(setOne[4]); SendEvent(setTwo[3]); joinView.Start(); SendEvent(setTwo[4]); Assert.IsFalse(_updateListener.IsInvoked); // assert type-statement reference EPServiceProviderSPI spi = (EPServiceProviderSPI)_epService; Assert.IsTrue(spi.StatementEventTypeRef.IsInUse(typeof(SupportMarketDataBean).FullName)); ICollection <String> stmtNames = spi.StatementEventTypeRef.GetStatementNamesForType(typeof(SupportMarketDataBean).FullName); Assert.IsTrue(stmtNames.Contains("MyJoin")); joinView.Dispose(); Assert.IsFalse(spi.StatementEventTypeRef.IsInUse(typeof(SupportMarketDataBean).FullName)); stmtNames = spi.StatementEventTypeRef.GetStatementNamesForType(typeof(SupportMarketDataBean).FullName); EPAssertionUtil.AssertEqualsAnyOrder(null, stmtNames.ToArray()); Assert.IsFalse(stmtNames.Contains("MyJoin")); }
private void RunAssertionEventsProcessed(EPServiceProvider epService) { var listenerOne = new SupportListenerTimerHRes(); var listenerTwo = new SupportListenerTimerHRes(); var listenerThree = new SupportListenerTimerHRes(); EPStatement stmtOne = epService.EPAdministrator.CreateEPL("select SupportStaticMethodLib.Sleep(100) from MyMap"); stmtOne.Events += listenerOne.Update; EPStatement stmtTwo = epService.EPAdministrator.CreateEPL("select SupportStaticMethodLib.Sleep(100) from SupportBean"); stmtTwo.Events += listenerTwo.Update; EPStatement stmtThree = epService.EPAdministrator.CreateEPL("select SupportStaticMethodLib.Sleep(100) from XMLType"); stmtThree.Events += listenerThree.Update; EventSender senderOne = epService.EPRuntime.GetEventSender("MyMap"); EventSender senderTwo = epService.EPRuntime.GetEventSender("SupportBean"); EventSender senderThree = epService.EPRuntime.GetEventSender("XMLType"); long start = PerformanceObserver.NanoTime; for (int i = 0; i < 2; i++) { epService.EPRuntime.SendEvent(new Dictionary <string, Object>(), "MyMap"); senderOne.SendEvent(new Dictionary <string, Object>()); epService.EPRuntime.SendEvent(new SupportBean()); senderTwo.SendEvent(new SupportBean()); epService.EPRuntime.SendEvent(SupportXML.GetDocument("<myevent/>")); senderThree.SendEvent(SupportXML.GetDocument("<myevent/>")); } long end = PerformanceObserver.NanoTime; long delta = (end - start) / 1000000; Assert.IsTrue(delta < 500); Thread.Sleep(1000); Assert.AreEqual(4, listenerOne.NewEvents.Count); Assert.AreEqual(4, listenerTwo.NewEvents.Count); Assert.AreEqual(4, listenerThree.NewEvents.Count); EPServiceProviderSPI spi = (EPServiceProviderSPI)epService; Assert.AreEqual(0, spi.ThreadingService.InboundQueue.Count); Assert.IsNotNull(spi.ThreadingService.InboundThreadPool); stmtOne.Dispose(); stmtTwo.Dispose(); stmtThree.Dispose(); }
public void SetUp() { EPServiceProviderManager.PurgeAllProviders(); Configuration config = SupportConfigFactory.GetConfiguration(); _epService = (EPServiceProviderSPI)EPServiceProviderManager.GetDefaultProvider(config); _epService.Initialize(); _listener = new SupportUpdateListener(); GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect(); GC.WaitForPendingFinalizers(); }
public void SetUp() { var config = SupportConfigFactory.GetConfiguration(); _epService = (EPServiceProviderSPI)EPServiceProviderManager.GetDefaultProvider(config); _epService.Initialize(); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.StartTest(_epService, this.GetType(), GetType().FullName); } _epService.EPAdministrator.Configuration.AddEventType <SupportBean>(); _epService.EPAdministrator.Configuration.AddEventType(typeof(SupportBean_S0)); _epService.EPAdministrator.Configuration.AddEventType(typeof(SupportBean_S1)); _epService.EPAdministrator.Configuration.AddEventType(typeof(SupportBean_S2)); }
/// <summary> /// Setup the esper. /// </summary> static void SetupEsper() { Configuration configuration = new Configuration(); configuration.AddEventType <BidData>(); configuration.EngineDefaults.ExpressionConfig.IsUdfCache = true; configuration.EngineDefaults.LoggingConfig.IsEnableExecutionDebug = false; configuration.EngineDefaults.LoggingConfig.IsEnableTimerDebug = false; configuration.EngineDefaults.MetricsReportingConfig.IsEnableMetricsReporting = false; configuration.EngineDefaults.MetricsReportingConfig.IsThreading = false; _espServiceProvider = (EPServiceProviderSPI)EPServiceProviderManager.GetDefaultProvider(configuration); _espAdministrator = _espServiceProvider.EPAdministrator; _espRuntime = _espServiceProvider.EPRuntime; }
public void SetUp() { Configuration configuration = SupportConfigFactory.GetConfiguration(); configuration.AddEventType("SupportBean", typeof(SupportBean)); configuration.EngineDefaults.ExecutionConfig.IsPrioritized = true; _epService = EPServiceProviderManager.GetDefaultProvider(configuration); _epService.Initialize(); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.StartTest(_epService, GetType(), GetType().FullName); } _spi = (EPServiceProviderSPI)_epService; _listener = new SupportUpdateListener(); }
public void SetUp() { var configuration = SupportConfigFactory.GetConfiguration(); configuration.AddEventType <SupportBean>(); configuration.AddEventType <SupportBean_S0>(); configuration.EngineDefaults.LoggingConfig.IsEnableExecutionDebug = true; _epService = EPServiceProviderManager.GetDefaultProvider(configuration); _epService.Initialize(); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.StartTest(_epService, GetType(), GetType().FullName); } _spi = (EPServiceProviderSPI)_epService; _listener = new SupportUpdateListener(); }
/// <summary> /// For initialization of the service to provide statement context. /// </summary> /// <param name="epStatement">the statement</param> /// <param name="epServiceProvider">the engine instance</param> /// <param name="isInsertInto">true if this is insert into</param> /// <param name="isPattern">true if this is a pattern statement</param> /// <param name="isDistinct">true if using distinct</param> /// <param name="isForClause">if set to <c>true</c> [is for clause].</param> /// <param name="statementMetricHandle">handle for metrics reporting</param> public void SetContext(EPStatementSPI epStatement, EPServiceProviderSPI epServiceProvider, bool isInsertInto, bool isPattern, bool isDistinct, bool isForClause, StatementMetricHandle statementMetricHandle) { _epStatement = epStatement; _epServiceProvider = epServiceProvider; _isInsertInto = isInsertInto; _isPattern = isPattern; _isDistinct = isDistinct; _isForClause = isForClause; _isMakeSynthetic = isInsertInto || isPattern || isDistinct || isForClause; _statementMetricHandle = statementMetricHandle; }
public void SetUp() { Configuration configuration = SupportConfigFactory.GetConfiguration(); configuration.AddEventType <SupportBean>(); configuration.AddEventType <SupportBean_S0>(); configuration.AddPlugInVirtualDataWindow("test", "vdw", typeof(SupportVirtualDWFactory).FullName, SupportVirtualDW.ITERATE); // configure with iteration _epService = EPServiceProviderManager.GetDefaultProvider(configuration); _epService.Initialize(); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.StartTest(_epService, GetType(), GetType().FullName); } _spi = (EPServiceProviderSPI)_epService; }
private void TryAssertionHash(EPServiceProvider epService, SupportUpdateListener listener, string ctx, EPStatementSPI statement, HashCodeFunc codeFunc) { string[] fields = "c0,c1,c2".Split(','); epService.EPRuntime.SendEvent(new SupportBean("E1", 5)); EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { ctx, "E1", 5 }); AssertIterator(statement, fields, new[] { new object[] { ctx, "E1", 5 } }); epService.EPRuntime.SendEvent(new SupportBean("E2", 6)); EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { ctx, "E2", 6 }); AssertIterator(statement, fields, new[] { new object[] { ctx, "E1", 5 }, new object[] { ctx, "E2", 6 } }); epService.EPRuntime.SendEvent(new SupportBean("E3", 7)); EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { ctx, "E3", 7 }); AssertIterator(statement, fields, new[] { new object[] { ctx, "E1", 5 }, new object[] { ctx, "E3", 7 }, new object[] { ctx, "E2", 6 } }); epService.EPRuntime.SendEvent(new SupportBean("E4", 8)); EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { ctx, "E4", 8 }); AssertIterator(statement, fields, new[] { new object[] { ctx, "E1", 5 }, new object[] { ctx, "E3", 7 }, new object[] { ctx, "E4", 8 }, new object[] { ctx, "E2", 6 } }); epService.EPRuntime.SendEvent(new SupportBean("E5", 9)); EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { ctx, "E5", 9 }); AssertIterator(statement, fields, new[] { new object[] { ctx, "E5", 9 }, new object[] { ctx, "E1", 5 }, new object[] { ctx, "E3", 7 }, new object[] { ctx, "E4", 8 }, new object[] { ctx, "E2", 6 } }); epService.EPRuntime.SendEvent(new SupportBean("E1", 10)); EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { ctx, "E1", 15 }); AssertIterator(statement, fields, new[] { new object[] { ctx, "E5", 9 }, new object[] { ctx, "E1", 15 }, new object[] { ctx, "E3", 7 }, new object[] { ctx, "E4", 8 }, new object[] { ctx, "E2", 6 } }); epService.EPRuntime.SendEvent(new SupportBean("E4", 11)); EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { ctx, "E4", 19 }); AssertIterator(statement, fields, new[] { new object[] { ctx, "E5", 9 }, new object[] { ctx, "E1", 15 }, new object[] { ctx, "E3", 7 }, new object[] { ctx, "E4", 19 }, new object[] { ctx, "E2", 6 } }); statement.Stop(); AgentInstanceAssertionUtil.AssertInstanceCounts(statement.StatementContext, 0, 0, 0, 0); EPServiceProviderSPI spi = (EPServiceProviderSPI)epService; Assert.AreEqual(1, spi.ContextManagementService.ContextCount); epService.EPAdministrator.GetStatement("context").Dispose(); Assert.AreEqual(1, spi.ContextManagementService.ContextCount); statement.Dispose(); Assert.AreEqual(0, spi.ContextManagementService.ContextCount); }
private void RunAssertionLifecycle(EPServiceProvider epService) { string epl = "@Name('context') create context NineToFive as start (0, 9, *, *, *) end (0, 17, *, *, *)"; EPServiceProviderSPI spi = (EPServiceProviderSPI)epService; ContextManagementService ctxMgmtService = spi.ContextManagementService; SchedulingService schedulingService = spi.SchedulingService; Assert.AreEqual(0, ctxMgmtService.ContextCount); Assert.AreEqual(0, schedulingService.ScheduleHandleCount); // create and destroy EPStatement stmtContext = epService.EPAdministrator.CreateEPL(epl); Assert.AreEqual(1, ctxMgmtService.ContextCount); Assert.AreEqual(0, schedulingService.ScheduleHandleCount); stmtContext.Dispose(); Assert.AreEqual(0, ctxMgmtService.ContextCount); // create context, create statement, destroy statement, destroy context stmtContext = epService.EPAdministrator.CreateEPL(epl); Assert.AreEqual(1, ctxMgmtService.ContextCount); EPStatement stmt = epService.EPAdministrator.CreateEPL("@Name('C') context NineToFive select * from SupportBean"); Assert.AreEqual(1, schedulingService.ScheduleHandleCount); stmt.Dispose(); Assert.AreEqual(0, schedulingService.ScheduleHandleCount); stmtContext.Dispose(); Assert.AreEqual(0, ctxMgmtService.ContextCount); // create same context epService.EPAdministrator.CreateEPL(epl); epService.EPAdministrator.CreateEPL("@Name('C') context NineToFive select * from SupportBean"); epService.EPAdministrator.CreateEPL("@Name('D') context NineToFive select * from SupportBean"); epService.EPAdministrator.DestroyAllStatements(); Assert.AreEqual(0, ctxMgmtService.ContextCount); Assert.AreEqual(0, schedulingService.ScheduleHandleCount); epService.EPAdministrator.DestroyAllStatements(); }
private void RunAssertionStatementStateChange() { EPServiceProvider stateChangeEngine = EPServiceProviderManager.GetProvider( SupportContainer.Instance, this.GetType().Name + "_statechange", SupportConfigFactory.GetConfiguration()); EPServiceProviderSPI spi = (EPServiceProviderSPI)stateChangeEngine; var observer = new SupportStmtLifecycleObserver(); spi.StatementLifecycleSvc.LifecycleEvent += observer.Observe; var listener = new SupportStatementStateListener(); stateChangeEngine.StatementCreate += listener.OnStatementCreate; stateChangeEngine.StatementStateChange += listener.OnStatementStateChange; EPStatement stmt = stateChangeEngine.EPAdministrator.CreateEPL("select * from " + typeof(SupportBean).FullName); Assert.AreEqual("CREATE;STATECHANGE;", observer.EventsAsString); Assert.AreEqual(stmt, listener.AssertOneGetAndResetCreatedEvents()); Assert.AreEqual(stmt, listener.AssertOneGetAndResetStateChangeEvents()); observer.Flush(); stmt.Stop(); Assert.AreEqual("STATECHANGE;", observer.EventsAsString); Assert.AreEqual(stmt.Name, observer.Events[0].Statement.Name); Assert.AreEqual(stmt, listener.AssertOneGetAndResetStateChangeEvents()); observer.Flush(); stmt.Events += (sender, args) => { }; Assert.AreEqual("LISTENER_ADD;", observer.EventsAsString); Assert.IsNotNull(observer.LastContext); Assert.IsTrue(observer.LastContext[0] is UpdateEventHandler); observer.Flush(); stmt.RemoveAllEventHandlers(); Assert.AreEqual(StatementLifecycleEvent.LifecycleEventType.LISTENER_REMOVE_ALL.ToString() + ";", observer.EventsAsString); stmt.Dispose(); Assert.AreEqual(stmt, listener.AssertOneGetAndResetStateChangeEvents()); stateChangeEngine.Dispose(); }
public void TestWithAdapterLoader() { // Assure destroy order ESPER-489 Configuration config = SupportConfigFactory.GetConfiguration(); Properties props = new Properties(); props["name"] = "val"; config.AddPluginLoader("MyLoader", typeof(SupportPluginLoader).FullName, props); props = new Properties(); props["name2"] = "val2"; config.AddPluginLoader("MyLoader2", typeof(SupportPluginLoader).FullName, props); EPServiceProvider service = EPServiceProviderManager.GetProvider("TestAdapterLoader", config); Assert.AreEqual(2, SupportPluginLoader.Names.Count); Assert.AreEqual(2, SupportPluginLoader.PostInitializes.Count); Assert.AreEqual("MyLoader", SupportPluginLoader.Names[0]); Assert.AreEqual("MyLoader2", SupportPluginLoader.Names[1]); Assert.AreEqual("val", SupportPluginLoader.Props[0].Get("name")); Assert.AreEqual("val2", SupportPluginLoader.Props[1].Get("name2")); EPServiceProviderSPI spi = (EPServiceProviderSPI)service; Object loader = spi.EngineEnvContext.Lookup("plugin-loader/MyLoader"); Assert.IsTrue(loader is SupportPluginLoader); loader = spi.EngineEnvContext.Lookup("plugin-loader/MyLoader2"); Assert.IsTrue(loader is SupportPluginLoader); SupportPluginLoader.PostInitializes.Clear(); SupportPluginLoader.Names.Clear(); service.Initialize(); Assert.AreEqual(2, SupportPluginLoader.PostInitializes.Count); Assert.AreEqual(2, SupportPluginLoader.Names.Count); service.Dispose(); Assert.AreEqual(2, SupportPluginLoader.Destroys.Count); Assert.AreEqual("val2", SupportPluginLoader.Destroys[0].Get("name2")); Assert.AreEqual("val", SupportPluginLoader.Destroys[1].Get("name")); }
public void SetUp() { var configDB = new ConfigurationDBRef(); configDB.SetDatabaseDriver(SupportDatabaseService.DbDriverFactoryNative); Configuration configuration = SupportConfigFactory.GetConfiguration(); configuration.AddDatabaseReference("MyDB", configDB); configuration.AddEventType("SupportBean", typeof(SupportBean)); configuration.AddEventType("SupportBean_S0", typeof(SupportBean_S0)); configuration.AddEventType("SupportBean_S1", typeof(SupportBean_S1)); _epService = EPServiceProviderManager.GetDefaultProvider(configuration); _epService.Initialize(); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.StartTest(_epService, GetType(), GetType().FullName); } _spi = (EPServiceProviderSPI)_epService; }
/// <summary> /// Ctor. /// </summary> /// <param name="epService">the EPServiceProvider for the engine runtime and services</param> /// <param name="usingEngineThread">true if the Adapter should set time by the scheduling service in the engine,false if it should set time externally through the calling thread</param> /// <param name="usingExternalTimer">true to use esper's external timer mechanism instead of internal timing</param> /// <param name="usingTimeSpanEvents"></param> protected AbstractCoordinatedAdapter(EPServiceProvider epService, bool usingEngineThread, bool usingExternalTimer, bool usingTimeSpanEvents) { UsingEngineThread = usingEngineThread; UsingExternalTimer = usingExternalTimer; UsingTimeSpanEvents = usingTimeSpanEvents; Sender = new DirectSender(); if (epService == null) { return; } if (!(epService is EPServiceProviderSPI)) { throw new ArgumentException("Invalid epService provided"); } _epService = (EPServiceProviderSPI)epService; _container = _epService.Container; Runtime = epService.EPRuntime; _schedulingService = ((EPServiceProviderSPI)epService).SchedulingService; }
public void SetUp() { var configDB = new ConfigurationDBRef(); configDB.SetDatabaseDriver(SupportDatabaseService.DbDriverFactoryNative); //configDB.SetDriverManagerConnection(SupportDatabaseService.DRIVER, SupportDatabaseService.FULLURL, new Properties()); Configuration configuration = SupportConfigFactory.GetConfiguration(); configuration.AddDatabaseReference("MyDB", configDB); configuration.AddEventType <SupportBean>(); configuration.AddEventType <SupportBean_S0>(); configuration.AddEventType <SupportBean_S1>(); _epService = EPServiceProviderManager.GetDefaultProvider(configuration); _epService.Initialize(); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.StartTest(_epService, this.GetType(), this.GetType().FullName); } _spi = (EPServiceProviderSPI)_epService; }
private void RunAssertionVariantRStreamOMToStmt(EPServiceProvider epService) { var model = new EPStatementObjectModel(); model.InsertInto = InsertIntoClause.Create("Event_1_RSOM", new string[0], StreamSelector.RSTREAM_ONLY); model.SelectClause = SelectClause.Create().Add("IntPrimitive", "IntBoxed"); model.FromClause = FromClause.Create(FilterStream.Create(typeof(SupportBean).FullName)); model = (EPStatementObjectModel)SerializableObjectCopier.Copy(epService.Container, model); EPStatement stmt = epService.EPAdministrator.Create(model, "s1"); string epl = "insert rstream into Event_1_RSOM " + "select IntPrimitive, IntBoxed " + "from " + typeof(SupportBean).FullName; Assert.AreEqual(epl, model.ToEPL()); Assert.AreEqual(epl, stmt.Text); EPStatementObjectModel modelTwo = epService.EPAdministrator.CompileEPL(model.ToEPL()); model = (EPStatementObjectModel)SerializableObjectCopier.Copy(epService.Container, model); Assert.AreEqual(epl, modelTwo.ToEPL()); // assert statement-type reference EPServiceProviderSPI spi = (EPServiceProviderSPI)epService; Assert.IsTrue(spi.StatementEventTypeRef.IsInUse("Event_1_RSOM")); var stmtNames = spi.StatementEventTypeRef.GetStatementNamesForType(typeof(SupportBean).FullName); Assert.IsTrue(stmtNames.Contains("s1")); stmt.Dispose(); Assert.IsFalse(spi.StatementEventTypeRef.IsInUse("Event_1_RSOM")); stmtNames = spi.StatementEventTypeRef.GetStatementNamesForType(typeof(SupportBean).FullName); Assert.IsFalse(stmtNames.Contains("s1")); }