public void Run(RegressionEnvironment env) { var path = new RegressionPath(); env.CompileDeploy( "create table varaggMS (eventset window(*) @type(SupportBean), total sum(int))", path); env.CompileDeploy( "into table varaggMS select window(*) as eventset, " + "sum(IntPrimitive) as total from SupportBean#length(2)", path); env.CompileDeploy( "on SupportBean_S0 merge varaggMS " + "when matched then insert into ResultStream select eventset, total, eventset.takeLast(1) as c0", path); env.CompileDeploy("@Name('s0') select * from ResultStream", path).AddListener("s0"); var e1 = new SupportBean("E1", 15); env.SendEventBean(e1); AssertResultAggRead( env, new object[] {e1}, 15); env.Milestone(0); var e2 = new SupportBean("E2", 20); env.SendEventBean(e2); AssertResultAggRead( env, new object[] {e1, e2}, 35); env.Milestone(1); var e3 = new SupportBean("E3", 30); env.SendEventBean(e3); AssertResultAggRead( env, new object[] {e2, e3}, 50); env.UndeployAll(); }
private static IEnumerator <EventBean> MakeEnumerator(int[] values) { IList <EventBean> events = new List <EventBean>(); for (int i = 0; i < values.Length; i++) { var bean = new SupportBean(); bean.IntPrimitive = values[i]; EventBean theEvent = SupportEventBeanFactory.CreateObject(bean); events.Add(theEvent); } return(TransformEventUtil.Transform( events.GetEnumerator(), eventBean => SupportEventBeanFactory.CreateObject( new SupportBean_S0((int)eventBean.Get("IntPrimitive"))))); }
public void Run(RegressionEnvironment env) { var epl = "@Name('s0') select * from pattern[a=SupportBean() -> b=SupportBean(myCustomDecimalEquals(a.DecimalPrimitive, b.DecimalPrimitive))]"; env.CompileDeploy(epl).AddListener("s0"); var beanOne = new SupportBean("E1", 0); beanOne.DecimalPrimitive = 13m; env.SendEventBean(beanOne); var beanTwo = new SupportBean("E2", 0); beanTwo.DecimalPrimitive = 13m; env.SendEventBean(beanTwo); Assert.IsTrue(env.Listener("s0").IsInvoked); env.UndeployAll(); }
public void TestConfiguredViaPropsAndXML() { var configuration = SupportConfigFactory.GetConfiguration(); configuration.EngineDefaults.EventMetaConfig.DefaultEventRepresentation = EventRepresentation.OBJECTARRAY; configuration.AddEventType( "MyOAType", "bean,TheString,map".Split(','), new Object[] { typeof(SupportBean).FullName, typeof(String).FullName, typeof(Map).FullName }); var epService = EPServiceProviderManager.GetDefaultProvider(configuration); epService.Initialize(); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.StartTest(epService, GetType(), GetType().FullName); } var eventType = epService.EPAdministrator.Configuration.GetEventType("MyOAType"); Assert.AreEqual(typeof(Object[]), eventType.UnderlyingType); Assert.AreEqual(typeof(String), eventType.GetPropertyType("TheString")); Assert.AreEqual(typeof(Map), eventType.GetPropertyType("map")); Assert.AreEqual(typeof(SupportBean), eventType.GetPropertyType("bean")); var stmt = epService.EPAdministrator.CreateEPL("select bean, TheString, map('key'), bean.TheString from MyOAType"); var listener = new SupportUpdateListener(); stmt.Events += listener.Update; Assert.AreEqual(typeof(Object[]), stmt.EventType.UnderlyingType); var bean = new SupportBean("E1", 1); epService.EPRuntime.SendEvent(new Object[] { bean, "abc", Collections.SingletonDataMap("key", "value") }, "MyOAType"); EPAssertionUtil.AssertProps(listener.AssertOneGetNew(), "bean,TheString,map('key'),bean.TheString".Split(','), new Object[] { bean, "abc", "value", "E1" }); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.EndTest(); } }
private static void AssertReceived( SupportListener listenerStmtOne, SupportBean[] beans, int[] indexesAll, int[] indexesWhere, string[] mapKeys, object[] mapValues) { var received = listenerStmtOne.AssertOneGetNewAndReset(); EPAssertionUtil.AssertEqualsExactOrder( SupportBean.GetBeansPerIndex(beans, indexesAll), (object[]) received.Get("c0")); EPAssertionUtil.AssertEqualsExactOrder( SupportBean.GetBeansPerIndex(beans, indexesWhere), (ICollection<object>) received.Get("c1")); EPAssertionUtil.AssertPropsMap((IDictionary<object, object>) received.Get("c2"), mapKeys, mapValues); }
private void SendEventWithDouble(byte?byteBoxed, short?shortBoxed, int?intBoxed, long?longBoxed, float?floatBoxed, double?doubleBoxed) { var bean = new SupportBean(); bean.ByteBoxed = byteBoxed; bean.ShortBoxed = shortBoxed; bean.IntBoxed = intBoxed; bean.LongBoxed = longBoxed; bean.FloatBoxed = floatBoxed; bean.DoubleBoxed = doubleBoxed; _epService.EPRuntime.SendEvent(bean); }
public static IList<FilterTestMultiStmtExecution> Executions(bool withStats) { IList<FilterTestMultiStmtPermutable> cases = new List<FilterTestMultiStmtPermutable>(); // no filter AddCase( cases, MakeSingleStat("P0=(fh:1,fi:0),P1=(fh:0,fi:0)"), "", MakeItem(SupportBean.MakeBean("E1"), true)); // no filter return FilterTestMultiStmtRunner.ComputePermutations( typeof(ExprFilterPlanNoFilter), new PermutationSpec(true), cases, withStats); }
private static void SendAndAssert1( RegressionEnvironment env, int? intBoxed, float? floatBoxed, double doublePrimitive, bool? result) { var bean = new SupportBean(); bean.IntBoxed = intBoxed; bean.FloatBoxed = floatBoxed; bean.DoublePrimitive = doublePrimitive; env.SendEventBean(bean); var theEvent = env.Listener("s0").AssertOneGetNewAndReset(); Assert.AreEqual(result, theEvent.Get("result")); }
private static void SendAndAssert3( RegressionEnvironment env, int intPrimitive, int shortBoxed, long? longBoxed, bool? result) { var bean = new SupportBean(); bean.IntPrimitive = intPrimitive; bean.ShortBoxed = (short) shortBoxed; bean.LongBoxed = longBoxed; env.SendEventBean(bean); var theEvent = env.Listener("s0").AssertOneGetNewAndReset(); Assert.AreEqual(result, theEvent.Get("result")); }
public void Run(RegressionEnvironment env) { var stmtTextSet = "@Name('set') on SupportBean set p_1 = TheString, p_2 = BoolBoxed, p_3 = IntBoxed, p_4 = IntBoxed"; env.CompileDeploy(stmtTextSet).AddListener("set"); string[] fieldsVar = {"p_1", "p_2", "p_3", "p_4"}; EPAssertionUtil.AssertPropsPerRow( env.GetEnumerator("set"), fieldsVar, new[] {new object[] {null, true, 10L, 11.1d}}); var typeSet = env.Statement("set").EventType; Assert.AreEqual(typeof(string), typeSet.GetPropertyType("p_1")); Assert.AreEqual(typeof(bool?), typeSet.GetPropertyType("p_2")); Assert.AreEqual(typeof(long?), typeSet.GetPropertyType("p_3")); Assert.AreEqual(typeof(double?), typeSet.GetPropertyType("p_4")); Array.Sort(typeSet.PropertyNames); CollectionAssert.AreEquivalent(fieldsVar, typeSet.PropertyNames); var bean = new SupportBean(); bean.TheString = "text"; bean.BoolBoxed = false; bean.IntBoxed = 200; env.SendEventBean(bean); EPAssertionUtil.AssertProps( env.Listener("set").AssertOneGetNewAndReset(), fieldsVar, new object[] {"text", false, 200L, 200d}); EPAssertionUtil.AssertPropsPerRow( env.GetEnumerator("set"), fieldsVar, new[] {new object[] {"text", false, 200L, 200d}}); bean = new SupportBean(); // leave all fields null env.SendEventBean(bean); EPAssertionUtil.AssertProps( env.Listener("set").AssertOneGetNewAndReset(), fieldsVar, new object[] {null, null, null, null}); EPAssertionUtil.AssertPropsPerRow( env.GetEnumerator("set"), fieldsVar, new[] {new object[] {null, null, null, null}}); env.UndeployAll(); }
private void RunAssertionAddNameClass(EPServiceProvider epService) { TryInvalid(epService, "AddedName"); // First statement with new name epService.EPAdministrator.Configuration.AddEventType("AddedName", typeof(SupportBean)); Assert.IsTrue(epService.EPAdministrator.Configuration.IsEventTypeExists("AddedName")); EPStatement stmt = epService.EPAdministrator.CreateEPL("select * from AddedName"); var testListener = new SupportUpdateListener(); stmt.Events += testListener.Update; var eventOne = new SupportBean("a", 1); epService.EPRuntime.SendEvent(eventOne); Assert.AreSame(eventOne, testListener.AssertOneGetNewAndReset().Underlying); TryInvalid(epService, "AddedNameSecond"); // Second statement using a new alias to the same type, should both receive epService.EPAdministrator.Configuration.AddEventType("AddedNameSecond", typeof(SupportBean)); var testListenerTwo = new SupportUpdateListener(); stmt = epService.EPAdministrator.CreateEPL("select * from AddedNameSecond"); stmt.Events += testListenerTwo.Update; var eventTwo = new SupportBean("b", 2); epService.EPRuntime.SendEvent(eventTwo); Assert.AreSame(eventTwo, testListener.AssertOneGetNewAndReset().Underlying); Assert.AreSame(eventTwo, testListenerTwo.AssertOneGetNewAndReset().Underlying); // Add the same name and type again epService.EPAdministrator.Configuration.AddEventType("AddedNameSecond", typeof(SupportBean)); // Add the same name and a different type try { epService.EPAdministrator.Configuration.AddEventType("AddedNameSecond", typeof(SupportBean_A)); Assert.Fail(); } catch (ConfigurationException) { // expected } epService.EPAdministrator.DestroyAllStatements(); epService.EPAdministrator.Configuration.RemoveEventType("AddedNameSecond", true); }
public void TestPropertiesSimplePattern() { SetupSimplePattern("a, a as myEvent, a.IntPrimitive as MyInt, a.TheString"); SupportBean theEvent = new SupportBean(); theEvent.IntPrimitive = 1; theEvent.TheString = "test"; _epService.EPRuntime.SendEvent(theEvent); EventBean eventBean = _updateListener.AssertOneGetNewAndReset(); Assert.AreSame(theEvent, eventBean.Get("a")); Assert.AreSame(theEvent, eventBean.Get("myEvent")); Assert.AreEqual(1, eventBean.Get("MyInt")); Assert.AreEqual("test", eventBean.Get("a.TheString")); }
public void TestMultirowUnderlyingCorrelated() { String stmtText = "select p00, " + "(select Window(sb.*) from SupportBean.win:keepall() sb where TheString = s0.P00) as val " + "from S0 as s0"; EPStatement stmt = _epService.EPAdministrator.CreateEPL(stmtText); stmt.Events += _listener.Update; Object[][] rows = new Object[][] { new Object[] { "p00", typeof(string) }, new Object[] { "val", typeof(SupportBean[]) } }; for (int i = 0; i < rows.Length; i++) { String message = "Failed assertion for " + rows[i][0]; EventPropertyDescriptor prop = stmt.EventType.PropertyDescriptors[i]; Assert.AreEqual(rows[i][0], prop.PropertyName, message); Assert.AreEqual(rows[i][1], prop.PropertyType, message); } _epService.EPRuntime.SendEvent(new SupportBean_S0(1, "T1")); Assert.IsNull(_listener.AssertOneGetNewAndReset().Get("val")); SupportBean sb1 = new SupportBean("T1", 10); _epService.EPRuntime.SendEvent(sb1); _epService.EPRuntime.SendEvent(new SupportBean_S0(2, "T1")); EventBean received = _listener.AssertOneGetNewAndReset(); Assert.AreEqual(typeof(SupportBean[]), received.Get("val").GetType()); EPAssertionUtil.AssertEqualsAnyOrder((Object[])received.Get("val"), new Object[] { sb1 }); SupportBean sb2 = new SupportBean("T2", 20); _epService.EPRuntime.SendEvent(sb2); SupportBean sb3 = new SupportBean("T2", 30); _epService.EPRuntime.SendEvent(sb3); _epService.EPRuntime.SendEvent(new SupportBean_S0(3, "T2")); received = _listener.AssertOneGetNewAndReset(); EPAssertionUtil.AssertEqualsAnyOrder((Object[])received.Get("val"), new Object[] { sb2, sb3 }); }
private void RunAssertionOnSelectEqualsAndRangePerformance(EPServiceProvider epService) { // create window one epService.EPAdministrator.CreateEPL("create window MyWindow#keepall as SupportBean"); epService.EPAdministrator.CreateEPL("insert into MyWindow select * from SupportBean"); // insert X rows int maxRows = 10000; //for performance testing change to int maxRows = 100000; for (int i = 0; i < maxRows; i++) { var bean = new SupportBean((i < 5000) ? "A" : "B", i); bean.LongPrimitive = i; bean.LongBoxed = (i + 1); epService.EPRuntime.SendEvent(bean); } epService.EPRuntime.SendEvent(new SupportBean("B", 100)); string eplIdx1One = "on SupportBeanRange sbr select sum(IntPrimitive) as sumi from MyWindow where IntPrimitive = sbr.rangeStart"; RunOnDemandAssertion(epService, eplIdx1One, 1, new SupportBeanRange("R", 5501, 0), 5501); string eplIdx1Two = "on SupportBeanRange sbr select sum(IntPrimitive) as sumi from MyWindow where IntPrimitive between sbr.rangeStart and sbr.rangeEnd"; RunOnDemandAssertion(epService, eplIdx1Two, 1, new SupportBeanRange("R", 5501, 5503), 5501 + 5502 + 5503); string eplIdx1Three = "on SupportBeanRange sbr select sum(IntPrimitive) as sumi from MyWindow where TheString = key and IntPrimitive between sbr.rangeStart and sbr.rangeEnd"; RunOnDemandAssertion(epService, eplIdx1Three, 1, new SupportBeanRange("R", "A", 4998, 5503), 4998 + 4999); string eplIdx1Four = "on SupportBeanRange sbr select sum(IntPrimitive) as sumi from MyWindow " + "where TheString = key and LongPrimitive = rangeStart and IntPrimitive between rangeStart and rangeEnd " + "and LongBoxed between rangeStart and rangeEnd"; RunOnDemandAssertion(epService, eplIdx1Four, 1, new SupportBeanRange("R", "A", 4998, 5503), 4998); string eplIdx1Five = "on SupportBeanRange sbr select sum(IntPrimitive) as sumi from MyWindow " + "where IntPrimitive between rangeStart and rangeEnd " + "and LongBoxed between rangeStart and rangeEnd"; RunOnDemandAssertion(epService, eplIdx1Five, 1, new SupportBeanRange("R", "A", 4998, 5001), 4998 + 4999 + 5000); epService.EPAdministrator.DestroyAllStatements(); epService.EPAdministrator.Configuration.RemoveEventType("MyWindow", true); }
public void TestOnSelectEqualsAndRangePerformance() { _epService.EPAdministrator.Configuration.AddEventType <SupportBean>(); _epService.EPAdministrator.Configuration.AddEventType("SupportBeanRange", typeof(SupportBeanRange)); // create window one _epService.EPAdministrator.CreateEPL("create window MyWindow.win:keepall() as SupportBean"); _epService.EPAdministrator.CreateEPL("insert into MyWindow select * from SupportBean"); // insert X rows int maxRows = 10000; //for performance testing change to int maxRows = 100000; for (int i = 0; i < maxRows; i++) { SupportBean bean = new SupportBean((i < 5000) ? "A" : "B", i); bean.LongPrimitive = i; bean.LongBoxed = ((long)i + 1); _epService.EPRuntime.SendEvent(bean); } _epService.EPRuntime.SendEvent(new SupportBean("B", 100)); String eplIdx1One = "on SupportBeanRange sbr select sum(IntPrimitive) as sumi from MyWindow where IntPrimitive = sbr.rangeStart"; RunOnDemandAssertion(eplIdx1One, 1, new SupportBeanRange("R", 5501, 0), 5501); String eplIdx1Two = "on SupportBeanRange sbr select sum(IntPrimitive) as sumi from MyWindow where IntPrimitive between sbr.rangeStart and sbr.rangeEnd"; RunOnDemandAssertion(eplIdx1Two, 1, new SupportBeanRange("R", 5501, 5503), 5501 + 5502 + 5503); String eplIdx1Three = "on SupportBeanRange sbr select sum(IntPrimitive) as sumi from MyWindow where TheString = key and IntPrimitive between sbr.rangeStart and sbr.rangeEnd"; RunOnDemandAssertion(eplIdx1Three, 1, new SupportBeanRange("R", "A", 4998, 5503), 4998 + 4999); String eplIdx1Four = "on SupportBeanRange sbr select sum(IntPrimitive) as sumi from MyWindow " + "where TheString = key and LongPrimitive = rangeStart and IntPrimitive between rangeStart and rangeEnd " + "and LongBoxed between rangeStart and rangeEnd"; RunOnDemandAssertion(eplIdx1Four, 1, new SupportBeanRange("R", "A", 4998, 5503), 4998); String eplIdx1Five = "on SupportBeanRange sbr select sum(IntPrimitive) as sumi from MyWindow " + "where IntPrimitive between rangeStart and rangeEnd " + "and LongBoxed between rangeStart and rangeEnd"; RunOnDemandAssertion(eplIdx1Five, 1, new SupportBeanRange("R", "A", 4998, 5001), 4998 + 4999 + 5000); }
private void RunAssertionUnmatchedSendEvent(EPServiceProvider epService) { var listener = new MyUnmatchedListener(); epService.EPRuntime.UnmatchedEvent += listener.Update; // no statement, should be unmatched SupportBean theEvent = SendEvent(epService, "E1"); Assert.AreEqual(1, listener.Received.Count); Assert.AreSame(theEvent, listener.Received[0].Underlying); listener.Reset(); // no unmatched listener epService.EPRuntime.RemoveAllUnmatchedEventHandlers(); SendEvent(epService, "E1"); Assert.AreEqual(0, listener.Received.Count); // create statement and re-register unmatched listener EPStatement stmt = epService.EPAdministrator.CreateEPL("select * from " + typeof(SupportBean).FullName); epService.EPRuntime.UnmatchedEvent += listener.Update; SendEvent(epService, "E1"); Assert.AreEqual(0, listener.Received.Count); // stop statement stmt.Stop(); theEvent = SendEvent(epService, "E1"); Assert.AreEqual(1, listener.Received.Count); Assert.AreSame(theEvent, listener.Received[0].Underlying); listener.Reset(); // start statement stmt.Start(); SendEvent(epService, "E1"); Assert.AreEqual(0, listener.Received.Count); // destroy statement stmt.Dispose(); theEvent = SendEvent(epService, "E1"); Assert.AreEqual(1, listener.Received.Count); Assert.AreSame(theEvent, listener.Received[0].Underlying); epService.EPRuntime.RemoveAllUnmatchedEventHandlers(); }
public bool Call() { try { for (int loop = 0; loop < _numRepeats; loop++) { Log.Info(".call Thread " + Thread.CurrentThread.ManagedThreadId + " sending event " + loop); String id = Convert.ToString(_threadNum * 100000000 + loop); SupportBean bean = new SupportBean(id, 0); _engine.EPRuntime.SendEvent(bean); for (int i = 0; i < _stmt.Length; i++) { Log.Info(".call Thread " + Thread.CurrentThread.ManagedThreadId + " starting enumerator " + loop); bool found = false; using (var en = _stmt[i].GetSafeEnumerator()) { while (en.MoveNext()) { EventBean theEvent = en.Current; if (theEvent.Get("TheString").Equals(id)) { found = true; } } } Assert.IsTrue(found); Log.Info(".call Thread " + Thread.CurrentThread.ManagedThreadId + " end enumerator " + loop); } } } catch (AssertionException ex) { Log.Fatal("Assertion error in thread " + Thread.CurrentThread.ManagedThreadId, ex); return(false); } catch (Exception e) { Log.Fatal("Error in thread " + Thread.CurrentThread.ManagedThreadId, e); return(false); } return(true); }
private void RunAssertionOuterJoinPlusWhere(EPServiceProvider epService) { var stmtText = "select TheString, mycol3, mycol1 from " + " sql:MyDB ['select mycol1, mycol3 from mytesttable_large'] as s1 right outer join " + typeof(SupportBean).FullName + " as s0 on TheString = mycol1 where s1.mycol3 = s0.IntPrimitive"; var statement = epService.EPAdministrator.CreateEPL(stmtText); var listener = new SupportUpdateListener(); statement.AddListener(listener); // Send events which all perform the join var startTime = PerformanceObserver.MilliTime; for (var i = 0; i < 200; i++) { var beanX = new SupportBean(); beanX.TheString = ("50"); beanX.IntPrimitive = (50); epService.EPRuntime.SendEvent(beanX); EPAssertionUtil.AssertProps( listener.AssertOneGetNewAndReset(), new string[] { "TheString", "mycol3", "mycol1" }, new object[] { "50", 50, "50" }); } var endTime = PerformanceObserver.MilliTime; // no matching on-clause var bean = new SupportBean(); Assert.IsFalse(listener.IsInvoked); // matching on-clause not matching where bean = new SupportBean(); bean.TheString = ("50"); bean.IntPrimitive = (49); epService.EPRuntime.SendEvent(bean); Assert.IsFalse(listener.IsInvoked); Log.Info("delta=" + (endTime - startTime)); Assert.IsTrue(endTime - startTime < 500); statement.Dispose(); }
public void TestEPLtoOMtoStmt() { var stmtText = "select * from " + typeof(SupportBean).FullName; var model = _epService.EPAdministrator.CompileEPL(stmtText); SerializableObjectCopier.Copy(model); EPStatement stmt = _epService.EPAdministrator.Create(model, "s1"); stmt.Events += _listener.Update; Object theEvent = new SupportBean(); _epService.EPRuntime.SendEvent(theEvent); Assert.AreEqual(theEvent, _listener.AssertOneGetNewAndReset().Underlying); Assert.AreEqual(stmtText, stmt.Text); Assert.AreEqual("s1", stmt.Name); }
public void TestBindWildcardPlusProperties() { var subscriber = new MySubscriberRowByRowSpecific(); EPStatement stmt = _epService.EPAdministrator.CreateEPL( "select *, IntPrimitive + 2, 'x'||TheString||'x' from " + typeof(SupportBean).FullName); stmt.Subscriber = subscriber; var s0 = new SupportBean("E1", 100); _epService.EPRuntime.SendEvent(s0); EPAssertionUtil.AssertEqualsExactOrder(new Object[] { s0, 102, "xE1x" } , subscriber.GetAndResetIndicate()[0]); }
public void TestWildcardOrPattern() { SetupOrPattern("*"); Object theEvent = new SupportBean(); _epService.EPRuntime.SendEvent(theEvent); EventBean eventBean = _updateListener.AssertOneGetNewAndReset(); Assert.AreSame(theEvent, eventBean.Get("a")); Assert.IsNull(eventBean.Get("b")); theEvent = SupportBeanComplexProps.MakeDefaultBean(); _epService.EPRuntime.SendEvent(theEvent); eventBean = _updateListener.AssertOneGetNewAndReset(); Assert.AreSame(theEvent, eventBean.Get("b")); Assert.IsNull(eventBean.Get("a")); }
private void RunAssertionLookupSPI(RegressionEnvironment env) { var path = new RegressionPath(); env.CompileDeploy("create window MyVDW.test:vdwnoparam() as SupportBean", path); var window = (SupportVirtualDW) GetFromContext(env, "/virtualdw/MyVDW"); var supportBean = new SupportBean("E1", 100); window.Data = Collections.SingletonSet<object>(supportBean); env.CompileDeploy( "@Name('s0') select (select sum(IntPrimitive) from MyVDW vdw where vdw.TheString = S0.P00) from SupportBean_S0 S0", path); env.AddListener("s0"); var spiContext = (VirtualDataWindowLookupContextSPI) window.LastRequestedLookup; Assert.IsNotNull(spiContext); env.UndeployAll(); }
public void Run(RegressionEnvironment env) { var fields = "c0,c1,c2,c3".SplitCsv(); var builder = new SupportEvalBuilder("SupportBean") .WithExpression(fields[0], "BigInteger = any (null, 1)") .WithExpression(fields[1], "BigInteger = any (2, 3)") .WithExpression(fields[2], "DecimalPrimitive = any (null, 1)") .WithExpression(fields[3], "DecimalPrimitive = any (2, 3)"); var bean = new SupportBean(); bean.BigInteger = BigInteger.One; bean.DecimalPrimitive = 1.0m; builder.WithAssertion(bean).Expect(fields, true, false, true, false); builder.Run(env); env.UndeployAll(); }
public void TestLateConsumerNoIterate() { // client-side _epService.EPAdministrator.CreateEPL("create window MyVDW.test:vdw() as SupportBean"); var window = (SupportVirtualDW)GetFromContext("/virtualdw/MyVDW"); var supportBean = new SupportBean("E1", 100); window.Data = Collections.SingletonSet <object>(supportBean); var stmt = _epService.EPAdministrator.CreateEPL("select (select sum(IntPrimitive) from MyVDW vdw where vdw.TheString = s0.p00) from SupportBean_S0 s0"); stmt.AddListener(_listener); var spiContext = (VirtualDataWindowLookupContextSPI)window.LastRequestedIndex; // CM side _epService.EPAdministrator.CreateEPL("create window MyWin.std:unique(TheString) as SupportBean"); _epService.EPAdministrator.CreateEPL("insert into MyWin select * from SupportBean"); }
private void TryCoalesceBeans(String viewExpr) { _epService.Initialize(); EPStatement selectTestView = _epService.EPAdministrator.CreateEPL(viewExpr); selectTestView.Events += _testListener.Update; SupportBean theEvent = SendEvent("s0"); EventBean eventReceived = _testListener.AssertOneGetNewAndReset(); Assert.AreEqual("s0", eventReceived.Get("MyString")); Assert.AreSame(theEvent, eventReceived.Get("myBean")); theEvent = SendEvent("s1"); eventReceived = _testListener.AssertOneGetNewAndReset(); Assert.AreEqual("s1", eventReceived.Get("MyString")); Assert.AreSame(theEvent, eventReceived.Get("myBean")); }
private void SendEventSetAssert( RegressionEnvironment env, string[] fieldSetOne) { SendBean(env, "E1", 10); SendBean(env, "E2", 10); SupportBean e3 = SendBean(env, "E3", 30); EventBean row = env.GetEnumerator("table").Advance(); EPAssertionUtil.AssertProps( row, fieldSetOne, new object[] {8.88888888888889d, 3L, 2L, 30, 10.0, 11.547005383792515d, "E1", 3L, e3}); Assert.AreEqual(-3, row.Get("myPluginAggSingle")); Assert.AreEqual(3, (row.Get("myPluginAggAccess").AsObjectDictionary()).Count); AssertCountMinSketch(env, "E1", 1); }
public bool Call() { try { for (int loop = 0; loop < _numRepeats; loop++) { var eventOne = new SupportBean(); eventOne.TheString = "E1_" + _threadKey; _engine.EPRuntime.SendEvent(eventOne); var eventTwo = new SupportMarketDataBean("E2_" + _threadKey, 0d, null, null); _engine.EPRuntime.SendEvent(eventTwo); } } catch (Exception ex) { Log.Error("Error in thread " + Thread.CurrentThread.ManagedThreadId, ex); return(false); } return(true); }
public void TestBindWildcardIRStream() { var subscriber = new MySubscriberMultirowUnderlying(); EPStatement stmt = _epService.EPAdministrator.CreateEPL( "select irstream * from SupportBean.win:length_batch(2)"); stmt.Subscriber = subscriber; var s0 = new SupportBean("E1", 100); var s1 = new SupportBean("E2", 200); _epService.EPRuntime.SendEvent(s0); _epService.EPRuntime.SendEvent(s1); Assert.AreEqual(1, subscriber.IndicateArr.Count); UniformPair <SupportBean[]> beans = subscriber.GetAndResetIndicateArr()[0]; Assert.AreEqual(2, beans.First.Length); Assert.AreEqual(null, beans.Second); EPAssertionUtil.AssertEqualsExactOrder(new Object[] { s0, s1 } , beans.First); var s2 = new SupportBean("E3", 300); var s3 = new SupportBean("E4", 400); _epService.EPRuntime.SendEvent(s2); _epService.EPRuntime.SendEvent(s3); Assert.AreEqual(1, subscriber.IndicateArr.Count); beans = subscriber.GetAndResetIndicateArr()[0]; Assert.AreEqual(2, beans.First.Length); Assert.AreEqual(2, beans.Second.Length); EPAssertionUtil.AssertEqualsExactOrder(new Object[] { s2, s3 } , beans.First); EPAssertionUtil.AssertEqualsExactOrder(new Object[] { s0, s1 } , beans.Second); }
public void Run(RegressionEnvironment env) { var stmtText = "@Name('s0') select P00, " + "(select window(sb.*) from SupportBean#keepall sb where TheString = S0.P00) as val " + "from SupportBean_S0 as S0"; env.CompileDeployAddListenerMileZero(stmtText, "s0"); object[][] rows = { new object[] {"P00", typeof(string)}, new object[] {"val", typeof(SupportBean[])} }; for (var i = 0; i < rows.Length; i++) { var message = "Failed assertion for " + rows[i][0]; var prop = env.Statement("s0").EventType.PropertyDescriptors[i]; Assert.AreEqual(rows[i][0], prop.PropertyName, message); Assert.AreEqual(rows[i][1], prop.PropertyType, message); } env.SendEventBean(new SupportBean_S0(1, "T1")); Assert.IsNull(env.Listener("s0").AssertOneGetNewAndReset().Get("val")); var sb1 = new SupportBean("T1", 10); env.SendEventBean(sb1); env.SendEventBean(new SupportBean_S0(2, "T1")); var received = env.Listener("s0").AssertOneGetNewAndReset(); Assert.AreEqual(typeof(SupportBean[]), received.Get("val").GetType()); EPAssertionUtil.AssertEqualsAnyOrder( (object[]) received.Get("val"), new object[] {sb1}); var sb2 = new SupportBean("T2", 20); env.SendEventBean(sb2); var sb3 = new SupportBean("T2", 30); env.SendEventBean(sb3); env.SendEventBean(new SupportBean_S0(3, "T2")); received = env.Listener("s0").AssertOneGetNewAndReset(); EPAssertionUtil.AssertEqualsAnyOrder( (object[]) received.Get("val"), new object[] {sb2, sb3}); env.UndeployAll(); }
public void TestInsertConsume() { _epService.EPAdministrator.CreateEPL("create window MyVDW.test:vdw() as SupportBean"); var window = (SupportVirtualDW)GetFromContext("/virtualdw/MyVDW"); var supportBean = new SupportBean("S1", 100); window.Data = supportBean.AsSingleton(); _epService.EPAdministrator.CreateEPL("insert into MyVDW select * from SupportBean"); // test aggregated consumer - wherein the virtual data window does not return an iterator that prefills the aggregation state var fields = "val0".Split(','); var stmtAggregate = _epService.EPAdministrator.CreateEPL("@Name('ABC') select sum(IntPrimitive) as val0 from MyVDW"); stmtAggregate.Events += _listener.Update; EPAssertionUtil.AssertProps(stmtAggregate.First(), fields, new Object[] { 100 }); _epService.EPRuntime.SendEvent(new SupportBean("E1", 10)); EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { 110 }); _epService.EPRuntime.SendEvent(new SupportBean("E1", 20)); EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { 130 }); // assert events received for add-consumer and remove-consumer stmtAggregate.Dispose(); var addConsumerEvent = (VirtualDataWindowEventConsumerAdd)window.Events[0]; var removeConsumerEvent = (VirtualDataWindowEventConsumerRemove)window.Events[1]; foreach (var @base in new VirtualDataWindowEventConsumerBase[] { addConsumerEvent, removeConsumerEvent }) { Assert.AreEqual(-1, @base.AgentInstanceId); Assert.AreEqual("MyVDW", @base.NamedWindowName); Assert.AreEqual("ABC", @base.StatementName); } Assert.AreSame(removeConsumerEvent.ConsumerObject, addConsumerEvent.ConsumerObject); window.Events.Clear(); // test filter criteria passed to event var stmtAggregateWFilter = _epService.EPAdministrator.CreateEPL("@Name('ABC') select sum(IntPrimitive) as val0 from MyVDW(TheString = 'A')"); var eventWithFilter = (VirtualDataWindowEventConsumerAdd)window.Events[0]; Assert.AreEqual(1, eventWithFilter.FilterExpressions.Length); Assert.IsNotNull(eventWithFilter.ExprEvaluatorContext); stmtAggregateWFilter.Dispose(); }