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();
}
