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; }