private void AssertParse( string text, long?expectedNumRepeats, string expectedDate, TimePeriod expectedTimePeriod) { var spec = TimerScheduleISO8601Parser.Parse(text); Assert.AreEqual(expectedNumRepeats, spec.OptionalRepeatCount); if (expectedTimePeriod == null) { Assert.IsNull(spec.OptionalTimePeriod); } else { Assert.AreEqual( expectedTimePeriod, spec.OptionalTimePeriod, "expected '" + expectedTimePeriod.ToStringISO8601() + "' got '" + spec.OptionalTimePeriod.ToStringISO8601() + "'"); } if (expectedDate == null) { Assert.IsNull(spec.OptionalDate); } else { Assert.AreEqual(DateTimeParsingFunctions.ParseDefaultMSecWZone(expectedDate), spec.OptionalDate.UtcMillis); } }
private static void AdvanceTime( RegressionEnvironment env, string stageUri, string time) { env.AdvanceTimeStage(stageUri, DateTimeParsingFunctions.ParseDefaultMSec(time)); }
public void CheckCorrectWZone( ScheduleSpec spec, string nowWZone, string expectedWZone) { var nowDate = DateTimeParsingFunctions.ParseDefaultMSecWZone(nowWZone); var expectedDate = DateTimeParsingFunctions.ParseDefaultMSecWZone(expectedWZone); var result = ScheduleComputeHelper.ComputeNextOccurance( spec, nowDate, TimeZoneInfo.Utc, TimeAbacusMilliseconds.INSTANCE); var resultDate = DateTimeEx.GetInstance(TimeZoneInfo.Utc, result); if (result != expectedDate) { Log.Debug( ".checkCorrect Difference in result found, spec=" + spec); Log.Debug( ".checkCorrect now=" + timeFormat.Format(nowDate.TimeFromMillis()) + " long=" + nowDate); Log.Debug( ".checkCorrect expected=" + timeFormat.Format(expectedDate.TimeFromMillis()) + " long=" + expectedDate); Log.Debug( ".checkCorrect result=" + timeFormat.Format(resultDate) + " long=" + resultDate.UtcMillis); Assert.IsTrue(false); } }
private static void TryDatetime( RegressionEnvironment env, string dialect) { var dayOfWeek = (int) DayOfWeek.Thursday; var msecDate = DateTimeParsingFunctions.ParseDefaultMSec("2002-05-30T09:00:00.000"); var expression = $"expression long {dialect}:callIt() [return {msecDate}]"; var epl = $"@Name('s0') {expression} select callIt().getHourOfDay() as val0, callIt().getDayOfWeek() as val1 from SupportBean"; env.CompileDeploy(epl).AddListener("s0"); Assert.AreEqual(typeof(int?), env.Statement("s0").EventType.GetPropertyType("val0")); env.SendEventBean(new SupportBean()); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), new[] {"val0", "val1"}, new object[] {9, dayOfWeek}); env.UndeployAll(); env.EplToModelCompileDeploy(epl).AddListener("s0"); env.SendEventBean(new SupportBean()); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), new[] {"val0", "val1"}, new object[] {9, dayOfWeek}); env.UndeployAll(); }
public static object GetValueCoerced( string expectedTime, string format) { var msec = DateTimeParsingFunctions.ParseDefaultMSec(expectedTime); return Coerce(msec, format); }
private static void SendCurrentTimeWithMinus( RegressionEnvironment env, string time, long minus) { env.AdvanceTime(DateTimeParsingFunctions.ParseDefaultMSec(time) - minus); }
public void Run(RegressionEnvironment env) { var point = typeof(Point); var epl = "@public @buseventtype " + "@JsonSchemaField(Name=point, adapter=" + nameof(SupportJsonFieldAdapterStringPoint) + ") " + "@JsonSchemaField(Name=mydate, adapter=" + nameof(SupportJsonFieldAdapterStringDate) + ") " + "create json schema JsonEvent(point " + point + ", mydate DateTime);\n" + "@Name('s0') select point, mydate from JsonEvent;\n" + "@Name('s1') select * from JsonEvent;\n"; env.CompileDeploy(epl).AddListener("s0").AddListener("s1"); var jsonFilled = "{\"point\":\"7,14\",\"mydate\":\"2002-05-01T08:00:01.999\"}"; SendAssert( env, jsonFilled, new object[] { new Point(7, 14), DateTimeParsingFunctions.ParseDefaultEx("2002-05-1T08:00:01.999") }); var jsonNulled = "{\"point\":null,\"mydate\":null}"; SendAssert( env, jsonNulled, new object[] { null, null }); env.UndeployAll(); }
public void Run(RegressionEnvironment env) { var startTime = "2002-05-30T09:00:00.000"; env.AdvanceTime(DateTimeParsingFunctions.ParseDefaultMSec(startTime)); var sdfPattern = "yyyy.MM.dd G 'at' HH:mm:ss"; var sdf = new SimpleDateFormat(sdfPattern); var fields = new [] { "val0","val1","val2","val3" }; var eplFragment = "@Name('s0') select " + "DateTimeEx.format(\"" + sdfPattern + "\") as val0," + "DateTimeOffset.format(\"" + sdfPattern + "\") as val1," + "DateTime.format(\"" + sdfPattern + "\") as val2," + "LongDate.format(\"" + sdfPattern + "\") as val3" + " from SupportDateTime"; env.CompileDeploy(eplFragment).AddListener("s0"); LambdaAssertionUtil.AssertTypesAllSame(env.Statement("s0").EventType, fields, typeof(string)); var sdt = SupportDateTime.Make(startTime); env.SendEventBean(SupportDateTime.Make(startTime)); var received = env.Listener("s0").AssertOneGetNewAndReset(); Assert.That(received.Get("val0"), Is.EqualTo(sdf.Format(sdt.DateTimeEx))); Assert.That(received.Get("val1"), Is.EqualTo(sdf.Format(sdt.DateTimeOffset))); Assert.That(received.Get("val2"), Is.EqualTo(sdf.Format(sdt.DateTime))); Assert.That(received.Get("val3"), Is.EqualTo(sdf.Format(sdt.LongDate))); env.SendEventBean(SupportDateTime.Make(null)); received = env.Listener("s0").AssertOneGetNewAndReset(); Assert.That(received.Get("val0"), Is.Null); Assert.That(received.Get("val1"), Is.Null); Assert.That(received.Get("val2"), Is.Null); Assert.That(received.Get("val3"), Is.Null); env.UndeployAll(); }
public static SupportEventIdWithTimestamp MakeTime( string id, string mytime) { var msec = DateTimeParsingFunctions.ParseDefaultMSec("2002-05-1T" + mytime); return new SupportEventIdWithTimestamp(id, msec); }
public SupportStartTSEndTSImpl( string datestr, long duration) { StartTS = DateTimeParsingFunctions.ParseDefaultMSec(datestr); EndTS = StartTS + duration; }
private static long ParseWithMicro(string startTime) { string[] parts = startTime.Split('u'); long millis = DateTimeParsingFunctions.ParseDefaultMSec(parts[0]); int micro = Int32.Parse(parts[1]); return 1000 * millis + micro; }
protected SupportTimeStartBase( string key, string datestr, long duration) { Key = key; if (datestr != null) { // expected : 2002-05-30T09:00:00.000 var start = DateTimeParsingFunctions.ParseDefaultEx(datestr); DateTimeExStart = start; DateTimeOffsetStart = DateTimeExStart.DateTime; DateTimeStart = DateTimeOffsetStart.DateTime; LongdateStart = start.UtcMillis; var end = start.Clone().AddTimeSpan(TimeSpan.FromMilliseconds(duration)); DateTimeExEnd = end; DateTimeOffsetEnd = DateTimeExEnd.DateTime; DateTimeEnd = DateTimeOffsetEnd.DateTime; LongdateEnd = end.UtcMillis; #if false Console.WriteLine("DateTimeExStart: " + DateTimeExStart + " / " + DateTimeExStart.Millisecond); Console.WriteLine("DateTimeOffsetStart: " + DateTimeOffsetStart + " / " + DateTimeOffsetStart.Millisecond); Console.WriteLine("DateTimeStart: " + DateTimeStart + " / " + DateTimeStart.Millisecond); Console.WriteLine("DateTimeExEnd: " + DateTimeExEnd + " / " + DateTimeExEnd.Millisecond); Console.WriteLine("DateTimeOffsetEnd: " + DateTimeOffsetEnd + " / " + DateTimeOffsetEnd.Millisecond); Console.WriteLine("DateTimeEnd: " + DateTimeEnd + " / " + DateTimeEnd.Millisecond); #endif } }
public static DateTimeEx GetThe1980Calendar() { var dateTimeEx = DateTimeEx.GetInstance( TimeZoneHelper.GetTimeZoneInfo("GMT-0:00"), DateTimeParsingFunctions.ParseDefaultMSecWZone("1980-01-01T00:0:0.000GMT-0:00")); return dateTimeEx; }
public void Run(RegressionEnvironment env) { var epl = "@public @buseventtype create schema LocalEvent as " + typeof(LocalEvent).FullName + ";\n" + "@JsonSchemaField(Name=mydate, adapter=" + nameof(SupportJsonFieldAdapterStringDate) + ") " + "@JsonSchemaField(Name=point, adapter=" + nameof(SupportJsonFieldAdapterStringPoint) + ") " + EventRepresentationChoice.JSON.GetAnnotationText() + " insert into JsonEvent select point, mydate from LocalEvent;\n" + "@Name('s0') select point, mydate from JsonEvent;\n" + "@Name('s1') select * from JsonEvent;\n"; env.CompileDeploy(epl).AddListener("s0").AddListener("s1"); env.SendEventBean( new LocalEvent( new Point(7, 14), DateTimeParsingFunctions.ParseDefaultEx("2002-05-01T08:00:01.999"))); var jsonFilled = "{\"point\":\"7,14\",\"mydate\":\"2002-05-01T08:00:01.999\"}"; DoAssert( env, jsonFilled, new object[] { new Point(7, 14), DateTimeParsingFunctions.ParseDefaultEx("2002-05-1T08:00:01.999") }); env.UndeployAll(); }
public void TestDateFormat() { // no date format specified var testtime = DateTimeParsingFunctions.ParseDefaultMSec("2012-01-30T08:43:32.116"); var graph = "create dataflow ReadCSV " + "FileSource -> mystream<MyOAType> { file: '../../../etc/regression/dateprocessing_one.csv', hasTitleLine: false}" + "DefaultSupportCaptureOp(mystream) {}"; var received = RunDataFlow(graph); Assert.AreEqual(1, received.Count); var data = (object[])received[0][0]; Assert.AreEqual(testtime, ((DateTime)data[0]).UtcMillis()); Assert.AreEqual(testtime, ((DateTimeEx)data[1]).UtcMillis); // with date format specified var testTimeOffset = DateTimeOffset.ParseExact( "20120320084332000", new string[] { "yyyyMMddHHmmssfff" }, CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces | DateTimeStyles.AssumeUniversal); testtime = testTimeOffset.UtcMillis(); graph = "create dataflow ReadCSV " + "FileSource -> mystream<MyOAType> { file: '../../../etc/regression/dateprocessing_two.csv', hasTitleLine: false, dateFormat: 'yyyyMMddHHmmssfff'}" + "DefaultSupportCaptureOp(mystream) {}"; received = RunDataFlow(graph); Assert.AreEqual(1, received.Count); data = (object[])received[0][0]; Assert.AreEqual(testtime, ((DateTime)data[0]).UtcMillis()); Assert.AreEqual(testtime, ((DateTimeEx)data[1]).UtcMillis); }
public void Run(RegressionEnvironment env) { var time = DateTimeParsingFunctions.ParseDefaultMSec("2002-05-30T09:05:06.007"); var dtxTime = DateTimeEx.GetInstance(TimeZoneInfo.Utc, time); var dtxMod = DateTimeEx.GetInstance(TimeZoneInfo.Utc, time) .SetHour(1) .SetMinute(2) .SetSecond(3) .SetMillis(4); var select = "LongDate.withTime(1, 2, 3, 4) as c0," + "LongDate.set('hour', 1).set('minute', 2).set('second', 3).set('millisecond', 4).toDateTimeEx() as c1," + "LongDate.get('month') as c2," + "current_timestamp.get('month') as c3," + "current_timestamp.getMinuteOfHour() as c4," + "current_timestamp.toDateTime() as c5," + "current_timestamp.toDateTimeEx() as c6," + "current_timestamp.minus(1) as c7"; var fields = new [] { "c0", "c1", "c2", "c3", "c4", "c5", "c6", "c7" }; if (!isMicrosecond) { RunAssertionLongProperty( env, time, new SupportDateTime(time, null, null, null), select, fields, new object[] { dtxMod.UtcMillis, // c0 dtxMod, // c1 (dtx) 5, // c2 (month) 5, // c3 (month) 5, // c4 (month) dtxTime.DateTime.DateTime, // c5 (dateTime) dtxTime, // c6 (dateTimeEx) time - 1 // c7 }); } else { RunAssertionLongProperty( env, time * 1000, new SupportDateTime(time * 1000 + 123, null, null, null), select, fields, new object[] { dtxMod.UtcMillis * 1000 + 123, // c0 dtxMod, // c1 (dtx) 5, // c2 (month) 5, // c3 (month) 5, // c4 (month) dtxTime.DateTime.DateTime, // c5 (dateTime) dtxTime, // c6 (dateTimeEx) time * 1000 - 1000 // c7 }); } }
private static void SetCurrentTime( RegressionEnvironment env, string time) { var timestamp = "2002-05-30T" + time + ".000"; var current = DateTimeParsingFunctions.ParseDefaultMSec(timestamp); Console.Out.WriteLine("Advancing time to " + timestamp + " msec " + current); env.AdvanceTimeSpan(current); }
private static void RunAssertionISO8601Date( RegressionEnvironment env, AtomicLong milestone) { var epl = "@Name('s0') select " + "cast('1997-07-16T19:20:30Z',dtx,dateformat:'iso') as c0," + "cast('1997-07-16T19:20:30+01:00',dtx,dateformat:'iso') as c1," + "cast('1997-07-16T19:20:30',dtx,dateformat:'iso') as c2," + "cast('1997-07-16T19:20:30.45Z',dtx,dateformat:'iso') as c3," + "cast('1997-07-16T19:20:30.45+01:00',dtx,dateformat:'iso') as c4," + "cast('1997-07-16T19:20:30.45',dtx,dateformat:'iso') as c5," + "cast('1997-07-16T19:20:30.45',long,dateformat:'iso') as c6," + "cast('1997-07-16T19:20:30.45',datetime,dateformat:'iso') as c7," + "cast(TheString,dtx,dateformat:'iso') as c8," + "cast(TheString,long,dateformat:'iso') as c9," + "cast(TheString,datetime,dateformat:'iso') as c10," + "cast('1997-07-16T19:20:30.45',datetimeoffset,dateformat:'iso') as c11," + "cast('1997-07-16T19:20:30+01:00',datetime,dateformat:'iso') as c12," + "cast('1997-07-16',datetimeoffset,dateformat:'iso') as c13," + "cast('19:20:30',datetimeoffset,dateformat:'iso') as c14" + " from SupportBean"; env.CompileDeployAddListenerMile(epl, "s0", milestone.GetAndIncrement()); env.SendEventBean(new SupportBean()); var @event = env.Listener("s0").AssertOneGetNewAndReset(); SupportDateTimeUtil.CompareDate((DateTimeEx)@event.Get("c0"), 1997, 7, 16, 19, 20, 30, 0, "UTC"); SupportDateTimeUtil.CompareDate((DateTimeEx)@event.Get("c1"), 1997, 7, 16, 19, 20, 30, 0, "GMT+01:00"); SupportDateTimeUtil.CompareDate((DateTimeEx)@event.Get("c2"), 1997, 7, 16, 19, 20, 30, 0, "UTC"); SupportDateTimeUtil.CompareDate((DateTimeEx)@event.Get("c3"), 1997, 7, 16, 19, 20, 30, 450, "UTC"); SupportDateTimeUtil.CompareDate((DateTimeEx)@event.Get("c4"), 1997, 7, 16, 19, 20, 30, 450, "GMT+01:00"); SupportDateTimeUtil.CompareDate((DateTimeEx)@event.Get("c5"), 1997, 7, 16, 19, 20, 30, 450, "UTC"); Assert.That(@event.Get("c6"), Is.InstanceOf <long>()); Assert.That(@event.Get("c7"), Is.InstanceOf <DateTime>()); foreach (var prop in "c8,c9,c10".SplitCsv()) { Assert.IsNull(@event.Get(prop)); } var isoDateTimeFormat = DateTimeFormat.ISO_DATE_TIME; var expectedC11 = isoDateTimeFormat.Parse("1997-07-16T19:20:30.45").DateTime; var expectedC12 = isoDateTimeFormat.Parse("1997-07-16T19:20:30+01:00").DateTime.DateTime; var expectedC13 = DateTimeParsingFunctions.ParseDefault("1997-07-16"); var expectedC14 = DateTimeParsingFunctions.ParseDefault("19:20:30"); Assert.That(@event.Get("c11"), Is.EqualTo(expectedC11)); Assert.That(@event.Get("c12"), Is.EqualTo(expectedC12)); Assert.That(@event.Get("c13"), Is.EqualTo(expectedC13)); Assert.That(@event.Get("c14"), Is.EqualTo(expectedC14)); env.UndeployAll(); }
public void Run(RegressionEnvironment env) { var time = DateTimeParsingFunctions.ParseDefaultMSec("2002-05-30T09:00:00.000"); if (!isMicrosecond) { RunAssertionEventTime(env, time, time); } else { RunAssertionEventTime(env, time * 1000, time * 1000); } }
private void TryAssertionCreateSchema( RegressionEnvironment env, EventRepresentationChoice eventRepresentationEnum) { var startA = "2002-05-30T09:00:00.000"; var endA = "2002-05-30T09:00:01.000"; var startB = "2002-05-30T09:00:00.500"; var endB = "2002-05-30T09:00:00.700"; // test Map type Long-type timestamps RunAssertionCreateSchemaWTypes<MyLocalJsonProvidedLong>( env, eventRepresentationEnum, "long", DateTimeParsingFunctions.ParseDefaultMSec(startA), DateTimeParsingFunctions.ParseDefaultMSec(endA), DateTimeParsingFunctions.ParseDefaultMSec(startB), DateTimeParsingFunctions.ParseDefaultMSec(endB)); // test Map type DateTimeEx-type timestamps if (!eventRepresentationEnum.IsAvroOrJsonEvent()) { RunAssertionCreateSchemaWTypes<MyLocalJsonProvidedDateTimeEx>( env, eventRepresentationEnum, typeof(DateTimeEx).FullName, DateTimeParsingFunctions.ParseDefaultEx(startA), DateTimeParsingFunctions.ParseDefaultEx(endA), DateTimeParsingFunctions.ParseDefaultEx(startB), DateTimeParsingFunctions.ParseDefaultEx(endB)); } // test Map type DateTimeOffset-type timestamps if (!eventRepresentationEnum.IsAvroOrJsonEvent()) { RunAssertionCreateSchemaWTypes<MyLocalJsonProvidedDateTimeOffset>( env, eventRepresentationEnum, typeof(DateTimeOffset).FullName, DateTimeParsingFunctions.ParseDefaultDateTimeOffset(startA), DateTimeParsingFunctions.ParseDefaultDateTimeOffset(endA), DateTimeParsingFunctions.ParseDefaultDateTimeOffset(startB), DateTimeParsingFunctions.ParseDefaultDateTimeOffset(endB)); } // test Map type DateTime-type timestamps if (!eventRepresentationEnum.IsAvroOrJsonEvent()) { RunAssertionCreateSchemaWTypes<MyLocalJsonProvidedDateTime>( env, eventRepresentationEnum, typeof(DateTime).FullName, DateTimeParsingFunctions.ParseDefaultDateTimeOffset(startA).DateTime, DateTimeParsingFunctions.ParseDefaultDateTimeOffset(endA).DateTime, DateTimeParsingFunctions.ParseDefaultDateTimeOffset(startB).DateTime, DateTimeParsingFunctions.ParseDefaultDateTimeOffset(endB).DateTime); } }
private void AssertCompute(long current, TimePeriod timePeriod, string reference, LongAssertion factorAssertion, string expectedTarget) { var referenceDate = DateTimeParsingFunctions.ParseDefaultEx(reference); CalendarOpPlusFastAddResult result = CalendarOpPlusFastAddHelper.ComputeNextDue(current, timePeriod, referenceDate, TimeAbacusMilliseconds.INSTANCE, 0); Assert.That( result.Scheduled, Is.EqualTo(DateTimeParsingFunctions.ParseDefaultEx(expectedTarget))); factorAssertion.AssertLong(result.Factor); }
public static IList<RegressionExecution> WithWindowFlipTimer(IList<RegressionExecution> execs = null) { var currentTime = DateTimeParsingFunctions.ParseDefaultMSec("2002-05-1T08:00:01.999"); execs = execs ?? new List<RegressionExecution>(); execs.Add(new ViewTimeWindowFlipTimer(0, "1", 1000)); execs.Add(new ViewTimeWindowFlipTimer(123456789, "10", 123456789 + 10 * 1000)); execs.Add(new ViewTimeWindowFlipTimer(0, "1 months 10 milliseconds", TimePlusMonth(0, 1) + 10)); execs.Add(new ViewTimeWindowFlipTimer(currentTime, "1 months 50 milliseconds", TimePlusMonth(currentTime, 1) + 50)); return execs; }
public static object[] GetArrayCoerced( string expectedTime, params string[] desc) { var result = new object[desc.Length]; var msec = DateTimeParsingFunctions.ParseDefaultMSec(expectedTime); for (var i = 0; i < desc.Length; i++) { result[i] = Coerce(msec, desc[i]); } return result; }
private static void AssertReceivedAtTime( RegressionEnvironment env, string time) { var msec = DateTimeParsingFunctions.ParseDefaultMSecWZone(time); env.AdvanceTime(msec - 1); Assert.IsFalse(env.Listener("s0").IsInvokedAndReset()); env.AdvanceTime(msec); Assert.IsTrue(env.Listener("s0").IsInvokedAndReset(), "expected but not received at " + time); }
public static object[] GetArrayCoerced( string[] expectedTimes, string desc) { var result = new object[expectedTimes.Length]; for (var i = 0; i < expectedTimes.Length; i++) { var msec = DateTimeParsingFunctions.ParseDefaultMSec(expectedTimes[i]); result[i] = Coerce(msec, desc); } return result; }
private static object[] MakePopulateEvent() { return new object[] { "E1", DateTimeParsingFunctions.ParseDefaultMSec("2002-05-30T09:55:00.000"), // ts new MyBean(), // mb new[] {new MyBean(), new MyBean()}, // mbarr new object[] {"p0value"}, // me new[] { new object[] {"0_p0"}, new object[] {"1_p0"} } // mearr }; }
public static SupportDateTime Make(string datestr) { if (datestr == null) { return new SupportDateTime(null, null, null, null); } // expected : 2002-05-30T09:00:00 var dateTimeEx = DateTimeParsingFunctions.ParseDefaultEx(datestr); return new SupportDateTime( dateTimeEx.UtcMillis, dateTimeEx, dateTimeEx.UtcDateTime, dateTimeEx.UtcDateTime.DateTime); }
private static void RunSequence( RegressionEnvironment env, string[] times) { foreach (var next in times) { // send right-before time var nextLong = DateTimeParsingFunctions.ParseDefaultMSec(next); env.AdvanceTime(nextLong - 1001); Assert.IsFalse(env.Listener("s0").IsInvoked, "unexpected callback at " + next); // send right-after time env.AdvanceTime(nextLong + 1000); Assert.IsTrue(env.Listener("s0").GetAndClearIsInvoked(), "missing callback at " + next); } }
public static DateTimeEx ParseDate(string dateText) { try { return DateTimeParsingFunctions.ParseDefaultEx(dateText); //return javax.xml.datatype.DatatypeFactory.NewInstance().NewXMLGregorianCalendar(dateText) // .ToGregorianCalendar(); } catch (EPException) { throw; } catch (Exception e) { var message = "Exception parsing date '" + dateText + "', the date is not a supported ISO 8601 date"; log.Debug(message, e); throw new ScheduleParameterException(message); } }
public void Run(RegressionEnvironment env) { var epl = "@Name('s0') select rstream * from SupportBean#ext_timed(LongPrimitive, 1 month)"; env.CompileDeployAddListenerMileZero(epl, "s0"); SendExtTimeEvent(env, DateTimeParsingFunctions.ParseDefaultMSec("2002-02-01T09:00:00.000"), "E1"); SendExtTimeEvent(env, DateTimeParsingFunctions.ParseDefaultMSec("2002-03-01T09:00:00.000") - 1, "E2"); Assert.IsFalse(env.Listener("s0").IsInvoked); SendExtTimeEvent(env, DateTimeParsingFunctions.ParseDefaultMSec("2002-03-01T09:00:00.000"), "E3"); EPAssertionUtil.AssertProps( env.Listener("s0").AssertOneGetNewAndReset(), new[] {"TheString"}, new object[] {"E1"}); env.UndeployAll(); }