public void TestGetConstructorNullElementType()
{
EnumBuilder enumBuilder = GenerateEnum();
enumBuilder.CreateType();
ConstructorInfo ctor = enumBuilder.GetConstructor(
BindingFlags.Public, null, CallingConventions.Any,
new Type [] { null }, new ParameterModifier [0]);
}
public void TestAssemblyProperty()
{
CreateCallee();
_myEnumBuilder = _myModuleBuilder.DefineEnum("myEnum", TypeAttributes.Public, typeof(int));
_myEnumBuilder.AsType();
Assembly myAssem = _myEnumBuilder.Assembly;
Assert.Equal(_myAssemblyBuilder.FullName, myAssem.FullName);
}
public void TestDeclaringTypeProperty()
{
CreateCallee();
_myEnumBuilder = _myModuleBuilder.DefineEnum("myEnum", TypeAttributes.Public, typeof(int));
_myEnumBuilder.AsType();
Type myDeclaringType = _myEnumBuilder.DeclaringType;
Assert.Null(myDeclaringType);
}
public void TestDefineLiteralTypeComplete()
{
EnumBuilder enumBuilder = GenerateEnum();
Type enumType = enumBuilder.CreateType();
// you should not be able to define literal after type
// has been created
enumBuilder.DefineLiteral(_fieldName, _fieldValue);
}
public void TestFindInterfaces()
{
EnumBuilder enumBuilder = GenerateEnum();
Type [] interfaces = enumBuilder.FindInterfaces(
new TypeFilter(MyInterfaceFilter),
"System.Collections.IEnumerable");
Assert.AreEqual(0, interfaces.Length);
}
protected virtual void DescribeType(EnumBuilder builder, Type type)
{
if (type.GetTypeInfo().GetCustomAttribute <FlagsAttribute>() != null)
{
builder.Hint("enum-flags", "true");
}
builder.Hint("source-assembly", type.Assembly.FullName);
builder.Hint("source-type", type.FullName);
}
/// <inheritdoc />
public virtual void Describe(EnumBuilder builder)
{
switch (builder.Source)
{
case Type type:
DescribeType(builder, type);
break;
}
}
public void Emit(EnumBuilder enumBuilder)
{
for (int i = 0; i < EnumItems.Count; i++)
{
string name = EnumItems[i];
FieldBuilder builder = enumBuilder.DefineLiteral(name, i + 1);
ASTUtil.SetAttrZCode(builder, name);
}
}
public void TestHasElementTypeEnumBuilderComplete()
{
EnumBuilder enumBuilder = GenerateEnum();
enumBuilder.CreateType();
bool hasElementType = enumBuilder.HasElementType;
Assert.IsFalse(hasElementType);
}
public void SetJobResultMode(ViewResultMode mode)
{
var fudgeMsg = new FudgeMsg(FudgeContext)
{
{ 1, EnumBuilder <ViewResultMode> .GetJavaName(mode) }
};
REST.Resolve("jobResultMode").Put(fudgeMsg);
}
public void TestModuleProperty()
{
CreateCallee();
_myEnumBuilder = _myModuleBuilder.DefineEnum("myEnum", TypeAttributes.Public, typeof(int));
_myEnumBuilder.AsType();
Module myModule = _myEnumBuilder.Module;
Assert.True(myModule.Equals(_myModuleBuilder));
}
public void TestBaseTypeProperty()
{
CreateCallee();
_myEnumBuilder = _myModuleBuilder.DefineEnum("myEnum", TypeAttributes.Public, typeof(int));
_myEnumBuilder.AsType();
Type myBaseType = _myEnumBuilder.BaseType;
Assert.Equal(typeof(Enum), myBaseType);
}
private static Type GetBoolEnumType()
{
EnumBuilder enumBuilder = GetNonRuntimeEnumTypeBuilder(typeof(bool));
enumBuilder.DefineLiteral("Value1", true);
enumBuilder.DefineLiteral("Value2", false);
return(enumBuilder.CreateTypeInfo().AsType());
}
public void TestFullNameProperty()
{
CreateCallee();
_myEnumBuilder = _myModuleBuilder.DefineEnum("myEnum", TypeAttributes.Public, typeof(int));
_myEnumBuilder.AsType();
string myFullName = _myEnumBuilder.FullName;
Assert.Equal(_myEnumBuilder.FullName, myFullName);
}
public void TestEnumBuilder_NotInMono()
{
// If we decide to fix this (I dont see why we should),
// move to the routine above
EnumBuilder enumBuilder = GenerateEnum();
Assert.IsFalse(enumBuilder.IsSerializable);
}
public Type CompileType(ILEnumBuilder builder)
{
EnumBuilder realBuilder = builder.EnumBuilder;
Type createdType = realBuilder.CreateType();
this._compiledTypes.Add(builder.Name, createdType);
this._definedEnums.Remove(builder.Name);
return(createdType);
}
public void TestMakePointerType()
{
CreateCallee();
_myEnumBuilder = _myModuleBuilder.DefineEnum("myEnum", TypeAttributes.Public, typeof(int));
Type myType = _myEnumBuilder.MakePointerType();
Assert.True(myType.GetTypeInfo().BaseType.Equals(typeof(Array)));
Assert.Equal(myType.Name, "myEnum*");
}
/// <summary>
/// Applies an attribute to an enum.
/// </summary>
/// <param name="enum">An instance of EnumBuilder to apply the attribute to.</param>
/// <param name="expression">An expression that represents the attribute.</param>
public static void SetCustomAttribute(this EnumBuilder @enum, Expression <Func <Attribute> > expression)
{
var builder = @enum.Module.Assembly.ReflectionOnly
? new ReflectionOnlyCustomAttributeBuilderBuilder()
: new CustomAttributeBuilderBuilder();
var attribute = builder.Build(expression);
@enum.SetCustomAttribute(attribute);
}
public void TestModuleName()
{
CreateCallee();
_myEnumBuilder = _myModuleBuilder.DefineEnum("myEnum", TypeAttributes.Public, typeof(int));
_myEnumBuilder.AsType();
string myEnumName = _myEnumBuilder.Name;
Assert.Equal("myEnum", myEnumName);
}
/// <inheritdoc />
protected override Enum Bind(EnumDefinitionContext node, IDocument parent)
{
var builder = new EnumBuilder()
.SetNode(node)
.SetParent(parent)
.SetBinderProvider(this.binderProvider)
.SetName(node.name?.Text);
return(builder.Build());
}
public void DefineLiteral()
{
EnumBuilder enumBuilder = Helpers.DynamicEnum(TypeAttributes.Public, typeof(int));
FieldBuilder field = enumBuilder.DefineLiteral("FieldOne", 1);
enumBuilder.AsType();
Assert.True(field.IsLiteral);
Assert.True(field.IsPublic);
Assert.True(field.IsStatic);
}
public static ResultModelDefinition FromFudgeMsg(IFudgeFieldContainer ffc, IFudgeDeserializer deserializer)
{
return(new ResultModelDefinition(
EnumBuilder <ResultOutputMode> .Parse(ffc.GetValue <string>("aggregatePositionOutputMode")),
EnumBuilder <ResultOutputMode> .Parse(ffc.GetValue <string>("positionOutputMode")),
EnumBuilder <ResultOutputMode> .Parse(ffc.GetValue <string>("tradeOutputMode")),
EnumBuilder <ResultOutputMode> .Parse(ffc.GetValue <string>("securityOutputMode")),
EnumBuilder <ResultOutputMode> .Parse(ffc.GetValue <string>("primitiveOutputMode"))
));
}
public void ToFudgeMsg(IAppendingFudgeFieldContainer a, IFudgeSerializer s)
{
a.Add("type", EnumBuilder <StripInstrumentType> .GetJavaName(InstrumentType));
s.WriteInline(a, "tenor", CurveNodePointTime);
a.Add("conventionName", ConventionName);
if (InstrumentType == StripInstrumentType.Future)
{
a.Add("numFutures", NthFutureFromTenor);
}
}
public void TestGetConstructorsComplete()
{
EnumBuilder enumBuilder = GenerateEnum();
enumBuilder.CreateType();
ConstructorInfo [] ctors = enumBuilder.GetConstructors(
BindingFlags.Instance | BindingFlags.Public);
Assert.AreEqual(0, ctors.Length);
}
public void TestSetCustomAttribute()
{
CreateCallee();
_myEnumBuilder = _myModuleBuilder.DefineEnum("myEnum", TypeAttributes.Public, typeof(int));
_myEnumBuilder.CreateTypeInfo().AsType();
_myEnumBuilder.SetCustomAttribute(_myInfo, new byte[] { 01, 00, 01 });
object[] objVals = _myEnumBuilder.GetCustomAttributes(true).Select(a => (object)a).ToArray().Select(a => (object)a).ToArray();
Assert.Equal(1, objVals.Length);
Assert.True(objVals[0].Equals(new EBMyAttribute(true)));
}
/// <summary>
/// Facade for EnumBuilder.CreateTypeInfo
/// </summary>
/// <remarks>
/// In Core PowerShell, we need to track the dynamic assemblies that powershell generates.
/// </remarks>
internal static void CreateEnumType(EnumBuilder enumBuilder)
{
#if CORECLR
// Create the enum type and add the dynamic assembly to assembly cache.
TypeInfo enumTypeinfo = enumBuilder.CreateTypeInfo();
PSAssemblyLoadContext.TryAddAssemblyToCache(enumTypeinfo.Assembly);
#else
enumBuilder.CreateTypeInfo();
#endif
}
public EnumBuilder Build(AssemblyBuilder assembly)
{
var eb = new EnumBuilder(assembly, UnderlyingSystemType, Name);
foreach (var field in Fields)
{
eb.AddField(field.Build(assembly));
}
return(eb);
}
public void ValueCanBeFoundFromName()
{
var builder = new EnumBuilder("TestEnum");
builder.PushEntry("A", 1);
var enumDefinition = builder.Build();
Assert.True(enumDefinition.TryGetValue("A", out var value));
Assert.Equal(1, value);
}
public void TestGetConstructorComplete()
{
EnumBuilder enumBuilder = GenerateEnum();
enumBuilder.CreateType();
ConstructorInfo ctor = enumBuilder.GetConstructor(
BindingFlags.Public, null, CallingConventions.Any,
Type.EmptyTypes, new ParameterModifier [0]);
Assert.IsNull(ctor);
}
public void TestFindMembersIncomplete()
{
EnumBuilder enumBuilder = GenerateEnum();
GenerateField(enumBuilder);
MemberInfo [] members = enumBuilder.FindMembers(
MemberTypes.All, BindingFlags.Static |
BindingFlags.Public, new MemberFilter(MemberNameFilter),
_fieldName);
}
/// <summary>
/// Creates an enum builder
/// </summary>
/// <param name="Name">Name of the enum</param>
/// <param name="EnumBaseType">Base type of the enum (defaults to int)</param>
/// <param name="Attributes">Attributes associated with the type</param>
/// <returns>An EnumBuilder class</returns>
public virtual EnumBuilder CreateEnum(string Name, Type EnumBaseType = null,
TypeAttributes Attributes = TypeAttributes.Public)
{
if (EnumBaseType == null)
EnumBaseType = typeof(int);
EnumBuilder ReturnValue = new EnumBuilder(this, Name, EnumBaseType, Attributes);
Enums.Add(ReturnValue);
return ReturnValue;
}
/// <summary>
/// Creates an enum builder
/// </summary>
/// <param name="name">name of the enum</param>
/// <param name="enumBaseType">Base type of the enum (defaults to int)</param>
/// <param name="attributes">Attributes associated with the type</param>
/// <returns>An EnumBuilder class</returns>
public virtual EnumBuilder CreateEnum(string name, Type enumBaseType = null,
TypeAttributes attributes = TypeAttributes.Public)
{
if (enumBaseType == null)
enumBaseType = typeof (int);
var returnValue = new EnumBuilder(this, name, enumBaseType, attributes);
Enums.Add(returnValue);
return returnValue;
}
