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)
{
// 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();
}
private void RunAssertionTypeValidProp(
EPServiceProvider epService,
string typeName,
ExecEventInfraPropertyNestedSimple.FunctionSendEvent4Int send,
Type nestedClass,
string fragmentTypeName)
{
var eventType = epService.EPAdministrator.Configuration.GetEventType(typeName);
var arrayType = nestedClass == typeof(object[]) ? nestedClass : TypeHelper.GetArrayType(nestedClass);
var expectedType = new[] { new object[] { "l1", arrayType, fragmentTypeName, true } };
SupportEventTypeAssertionUtil.AssertEventTypeProperties(
expectedType, eventType, SupportEventTypeAssertionEnumExtensions.GetSetWithFragment());
EPAssertionUtil.AssertEqualsAnyOrder(new[] { "l1" }, eventType.PropertyNames);
foreach (var prop in Collections.List("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.AreEqual(arrayType, eventType.GetPropertyType("l1"));
foreach (var prop in Collections.List("l1[0].lvl1", "l1[0].l2[0].lvl2", "l1[0].l2[0].l3[0].lvl3"))
{
Assert.AreEqual(typeof(int?), TypeHelper.GetBoxedType(eventType.GetPropertyType(prop)));
}
var lvl1Fragment = eventType.GetFragmentType("l1");
Assert.IsTrue(lvl1Fragment.IsIndexed);
Assert.AreEqual(send == FBEAN, lvl1Fragment.IsNative);
Assert.AreEqual(fragmentTypeName, lvl1Fragment.FragmentType.Name);
var lvl2Fragment = eventType.GetFragmentType("l1[0].l2");
Assert.IsTrue(lvl2Fragment.IsIndexed);
Assert.AreEqual(send == FBEAN, lvl2Fragment.IsNative);
Assert.AreEqual(
new EventPropertyDescriptor("l1", arrayType, nestedClass, false, false, true, false, true),
eventType.GetPropertyDescriptor("l1"));
}
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();
}
public void Run(RegressionEnvironment env)
{
var fieldsEnumEvent = "c0,c1,c2".SplitCsv();
var eplEnumEvent = "@Name('s0') select " +
"ee() as c0, " +
"ee().allOf(v => v.TheString = 'E1') as c1, " +
"ee().allOf(v => v.IntPrimitive = 1) as c2 " +
"from SupportBean";
env.CompileDeploy(eplEnumEvent).AddListener("s0");
var expectedEnumEvent = new[] {
new object[] { "c0", typeof(SupportBean[]), typeof(SupportBean).FullName, true },
new object[] { "c1", typeof(bool?), null, null },
new object[] { "c2", typeof(bool?), null, null }
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(
expectedEnumEvent,
env.Statement("s0").EventType,
SupportEventTypeAssertionEnumExtensions.GetSetWithFragment());
var eventEnumOne = new SupportBean("E1", 1);
env.SendEventBean(eventEnumOne);
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fieldsEnumEvent,
new object[] { new[] { eventEnumOne }, true, true });
var eventEnumTwo = new SupportBean("E2", 2);
env.SendEventBean(eventEnumTwo);
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fieldsEnumEvent,
new object[] { new[] { eventEnumOne, eventEnumTwo }, false, false });
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
// test single-event return
var fieldsSingleEvent = "c0,c1,c2,c3,c4".SplitCsv();
var eplSingleEvent = "@Name('s0') select " +
"se1() as c0, " +
"se1().allOf(v => v.TheString = 'E1') as c1, " +
"se1().allOf(v => v.IntPrimitive = 1) as c2, " +
"se1().TheString as c3, " +
"se1().IntPrimitive as c4 " +
"from SupportBean";
env.CompileDeploy(eplSingleEvent).AddListener("s0");
var expectedSingleEvent = new[] {
new object[] { "c0", typeof(SupportBean), typeof(SupportBean).FullName, false },
new object[] { "c1", typeof(bool?), null, null },
new object[] { "c2", typeof(bool?), null, null },
new object[] { "c3", typeof(string), null, null },
new object[] { "c4", typeof(int?), null, null },
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(
expectedSingleEvent,
env.Statement("s0").EventType,
SupportEventTypeAssertionEnumExtensions.GetSetWithFragment());
var eventOne = new SupportBean("E1", 1);
env.SendEventBean(eventOne);
EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), fieldsSingleEvent, new object[] { eventOne, true, true, "E1", 1 });
var eventTwo = new SupportBean("E2", 2);
env.SendEventBean(eventTwo);
EPAssertionUtil.AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), fieldsSingleEvent, new object[] { eventTwo, false, false, "E2", 2 });
env.UndeployAll();
}
private void RunAssertionTypeValidProp(EPServiceProvider epService, 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 };
var 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[] {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 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"));
}
private void RunAssertionDifferentReturnTypes(EPServiceProvider epService)
{
// test scalar only
string[] fieldsScalar = "c0,c1".Split(',');
string eplScalar = "select ss(TheString) as c0, ss(IntPrimitive) as c1 from SupportBean";
EPStatement stmtScalar = epService.EPAdministrator.CreateEPL(eplScalar);
var listener = new SupportUpdateListener();
stmtScalar.Events += listener.Update;
var expectedScalar = new object[][] { new object[] { "c0", typeof(string), null, null }, new object[] { "c1", typeof(int), null, null } };
SupportEventTypeAssertionUtil.AssertEventTypeProperties(expectedScalar, stmtScalar.EventType, SupportEventTypeAssertionEnumExtensions.GetSetWithFragment());
epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fieldsScalar, new object[] { "E1", 1 });
epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fieldsScalar, new object[] { "E2", 2 });
stmtScalar.Dispose();
// test scalar-array only
string[] fieldsScalarArray = "c0,c1,c2,c3".Split(',');
string eplScalarArray = "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";
EPStatement stmtScalarArray = epService.EPAdministrator.CreateEPL(eplScalarArray);
stmtScalarArray.Events += listener.Update;
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, stmtScalarArray.EventType, SupportEventTypeAssertionEnumExtensions.GetSetWithFragment());
epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fieldsScalarArray, new object[] {
new string[] { "E1" }, new int[] { 1 }, true, true
});
epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fieldsScalarArray, new object[] {
new string[] { "E1", "E2" }, new int[] { 1, 2 }, false, false
});
stmtScalarArray.Dispose();
// test scalar-collection only
string[] fieldsScalarColl = "c2,c3".Split(',');
string eplScalarColl = "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";
EPStatement stmtScalarColl = epService.EPAdministrator.CreateEPL(eplScalarColl);
stmtScalarColl.Events += listener.Update;
var expectedScalarColl = new object[][] {
new object[] { "c0", typeof(ICollection <string>), null, null },
new object[] { "c1", typeof(ICollection <int>), null, null },
new object[] { "c2", typeof(bool), null, null },
new object[] { "c3", typeof(bool), null, null },
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(expectedScalarColl, stmtScalarColl.EventType, SupportEventTypeAssertionEnumExtensions.GetSetWithFragment());
epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
EPAssertionUtil.AssertEqualsExactOrder(new string[] { "E1" }, listener.AssertOneGetNew().Get("c0").Unwrap <string>());
EPAssertionUtil.AssertEqualsExactOrder(new int[] { 1 }, listener.AssertOneGetNew().Get("c1").Unwrap <int>());
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fieldsScalarColl, new object[] { true, true });
epService.EPRuntime.SendEvent(new SupportBean("E2", 2));
EPAssertionUtil.AssertEqualsExactOrder(new string[] { "E1", "E2" }, listener.AssertOneGetNew().Get("c0").Unwrap <string>());
EPAssertionUtil.AssertEqualsExactOrder(new int[] { 1, 2 }, listener.AssertOneGetNew().Get("c1").Unwrap <int>());
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fieldsScalarColl, new object[] { false, false });
stmtScalarColl.Dispose();
// test single-event return
string[] fieldsSingleEvent = "c0,c1,c2,c3,c4".Split(',');
string eplSingleEvent = "select " +
"se1() as c0, " +
"se1().allOf(v => v.TheString = 'E1') as c1, " +
"se1().allOf(v => v.IntPrimitive = 1) as c2, " +
"se1().TheString as c3, " +
"se1().IntPrimitive as c4 " +
"from SupportBean";
EPStatement stmtSingleEvent = epService.EPAdministrator.CreateEPL(eplSingleEvent);
stmtSingleEvent.Events += listener.Update;
var expectedSingleEvent = new object[][] {
new object[] { "c0", typeof(SupportBean), "SupportBean", false },
new object[] { "c1", typeof(bool), null, null },
new object[] { "c2", typeof(bool), null, null },
new object[] { "c3", typeof(string), null, null },
new object[] { "c4", typeof(int?), null, null },
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(expectedSingleEvent, stmtSingleEvent.EventType, SupportEventTypeAssertionEnumExtensions.GetSetWithFragment());
var eventOne = new SupportBean("E1", 1);
epService.EPRuntime.SendEvent(eventOne);
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fieldsSingleEvent, new object[] { eventOne, true, true, "E1", 1 });
var eventTwo = new SupportBean("E2", 2);
epService.EPRuntime.SendEvent(eventTwo);
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fieldsSingleEvent, new object[] { eventTwo, false, false, "E2", 2 });
stmtSingleEvent.Dispose();
// test single-event return
string[] fieldsEnumEvent = "c0,c1,c2".Split(',');
string eplEnumEvent = "select " +
"ee() as c0, " +
"ee().allOf(v => v.TheString = 'E1') as c1, " +
"ee().allOf(v => v.IntPrimitive = 1) as c2 " +
"from SupportBean";
EPStatement stmtEnumEvent = epService.EPAdministrator.CreateEPL(eplEnumEvent);
stmtEnumEvent.Events += listener.Update;
var expectedEnumEvent = new object[][] {
new object[] { "c0", typeof(SupportBean[]), "SupportBean", true },
new object[] { "c1", typeof(bool), null, null },
new object[] { "c2", typeof(bool), null, null }
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(expectedEnumEvent, stmtEnumEvent.EventType, SupportEventTypeAssertionEnumExtensions.GetSetWithFragment());
var eventEnumOne = new SupportBean("E1", 1);
epService.EPRuntime.SendEvent(eventEnumOne);
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fieldsEnumEvent, new object[] { new SupportBean[] { eventEnumOne }, true, true });
var eventEnumTwo = new SupportBean("E2", 2);
epService.EPRuntime.SendEvent(eventEnumTwo);
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fieldsEnumEvent, new object[] { new SupportBean[] { eventEnumOne, eventEnumTwo }, false, false });
stmtEnumEvent.Dispose();
}
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"));
}
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 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 RunAssertionTypeValidProp(
RegressionEnvironment env,
string typeName,
object underlying)
{
var eventType = env.Runtime.EventTypeService.GetBusEventType(typeName);
var mapType = underlying is GenericRecord
? typeof(IDictionary <string, string>)
: typeof(IDictionary <string, object>);
var mapValueType = mapType.GetDictionaryValueType();
object[][] expectedType =
{
new object[] { "Indexed", typeof(string[]), null, null },
new object[] { "Mapped", mapType, null, null }
};
SupportEventTypeAssertionUtil.AssertEventTypeProperties(expectedType, eventType, SupportEventTypeAssertionEnumExtensions.GetSetWithFragment());
EPAssertionUtil.AssertEqualsAnyOrder(new string[] { "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(mapType, eventType.GetPropertyType("Mapped"));
Assert.AreEqual(mapValueType, eventType.GetPropertyType("Mapped('a')"));
// underlying is GenericRecord ? typeof(ICollection) : typeof(string[]), eventType.GetPropertyType("Indexed")
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",
mapType,
mapValueType,
false,
false,
false,
true,
false),
eventType.GetPropertyDescriptor("Mapped"));
Assert.IsNull(eventType.GetFragmentType("Indexed"));
Assert.IsNull(eventType.GetFragmentType("Mapped"));
}
