public void ILOffset_SomethingEmitted_ReturnsNonZero()
{
ModuleBuilder module = Helpers.DynamicModule();
MethodBuilder method = module.DefineGlobalMethod("method1", MethodAttributes.Public | MethodAttributes.Static, typeof(Type), new Type[0]);
ILGenerator ilGenerator = method.GetILGenerator();
ilGenerator.Emit(OpCodes.Ret);
Assert.Equal(1, ilGenerator.ILOffset);
}
public void TestWithStaticAndPublic(FieldAttributes attributes)
{
ModuleBuilder module = Helpers.DynamicModule();
FieldBuilder field = module.DefineInitializedData("MyField", new byte[] { 01, 00, 01 }, attributes);
Assert.True(field.IsStatic);
Assert.Equal((attributes & FieldAttributes.Public) != 0, field.IsPublic);
Assert.Equal((attributes & FieldAttributes.Private) != 0, field.IsPrivate);
Assert.Equal(field.Name, "MyField");
}
public void DefineType_String_TypeAttributes(TypeAttributes attributes)
{
ModuleBuilder module = Helpers.DynamicModule();
TypeBuilder type = module.DefineType("TestType", attributes);
Type createdType = type.CreateTypeInfo().AsType();
Assert.Equal("TestType", createdType.Name);
Assert.Equal(attributes, createdType.GetTypeInfo().Attributes);
}
public void DefineInitializedData_CreateGlobalFunctionsCalled_ThrowsInvalidOperationException()
{
ModuleBuilder module = Helpers.DynamicModule();
FieldBuilder field = module.DefineInitializedData("MyField", new byte[] { 1, 0, 1 }, FieldAttributes.Public);
module.CreateGlobalFunctions();
Assert.Null(field.DeclaringType);
Assert.Throws <InvalidOperationException>(() => module.DefineInitializedData("MyField2", new byte[] { 1, 0, 1 }, FieldAttributes.Public));
}
public void AddArgument_DifferentCountsForCustomModifiers_ThrowsArgumentException()
{
ModuleBuilder module = Helpers.DynamicModule();
SignatureHelper helper = SignatureHelper.GetFieldSigHelper(module);
helper.GetSignature();
AssertExtensions.Throws <ArgumentException>(null, () => helper.AddArgument(typeof(string), new Type[] { typeof(int) }, null));
AssertExtensions.Throws <ArgumentException>(null, () => helper.AddArgument(typeof(string), null, new Type[] { typeof(int) }));
}
public void Module()
{
ModuleBuilder module = Helpers.DynamicModule();
TypeBuilder type = module.DefineType("TestType", TypeAttributes.Public);
string[] typeParamNames = new string[] { "TFirst" };
GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
Assert.Equal(module, typeParams[0].Module);
}
public void AddArgument_SignatureFinished_ThrowsArgumentException()
{
ModuleBuilder module = Helpers.DynamicModule();
SignatureHelper helper = SignatureHelper.GetFieldSigHelper(module);
helper.GetSignature();
AssertExtensions.Throws <ArgumentException>(null, () => helper.AddArgument(typeof(string)));
AssertExtensions.Throws <ArgumentException>(null, () => helper.AddArgument(typeof(string), null, null));
}
public void Size_Set_ReturnsExpected(int size)
{
ModuleBuilder module = Helpers.DynamicModule();
TypeBuilder type = module.DefineType("TestType", TypeAttributes.Class | TypeAttributes.Public, null, size);
Assert.Equal(size, type.Size);
type.DefineGenericParameters("T", "U");
Assert.Equal(size, type.Size);
}
public void ParentNotCreated_ThrowsNotSupportedExceptionOnCreation()
{
ModuleBuilder module = Helpers.DynamicModule();
TypeBuilder type = module.DefineType("Daughter", TypeAttributes.Public);
TypeBuilder parentType = module.DefineType("Parent", TypeAttributes.Public);
type.SetParent(parentType.AsType());
Assert.Equal(parentType.AsType(), type.BaseType);
Assert.Throws <NotSupportedException>(() => type.CreateTypeInfo());
}
public void GetMethodSigHelper_Module_CallingConventions_Type_Length_ReturnsThree(CallingConventions callingConventions, Type type)
{
ModuleBuilder module = Helpers.DynamicModule();
SignatureHelper helper1 = SignatureHelper.GetMethodSigHelper(module, callingConventions, type);
Assert.Equal(3, helper1.GetSignature().Length);
SignatureHelper helper2 = SignatureHelper.GetMethodSigHelper(null, callingConventions, type);
Assert.Equal(3, helper2.GetSignature().Length);
}
public void GetMethodSigHelper_Module_Type_TypeArray()
{
ModuleBuilder module = Helpers.DynamicModule();
SignatureHelper helper1 = SignatureHelper.GetMethodSigHelper(module, typeof(string), new Type[] { typeof(char), typeof(int) });
Assert.Equal(5, helper1.GetSignature().Length);
SignatureHelper helper2 = SignatureHelper.GetMethodSigHelper(null, typeof(string), new Type[] { typeof(char), typeof(int) });
Assert.Equal(5, helper2.GetSignature().Length);
}
public void AddArgument_DifferentCountsForCustomModifiers_ThrowsArgumentException()
{
ModuleBuilder module = Helpers.DynamicModule();
SignatureHelper helper = SignatureHelper.GetFieldSigHelper(module);
AssertExtensions.Throws <ArgumentException>("requiredCustomModifiers", () => helper.AddArguments(new Type[] { typeof(string) }, new Type[][] { new Type[] { typeof(int), typeof(int[]) } }, null));
AssertExtensions.Throws <ArgumentException>(null, () => helper.AddArguments(new Type[] { typeof(string) }, new Type[][] { new Type[] { typeof(int) }, new Type[] { typeof(char) } }, null));
AssertExtensions.Throws <ArgumentException>("optionalCustomModifiers", () => helper.AddArguments(new Type[] { typeof(string) }, null, new Type[][] { new Type[] { typeof(int), typeof(int[]) } }));
AssertExtensions.Throws <ArgumentException>(null, () => helper.AddArguments(new Type[] { typeof(string) }, null, new Type[][] { new Type[] { typeof(int) }, new Type[] { typeof(char) } }));
}
public void GetArrayMethod_InvalidArgument_ThrowsArgumentException()
{
ModuleBuilder module = Helpers.DynamicModule();
AssertExtensions.Throws <ArgumentNullException>("arrayClass", () => module.GetArrayMethod(null, "TestMethod", CallingConventions.Standard, typeof(void), new Type[0]));
AssertExtensions.Throws <ArgumentNullException>("methodName", () => module.GetArrayMethod(typeof(string[]), null, CallingConventions.Standard, typeof(void), new Type[0]));
AssertExtensions.Throws <ArgumentException>("methodName", () => module.GetArrayMethod(typeof(string[]), "", CallingConventions.Standard, typeof(void), new Type[0]));
AssertExtensions.Throws <ArgumentNullException>("argument", () => module.GetArrayMethod(typeof(string[]), "TestMethod", CallingConventions.Standard, typeof(void), new Type[] { null }));
}
public void DefineMethodOverride_GlobalMethod_ThrowsArgumentException()
{
ModuleBuilder module = Helpers.DynamicModule();
MethodBuilder globalMethod = module.DefineGlobalMethod("GlobalMethod", MethodAttributes.Public | MethodAttributes.Static, typeof(void), new Type[0]);
globalMethod.GetILGenerator().Emit(OpCodes.Ret);
TypeBuilder type = module.DefineType("Name");
AssertExtensions.Throws <ArgumentException>(null, () => type.DefineMethodOverride(globalMethod, typeof(DefineMethodOverrideInterface).GetMethod(nameof(DefineMethodOverrideInterface.M))));
}
public void CreateGlobalFunctions_SingleGlobalMethod()
{
ModuleBuilder module = Helpers.DynamicModule();
MethodBuilder method = module.DefineGlobalMethod("TestMethod", MethodAttributes.Static | MethodAttributes.Public, null, null);
ILGenerator ilGenerator = method.GetILGenerator();
ilGenerator.EmitWriteLine("Hello World from global method.");
ilGenerator.Emit(OpCodes.Ret);
module.CreateGlobalFunctions();
}
public void DeclareLocal_GlobalFunctionsCreated_ThrowsInvalidOperationException()
{
ModuleBuilder module = Helpers.DynamicModule();
MethodBuilder method = module.DefineGlobalMethod("method1", MethodAttributes.Public | MethodAttributes.Static, typeof(Type), new Type[0]);
ILGenerator ilGenerator = method.GetILGenerator();
ilGenerator.Emit(OpCodes.Ret);
module.CreateGlobalFunctions();
Assert.Throws <InvalidOperationException>(() => ilGenerator.DeclareLocal(typeof(int)));
}
public void DefineEnum_DynamicUnderlyingType_Works()
{
ModuleBuilder module = Helpers.DynamicModule();
EnumBuilder underlyingEnumTypeBuilder = module.DefineEnum("Enum1", TypeAttributes.Public, typeof(int));
Type underlyingEnumType = underlyingEnumTypeBuilder.CreateTypeInfo().AsType();
EnumBuilder enumBuilder = module.DefineEnum("Enum2", TypeAttributes.Public, underlyingEnumType);
Type enumType = enumBuilder.CreateTypeInfo().AsType();
Assert.Equal(typeof(int), Enum.GetUnderlyingType(enumType));
}
public void SetCustomAttribute_ConstructorInfo_ByteArray()
{
ModuleBuilder module = Helpers.DynamicModule();
ConstructorInfo attributeConstructor = typeof(IntAllAttribute).GetConstructor(new Type[] { typeof(int) });
module.SetCustomAttribute(attributeConstructor, new byte[] { 01, 00, 05, 00, 00, 00 });
object[] attributes = module.GetCustomAttributes().ToArray();
Assert.Equal(1, attributes.Length);
Assert.True(attributes[0] is IntAllAttribute);
Assert.Equal(5, ((IntAllAttribute)attributes[0])._i);
}
public void CreateGlobalFunctions_CalledMultipleTimes_ThrowsInvalidOperationException()
{
ModuleBuilder module = Helpers.DynamicModule();
MethodBuilder method = module.DefineGlobalMethod("TestMethod", MethodAttributes.Static | MethodAttributes.Public, null, null);
ILGenerator ilGenerator = method.GetILGenerator();
ilGenerator.EmitWriteLine("Hello World from global method.");
ilGenerator.Emit(OpCodes.Ret);
module.CreateGlobalFunctions();
Assert.Throws <InvalidOperationException>(() => module.CreateGlobalFunctions());
}
public void DefineEnum_ValueType(TypeAttributes visibility)
{
foreach (Type integerType in s_builtInIntegerTypes)
{
ModuleBuilder module = Helpers.DynamicModule();
EnumBuilder enumBuilder = module.DefineEnum("MyEnum", visibility, integerType);
Assert.True(enumBuilder.IsEnum);
Assert.Equal("MyEnum", enumBuilder.FullName);
enumBuilder.CreateTypeInfo().AsType();
}
}
public void DefineType_String_TypeAttributes_Type_TypeCreatedInModule()
{
ModuleBuilder module = Helpers.DynamicModule();
TypeBuilder type1 = module.DefineType("TestType1");
Type parent = type1.CreateTypeInfo().AsType();
TypeBuilder type2 = module.DefineType("TestType2", TypeAttributes.NotPublic, parent);
Type createdType = type2.CreateTypeInfo().AsType();
Assert.Equal("TestType2", createdType.Name);
Assert.Equal(TypeAttributes.NotPublic, createdType.GetTypeInfo().Attributes);
Assert.Equal(parent, createdType.GetTypeInfo().BaseType);
}
public void DefineUninitializedData(FieldAttributes attributes)
{
ModuleBuilder module = Helpers.DynamicModule();
foreach (int size in new int[] { 1, 2, 0x003f0000 - 1 })
{
FieldBuilder field = module.DefineUninitializedData(size.ToString(), size, attributes);
int expectedAttributes = ((int)attributes | (int)FieldAttributes.Static) & ~ReservedMaskFieldAttribute;
Assert.Equal(size.ToString(), field.Name);
Assert.Equal((FieldAttributes)expectedAttributes, field.Attributes);
}
}
public void Size_Set_ReturnsExpected(int size)
{
ModuleBuilder module = Helpers.DynamicModule();
TypeBuilder type = module.DefineType("TestType", TypeAttributes.Class | TypeAttributes.Public, null, size);
Assert.Equal(size, type.Size);
type.DefineGenericParameters("T", "U");
Assert.Equal(size, type.Size);
// We should be able to create the type no matter the size
Assert.Equal(type.Name, type.CreateTypeInfo().Name);
}
public void DefineDefaultConstructor_GenericParentNotCreated_ThrowsNotSupportedException()
{
ModuleBuilder module = Helpers.DynamicModule();
TypeBuilder genericTypeDefinition = module.DefineType("GenericType", TypeAttributes.Public);
genericTypeDefinition.DefineGenericParameters("T");
Type genericParent = genericTypeDefinition.MakeGenericType(typeof(int));
TypeBuilder type = module.DefineType("Type");
type.SetParent(genericParent);
Assert.Throws <NotSupportedException>(() => type.DefineDefaultConstructor(MethodAttributes.Public));
}
private void VerificationHelperNegative(string name, TypeAttributes myTypeAttribute, Type mytype, bool flag)
{
ModuleBuilder myModuleBuilder = Helpers.DynamicModule();
Assert.Throws <ArgumentException>(() =>
{
EnumBuilder myEnumBuilder = myModuleBuilder.DefineEnum(name, myTypeAttribute, mytype);
if (!flag)
{
myEnumBuilder = myModuleBuilder.DefineEnum(name, myTypeAttribute, typeof(int));
}
});
}
public void DefineType_NullName_ThrowsArgumentNullException()
{
ModuleBuilder module = Helpers.DynamicModule();
AssertExtensions.Throws <ArgumentNullException>("fullname", () => module.DefineType(null));
AssertExtensions.Throws <ArgumentNullException>("fullname", () => module.DefineType(null, TypeAttributes.NotPublic));
AssertExtensions.Throws <ArgumentNullException>("fullname", () => module.DefineType(null, TypeAttributes.NotPublic, typeof(ModuleBuilderDefineType)));
AssertExtensions.Throws <ArgumentNullException>("fullname", () => module.DefineType(null, TypeAttributes.NotPublic, typeof(ModuleBuilderDefineType), PackingSize.Unspecified));
AssertExtensions.Throws <ArgumentNullException>("fullname", () => module.DefineType(null, TypeAttributes.NotPublic, typeof(ModuleBuilderDefineType), 0));
AssertExtensions.Throws <ArgumentNullException>("fullname", () => module.DefineType(null, TypeAttributes.NotPublic, typeof(ModuleBuilderDefineType), PackingSize.Unspecified, 0));
AssertExtensions.Throws <ArgumentNullException>("fullname", () => module.DefineType(null, TypeAttributes.NotPublic, typeof(ModuleBuilderDefineType), new Type[0]));
}
public void DefineType_TypeAlreadyExists_ThrowsArgumentException()
{
ModuleBuilder module = Helpers.DynamicModule();
module.DefineType("TestType");
AssertExtensions.Throws <ArgumentException>(null, () => module.DefineType("TestType"));
AssertExtensions.Throws <ArgumentException>(null, () => module.DefineType("TestType", TypeAttributes.NotPublic));
AssertExtensions.Throws <ArgumentException>(null, () => module.DefineType("TestType", TypeAttributes.NotPublic, typeof(ModuleBuilderDefineType)));
AssertExtensions.Throws <ArgumentException>(null, () => module.DefineType("TestType", TypeAttributes.NotPublic, typeof(ModuleBuilderDefineType), PackingSize.Unspecified));
AssertExtensions.Throws <ArgumentException>(null, () => module.DefineType("TestType", TypeAttributes.NotPublic, typeof(ModuleBuilderDefineType), 0));
AssertExtensions.Throws <ArgumentException>(null, () => module.DefineType("TestType", TypeAttributes.NotPublic, typeof(ModuleBuilderDefineType), PackingSize.Unspecified, 0));
AssertExtensions.Throws <ArgumentException>(null, () => module.DefineType("TestType", TypeAttributes.NotPublic, typeof(ModuleBuilderDefineType), new Type[0]));
}
public void DefineEnum(string name, TypeAttributes visibility, Type underlyingType)
{
ModuleBuilder module = Helpers.DynamicModule();
EnumBuilder enumBuilder = module.DefineEnum(name, visibility, underlyingType);
Assert.True(enumBuilder.IsEnum);
Assert.Equal(module.Assembly, enumBuilder.Assembly);
Assert.Equal(module, enumBuilder.Module);
Assert.Equal(name, enumBuilder.Name);
Assert.Equal(Helpers.GetFullName(name), enumBuilder.FullName);
Assert.Equal(enumBuilder.FullName + ", " + module.Assembly.FullName, enumBuilder.AssemblyQualifiedName);
Assert.Equal(typeof(Enum), enumBuilder.BaseType);
Assert.Null(enumBuilder.DeclaringType);
Assert.Equal(visibility | TypeAttributes.Sealed, enumBuilder.Attributes);
Assert.Equal("value__", enumBuilder.UnderlyingField.Name);
Assert.Equal(underlyingType, enumBuilder.UnderlyingField.FieldType);
Assert.Equal(FieldAttributes.Public | FieldAttributes.SpecialName, enumBuilder.UnderlyingField.Attributes);
// Verify we can create the Enum properly
TypeInfo createdEnum = enumBuilder.CreateTypeInfo();
Assert.True(createdEnum.IsEnum);
Assert.Equal(module.Assembly.ToString(), createdEnum.Assembly.ToString());
Assert.Equal(module.ToString(), createdEnum.Module.ToString());
Assert.Equal(Helpers.GetFullName(name), createdEnum.Name);
Assert.Equal(Helpers.GetFullName(name), enumBuilder.FullName);
Assert.Equal(enumBuilder.FullName + ", " + module.Assembly.FullName, enumBuilder.AssemblyQualifiedName);
Assert.Equal(typeof(Enum), createdEnum.BaseType);
Assert.Null(createdEnum.DeclaringType);
Assert.Equal(visibility | TypeAttributes.Sealed, createdEnum.Attributes);
Type expectedUnderlyingType = underlyingType.GetTypeInfo().IsEnum ? Enum.GetUnderlyingType(underlyingType) : underlyingType;
Assert.Equal(expectedUnderlyingType, Enum.GetUnderlyingType(createdEnum.AsType()));
// There should be a field called "value__" created
FieldInfo createdUnderlyingField = createdEnum.AsType().GetField("value__", Helpers.AllFlags);
Assert.Equal(FieldAttributes.Public | FieldAttributes.SpecialName | FieldAttributes.RTSpecialName, createdUnderlyingField.Attributes);
}
public void GetConstructor_DeclaringTypeOfConstructorNotGenericTypeDefinitionOfType_ThrowsArgumentException()
{
ModuleBuilder module = Helpers.DynamicModule();
TypeBuilder type1 = module.DefineType("TestType1", TypeAttributes.Class | TypeAttributes.Public);
type1.DefineGenericParameters("T");
TypeBuilder type2 = module.DefineType("TestType2", TypeAttributes.Class | TypeAttributes.Public);
type2.DefineGenericParameters("T");
ConstructorBuilder ctor1 = type1.DefineDefaultConstructor(MethodAttributes.PrivateScope | MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);
ConstructorBuilder ctor2 = type2.DefineDefaultConstructor(MethodAttributes.PrivateScope | MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);
Type genericInt = type1.MakeGenericType(typeof(int));
AssertExtensions.Throws<ArgumentException>("type", () => TypeBuilder.GetConstructor(genericInt, ctor2));
}
public void CreateGlobalFunctions_MultipleGlobalMethods()
{
ModuleBuilder module = Helpers.DynamicModule();
MethodBuilder method = module.DefineGlobalMethod("TestMethod", MethodAttributes.Static | MethodAttributes.Public, null, null);
ILGenerator ilGenerator = method.GetILGenerator();
ilGenerator.EmitWriteLine("Hello World from global method.");
ilGenerator.Emit(OpCodes.Ret);
method = module.DefineGlobalMethod("MyMethod2", MethodAttributes.Static | MethodAttributes.Public,
null, null);
ilGenerator = method.GetILGenerator();
ilGenerator.EmitWriteLine("Hello World from global method again!");
module.CreateGlobalFunctions();
Assert.Null(method.DeclaringType);
}