示例#1
0
        public void TestIncludeEndpoints()
        {
            String startTime = "2002-05-30 09:00:00.000";

            _epService.EPRuntime.SendEvent(new CurrentTimeEvent(DateTimeParser.ParseDefaultMSec(startTime)));

            String[] fieldsCurrentTs = "val0,val1,val2,val3,val4,val5,val6".Split(',');
            String   eplCurrentTS    = "select " +
                                       "current_timestamp.After(msecdateStart) as val0, " +
                                       "current_timestamp.Between(msecdateStart, msecdateEnd) as val1, " +
                                       "current_timestamp.Between(utildateStart, caldateEnd) as val2, " +
                                       "current_timestamp.Between(caldateStart, utildateEnd) as val3, " +
                                       "current_timestamp.Between(utildateStart, utildateEnd) as val4, " +
                                       "current_timestamp.Between(caldateStart, caldateEnd) as val5, " +
                                       "current_timestamp.Between(caldateEnd, caldateStart) as val6 " +
                                       "from SupportTimeStartEndA";
            EPStatement stmtCurrentTs = _epService.EPAdministrator.CreateEPL(eplCurrentTS);

            stmtCurrentTs.Events += _listener.Update;
            LambdaAssertionUtil.AssertTypesAllSame(stmtCurrentTs.EventType, fieldsCurrentTs, typeof(bool?));

            _epService.EPRuntime.SendEvent(SupportTimeStartEndA.Make("E1", "2002-05-30 08:59:59.999", 0));
            EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsCurrentTs, new Object[] { true, false, false, false, false, false, false });

            _epService.EPRuntime.SendEvent(SupportTimeStartEndA.Make("E1", "2002-05-30 08:59:59.999", 1));
            EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsCurrentTs, new Object[] { true, true, true, true, true, true, true });

            _epService.EPRuntime.SendEvent(SupportTimeStartEndA.Make("E1", "2002-05-30 08:59:59.999", 100));
            EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsCurrentTs, new Object[] { true, true, true, true, true, true, true });

            _epService.EPRuntime.SendEvent(SupportTimeStartEndA.Make("E1", "2002-05-30 09:00:00.000", 0));
            EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsCurrentTs, new Object[] { false, true, true, true, true, true, true });

            _epService.EPRuntime.SendEvent(SupportTimeStartEndA.Make("E1", "2002-05-30 09:00:00.000", 100));
            EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsCurrentTs, new Object[] { false, true, true, true, true, true, true });

            _epService.EPRuntime.SendEvent(SupportTimeStartEndA.Make("E1", "2002-05-30 09:00:00.001", 100));
            EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fieldsCurrentTs, new Object[] { false, false, false, false, false, false, false });
            stmtCurrentTs.Dispose();

            // test calendar field and constants
            _epService.EPAdministrator.Configuration.AddImport(typeof(DateTimeParser));
            String[] fieldsConstants = "val0,val1,val2,val3".Split(',');
            String   eplConstants    = "select " +
                                       "msecdateStart.between(DateTimeParser.ParseDefault('2002-05-30 09:00:00.000'), DateTimeParser.ParseDefault('2002-05-30 09:01:00.000')) as val0, " +
                                       "utildateStart.between(DateTimeParser.ParseDefault('2002-05-30 09:00:00.000'), DateTimeParser.ParseDefault('2002-05-30 09:01:00.000')) as val1, " +
                                       "caldateStart.between(DateTimeParser.ParseDefault('2002-05-30 09:00:00.000'), DateTimeParser.ParseDefault('2002-05-30 09:01:00.000')) as val2, " +
                                       "msecdateStart.between(DateTimeParser.ParseDefault('2002-05-30 09:01:00.000'), DateTimeParser.ParseDefault('2002-05-30 09:00:00.000')) as val3 " +
                                       "from SupportTimeStartEndA";
            EPStatement stmtConstants = _epService.EPAdministrator.CreateEPL(eplConstants);

            stmtConstants.Events += _listener.Update;
            LambdaAssertionUtil.AssertTypesAllSame(stmtConstants.EventType, fieldsConstants, typeof(bool?));

            _epService.EPRuntime.SendEvent(SupportTimeStartEndA.Make("E1", "2002-05-30 8:59:59.999", 0));
            EPAssertionUtil.AssertPropsAllValuesSame(_listener.AssertOneGetNewAndReset(), fieldsConstants, false);

            _epService.EPRuntime.SendEvent(SupportTimeStartEndA.Make("E2", "2002-05-30 9:00:00.000", 0));
            EPAssertionUtil.AssertPropsAllValuesSame(_listener.AssertOneGetNewAndReset(), fieldsConstants, true);

            _epService.EPRuntime.SendEvent(SupportTimeStartEndA.Make("E2", "2002-05-30 9:00:05.000", 0));
            EPAssertionUtil.AssertPropsAllValuesSame(_listener.AssertOneGetNewAndReset(), fieldsConstants, true);

            _epService.EPRuntime.SendEvent(SupportTimeStartEndA.Make("E2", "2002-05-30 9:00:59.999", 0));
            EPAssertionUtil.AssertPropsAllValuesSame(_listener.AssertOneGetNewAndReset(), fieldsConstants, true);

            _epService.EPRuntime.SendEvent(SupportTimeStartEndA.Make("E2", "2002-05-30 9:01:00.000", 0));
            EPAssertionUtil.AssertPropsAllValuesSame(_listener.AssertOneGetNewAndReset(), fieldsConstants, true);

            _epService.EPRuntime.SendEvent(SupportTimeStartEndA.Make("E2", "2002-05-30 9:01:00.001", 0));
            EPAssertionUtil.AssertPropsAllValuesSame(_listener.AssertOneGetNewAndReset(), fieldsConstants, false);

            stmtConstants.Dispose();
        }
示例#2
0
            public void Run(RegressionEnvironment env)
            {
                var startTime = "2002-05-30T09:00:00.000";
                env.AdvanceTime(DateTimeParsingFunctions.ParseDefaultMSec(startTime));

                var fieldsCurrentTs = new [] { "val0","val1","val2","val3","val4","val5","val6","val7" };
                var eplCurrentTS = "@Name('s0') select " +
                                   "current_timestamp.after(LongdateStart) as val0, " +
                                   "current_timestamp.between(LongdateStart, LongdateEnd) as val1, " +
                                   "current_timestamp.between(DateTimeStart, DateTimeExEnd) as val2, " +
                                   "current_timestamp.between(DateTimeExStart, DateTimeEnd) as val3, " +
                                   "current_timestamp.between(DateTimeStart, DateTimeEnd) as val4, " +
                                   "current_timestamp.between(DateTimeExStart, DateTimeExEnd) as val5, " +
                                   "current_timestamp.between(DateTimeExEnd, DateTimeExStart) as val6, " +
                                   "current_timestamp.between(DateTimeOffsetStart, DateTimeOffsetEnd) as val7 " +
                                   "from SupportTimeStartEndA";
                env.CompileDeploy(eplCurrentTS).AddListener("s0");
                LambdaAssertionUtil.AssertTypesAllSame(env.Statement("s0").EventType, fieldsCurrentTs, typeof(bool?));

                env.SendEventBean(SupportTimeStartEndA.Make("E1", "2002-05-30T08:59:59.999", 0));
                EPAssertionUtil.AssertProps(
                    env.Listener("s0").AssertOneGetNewAndReset(),
                    fieldsCurrentTs,
                    new object[] {
                        true,  // LongdateStart (val0)
                        false, // LongdateStart - LongdateEnd
                        false, // DateTimeStart - DateTimeExEnd
                        false, // DateTimeExStart - DateTimeEnd
                        false, // DateTimeStart - DateTimeEnd
                        false, // DateTimeExStart - DateTimeExEnd
                        false, // DateTimeExEnd - DateTimeExStart
                        false  // DateTimeOffsetStart - DateTimeOffsetEnd
                    });

                env.SendEventBean(SupportTimeStartEndA.Make("E1", "2002-05-30T08:59:59.999", 1));
                EPAssertionUtil.AssertProps(
                    env.Listener("s0").AssertOneGetNewAndReset(),
                    fieldsCurrentTs,
                    new object[] {
                        true, // LongdateStart (val0)
                        true, // LongdateStart - LongdateEnd
                        true, // DateTimeStart - DateTimeExEnd
                        true, // DateTimeExStart - DateTimeEnd
                        true, // DateTimeStart - DateTimeEnd
                        true, // DateTimeExStart - DateTimeExEnd
                        true, // DateTimeExEnd - DateTimeExStart
                        true  // DateTimeOffsetStart - DateTimeOffsetEnd
                    });

                env.SendEventBean(SupportTimeStartEndA.Make("E1", "2002-05-30T08:59:59.999", 100));
                EPAssertionUtil.AssertProps(
                    env.Listener("s0").AssertOneGetNewAndReset(),
                    fieldsCurrentTs,
                    new object[] {
                        true, // LongdateStart (val0)
                        true, // LongdateStart - LongdateEnd
                        true, // DateTimeStart - DateTimeExEnd
                        true, // DateTimeExStart - DateTimeEnd
                        true, // DateTimeStart - DateTimeEnd
                        true, // DateTimeExStart - DateTimeExEnd
                        true, // DateTimeExEnd - DateTimeExStart
                        true  // DateTimeOffsetStart - DateTimeOffsetEnd
                    });

                env.SendEventBean(SupportTimeStartEndA.Make("E1", "2002-05-30T09:00:00.000", 0));
                EPAssertionUtil.AssertProps(
                    env.Listener("s0").AssertOneGetNewAndReset(),
                    fieldsCurrentTs,
                    new object[] {
                        false, // LongdateStart (val0)
                        true, // LongdateStart - LongdateEnd
                        true, // DateTimeStart - DateTimeExEnd
                        true, // DateTimeExStart - DateTimeEnd
                        true, // DateTimeStart - DateTimeEnd
                        true, // DateTimeExStart - DateTimeExEnd
                        true, // DateTimeExEnd - DateTimeExStart
                        true  // DateTimeOffsetStart - DateTimeOffsetEnd
                    });

                env.SendEventBean(SupportTimeStartEndA.Make("E1", "2002-05-30T09:00:00.000", 100));
                EPAssertionUtil.AssertProps(
                    env.Listener("s0").AssertOneGetNewAndReset(),
                    fieldsCurrentTs,
                    new object[] {
                        false, // LongdateStart (val0)
                        true, // LongdateStart - LongdateEnd
                        true, // DateTimeStart - DateTimeExEnd
                        true, // DateTimeExStart - DateTimeEnd
                        true, // DateTimeStart - DateTimeEnd
                        true, // DateTimeExStart - DateTimeExEnd
                        true, // DateTimeExEnd - DateTimeExStart
                        true  // DateTimeOffsetStart - DateTimeOffsetEnd
                    });

                env.SendEventBean(SupportTimeStartEndA.Make("E1", "2002-05-30T09:00:00.001", 100));
                EPAssertionUtil.AssertProps(
                    env.Listener("s0").AssertOneGetNewAndReset(),
                    fieldsCurrentTs,
                    new object[] {
                        false, // LongdateStart (val0)
                        false, // LongdateStart - LongdateEnd
                        false, // DateTimeStart - DateTimeExEnd
                        false, // DateTimeExStart - DateTimeEnd
                        false, // DateTimeStart - DateTimeEnd
                        false, // DateTimeExStart - DateTimeExEnd
                        false, // DateTimeExEnd - DateTimeExStart
                        false  // DateTimeOffsetStart - DateTimeOffsetEnd
                    });
                env.UndeployAll();

                // test calendar field and constants
                var fieldsConstants = new [] { "val0","val1","val2","val3","val4" };
                var eplConstants = "@Name('s0') select " +
                                   "LongdateStart.between(DateTimeParsingFunctions.ParseDefaultEx('2002-05-30T09:00:00.000'), DateTimeParsingFunctions.ParseDefaultEx('2002-05-30T09:01:00.000')) as val0, " +
                                   "DateTimeStart.between(DateTimeParsingFunctions.ParseDefaultEx('2002-05-30T09:00:00.000'), DateTimeParsingFunctions.ParseDefaultEx('2002-05-30T09:01:00.000')) as val1, " +
                                   "DateTimeExStart.between(DateTimeParsingFunctions.ParseDefaultEx('2002-05-30T09:00:00.000'), DateTimeParsingFunctions.ParseDefaultEx('2002-05-30T09:01:00.000')) as val2, " +
                                   "DateTimeOffsetStart.between(DateTimeParsingFunctions.ParseDefaultEx('2002-05-30T09:00:00.000'), DateTimeParsingFunctions.ParseDefaultEx('2002-05-30T09:01:00.000')) as val3, " +
                                   "LongdateStart.between(DateTimeParsingFunctions.ParseDefaultEx('2002-05-30T09:01:00.000'), DateTimeParsingFunctions.ParseDefaultEx('2002-05-30T09:00:00.000')) as val4 " +
                                   "from SupportTimeStartEndA";
                env.CompileDeployAddListenerMile(eplConstants, "s0", 1);
                LambdaAssertionUtil.AssertTypesAllSame(env.Statement("s0").EventType, fieldsConstants, typeof(bool?));

                env.SendEventBean(SupportTimeStartEndA.Make("E1", "2002-05-30T08:59:59.999", 0));
                EPAssertionUtil.AssertPropsAllValuesSame(
                    env.Listener("s0").AssertOneGetNewAndReset(),
                    fieldsConstants,
                    false);

                env.SendEventBean(SupportTimeStartEndA.Make("E2", "2002-05-30T09:00:00.000", 0));
                EPAssertionUtil.AssertPropsAllValuesSame(
                    env.Listener("s0").AssertOneGetNewAndReset(),
                    fieldsConstants,
                    true);

                env.SendEventBean(SupportTimeStartEndA.Make("E2", "2002-05-30T09:00:05.000", 0));
                EPAssertionUtil.AssertPropsAllValuesSame(
                    env.Listener("s0").AssertOneGetNewAndReset(),
                    fieldsConstants,
                    true);

                env.SendEventBean(SupportTimeStartEndA.Make("E2", "2002-05-30T09:00:59.999", 0));
                EPAssertionUtil.AssertPropsAllValuesSame(
                    env.Listener("s0").AssertOneGetNewAndReset(),
                    fieldsConstants,
                    true);

                env.SendEventBean(SupportTimeStartEndA.Make("E2", "2002-05-30T09:01:00.000", 0));
                EPAssertionUtil.AssertPropsAllValuesSame(
                    env.Listener("s0").AssertOneGetNewAndReset(),
                    fieldsConstants,
                    true);

                env.SendEventBean(SupportTimeStartEndA.Make("E2", "2002-05-30T09:01:00.001", 0));
                EPAssertionUtil.AssertPropsAllValuesSame(
                    env.Listener("s0").AssertOneGetNewAndReset(),
                    fieldsConstants,
                    false);

                env.UndeployAll();
            }
示例#3
0
        private static void TryAssertionExcludeEndpoints(
            RegressionEnvironment env,
            RegressionPath path,
            string fields,
            AtomicLong milestone)
        {
            var fieldsCurrentTs = new [] { "val0","val1","val2","val3","val4","val5","val6","val7" };
            var eplCurrentTS = "@Name('s0') select " +
                               "current_timestamp.between(" + fields + ", true, true) as val0, " +
                               "current_timestamp.between(" + fields + ", true, false) as val1, " +
                               "current_timestamp.between(" + fields + ", false, true) as val2, " + 
                               "current_timestamp.between(" + fields + ", false, false) as val3, " +
                               "current_timestamp.between(" + fields + ", VAR_TRUE, VAR_TRUE) as val4, " +
                               "current_timestamp.between(" + fields + ", VAR_TRUE, VAR_FALSE) as val5, " +
                               "current_timestamp.between(" + fields + ", VAR_FALSE, VAR_TRUE) as val6, " +
                               "current_timestamp.between(" + fields + ", VAR_FALSE, VAR_FALSE) as val7 " +
                               "from SupportTimeStartEndA";
            env.CompileDeploy(eplCurrentTS, path).AddListener("s0");
            LambdaAssertionUtil.AssertTypesAllSame(env.Statement("s0").EventType, fieldsCurrentTs, typeof(bool?));

            env.SendEventBean(SupportTimeStartEndA.Make("E1", "2002-05-30T08:59:59.999", 0));
            EPAssertionUtil.AssertPropsAllValuesSame(
                env.Listener("s0").AssertOneGetNewAndReset(),
                fieldsCurrentTs,
                false);

            env.SendEventBean(SupportTimeStartEndA.Make("E1", "2002-05-30T08:59:59.999", 1));
            EPAssertionUtil.AssertProps(
                env.Listener("s0").AssertOneGetNewAndReset(),
                fieldsCurrentTs,
                new object[] {true, false, true, false, true, false, true, false});

            env.MilestoneInc(milestone);

            env.SendEventBean(SupportTimeStartEndA.Make("E1", "2002-05-30T08:59:59.999", 2));
            EPAssertionUtil.AssertPropsAllValuesSame(
                env.Listener("s0").AssertOneGetNewAndReset(),
                fieldsCurrentTs,
                true);

            env.SendEventBean(SupportTimeStartEndA.Make("E1", "2002-05-30T09:00:00.000", 1));
            EPAssertionUtil.AssertProps(
                env.Listener("s0").AssertOneGetNewAndReset(),
                fieldsCurrentTs,
                new object[] {true, true, false, false, true, true, false, false});

            env.UndeployModuleContaining("s0");

            // test calendar field and constants
            var fieldsConstants = new [] { "val0","val1","val2","val3" };
            var eplConstants = "@Name('s0') select " +
                               "LongdateStart.between(DateTimeParsingFunctions.ParseDefaultEx('2002-05-30T09:00:00.000'), DateTimeParsingFunctions.ParseDefaultEx('2002-05-30T09:01:00.000'), true, true) as val0, " +
                               "LongdateStart.between(DateTimeParsingFunctions.ParseDefaultEx('2002-05-30T09:00:00.000'), DateTimeParsingFunctions.ParseDefaultEx('2002-05-30T09:01:00.000'), true, false) as val1, " +
                               "LongdateStart.between(DateTimeParsingFunctions.ParseDefaultEx('2002-05-30T09:00:00.000'), DateTimeParsingFunctions.ParseDefaultEx('2002-05-30T09:01:00.000'), false, true) as val2, " +
                               "LongdateStart.between(DateTimeParsingFunctions.ParseDefaultEx('2002-05-30T09:00:00.000'), DateTimeParsingFunctions.ParseDefaultEx('2002-05-30T09:01:00.000'), false, false) as val3 " +
                               "from SupportTimeStartEndA";
            env.CompileDeploy(eplConstants).AddListener("s0");
            LambdaAssertionUtil.AssertTypesAllSame(env.Statement("s0").EventType, fieldsConstants, typeof(bool?));

            env.SendEventBean(SupportTimeStartEndA.Make("E1", "2002-05-30T08:59:59.999", 0));
            EPAssertionUtil.AssertProps(
                env.Listener("s0").AssertOneGetNewAndReset(),
                fieldsConstants,
                new object[] {false, false, false, false});

            env.SendEventBean(SupportTimeStartEndA.Make("E2", "2002-05-30T09:00:00.000", 0));
            EPAssertionUtil.AssertProps(
                env.Listener("s0").AssertOneGetNewAndReset(),
                fieldsConstants,
                new object[] {true, true, false, false});

            env.SendEventBean(SupportTimeStartEndA.Make("E2", "2002-05-30T09:00:05.000", 0));
            EPAssertionUtil.AssertProps(
                env.Listener("s0").AssertOneGetNewAndReset(),
                fieldsConstants,
                new object[] {true, true, true, true});

            env.MilestoneInc(milestone);

            env.SendEventBean(SupportTimeStartEndA.Make("E2", "2002-05-30T09:00:59.999", 0));
            EPAssertionUtil.AssertProps(
                env.Listener("s0").AssertOneGetNewAndReset(),
                fieldsConstants,
                new object[] {true, true, true, true});

            env.SendEventBean(SupportTimeStartEndA.Make("E2", "2002-05-30T09:01:00.000", 0));
            EPAssertionUtil.AssertProps(
                env.Listener("s0").AssertOneGetNewAndReset(),
                fieldsConstants,
                new object[] {true, false, true, false});

            env.SendEventBean(SupportTimeStartEndA.Make("E2", "2002-05-30T09:01:00.001", 0));
            EPAssertionUtil.AssertProps(
                env.Listener("s0").AssertOneGetNewAndReset(),
                fieldsConstants,
                new object[] {false, false, false, false});

            env.UndeployModuleContaining("s0");
        }
示例#4
0
        private void RunAssertionIncludeEndpoints(EPServiceProvider epService)
        {
            string startTime = "2002-05-30T09:00:00.000";

            epService.EPRuntime.SendEvent(new CurrentTimeEvent(DateTimeParser.ParseDefaultMSec(startTime)));

            string[] fieldsCurrentTs = "val0,val1,val2,val3,val4,val5,val6".Split(',');
            string   eplCurrentTS    = "select " +
                                       "current_timestamp.after(longdateStart) as val0, " +
                                       "current_timestamp.between(longdateStart, longdateEnd) as val1, " +
                                       "current_timestamp.between(utildateStart, caldateEnd) as val2, " +
                                       "current_timestamp.between(caldateStart, utildateEnd) as val3, " +
                                       "current_timestamp.between(utildateStart, utildateEnd) as val4, " +
                                       "current_timestamp.between(caldateStart, caldateEnd) as val5, " +
                                       "current_timestamp.between(caldateEnd, caldateStart) as val6 " +
                                       "from SupportTimeStartEndA";
            EPStatement stmtCurrentTs = epService.EPAdministrator.CreateEPL(eplCurrentTS);
            var         listener      = new SupportUpdateListener();

            stmtCurrentTs.Events += listener.Update;
            LambdaAssertionUtil.AssertTypesAllSame(stmtCurrentTs.EventType, fieldsCurrentTs, typeof(bool?));

            epService.EPRuntime.SendEvent(SupportTimeStartEndA.Make("E1", "2002-05-30T08:59:59.999", 0));
            EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fieldsCurrentTs, new object[] {
                true, false, false, false, false, false, false
            });

            epService.EPRuntime.SendEvent(SupportTimeStartEndA.Make("E1", "2002-05-30T08:59:59.999", 1));
            EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fieldsCurrentTs, new object[] {
                true, true, true, true, true, true, true
            });

            epService.EPRuntime.SendEvent(SupportTimeStartEndA.Make("E1", "2002-05-30T08:59:59.999", 100));
            EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fieldsCurrentTs, new object[] {
                true, true, true, true, true, true, true
            });

            epService.EPRuntime.SendEvent(SupportTimeStartEndA.Make("E1", "2002-05-30T09:00:00.000", 0));
            EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fieldsCurrentTs, new object[] {
                false, true, true, true, true, true, true
            });

            epService.EPRuntime.SendEvent(SupportTimeStartEndA.Make("E1", "2002-05-30T09:00:00.000", 100));
            EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fieldsCurrentTs, new object[] {
                false, true, true, true, true, true, true
            });

            epService.EPRuntime.SendEvent(SupportTimeStartEndA.Make("E1", "2002-05-30T09:00:00.001", 100));
            EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fieldsCurrentTs, new object[] {
                false, false, false, false, false, false, false
            });
            stmtCurrentTs.Dispose();

            // test calendar field and constants
            epService.EPAdministrator.Configuration.AddImport(typeof(DateTime));
            string[] fieldsConstants = "val0,val1,val2,val5".Split(',');
            string   eplConstants    = "select " +
                                       "longdateStart.between(DateTimeParser.ParseDefault('2002-05-30T09:00:00.000'), DateTimeParser.ParseDefault('2002-05-30T09:01:00.000')) as val0, " +
                                       "utildateStart.between(DateTimeParser.ParseDefault('2002-05-30T09:00:00.000'), DateTimeParser.ParseDefault('2002-05-30T09:01:00.000')) as val1, " +
                                       "caldateStart.between(DateTimeParser.ParseDefault('2002-05-30T09:00:00.000'), DateTimeParser.ParseDefault('2002-05-30T09:01:00.000')) as val2, " +
                                       "longdateStart.between(DateTimeParser.ParseDefault('2002-05-30T09:01:00.000'), DateTimeParser.ParseDefault('2002-05-30T09:00:00.000')) as val5 " +
                                       "from SupportTimeStartEndA";
            EPStatement stmtConstants = epService.EPAdministrator.CreateEPL(eplConstants);

            stmtConstants.Events += listener.Update;
            LambdaAssertionUtil.AssertTypesAllSame(stmtConstants.EventType, fieldsConstants, typeof(bool?));

            epService.EPRuntime.SendEvent(SupportTimeStartEndA.Make("E1", "2002-05-30T08:59:59.999", 0));
            EPAssertionUtil.AssertPropsAllValuesSame(listener.AssertOneGetNewAndReset(), fieldsConstants, false);

            epService.EPRuntime.SendEvent(SupportTimeStartEndA.Make("E2", "2002-05-30T09:00:00.000", 0));
            EPAssertionUtil.AssertPropsAllValuesSame(listener.AssertOneGetNewAndReset(), fieldsConstants, true);

            epService.EPRuntime.SendEvent(SupportTimeStartEndA.Make("E2", "2002-05-30T09:00:05.000", 0));
            EPAssertionUtil.AssertPropsAllValuesSame(listener.AssertOneGetNewAndReset(), fieldsConstants, true);

            epService.EPRuntime.SendEvent(SupportTimeStartEndA.Make("E2", "2002-05-30T09:00:59.999", 0));
            EPAssertionUtil.AssertPropsAllValuesSame(listener.AssertOneGetNewAndReset(), fieldsConstants, true);

            epService.EPRuntime.SendEvent(SupportTimeStartEndA.Make("E2", "2002-05-30T09:01:00.000", 0));
            EPAssertionUtil.AssertPropsAllValuesSame(listener.AssertOneGetNewAndReset(), fieldsConstants, true);

            epService.EPRuntime.SendEvent(SupportTimeStartEndA.Make("E2", "2002-05-30T09:01:00.001", 0));
            EPAssertionUtil.AssertPropsAllValuesSame(listener.AssertOneGetNewAndReset(), fieldsConstants, false);

            stmtConstants.Dispose();
        }