Beispiel #1
0
            public void Run(RegressionEnvironment env)
            {
                var epl =
                    "@Name('create') create window MyWindow#keepall as select TheString as a, LongPrimitive as b from SupportBean;\n" +
                    "on SupportMarketDataBean delete from MyWindow where b = Price;\n" +
                    "on SupportBean_A delete from MyWindow where Id = a;\n" +
                    "insert into MyWindow select TheString as a, LongPrimitive as b from SupportBean;\n";
                env.CompileDeploy(epl);

                // load window
                for (var i = 0; i < 20000; i++) {
                    SendSupportBean(env, "S" + i, (long) i);
                }

                // delete all rows
                env.AddListener("create");
                var startTime = PerformanceObserver.MilliTime;
                for (var i = 0; i < 10000; i++) {
                    SendMarketBean(env, "S" + i, i);
                    SendSupportBean_A(env, "S" + (i + 10000));
                }

                var endTime = PerformanceObserver.MilliTime;
                var delta = endTime - startTime;
                Assert.That(delta, Is.LessThan(1500), "Delta=" + delta);

                // assert they are all deleted
                Assert.AreEqual(0, EPAssertionUtil.EnumeratorCount(env.GetEnumerator("create")));
                Assert.AreEqual(20000, env.Listener("create").OldDataList.Count);

                env.UndeployAll();
            }
Beispiel #2
0
        private void RunAssertionDeletePerformanceTwoDeleters(EPServiceProvider epService)
        {
            if (SupportConfigFactory.SkipTest(typeof(ExecNamedWindowPerformance)))
            {
                return;
            }

            // create window
            string      stmtTextCreate = "create window MyWindow#keepall as select TheString as a, LongPrimitive as b from " + typeof(SupportBean).FullName;
            EPStatement stmtCreate     = epService.EPAdministrator.CreateEPL(stmtTextCreate);

            // create delete stmt one
            string stmtTextDeleteOne = "on " + typeof(SupportMarketDataBean).FullName + " delete from MyWindow where b = price";

            epService.EPAdministrator.CreateEPL(stmtTextDeleteOne);

            // create delete stmt two
            string stmtTextDeleteTwo = "on " + typeof(SupportBean_A).FullName + " delete from MyWindow where id = a";

            epService.EPAdministrator.CreateEPL(stmtTextDeleteTwo);

            // create insert into
            string stmtTextInsertOne = "insert into MyWindow select TheString as a, LongPrimitive as b from " + typeof(SupportBean).FullName;

            epService.EPAdministrator.CreateEPL(stmtTextInsertOne);

            // load window
            for (int i = 0; i < 20000; i++)
            {
                SendSupportBean(epService, "S" + i, (long)i);
            }

            // delete all rows
            var listener = new SupportUpdateListener();

            stmtCreate.Events += listener.Update;
            long startTime = DateTimeHelper.CurrentTimeMillis;

            for (int i = 0; i < 10000; i++)
            {
                SendMarketBean(epService, "S" + i, i);
                SendSupportBean_A(epService, "S" + (i + 10000));
            }
            long endTime = DateTimeHelper.CurrentTimeMillis;
            long delta   = endTime - startTime;

            Assert.IsTrue(delta < 1500, "Delta=" + delta);

            // assert they are all deleted
            Assert.AreEqual(0, EPAssertionUtil.EnumeratorCount(stmtCreate.GetEnumerator()));
            Assert.AreEqual(20000, listener.OldDataList.Count);

            epService.EPAdministrator.DestroyAllStatements();
            epService.EPAdministrator.Configuration.RemoveEventType("MyWindow", true);
        }
        public void TestDeletePerformanceTwoDeleters()
        {
            // create window
            String      stmtTextCreate = "create window MyWindow.win:keepall() as select TheString as a, LongPrimitive as b from " + typeof(SupportBean).FullName;
            EPStatement stmtCreate     = _epService.EPAdministrator.CreateEPL(stmtTextCreate);

            // create delete stmt one
            String stmtTextDeleteOne = "on " + typeof(SupportMarketDataBean).FullName + " delete from MyWindow where b = Price";

            _epService.EPAdministrator.CreateEPL(stmtTextDeleteOne);

            // create delete stmt two
            String stmtTextDeleteTwo = "on " + typeof(SupportBean_A).FullName + " delete from MyWindow where id = a";

            _epService.EPAdministrator.CreateEPL(stmtTextDeleteTwo);

            // create insert into
            String stmtTextInsertOne = "insert into MyWindow select TheString as a, LongPrimitive as b from " + typeof(SupportBean).FullName;

            _epService.EPAdministrator.CreateEPL(stmtTextInsertOne);

            // load window
            for (int i = 0; i < 20000; i++)
            {
                SendSupportBean("S" + i, (long)i);
            }

            // delete all rows
            stmtCreate.Events += _listener.Update;
            long delta = PerformanceObserver.TimeMillis(
                delegate
            {
                for (int i = 0; i < 10000; i++)
                {
                    SendMarketBean("S" + i, i);
                    SendSupportBean_A("S" + (i + 10000));
                }
            });

            Assert.That(delta, Is.LessThan(1500));

            // assert they are all deleted
            Assert.AreEqual(0, EPAssertionUtil.EnumeratorCount(stmtCreate.GetEnumerator()));
            Assert.AreEqual(20000, _listener.OldDataList.Count);
        }
Beispiel #4
0
        private void RunAssertionDeletePerformance(EPServiceProvider epService)
        {
            // create window
            string      stmtTextCreate = "create window MyWindow#keepall as select TheString as a, IntPrimitive as b from " + typeof(SupportBean).FullName;
            EPStatement stmtCreate     = epService.EPAdministrator.CreateEPL(stmtTextCreate);

            // create delete stmt
            string stmtTextDelete = "on " + typeof(SupportBean_A).FullName + " delete from MyWindow where id = a";

            epService.EPAdministrator.CreateEPL(stmtTextDelete);

            // create insert into
            string stmtTextInsertOne = "insert into MyWindow select TheString as a, IntPrimitive as b from " + typeof(SupportBean).FullName;

            epService.EPAdministrator.CreateEPL(stmtTextInsertOne);

            // load window
            for (int i = 0; i < 50000; i++)
            {
                SendSupportBean(epService, "S" + i, i);
            }

            // delete rows
            var listener = new SupportUpdateListener();

            stmtCreate.Events += listener.Update;

            var delta = PerformanceObserver.TimeMillis(
                () => {
                for (int i = 0; i < 10000; i++)
                {
                    SendSupportBean_A(epService, "S" + i);
                }
            });

            Assert.IsTrue(delta < 100, "Delta=" + delta);

            // assert they are deleted
            Assert.AreEqual(50000 - 10000, EPAssertionUtil.EnumeratorCount(stmtCreate.GetEnumerator()));
            Assert.AreEqual(10000, listener.OldDataList.Count);

            epService.EPAdministrator.DestroyAllStatements();
            epService.EPAdministrator.Configuration.RemoveEventType("MyWindow", true);
        }
Beispiel #5
0
        private void RunAssertionDeletePerformanceIndexReuse(EPServiceProvider epService)
        {
            // create window
            string      stmtTextCreate = "create window MyWindow#keepall as select TheString as a, LongPrimitive as b from " + typeof(SupportBean).FullName;
            EPStatement stmtCreate     = epService.EPAdministrator.CreateEPL(stmtTextCreate);

            // create delete stmt
            var statements = new EPStatement[50];

            for (int i = 0; i < statements.Length; i++)
            {
                string stmtTextDelete = "on " + typeof(SupportMarketDataBean).FullName + " delete from MyWindow where b = price";
                statements[i] = epService.EPAdministrator.CreateEPL(stmtTextDelete);
            }

            // create insert into
            string stmtTextInsertOne = "insert into MyWindow select TheString as a, LongPrimitive as b from " + typeof(SupportBean).FullName;

            epService.EPAdministrator.CreateEPL(stmtTextInsertOne);

            // load window
            long startTime = DateTimeHelper.CurrentTimeMillis;

            for (int i = 0; i < 10000; i++)
            {
                SendSupportBean(epService, "S" + i, (long)i);
            }
            long endTime = DateTimeHelper.CurrentTimeMillis;
            long delta   = endTime - startTime;

            Assert.IsTrue(delta < 1000, "Delta=" + delta);
            Assert.AreEqual(10000, EPAssertionUtil.EnumeratorCount(stmtCreate.GetEnumerator()));

            // destroy all
            foreach (EPStatement statement in statements)
            {
                statement.Dispose();
            }

            epService.EPAdministrator.DestroyAllStatements();
            epService.EPAdministrator.Configuration.RemoveEventType("MyWindow", true);
        }
Beispiel #6
0
            public void Run(RegressionEnvironment env)
            {
                var path = new RegressionPath();

                // create window
                var stmtTextCreate =
                    "@Name('create') create window MyWindow#keepall as select TheString as a, LongPrimitive as b from SupportBean";
                env.CompileDeploy(stmtTextCreate, path);

                // create delete stmt
                var statements = new string[50];
                for (var i = 0; i < statements.Length; i++) {
                    var name = "s" + i;
                    var stmtTextDelete =
                        "@Name('" + name + "') on SupportMarketDataBean delete from MyWindow where b = Price";
                    env.CompileDeploy(stmtTextDelete, path);
                    statements[i] = name;
                }

                // create insert into
                var stmtTextInsertOne =
                    "insert into MyWindow select TheString as a, LongPrimitive as b from SupportBean";
                env.CompileDeploy(stmtTextInsertOne, path);

                // load window
                var startTime = PerformanceObserver.MilliTime;
                for (var i = 0; i < 10000; i++) {
                    SendSupportBean(env, "S" + i, (long) i);
                }

                var endTime = PerformanceObserver.MilliTime;
                var delta = endTime - startTime;
                Assert.That(delta, Is.LessThan(1000), "Delta=" + delta);
                Assert.AreEqual(10000, EPAssertionUtil.EnumeratorCount(env.GetEnumerator("create")));

                // destroy all
                foreach (var statement in statements) {
                    env.UndeployModuleContaining(statement);
                }

                env.UndeployAll();
            }
        public void TestDeletePerformanceCoercion()
        {
            // create window
            String      stmtTextCreate = "create window MyWindow.win:keepall() as select TheString as a, LongPrimitive as b from " + typeof(SupportBean).FullName;
            EPStatement stmtCreate     = _epService.EPAdministrator.CreateEPL(stmtTextCreate);

            // create delete stmt
            String stmtTextDelete = "on " + typeof(SupportMarketDataBean).FullName + " delete from MyWindow where b = Price";

            _epService.EPAdministrator.CreateEPL(stmtTextDelete);

            // create insert into
            String stmtTextInsertOne = "insert into MyWindow select TheString as a, LongPrimitive as b from " + typeof(SupportBean).FullName;

            _epService.EPAdministrator.CreateEPL(stmtTextInsertOne);

            // load window
            for (int i = 0; i < 50000; i++)
            {
                SendSupportBean("S" + i, (long)i);
            }

            // delete rows
            stmtCreate.Events += _listener.Update;
            long startTime = Environment.TickCount;

            for (int i = 0; i < 10000; i++)
            {
                SendMarketBean("S" + i, i);
            }
            long endTime = Environment.TickCount;
            long delta   = endTime - startTime;

            Assert.IsTrue(delta < 500, "Delta=" + delta);

            // assert they are deleted
            Assert.AreEqual(50000 - 10000, EPAssertionUtil.EnumeratorCount(stmtCreate.GetEnumerator()));
            Assert.AreEqual(10000, _listener.OldDataList.Count);
        }
        public void TestDeletePerformanceIndexReuse()
        {
            // create window
            String      stmtTextCreate = "create window MyWindow.win:keepall() as select TheString as a, LongPrimitive as b from " + typeof(SupportBean).FullName;
            EPStatement stmtCreate     = _epService.EPAdministrator.CreateEPL(stmtTextCreate);

            // create delete stmt
            EPStatement[] statements = new EPStatement[50];
            for (int i = 0; i < statements.Length; i++)
            {
                String stmtTextDelete = "on " + typeof(SupportMarketDataBean).FullName + " delete from MyWindow where b = Price";
                statements[i] = _epService.EPAdministrator.CreateEPL(stmtTextDelete);
            }

            // create insert into
            String stmtTextInsertOne = "insert into MyWindow select TheString as a, LongPrimitive as b from " + typeof(SupportBean).FullName;

            _epService.EPAdministrator.CreateEPL(stmtTextInsertOne);

            // load window
            long startTime = Environment.TickCount;

            for (int i = 0; i < 10000; i++)
            {
                SendSupportBean("S" + i, (long)i);
            }
            long endTime = Environment.TickCount;
            long delta   = endTime - startTime;

            Assert.IsTrue(delta < 1000, "Delta=" + delta);
            Assert.AreEqual(10000, EPAssertionUtil.EnumeratorCount(stmtCreate.GetEnumerator()));

            // destroy all
            for (int i = 0; i < statements.Length; i++)
            {
                statements[i].Dispose();
            }
        }
Beispiel #9
0
        public void TestPatternUnidirectionalOuterJoinNoOn()
        {
            // test 2-stream left outer join and SODA
            //
            _epService.EPAdministrator.Configuration.AddEventType("SupportBean", typeof(SupportBean));
            _epService.EPAdministrator.Configuration.AddEventType("SupportBean_S0", typeof(SupportBean_S0));
            _epService.EPAdministrator.Configuration.AddEventType("SupportBean_S1", typeof(SupportBean_S1));
            _epService.EPRuntime.SendEvent(new CurrentTimeEvent(1000));

            String stmtTextLO = "select sum(IntPrimitive) as c0, count(*) as c1 " +
                                "from pattern [every timer:interval(1 seconds)] unidirectional " +
                                "left outer join " +
                                "SupportBean.win:keepall()";
            EPStatement stmtLO = _epService.EPAdministrator.CreateEPL(stmtTextLO);

            stmtLO.Events += _listener.Update;

            RunAssertionPatternUniOuterJoinNoOn(0);

            stmtLO.Dispose();
            EPStatementObjectModel model = _epService.EPAdministrator.CompileEPL(stmtTextLO);

            Assert.AreEqual(stmtTextLO, model.ToEPL());
            stmtLO = _epService.EPAdministrator.Create(model);
            Assert.AreEqual(stmtTextLO, stmtLO.Text);
            stmtLO.Events += _listener.Update;

            RunAssertionPatternUniOuterJoinNoOn(100000);

            stmtLO.Dispose();

            // test 2-stream inner join
            //
            String[] fieldsIJ   = "c0,c1".Split(',');
            String   stmtTextIJ = "select sum(IntPrimitive) as c0, count(*) as c1 " +
                                  "from SupportBean_S0 unidirectional " +
                                  "inner join " +
                                  "SupportBean.win:keepall()";
            EPStatement stmtIJ = _epService.EPAdministrator.CreateEPL(stmtTextIJ);

            stmtIJ.Events += _listener.Update;

            _epService.EPRuntime.SendEvent(new SupportBean_S0(1, "S0_1"));
            _epService.EPRuntime.SendEvent(new SupportBean("E1", 100));
            Assert.IsFalse(_listener.IsInvoked);

            _epService.EPRuntime.SendEvent(new SupportBean_S0(2, "S0_2"));
            EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsIJ, new Object[] { 100, 1L });

            _epService.EPRuntime.SendEvent(new SupportBean("E2", 200));

            _epService.EPRuntime.SendEvent(new SupportBean_S0(3, "S0_3"));
            EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsIJ, new Object[] { 300, 2L });
            stmtIJ.Dispose();

            // test 2-stream inner join with group-by
            RunAssertion2StreamInnerWGroupBy();

            // test 3-stream inner join
            //
            String[] fields3IJ   = "c0,c1".Split(',');
            String   stmtText3IJ = "select sum(IntPrimitive) as c0, count(*) as c1 " +
                                   "from " +
                                   "SupportBean_S0.win:keepall()" +
                                   "inner join " +
                                   "SupportBean_S1.win:keepall()" +
                                   "inner join " +
                                   "SupportBean.win:keepall()";

            EPStatement stmt3IJ = _epService.EPAdministrator.CreateEPL(stmtText3IJ);

            stmt3IJ.Events += _listener.Update;

            _epService.EPRuntime.SendEvent(new SupportBean_S0(1, "S0_1"));
            _epService.EPRuntime.SendEvent(new SupportBean("E1", 50));
            Assert.IsFalse(_listener.IsInvoked);

            _epService.EPRuntime.SendEvent(new SupportBean_S1(10, "S1_1"));
            EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields3IJ, new Object[] { 50, 1L });

            _epService.EPRuntime.SendEvent(new SupportBean("E2", 51));
            EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields3IJ, new Object[] { 101, 2L });

            stmt3IJ.Dispose();

            // test 3-stream full outer join
            //
            String[] fields3FOJ   = "P00,P10,TheString".Split(',');
            String   stmtText3FOJ = "select P00, P10, TheString " +
                                    "from " +
                                    "SupportBean_S0.win:keepall()" +
                                    "full outer join " +
                                    "SupportBean_S1.win:keepall()" +
                                    "full outer join " +
                                    "SupportBean.win:keepall()";

            EPStatement stmt3FOJ = _epService.EPAdministrator.CreateEPL(stmtText3FOJ);

            stmt3FOJ.Events += _listener.Update;

            _epService.EPRuntime.SendEvent(new SupportBean_S0(1, "S0_1"));
            EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields3FOJ, new Object[] { "S0_1", null, null });

            _epService.EPRuntime.SendEvent(new SupportBean("E10", 0));
            EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields3FOJ, new Object[] { null, null, "E10" });

            _epService.EPRuntime.SendEvent(new SupportBean_S0(2, "S0_2"));
            EPAssertionUtil.AssertPropsPerRow(_listener.GetAndResetLastNewData(), fields3FOJ, new Object[][] { new Object[] { "S0_2", null, null } });

            _epService.EPRuntime.SendEvent(new SupportBean_S1(1, "S1_0"));
            EPAssertionUtil.AssertPropsPerRowAnyOrder(_listener.GetAndResetLastNewData(), fields3FOJ, new Object[][] { new Object[] { "S0_1", "S1_0", "E10" }, new Object[] { "S0_2", "S1_0", "E10" } });

            _epService.EPRuntime.SendEvent(new SupportBean_S0(2, "S0_3"));
            EPAssertionUtil.AssertPropsPerRow(_listener.GetAndResetLastNewData(), fields3FOJ, new Object[][] { new Object[] { "S0_3", "S1_0", "E10" } });

            _epService.EPRuntime.SendEvent(new SupportBean("E11", 0));
            EPAssertionUtil.AssertPropsPerRowAnyOrder(_listener.GetAndResetLastNewData(), fields3FOJ, new Object[][] { new Object[] { "S0_1", "S1_0", "E11" }, new Object[] { "S0_2", "S1_0", "E11" }, new Object[] { "S0_3", "S1_0", "E11" } });
            Assert.AreEqual(6, EPAssertionUtil.EnumeratorCount(stmt3FOJ.GetEnumerator()));

            stmt3FOJ.Dispose();

            // test 3-stream full outer join with where-clause
            //
            String[] fields3FOJW   = "P00,P10,TheString".Split(',');
            String   stmtText3FOJW = "select P00, P10, TheString " +
                                     "from " +
                                     "SupportBean_S0.win:keepall() as s0 " +
                                     "full outer join " +
                                     "SupportBean_S1.win:keepall() as s1 " +
                                     "full outer join " +
                                     "SupportBean.win:keepall() as sb " +
                                     "where s0.P00 = s1.P10";

            EPStatement stmt3FOJW = _epService.EPAdministrator.CreateEPL(stmtText3FOJW);

            stmt3FOJW.Events += _listener.Update;

            _epService.EPRuntime.SendEvent(new SupportBean_S0(1, "X1"));
            Assert.IsFalse(_listener.IsInvoked);

            _epService.EPRuntime.SendEvent(new SupportBean_S1(1, "Y1"));
            Assert.IsFalse(_listener.IsInvoked);

            _epService.EPRuntime.SendEvent(new SupportBean_S0(1, "Y1"));
            EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields3FOJW, new Object[] { "Y1", "Y1", null });
        }
Beispiel #10
0
 private static long GetTableCount(EPStatement stmt)
 {
     return EPAssertionUtil.EnumeratorCount(stmt.GetEnumerator());
 }
 private static void AssertCount(
     EPStatement stmt,
     long count)
 {
     Assert.AreEqual(count, EPAssertionUtil.EnumeratorCount(stmt.GetEnumerator()));
 }
            public void Run(RegressionEnvironment env)
            {
                // test 2-stream left outer join and SODA
                //
                var milestone = new AtomicLong();
                env.AdvanceTime(1000);

                var stmtTextLO = "@Name('s0') select sum(IntPrimitive) as c0, count(*) as c1 " +
                                 "from pattern [every timer:interval(1)] unidirectional " +
                                 "left outer join " +
                                 "SupportBean#keepall";
                env.CompileDeployAddListenerMile(stmtTextLO, "s0", milestone.GetAndIncrement());

                TryAssertionPatternUniOuterJoinNoOn(env, 0);

                env.UndeployAll();

                env.EplToModelCompileDeploy(stmtTextLO).AddListener("s0").Milestone(milestone.GetAndIncrement());

                TryAssertionPatternUniOuterJoinNoOn(env, 100000);

                env.UndeployAll();

                // test 2-stream inner join
                //
                var fieldsIJ = new[] {"c0", "c1"};
                var stmtTextIJ = "@Name('s0') select sum(IntPrimitive) as c0, count(*) as c1 " +
                                 "from SupportBean_S0 unidirectional " +
                                 "inner join " +
                                 "SupportBean#keepall";
                env.CompileDeployAddListenerMile(stmtTextIJ, "s0", milestone.GetAndIncrement());

                env.SendEventBean(new SupportBean_S0(1, "S0_1"));
                env.SendEventBean(new SupportBean("E1", 100));
                Assert.IsFalse(env.Listener("s0").IsInvoked);

                env.SendEventBean(new SupportBean_S0(2, "S0_2"));
                EPAssertionUtil.AssertProps(
                    env.Listener("s0").AssertOneGetNewAndReset(),
                    fieldsIJ,
                    new object[] {100, 1L});

                env.SendEventBean(new SupportBean("E2", 200));

                env.SendEventBean(new SupportBean_S0(3, "S0_3"));
                EPAssertionUtil.AssertProps(
                    env.Listener("s0").AssertOneGetNewAndReset(),
                    fieldsIJ,
                    new object[] {300, 2L});
                env.UndeployAll();

                // test 2-stream inner join with group-by
                TryAssertion2StreamInnerWGroupBy(env);

                // test 3-stream inner join
                //
                var fields3IJ = new[] {"c0", "c1"};
                var stmtText3IJ = "@Name('s0') select sum(IntPrimitive) as c0, count(*) as c1 " +
                                  "from " +
                                  "SupportBean_S0#keepall " +
                                  "inner join " +
                                  "SupportBean_S1#keepall " +
                                  "inner join " +
                                  "SupportBean#keepall";
                env.CompileDeployAddListenerMile(stmtText3IJ, "s0", milestone.GetAndIncrement());

                env.SendEventBean(new SupportBean_S0(1, "S0_1"));
                env.SendEventBean(new SupportBean("E1", 50));
                Assert.IsFalse(env.Listener("s0").IsInvoked);

                env.SendEventBean(new SupportBean_S1(10, "S1_1"));
                EPAssertionUtil.AssertProps(
                    env.Listener("s0").AssertOneGetNewAndReset(),
                    fields3IJ,
                    new object[] {50, 1L});

                env.SendEventBean(new SupportBean("E2", 51));
                EPAssertionUtil.AssertProps(
                    env.Listener("s0").AssertOneGetNewAndReset(),
                    fields3IJ,
                    new object[] {101, 2L});

                env.UndeployAll();

                // test 3-stream full outer join
                //
                var fields3FOJ = new[] {"P00", "P10", "TheString"};
                var stmtText3FOJ = "@Name('s0') select P00, P10, TheString " +
                                   "from " +
                                   "SupportBean_S0#keepall " +
                                   "full outer join " +
                                   "SupportBean_S1#keepall " +
                                   "full outer join " +
                                   "SupportBean#keepall";
                env.CompileDeployAddListenerMile(stmtText3FOJ, "s0", milestone.GetAndIncrement());

                env.SendEventBean(new SupportBean_S0(1, "S0_1"));
                EPAssertionUtil.AssertProps(
                    env.Listener("s0").AssertOneGetNewAndReset(),
                    fields3FOJ,
                    new object[] {"S0_1", null, null});

                env.SendEventBean(new SupportBean("E10", 0));
                EPAssertionUtil.AssertProps(
                    env.Listener("s0").AssertOneGetNewAndReset(),
                    fields3FOJ,
                    new object[] {null, null, "E10"});

                env.SendEventBean(new SupportBean_S0(2, "S0_2"));
                EPAssertionUtil.AssertPropsPerRow(
                    env.Listener("s0").GetAndResetLastNewData(),
                    fields3FOJ,
                    new[] {new object[] {"S0_2", null, null}});

                env.SendEventBean(new SupportBean_S1(1, "S1_0"));
                EPAssertionUtil.AssertPropsPerRowAnyOrder(
                    env.Listener("s0").GetAndResetLastNewData(),
                    fields3FOJ,
                    new[] {new object[] {"S0_1", "S1_0", "E10"}, new object[] {"S0_2", "S1_0", "E10"}});

                env.SendEventBean(new SupportBean_S0(2, "S0_3"));
                EPAssertionUtil.AssertPropsPerRow(
                    env.Listener("s0").GetAndResetLastNewData(),
                    fields3FOJ,
                    new[] {new object[] {"S0_3", "S1_0", "E10"}});

                env.SendEventBean(new SupportBean("E11", 0));
                EPAssertionUtil.AssertPropsPerRowAnyOrder(
                    env.Listener("s0").GetAndResetLastNewData(),
                    fields3FOJ,
                    new[] {
                        new object[] {"S0_1", "S1_0", "E11"}, new object[] {"S0_2", "S1_0", "E11"},
                        new object[] {"S0_3", "S1_0", "E11"}
                    });
                Assert.AreEqual(6, EPAssertionUtil.EnumeratorCount(env.GetEnumerator("s0")));

                env.UndeployAll();

                // test 3-stream full outer join with where-clause
                //
                var fields3FOJW = new[] {"P00", "P10", "TheString"};
                var stmtText3FOJW = "@Name('s0') select P00, P10, TheString " +
                                    "from " +
                                    "SupportBean_S0#keepall as S0 " +
                                    "full outer join " +
                                    "SupportBean_S1#keepall as S1 " +
                                    "full outer join " +
                                    "SupportBean#keepall as sb " +
                                    "where S0.P00 = S1.P10";
                env.CompileDeployAddListenerMile(stmtText3FOJW, "s0", milestone.GetAndIncrement());

                env.SendEventBean(new SupportBean_S0(1, "X1"));
                Assert.IsFalse(env.Listener("s0").IsInvoked);

                env.SendEventBean(new SupportBean_S1(1, "Y1"));
                Assert.IsFalse(env.Listener("s0").IsInvoked);

                env.SendEventBean(new SupportBean_S0(1, "Y1"));
                EPAssertionUtil.AssertProps(
                    env.Listener("s0").AssertOneGetNewAndReset(),
                    fields3FOJW,
                    new object[] {"Y1", "Y1", null});

                env.UndeployAll();
            }