public void AddPlugInEnumMethod(
string dtmMethodName,
ConfigurationCompilerPlugInEnumMethod config)
{
ValidateFunctionName("enum-method", dtmMethodName);
if (!IsClassName(config.ForgeClassName))
{
throw new ImportException("Invalid class name for enum-method '" + config.ForgeClassName + "'");
}
_enumMethods.Put(dtmMethodName.ToLowerInvariant(), config);
}
internal static void AssertFileConfig(Configuration config)
{
var container = config.Container;
var common = config.Common;
var compiler = config.Compiler;
var runtime = config.Runtime;
/*
* COMMON
*
*/
// assert name for class
Assert.AreEqual(3, common.EventTypeNames.Count);
Assert.AreEqual("com.mycompany.myapp.MySampleEventOne", common.EventTypeNames.Get("MySampleEventOne"));
Assert.AreEqual("com.mycompany.myapp.MySampleEventTwo", common.EventTypeNames.Get("MySampleEventTwo"));
Assert.AreEqual("com.mycompany.package.MyLegacyTypeEvent", common.EventTypeNames.Get("MyLegacyTypeEvent"));
// need the assembly for commons - to be certain, we are using a class that is not in any of the
// namespaces listed below, but is in the NEsper.Commons assembly.
var commonsAssembly = typeof(BeanEventBean).Assembly;
// assert auto imports
Assert.AreEqual(9, common.Imports.Count);
CollectionAssert.AreEquivalent(
new Import[] {
new ImportNamespace("System"),
new ImportNamespace("System.Text"),
new ImportNamespace("com.espertech.esper.common.internal.epl.dataflow.ops", commonsAssembly.FullName),
new ImportNamespace("com.mycompany.myapp"),
new ImportNamespace("com.mycompany.myapp", "AssemblyA"),
new ImportNamespace("com.mycompany.myapp", "AssemblyB.dll"),
new ImportType("com.mycompany.myapp.ClassOne"),
new ImportType("com.mycompany.myapp.ClassTwo", "AssemblyB.dll"),
ImportBuiltinAnnotations.Instance
},
common.Imports);
// assert XML DOM - no schema
Assert.AreEqual(2, common.EventTypesXMLDOM.Count);
var noSchemaDesc = common.EventTypesXMLDOM.Get("MyNoSchemaXMLEventName");
Assert.AreEqual("MyNoSchemaEvent", noSchemaDesc.RootElementName);
Assert.AreEqual("/myevent/element1", noSchemaDesc.XPathProperties.Get("element1").XPath);
Assert.AreEqual(XPathResultType.Number, noSchemaDesc.XPathProperties.Get("element1").Type);
Assert.IsNull(noSchemaDesc.XPathProperties.Get("element1").OptionalCastToType);
Assert.IsNull(noSchemaDesc.XPathFunctionResolver);
Assert.IsNull(noSchemaDesc.XPathVariableResolver);
Assert.IsFalse(noSchemaDesc.IsXPathPropertyExpr);
// assert XML DOM - with schema
var schemaDesc = common.EventTypesXMLDOM.Get("MySchemaXMLEventName");
Assert.AreEqual("MySchemaEvent", schemaDesc.RootElementName);
Assert.AreEqual("MySchemaXMLEvent.xsd", schemaDesc.SchemaResource);
Assert.AreEqual("actual-xsd-text-here", schemaDesc.SchemaText);
Assert.AreEqual("samples:schemas:simpleSchema", schemaDesc.RootElementNamespace);
Assert.AreEqual("default-name-space", schemaDesc.DefaultNamespace);
Assert.AreEqual("/myevent/element2", schemaDesc.XPathProperties.Get("element2").XPath);
Assert.AreEqual(XPathResultType.String, schemaDesc.XPathProperties.Get("element2").Type);
Assert.AreEqual(typeof(long), schemaDesc.XPathProperties.Get("element2").OptionalCastToType);
Assert.AreEqual("/bookstore/book", schemaDesc.XPathProperties.Get("element3").XPath);
Assert.AreEqual(XPathResultType.NodeSet, schemaDesc.XPathProperties.Get("element3").Type);
Assert.IsNull(schemaDesc.XPathProperties.Get("element3").OptionalCastToType);
Assert.AreEqual("MyOtherXMLNodeEvent", schemaDesc.XPathProperties.Get("element3").OptionalEventTypeName);
Assert.AreEqual(1, schemaDesc.NamespacePrefixes.Count);
Assert.AreEqual("samples:schemas:simpleSchema", schemaDesc.NamespacePrefixes.Get("ss"));
Assert.IsFalse(schemaDesc.IsXPathResolvePropertiesAbsolute);
Assert.AreEqual("com.mycompany.OptionalFunctionResolver", schemaDesc.XPathFunctionResolver);
Assert.AreEqual("com.mycompany.OptionalVariableResolver", schemaDesc.XPathVariableResolver);
Assert.IsTrue(schemaDesc.IsXPathPropertyExpr);
Assert.IsFalse(schemaDesc.IsEventSenderValidatesRoot);
Assert.IsFalse(schemaDesc.IsAutoFragment);
Assert.AreEqual("startts", schemaDesc.StartTimestampPropertyName);
Assert.AreEqual("endts", schemaDesc.EndTimestampPropertyName);
// assert mapped events
Assert.AreEqual(1, common.EventTypesMapEvents.Count);
Assert.IsTrue(common.EventTypesMapEvents.Keys.Contains("MyMapEvent"));
var expectedProps = new HashMap <string, string>();
expectedProps.Put("myInt", "int");
expectedProps.Put("myString", "string");
Assert.AreEqual(expectedProps, common.EventTypesMapEvents.Get("MyMapEvent"));
Assert.AreEqual(1, common.MapTypeConfigurations.Count);
var superTypes = common.MapTypeConfigurations.Get("MyMapEvent").SuperTypes;
EPAssertionUtil.AssertEqualsExactOrder(new object[] { "MyMapSuperType1", "MyMapSuperType2" }, superTypes.ToArray());
Assert.AreEqual("startts", common.MapTypeConfigurations.Get("MyMapEvent").StartTimestampPropertyName);
Assert.AreEqual("endts", common.MapTypeConfigurations.Get("MyMapEvent").EndTimestampPropertyName);
// assert objectarray events
Assert.AreEqual(1, common.EventTypesNestableObjectArrayEvents.Count);
Assert.IsTrue(common.EventTypesNestableObjectArrayEvents.ContainsKey("MyObjectArrayEvent"));
var expectedPropsObjectArray = new HashMap <string, string>();
expectedPropsObjectArray.Put("myInt", "int");
expectedPropsObjectArray.Put("myString", "string");
Assert.AreEqual(expectedPropsObjectArray, common.EventTypesNestableObjectArrayEvents.Get("MyObjectArrayEvent"));
Assert.AreEqual(1, common.ObjectArrayTypeConfigurations.Count);
var superTypesOA = common.ObjectArrayTypeConfigurations.Get("MyObjectArrayEvent").SuperTypes;
EPAssertionUtil.AssertEqualsExactOrder(new object[] { "MyObjectArraySuperType1", "MyObjectArraySuperType2" }, superTypesOA.ToArray());
Assert.AreEqual("startts", common.ObjectArrayTypeConfigurations.Get("MyObjectArrayEvent").StartTimestampPropertyName);
Assert.AreEqual("endts", common.ObjectArrayTypeConfigurations.Get("MyObjectArrayEvent").EndTimestampPropertyName);
// assert avro events
Assert.AreEqual(2, common.EventTypesAvro.Count);
var avroOne = common.EventTypesAvro.Get("MyAvroEvent");
Assert.AreEqual(
"{\"type\":\"record\",\"name\":\"typename\",\"fields\":[{\"name\":\"num\",\"type\":\"int\"}]}", avroOne.AvroSchemaText);
Assert.IsNull(avroOne.AvroSchema);
Assert.IsNull(avroOne.StartTimestampPropertyName);
Assert.IsNull(avroOne.EndTimestampPropertyName);
Assert.IsTrue(avroOne.SuperTypes.IsEmpty());
var avroTwo = common.EventTypesAvro.Get("MyAvroEventTwo");
Assert.AreEqual(
"{\"type\":\"record\",\"name\":\"MyAvroEvent\",\"fields\":[{\"name\":\"carId\",\"type\":\"int\"},{\"name\":\"carType\",\"type\":{\"type\":\"string\",\"avro.string\":\"string\"}}]}",
avroTwo.AvroSchemaText);
Assert.AreEqual("startts", avroTwo.StartTimestampPropertyName);
Assert.AreEqual("endts", avroTwo.EndTimestampPropertyName);
Assert.AreEqual("[\"SomeSuperAvro\", \"SomeSuperAvroTwo\"]", avroTwo.SuperTypes.RenderAny());
// assert legacy type declaration
Assert.AreEqual(1, common.EventTypesBean.Count);
var legacy = common.EventTypesBean.Get("MyLegacyTypeEvent");
Assert.AreEqual(AccessorStyle.PUBLIC, legacy.AccessorStyle);
Assert.AreEqual(1, legacy.FieldProperties.Count);
Assert.AreEqual("myFieldName", legacy.FieldProperties[0].AccessorFieldName);
Assert.AreEqual("myfieldprop", legacy.FieldProperties[0].Name);
Assert.AreEqual(1, legacy.MethodProperties.Count);
Assert.AreEqual("myAccessorMethod", legacy.MethodProperties[0].AccessorMethodName);
Assert.AreEqual("mymethodprop", legacy.MethodProperties[0].Name);
Assert.AreEqual(PropertyResolutionStyle.CASE_INSENSITIVE, legacy.PropertyResolutionStyle);
Assert.AreEqual("com.mycompany.myapp.MySampleEventFactory.createMyLegacyTypeEvent", legacy.FactoryMethod);
Assert.AreEqual("myCopyMethod", legacy.CopyMethod);
Assert.AreEqual("startts", legacy.StartTimestampPropertyName);
Assert.AreEqual("endts", legacy.EndTimestampPropertyName);
// assert database reference - data source config
Assert.AreEqual(2, common.DatabaseReferences.Count);
var configDBRef = common.DatabaseReferences.Get("mydb1");
var dbDef = (DriverConnectionFactoryDesc)configDBRef.ConnectionFactoryDesc;
var dbDriver = DbDriverConnectionHelper.ResolveDriver(container, dbDef);
Assert.AreEqual("com.espertech.esper.epl.db.drivers.DbDriverPgSQL", dbDriver.GetType().FullName);
Assert.AreEqual("Host=nesper-pgsql-integ.local;Database=test;Username=esper;Password=3sp3rP@ssw0rd;", dbDriver.ConnectionString);
Assert.AreEqual(ConnectionLifecycleEnum.POOLED, configDBRef.ConnectionLifecycleEnum);
Assert.IsNull(configDBRef.ConnectionSettings.AutoCommit);
Assert.IsNull(configDBRef.ConnectionSettings.Catalog);
Assert.IsNull(configDBRef.ConnectionSettings.TransactionIsolation);
var lruCache = (ConfigurationCommonCacheLRU)configDBRef.DataCacheDesc;
Assert.AreEqual(10, lruCache.Size);
Assert.AreEqual(ColumnChangeCaseEnum.LOWERCASE, configDBRef.ColumnChangeCase);
Assert.AreEqual(MetadataOriginEnum.SAMPLE, configDBRef.MetadataRetrievalEnum);
//Assert.AreEqual(2, configDBRef.DataTypesMapping.Count);
//Assert.AreEqual("int", configDBRef.DataTypesMapping[2]);
//Assert.AreEqual("float", configDBRef.DataTypesMapping[6]);
// assert database reference - driver manager config
configDBRef = common.DatabaseReferences.Get("mydb2");
var dmDef = (DriverConnectionFactoryDesc)configDBRef.ConnectionFactoryDesc;
var dmDriver = DbDriverConnectionHelper.ResolveDriver(container, dmDef);
Assert.AreEqual("com.espertech.esper.epl.db.drivers.DbDriverPgSQL", dmDriver.GetType().FullName);
Assert.AreEqual("Host=nesper-pgsql-integ.local;Database=test;Username=esper;Password=3sp3rP@ssw0rd;", dmDriver.ConnectionString);
Assert.AreEqual(ConnectionLifecycleEnum.RETAIN, configDBRef.ConnectionLifecycleEnum);
Assert.AreEqual(false, configDBRef.ConnectionSettings.AutoCommit);
Assert.AreEqual("test", configDBRef.ConnectionSettings.Catalog);
Assert.AreEqual(IsolationLevel.ReadCommitted, configDBRef.ConnectionSettings.TransactionIsolation);
var expCache = (ConfigurationCommonCacheExpiryTime)configDBRef.DataCacheDesc;
Assert.AreEqual(60.5, expCache.MaxAgeSeconds);
Assert.AreEqual(120.1, expCache.PurgeIntervalSeconds);
Assert.AreEqual(CacheReferenceType.HARD, expCache.CacheReferenceType);
Assert.AreEqual(ColumnChangeCaseEnum.UPPERCASE, configDBRef.ColumnChangeCase);
Assert.AreEqual(MetadataOriginEnum.METADATA, configDBRef.MetadataRetrievalEnum);
//Assert.AreEqual(1, configDBRef.DataTypesMapping.Count);
//Assert.AreEqual("System.String", configDBRef.DataTypesMapping[99]);
Assert.AreEqual(PropertyResolutionStyle.DISTINCT_CASE_INSENSITIVE, common.EventMeta.ClassPropertyResolutionStyle);
Assert.AreEqual(AccessorStyle.PUBLIC, common.EventMeta.DefaultAccessorStyle);
Assert.AreEqual(EventUnderlyingType.MAP, common.EventMeta.DefaultEventRepresentation);
Assert.IsFalse(common.EventMeta.AvroSettings.IsEnableAvro);
Assert.IsFalse(common.EventMeta.AvroSettings.IsEnableNativeString);
Assert.IsFalse(common.EventMeta.AvroSettings.IsEnableSchemaDefaultNonNull);
Assert.AreEqual("myObjectValueTypeWidenerFactoryClass", common.EventMeta.AvroSettings.ObjectValueTypeWidenerFactoryClass);
Assert.AreEqual("myTypeToRepresentationMapperClass", common.EventMeta.AvroSettings.TypeRepresentationMapperClass);
Assert.IsTrue(common.Logging.IsEnableQueryPlan);
Assert.IsTrue(common.Logging.IsEnableADO);
Assert.AreEqual(TimeUnit.MICROSECONDS, common.TimeSource.TimeUnit);
// variables
Assert.AreEqual(3, common.Variables.Count);
var variable = common.Variables.Get("var1");
Assert.AreEqual(typeof(int).FullName, variable.VariableType);
Assert.AreEqual("1", variable.InitializationValue);
Assert.IsFalse(variable.IsConstant);
variable = common.Variables.Get("var2");
Assert.AreEqual(typeof(string).FullName, variable.VariableType);
Assert.IsNull(variable.InitializationValue);
Assert.IsFalse(variable.IsConstant);
variable = common.Variables.Get("var3");
Assert.IsTrue(variable.IsConstant);
// method references
Assert.AreEqual(2, common.MethodInvocationReferences.Count);
var methodRef = common.MethodInvocationReferences.Get("abc");
expCache = (ConfigurationCommonCacheExpiryTime)methodRef.DataCacheDesc;
Assert.AreEqual(91.0, expCache.MaxAgeSeconds);
Assert.AreEqual(92.2, expCache.PurgeIntervalSeconds);
Assert.AreEqual(CacheReferenceType.WEAK, expCache.CacheReferenceType);
methodRef = common.MethodInvocationReferences.Get("def");
lruCache = (ConfigurationCommonCacheLRU)methodRef.DataCacheDesc;
Assert.AreEqual(20, lruCache.Size);
// variance types
Assert.AreEqual(1, common.VariantStreams.Count);
var configVStream = common.VariantStreams.Get("MyVariantStream");
Assert.AreEqual(2, configVStream.VariantTypeNames.Count);
Assert.IsTrue(configVStream.VariantTypeNames.Contains("MyEvenTypetNameOne"));
Assert.IsTrue(configVStream.VariantTypeNames.Contains("MyEvenTypetNameTwo"));
Assert.AreEqual(TypeVariance.ANY, configVStream.TypeVariance);
Assert.AreEqual(ThreadingProfile.LARGE, common.Execution.ThreadingProfile);
Assert.AreEqual(2, common.EventTypeAutoNameNamespaces.Count);
Assert.AreEqual("com.mycompany.eventsone", common.EventTypeAutoNameNamespaces.ToArray()[0]);
Assert.AreEqual("com.mycompany.eventstwo", common.EventTypeAutoNameNamespaces.ToArray()[1]);
/*
* COMPILER
*
*/
// assert custom view implementations
var configViews = compiler.PlugInViews;
Assert.AreEqual(2, configViews.Count);
for (var i = 0; i < configViews.Count; i++)
{
var entry = configViews[i];
Assert.AreEqual("ext" + i, entry.Namespace);
Assert.AreEqual("myview" + i, entry.Name);
Assert.AreEqual("com.mycompany.MyViewForge" + i, entry.ForgeClassName);
}
// assert custom virtual data window implementations
var configVDW = compiler.PlugInVirtualDataWindows;
Assert.AreEqual(2, configVDW.Count);
for (var i = 0; i < configVDW.Count; i++)
{
var entry = configVDW[i];
Assert.AreEqual("vdw" + i, entry.Namespace);
Assert.AreEqual("myvdw" + i, entry.Name);
Assert.AreEqual("com.mycompany.MyVdwForge" + i, entry.ForgeClassName);
if (i == 1)
{
Assert.AreEqual("abc", entry.Config);
}
}
// assert plug-in aggregation function loaded
Assert.AreEqual(2, compiler.PlugInAggregationFunctions.Count);
var pluginAgg = compiler.PlugInAggregationFunctions[0];
Assert.AreEqual("func1a", pluginAgg.Name);
Assert.AreEqual("com.mycompany.MyMatrixAggregationMethod0Forge", pluginAgg.ForgeClassName);
pluginAgg = compiler.PlugInAggregationFunctions[1];
Assert.AreEqual("func2a", pluginAgg.Name);
Assert.AreEqual("com.mycompany.MyMatrixAggregationMethod1Forge", pluginAgg.ForgeClassName);
// assert plug-in aggregation multi-function loaded
Assert.AreEqual(1, compiler.PlugInAggregationMultiFunctions.Count);
var pluginMultiAgg = compiler.PlugInAggregationMultiFunctions[0];
EPAssertionUtil.AssertEqualsExactOrder(new[] { "func1", "func2" }, pluginMultiAgg.FunctionNames);
Assert.AreEqual("com.mycompany.MyAggregationMultiFunctionForge", pluginMultiAgg.MultiFunctionForgeClassName);
Assert.AreEqual(1, pluginMultiAgg.AdditionalConfiguredProperties.Count);
Assert.AreEqual("value1", pluginMultiAgg.AdditionalConfiguredProperties.Get("prop1"));
// assert plug-in single-row function loaded
Assert.AreEqual(2, compiler.PlugInSingleRowFunctions.Count);
var pluginSingleRow = compiler.PlugInSingleRowFunctions[0];
Assert.AreEqual("com.mycompany.MyMatrixSingleRowMethod0", pluginSingleRow.FunctionClassName);
Assert.AreEqual("method1", pluginSingleRow.FunctionMethodName);
Assert.AreEqual("func3", pluginSingleRow.Name);
Assert.AreEqual(ConfigurationCompilerPlugInSingleRowFunction.ValueCacheEnum.DISABLED, pluginSingleRow.ValueCache);
Assert.AreEqual(ConfigurationCompilerPlugInSingleRowFunction.FilterOptimizableEnum.ENABLED, pluginSingleRow.FilterOptimizable);
Assert.IsFalse(pluginSingleRow.RethrowExceptions);
pluginSingleRow = compiler.PlugInSingleRowFunctions[1];
Assert.AreEqual("com.mycompany.MyMatrixSingleRowMethod1", pluginSingleRow.FunctionClassName);
Assert.AreEqual("func4", pluginSingleRow.Name);
Assert.AreEqual("method2", pluginSingleRow.FunctionMethodName);
Assert.AreEqual(ConfigurationCompilerPlugInSingleRowFunction.ValueCacheEnum.ENABLED, pluginSingleRow.ValueCache);
Assert.AreEqual(ConfigurationCompilerPlugInSingleRowFunction.FilterOptimizableEnum.DISABLED, pluginSingleRow.FilterOptimizable);
Assert.IsTrue(pluginSingleRow.RethrowExceptions);
Assert.AreEqual("XYZEventTypeName", pluginSingleRow.EventTypeName);
// assert plug-in guard objects loaded
Assert.AreEqual(4, compiler.PlugInPatternObjects.Count);
var pluginPattern = compiler.PlugInPatternObjects[0];
Assert.AreEqual("com.mycompany.MyGuardForge0", pluginPattern.ForgeClassName);
Assert.AreEqual("ext0", pluginPattern.Namespace);
Assert.AreEqual("guard1", pluginPattern.Name);
Assert.AreEqual(PatternObjectType.GUARD, pluginPattern.PatternObjectType);
pluginPattern = compiler.PlugInPatternObjects[1];
Assert.AreEqual("com.mycompany.MyGuardForge1", pluginPattern.ForgeClassName);
Assert.AreEqual("ext1", pluginPattern.Namespace);
Assert.AreEqual("guard2", pluginPattern.Name);
Assert.AreEqual(PatternObjectType.GUARD, pluginPattern.PatternObjectType);
pluginPattern = compiler.PlugInPatternObjects[2];
Assert.AreEqual("com.mycompany.MyObserverForge0", pluginPattern.ForgeClassName);
Assert.AreEqual("ext0", pluginPattern.Namespace);
Assert.AreEqual("observer1", pluginPattern.Name);
Assert.AreEqual(PatternObjectType.OBSERVER, pluginPattern.PatternObjectType);
pluginPattern = compiler.PlugInPatternObjects[3];
Assert.AreEqual("com.mycompany.MyObserverForge1", pluginPattern.ForgeClassName);
Assert.AreEqual("ext1", pluginPattern.Namespace);
Assert.AreEqual("observer2", pluginPattern.Name);
Assert.AreEqual(PatternObjectType.OBSERVER, pluginPattern.PatternObjectType);
// assert plug-in date-time method and enum-method
IList <ConfigurationCompilerPlugInDateTimeMethod> configDTM = compiler.PlugInDateTimeMethods;
Assert.AreEqual(1, configDTM.Count);
ConfigurationCompilerPlugInDateTimeMethod dtmOne = configDTM[0];
Assert.AreEqual("methodname1", dtmOne.Name);
Assert.AreEqual("com.mycompany.MyDateTimeMethodForge", dtmOne.ForgeClassName);
IList <ConfigurationCompilerPlugInEnumMethod> configENM = compiler.PlugInEnumMethods;
Assert.AreEqual(1, configENM.Count);
ConfigurationCompilerPlugInEnumMethod enmOne = configENM[0];
Assert.AreEqual("methodname2", enmOne.Name);
Assert.AreEqual("com.mycompany.MyEnumMethodForge", enmOne.ForgeClassName);
Assert.IsTrue(compiler.ViewResources.IsIterableUnbound);
Assert.IsFalse(compiler.ViewResources.IsOutputLimitOpt);
Assert.IsTrue(compiler.Logging.IsEnableCode);
Assert.IsTrue(compiler.Logging.IsEnableFilterPlan);
Assert.AreEqual(StreamSelector.RSTREAM_ISTREAM_BOTH, compiler.StreamSelection.DefaultStreamSelector);
var byteCode = compiler.ByteCode;
Assert.IsTrue(byteCode.IsIncludeComments);
Assert.IsTrue(byteCode.IsIncludeDebugSymbols);
Assert.IsFalse(byteCode.IsAttachEPL);
Assert.IsTrue(byteCode.IsAttachModuleEPL);
Assert.IsTrue(byteCode.IsAttachPatternEPL);
Assert.IsTrue(byteCode.IsInstrumented);
Assert.IsTrue(byteCode.IsAllowSubscriber);
Assert.AreEqual(NameAccessModifier.INTERNAL, byteCode.AccessModifierContext);
Assert.AreEqual(NameAccessModifier.PUBLIC, byteCode.AccessModifierEventType);
Assert.AreEqual(NameAccessModifier.INTERNAL, byteCode.AccessModifierExpression);
Assert.AreEqual(NameAccessModifier.PUBLIC, byteCode.AccessModifierNamedWindow);
Assert.AreEqual(NameAccessModifier.INTERNAL, byteCode.AccessModifierScript);
Assert.AreEqual(NameAccessModifier.PUBLIC, byteCode.AccessModifierTable);
Assert.AreEqual(NameAccessModifier.INTERNAL, byteCode.AccessModifierVariable);
Assert.AreEqual(EventTypeBusModifier.BUS, byteCode.BusModifierEventType);
Assert.AreEqual(1234, byteCode.ThreadPoolCompilerNumThreads);
Assert.AreEqual(4321, (int)byteCode.ThreadPoolCompilerCapacity);
Assert.AreEqual(5555, byteCode.MaxMethodsPerClass);
Assert.IsFalse(byteCode.IsAllowInlinedClass);
Assert.AreEqual(StreamSelector.RSTREAM_ISTREAM_BOTH, compiler.StreamSelection.DefaultStreamSelector);
Assert.AreEqual(100, compiler.Execution.FilterServiceMaxFilterWidth);
Assert.AreEqual(ConfigurationCompilerExecution.FilterIndexPlanningEnum.NONE, compiler.Execution.FilterIndexPlanning);
Assert.IsFalse(compiler.Execution.IsEnabledDeclaredExprValueCache);
Assert.IsTrue(compiler.Language.IsSortUsingCollator);
Assert.IsTrue(compiler.Expression.IsIntegerDivision);
Assert.IsTrue(compiler.Expression.IsDivisionByZeroReturnsNull);
Assert.IsFalse(compiler.Expression.IsUdfCache);
Assert.IsFalse(compiler.Expression.IsExtendedAggregation);
Assert.IsTrue(compiler.Expression.IsDuckTyping);
Assert.AreEqual(2, compiler.Expression.MathContext.Precision);
Assert.AreEqual(MidpointRounding.ToEven, compiler.Expression.MathContext.RoundingMode);
Assert.AreEqual("abc", compiler.Scripts.DefaultDialect);
Assert.IsFalse(compiler.Scripts.IsEnabled);
Assert.IsFalse(compiler.Serde.IsEnableExtendedBuiltin);
Assert.IsTrue(compiler.Serde.IsEnableExternalizable);
Assert.IsTrue(compiler.Serde.IsEnableSerializable);
Assert.IsTrue(compiler.Serde.IsEnableSerializationFallback);
IList <String> serdeProviderFactories = compiler.Serde.SerdeProviderFactories;
Assert.AreEqual(2, serdeProviderFactories.Count);
Assert.AreEqual("a.b.c.MySerdeProviderFactoryOne", serdeProviderFactories[0]);
Assert.AreEqual("a.b.c.MySerdeProviderFactoryTwo", serdeProviderFactories[1]);
/*
* RUNTIME
*
*/
// assert runtime defaults
Assert.IsFalse(runtime.Threading.IsInsertIntoDispatchPreserveOrder);
Assert.AreEqual(3000, runtime.Threading.InsertIntoDispatchTimeout);
Assert.AreEqual(Locking.SUSPEND, runtime.Threading.InsertIntoDispatchLocking);
Assert.IsFalse(runtime.Threading.IsNamedWindowConsumerDispatchPreserveOrder);
Assert.AreEqual(4000, runtime.Threading.NamedWindowConsumerDispatchTimeout);
Assert.AreEqual(Locking.SUSPEND, runtime.Threading.NamedWindowConsumerDispatchLocking);
Assert.IsFalse(runtime.Threading.IsListenerDispatchPreserveOrder);
Assert.AreEqual(2000, runtime.Threading.ListenerDispatchTimeout);
Assert.AreEqual(Locking.SUSPEND, runtime.Threading.ListenerDispatchLocking);
Assert.IsTrue(runtime.Threading.IsThreadPoolInbound);
Assert.IsTrue(runtime.Threading.IsThreadPoolOutbound);
Assert.IsTrue(runtime.Threading.IsThreadPoolRouteExec);
Assert.IsTrue(runtime.Threading.IsThreadPoolTimerExec);
Assert.AreEqual(1, runtime.Threading.ThreadPoolInboundNumThreads);
Assert.AreEqual(2, runtime.Threading.ThreadPoolOutboundNumThreads);
Assert.AreEqual(3, runtime.Threading.ThreadPoolTimerExecNumThreads);
Assert.AreEqual(4, runtime.Threading.ThreadPoolRouteExecNumThreads);
Assert.AreEqual(1000, (int)runtime.Threading.ThreadPoolInboundCapacity);
Assert.AreEqual(1500, (int)runtime.Threading.ThreadPoolOutboundCapacity);
Assert.IsNull(runtime.Threading.ThreadPoolTimerExecCapacity);
Assert.AreEqual(2000, (int)runtime.Threading.ThreadPoolRouteExecCapacity);
Assert.IsTrue(runtime.Threading.IsRuntimeFairlock);
Assert.IsFalse(runtime.Threading.IsInternalTimerEnabled);
Assert.AreEqual(1234567, runtime.Threading.InternalTimerMsecResolution);
Assert.IsTrue(runtime.Logging.IsEnableExecutionDebug);
Assert.IsFalse(runtime.Logging.IsEnableTimerDebug);
Assert.AreEqual("[%u] %m", runtime.Logging.AuditPattern);
Assert.AreEqual(30000, runtime.Variables.MsecVersionRelease);
Assert.AreEqual(3L, (long)runtime.Patterns.MaxSubexpressions);
Assert.IsFalse(runtime.Patterns.IsMaxSubexpressionPreventStart);
Assert.AreEqual(3L, (long)runtime.MatchRecognize.MaxStates);
Assert.IsFalse(runtime.MatchRecognize.IsMaxStatesPreventStart);
// assert adapter loaders parsed
IList <ConfigurationRuntimePluginLoader> plugins = runtime.PluginLoaders;
Assert.AreEqual(2, plugins.Count);
var pluginOne = plugins[0];
Assert.AreEqual("Loader1", pluginOne.LoaderName);
Assert.AreEqual("com.espertech.esper.support.plugin.SupportLoaderOne", pluginOne.ClassName);
Assert.AreEqual(2, pluginOne.ConfigProperties.Count);
Assert.AreEqual("val1", pluginOne.ConfigProperties.Get("name1"));
Assert.AreEqual("val2", pluginOne.ConfigProperties.Get("name2"));
Assert.AreEqual(
"<sample-initializer xmlns=\"http://www.espertech.com/schema/esper\"><some-any-xml-can-be-here>This section for use by a plugin loader.</some-any-xml-can-be-here></sample-initializer>",
pluginOne.ConfigurationXML);
var pluginTwo = plugins[1];
Assert.AreEqual("Loader2", pluginTwo.LoaderName);
Assert.AreEqual("com.espertech.esper.support.plugin.SupportLoaderTwo", pluginTwo.ClassName);
Assert.AreEqual(0, pluginTwo.ConfigProperties.Count);
Assert.AreEqual(TimeSourceType.NANO, runtime.TimeSource.TimeSourceType);
Assert.IsTrue(runtime.Execution.IsPrioritized);
Assert.IsTrue(runtime.Execution.IsFairlock);
Assert.IsTrue(runtime.Execution.IsDisableLocking);
Assert.AreEqual(FilterServiceProfile.READWRITE, runtime.Execution.FilterServiceProfile);
Assert.AreEqual(101, runtime.Execution.DeclaredExprValueCacheSize);
var metrics = runtime.MetricsReporting;
Assert.IsTrue(metrics.IsEnableMetricsReporting);
Assert.AreEqual(4000L, metrics.RuntimeInterval);
Assert.AreEqual(500L, metrics.StatementInterval);
Assert.IsFalse(metrics.IsThreading);
Assert.AreEqual(2, metrics.StatementGroups.Count);
Assert.IsTrue(metrics.IsRuntimeMetrics);
var def = metrics.StatementGroups.Get("MyStmtGroup");
Assert.AreEqual(5000, def.Interval);
Assert.IsTrue(def.IsDefaultInclude);
Assert.AreEqual(50, def.NumStatements);
Assert.IsTrue(def.IsReportInactive);
Assert.AreEqual(5, def.Patterns.Count);
Assert.AreEqual(def.Patterns[0], new Pair <StringPatternSet, bool>(new StringPatternSetRegex(".*"), true));
Assert.AreEqual(def.Patterns[1], new Pair <StringPatternSet, bool>(new StringPatternSetRegex(".*test.*"), false));
Assert.AreEqual(def.Patterns[2], new Pair <StringPatternSet, bool>(new StringPatternSetLike("%MyMetricsStatement%"), false));
Assert.AreEqual(
def.Patterns[3], new Pair <StringPatternSet, bool>(new StringPatternSetLike("%MyFraudAnalysisStatement%"), true));
Assert.AreEqual(def.Patterns[4], new Pair <StringPatternSet, bool>(new StringPatternSetLike("%SomerOtherStatement%"), true));
def = metrics.StatementGroups.Get("MyStmtGroupTwo");
Assert.AreEqual(200, def.Interval);
Assert.IsFalse(def.IsDefaultInclude);
Assert.AreEqual(100, def.NumStatements);
Assert.IsFalse(def.IsReportInactive);
Assert.AreEqual(0, def.Patterns.Count);
Assert.IsFalse(runtime.Expression.IsSelfSubselectPreeval);
Assert.AreEqual(TimeZoneHelper.GetTimeZoneInfo("GMT-4:00"), runtime.Expression.TimeZone);
Assert.AreEqual(2, runtime.ExceptionHandling.HandlerFactories.Count);
Assert.AreEqual("my.company.cep.LoggingExceptionHandlerFactory", runtime.ExceptionHandling.HandlerFactories[0]);
Assert.AreEqual("my.company.cep.AlertExceptionHandlerFactory", runtime.ExceptionHandling.HandlerFactories[1]);
Assert.AreEqual(UndeployRethrowPolicy.RETHROW_FIRST, runtime.ExceptionHandling.UndeployRethrowPolicy);
Assert.AreEqual(2, runtime.ConditionHandling.HandlerFactories.Count);
Assert.AreEqual("my.company.cep.LoggingConditionHandlerFactory", runtime.ConditionHandling.HandlerFactories[0]);
Assert.AreEqual("my.company.cep.AlertConditionHandlerFactory", runtime.ConditionHandling.HandlerFactories[1]);
}
