Esempio n. 1
0
        public void TestSetLogicWithContained()
        {
            String epl = "select " + "contained.except(containedTwo) as val0,"
                         + "contained.intersect(containedTwo) as val1, "
                         + "contained.union(containedTwo) as val2 "
                         + " from SupportBean_ST0_Container";
            EPStatement stmt = _epService.EPAdministrator.CreateEPL(epl);

            stmt.Events += _listener.Update;
            LambdaAssertionUtil.AssertTypes(stmt.EventType, "val0".Split(','),
                                            new Type[] { typeof(ICollection <SupportBean_ST0>) }
                                            );

            List <SupportBean_ST0> first = SupportBean_ST0_Container.Make2ValueList(
                "E1,1", "E2,10", "E3,1", "E4,10", "E5,11");
            List <SupportBean_ST0> second = SupportBean_ST0_Container.Make2ValueList(
                "E1,1", "E3,1", "E4,10");

            _epService.EPRuntime.SendEvent(
                new SupportBean_ST0_Container(first, second));
            LambdaAssertionUtil.AssertST0Id(_listener, "val0", "E2,E5");
            LambdaAssertionUtil.AssertST0Id(_listener, "val1", "E1,E3,E4");
            LambdaAssertionUtil.AssertST0Id(_listener, "val2",
                                            "E1,E2,E3,E4,E5,E1,E3,E4");
            _listener.Reset();
        }
Esempio n. 2
0
        private void RunAssertionReverseEvents(EPServiceProvider epService)
        {
            string      epl      = "select Contained.Reverse() as val from Bean";
            EPStatement stmt     = epService.EPAdministrator.CreateEPL(epl);
            var         listener = new SupportUpdateListener();

            stmt.Events += listener.Update;
            LambdaAssertionUtil.AssertTypes(stmt.EventType, "val".Split(','), new Type[] {
                typeof(ICollection <SupportBean_ST0>)
            });

            epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E1,1", "E2,9", "E3,1"));
            LambdaAssertionUtil.AssertST0Id(listener, "val", "E3,E2,E1");
            listener.Reset();

            epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E2,9", "E1,1"));
            LambdaAssertionUtil.AssertST0Id(listener, "val", "E1,E2");
            listener.Reset();

            epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E1,1"));
            LambdaAssertionUtil.AssertST0Id(listener, "val", "E1");
            listener.Reset();

            epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value(null));
            LambdaAssertionUtil.AssertST0Id(listener, "val", null);
            listener.Reset();

            epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value());
            LambdaAssertionUtil.AssertST0Id(listener, "val", "");
            listener.Reset();

            stmt.Dispose();
        }
Esempio n. 3
0
        public void TestReverseEvents()
        {
            String      epl  = "select contained.reverse() as val from Bean";
            EPStatement stmt = _epService.EPAdministrator.CreateEPL(epl);

            stmt.Events += _listener.Update;
            LambdaAssertionUtil.AssertTypes(stmt.EventType, "val".Split(','), new Type[] { typeof(ICollection <SupportBean_ST0>) });

            _epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E1,1", "E2,9", "E3,1"));
            LambdaAssertionUtil.AssertST0Id(_listener, "val", "E3,E2,E1");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E2,9", "E1,1"));
            LambdaAssertionUtil.AssertST0Id(_listener, "val", "E1,E2");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E1,1"));
            LambdaAssertionUtil.AssertST0Id(_listener, "val", "E1");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value(null));
            LambdaAssertionUtil.AssertST0Id(_listener, "val", null);
            _listener.Reset();

            _epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value());
            LambdaAssertionUtil.AssertST0Id(_listener, "val", "");
            _listener.Reset();
        }
Esempio n. 4
0
        public void TestWhereEvents()
        {
            String epl = "select " +
                         "contained.Where(x => p00 = 9) as val0," +
                         "contained.Where((x, i) => x.P00 = 9 and i >= 1) as val1 from Bean";
            EPStatement stmt = _epService.EPAdministrator.CreateEPL(epl);

            stmt.Events += _listener.Update;
            LambdaAssertionUtil.AssertTypes(stmt.EventType, "val0,val1".Split(','), new Type[] { typeof(ICollection <object>), typeof(ICollection <object>) });

            _epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E1,1", "E2,9", "E3,1"));
            LambdaAssertionUtil.AssertST0Id(_listener, "val0", "E2");
            LambdaAssertionUtil.AssertST0Id(_listener, "val1", "E2");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E1,9", "E2,1", "E3,1"));
            LambdaAssertionUtil.AssertST0Id(_listener, "val0", "E1");
            LambdaAssertionUtil.AssertST0Id(_listener, "val1", "");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E1,1", "E2,1", "E3,9"));
            LambdaAssertionUtil.AssertST0Id(_listener, "val0", "E3");
            LambdaAssertionUtil.AssertST0Id(_listener, "val1", "E3");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value(null));
            LambdaAssertionUtil.AssertST0Id(_listener, "val0", null);
            LambdaAssertionUtil.AssertST0Id(_listener, "val1", null);
            _listener.Reset();

            _epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value());
            LambdaAssertionUtil.AssertST0Id(_listener, "val0", "");
            LambdaAssertionUtil.AssertST0Id(_listener, "val1", "");
            _listener.Reset();
        }
Esempio n. 5
0
        public void TestDistinctEvents()
        {
            String[] fields      = "val0".Split(',');
            String   eplFragment = "select " +
                                   "contained.DistinctOf(x => p00) as val0 " +
                                   " from Bean";
            EPStatement stmtFragment = _epService.EPAdministrator.CreateEPL(eplFragment);

            stmtFragment.Events += _listener.Update;
            LambdaAssertionUtil.AssertTypes(stmtFragment.EventType, fields, new Type[] { typeof(ICollection <object>) });

            _epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E1,1", "E2,2", "E3,1"));
            LambdaAssertionUtil.AssertST0Id(_listener, "val0", "E1,E2");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E3,1", "E2,2", "E4,1", "E1,2"));
            LambdaAssertionUtil.AssertST0Id(_listener, "val0", "E3,E2");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value(null));
            foreach (String field in fields)
            {
                LambdaAssertionUtil.AssertST0Id(_listener, field, null);
            }
            _listener.Reset();

            _epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value());
            foreach (String field in fields)
            {
                LambdaAssertionUtil.AssertST0Id(_listener, field, "");
            }
            _listener.Reset();
        }
Esempio n. 6
0
        private void RunAssertionPrevWindowSorted(EPServiceProvider epService)
        {
            var stmt = epService.EPAdministrator.CreateEPL(
                "select prevwindow(st0) as val0, prevwindow(st0).EsperInternalNoop() as val1 " +
                "from SupportBean_ST0#sort(3, p00 asc) as st0");
            var listener = new SupportUpdateListener();
            stmt.Events += listener.Update;
            LambdaAssertionUtil.AssertTypes(
                stmt.EventType, "val0,val1".Split(','), new[] {
                    typeof(SupportBean_ST0[]),
                    typeof(ICollection<SupportBean_ST0>)
                });

            epService.EPRuntime.SendEvent(new SupportBean_ST0("E1", 5));
            LambdaAssertionUtil.AssertST0Id(listener, "val1", "E1");
            listener.Reset();

            epService.EPRuntime.SendEvent(new SupportBean_ST0("E2", 6));
            LambdaAssertionUtil.AssertST0Id(listener, "val1", "E1,E2");
            listener.Reset();

            epService.EPRuntime.SendEvent(new SupportBean_ST0("E3", 4));
            LambdaAssertionUtil.AssertST0Id(listener, "val1", "E3,E1,E2");
            listener.Reset();

            epService.EPRuntime.SendEvent(new SupportBean_ST0("E5", 3));
            LambdaAssertionUtil.AssertST0Id(listener, "val1", "E5,E3,E1");
            listener.Reset();
            stmt.Dispose();

            // Scalar version
            var fields = new[] {"val0"};
            var stmtScalar = epService.EPAdministrator.CreateEPL(
                "select prevwindow(id).where(x => x not like '%ignore%') as val0 " +
                "from SupportBean_ST0#keepall as st0");
            stmtScalar.Events += listener.Update;
            LambdaAssertionUtil.AssertTypes(stmtScalar.EventType, fields, new[] {
                typeof(ICollection<string>)
            });

            epService.EPRuntime.SendEvent(new SupportBean_ST0("E1", 5));
            LambdaAssertionUtil.AssertValuesArrayScalar(listener, "val0", "E1");
            listener.Reset();

            epService.EPRuntime.SendEvent(new SupportBean_ST0("E2ignore", 6));
            LambdaAssertionUtil.AssertValuesArrayScalar(listener, "val0", "E1");
            listener.Reset();

            epService.EPRuntime.SendEvent(new SupportBean_ST0("E3", 4));
            LambdaAssertionUtil.AssertValuesArrayScalar(listener, "val0", "E3", "E1");
            listener.Reset();

            epService.EPRuntime.SendEvent(new SupportBean_ST0("ignoreE5", 3));
            LambdaAssertionUtil.AssertValuesArrayScalar(listener, "val0", "E3", "E1");
            listener.Reset();

            stmtScalar.Dispose();
        }
Esempio n. 7
0
        private void RunAssertionOrderByEvents(EPServiceProvider epService)
        {
            string[] fields      = "val0,val1,val2,val3,val4,val5".Split(',');
            string   eplFragment = "select " +
                                   "Contained.orderBy(x => p00) as val0," +
                                   "Contained.orderBy(x => 10 - p00) as val1," +
                                   "Contained.orderBy(x => 0) as val2," +
                                   "Contained.OrderByDesc(x => p00) as val3," +
                                   "Contained.OrderByDesc(x => 10 - p00) as val4," +
                                   "Contained.OrderByDesc(x => 0) as val5" +
                                   " from Bean";
            EPStatement stmtFragment = epService.EPAdministrator.CreateEPL(eplFragment);
            var         listener     = new SupportUpdateListener();

            stmtFragment.Events += listener.Update;
            LambdaAssertionUtil.AssertTypes(stmtFragment.EventType, fields, new Type[] {
                typeof(ICollection <SupportBean_ST0>),
                typeof(ICollection <SupportBean_ST0>),
                typeof(ICollection <SupportBean_ST0>),
                typeof(ICollection <SupportBean_ST0>),
                typeof(ICollection <SupportBean_ST0>),
                typeof(ICollection <SupportBean_ST0>)
            });

            epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E1,1", "E2,2"));
            LambdaAssertionUtil.AssertST0Id(listener, "val0", "E1,E2");
            LambdaAssertionUtil.AssertST0Id(listener, "val1", "E2,E1");
            LambdaAssertionUtil.AssertST0Id(listener, "val2", "E1,E2");
            LambdaAssertionUtil.AssertST0Id(listener, "val3", "E2,E1");
            LambdaAssertionUtil.AssertST0Id(listener, "val4", "E1,E2");
            LambdaAssertionUtil.AssertST0Id(listener, "val5", "E1,E2");
            listener.Reset();

            epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E3,1", "E2,2", "E4,1", "E1,2"));
            LambdaAssertionUtil.AssertST0Id(listener, "val0", "E3,E4,E2,E1");
            LambdaAssertionUtil.AssertST0Id(listener, "val1", "E2,E1,E3,E4");
            LambdaAssertionUtil.AssertST0Id(listener, "val2", "E3,E2,E4,E1");
            LambdaAssertionUtil.AssertST0Id(listener, "val3", "E2,E1,E3,E4");
            LambdaAssertionUtil.AssertST0Id(listener, "val4", "E3,E4,E2,E1");
            LambdaAssertionUtil.AssertST0Id(listener, "val5", "E3,E2,E4,E1");
            listener.Reset();

            epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value(null));
            foreach (string field in fields)
            {
                LambdaAssertionUtil.AssertST0Id(listener, field, null);
            }
            listener.Reset();

            epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value());
            foreach (string field in fields)
            {
                LambdaAssertionUtil.AssertST0Id(listener, field, "");
            }
            listener.Reset();

            stmtFragment.Dispose();
        }
Esempio n. 8
0
        public void TestOrderByEvents()
        {
            String[] fields      = "val0,val1,val2,val3,val4,val5".Split(',');
            String   eplFragment = "select " +
                                   "contained.orderBy(x => p00) as val0," +
                                   "contained.orderBy(x => 10 - p00) as val1," +
                                   "contained.orderBy(x => 0) as val2," +
                                   "contained.orderByDesc(x => p00) as val3," +
                                   "contained.orderByDesc(x => 10 - p00) as val4," +
                                   "contained.orderByDesc(x => 0) as val5" +
                                   " from Bean";
            EPStatement stmtFragment = _epService.EPAdministrator.CreateEPL(eplFragment);

            stmtFragment.Events += _listener.Update;
            LambdaAssertionUtil.AssertTypes(stmtFragment.EventType, fields,
                                            new Type[]
            {
                typeof(ICollection <SupportBean_ST0>),
                typeof(ICollection <SupportBean_ST0>),
                typeof(ICollection <SupportBean_ST0>),
                typeof(ICollection <SupportBean_ST0>),
                typeof(ICollection <SupportBean_ST0>),
                typeof(ICollection <SupportBean_ST0>)
            });

            _epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E1,1", "E2,2"));
            LambdaAssertionUtil.AssertST0Id(_listener, "val0", "E1,E2");
            LambdaAssertionUtil.AssertST0Id(_listener, "val1", "E2,E1");
            LambdaAssertionUtil.AssertST0Id(_listener, "val2", "E1,E2");
            LambdaAssertionUtil.AssertST0Id(_listener, "val3", "E2,E1");
            LambdaAssertionUtil.AssertST0Id(_listener, "val4", "E1,E2");
            LambdaAssertionUtil.AssertST0Id(_listener, "val5", "E1,E2");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E3,1", "E2,2", "E4,1", "E1,2"));
            LambdaAssertionUtil.AssertST0Id(_listener, "val0", "E3,E4,E2,E1");
            LambdaAssertionUtil.AssertST0Id(_listener, "val1", "E2,E1,E3,E4");
            LambdaAssertionUtil.AssertST0Id(_listener, "val2", "E3,E2,E4,E1");
            LambdaAssertionUtil.AssertST0Id(_listener, "val3", "E2,E1,E3,E4");
            LambdaAssertionUtil.AssertST0Id(_listener, "val4", "E3,E4,E2,E1");
            LambdaAssertionUtil.AssertST0Id(_listener, "val5", "E3,E2,E4,E1");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value(null));
            foreach (String field in fields)
            {
                LambdaAssertionUtil.AssertST0Id(_listener, field, null);
            }
            _listener.Reset();

            _epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value());
            foreach (String field in fields)
            {
                LambdaAssertionUtil.AssertST0Id(_listener, field, "");
            }
            _listener.Reset();
        }
Esempio n. 9
0
        public void TestPrevWindowSorted()
        {
            var stmt = _epService.EPAdministrator.CreateEPL("select Prevwindow(st0) as val0, Prevwindow(st0).EsperInternalNoop() as val1 " +
                                                            "from SupportBean_ST0.ext:sort(3, p00 asc) as st0");

            stmt.Events += _listener.Update;
            LambdaAssertionUtil.AssertTypes(stmt.EventType, "val0,val1".Split(','), new Type[]
            {
                typeof(SupportBean_ST0[]), typeof(ICollection <object>)
            });

            _epService.EPRuntime.SendEvent(new SupportBean_ST0("E1", 5));
            LambdaAssertionUtil.AssertST0Id(_listener, "val1", "E1");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(new SupportBean_ST0("E2", 6));
            LambdaAssertionUtil.AssertST0Id(_listener, "val1", "E1,E2");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(new SupportBean_ST0("E3", 4));
            LambdaAssertionUtil.AssertST0Id(_listener, "val1", "E3,E1,E2");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(new SupportBean_ST0("E5", 3));
            LambdaAssertionUtil.AssertST0Id(_listener, "val1", "E5,E3,E1");
            _listener.Reset();
            stmt.Dispose();

            // Scalar version
            String[] fields     = { "val0" };
            var      stmtScalar = _epService.EPAdministrator.CreateEPL("select Prevwindow(id).Where(x => x not like '%ignore%') as val0 " +
                                                                       "from SupportBean_ST0.win:keepall() as st0");

            stmtScalar.Events += _listener.Update;
            LambdaAssertionUtil.AssertTypes(stmtScalar.EventType, fields, new Type[] { typeof(ICollection <object>) });

            _epService.EPRuntime.SendEvent(new SupportBean_ST0("E1", 5));
            LambdaAssertionUtil.AssertValuesArrayScalar(_listener, "val0", "E1");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(new SupportBean_ST0("E2ignore", 6));
            LambdaAssertionUtil.AssertValuesArrayScalar(_listener, "val0", "E1");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(new SupportBean_ST0("E3", 4));
            LambdaAssertionUtil.AssertValuesArrayScalar(_listener, "val0", "E3", "E1");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(new SupportBean_ST0("ignoreE5", 3));
            LambdaAssertionUtil.AssertValuesArrayScalar(_listener, "val0", "E3", "E1");
            _listener.Reset();
        }
Esempio n. 10
0
        public void TestUnionWhere()
        {
            String epl = "expression one {"
                         + "  x => x.contained.Where(y => p00 = 10)" + "} " + ""
                         + "expression two {" + "  x => x.contained.Where(y => p00 = 11)"
                         + "} " + ""
                         + "select one(bean).union(two(bean)) as val0 from SupportBean_ST0_Container as bean";
            EPStatement stmt = _epService.EPAdministrator.CreateEPL(epl);

            stmt.Events += _listener.Update;
            LambdaAssertionUtil.AssertTypes(stmt.EventType, "val0".Split(','),
                                            new Type[] { typeof(ICollection <SupportBean_ST0>) }
                                            );

            _epService.EPRuntime.SendEvent(
                SupportBean_ST0_Container.Make2Value("E1,1", "E2,10", "E3,1",
                                                     "E4,10", "E5,11"));
            LambdaAssertionUtil.AssertST0Id(_listener, "val0", "E2,E4,E5");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(
                SupportBean_ST0_Container.Make2Value("E1,10", "E2,1", "E3,1"));
            LambdaAssertionUtil.AssertST0Id(_listener, "val0", "E1");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(
                SupportBean_ST0_Container.Make2Value("E1,1", "E2,1", "E3,10",
                                                     "E4,11"));
            LambdaAssertionUtil.AssertST0Id(_listener, "val0", "E3,E4");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(
                SupportBean_ST0_Container.Make2Value(null));
            LambdaAssertionUtil.AssertST0Id(_listener, "val0", null);
            _listener.Reset();

            _epService.EPRuntime.SendEvent(
                SupportBean_ST0_Container.Make2Value());
            LambdaAssertionUtil.AssertST0Id(_listener, "val0", "");
            _listener.Reset();
        }
        private void RunAssertionUnionWhere(EPServiceProvider epService)
        {
            string epl = "expression one {" +
                         "  x => x.Contained.where(y => p00 = 10)" +
                         "} " +
                         "" +
                         "expression two {" +
                         "  x => x.Contained.where(y => p00 = 11)" +
                         "} " +
                         "" +
                         "select one(bean).union(two(bean)) as val0 from SupportBean_ST0_Container as bean";
            EPStatement stmt     = epService.EPAdministrator.CreateEPL(epl);
            var         listener = new SupportUpdateListener();

            stmt.Events += listener.Update;
            LambdaAssertionUtil.AssertTypes(stmt.EventType, "val0".Split(','), new Type[] {
                typeof(ICollection <SupportBean_ST0>)
            });

            epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E1,1", "E2,10", "E3,1", "E4,10", "E5,11"));
            LambdaAssertionUtil.AssertST0Id(listener, "val0", "E2,E4,E5");
            listener.Reset();

            epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E1,10", "E2,1", "E3,1"));
            LambdaAssertionUtil.AssertST0Id(listener, "val0", "E1");
            listener.Reset();

            epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E1,1", "E2,1", "E3,10", "E4,11"));
            LambdaAssertionUtil.AssertST0Id(listener, "val0", "E3,E4");
            listener.Reset();

            epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value((string[])null));
            LambdaAssertionUtil.AssertST0Id(listener, "val0", null);
            listener.Reset();

            epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value());
            LambdaAssertionUtil.AssertST0Id(listener, "val0", "");
            listener.Reset();

            stmt.Dispose();
        }
Esempio n. 12
0
        private void RunAssertionWhereEvents(EPServiceProvider epService)
        {
            string epl = "select " +
                         "Contained.where(x => p00 = 9) as val0," +
                         "Contained.where((x, i) => x.p00 = 9 and i >= 1) as val1 from Bean";
            EPStatement stmt     = epService.EPAdministrator.CreateEPL(epl);
            var         listener = new SupportUpdateListener();

            stmt.Events += listener.Update;
            LambdaAssertionUtil.AssertTypes(stmt.EventType, "val0,val1".Split(','), new Type[] {
                typeof(ICollection <SupportBean_ST0>), typeof(ICollection <SupportBean_ST0>)
            });

            epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E1,1", "E2,9", "E3,1"));
            LambdaAssertionUtil.AssertST0Id(listener, "val0", "E2");
            LambdaAssertionUtil.AssertST0Id(listener, "val1", "E2");
            listener.Reset();

            epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E1,9", "E2,1", "E3,1"));
            LambdaAssertionUtil.AssertST0Id(listener, "val0", "E1");
            LambdaAssertionUtil.AssertST0Id(listener, "val1", "");
            listener.Reset();

            epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E1,1", "E2,1", "E3,9"));
            LambdaAssertionUtil.AssertST0Id(listener, "val0", "E3");
            LambdaAssertionUtil.AssertST0Id(listener, "val1", "E3");
            listener.Reset();

            epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value(null));
            LambdaAssertionUtil.AssertST0Id(listener, "val0", null);
            LambdaAssertionUtil.AssertST0Id(listener, "val1", null);
            listener.Reset();

            epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value());
            LambdaAssertionUtil.AssertST0Id(listener, "val0", "");
            LambdaAssertionUtil.AssertST0Id(listener, "val1", "");
            listener.Reset();

            stmt.Dispose();
        }
Esempio n. 13
0
        public void TestTakeEvents()
        {
            String[] fields = "val0,val1,val2,val3,val4,val5".Split(',');
            String   epl    = "select " +
                              "contained.Take(2) as val0," +
                              "contained.Take(1) as val1," +
                              "contained.Take(0) as val2," +
                              "contained.Take(-1) as val3," +
                              "contained.TakeLast(2) as val4," +
                              "contained.TakeLast(1) as val5" +
                              " from Bean";
            EPStatement stmt = _epService.EPAdministrator.CreateEPL(epl);

            stmt.Events += _listener.Update;
            LambdaAssertionUtil.AssertTypes(stmt.EventType, fields, new Type[]
            {
                typeof(ICollection <object>),
                typeof(ICollection <object>),
                typeof(ICollection <object>),
                typeof(ICollection <object>),
                typeof(ICollection <object>),
                typeof(ICollection <object>)
            });

            _epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E1,1", "E2,2", "E3,3"));
            LambdaAssertionUtil.AssertST0Id(_listener, "val0", "E1,E2");
            LambdaAssertionUtil.AssertST0Id(_listener, "val1", "E1");
            LambdaAssertionUtil.AssertST0Id(_listener, "val2", "");
            LambdaAssertionUtil.AssertST0Id(_listener, "val3", "");
            LambdaAssertionUtil.AssertST0Id(_listener, "val4", "E2,E3");
            LambdaAssertionUtil.AssertST0Id(_listener, "val5", "E3");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E1,1", "E2,2"));
            LambdaAssertionUtil.AssertST0Id(_listener, "val0", "E1,E2");
            LambdaAssertionUtil.AssertST0Id(_listener, "val1", "E1");
            LambdaAssertionUtil.AssertST0Id(_listener, "val2", "");
            LambdaAssertionUtil.AssertST0Id(_listener, "val3", "");
            LambdaAssertionUtil.AssertST0Id(_listener, "val4", "E1,E2");
            LambdaAssertionUtil.AssertST0Id(_listener, "val5", "E2");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E1,1"));
            LambdaAssertionUtil.AssertST0Id(_listener, "val0", "E1");
            LambdaAssertionUtil.AssertST0Id(_listener, "val1", "E1");
            LambdaAssertionUtil.AssertST0Id(_listener, "val2", "");
            LambdaAssertionUtil.AssertST0Id(_listener, "val3", "");
            LambdaAssertionUtil.AssertST0Id(_listener, "val4", "E1");
            LambdaAssertionUtil.AssertST0Id(_listener, "val5", "E1");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value());
            foreach (String field in fields)
            {
                LambdaAssertionUtil.AssertST0Id(_listener, field, "");
            }
            _listener.Reset();

            _epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value(null));
            foreach (String field in fields)
            {
                LambdaAssertionUtil.AssertST0Id(_listener, field, null);
            }
            _listener.Reset();
        }
Esempio n. 14
0
        public void TestSetLogicWithEvents()
        {
            String epl = "expression last10A {"
                         + " (select * from SupportBean_ST0(key0 like 'A%')#length(2)) "
                         + "}" + "expression last10NonZero {"
                         + " (select * from SupportBean_ST0(p00 > 0)#length(2)) "
                         + "}" + "select " + "last10A().except(last10NonZero()) as val0,"
                         + "last10A().intersect(last10NonZero()) as val1, "
                         + "last10A().union(last10NonZero()) as val2 "
                         + "from SupportBean";
            EPStatement stmt = _epService.EPAdministrator.CreateEPL(epl);

            stmt.Events += _listener.Update;
            LambdaAssertionUtil.AssertTypes(stmt.EventType, "val0".Split(','),
                                            new Type[] { typeof(ICollection <SupportBean_ST0>) }
                                            );

            _epService.EPRuntime.SendEvent(new SupportBean_ST0("E1", "A1", 10)); // in both
            _epService.EPRuntime.SendEvent(
                new SupportBean());
            LambdaAssertionUtil.AssertST0Id(_listener, "val0", "");
            LambdaAssertionUtil.AssertST0Id(_listener, "val1", "E1");
            LambdaAssertionUtil.AssertST0Id(_listener, "val2", "E1,E1");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(new SupportBean_ST0("E2", "A1", 0));
            _epService.EPRuntime.SendEvent(new SupportBean());
            LambdaAssertionUtil.AssertST0Id(_listener, "val0", "E2");
            LambdaAssertionUtil.AssertST0Id(_listener, "val1", "E1");
            LambdaAssertionUtil.AssertST0Id(_listener, "val2", "E1,E2,E1");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(new SupportBean_ST0("E3", "B1", 0));
            _epService.EPRuntime.SendEvent(new SupportBean());
            LambdaAssertionUtil.AssertST0Id(_listener, "val0", "E2");
            LambdaAssertionUtil.AssertST0Id(_listener, "val1", "E1");
            LambdaAssertionUtil.AssertST0Id(_listener, "val2", "E1,E2,E1");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(new SupportBean_ST0("E4", "A2", -1));
            _epService.EPRuntime.SendEvent(new SupportBean());
            LambdaAssertionUtil.AssertST0Id(_listener, "val0", "E2,E4");
            LambdaAssertionUtil.AssertST0Id(_listener, "val1", "");
            LambdaAssertionUtil.AssertST0Id(_listener, "val2", "E2,E4,E1");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(new SupportBean_ST0("E5", "A3", -2));
            _epService.EPRuntime.SendEvent(new SupportBean());
            LambdaAssertionUtil.AssertST0Id(_listener, "val0", "E4,E5");
            LambdaAssertionUtil.AssertST0Id(_listener, "val1", "");
            LambdaAssertionUtil.AssertST0Id(_listener, "val2", "E4,E5,E1");
            _listener.Reset();

            _epService.EPRuntime.SendEvent(new SupportBean_ST0("E6", "A6", 11)); // in both
            _epService.EPRuntime.SendEvent(
                new SupportBean_ST0("E7", "A7", 12));                            // in both
            _epService.EPRuntime.SendEvent(new SupportBean());
            LambdaAssertionUtil.AssertST0Id(_listener, "val0", "");
            LambdaAssertionUtil.AssertST0Id(_listener, "val1", "E6,E7");
            LambdaAssertionUtil.AssertST0Id(_listener, "val2", "E6,E7,E6,E7");
            _listener.Reset();
        }
        private void RunAssertionTakeWhileEvents(EPServiceProvider epService)
        {
            string[] fields = "val0,val1,val2,val3".Split(',');
            string   epl    = "select " +
                              "Contained.takeWhile(x => x.p00 > 0) as val0," +
                              "Contained.takeWhile( (x, i) => x.p00 > 0 and i<2) as val1," +
                              "Contained.takeWhileLast(x => x.p00 > 0) as val2," +
                              "Contained.takeWhileLast( (x, i) => x.p00 > 0 and i<2) as val3" +
                              " from Bean";
            EPStatement stmt     = epService.EPAdministrator.CreateEPL(epl);
            var         listener = new SupportUpdateListener();

            stmt.Events += listener.Update;
            LambdaAssertionUtil.AssertTypes(stmt.EventType, fields, new Type[] {
                typeof(ICollection <SupportBean_ST0>),
                typeof(ICollection <SupportBean_ST0>),
                typeof(ICollection <SupportBean_ST0>),
                typeof(ICollection <SupportBean_ST0>)
            });

            epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E1,1", "E2,2", "E3,3"));
            LambdaAssertionUtil.AssertST0Id(listener, "val0", "E1,E2,E3");
            LambdaAssertionUtil.AssertST0Id(listener, "val1", "E1,E2");
            LambdaAssertionUtil.AssertST0Id(listener, "val2", "E1,E2,E3");
            LambdaAssertionUtil.AssertST0Id(listener, "val3", "E2,E3");
            listener.Reset();

            epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E1,0", "E2,2", "E3,3"));
            LambdaAssertionUtil.AssertST0Id(listener, "val0", "");
            LambdaAssertionUtil.AssertST0Id(listener, "val1", "");
            LambdaAssertionUtil.AssertST0Id(listener, "val2", "E2,E3");
            LambdaAssertionUtil.AssertST0Id(listener, "val3", "E2,E3");
            listener.Reset();

            epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E1,1", "E2,0", "E3,3"));
            LambdaAssertionUtil.AssertST0Id(listener, "val0", "E1");
            LambdaAssertionUtil.AssertST0Id(listener, "val1", "E1");
            LambdaAssertionUtil.AssertST0Id(listener, "val2", "E3");
            LambdaAssertionUtil.AssertST0Id(listener, "val3", "E3");
            listener.Reset();

            epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E1,1", "E2,1", "E3,0"));
            LambdaAssertionUtil.AssertST0Id(listener, "val0", "E1,E2");
            LambdaAssertionUtil.AssertST0Id(listener, "val1", "E1,E2");
            LambdaAssertionUtil.AssertST0Id(listener, "val2", "");
            LambdaAssertionUtil.AssertST0Id(listener, "val3", "");
            listener.Reset();

            epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value("E1,1"));
            LambdaAssertionUtil.AssertST0Id(listener, "val0", "E1");
            LambdaAssertionUtil.AssertST0Id(listener, "val1", "E1");
            LambdaAssertionUtil.AssertST0Id(listener, "val2", "E1");
            LambdaAssertionUtil.AssertST0Id(listener, "val3", "E1");
            listener.Reset();

            epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value());
            foreach (string field in fields)
            {
                LambdaAssertionUtil.AssertST0Id(listener, field, "");
            }
            listener.Reset();

            epService.EPRuntime.SendEvent(SupportBean_ST0_Container.Make2Value(null));
            foreach (string field in fields)
            {
                LambdaAssertionUtil.AssertST0Id(listener, field, null);
            }
            listener.Reset();

            stmt.Dispose();
        }