private void RunAssertionTypeValidProp(EPServiceProvider epService, string typeName, object underlying)
{
EventType eventType = epService.EPAdministrator.Configuration.GetEventType(typeName);
var expectedType = new[]
{
new object[] { "indexed", typeof(string[]), null, null },
new object[] { "mapped", typeof(StringMap), null, null }
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(expectedType, eventType, SupportEventTypeAssertionEnumExtensions.GetSetWithFragment());
EPAssertionUtil.AssertEqualsAnyOrder(new[] { "indexed", "mapped" }, eventType.PropertyNames);
Assert.IsNotNull(eventType.GetGetter("mapped"));
Assert.IsNotNull(eventType.GetGetter("mapped('a')"));
Assert.IsNotNull(eventType.GetGetter("indexed"));
Assert.IsNotNull(eventType.GetGetter("indexed[0]"));
Assert.IsTrue(eventType.IsProperty("mapped"));
Assert.IsTrue(eventType.IsProperty("mapped('a')"));
Assert.IsTrue(eventType.IsProperty("indexed"));
Assert.IsTrue(eventType.IsProperty("indexed[0]"));
Assert.AreEqual(typeof(StringMap), eventType.GetPropertyType("mapped"));
Assert.AreEqual(typeof(string), eventType.GetPropertyType("mapped('a')"));
Assert.AreEqual(typeof(string[]), eventType.GetPropertyType("indexed"));
Assert.AreEqual(typeof(string), eventType.GetPropertyType("indexed[0]"));
Assert.AreEqual(new EventPropertyDescriptor("indexed", typeof(string[]), typeof(string), false, false, true, false, false), eventType.GetPropertyDescriptor("indexed"));
Assert.AreEqual(new EventPropertyDescriptor("mapped", typeof(StringMap), typeof(string), false, false, false, true, false), eventType.GetPropertyDescriptor("mapped"));
Assert.IsNull(eventType.GetFragmentType("indexed"));
Assert.IsNull(eventType.GetFragmentType("mapped"));
}
private void RunAssertionExprSelectClauseRenderingUnnamedCol(EPServiceProvider epService)
{
epService.EPAdministrator.CreateEPL(
"create table varaggESC (" +
"key string primary key, theEvents window(*) @Type(SupportBean))");
var stmtSelect = epService.EPAdministrator.CreateEPL(
"select " +
"varaggESC.keys()," +
"varaggESC[p00].theEvents," +
"varaggESC[p00]," +
"varaggESC[p00].theEvents.last(*)," +
"varaggESC[p00].theEvents.window(*).take(1) from SupportBean_S0");
var expectedAggType = new object[][] {
new object[] { "varaggESC.keys()", typeof(object[]) },
new object[] { "varaggESC[p00].theEvents", typeof(SupportBean[]) },
new object[] { "varaggESC[p00]", typeof(Map) },
new object[] { "varaggESC[p00].theEvents.last(*)", typeof(SupportBean) },
new object[] { "varaggESC[p00].theEvents.window(*).take(1)", typeof(ICollection <SupportBean>) },
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(
expectedAggType, stmtSelect.EventType, SupportEventTypeAssertionEnum.NAME,
SupportEventTypeAssertionEnum.TYPE);
epService.EPAdministrator.DestroyAllStatements();
}
private static void RunAssertionType(
RegressionEnvironment env,
bool namedWindow)
{
var eplCreate = namedWindow
? "@Name('s0') create window MyInfra#keepall as (c0 int[], c1 int[primitive])"
: "@Name('s0') create table MyInfra (c0 int[], c1 int[primitive])";
env.CompileDeploy(eplCreate);
object[][] expectedType = {
new object[] {
"c0", typeof(int?[])
},
new object[] {
"c1", typeof(int[])
}
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(
expectedType,
env.Statement("s0").EventType,
SupportEventTypeAssertionEnum.NAME,
SupportEventTypeAssertionEnum.TYPE);
env.UndeployAll();
}
private void RunAssertionTypeValidProp(string typeName, FunctionSendEvent4Int send, Type nestedClass, string fragmentTypeName)
{
var eventType = _epService.EPAdministrator.Configuration.GetEventType(typeName);
var expectedType = new object[][] { new object[] { "l1", nestedClass, fragmentTypeName, false } };
SupportEventTypeAssertionUtil.AssertEventTypeProperties(expectedType, eventType, SupportEventTypeAssertionEnumExtensions.GetSetWithFragment());
EPAssertionUtil.AssertEqualsAnyOrder(new string[] { "l1" }, eventType.PropertyNames);
foreach (var prop in Collections.List("l1", "l1.lvl1", "l1.l2", "l1.l2.lvl2"))
{
Assert.IsNotNull(eventType.GetGetter(prop));
Assert.IsTrue(eventType.IsProperty(prop));
}
Assert.AreEqual(nestedClass, eventType.GetPropertyType("l1"));
foreach (var prop in Collections.List("l1.lvl1", "l1.l2.lvl2", "l1.l2.l3.lvl3"))
{
Assert.AreEqual(typeof(int?), TypeHelper.GetBoxedType(eventType.GetPropertyType(prop)));
}
var lvl1Fragment = eventType.GetFragmentType("l1");
Assert.IsFalse(lvl1Fragment.IsIndexed);
Assert.AreEqual(send == FBEAN, lvl1Fragment.IsNative);
Assert.AreEqual(fragmentTypeName, lvl1Fragment.FragmentType.Name);
var lvl2Fragment = eventType.GetFragmentType("l1.l2");
Assert.IsFalse(lvl2Fragment.IsIndexed);
Assert.AreEqual(send == FBEAN, lvl2Fragment.IsNative);
Assert.AreEqual(new EventPropertyDescriptor("l1", nestedClass, null, false, false, false, false, true), eventType.GetPropertyDescriptor("l1"));
}
public void TestOnUpdateWTypeWiden()
{
SupportUpdateListener listenerUpdate = new SupportUpdateListener();
string[] fields = "keyOne,keyTwo,p0".Split(',');
_epService.EPAdministrator.CreateEPL("create table varagg as (" +
"keyOne string primary key, keyTwo int primary key, p0 long)");
_epService.EPAdministrator.CreateEPL("on SupportBean merge varagg where TheString = keyOne and " +
"IntPrimitive = keyTwo when not matched then insert select TheString as keyOne, IntPrimitive as keyTwo, 1 as p0");
_epService.EPAdministrator.CreateEPL("select varagg[p00, id].p0 as value from SupportBean_S0").AddListener(_listener);
EPStatement stmtUpdate = _epService.EPAdministrator.CreateEPL("on MyUpdateEvent update varagg set p0 = newValue " +
"where k1 = keyOne and k2 = keyTwo");
stmtUpdate.AddListener(listenerUpdate);
object[][] expectedType = new object[][] { new object[] { "keyOne", typeof(string) }, new object[] { "keyTwo", typeof(int) }, new object[] { "p0", typeof(long) } };
SupportEventTypeAssertionUtil.AssertEventTypeProperties(expectedType, stmtUpdate.EventType, SupportEventTypeAssertionEnum.NAME, SupportEventTypeAssertionEnum.TYPE);
_epService.EPRuntime.SendEvent(new SupportBean("G1", 10));
AssertValues(new object[][] { new object[] { "G1", 10 } }, new long?[] { 1L });
_epService.EPRuntime.SendEvent(new MyUpdateEvent("G1", 10, 2));
AssertValues(new object[][] { new object[] { "G1", 10 } }, new long?[] { 2L });
EPAssertionUtil.AssertProps(listenerUpdate.LastNewData[0], fields, new object[] { "G1", 10, 2L });
EPAssertionUtil.AssertProps(listenerUpdate.GetAndResetLastOldData()[0], fields, new object[] { "G1", 10, 1L });
// try property method invocation
_epService.EPAdministrator.CreateEPL("create table MyTableSuppBean as (sb SupportBean)");
_epService.EPAdministrator.CreateEPL("on SupportBean_S0 update MyTableSuppBean sb set sb.set_LongPrimitive(10)");
}
public void RunOnMergeInsertUpdDeleteUngrouped(bool soda)
{
var eplDeclare = "create table varagg (p0 string, sumint sum(int))";
SupportModelHelper.CreateByCompileOrParse(_epService, soda, eplDeclare);
var fields = "c0,c1".Split(',');
var eplRead = "select varagg.p0 as c0, varagg.sumint as c1, varagg as c2 from SupportBean_S0";
EPStatement stmtRead = SupportModelHelper.CreateByCompileOrParse(_epService, soda, eplRead);
stmtRead.AddListener(_listener);
// assert selected column types
var expectedAggType = new object[][] { new object[] { "c0", typeof(string) }, new object[] { "c1", typeof(int?) } };
SupportEventTypeAssertionUtil.AssertEventTypeProperties(expectedAggType, stmtRead.EventType, SupportEventTypeAssertionEnum.NAME, SupportEventTypeAssertionEnum.TYPE);
// assert no row
_epService.EPRuntime.SendEvent(new SupportBean_S0(0));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { null, null });
// create merge
var eplMerge = "on SupportBean merge varagg" +
" when not matched then" +
" insert select TheString as p0" +
" when matched and TheString like \"U%\" then" +
" update set p0=\"updated\"" +
" when matched and TheString like \"D%\" then" +
" delete";
SupportModelHelper.CreateByCompileOrParse(_epService, soda, eplMerge);
// merge for varagg
_epService.EPRuntime.SendEvent(new SupportBean("E1", 0));
// assert
_epService.EPRuntime.SendEvent(new SupportBean_S0(0));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { "E1", null });
// also aggregate-into the same key
SupportModelHelper.CreateByCompileOrParse(_epService, soda, "into table varagg select sum(50) as sumint from SupportBean_S1");
_epService.EPRuntime.SendEvent(new SupportBean_S1(0));
_epService.EPRuntime.SendEvent(new SupportBean_S0(0));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { "E1", 50 });
// update for varagg
_epService.EPRuntime.SendEvent(new SupportBean("U2", 10));
_epService.EPRuntime.SendEvent(new SupportBean_S0(0));
var received = _listener.AssertOneGetNewAndReset();
EPAssertionUtil.AssertProps(received, fields, new object[] { "updated", 50 });
EPAssertionUtil.AssertPropsMap((IDictionary <string, object>)received.Get("c2"), "p0,sumint".Split(','), new object[] { "updated", 50 });
// delete for varagg
_epService.EPRuntime.SendEvent(new SupportBean("D3", 0));
_epService.EPRuntime.SendEvent(new SupportBean_S0(0));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { null, null });
_epService.EPAdministrator.DestroyAllStatements();
}
private void RunAssertionDeleteFlow()
{
SupportUpdateListener listenerDeleteFiltered = new SupportUpdateListener();
SupportUpdateListener listenerDeleteAll = new SupportUpdateListener();
string[] fields = "key,thesum".Split(',');
epService.EPAdministrator.CreateEPL("create table varagg as (key string primary key, thesum sum(int))");
epService.EPAdministrator.CreateEPL("into table varagg select sum(IntPrimitive) as thesum from SupportBean group by TheString");
epService.EPAdministrator.CreateEPL("select varagg[p00].thesum as value from SupportBean_S0").AddListener(listener);
EPStatement stmtDeleteFiltered = epService.EPAdministrator.CreateEPL("on SupportBean_S1(id = 1) delete from varagg where key = p10");
EPStatement stmtDeleteAll = epService.EPAdministrator.CreateEPL("on SupportBean_S1(id = 2) delete from varagg");
object[][] expectedType = new object[][] { new object[] { "key", typeof(string) }, new object[] { "thesum", typeof(int?) } };
SupportEventTypeAssertionUtil.AssertEventTypeProperties(expectedType, stmtDeleteAll.EventType, SupportEventTypeAssertionEnum.NAME, SupportEventTypeAssertionEnum.TYPE);
stmtDeleteFiltered.AddListener(listenerDeleteFiltered);
stmtDeleteAll.AddListener(listenerDeleteAll);
epService.EPRuntime.SendEvent(new SupportBean("G1", 10));
AssertValues(epService, listener, "G1,G2", new int?[] { 10, null });
epService.EPRuntime.SendEvent(new SupportBean("G2", 20));
AssertValues(epService, listener, "G1,G2", new int?[] { 10, 20 });
epService.EPRuntime.SendEvent(new SupportBean_S1(1, "G1"));
AssertValues(epService, listener, "G1,G2", new int?[] { null, 20 });
EPAssertionUtil.AssertProps(listenerDeleteFiltered.AssertOneGetNewAndReset(), fields, new object[] { "G1", 10 });
epService.EPRuntime.SendEvent(new SupportBean_S1(2, null));
AssertValues(epService, listener, "G1,G2", new int?[] { null, null });
EPAssertionUtil.AssertProps(listenerDeleteAll.AssertOneGetNewAndReset(), fields, new object[] { "G2", 20 });
epService.EPAdministrator.DestroyAllStatements();
}
public void Run(RegressionEnvironment env)
{
string epl = "@public @buseventtype create json schema JsonEvent (c0 Map);\n" +
"@Name('s0') select * from JsonEvent#keepall;\n";
env.CompileDeploy(epl).AddListener("s0");
object[][] namesAndTypes = new object[][] {
new object[] {"c0", typeof(IDictionary<string, object>)}
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(
namesAndTypes,
env.Statement("s0").EventType,
SupportEventTypeAssertionEnum.NAME,
SupportEventTypeAssertionEnum.TYPE);
SendAssertColumn(env, "{}", null);
SendAssertColumn(env, "{\"c0\": {\"c1\" : 10}}", Collections.SingletonMap("c1", 10));
SendAssertColumn(env, "{\"c0\": {\"c1\": {\"c2\": 20}}}", Collections.SingletonMap("c1", Collections.SingletonMap("c2", 20)));
Consumer<object> assertionOne = result => {
object[] oa = (object[]) (result.AsStringDictionary()).Get("c1");
EPAssertionUtil.AssertEqualsExactOrder(new object[] {"c2", 20}, oa);
};
SendAssert(env, "{\"c0\": {\"c1\": [\"c2\", 20]}}", assertionOne);
env.Milestone(0);
IEnumerator<EventBean> it = env.Statement("s0").GetEnumerator();
AssertColumn(it.Advance(), null);
AssertColumn(it.Advance(), Collections.SingletonMap("c1", 10));
AssertColumn(it.Advance(), Collections.SingletonMap("c1", Collections.SingletonMap("c2", 20)));
JustAssert(it.Advance(), assertionOne);
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
var epl = "@Name('s0') select " +
"new SupportBean(\"A\",IntPrimitive) as c0, " +
"new SupportBean(\"B\",IntPrimitive+10), " +
"new SupportBean() as c2, " +
"new SupportBean(\"ABC\",0).GetTheString() as c3 " +
"from SupportBean";
env.CompileDeploy(soda, epl).AddListener("s0");
var expectedAggType = new[] {
new object[] { "c0", typeof(SupportBean) },
new object[] { "c2", typeof(SupportBean) },
new object[] { "c3", typeof(string) },
new object[] { "new SupportBean(\"B\",IntPrimitive+10)", typeof(SupportBean) }
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(
expectedAggType,
env.Statement("s0").EventType,
SupportEventTypeAssertionEnum.NAME,
SupportEventTypeAssertionEnum.TYPE);
env.SendEventBean(new SupportBean("E1", 10));
var @event = env.Listener("s0").AssertOneGetNewAndReset();
AssertSupportBean(@event.Get("c0"), new object[] { "A", 10 });
AssertSupportBean(@event.Underlying.AsStringDictionary().Get("new SupportBean(\"B\",IntPrimitive+10)"), new object[] { "B", 20 });
AssertSupportBean(@event.Get("c2"), new object[] { null, 0 });
Assert.AreEqual("ABC", @event.Get("c3"));
env.UndeployAll();
}
private void RunAssertionTypeValidProp(
RegressionEnvironment env,
string typeName,
bool boxed)
{
var eventType = !typeName.Equals(JSON_TYPENAME)
? env.Runtime.EventTypeService.GetEventTypePreconfigured(typeName)
: env.Runtime.EventTypeService.GetEventType(env.DeploymentId("schema"), typeName);
var intType = boxed
? typeof(int?)
: typeof(int);
var expectedType = new object[][] {
new object[] { "MyInt", intType, null, null },
new object[] { "MyString", typeof(string), null, null }
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(expectedType, eventType, SupportEventTypeAssertionEnumExtensions.GetSetWithFragment());
EPAssertionUtil.AssertEqualsAnyOrder(new string[] { "MyString", "MyInt" }, eventType.PropertyNames);
Assert.IsNotNull(eventType.GetGetter("MyInt"));
Assert.IsTrue(eventType.IsProperty("MyInt"));
Assert.AreEqual(intType, eventType.GetPropertyType("MyInt"));
Assert.AreEqual(
new EventPropertyDescriptor("MyString", typeof(string), typeof(char), false, false, true, false, false),
eventType.GetPropertyDescriptor("MyString"));
}
public void Run(RegressionEnvironment env)
{
var fieldsScalar = "c0,c1".SplitCsv();
var eplScalar = "@Name('s0') select ss(TheString) as c0, ss(IntPrimitive) as c1 from SupportBean";
env.CompileDeploy(eplScalar).AddListener("s0");
var expectedScalar = new[] {
new object[] { "c0", typeof(string), null, null },
new object[] { "c1", typeof(int?), null, null }
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(
expectedScalar,
env.Statement("s0").EventType,
SupportEventTypeAssertionEnumExtensions.GetSetWithFragment());
env.SendEventBean(new SupportBean("E1", 1));
EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), fieldsScalar, new object[] { "E1", 1 });
env.SendEventBean(new SupportBean("E2", 2));
EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), fieldsScalar, new object[] { "E2", 2 });
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
string epl = "@public @buseventtype create json schema JsonEvent (c0 Map);\n" +
"@Name('s0') select * from JsonEvent#keepall;\n";
env.CompileDeploy(epl).AddListener("s0");
object[][] namesAndTypes = new object[][] {
new object[] { "c0", typeof(IDictionary <string, object>) }
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(
namesAndTypes,
env.Statement("s0").EventType,
SupportEventTypeAssertionEnum.NAME,
SupportEventTypeAssertionEnum.TYPE);
string[] jsons = new string[] {
"{\"c0\": {\"c1\" : 10}}",
"{\"c0\": {\"c1\": [\"c2\", 20]}}",
};
foreach (string json in jsons)
{
SendAssert(env, json);
}
env.Milestone(0);
using (IEnumerator <EventBean> it = env.Statement("s0").GetEnumerator()) {
foreach (string json in jsons)
{
AssertJsonWrite(json, it.Advance());
}
}
env.UndeployAll();
}
private void RunAssertionNewInstance(EPServiceProvider epService, bool soda)
{
epService.EPAdministrator.Configuration.AddImport(typeof(SupportBean));
var container = epService.Container;
var epl = "select " +
"new SupportBean(\"A\",IntPrimitive) as c0, " +
"new SupportBean(\"B\",IntPrimitive+10), " +
"new SupportBean() as c2, " +
"new SupportBean(\"ABC\",0).get_TheString() as c3 " +
"from SupportBean";
var stmt = SupportModelHelper.CreateByCompileOrParse(epService, soda, epl);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
var expectedAggType = new object[][] { new object[] { "c0", typeof(SupportBean) }, new object[] {
"new SupportBean(\"B\",IntPrimitive+10)", typeof(SupportBean)
} };
SupportEventTypeAssertionUtil.AssertEventTypeProperties(expectedAggType, stmt.EventType, SupportEventTypeAssertionEnum.NAME, SupportEventTypeAssertionEnum.TYPE);
var fields = "TheString,IntPrimitive".Split(',');
epService.EPRuntime.SendEvent(new SupportBean("E1", 10));
var @event = listener.AssertOneGetNewAndReset();
EPAssertionUtil.AssertPropsPono(container, @event.Get("c0"), fields, new object[] { "A", 10 });
EPAssertionUtil.AssertPropsPono(container, ((Map)@event.Underlying).Get("new SupportBean(\"B\",IntPrimitive+10)"), fields, new object[] { "B", 20 });
EPAssertionUtil.AssertPropsPono(container, @event.Get("c2"), fields, new object[] { null, 0 });
Assert.AreEqual("ABC", @event.Get("c3"));
epService.EPAdministrator.DestroyAllStatements();
}
private void RunAssertionTypeValidProp(string typeName, bool boxed, bool isBeanStyle)
{
var eventType = _epService.EPAdministrator.Configuration.GetEventType(typeName);
string nameMyString;
string nameMyInt;
if (isBeanStyle)
{
nameMyString = "MyString";
nameMyInt = "MyInt";
}
else
{
nameMyString = "myString";
nameMyInt = "myInt";
}
var valuesMyString = new object[] { nameMyString, typeof(string), null, null };
var valuesMyInt = new object[] { nameMyInt, boxed ? typeof(int?) : typeof(int), null, null };
object[][] expectedType = isBeanStyle
? new object[][] { valuesMyString, valuesMyInt } // why are we dependent on order?
: new object[][] { valuesMyInt, valuesMyString };
SupportEventTypeAssertionUtil.AssertEventTypeProperties(expectedType, eventType, SupportEventTypeAssertionEnumExtensions.GetSetWithFragment());
EPAssertionUtil.AssertEqualsAnyOrder(new string[] { nameMyString, nameMyInt }, eventType.PropertyNames);
Assert.IsNotNull(eventType.GetGetter(nameMyInt));
Assert.IsTrue(eventType.IsProperty(nameMyInt));
Assert.AreEqual(boxed ? typeof(int?) : typeof(int), eventType.GetPropertyType(nameMyInt));
Assert.AreEqual(new EventPropertyDescriptor(nameMyString, typeof(string), typeof(char), false, false, true, false, false), eventType.GetPropertyDescriptor(nameMyString));
}
private void TryAssertionSchemaArrayPrimitiveType(EPServiceProvider epService, bool soda)
{
SupportModelHelper.CreateByCompileOrParse(epService, soda, "create schema MySchema as (c0 int[primitive], c1 int[])");
var expectedType = new object[][] { new object[] { "c0", typeof(int[]) }, new object[] { "c1", typeof(int[]) } };
SupportEventTypeAssertionUtil.AssertEventTypeProperties(expectedType, epService.EPAdministrator.Configuration.GetEventType("MySchema"), SupportEventTypeAssertionEnum.NAME, SupportEventTypeAssertionEnum.TYPE);
epService.EPAdministrator.Configuration.RemoveEventType("MySchema", true);
}
private static void AssertTypeExpected(
RegressionEnvironment env,
Type clazz)
{
object[][] expectedColTypes = new object[][] {
new object[] { "c0", clazz },
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(expectedColTypes, env.Statement("s0").EventType, NAME, TYPE);
}
private void RunAssertionNestedMultivalueAccess(EPServiceProvider epService, bool grouped, bool soda)
{
string eplDeclare = "create table varagg (" +
(grouped ? "key string primary key, " : "") + "windowSupportBean window(*) @Type('SupportBean'))";
SupportModelHelper.CreateByCompileOrParse(epService, soda, eplDeclare);
string eplInto = "into table varagg " +
"select window(*) as windowSupportBean from SupportBean#length(2)" +
(grouped ? " group by TheString" : "");
SupportModelHelper.CreateByCompileOrParse(epService, soda, eplInto);
string key = grouped ? "[\"E1\"]" : "";
string eplSelect = "select " +
"varagg" + key + ".windowSupportBean.last(*) as c0, " +
"varagg" + key + ".windowSupportBean.window(*) as c1, " +
"varagg" + key + ".windowSupportBean.first(*) as c2, " +
"varagg" + key + ".windowSupportBean.last(IntPrimitive) as c3, " +
"varagg" + key + ".windowSupportBean.window(IntPrimitive) as c4, " +
"varagg" + key + ".windowSupportBean.first(IntPrimitive) as c5" +
" from SupportBean_S0";
EPStatement stmtSelect = SupportModelHelper.CreateByCompileOrParse(epService, soda, eplSelect);
var listener = new SupportUpdateListener();
stmtSelect.Events += listener.Update;
var expectedAggType = new object[][] {
new object[] { "c0", typeof(SupportBean) }, new object[] { "c1", typeof(SupportBean[]) }, new object[] { "c2", typeof(SupportBean) },
new object[] { "c3", typeof(int) }, new object[] { "c4", typeof(int[]) }, new object[] { "c5", typeof(int) }
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(expectedAggType, stmtSelect.EventType, SupportEventTypeAssertionEnum.NAME, SupportEventTypeAssertionEnum.TYPE);
string[] fields = "c0,c1,c2,c3,c4,c5".Split(',');
SupportBean b1 = MakeSendBean(epService, "E1", 10);
epService.EPRuntime.SendEvent(new SupportBean_S0(0));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields,
new object[] { b1, new object[] { b1 }, b1, 10, new int[] { 10 }, 10 });
SupportBean b2 = MakeSendBean(epService, "E1", 20);
epService.EPRuntime.SendEvent(new SupportBean_S0(0));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields,
new object[] { b2, new object[] { b1, b2 }, b1, 20, new int[] { 10, 20 }, 10 });
SupportBean b3 = MakeSendBean(epService, "E1", 30);
epService.EPRuntime.SendEvent(new SupportBean_S0(0));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields,
new object[] { b3, new object[] { b2, b3 }, b2, 30, new int[] { 20, 30 }, 20 });
epService.EPAdministrator.DestroyAllStatements();
epService.EPAdministrator.Configuration.RemoveEventType("table_varagg__internal", false);
epService.EPAdministrator.Configuration.RemoveEventType("table_varagg__public", false);
}
private static void AssertEventType(
EventType eventType,
object[][] expectedType)
{
SupportEventTypeAssertionUtil.AssertEventTypeProperties(
expectedType,
eventType,
SupportEventTypeAssertionEnum.NAME,
SupportEventTypeAssertionEnum.TYPE);
}
private void RunAssertionTypeValidProp(
RegressionEnvironment env,
bool preconfigured,
string typeName,
FunctionSendEvent4IntWArrayNested send,
Type nestedClass,
string fragmentTypeName)
{
var eventType = preconfigured
? env.Runtime.EventTypeService.GetEventTypePreconfigured(typeName)
: env.Runtime.EventTypeService.GetEventType(env.DeploymentId("types"), typeName);
var arrayType = nestedClass == typeof(object[]) ? nestedClass : TypeHelper.GetArrayType(nestedClass);
//arrayType = arrayType == typeof(GenericRecord[]) ? typeof(ICollection) : arrayType;
var expectedType = new object[][] {
new object[] { "l1", arrayType, fragmentTypeName, true }
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(expectedType, eventType, SupportEventTypeAssertionEnumExtensions.GetSetWithFragment());
EPAssertionUtil.AssertEqualsAnyOrder(new string[] { "l1" }, eventType.PropertyNames);
foreach (var prop in Arrays.AsList("l1[0]", "l1[0].lvl1", "l1[0].l2", "l1[0].l2[0]", "l1[0].l2[0].lvl2"))
{
Assert.IsNotNull(eventType.GetGetter(prop));
Assert.IsTrue(eventType.IsProperty(prop));
}
Assert.IsTrue(TypeHelper.IsSubclassOrImplementsInterface(eventType.GetPropertyType("l1"), arrayType));
foreach (var prop in Arrays.AsList("l1[0].lvl1", "l1[0].l2[0].lvl2", "l1[0].l2[0].l3[0].lvl3"))
{
Assert.AreEqual(typeof(int?), eventType.GetPropertyType(prop).GetBoxedType());
}
var lvl1Fragment = eventType.GetFragmentType("l1");
Assert.IsTrue(lvl1Fragment.IsIndexed);
var isNative = typeName.Equals(BEAN_TYPENAME);
Assert.AreEqual(isNative, lvl1Fragment.IsNative);
Assert.AreEqual(fragmentTypeName, lvl1Fragment.FragmentType.Name);
var lvl2Fragment = eventType.GetFragmentType("l1[0].l2");
Assert.IsTrue(lvl2Fragment.IsIndexed);
Assert.AreEqual(isNative, lvl2Fragment.IsNative);
if (typeName.Equals(JSON_TYPENAME))
{
arrayType = TypeHelper.GetArrayType(SupportJsonEventTypeUtil.GetNestedUnderlyingType((JsonEventType)eventType, "l1"));
nestedClass = arrayType.GetElementType();
}
Assert.AreEqual(new EventPropertyDescriptor("l1", arrayType, nestedClass, false, false, true, false, true), eventType.GetPropertyDescriptor("l1"));
}
private void TryAssertionNestedDotMethod(EPServiceProvider epService, bool grouped, bool soda)
{
string eplDeclare = "create table varaggNDM (" +
(grouped ? "key string primary key, " : "") +
"windowSupportBean window(*) @Type('SupportBean'))";
SupportModelHelper.CreateByCompileOrParse(epService, soda, eplDeclare);
string eplInto = "into table varaggNDM " +
"select window(*) as windowSupportBean from SupportBean#length(2)" +
(grouped ? " group by TheString" : "");
SupportModelHelper.CreateByCompileOrParse(epService, soda, eplInto);
string key = grouped ? "[\"E1\"]" : "";
string eplSelect = "select " +
"varaggNDM" + key + ".windowSupportBean.last(*).IntPrimitive as c0, " +
"varaggNDM" + key + ".windowSupportBean.window(*).countOf() as c1, " +
"varaggNDM" + key + ".windowSupportBean.window(IntPrimitive).take(1) as c2" +
" from SupportBean_S0";
EPStatement stmtSelect = SupportModelHelper.CreateByCompileOrParse(epService, soda, eplSelect);
var listener = new SupportUpdateListener();
stmtSelect.Events += listener.Update;
var expectedAggType = new object[][] {
new object[] { "c0", typeof(int?) },
new object[] { "c1", typeof(int) },
new object[] { "c2", typeof(ICollection <int>) }
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(
expectedAggType, stmtSelect.EventType, SupportEventTypeAssertionEnum.NAME,
SupportEventTypeAssertionEnum.TYPE);
string[] fields = "c0,c1,c2".Split(',');
MakeSendBean(epService, "E1", 10, 0);
epService.EPRuntime.SendEvent(new SupportBean_S0(0));
EPAssertionUtil.AssertProps(
listener.AssertOneGetNewAndReset(), fields, new object[] { 10, 1, Collections.SingletonList(10) });
MakeSendBean(epService, "E1", 20, 0);
epService.EPRuntime.SendEvent(new SupportBean_S0(0));
EPAssertionUtil.AssertProps(
listener.AssertOneGetNewAndReset(), fields, new object[] { 20, 2, Collections.SingletonList(10) });
MakeSendBean(epService, "E1", 30, 0);
epService.EPRuntime.SendEvent(new SupportBean_S0(0));
EPAssertionUtil.AssertProps(
listener.AssertOneGetNewAndReset(), fields, new object[] { 30, 2, Collections.SingletonList(20) });
epService.EPAdministrator.DestroyAllStatements();
epService.EPAdministrator.Configuration.RemoveEventType("table_varaggNDM__internal", false);
epService.EPAdministrator.Configuration.RemoveEventType("table_varaggNDM__public", false);
}
private void RunAssertionType(bool namedWindow)
{
string eplCreate = namedWindow ?
"create window MyInfra#keepall as (c0 int[], c1 int[primitive])" :
"create table MyInfra (c0 int[], c1 int[primitive])";
EPStatement stmt = SupportModelHelper.CreateByCompileOrParse(_epService, false, eplCreate);
object[][] expectedType = new object[][] { new object[] { "c0", typeof(int[]) }, new object[] { "c1", typeof(int[]) } };
SupportEventTypeAssertionUtil.AssertEventTypeProperties(expectedType, stmt.EventType, SupportEventTypeAssertionEnum.NAME, SupportEventTypeAssertionEnum.TYPE);
_epService.EPAdministrator.DestroyAllStatements();
_epService.EPAdministrator.Configuration.RemoveEventType("MyInfra", false);
}
private void RunAggregationWDatetimeEtc(EPServiceProvider epService, bool grouped, bool soda)
{
string eplDeclare = "create table varaggWDE (" + (grouped ? "key string primary key, " : "") +
"a1 lastever(long), a2 window(*) @Type('SupportBean'))";
SupportModelHelper.CreateByCompileOrParse(epService, soda, eplDeclare);
string eplInto = "into table varaggWDE " +
"select lastever(LongPrimitive) as a1, window(*) as a2 from SupportBean#time(10 seconds)" +
(grouped ? " group by TheString" : "");
EPStatement stmtInto = SupportModelHelper.CreateByCompileOrParse(epService, soda, eplInto);
var expectedAggType = new object[][] {
new object[] { "a1", typeof(long) },
new object[] { "a2", typeof(SupportBean[]) }
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(
expectedAggType, stmtInto.EventType, SupportEventTypeAssertionEnum.NAME,
SupportEventTypeAssertionEnum.TYPE);
string key = grouped ? "[\"E1\"]" : "";
string eplGet = "select varaggWDE" + key + ".a1.after(150L) as c0, " +
"varaggWDE" + key + ".a2.countOf() as c1 from SupportBean_S0";
EPStatement stmtGet = SupportModelHelper.CreateByCompileOrParse(epService, soda, eplGet);
var listener = new SupportUpdateListener();
stmtGet.Events += listener.Update;
var expectedGetType =
new object[][] {
new object[] { "c0", typeof(bool?) },
new object[] { "c1", typeof(int) }
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(
expectedGetType, stmtGet.EventType, SupportEventTypeAssertionEnum.NAME,
SupportEventTypeAssertionEnum.TYPE);
string[] fields = "c0,c1".Split(',');
MakeSendBean(epService, "E1", 10, 100);
epService.EPRuntime.SendEvent(new SupportBean_S0(0));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { false, 1 });
MakeSendBean(epService, "E1", 20, 200);
epService.EPRuntime.SendEvent(new SupportBean_S0(0));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { true, 2 });
epService.EPAdministrator.DestroyAllStatements();
epService.EPAdministrator.Configuration.RemoveEventType("table_varaggWDE__internal", false);
epService.EPAdministrator.Configuration.RemoveEventType("table_varaggWDE__public", false);
}
public override void Run(EPServiceProvider epService)
{
foreach (var clazz in new[] {typeof(SupportBean), typeof(SupportBean_S0), typeof(MyUpdateEvent)})
{
epService.EPAdministrator.Configuration.AddEventType(clazz);
}
var listenerUpdate = new SupportUpdateListener();
var fields = "keyOne,keyTwo,p0".Split(',');
epService.EPAdministrator.CreateEPL(
"create table varagg as (" +
"keyOne string primary key, keyTwo int primary key, p0 long)");
epService.EPAdministrator.CreateEPL(
"on SupportBean merge varagg where TheString = keyOne and " +
"IntPrimitive = keyTwo when not matched then insert select TheString as keyOne, IntPrimitive as keyTwo, 1 as p0");
var listener = new SupportUpdateListener();
epService.EPAdministrator.CreateEPL("select varagg[p00, id].p0 as value from SupportBean_S0")
.Events += listener.Update;
var stmtUpdate = epService.EPAdministrator.CreateEPL(
"on MyUpdateEvent update varagg set p0 = newValue " +
"where k1 = keyOne and k2 = keyTwo");
stmtUpdate.Events += listenerUpdate.Update;
var expectedType = new[]
{
new object[] {"keyOne", typeof(string)},
new object[] {"keyTwo", typeof(int)},
new object[] {"p0", typeof(long)}
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(
expectedType, stmtUpdate.EventType, SupportEventTypeAssertionEnum.NAME,
SupportEventTypeAssertionEnum.TYPE);
epService.EPRuntime.SendEvent(new SupportBean("G1", 10));
AssertValues(epService, listener, new[] {new object[] {"G1", 10}}, new[] {1L});
epService.EPRuntime.SendEvent(new MyUpdateEvent("G1", 10, 2));
AssertValues(epService, listener, new[] {new object[] {"G1", 10}}, new[] {2L});
EPAssertionUtil.AssertProps(listenerUpdate.LastNewData[0], fields, new object[] {"G1", 10, 2L});
EPAssertionUtil.AssertProps(
listenerUpdate.GetAndResetLastOldData()[0], fields, new object[] {"G1", 10, 1L});
// try property method invocation
epService.EPAdministrator.CreateEPL("create table MyTableSuppBean as (sb SupportBean)");
epService.EPAdministrator.CreateEPL(
"on SupportBean_S0 update MyTableSuppBean sb set sb.set_LongPrimitive(10)");
}
public void Run(RegressionEnvironment env)
{
var path = new RegressionPath();
var fields = new[] {"key", "thesum"};
env.CompileDeploy("create table varagg as (key string primary key, thesum sum(int))", path);
env.CompileDeploy(
"into table varagg select sum(IntPrimitive) as thesum from SupportBean group by TheString",
path);
env.CompileDeploy("@Name('s0') select varagg[P00].thesum as value from SupportBean_S0", path)
.AddListener("s0");
env.CompileDeploy("@Name('sdf') on SupportBean_S1(Id = 1) delete from varagg where key = P10", path)
.AddListener("sdf");
env.CompileDeploy("@Name('sda') on SupportBean_S1(Id = 2) delete from varagg", path).AddListener("sda");
object[][] expectedType = {
new object[] {"key", typeof(string)},
new object[] {"thesum", typeof(int?)}
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(
expectedType,
env.Statement("sda").EventType,
SupportEventTypeAssertionEnum.NAME,
SupportEventTypeAssertionEnum.TYPE);
env.SendEventBean(new SupportBean("G1", 10));
AssertValues(env, "G1,G2", new int?[] {10, null});
env.SendEventBean(new SupportBean("G2", 20));
AssertValues(env, "G1,G2", new int?[] {10, 20});
env.SendEventBean(new SupportBean_S1(1, "G1"));
AssertValues(env, "G1,G2", new int?[] {null, 20});
EPAssertionUtil.AssertProps(
env.Listener("sdf").AssertOneGetNewAndReset(),
fields,
new object[] {"G1", 10});
env.Milestone(0);
env.SendEventBean(new SupportBean_S1(2, null));
AssertValues(env, "G1,G2", new int?[] {null, null});
EPAssertionUtil.AssertProps(
env.Listener("sda").AssertOneGetNewAndReset(),
fields,
new object[] {"G2", 20});
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
string epl = "@public @buseventtype create json schema JsonEvent (c0 Object[]);\n" +
"@Name('s0') select * from JsonEvent#keepall;\n";
env.CompileDeploy(epl).AddListener("s0");
object[][] namesAndTypes = new object[][] {
new object[] {"c0", typeof(object[])}
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(
namesAndTypes,
env.Statement("s0").EventType,
SupportEventTypeAssertionEnum.NAME,
SupportEventTypeAssertionEnum.TYPE);
SendAssertColumn(env, "{}", null);
SendAssertColumn(env, "{\"c0\": []}", new object[0]);
SendAssertColumn(env, "{\"c0\": [1.0]}", new object[] {1.0d});
SendAssertColumn(env, "{\"c0\": [null]}", new object[] {null});
SendAssertColumn(env, "{\"c0\": [true]}", new object[] {true});
SendAssertColumn(env, "{\"c0\": [false]}", new object[] {false});
SendAssertColumn(env, "{\"c0\": [\"abc\"]}", new object[] {"abc"});
SendAssertColumn(env, "{\"c0\": [[\"abc\"]]}", new object[][] {new object[] {"abc"}});
SendAssertColumn(env, "{\"c0\": [[]]}", new object[] {new object[0]});
SendAssertColumn(env, "{\"c0\": [[\"abc\", 2]]}", new object[][] {new object[] {"abc", 2}});
SendAssertColumn(env, "{\"c0\": [[[\"abc\"], [5.0]]]}", new object[][][] {new object[][] {new object[] {"abc"}, new object[] {5d}}});
SendAssertColumn(env, "{\"c0\": [{\"c1\": 10}]}", new object[] {Collections.SingletonMap("c1", 10)});
SendAssertColumn(env, "{\"c0\": [{\"c1\": 10, \"c2\": \"abc\"}]}", new object[] {CollectionUtil.BuildMap("c1", 10, "c2", "abc")});
env.Milestone(0);
IEnumerator<EventBean> it = env.Statement("s0").GetEnumerator();
AssertColumn(it.Advance(), null);
AssertColumn(it.Advance(), new object[0]);
AssertColumn(it.Advance(), new object[] {1.0d});
AssertColumn(it.Advance(), new object[] {null});
AssertColumn(it.Advance(), new object[] {true});
AssertColumn(it.Advance(), new object[] {false});
AssertColumn(it.Advance(), new object[] {"abc"});
AssertColumn(it.Advance(), new object[][] {new object[] {"abc"}});
AssertColumn(it.Advance(), new object[] {new object[0]});
AssertColumn(it.Advance(), new object[][] {new object[] {"abc", 2}});
AssertColumn(it.Advance(), new object[][][] {new object[][] {new object[] {"abc"}, new object[] {5d}}});
AssertColumn(it.Advance(), new object[] {Collections.SingletonMap("c1", 10)});
AssertColumn(it.Advance(), new object[] {CollectionUtil.BuildMap("c1", 10, "c2", "abc")});
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
// test scalar-collection only
var fieldsScalarColl = "c2,c3".SplitCsv();
var eplScalarColl = "@Name('s0') select " +
"sc(TheString) as c0, " +
"sc(IntPrimitive) as c1, " +
"sc(TheString).allOf(v => v = 'E1') as c2, " +
"sc(IntPrimitive).allOf(v => v = 1) as c3 " +
"from SupportBean";
env.CompileDeploy(eplScalarColl).AddListener("s0");
var expectedScalarColl = new[] {
new object[] { "c0", typeof(ICollection <object>), null, null },
new object[] { "c1", typeof(ICollection <object>), null, null },
new object[] { "c2", typeof(bool?), null, null },
new object[] { "c3", typeof(bool?), null, null },
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(
expectedScalarColl,
env.Statement("s0").EventType,
SupportEventTypeAssertionEnumExtensions.GetSetWithFragment());
env.SendEventBean(new SupportBean("E1", 1));
EPAssertionUtil.AssertEqualsExactOrder(
new object[] { "E1" },
env.Listener("s0").AssertOneGetNew().Get("c0").Unwrap <object>());
EPAssertionUtil.AssertEqualsExactOrder(
new object[] { 1 },
env.Listener("s0").AssertOneGetNew().Get("c1").Unwrap <object>());
EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), fieldsScalarColl, new object[] { true, true });
env.SendEventBean(new SupportBean("E2", 2));
EPAssertionUtil.AssertEqualsExactOrder(
new object[] { "E1", "E2" },
env.Listener("s0").AssertOneGetNew().Get("c0").Unwrap <object>());
EPAssertionUtil.AssertEqualsExactOrder(
new object[] { 1, 2 },
env.Listener("s0").AssertOneGetNew().Get("c1").Unwrap <object>());
EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), fieldsScalarColl, new object[] { false, false });
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
string epl = "@public @buseventtype create json schema JsonEvent (c0 BigInteger, c1 BigDecimal," +
"c2 BigInteger[], c3 BigDecimal[], c4 BigInteger[][], c5 BigDecimal[][]);\n" +
"@Name('s0') select * from JsonEvent#keepall;\n";
env.CompileDeploy(epl).AddListener("s0");
object[][] namesAndTypes = new object[][] {
new object[] {"c0", typeof(BigInteger?)},
new object[] {"c1", typeof(decimal?)},
new object[] {"c2", typeof(BigInteger?[])},
new object[] {"c3", typeof(decimal?[])},
new object[] {"c4", typeof(BigInteger?[][])},
new object[] {"c5", typeof(decimal?[][])}
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(
namesAndTypes,
env.Statement("s0").EventType,
SupportEventTypeAssertionEnum.NAME,
SupportEventTypeAssertionEnum.TYPE);
string json = "{\"c0\": 123456789123456789123456789, \"c1\": 123456789123456789123456789.1," +
"\"c2\": [123456789123456789123456789], \"c3\": [123456789123456789123456789.1]," +
"\"c4\": [[123456789123456789123456789]], \"c5\": [[123456789123456789123456789.1]]" +
"}";
env.SendEventJson(json, "JsonEvent");
AssertFilled(env.Listener("s0").AssertOneGetNewAndReset());
json = "{}";
env.SendEventJson(json, "JsonEvent");
AssertUnfilled(env.Listener("s0").AssertOneGetNewAndReset());
json = "{\"c0\": null, \"c1\": null, \"c2\": null, \"c3\": null, \"c4\": null, \"c5\": null}";
env.SendEventJson(json, "JsonEvent");
AssertUnfilled(env.Listener("s0").AssertOneGetNewAndReset());
env.Milestone(0);
IEnumerator<EventBean> it = env.Statement("s0").GetEnumerator();
AssertFilled(it.Advance());
AssertUnfilled(it.Advance());
AssertUnfilled(it.Advance());
env.UndeployAll();
}
private void RunAssertionTypeValidProp(
RegressionEnvironment env,
string typeName,
FunctionSendEvent4Int send,
Type nestedClass,
string fragmentTypeName)
{
var eventType = env.Runtime.EventTypeService.GetEventTypePreconfigured(typeName);
var expectedType = new object[][] {
new object[] { "L1", nestedClass, fragmentTypeName, false }
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(expectedType, eventType, SupportEventTypeAssertionEnumExtensions.GetSetWithFragment());
EPAssertionUtil.AssertEqualsAnyOrder(new string[] { "L1" }, eventType.PropertyNames);
foreach (var prop in Arrays.AsList("L1", "L1.Lvl1", "L1.L2", "L1.L2.Lvl2"))
{
Assert.IsNotNull(eventType.GetGetter(prop));
Assert.IsTrue(eventType.IsProperty(prop));
}
Assert.AreEqual(nestedClass, eventType.GetPropertyType("L1"));
foreach (var prop in Arrays.AsList("L1.Lvl1", "L1.L2.Lvl2", "L1.L2.L3.Lvl3"))
{
Assert.AreEqual(typeof(int?), eventType.GetPropertyType(prop).GetBoxedType());
}
var lvl1Fragment = eventType.GetFragmentType("L1");
Assert.IsFalse(lvl1Fragment.IsIndexed);
var isNative = typeName.Equals(BEAN_TYPENAME) || typeName.Equals(JSONPROVIDED_TYPENAME);
Assert.AreEqual(isNative, lvl1Fragment.IsNative);
Assert.AreEqual(fragmentTypeName, lvl1Fragment.FragmentType.Name);
var lvl2Fragment = eventType.GetFragmentType("L1.L2");
Assert.IsFalse(lvl2Fragment.IsIndexed);
Assert.AreEqual(isNative, lvl2Fragment.IsNative);
Assert.AreEqual(new EventPropertyDescriptor("L1", nestedClass, null, false, false, false, false, true), eventType.GetPropertyDescriptor("L1"));
}
public void Run(RegressionEnvironment env)
{
string epl = "@public @buseventtype create json schema JsonEvent (c0 SupportEnum, c1 SupportEnum[], c2 SupportEnum[][]);\n" +
"@Name('s0') select * from JsonEvent#keepall;\n";
env.CompileDeploy(epl).AddListener("s0");
object[][] namesAndTypes = new object[][] {
new object[] {"c0", typeof(SupportEnum)},
new object[] {"c1", typeof(SupportEnum[])},
new object[] {"c2", typeof(SupportEnum[][])}
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(
namesAndTypes,
env.Statement("s0").EventType,
SupportEventTypeAssertionEnum.NAME,
SupportEventTypeAssertionEnum.TYPE);
string json =
"{\"c0\": \"ENUM_VALUE_2\", \"c1\": [\"ENUM_VALUE_2\", \"ENUM_VALUE_1\"], \"c2\": [[\"ENUM_VALUE_2\"], [\"ENUM_VALUE_1\", \"ENUM_VALUE_3\"]]}";
env.SendEventJson(json, "JsonEvent");
AssertFilled(env.Listener("s0").AssertOneGetNewAndReset());
json = "{}";
env.SendEventJson(json, "JsonEvent");
AssertUnfilled(env.Listener("s0").AssertOneGetNewAndReset());
json = "{\"c0\": null, \"c1\": null, \"c2\": null}";
env.SendEventJson(json, "JsonEvent");
AssertUnfilled(env.Listener("s0").AssertOneGetNewAndReset());
json = "{\"c1\": [], \"c2\": [[]]}";
env.SendEventJson(json, "JsonEvent");
AssertEmptyArray(env.Listener("s0").AssertOneGetNewAndReset());
env.Milestone(0);
IEnumerator<EventBean> it = env.Statement("s0").GetEnumerator();
AssertFilled(it.Advance());
AssertUnfilled(it.Advance());
AssertUnfilled(it.Advance());
AssertEmptyArray(it.Advance());
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
var fieldsScalarArray = "c0,c1,c2,c3".SplitCsv();
var eplScalarArray = "@Name('s0') select " +
"sa(TheString) as c0, " +
"sa(IntPrimitive) as c1, " +
"sa(TheString).allOf(v => v = 'E1') as c2, " +
"sa(IntPrimitive).allOf(v => v = 1) as c3 " +
"from SupportBean";
env.CompileDeploy(eplScalarArray).AddListener("s0");
var expectedScalarArray = new [] {
new object[] { "c0", typeof(string[]), null, null },
new object[] { "c1", typeof(int?[]), null, null },
new object[] { "c2", typeof(bool?), null, null },
new object[] { "c3", typeof(bool?), null, null },
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(
expectedScalarArray,
env.Statement("s0").EventType,
SupportEventTypeAssertionEnumExtensions.GetSetWithFragment());
env.SendEventBean(new SupportBean("E1", 1));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fieldsScalarArray,
new object[] {
new[] { "E1" }, new int?[] { 1 }, true, true
});
env.SendEventBean(new SupportBean("E2", 2));
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fieldsScalarArray,
new object[] {
new[] { "E1", "E2" }, new int?[] { 1, 2 }, false, false
});
env.UndeployAll();
}
