public void SetUp()
{
lockFactory = new FilterServiceGranularLockFactoryReentrant(
container.RWLockManager());
var testBean = new SupportBean();
testBean.IntPrimitive = 50;
testBean.DoublePrimitive = 0.5;
testBean.TheString = "jack";
testBean.LongPrimitive = 10;
testBean.ShortPrimitive = (short)20;
eventBean = SupportEventBeanFactory
.GetInstance(container)
.CreateObject(testBean);
eventType = eventBean.EventType;
matches = new List <FilterHandle>();
// Allocate a couple of callbacks
testFilterCallback = new SupportFilterHandle[20];
for (var i = 0; i < testFilterCallback.Length; i++)
{
testFilterCallback[i] = new SupportFilterHandle();
}
}
public void TestAdd()
{
// Add event without these properties should fail
EventBean theEvent = SupportEventBeanFactory.CreateObject(new SupportBean_A("d"));
try
{
_index.Add(new[] {theEvent});
Assert.Fail();
}
catch (PropertyAccessException ex)
{
// Expected
}
// Add null should fail
try
{
_index.Add(new EventBean[] {null});
Assert.Fail();
}
catch (PropertyAccessException ex)
{
// Expected
}
}
private EventBean[] MakeEvent(String stringValue)
{
SupportBean theEvent = new SupportBean();
theEvent.TheString = stringValue;
return(new EventBean[] { SupportEventBeanFactory.CreateObject(theEvent) });
}
public void TestNodeMatching()
{
SupportBeanSimple eventObject = new SupportBeanSimple("DepositEvent_1", 1);
EventBean eventBean = SupportEventBeanFactory.CreateObject(eventObject);
FilterHandle expr = new SupportFilterHandle();
_testNode.Add(expr);
// Check matching without an index node
List <FilterHandle> matches = new List <FilterHandle>();
_testNode.MatchEvent(eventBean, matches);
Assert.AreEqual(1, matches.Count);
Assert.AreEqual(expr, matches[0]);
matches.Clear();
// Create, add and populate an index node
FilterParamIndexBase index = new FilterParamIndexEquals(
MakeLookupable("MyString", eventBean.EventType), ReaderWriterLockManager.CreateDefaultLock());
_testNode.Add(index);
index["DepositEvent_1"] = _testEvaluator;
// Verify matcher instance stored in index is called
_testNode.MatchEvent(eventBean, matches);
Assert.IsTrue(_testEvaluator.GetAndResetCountInvoked() == 1);
Assert.IsTrue(_testEvaluator.GetLastEvent() == eventBean);
Assert.AreEqual(1, matches.Count);
Assert.AreEqual(expr, matches[0]);
}
public void SetUp()
{
_indexedEventOne = SupportEventBeanFactory.MakeEvents(new String[] { "s1_1", "s1_2" });
_indexedEventTwo = SupportEventBeanFactory.MakeEvents(new String[] { "s2_1", "s2_2" });
_newEventOne = SupportEventBeanFactory.MakeEvents(new String[] { "s1_3" });
_newEventTwo = SupportEventBeanFactory.MakeEvents(new String[] { "s2_3" });
_indexLeft = new UnindexedEventTableImpl(1);
_indexLeft.Add(_indexedEventOne);
_indexRight = new UnindexedEventTableImpl(1);
_indexRight.Add(_indexedEventTwo);
var queryStrategies = new QueryStrategy[2];
var lookupLeft = new TableLookupExecNode(1, new FullTableScanLookupStrategy(_indexRight));
var lookupRight = new TableLookupExecNode(0, new FullTableScanLookupStrategy(_indexLeft));
queryStrategies[0] = new ExecNodeQueryStrategy(0, 2, lookupLeft);
queryStrategies[1] = new ExecNodeQueryStrategy(1, 2, lookupRight);
var indexes = new IDictionary <TableLookupIndexReqKey, EventTable> [2];
indexes[0] = new NullableDictionary <TableLookupIndexReqKey, EventTable>();
indexes[1] = new NullableDictionary <TableLookupIndexReqKey, EventTable>();
indexes[0].Put(new TableLookupIndexReqKey("idxLeft"), _indexLeft);
indexes[1].Put(new TableLookupIndexReqKey("idxLeft"), _indexRight);
_joinSetComposerImpl = new JoinSetComposerImpl(true, indexes, queryStrategies, false, null, true);
}
protected internal static EventBean MakeEvent(int intPrimitive)
{
SupportBean theEvent = new SupportBean();
theEvent.IntPrimitive = intPrimitive;
return(SupportEventBeanFactory.CreateObject(theEvent));
}
public void SetUp()
{
UnindexedEventTable[] indexes = new UnindexedEventTable[4];
for (int i = 0; i < indexes.Length; i++)
{
indexes[i] = new UnindexedEventTableImpl(0);
}
_exec = new NestedIterationExecNode(new int[] { 3, 0, 1 });
_exec.AddChildNode(new TableLookupExecNode(3, new FullTableScanLookupStrategy(indexes[3])));
_exec.AddChildNode(new TableLookupExecNode(0, new FullTableScanLookupStrategy(indexes[0])));
_exec.AddChildNode(new TableLookupExecNode(1, new FullTableScanLookupStrategy(indexes[1])));
_streamEvents = new EventBean[4][];
_streamEvents[0] = SupportEventBeanFactory.MakeEvents_A(new String[] { "a1", "a2" });
_streamEvents[1] = SupportEventBeanFactory.MakeEvents_B(new String[] { "b1", "b2" });
_streamEvents[2] = SupportEventBeanFactory.MakeEvents_C(new String[] { "c1", "c2" });
_streamEvents[3] = SupportEventBeanFactory.MakeEvents_D(new String[] { "d1", "d2" });
// Fill with data
indexes[0].Add(_streamEvents[0]);
indexes[1].Add(_streamEvents[1]);
indexes[2].Add(_streamEvents[2]);
indexes[3].Add(_streamEvents[3]);
}
public void TestGetGetter()
{
SupportBean nestedSupportBean = new SupportBean();
nestedSupportBean.IntPrimitive = 100;
SupportBeanComplexProps complexPropBean = SupportBeanComplexProps.MakeDefaultBean();
Assert.AreEqual(null, _eventType.GetGetter("dummy"));
Object[] values = new Object[] { 20, 20, "a", nestedSupportBean, complexPropBean, null };
EventBean eventBean = new ObjectArrayEventBean(values, _eventType);
Assert.AreEqual(20, _eventType.GetGetter("myInt").Get(eventBean));
Assert.AreEqual(20, _eventType.GetGetter("myIntBoxed").Get(eventBean));
Assert.AreEqual("a", _eventType.GetGetter("myString").Get(eventBean));
Assert.AreEqual(nestedSupportBean, _eventType.GetGetter("mySupportBean").Get(eventBean));
Assert.AreEqual(100, _eventType.GetGetter("mySupportBean.IntPrimitive").Get(eventBean));
Assert.AreEqual("NestedValue", _eventType.GetGetter("myComplexBean.Nested.NestedValue").Get(eventBean));
try
{
eventBean = SupportEventBeanFactory.CreateObject(new Object());
_eventType.GetGetter("myInt").Get(eventBean);
Assert.IsTrue(false);
}
catch (InvalidCastException ex)
{
}
}
public void SetUp()
{
_bean = SupportBeanComplexProps.MakeDefaultBean();
_event = SupportEventBeanFactory.CreateObject(_bean);
_getter = MakeGetter(0);
_getterOutOfBounds = MakeGetter(int.MaxValue);
}
private EventBean MakeEvent(int intPrimitive, int intBoxed)
{
var bean = new SupportBean();
bean.IntPrimitive = intPrimitive;
bean.IntBoxed = intBoxed;
return SupportEventBeanFactory.CreateObject(bean);
}
private EventBean[] MakeEvent(int intPrimitive)
{
var theEvent = new SupportBean();
theEvent.IntPrimitive = intPrimitive;
return(new[] { SupportEventBeanFactory.CreateObject(supportEventTypeFactory, theEvent) });
}
public void TestNodeMatching()
{
var eventObject = new SupportBeanSimple("DepositEvent_1", 1);
var eventBean = SupportEventBeanFactory
.GetInstance(container)
.CreateObject(eventObject);
FilterHandle expr = new SupportFilterHandle();
testNode.Add(expr);
// Check matching without an index node
IList <FilterHandle> matches = new List <FilterHandle>();
testNode.MatchEvent(eventBean, matches, null);
Assert.AreEqual(1, matches.Count);
Assert.AreEqual(expr, matches[0]);
matches.Clear();
// Create, add and populate an index node
FilterParamIndexBase index = new FilterParamIndexEquals(
MakeLookupable("MyString", eventBean.EventType),
new SlimReaderWriterLock());
testNode.Add(index);
index.Put("DepositEvent_1", testEvaluator);
// Verify matcher instance stored in index is called
testNode.MatchEvent(eventBean, matches, null);
Assert.IsTrue(testEvaluator.GetAndResetCountInvoked() == 1);
Assert.IsTrue(testEvaluator.LastEvent == eventBean);
Assert.AreEqual(1, matches.Count);
Assert.AreEqual(expr, matches[0]);
}
private EventBean[] MakeEvent(string stringValue)
{
var theEvent = new SupportBean();
theEvent.TheString = stringValue;
return(new[] { SupportEventBeanFactory.CreateObject(supportEventTypeFactory, theEvent) });
}
public void SetUp()
{
_container = SupportContainer.Reset();
SupportLegacyBean testEvent = new SupportLegacyBean("a");
_unitTestBean = SupportEventBeanFactory.CreateObject(testEvent);
}
public void TestGetValueSet()
{
IList <FilterSpecParam> parameters = SupportFilterSpecBuilder.BuildList(_eventType, new Object[]
{ "IntPrimitive", FilterOperator.EQUAL, 2 });
var numberCoercer = CoercerFactory.GetCoercer(typeof(int), typeof(double));
parameters.Add(new FilterSpecParamEventProp(MakeLookupable("DoubleBoxed"), FilterOperator.EQUAL, "asName", "DoublePrimitive", false, numberCoercer, typeof(double?), "Test"));
FilterSpecCompiled filterSpec = new FilterSpecCompiled(_eventType, "SupportBean", new IList <FilterSpecParam>[] { parameters }, null);
SupportBean eventBean = new SupportBean();
eventBean.DoublePrimitive = 999.999;
EventBean theEvent = SupportEventBeanFactory.CreateObject(eventBean);
MatchedEventMap matchedEvents = new MatchedEventMapImpl(new MatchedEventMapMeta(new String[] { "asName" }, false));
matchedEvents.Add(0, theEvent);
FilterValueSet valueSet = filterSpec.GetValueSet(matchedEvents, null, null);
// Assert the generated filter value container
Assert.AreSame(_eventType, valueSet.EventType);
Assert.AreEqual(2, valueSet.Parameters[0].Length);
// Assert the first param
var param = valueSet.Parameters[0][0];
Assert.AreEqual("IntPrimitive", param.Lookupable.Expression);
Assert.AreEqual(FilterOperator.EQUAL, param.FilterOperator);
Assert.AreEqual(2, param.FilterForValue);
// Assert the second param
param = (FilterValueSetParam)valueSet.Parameters[0][1];
Assert.AreEqual("DoubleBoxed", param.Lookupable.Expression);
Assert.AreEqual(FilterOperator.EQUAL, param.FilterOperator);
Assert.AreEqual(999.999, param.FilterForValue);
}
public void TestFlow()
{
EventBean[] oldDataOne = SupportEventBeanFactory.MakeEvents(new String[] { "a" });
EventBean[] newDataOne = SupportEventBeanFactory.MakeEvents(new String[] { "b" });
EventBean[] oldDataTwo = SupportEventBeanFactory.MakeEvents(new String[] { "c" });
EventBean[] newDataTwo = SupportEventBeanFactory.MakeEvents(new String[] { "d" });
_bufferViewOne.Update(newDataOne, oldDataOne);
_dispatchable.Execute();
Assert.AreEqual(1, _joinExecutionStrategy.GetLastNewDataPerStream()[0].Length);
Assert.AreSame(newDataOne[0], _joinExecutionStrategy.GetLastNewDataPerStream()[0][0]);
Assert.AreSame(oldDataOne[0], _joinExecutionStrategy.GetLastOldDataPerStream()[0][0]);
Assert.IsNull(_joinExecutionStrategy.GetLastNewDataPerStream()[1]);
Assert.IsNull(_joinExecutionStrategy.GetLastOldDataPerStream()[1]);
_bufferViewOne.Update(newDataTwo, oldDataTwo);
_bufferViewTwo.Update(newDataOne, oldDataOne);
_dispatchable.Execute();
Assert.AreEqual(1, _joinExecutionStrategy.GetLastNewDataPerStream()[0].Length);
Assert.AreEqual(1, _joinExecutionStrategy.GetLastNewDataPerStream()[1].Length);
Assert.AreSame(newDataTwo[0], _joinExecutionStrategy.GetLastNewDataPerStream()[0][0]);
Assert.AreSame(oldDataTwo[0], _joinExecutionStrategy.GetLastOldDataPerStream()[0][0]);
Assert.AreSame(newDataOne[0], _joinExecutionStrategy.GetLastNewDataPerStream()[1][0]);
Assert.AreSame(oldDataOne[0], _joinExecutionStrategy.GetLastOldDataPerStream()[1][0]);
}
public void TestFlow()
{
var lookupEvents = SupportEventBeanFactory.MakeMarketDataEvents(new String[] { "a2" });
var result = new List <EventBean[]>();
var prefill = new EventBean[] { lookupEvents[0], null };
// Test lookup on empty index, expect 1 row
_exec.Process(lookupEvents[0], prefill, result, null);
Assert.AreEqual(1, result.Count);
var events = result.FirstOrDefault();
Assert.IsNull(events[1]);
Assert.AreSame(lookupEvents[0], events[0]);
result.Clear();
// Test lookup on filled index, expect row2
var indexEvents = SupportEventBeanFactory.MakeEvents(new String[] { "a1", "a2" });
_index.Add(indexEvents);
_exec.Process(lookupEvents[0], prefill, result, null);
Assert.AreEqual(2, result.Count);
IEnumerator <EventBean[]> it = result.GetEnumerator();
events = it.Advance();
Assert.AreSame(lookupEvents[0], events[0]);
Assert.IsTrue((indexEvents[0] == events[1]) || (indexEvents[1] == events[1]));
events = it.Advance();
Assert.AreSame(lookupEvents[0], events[0]);
Assert.IsTrue((indexEvents[0] == events[1]) || (indexEvents[1] == events[1]));
}
public EventBean MakeEvent()
{
var theEvent = SupportEventBeanFactory.CreateObject(
SupportEventTypeFactory.GetInstance(_container), new SupportBean());
return(theEvent);
}
public void TestSetBehavior()
{
ISet<InterchangeablePair<EventBean, EventBean>> eventPairs = new HashSet<InterchangeablePair<EventBean, EventBean>>();
EventBean[] events = new EventBean[4];
for (int i = 0; i < events.Length; i++)
{
events[i] = SupportEventBeanFactory.CreateObject(
supportEventTypeFactory, new SupportBean("E" + i, i));
}
eventPairs.Add(new InterchangeablePair<EventBean, EventBean>(events[0], events[1]));
eventPairs.Add(new InterchangeablePair<EventBean, EventBean>(events[0], events[2]));
eventPairs.Add(new InterchangeablePair<EventBean, EventBean>(events[1], events[2]));
Assert.AreEqual(3, eventPairs.Count);
eventPairs.Add(new InterchangeablePair<EventBean, EventBean>(events[0], events[1]));
eventPairs.Add(new InterchangeablePair<EventBean, EventBean>(events[1], events[2]));
eventPairs.Add(new InterchangeablePair<EventBean, EventBean>(events[2], events[0]));
eventPairs.Add(new InterchangeablePair<EventBean, EventBean>(events[2], events[1]));
eventPairs.Add(new InterchangeablePair<EventBean, EventBean>(events[1], events[0]));
Assert.AreEqual(3, eventPairs.Count);
Assert.IsTrue(eventPairs.Contains(new InterchangeablePair<EventBean, EventBean>(events[1], events[0])));
Assert.IsFalse(eventPairs.Contains(new InterchangeablePair<EventBean, EventBean>(events[3], events[0])));
Assert.IsTrue(eventPairs.Contains(new InterchangeablePair<EventBean, EventBean>(events[1], events[2])));
Assert.IsTrue(eventPairs.Contains(new InterchangeablePair<EventBean, EventBean>(events[2], events[0])));
eventPairs.Remove(new InterchangeablePair<EventBean, EventBean>(events[2], events[0]));
Assert.IsFalse(eventPairs.Contains(new InterchangeablePair<EventBean, EventBean>(events[2], events[0])));
eventPairs.Remove(new InterchangeablePair<EventBean, EventBean>(events[1], events[2]));
eventPairs.Remove(new InterchangeablePair<EventBean, EventBean>(events[1], events[0]));
Assert.IsTrue(eventPairs.IsEmpty());
}
public void SetUp()
{
_container = SupportContainer.Reset();
_lockFactory = new FilterServiceGranularLockFactoryReentrant(
_container.Resolve <IReaderWriterLockManager>());
var testBean = new SupportBean();
testBean.IntPrimitive = 50;
testBean.DoublePrimitive = 0.5;
testBean.TheString = "jack";
testBean.LongPrimitive = 10;
testBean.ShortPrimitive = (short)20;
_eventBean = SupportEventBeanFactory.CreateObject(testBean);
_eventType = _eventBean.EventType;
_matches = new List <FilterHandle>();
// Allocate a couple of callbacks
_testFilterCallback = new SupportFilterHandle[20];
for (var i = 0; i < _testFilterCallback.Length; i++)
{
_testFilterCallback[i] = new SupportFilterHandle();
}
}
public void TestGetIterableListMapContained()
{
SupportBeanIterablePropsContainer eventIterableContained = SupportBeanIterablePropsContainer.MakeDefaultBean();
EventBean eventBean = SupportEventBeanFactory.CreateObject(eventIterableContained);
Assert.AreEqual(typeof(IEnumerable <SupportBeanIterableProps.SupportBeanSpecialGetterNested>), eventBean.EventType.GetPropertyType("Contained.IterableNested"));
Assert.AreEqual(typeof(SupportBeanIterableProps.SupportBeanSpecialGetterNested), eventBean.EventType.GetPropertyType("Contained.IterableNested[0]"));
Assert.AreEqual(typeof(IEnumerable <int?>), eventBean.EventType.GetPropertyType("Contained.IterableInteger"));
Assert.AreEqual(typeof(int?), eventBean.EventType.GetPropertyType("Contained.IterableInteger[0]"));
Assert.AreEqual(typeof(IList <SupportBeanIterableProps.SupportBeanSpecialGetterNested>), eventBean.EventType.GetPropertyType("Contained.ListNested"));
Assert.AreEqual(typeof(SupportBeanIterableProps.SupportBeanSpecialGetterNested), eventBean.EventType.GetPropertyType("Contained.ListNested[0]"));
Assert.AreEqual(typeof(IList <int?>), eventBean.EventType.GetPropertyType("Contained.ListInteger"));
Assert.AreEqual(typeof(int?), eventBean.EventType.GetPropertyType("Contained.ListInteger[0]"));
Assert.AreEqual(typeof(IDictionary <string, SupportBeanIterableProps.SupportBeanSpecialGetterNested>), eventBean.EventType.GetPropertyType("Contained.MapNested"));
Assert.AreEqual(typeof(SupportBeanIterableProps.SupportBeanSpecialGetterNested), eventBean.EventType.GetPropertyType("Contained.MapNested('a')"));
Assert.AreEqual(typeof(IDictionary <string, int>), eventBean.EventType.GetPropertyType("Contained.MapInteger"));
Assert.AreEqual(typeof(int), eventBean.EventType.GetPropertyType("Contained.MapInteger('a')"));
AssertNestedElement(eventBean, "Contained.MapNested('a')", "MN1"); // note that property descriptors do not indicate Map-values are fragments
AssertNestedElement(eventBean, "Contained.MapNested('b')", "MN2");
AssertNestedElement(eventBean, "Contained.ListNested[0]", "LN1");
AssertNestedElement(eventBean, "Contained.ListNested[1]", "LN2");
AssertNestedElement(eventBean, "Contained.IterableNested[0]", "IN1");
AssertNestedElement(eventBean, "Contained.IterableNested[1]", "IN2");
AssertNestedCollection(eventBean, "Contained.IterableNested", "I");
AssertNestedCollection(eventBean, "Contained.ListNested", "L");
Assert.IsNull(eventBean.EventType.GetFragmentType("Contained.IterableInteger"));
Assert.IsNull(eventBean.EventType.GetFragmentType("Contained.ListInteger"));
Assert.IsNull(eventBean.EventType.GetFragmentType("Contained.IterableInteger[0]"));
Assert.IsNull(eventBean.EventType.GetFragmentType("Contained.ListInteger[0]"));
Assert.IsNull(eventBean.EventType.GetFragmentType("Contained.MapNested"));
Assert.IsNull(eventBean.EventType.GetFragmentType("Contained.MapInteger"));
}
private EventBean MakeEvent(double doublePrimitive)
{
SupportBean theEvent = new SupportBean();
theEvent.DoublePrimitive = doublePrimitive;
return(SupportEventBeanFactory.CreateObject(theEvent));
}
private static EventBean[] MakeEvent(int intPrimitive)
{
SupportBean theEvent = new SupportBean();
theEvent.IntPrimitive = intPrimitive;
return(new EventBean[] { SupportEventBeanFactory.CreateObject(theEvent) });
}
public void TestViewUpdate()
{
var eventData = new Dictionary <String, Object>();
// Generate some events
eventData["STDDEV"] = 100;
EventBean eventBeanOne = SupportEventBeanFactory.CreateMapFromValues(
new Dictionary <String, Object>(eventData), _parentEventType);
eventData["STDDEV"] = 0;
EventBean eventBeanTwo = SupportEventBeanFactory.CreateMapFromValues(
new Dictionary <String, Object>(eventData), _parentEventType);
eventData["STDDEV"] = 99999;
EventBean eventBeanThree = SupportEventBeanFactory.CreateMapFromValues(
new Dictionary <String, Object>(eventData), _parentEventType);
// Send events
_parentView.Update(new EventBean[] { eventBeanOne, eventBeanTwo }, new EventBean[] { eventBeanThree });
// Checks
EventBean[] newData = _childView.LastNewData;
Assert.AreEqual(2, newData.Length);
Assert.AreEqual("IBM", newData[0].Get("Symbol"));
Assert.AreEqual(100, newData[0].Get("STDDEV"));
Assert.AreEqual("IBM", newData[1].Get("Symbol"));
Assert.AreEqual(0, newData[1].Get("STDDEV"));
EventBean[] oldData = _childView.LastOldData;
Assert.AreEqual(1, oldData.Length);
Assert.AreEqual("IBM", oldData[0].Get("Symbol"));
Assert.AreEqual(99999, oldData[0].Get("STDDEV"));
}
private EventBean MakeBean(int intValue, String stringValue)
{
var bean = new SupportBean();
bean.IntPrimitive = intValue;
bean.TheString = stringValue;
return SupportEventBeanFactory.CreateObject(bean);
}
public void TestFlow()
{
var indexEvents = SupportEventBeanFactory.MakeEvents(new String[] { "a1", "a2" });
_index.Add(indexEvents);
var lookupEvents = SupportEventBeanFactory.MakeMarketDataEvents(new String[] { "a2", "a3" });
var result = new List <EventBean[]>();
var prefill = new EventBean[] { lookupEvents[0], null };
_exec.Process(lookupEvents[0], prefill, result, null);
// Test lookup found 1 row
Assert.AreEqual(1, result.Count);
var events = result.FirstOrDefault();
Assert.AreSame(indexEvents[1], events[1]);
Assert.AreSame(lookupEvents[0], events[0]);
// Test lookup found no rows
result.Clear();
_exec.Process(lookupEvents[1], prefill, result, null);
Assert.AreEqual(0, result.Count);
}
public void SetUp()
{
bean = SupportBeanComplexProps.MakeDefaultBean();
theEvent = SupportEventBeanFactory.CreateObject(supportEventTypeFactory, bean);
getter = MakeGetter(0);
getterOutOfBounds = MakeGetter(Int32.MaxValue);
}
protected EventBean MakeEvent(int intPrimitive)
{
SupportBean theEvent = new SupportBean();
theEvent.IntPrimitive = intPrimitive;
return(SupportEventBeanFactory.CreateObject(supportEventTypeFactory, theEvent));
}
public void SetUp()
{
_testEvaluator = new SupportEventEvaluator();
_testBean = new SupportBean();
_testEventBean = SupportEventBeanFactory.CreateObject(_testBean);
_testEventType = _testEventBean.EventType;
_matchesList = new List <FilterHandle>();
}
private EventBean MakeEvent(int aInt, double aDouble)
{
var bean = new SupportBean();
bean.IntPrimitive = aInt;
bean.DoublePrimitive = aDouble;
return(SupportEventBeanFactory.CreateObject(bean));
}
