private static void RunTest(PropTestDesc test, BeanEventType eventType, EventBean eventBean)
{
String propertyName = test.PropertyName;
Assert.AreEqual(test.IsProperty, eventType.IsProperty(propertyName), "isProperty mismatch on '" + propertyName + "',");
Assert.AreEqual(test.Clazz, eventType.GetPropertyType(propertyName), "getPropertyType mismatch on '" + propertyName + "',");
EventPropertyGetter getter = eventType.GetGetter(propertyName);
if (getter == null)
{
Assert.IsFalse(test.HasGetter, "getGetter null on '" + propertyName + "',");
}
else
{
Assert.IsTrue(test.HasGetter, "getGetter not null on '" + propertyName + "',");
if (test.GetterReturnValue == typeof(NullReferenceException))
{
try {
getter.Get(eventBean);
Assert.Fail("getGetter not throwing null pointer on '" + propertyName);
} catch (NullReferenceException) {
// expected
}
}
else
{
var value = getter.Get(eventBean);
Assert.AreEqual(test.GetterReturnValue, value, "getter value mismatch on '" + propertyName + "',");
}
}
}
private static void RunTest(PropTestDesc test, BeanEventType eventType, EventBean eventBean)
{
String propertyName = test.PropertyName;
Assert.AreEqual(test.IsProperty, eventType.IsProperty(propertyName), "isProperty mismatch on '" + propertyName + "',");
Assert.AreEqual(test.Clazz, eventType.GetPropertyType(propertyName), "getPropertyType mismatch on '" + propertyName + "',");
EventPropertyGetter getter = eventType.GetGetterSPI(propertyName);
if (getter == null)
{
Assert.IsFalse(test.HasGetter, "getGetter null on '" + propertyName + "',");
}
else
{
Assert.IsTrue(test.HasGetter, "getGetter not null on '" + propertyName + "',");
#pragma warning disable CS0252 // Possible unintended reference comparison; left hand side needs cast
if (test.GetterReturnValue == typeof(NullReferenceException))
{
#pragma warning restore CS0252 // Possible unintended reference comparison; left hand side needs cast
try {
getter.Get(eventBean);
Assert.Fail("getGetter not throwing null pointer on '" + propertyName);
} catch (NullReferenceException) {
// expected
}
}
else
{
var value = getter.Get(eventBean);
Assert.AreEqual(test.GetterReturnValue, value, "getter value mismatch on '" + propertyName + "',");
}
}
}
public virtual object Evaluate(EvaluateParams evaluateParams)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().QExprIdent(_identNode.FullUnresolvedName);
}
EventBean theEvent = evaluateParams.EventsPerStream[_streamNum];
if (theEvent == null)
{
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.Get().AExprIdent(null);
}
return(null);
}
if (InstrumentationHelper.ENABLED)
{
Object result = _propertyGetter.Get(theEvent);
InstrumentationHelper.Get().AExprIdent(result);
return(result);
}
return(_propertyGetter.Get(theEvent));
}
public void TestGetGetter()
{
EventPropertyGetter getter = _nested[0].GetGetter((BeanEventType)_event.EventType, SupportEventAdapterService.Service);
Assert.AreEqual("NestedValue", getter.Get(_event));
getter = _nested[1].GetGetter((BeanEventType)_event.EventType, SupportEventAdapterService.Service);
Assert.AreEqual("NestedNestedValue", getter.Get(_event));
}
public void TestGetGetter()
{
EventPropertyGetter getter = _nested[0].GetGetter((BeanEventType)_event.EventType, _container.Resolve <EventAdapterService>());
Assert.AreEqual("NestedValue", getter.Get(_event));
getter = _nested[1].GetGetter((BeanEventType)_event.EventType, _container.Resolve <EventAdapterService>());
Assert.AreEqual("NestedNestedValue", getter.Get(_event));
}
public void TestGetGetter()
{
EventPropertyGetter getter = nested[0].GetGetter((BeanEventType)theEvent.EventType,
EventBeanTypedEventFactoryCompileTime.INSTANCE,
supportEventTypeFactory.BEAN_EVENT_TYPE_FACTORY);
Assert.AreEqual("NestedValue", getter.Get(theEvent));
getter = nested[1].GetGetter((BeanEventType)theEvent.EventType, EventBeanTypedEventFactoryCompileTime.INSTANCE, supportEventTypeFactory.BEAN_EVENT_TYPE_FACTORY);
Assert.AreEqual("NestedNestedValue", getter.Get(theEvent));
}
public void Update(Object sender, UpdateEventArgs e)
{
statement = e.Statement;
serviceProvider = e.ServiceProvider;
lastSymbol = (string)symbolGetter.Get(e.NewEvents[0]);
lastVolume = (long?)volumeGetter.Get(e.NewEvents[0]);
}
private void RunAssertionSubscriberAndListener(EPServiceProvider epService)
{
epService.EPAdministrator.Configuration.AddEventType <SupportBean>();
epService.EPAdministrator.CreateEPL("insert into A1 select s.*, 1 as a from SupportBean as s");
EPStatement stmt = epService.EPAdministrator.CreateEPL("select a1.* from A1 as a1");
var listener = new SupportUpdateListener();
var subscriber = new SupportSubscriberRowByRowObjectArrayPlainNStmt();
stmt.Events += listener.Update;
stmt.Subscriber = subscriber;
epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
EventBean theEvent = listener.AssertOneGetNewAndReset();
Assert.AreEqual("E1", theEvent.Get("TheString"));
Assert.AreEqual(1, theEvent.Get("IntPrimitive"));
Assert.That(theEvent.Underlying, Is.InstanceOf <Pair <object, Map> >());
foreach (string property in stmt.EventType.PropertyNames)
{
EventPropertyGetter getter = stmt.EventType.GetGetter(property);
getter.Get(theEvent);
}
}
private ICollection <T> EvaluateInternal <T>(EventBean eventInQuestion)
{
var result = _getter.Get(eventInQuestion);
if (result == null)
{
return(null);
}
var resultType = result.GetType();
if (result is ICollection <T> )
{
return((ICollection <T>)result);
}
if (resultType.IsGenericCollection() || resultType is IEnumerable)
{
return(result.UnwrapWithNulls <T>());
}
Log.Warn(
"Expected iterable-type input from property '" + _propertyName + "' but received " + resultType.FullName);
return(null);
}
private bool HandleIsExistsTrailingChain(object result)
{
for (var i = 1; i < _getterChain.Length; i++)
{
if (result == null) return false;
EventPropertyGetter getter = _getterChain[i];
if (i == _getterChain.Length - 1)
if (getter is BeanEventPropertyGetter)
return ((BeanEventPropertyGetter) getter).IsBeanExistsProperty(result);
else if (result is Map && getter is MapEventPropertyGetter)
return ((MapEventPropertyGetter) getter).IsMapExistsProperty((Map) result);
else if (result is EventBean)
return getter.IsExistsProperty((EventBean) result);
else
return false;
if (getter is BeanEventPropertyGetter)
result = ((BeanEventPropertyGetter) getter).GetBeanProp(result);
else if (result is Map && getter is MapEventPropertyGetter)
result = ((MapEventPropertyGetter) getter).GetMap((Map) result);
else if (result is EventBean)
result = getter.Get((EventBean) result);
else
return false;
}
return false;
}
public void TestSubscriberandListener()
{
_epService.EPAdministrator.Configuration.AddEventType(
"SupportBean", typeof(SupportBean));
_epService.EPAdministrator.CreateEPL(
"insert into A1 select s.*, 1 as a from SupportBean as s");
EPStatement stmt = _epService.EPAdministrator.CreateEPL(
"select a1.* from A1 as a1");
var listener = new SupportUpdateListener();
var subscriber = new MySubscriberRowByRowObjectArr();
stmt.Events += listener.Update;
stmt.Subscriber = subscriber;
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
EventBean theEvent = listener.AssertOneGetNewAndReset();
Assert.AreEqual("E1", theEvent.Get("TheString"));
Assert.AreEqual(1, theEvent.Get("IntPrimitive"));
Assert.IsTrue(theEvent.Underlying is Pair <object, IDictionary <string, object> >);
foreach (String property in stmt.EventType.PropertyNames)
{
EventPropertyGetter getter = stmt.EventType.GetGetter(property);
getter.Get(theEvent);
}
}
private Object HandleGetterTrailingChain(Object result)
{
for (int i = 1; i < _getterChain.Length; i++)
{
if (result == null)
{
return(null);
}
EventPropertyGetter getter = _getterChain[i];
if (result is EventBean)
{
result = getter.Get((EventBean)result);
}
else if (getter is BeanEventPropertyGetter)
{
result = ((BeanEventPropertyGetter)getter).GetBeanProp(result);
}
else if (result is Map && getter is MapEventPropertyGetter)
{
result = ((MapEventPropertyGetter)getter).GetMap((Map)result);
}
else
{
return(null);
}
}
return(result);
}
public object GetFilterValue(MatchedEventMap matchedEvents, ExprEvaluatorContext evaluatorContext)
{
if (evaluatorContext.ContextProperties == null) return null;
var result = _getter.Get(evaluatorContext.ContextProperties);
if (_numberCoercer == null) return result;
return _numberCoercer.Invoke(result);
}
public Object Get(EventBean eventBean)
{
Object result = getter.Get(eventBean);
if (result is XmlNodeList)
{
var nodeList = (XmlNodeList)result;
if (nodeList.Count <= index)
{
return(null);
}
return(nodeList.Item(index));
}
if (result is string)
{
var asString = (string)result;
if (asString.Length <= index)
{
return(null);
}
return(asString[index]);
}
return(null);
}
/// <summary>
/// Returns the value of an event property.
/// </summary>
/// <value></value>
/// <returns> the value of a simple property with the specified name.
/// </returns>
/// <throws> PropertyAccessException - if there is no property of the specified name, or the property cannot be accessed </throws>
public Object this[String property]
{
get
{
EventPropertyGetter getter = variantEventType.GetGetter(property);
return(getter != null?getter.Get(this) : null);
}
}
public object GetFilterValue(MatchedEventMap matchedEvents, ExprEvaluatorContext exprEvaluatorContext)
{
if (exprEvaluatorContext.ContextProperties == null) return null;
var @object = _getter.Get(exprEvaluatorContext.ContextProperties);
if (@object == null) return null;
return @object.AsDouble();
}
public Object Evaluate(Object target, EventBean[] eventsPerStream, bool isNewData, ExprEvaluatorContext exprEvaluatorContext)
{
if (!(target is EventBean))
{
return(null);
}
return(_getter.Get((EventBean)target));
}
private void AssertGetter(
EventBean @event,
EventPropertyGetter getter,
string value)
{
Assert.IsTrue(getter.IsExistsProperty(@event));
Assert.AreEqual(value, getter.Get(@event));
Assert.IsNull(getter.GetFragment(@event));
}
private void AssertGetter(
EventBean @event,
EventPropertyGetter getter,
bool hasValue)
{
Assert.IsTrue(getter.IsExistsProperty(@event));
Assert.AreEqual(hasValue, getter.Get(@event) != null);
Assert.AreEqual(hasValue, getter.GetFragment(@event) != null);
}
public object Evaluate(EvaluateParams evaluateParams)
{
var streamEvent = evaluateParams.EventsPerStream[_streamNum];
if (streamEvent == null)
{
return null;
}
return _getter.Get(streamEvent);
}
public void TestGetGetter()
{
FastClass fastClass = FastClass.Create(typeof(SupportBeanPropertyNames));
EventBean bean = SupportEventBeanFactory.CreateObject(new SupportBeanPropertyNames());
MethodInfo method = typeof(SupportBeanPropertyNames).GetProperty("A").GetGetMethod();
EventPropertyGetter getter = PropertyHelper.GetGetter("A", method, fastClass, _container.Resolve <EventAdapterService>());
Assert.AreEqual("", getter.Get(bean));
}
public void TestGetGetter()
{
EventPropertyGetter getter = _prop.GetGetter(_eventType, SupportEventAdapterService.Service);
Assert.AreEqual("Simple", getter.Get(_theEvent));
Assert.IsNull(_invalidDummy.GetGetter(_eventType, SupportEventAdapterService.Service));
Assert.IsNull(_invalidPropMap.GetGetter(_eventType, SupportEventAdapterService.Service));
Assert.IsNull(_invalidPropIndexed.GetGetter(_eventType, SupportEventAdapterService.Service));
}
public Object Get(string property)
{
EventPropertyGetter getter = _variantEventType.GetGetter(property);
if (getter == null)
{
return(null);
}
return(getter.Get(this));
}
public object Evaluate(object target, EvaluateParams evaluateParams)
{
var timestamp = _getter.Get((EventBean)target);
if (timestamp == null)
{
return(null);
}
return(_inner.Evaluate(timestamp, evaluateParams));
}
public object Evaluate(EvaluateParams evaluateParams)
{
var theEvent = evaluateParams.EventsPerStream[_streamId];
if (theEvent == null)
{
return(null);
}
return(_getter.Get(theEvent));
}
public Object Get(String property)
{
EventPropertyGetter getter = EventType.GetGetter(property);
if (getter == null)
{
throw new PropertyAccessException("Property named '" + property + "' is not a valid property name for this type");
}
return(getter.Get(this));
}
public void TestGetGetter()
{
EventPropertyGetter getter = _prop.GetGetter(_eventType, _container.Resolve <EventAdapterService>());
Assert.AreEqual("Simple", getter.Get(_theEvent));
Assert.IsNull(_invalidDummy.GetGetter(_eventType, _container.Resolve <EventAdapterService>()));
Assert.IsNull(_invalidPropMap.GetGetter(_eventType, _container.Resolve <EventAdapterService>()));
Assert.IsNull(_invalidPropIndexed.GetGetter(_eventType, _container.Resolve <EventAdapterService>()));
}
public void TestGetGetter()
{
EventPropertyGetter getter = prop.GetGetter(eventType, INSTANCE, supportEventTypeFactory.BEAN_EVENT_TYPE_FACTORY);
Assert.AreEqual("simple", getter.Get(theEvent));
Assert.IsNull(invalidDummy.GetGetter(eventType, INSTANCE, supportEventTypeFactory.BEAN_EVENT_TYPE_FACTORY));
Assert.IsNull(invalidPropMap.GetGetter(eventType, INSTANCE, supportEventTypeFactory.BEAN_EVENT_TYPE_FACTORY));
Assert.IsNull(invalidPropIndexed.GetGetter(eventType, INSTANCE, supportEventTypeFactory.BEAN_EVENT_TYPE_FACTORY));
}
public Object Get(String property)
{
EventPropertyGetter getter = RevisionEventType.GetGetter(property);
if (getter == null)
{
return(null);
}
return(getter.Get(this));
}
public object Evaluate(EvaluateParams evaluateParams)
{
var context = evaluateParams.ExprEvaluatorContext;
if (context.ContextProperties != null)
{
return(_getter.Get(context.ContextProperties));
}
return(null);
}