public static void AssertValuesMayConvert(
EventBean eventBean,
string[] propertyNames,
ValueWithExistsFlag[] expected,
Func<object, object> optionalValueConversion)
{
SupportEventTypeAssertionUtil.AssertConsistency(eventBean);
var receivedValues = new object[propertyNames.Length];
var expectedValues = new object[propertyNames.Length];
for (var i = 0; i < receivedValues.Length; i++) {
var value = eventBean.Get(propertyNames[i]);
if (optionalValueConversion != null) {
value = optionalValueConversion.Invoke(value);
}
receivedValues[i] = value;
expectedValues[i] = expected[i].Value;
}
EPAssertionUtil.AssertEqualsExactOrder(expectedValues, receivedValues);
for (var i = 0; i < receivedValues.Length; i++) {
var exists = (bool) eventBean.Get("exists_" + propertyNames[i]);
Assert.AreEqual(
expected[i].IsExists,
exists,
"Assertion failed for property 'exists_" + propertyNames[i] + "'");
}
}
public void TestObservationExamplePropertyExpression()
{
var typecfg = new ConfigurationEventTypeXMLDOM();
typecfg.RootElementName = "Sensor";
var schemaUri = ResourceManager.ResolveResourceURL(CLASSLOADER_SCHEMA_URI).ToString();
typecfg.SchemaResource = schemaUri;
var configuration = SupportConfigFactory.GetConfiguration();
configuration.EngineDefaults.ViewResources.IsIterableUnbound = true;
configuration.AddEventType("SensorEvent", typecfg);
_epService = EPServiceProviderManager.GetDefaultProvider(configuration);
_epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(_epService, this.GetType(), this.GetType().FullName);
}
var stmtExampleOneText = "select ID, Observation.Command, Observation.ID,\n" +
"Observation.Tag[0].ID, Observation.Tag[1].ID\n" +
"from SensorEvent";
var stmtExampleOne = _epService.EPAdministrator.CreateEPL(stmtExampleOneText);
var stmtExampleTwo_0 = _epService.EPAdministrator.CreateEPL("insert into ObservationStream\n" +
"select ID, Observation from SensorEvent");
var stmtExampleTwo_1 = _epService.EPAdministrator.CreateEPL("select Observation.Command, Observation.Tag[0].ID from ObservationStream");
var stmtExampleThree_0 = _epService.EPAdministrator.CreateEPL("insert into TagListStream\n" +
"select ID as sensorId, Observation.* from SensorEvent");
var stmtExampleThree_1 = _epService.EPAdministrator.CreateEPL("select sensorId, Command, Tag[0].ID from TagListStream");
var doc = SupportXML.GetDocument(XML);
var sender = _epService.EPRuntime.GetEventSender("SensorEvent");
sender.SendEvent(doc);
SupportEventTypeAssertionUtil.AssertConsistency(stmtExampleOne.First());
SupportEventTypeAssertionUtil.AssertConsistency(stmtExampleTwo_0.First());
SupportEventTypeAssertionUtil.AssertConsistency(stmtExampleTwo_1.First());
SupportEventTypeAssertionUtil.AssertConsistency(stmtExampleThree_0.First());
SupportEventTypeAssertionUtil.AssertConsistency(stmtExampleThree_1.First());
EPAssertionUtil.AssertProps(stmtExampleTwo_1.First(), "Observation.Command,Observation.Tag[0].ID".SplitCsv(), new object[] { "READ_PALLET_TAGS_ONLY", "urn:epc:1:2.24.400" });
EPAssertionUtil.AssertProps(stmtExampleThree_1.First(), "sensorId,Command,Tag[0].ID".SplitCsv(), new object[] { "urn:epc:1:4.16.36", "READ_PALLET_TAGS_ONLY", "urn:epc:1:2.24.400" });
try {
_epService.EPAdministrator.CreateEPL("select Observation.Tag.ID from SensorEvent");
Assert.Fail();
} catch (EPStatementException ex) {
Assert.AreEqual("Error starting statement: Failed to validate select-clause expression 'Observation.Tag.ID': Failed to resolve property 'Observation.Tag.ID' to a stream or nested property in a stream [select Observation.Tag.ID from SensorEvent]", ex.Message);
}
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.EndTest();
}
}
public override void Run(EPServiceProvider epService)
{
var tagcfg = new ConfigurationEventTypeXMLDOM();
tagcfg.RootElementName = "//Tag";
tagcfg.SchemaResource = _schemaUri;
epService.EPAdministrator.Configuration.AddEventType("TagEvent", tagcfg);
EPStatement stmtExampleOne = epService.EPAdministrator.CreateEPL("select countTags, countTagsInt, idarray, tagArray, tagOne from SensorEvent");
EPStatement stmtExampleTwo_0 = epService.EPAdministrator.CreateEPL("insert into TagOneStream select tagOne.* from SensorEvent");
EPStatement stmtExampleTwo_1 = epService.EPAdministrator.CreateEPL("select ID from TagOneStream");
EPStatement stmtExampleTwo_2 = epService.EPAdministrator.CreateEPL("insert into TagArrayStream select tagArray as mytags from SensorEvent");
EPStatement stmtExampleTwo_3 = epService.EPAdministrator.CreateEPL("select mytags[1].ID from TagArrayStream");
XmlDocument doc = SupportXML.GetDocument(OBSERVATION_XML);
epService.EPRuntime.SendEvent(doc);
SupportEventTypeAssertionUtil.AssertConsistency(stmtExampleOne.First());
SupportEventTypeAssertionUtil.AssertConsistency(stmtExampleTwo_0.First());
SupportEventTypeAssertionUtil.AssertConsistency(stmtExampleTwo_1.First());
SupportEventTypeAssertionUtil.AssertConsistency(stmtExampleTwo_2.First());
SupportEventTypeAssertionUtil.AssertConsistency(stmtExampleTwo_3.First());
Object resultArray = stmtExampleOne.First().Get("idarray");
EPAssertionUtil.AssertEqualsExactOrder((object[])resultArray, new string[] { "urn:epc:1:2.24.400", "urn:epc:1:2.24.401" });
EPAssertionUtil.AssertProps(stmtExampleOne.First(), "countTags,countTagsInt".Split(','), new object[] { 2d, 2 });
Assert.AreEqual("urn:epc:1:2.24.400", stmtExampleTwo_1.First().Get("ID"));
Assert.AreEqual("urn:epc:1:2.24.401", stmtExampleTwo_3.First().Get("mytags[1].ID"));
}
private void RunAssertionMapFragmentMapNested(EPServiceProvider epService)
{
var typeLev0 = new Dictionary <string, Object>();
typeLev0.Put("p1id", typeof(int));
epService.EPAdministrator.Configuration.AddEventType("HomerunLev0", typeLev0);
var mapOuter = new Dictionary <string, Object>();
mapOuter.Put("p0simple", "HomerunLev0");
mapOuter.Put("p0array", "HomerunLev0[]");
epService.EPAdministrator.Configuration.AddEventType("HomerunRoot", mapOuter);
var stmt = epService.EPAdministrator.CreateEPL("select * from HomerunRoot");
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
var dataInner = new Dictionary <string, Object>();
dataInner.Put("p1id", 10);
var dataRoot = new Dictionary <string, Object>();
dataRoot.Put("p0simple", dataInner);
dataRoot.Put("p0array", new Map[] { dataInner, dataInner });
// send event
epService.EPRuntime.SendEvent(dataRoot, "HomerunRoot");
var eventBean = listener.AssertOneGetNewAndReset();
// Log.Info(SupportEventTypeAssertionUtil.Print(eventBean)); comment me in
var eventType = eventBean.EventType;
SupportEventTypeAssertionUtil.AssertConsistency(eventType);
// resolve property via fragment
Assert.IsTrue(eventType.GetPropertyDescriptor("p0simple").IsFragment);
Assert.IsTrue(eventType.GetPropertyDescriptor("p0array").IsFragment);
var innerSimpleEvent = (EventBean)eventBean.GetFragment("p0simple");
Assert.AreEqual(10, innerSimpleEvent.Get("p1id"));
var innerArrayAllEvent = (EventBean[])eventBean.GetFragment("p0array");
Assert.AreEqual(10, innerArrayAllEvent[0].Get("p1id"));
var innerArrayElementEvent = (EventBean)eventBean.GetFragment("p0array[0]");
Assert.AreEqual(10, innerArrayElementEvent.Get("p1id"));
// resolve property via getter
Assert.AreEqual(10, eventBean.Get("p0simple.p1id"));
Assert.AreEqual(10, eventBean.Get("p0array[1].p1id"));
Assert.IsNull(eventType.GetFragmentType("p0array.p1id"));
Assert.IsNull(eventType.GetFragmentType("p0array[0].p1id"));
epService.EPAdministrator.DestroyAllStatements();
}
public void TestExpressionSimpleXPathGetter()
{
var eventTypeMeta = new ConfigurationEventTypeXMLDOM();
eventTypeMeta.RootElementName = "simpleEvent";
var schemaUri = ResourceManager.ResolveResourceURL(CLASSLOADER_SCHEMA_URI).ToString();
eventTypeMeta.SchemaResource = schemaUri;
eventTypeMeta.IsXPathPropertyExpr = true; // <== note this
eventTypeMeta.AddNamespacePrefix("ss", "samples:schemas:simpleSchema");
_epService.EPAdministrator.Configuration.AddEventType("TestXMLSchemaType", eventTypeMeta);
// note class not a fragment
var stmtInsert = _epService.EPAdministrator.CreateEPL("insert into MyNestedStream select nested1 from TestXMLSchemaType#lastevent");
EPAssertionUtil.AssertEqualsAnyOrder(new EventPropertyDescriptor[] {
new EventPropertyDescriptor("nested1", typeof(XmlNode), null, false, false, false, false, false),
}, stmtInsert.EventType.PropertyDescriptors);
SupportEventTypeAssertionUtil.AssertConsistency(stmtInsert.EventType);
EventType type = ((EPServiceProviderSPI)_epService).EventAdapterService.GetEventTypeByName("TestXMLSchemaType");
SupportEventTypeAssertionUtil.AssertConsistency(type);
Assert.IsNull(type.GetFragmentType("nested1"));
Assert.IsNull(type.GetFragmentType("nested1.nested2"));
SupportXML.SendDefaultEvent(_epService.EPRuntime, "ABC");
SupportEventTypeAssertionUtil.AssertConsistency(stmtInsert.First());
}
private void RunAssertionObjectArraySimpleTypes(EPServiceProvider epService)
{
string[] props = { "p0int", "p0intarray", "p0map" };
object[] types = { typeof(int), typeof(int[]), typeof(Map) };
epService.EPAdministrator.Configuration.AddEventType("OASimple", props, types);
var stmt = epService.EPAdministrator.CreateEPL("select * from OASimple");
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
var dataInner = new Dictionary <string, Object>();
dataInner.Put("p1someval", "A");
var dataRoot = new object[] { 99, new int[] { 101, 102 }, dataInner };
// send event
epService.EPRuntime.SendEvent(dataRoot, "OASimple");
var eventBean = listener.AssertOneGetNewAndReset();
//Log.Info(SupportEventTypeAssertionUtil.Print(eventBean)); //comment me in
var eventType = eventBean.EventType;
SupportEventTypeAssertionUtil.AssertConsistency(eventType);
// resolve property via fragment
Assert.IsNull(eventType.GetFragmentType("p0int"));
Assert.IsNull(eventType.GetFragmentType("p0intarray"));
Assert.IsNull(eventBean.GetFragment("p0map?"));
Assert.IsNull(eventBean.GetFragment("p0intarray[0]?"));
Assert.IsNull(eventBean.GetFragment("p0map('a')?"));
stmt.Dispose();
}
private void RunAssertion(
RegressionEnvironment env,
string typename,
FunctionSendEvent send,
object underlying,
RegressionPath path)
{
RunAssertionTypeValidProp(env, typename, underlying);
RunAssertionTypeInvalidProp(env, typename);
var stmtText = "@Name('s0') select * from " + typename;
env.CompileDeploy(stmtText, path).AddListener("s0");
send.Invoke(env, underlying, typename);
var @event = env.Listener("s0").AssertOneGetNewAndReset();
var mappedGetter = @event.EventType.GetGetterMapped("Mapped");
Assert.AreEqual("v1", mappedGetter.Get(@event, "k1"));
var indexedGetter = @event.EventType.GetGetterIndexed("Indexed");
Assert.AreEqual("v2", indexedGetter.Get(@event, 1));
RunAssertionEventInvalidProp(@event);
SupportEventTypeAssertionUtil.AssertConsistency(@event);
env.UndeployAll();
}
private void RunAssertionWrapperFragmentWithObjectArray(EPServiceProvider epService)
{
epService.EPAdministrator.Configuration.AddEventType("WheatLev0", new string[] { "p1id" }, new object[] { typeof(int) });
epService.EPAdministrator.Configuration.AddEventType("WheatRoot", new string[] { "p0simple", "p0bean" }, new object[] { "WheatLev0", typeof(SupportBeanComplexProps) });
var stmt = epService.EPAdministrator.CreateEPL("select *, p0simple.p1id + 1 as plusone, p0bean as mybean from WheatRoot");
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
epService.EPRuntime.SendEvent(new object[] { new object[] { 10 }, SupportBeanComplexProps.MakeDefaultBean() }, "WheatRoot");
var eventBean = listener.AssertOneGetNewAndReset();
// Log.Info(SupportEventTypeAssertionUtil.Print(eventBean)); comment me in
var eventType = eventBean.EventType;
SupportEventTypeAssertionUtil.AssertConsistency(eventType);
// resolve property via fragment
Assert.IsTrue(eventType.GetPropertyDescriptor("p0simple").IsFragment);
Assert.AreEqual(11, eventBean.Get("plusone"));
Assert.AreEqual(10, eventBean.Get("p0simple.p1id"));
var innerSimpleEvent = (EventBean)eventBean.GetFragment("p0simple");
Assert.AreEqual(10, innerSimpleEvent.Get("p1id"));
var innerBeanEvent = (EventBean)eventBean.GetFragment("mybean");
Assert.AreEqual("NestedNestedValue", innerBeanEvent.Get("Nested.NestedNested.NestedNestedValue"));
Assert.AreEqual("NestedNestedValue", ((EventBean)eventBean.GetFragment("mybean.Nested.NestedNested")).Get("NestedNestedValue"));
stmt.Dispose();
}
private static void RunAssertion(
RegressionEnvironment env,
String eventTypeName,
RegressionPath path)
{
env.CompileDeploy("@Name('insert') insert into MyNestedStream select nested1 from " + eventTypeName, path);
CollectionAssert.AreEquivalent(
new EventPropertyDescriptor[] {
new EventPropertyDescriptor("nested1", typeof(string), typeof(char), false, false, true, false, false)
},
env.Statement("insert").EventType.PropertyDescriptors);
SupportEventTypeAssertionUtil.AssertConsistency(env.Statement("insert").EventType);
env.CompileDeploy("@Name('s0') select * from " + eventTypeName, path);
CollectionAssert.AreEquivalent(new EventPropertyDescriptor[0], env.Statement("s0").EventType.PropertyDescriptors);
SupportEventTypeAssertionUtil.AssertConsistency(env.Statement("s0").EventType);
SupportXML.SendDefaultEvent(env.EventService, "test", eventTypeName);
var stmtInsertWildcardBean = env.GetEnumerator("insert").Advance();
var stmtSelectWildcardBean = env.GetEnumerator("s0").Advance();
Assert.IsNotNull(stmtInsertWildcardBean.Get("nested1"));
SupportEventTypeAssertionUtil.AssertConsistency(stmtSelectWildcardBean);
SupportEventTypeAssertionUtil.AssertConsistency(env.GetEnumerator("insert").Advance());
Assert.AreEqual(0, stmtSelectWildcardBean.EventType.PropertyNames.Length);
env.UndeployAll();
}
private void RunAssertionPassUnderlying(
EPServiceProvider epService, string typename, FunctionSendEventIntString send)
{
var epl = "select * from " + typename;
var statement = epService.EPAdministrator.CreateEPL(epl);
var listener = new SupportUpdateListener();
statement.Events += listener.Update;
var fields = "myInt,myString".Split(',');
Assert.AreEqual(typeof(int?), statement.EventType.GetPropertyType("myInt").GetBoxedType());
Assert.AreEqual(typeof(string), statement.EventType.GetPropertyType("myString"));
var eventOne = send.Invoke(epService, 3, "some string");
var @event = listener.AssertOneGetNewAndReset();
SupportEventTypeAssertionUtil.AssertConsistency(@event);
Assert.AreEqual(eventOne, @event.Underlying);
EPAssertionUtil.AssertProps(@event, fields, new object[] {3, "some string"});
var eventTwo = send.Invoke(epService, 4, "other string");
@event = listener.AssertOneGetNewAndReset();
Assert.AreEqual(eventTwo, @event.Underlying);
EPAssertionUtil.AssertProps(@event, fields, new object[] {4, "other string"});
statement.Dispose();
}
private void RunAssertionSelectNested(string typename, FunctionSendEvent4Int send)
{
var epl = "select " +
"l1[0].lvl1 as c0, " +
"exists(l1[0].lvl1) as exists_c0, " +
"l1[0].l2[0].lvl2 as c1, " +
"exists(l1[0].l2[0].lvl2) as exists_c1, " +
"l1[0].l2[0].l3[0].lvl3 as c2, " +
"exists(l1[0].l2[0].l3[0].lvl3) as exists_c2, " +
"l1[0].l2[0].l3[0].l4[0].lvl4 as c3, " +
"exists(l1[0].l2[0].l3[0].l4[0].lvl4) as exists_c3 " +
"from `" + typename + '`';
var statement = _epService.EPAdministrator.CreateEPL(epl);
var listener = new SupportUpdateListener();
statement.AddListener(listener);
var fields = "c0,exists_c0,c1,exists_c1,c2,exists_c2,c3,exists_c3".SplitCsv();
foreach (var property in fields)
{
Assert.AreEqual(property.StartsWith("exists") ? typeof(bool?) : typeof(int?), TypeHelper.GetBoxedType(statement.EventType.GetPropertyType(property)));
}
send.Invoke(_epService, 1, 2, 3, 4);
var @event = listener.AssertOneGetNewAndReset();
EPAssertionUtil.AssertProps(@event, fields, new object[] { 1, true, 2, true, 3, true, 4, true });
SupportEventTypeAssertionUtil.AssertConsistency(@event);
send.Invoke(_epService, 10, 5, 50, 400);
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { 10, true, 5, true, 50, true, 400, true });
statement.Dispose();
}
private void RunAssertionBeanNav(EPServiceProvider epService, string typename, ExecEventInfraPropertyNestedSimple.FunctionSendEvent4Int send)
{
var epl = "select * from " + typename;
var statement = epService.EPAdministrator.CreateEPL(epl);
var listener = new SupportUpdateListener();
statement.Events += listener.Update;
send.Invoke(epService, 1, 2, 3, 4);
var @event = listener.AssertOneGetNewAndReset();
EPAssertionUtil.AssertProps(
@event, "l1[0].lvl1,l1[0].l2[0].lvl2,l1[0].l2[0].l3[0].lvl3,l1[0].l2[0].l3[0].l4[0].lvl4".Split(','),
new object[] { 1, 2, 3, 4 });
SupportEventTypeAssertionUtil.AssertConsistency(@event);
var isNative = typename.Equals(BEAN_TYPENAME);
SupportEventTypeAssertionUtil.AssertFragments(
@event, isNative, true, "l1,l1[0].l2,l1[0].l2[0].l3,l1[0].l2[0].l3[0].l4");
SupportEventTypeAssertionUtil.AssertFragments(
@event, isNative, false, "l1[0],l1[0].l2[0],l1[0].l2[0].l3[0],l1[0].l2[0].l3[0].l4[0]");
RunAssertionEventInvalidProp(@event);
statement.Dispose();
}
private void RunAssertionBeanNav(
RegressionEnvironment env,
string typename,
FunctionSendEvent4IntWArrayNested send,
RegressionPath path)
{
var epl = "@Name('s0') select * from " + typename;
env.CompileDeploy(epl, path).AddListener("s0");
send.Invoke(typename, env, 1, 2, 3, 4);
var @event = env.Listener("s0").AssertOneGetNewAndReset();
EPAssertionUtil.AssertProps(
@event,
"l1[0].lvl1,l1[0].l2[0].lvl2,l1[0].l2[0].l3[0].lvl3,l1[0].l2[0].l3[0].l4[0].lvl4".SplitCsv(),
new object[] { 1, 2, 3, 4 });
SupportEventTypeAssertionUtil.AssertConsistency(@event);
var isNative = typename.Equals(BEAN_TYPENAME);
SupportEventTypeAssertionUtil.AssertFragments(@event, isNative, true, "l1,l1[0].l2,l1[0].l2[0].l3,l1[0].l2[0].l3[0].l4");
SupportEventTypeAssertionUtil.AssertFragments(@event, isNative, false, "l1[0],l1[0].l2[0],l1[0].l2[0].l3[0],l1[0].l2[0].l3[0].l4[0]");
RunAssertionEventInvalidProp(@event);
env.UndeployModuleContaining("s0");
}
private void RunAssertion(EPServiceProvider epService,
string typename,
FunctionSendEvent send,
object underlying)
{
RunAssertionTypeValidProp(epService, typename, underlying);
RunAssertionTypeInvalidProp(epService, typename);
string stmtText = "select * from " + typename;
EPStatement stmt = epService.EPAdministrator.CreateEPL(stmtText);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
send.Invoke(epService, underlying);
EventBean @event = listener.AssertOneGetNewAndReset();
EventPropertyGetterMapped mappedGetter = @event.EventType.GetGetterMapped("mapped");
Assert.AreEqual("v1", mappedGetter.Get(@event, "k1"));
EventPropertyGetterIndexed indexedGetter = @event.EventType.GetGetterIndexed("indexed");
Assert.AreEqual("v2", indexedGetter.Get(@event, 1));
RunAssertionEventInvalidProp(@event);
SupportEventTypeAssertionUtil.AssertConsistency(@event);
stmt.Dispose();
}
public override void Run(EPServiceProvider epService)
{
// Note that XPath Node results when transposed must be queried by XPath that is also absolute.
// For example: "nested1" => "/n0:simpleEvent/n0:nested1" results in a Node.
// That result Node's "prop1" => "/n0:simpleEvent/n0:nested1/n0:prop1" and "/n0:nested1/n0:prop1" does NOT result in a value.
// Therefore property transposal is disabled for Property-XPath expressions.
var eventTypeMeta = new ConfigurationEventTypeXMLDOM();
eventTypeMeta.RootElementName = "simpleEvent";
string schemaUri = SupportContainer.Instance.ResourceManager().ResolveResourceURL(CLASSLOADER_SCHEMA_URI).ToString();
eventTypeMeta.SchemaResource = schemaUri;
eventTypeMeta.IsXPathPropertyExpr = true; // <== note this
eventTypeMeta.AddNamespacePrefix("ss", "samples:schemas:simpleSchema");
epService.EPAdministrator.Configuration.AddEventType("TestXMLSchemaType", eventTypeMeta);
// note class not a fragment
EPStatement stmtInsert = epService.EPAdministrator.CreateEPL("insert into MyNestedStream select nested1 from TestXMLSchemaType#lastevent");
EPAssertionUtil.AssertEqualsAnyOrder(new EventPropertyDescriptor[] {
new EventPropertyDescriptor("nested1", typeof(XmlNode), null, false, false, false, false, false),
}, stmtInsert.EventType.PropertyDescriptors);
SupportEventTypeAssertionUtil.AssertConsistency(stmtInsert.EventType);
EventType type = ((EPServiceProviderSPI)epService).EventAdapterService.GetEventTypeByName("TestXMLSchemaType");
SupportEventTypeAssertionUtil.AssertConsistency(type);
Assert.IsNull(type.GetFragmentType("nested1"));
Assert.IsNull(type.GetFragmentType("nested1.nested2"));
SupportXML.SendDefaultEvent(epService.EPRuntime, "ABC");
SupportEventTypeAssertionUtil.AssertConsistency(stmtInsert.First());
}
private void TryAssertionTypableSubqueryMulti(EPServiceProvider epService, string typeType)
{
epService.EPAdministrator.CreateEPL("create " + typeType + " schema EventZero(e0_0 string, e0_1 string)");
epService.EPAdministrator.CreateEPL("create " + typeType + " schema EventOne(e1_0 string, ez EventZero[])");
string[] fields = "e1_0,ez[0].e0_0,ez[0].e0_1,ez[1].e0_0,ez[1].e0_1".Split(',');
EPStatement stmt = epService.EPAdministrator.CreateEPL("" +
"expression thequery {" +
" (select p00 as e0_0, p01 as e0_1 from SupportBean_S0#keepall)" +
"} " +
"insert into EventOne select " +
"TheString as e1_0, " +
"thequery() as ez " +
"from SupportBean");
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
epService.EPRuntime.SendEvent(new SupportBean_S0(1, "x1", "y1"));
epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
EventBean @event = listener.AssertOneGetNewAndReset();
EPAssertionUtil.AssertProps(@event, fields, new object[] { "E1", "x1", "y1", null, null });
SupportEventTypeAssertionUtil.AssertConsistency(@event);
epService.EPRuntime.SendEvent(new SupportBean_S0(2, "x2", "y2"));
epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { "E2", "x1", "y1", "x2", "y2" });
epService.EPAdministrator.DestroyAllStatements();
epService.EPAdministrator.Configuration.RemoveEventType("EventZero", true);
epService.EPAdministrator.Configuration.RemoveEventType("EventOne", true);
}
public void TestWrapperFragmentWithObjectArray()
{
_epService.EPAdministrator.Configuration.AddEventType("TypeLev0", new string[] { "p1id" }, new object[] { typeof(int) });
_epService.EPAdministrator.Configuration.AddEventType("TypeRoot", new string[] { "p0simple", "p0bean" }, new object[] { "TypeLev0", typeof(SupportBeanComplexProps) });
var stmt = _epService.EPAdministrator.CreateEPL("select *, p0simple.p1id + 1 as plusone, p0bean as mybean from TypeRoot");
stmt.AddListener(_listener);
_epService.EPRuntime.SendEvent(new object[] { new object[] { 10 }, SupportBeanComplexProps.MakeDefaultBean() }, "TypeRoot");
var eventBean = _listener.AssertOneGetNewAndReset();
var eventType = eventBean.EventType;
SupportEventTypeAssertionUtil.AssertConsistency(eventType);
// resolve property via fragment
Assert.IsTrue(eventType.GetPropertyDescriptor("p0simple").IsFragment);
Assert.AreEqual(11, eventBean.Get("plusone"));
Assert.AreEqual(10, eventBean.Get("p0simple.p1id"));
var innerSimpleEvent = (EventBean)eventBean.GetFragment("p0simple");
Assert.AreEqual(10, innerSimpleEvent.Get("p1id"));
var innerBeanEvent = (EventBean)eventBean.GetFragment("mybean");
Assert.AreEqual("NestedNestedValue", innerBeanEvent.Get("Nested.NestedNested.NestedNestedValue"));
Assert.AreEqual("NestedNestedValue", ((EventBean)eventBean.GetFragment("mybean.Nested.NestedNested")).Get("NestedNestedValue"));
}
private static void runAssertion(
RegressionEnvironment env,
string eventTypeName,
RegressionPath path)
{
var stmtText = "@Name('s0') select type?,dyn[1]?,nested.nes2?,map('a')? from " + eventTypeName;
env.CompileDeploy(stmtText, path).AddListener("s0");
CollectionAssert.AreEquivalent(
new EventPropertyDescriptor[] {
new EventPropertyDescriptor("type?", typeof(XmlNode), null, false, false, false, false, false),
new EventPropertyDescriptor("dyn[1]?", typeof(XmlNode), null, false, false, false, false, false),
new EventPropertyDescriptor("nested.nes2?", typeof(XmlNode), null, false, false, false, false, false),
new EventPropertyDescriptor("map('a')?", typeof(XmlNode), null, false, false, false, false, false)
},
env.Statement("s0").EventType.PropertyDescriptors);
SupportEventTypeAssertionUtil.AssertConsistency(env.Statement("s0").EventType);
var root = SupportXML.SendXMLEvent(env, NOSCHEMA_XML, eventTypeName);
var theEvent = env.Listener("s0").AssertOneGetNewAndReset();
Assert.AreSame(root.DocumentElement.ChildNodes.Item(0), theEvent.Get("type?"));
Assert.AreSame(root.DocumentElement.ChildNodes.Item(2), theEvent.Get("dyn[1]?"));
Assert.AreSame(root.DocumentElement.ChildNodes.Item(3).ChildNodes.Item(0), theEvent.Get("nested.nes2?"));
Assert.AreSame(root.DocumentElement.ChildNodes.Item(4), theEvent.Get("map('a')?"));
SupportEventTypeAssertionUtil.AssertConsistency(theEvent);
env.UndeployAll();
}
private static void RunAssertion(
RegressionEnvironment env,
String eventTypeName,
RegressionPath path)
{
// Note that XPath Node results when transposed must be queried by XPath that is also absolute.
// For example: "nested1" -> "/n0:simpleEvent/n0:nested1" results in a Node.
// That result Node's "prop1" -> "/n0:simpleEvent/n0:nested1/n0:prop1" and "/n0:nested1/n0:prop1" does NOT result in a value.
// Therefore property transposal is disabled for Property-XPath expressions.
// note class not a fragment
env.CompileDeploy("@Name('s0') insert into MyNestedStream select nested1 from " + eventTypeName + "#lastevent", path);
CollectionAssert.AreEquivalent(
new EventPropertyDescriptor[] {
new EventPropertyDescriptor("nested1", typeof(XmlNode), null, false, false, false, false, false)
},
env.Statement("s0").EventType.PropertyDescriptors);
SupportEventTypeAssertionUtil.AssertConsistency(env.Statement("s0").EventType);
var type = env.Runtime.EventTypeService.GetEventTypePreconfigured(eventTypeName);
SupportEventTypeAssertionUtil.AssertConsistency(type);
Assert.IsNull(type.GetFragmentType("nested1"));
Assert.IsNull(type.GetFragmentType("nested1.Nested2"));
SupportXML.SendDefaultEvent(env.EventService, "ABC", eventTypeName);
SupportEventTypeAssertionUtil.AssertConsistency(env.Statement("s0").First());
env.UndeployAll();
}
private void RunAssertionPassUnderlying(
RegressionEnvironment env,
string typename,
FunctionSendEventIntString send,
RegressionPath path)
{
var epl = "@Name('s0') select * from " + typename;
env.CompileDeploy(epl, path).AddListener("s0");
var fields = "MyInt,MyString".SplitCsv();
Assert.AreEqual(typeof(int?), env.Statement("s0").EventType.GetPropertyType("MyInt").GetBoxedType());
Assert.AreEqual(typeof(string), env.Statement("s0").EventType.GetPropertyType("MyString"));
var eventOne = send.Invoke(typename, env, 3, "some string");
var @event = env.Listener("s0").AssertOneGetNewAndReset();
SupportEventTypeAssertionUtil.AssertConsistency(@event);
AssertUnderlying(typename, eventOne, @event.Underlying);
EPAssertionUtil.AssertProps(@event, fields, new object[] { 3, "some string" });
var eventTwo = send.Invoke(typename, env, 4, "other string");
@event = env.Listener("s0").AssertOneGetNewAndReset();
AssertUnderlying(typename, eventTwo, @event.Underlying);
EPAssertionUtil.AssertProps(@event, fields, new object[] { 4, "other string" });
env.UndeployModuleContaining("s0");
}
public override void Run(EPServiceProvider epService)
{
var stmtText = "select type?,dyn[1]?,nested.nes2?,map('a')? from MyEvent";
var stmt = epService.EPAdministrator.CreateEPL(stmtText);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
EPAssertionUtil.AssertEqualsAnyOrder(new EventPropertyDescriptor[] {
new EventPropertyDescriptor("type?", typeof(XmlNode), null, false, false, false, false, false),
new EventPropertyDescriptor("dyn[1]?", typeof(XmlNode), null, false, false, false, false, false),
new EventPropertyDescriptor("nested.nes2?", typeof(XmlNode), null, false, false, false, false, false),
new EventPropertyDescriptor("map('a')?", typeof(XmlNode), null, false, false, false, false, false),
}, stmt.EventType.PropertyDescriptors);
SupportEventTypeAssertionUtil.AssertConsistency(stmt.EventType);
var root = SupportXML.SendEvent(epService.EPRuntime, NOSCHEMA_XML);
var theEvent = listener.AssertOneGetNewAndReset();
Assert.AreSame(root.DocumentElement.ChildNodes.Item(0), theEvent.Get("type?"));
Assert.AreSame(root.DocumentElement.ChildNodes.Item(1), theEvent.Get("dyn[1]?"));
Assert.AreSame(root.DocumentElement.ChildNodes.Item(3).ChildNodes.Item(0), theEvent.Get("nested.nes2?"));
Assert.AreSame(root.DocumentElement.ChildNodes.Item(4), theEvent.Get("map('a')?"));
SupportEventTypeAssertionUtil.AssertConsistency(theEvent);
}
public override void Run(EPServiceProvider epService)
{
var eventTypeMeta = new ConfigurationEventTypeXMLDOM();
eventTypeMeta.RootElementName = "simpleEvent";
// eventTypeMeta.IsXPathPropertyExpr = false; <== the default
epService.EPAdministrator.Configuration.AddEventType("TestXMLSchemaType", eventTypeMeta);
EPStatement stmtInsert = epService.EPAdministrator.CreateEPL("insert into MyNestedStream select nested1 from TestXMLSchemaType");
EPAssertionUtil.AssertEqualsAnyOrder(new EventPropertyDescriptor[] {
new EventPropertyDescriptor("nested1", typeof(string), typeof(char), false, false, true, false, false),
}, stmtInsert.EventType.PropertyDescriptors);
SupportEventTypeAssertionUtil.AssertConsistency(stmtInsert.EventType);
EPStatement stmtSelectWildcard = epService.EPAdministrator.CreateEPL("select * from TestXMLSchemaType");
EPAssertionUtil.AssertEqualsAnyOrder(new EventPropertyDescriptor[0], stmtSelectWildcard.EventType.PropertyDescriptors);
SupportEventTypeAssertionUtil.AssertConsistency(stmtSelectWildcard.EventType);
SupportXML.SendDefaultEvent(epService.EPRuntime, "test");
EventBean stmtInsertWildcardBean = stmtInsert.First();
EventBean stmtSelectWildcardBean = stmtSelectWildcard.First();
Assert.IsNotNull(stmtInsertWildcardBean.Get("nested1"));
SupportEventTypeAssertionUtil.AssertConsistency(stmtSelectWildcardBean);
SupportEventTypeAssertionUtil.AssertConsistency(stmtInsert.First());
Assert.AreEqual(0, stmtSelectWildcardBean.EventType.PropertyNames.Length);
}
public void Run(RegressionEnvironment env)
{
env.CompileDeploy("@Name('s0') select * from MSTypeOne").AddListener("s0");
IDictionary<string, object> dataInner = new Dictionary<string, object>();
dataInner.Put("p1someval", "A");
IDictionary<string, object> dataRoot = new Dictionary<string, object>();
dataRoot.Put("p0simple", 99);
dataRoot.Put("p0array", new[] {101, 102});
dataRoot.Put("p0map", dataInner);
// send event
env.SendEventMap(dataRoot, "MSTypeOne");
var eventBean = env.Listener("s0").AssertOneGetNewAndReset();
//System.out.println(SupportEventTypeAssertionUtil.print(eventBean)); //comment me in
var eventType = eventBean.EventType;
SupportEventTypeAssertionUtil.AssertConsistency(eventType);
// resolve property via fragment
Assert.IsNull(eventType.GetFragmentType("p0int"));
Assert.IsNull(eventType.GetFragmentType("p0intarray"));
Assert.IsNull(eventBean.GetFragment("p0map?"));
Assert.IsNull(eventBean.GetFragment("p0intarray[0]?"));
Assert.IsNull(eventBean.GetFragment("p0map('a')?"));
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
env.CompileDeploy("@Name('s0') select * from FlywheelRoot").AddListener("s0");
IDictionary<string, object> dataInner = new Dictionary<string, object>();
dataInner.Put("p1id", 10);
IDictionary<string, object> dataRoot = new Dictionary<string, object>();
dataRoot.Put("p0simple", dataInner);
// send event
env.SendEventMap(dataRoot, "FlywheelRoot");
var eventBean = env.Listener("s0").AssertOneGetNewAndReset();
// System.out.println(SupportEventTypeAssertionUtil.print(eventBean)); comment me in
var eventType = eventBean.EventType;
SupportEventTypeAssertionUtil.AssertConsistency(eventType);
Assert.IsFalse(eventType.GetPropertyDescriptor("p0simple").IsFragment);
Assert.IsNull(eventBean.GetFragment("p0simple"));
// resolve property via getter
Assert.AreEqual(10, eventBean.Get("p0simple.p1id"));
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
env.CompileDeploy(
"@Name('s0') select *, p0simple.p1id + 1 as plusone, p0bean as mybean from WheatRoot");
env.AddListener("s0");
env.SendEventObjectArray(
new object[] {new object[] {10}, SupportBeanComplexProps.MakeDefaultBean()},
"WheatRoot");
var eventBean = env.Listener("s0").AssertOneGetNewAndReset();
// System.out.println(SupportEventTypeAssertionUtil.print(eventBean)); comment me in
var eventType = eventBean.EventType;
SupportEventTypeAssertionUtil.AssertConsistency(eventType);
// resolve property via fragment
Assert.IsTrue(eventType.GetPropertyDescriptor("p0simple").IsFragment);
Assert.AreEqual(11, eventBean.Get("plusone"));
Assert.AreEqual(10, eventBean.Get("p0simple.p1id"));
var innerSimpleEvent = (EventBean) eventBean.GetFragment("p0simple");
Assert.AreEqual(10, innerSimpleEvent.Get("p1id"));
var innerBeanEvent = (EventBean) eventBean.GetFragment("mybean");
Assert.AreEqual("NestedNestedValue", innerBeanEvent.Get("Nested.NestedNested.NestedNestedValue"));
Assert.AreEqual(
"NestedNestedValue",
((EventBean) eventBean.GetFragment("mybean.Nested.NestedNested")).Get("NestedNestedValue"));
env.UndeployAll();
}
public void TestObjectArraySimpleTypes()
{
string[] props = { "p0int", "p0intarray", "p0map" };
object[] types = { typeof(int), typeof(int[]), typeof(IDictionary <string, object>) };
_epService.EPAdministrator.Configuration.AddEventType("TypeRoot", props, types);
var stmt = _epService.EPAdministrator.CreateEPL("select * from TypeRoot");
stmt.AddListener(_listener);
IDictionary <string, object> dataInner = new Dictionary <string, object>();
dataInner.Put("p1someval", "A");
var dataRoot = new object[] { 99, new int[] { 101, 102 }, dataInner };
// send event
_epService.EPRuntime.SendEvent(dataRoot, "TypeRoot");
var eventBean = _listener.AssertOneGetNewAndReset();
//System.out.println(SupportEventTypeAssertionUtil.print(eventBean)); //comment me in
var eventType = eventBean.EventType;
SupportEventTypeAssertionUtil.AssertConsistency(eventType);
// resolve property via fragment
Assert.IsNull(eventType.GetFragmentType("p0int"));
Assert.IsNull(eventType.GetFragmentType("p0intarray"));
Assert.IsNull(eventBean.GetFragment("p0map?"));
Assert.IsNull(eventBean.GetFragment("p0intarray[0]?"));
Assert.IsNull(eventBean.GetFragment("p0map('a')?"));
}
public void Run(RegressionEnvironment env)
{
env.CompileDeploy("@Name('s0') select * from LocalTypeRoot").AddListener("s0");
Assert.AreEqual(typeof(object[]), env.Statement("s0").EventType.UnderlyingType);
object[] dataInner = {
new SupportBean("E1", 11), new[] {new SupportBean("A1", 21), new SupportBean("A2", 22)},
SupportBeanComplexProps.MakeDefaultBean(),
new[] {SupportBeanComplexProps.MakeDefaultBean(), SupportBeanComplexProps.MakeDefaultBean()}
};
object[] dataRoot = {
dataInner,
new object[] {dataInner, dataInner}
};
// send event
env.SendEventObjectArray(dataRoot, "LocalTypeRoot");
var eventBean = env.Listener("s0").AssertOneGetNewAndReset();
// System.out.println(SupportEventTypeAssertionUtil.print(eventBean)); comment me in
var eventType = eventBean.EventType;
SupportEventTypeAssertionUtil.AssertConsistency(eventType);
Assert.AreEqual(11, ((EventBean) eventBean.GetFragment("p0simple.p1simple")).Get("IntPrimitive"));
Assert.AreEqual("A2", ((EventBean) eventBean.GetFragment("p0simple.p1array[1]")).Get("TheString"));
Assert.AreEqual(
"Simple",
((EventBean) eventBean.GetFragment("p0simple.p1complex")).Get("SimpleProperty"));
Assert.AreEqual(
"Simple",
((EventBean) eventBean.GetFragment("p0simple.p1complexarray[0]")).Get("SimpleProperty"));
Assert.AreEqual(
"NestedValue",
((EventBean) eventBean.GetFragment("p0simple.p1complexarray[0].Nested")).Get("NestedValue"));
Assert.AreEqual(
"NestedNestedValue",
((EventBean) eventBean.GetFragment("p0simple.p1complexarray[0].Nested.NestedNested")).Get(
"NestedNestedValue"));
var assertEvent = (EventBean) eventBean.GetFragment("p0simple");
Assert.AreEqual("E1", assertEvent.Get("p1simple.TheString"));
Assert.AreEqual(11, ((EventBean) assertEvent.GetFragment("p1simple")).Get("IntPrimitive"));
Assert.AreEqual(22, ((EventBean) assertEvent.GetFragment("p1array[1]")).Get("IntPrimitive"));
Assert.AreEqual(
"NestedNestedValue",
((EventBean) assertEvent.GetFragment("p1complex.Nested.NestedNested")).Get("NestedNestedValue"));
assertEvent = ((EventBean[]) eventBean.GetFragment("p0array"))[0];
Assert.AreEqual("E1", assertEvent.Get("p1simple.TheString"));
Assert.AreEqual(11, ((EventBean) assertEvent.GetFragment("p1simple")).Get("IntPrimitive"));
Assert.AreEqual(22, ((EventBean) assertEvent.GetFragment("p1array[1]")).Get("IntPrimitive"));
assertEvent = (EventBean) eventBean.GetFragment("p0array[0]");
Assert.AreEqual("E1", assertEvent.Get("p1simple.TheString"));
Assert.AreEqual(11, ((EventBean) assertEvent.GetFragment("p1simple")).Get("IntPrimitive"));
Assert.AreEqual(22, ((EventBean) assertEvent.GetFragment("p1array[1]")).Get("IntPrimitive"));
env.UndeployAll();
}
public void TestGetIterableListMap()
{
var eventComplex = SupportBeanIterableProps.MakeDefaultBean();
var eventBean = SupportEventBeanFactory.CreateObject(eventComplex);
SupportEventTypeAssertionUtil.AssertConsistency(eventBean);
// generic interogation : iterable, List and Map
Assert.AreEqual(typeof(IEnumerable <SupportBeanIterableProps.SupportBeanSpecialGetterNested>), eventBean.EventType.GetPropertyType("IterableNested"));
Assert.AreEqual(typeof(SupportBeanIterableProps.SupportBeanSpecialGetterNested), eventBean.EventType.GetPropertyType("IterableNested[0]"));
Assert.AreEqual(typeof(IEnumerable <int?>), eventBean.EventType.GetPropertyType("IterableInteger"));
Assert.AreEqual(typeof(int?), eventBean.EventType.GetPropertyType("IterableInteger[0]"));
Assert.AreEqual(typeof(IList <SupportBeanIterableProps.SupportBeanSpecialGetterNested>), eventBean.EventType.GetPropertyType("ListNested"));
Assert.AreEqual(typeof(SupportBeanIterableProps.SupportBeanSpecialGetterNested), eventBean.EventType.GetPropertyType("ListNested[0]"));
Assert.AreEqual(typeof(IList <int?>), eventBean.EventType.GetPropertyType("ListInteger"));
Assert.AreEqual(typeof(int?), eventBean.EventType.GetPropertyType("ListInteger[0]"));
Assert.AreEqual(typeof(IDictionary <string, SupportBeanIterableProps.SupportBeanSpecialGetterNested>), eventBean.EventType.GetPropertyType("MapNested"));
Assert.AreEqual(typeof(SupportBeanIterableProps.SupportBeanSpecialGetterNested), eventBean.EventType.GetPropertyType("MapNested('a')"));
Assert.AreEqual(typeof(IDictionary <string, int>), eventBean.EventType.GetPropertyType("MapInteger"));
Assert.AreEqual(typeof(int), eventBean.EventType.GetPropertyType("MapInteger('a')"));
Assert.AreEqual(typeof(IEnumerable), eventBean.EventType.GetPropertyType("IterableUndefined"));
Assert.AreEqual(typeof(IEnumerable <object>), eventBean.EventType.GetPropertyType("IterableObject"));
Assert.AreEqual(typeof(Object), eventBean.EventType.GetPropertyType("IterableUndefined[0]"));
Assert.AreEqual(typeof(Object), eventBean.EventType.GetPropertyType("IterableObject[0]"));
Assert.AreEqual(new EventPropertyDescriptor("IterableNested", typeof(IEnumerable <SupportBeanIterableProps.SupportBeanSpecialGetterNested>), typeof(SupportBeanIterableProps.SupportBeanSpecialGetterNested), false, false, true, false, true),
eventBean.EventType.GetPropertyDescriptor("IterableNested"));
Assert.AreEqual(new EventPropertyDescriptor("IterableInteger", typeof(IEnumerable <int?>), typeof(int?), false, false, true, false, false),
eventBean.EventType.GetPropertyDescriptor("IterableInteger"));
Assert.AreEqual(new EventPropertyDescriptor("ListNested", typeof(IList <SupportBeanIterableProps.SupportBeanSpecialGetterNested>), typeof(SupportBeanIterableProps.SupportBeanSpecialGetterNested), false, false, true, false, true),
eventBean.EventType.GetPropertyDescriptor("ListNested"));
Assert.AreEqual(new EventPropertyDescriptor("ListInteger", typeof(IList <int?>), typeof(int?), false, false, true, false, false),
eventBean.EventType.GetPropertyDescriptor("ListInteger"));
Assert.AreEqual(new EventPropertyDescriptor("MapNested", typeof(IDictionary <string, SupportBeanIterableProps.SupportBeanSpecialGetterNested>), typeof(SupportBeanIterableProps.SupportBeanSpecialGetterNested), false, false, false, true, false),
eventBean.EventType.GetPropertyDescriptor("MapNested"));
Assert.AreEqual(new EventPropertyDescriptor("MapInteger", typeof(IDictionary <string, int>), typeof(int), false, false, false, true, false),
eventBean.EventType.GetPropertyDescriptor("MapInteger"));
Assert.AreEqual(new EventPropertyDescriptor("IterableUndefined", typeof(IEnumerable), typeof(object), false, false, true, false, false),
eventBean.EventType.GetPropertyDescriptor("IterableUndefined"));
Assert.AreEqual(new EventPropertyDescriptor("IterableObject", typeof(IEnumerable <object>), typeof(object), false, false, true, false, false),
eventBean.EventType.GetPropertyDescriptor("IterableObject"));
AssertNestedCollection(eventBean, "IterableNested", "I");
AssertNestedCollection(eventBean, "ListNested", "L");
AssertNestedElement(eventBean, "MapNested('a')", "MN1"); // note that property descriptors do not indicate Map-values are fragments
AssertNestedElement(eventBean, "MapNested('b')", "MN2");
AssertNestedElement(eventBean, "ListNested[0]", "LN1");
AssertNestedElement(eventBean, "ListNested[1]", "LN2");
AssertNestedElement(eventBean, "IterableNested[0]", "IN1");
AssertNestedElement(eventBean, "IterableNested[1]", "IN2");
Assert.IsNull(eventBean.EventType.GetFragmentType("IterableInteger"));
Assert.IsNull(eventBean.EventType.GetFragmentType("ListInteger"));
Assert.IsNull(eventBean.EventType.GetFragmentType("IterableInteger[0]"));
Assert.IsNull(eventBean.EventType.GetFragmentType("ListInteger[0]"));
Assert.IsNull(eventBean.EventType.GetFragmentType("MapNested"));
Assert.IsNull(eventBean.EventType.GetFragmentType("MapInteger"));
}
public void Run(RegressionEnvironment env)
{
env.CompileDeploy("@Name('s0') select * from JackTypeRoot").AddListener("s0");
Assert.AreEqual(typeof(object[]), env.Statement("s0").EventType.UnderlyingType);
object[] dataLev1 = {10};
object[] dataLev0 = {
dataLev1,
new object[] {dataLev1, dataLev1}
};
object[] dataRoot = {
dataLev0,
new object[] {dataLev0, dataLev0}
};
// send event
env.SendEventObjectArray(dataRoot, "JackTypeRoot");
var eventBean = env.Listener("s0").AssertOneGetNewAndReset();
// System.out.println(SupportEventTypeAssertionUtil.print(eventBean)); comment me in
var eventType = eventBean.EventType;
SupportEventTypeAssertionUtil.AssertConsistency(eventType);
Assert.AreEqual(10, ((EventBean) eventBean.GetFragment("p0simple.p1simple")).Get("p2id"));
Assert.AreEqual(10, ((EventBean) eventBean.GetFragment("p0array[1].p1simple")).Get("p2id"));
Assert.AreEqual(10, ((EventBean) eventBean.GetFragment("p0array[1].p1array[0]")).Get("p2id"));
Assert.AreEqual(10, ((EventBean) eventBean.GetFragment("p0simple.p1array[0]")).Get("p2id"));
// resolve property via fragment
var assertEvent = (EventBean) eventBean.GetFragment("p0simple");
Assert.AreEqual(10, assertEvent.Get("p1simple.p2id"));
Assert.AreEqual(10, ((EventBean) assertEvent.GetFragment("p1simple")).Get("p2id"));
assertEvent = ((EventBean[]) eventBean.GetFragment("p0array"))[1];
Assert.AreEqual(10, assertEvent.Get("p1simple.p2id"));
Assert.AreEqual(10, ((EventBean) assertEvent.GetFragment("p1simple")).Get("p2id"));
assertEvent = (EventBean) eventBean.GetFragment("p0array[0]");
Assert.AreEqual(10, assertEvent.Get("p1simple.p2id"));
Assert.AreEqual(10, ((EventBean) assertEvent.GetFragment("p1simple")).Get("p2id"));
Assert.AreEqual("JackTypeLev1", eventType.GetFragmentType("p0array.p1simple").FragmentType.Name);
Assert.AreEqual(
typeof(int?),
eventType.GetFragmentType("p0array.p1simple").FragmentType.GetPropertyType("p2id"));
Assert.AreEqual(
typeof(int?),
eventType.GetFragmentType("p0array[0].p1array[0]")
.FragmentType.GetPropertyDescriptor("p2id")
.PropertyType);
Assert.IsFalse(eventType.GetFragmentType("p0simple.p1simple").IsIndexed);
Assert.IsTrue(eventType.GetFragmentType("p0simple.p1array").IsIndexed);
TryInvalid((EventBean) eventBean.GetFragment("p0simple"), "p1simple.p1id");
env.UndeployAll();
}
public void TestMapFragmentMapNested()
{
IDictionary <string, object> typeLev0 = new Dictionary <string, object>();
typeLev0.Put("p1id", typeof(int));
_epService.EPAdministrator.Configuration.AddEventType("TypeLev0", typeLev0);
IDictionary <string, object> mapOuter = new Dictionary <string, object>();
mapOuter.Put("p0simple", "TypeLev0");
mapOuter.Put("p0array", "TypeLev0[]");
_epService.EPAdministrator.Configuration.AddEventType("TypeRoot", mapOuter);
var stmt = _epService.EPAdministrator.CreateEPL("select * from TypeRoot");
stmt.AddListener(_listener);
IDictionary <string, object> dataInner = new Dictionary <string, object>();
dataInner.Put("p1id", 10);
IDictionary <string, object> dataRoot = new Dictionary <string, object>();
dataRoot.Put("p0simple", dataInner);
dataRoot.Put("p0array", new IDictionary <string, object>[] { dataInner, dataInner });
// send event
_epService.EPRuntime.SendEvent(dataRoot, "TypeRoot");
var eventBean = _listener.AssertOneGetNewAndReset();
// System.out.println(SupportEventTypeAssertionUtil.print(eventBean)); comment me in
var eventType = eventBean.EventType;
SupportEventTypeAssertionUtil.AssertConsistency(eventType);
// resolve property via fragment
Assert.IsTrue(eventType.GetPropertyDescriptor("p0simple").IsFragment);
Assert.IsTrue(eventType.GetPropertyDescriptor("p0array").IsFragment);
var innerSimpleEvent = (EventBean)eventBean.GetFragment("p0simple");
Assert.AreEqual(10, innerSimpleEvent.Get("p1id"));
var innerArrayAllEvent = (EventBean[])eventBean.GetFragment("p0array");
Assert.AreEqual(10, innerArrayAllEvent[0].Get("p1id"));
var innerArrayElementEvent = (EventBean)eventBean.GetFragment("p0array[0]");
Assert.AreEqual(10, innerArrayElementEvent.Get("p1id"));
// resolve property via getter
Assert.AreEqual(10, eventBean.Get("p0simple.p1id"));
Assert.AreEqual(10, eventBean.Get("p0array[1].p1id"));
Assert.IsNull(eventType.GetFragmentType("p0array.p1id"));
Assert.IsNull(eventType.GetFragmentType("p0array[0].p1id"));
}
