// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using System;
-using System.Reflection;
-using System.Reflection.Emit;
using Xunit;
namespace System.Reflection.Emit.Tests
{
public class GenericTypeParameterBuilderSetBaseTypeConstraint
{
- [Fact]
- public void TestWithStringBaseType()
+ [Theory]
+ [InlineData(typeof(string), typeof(string))]
+ [InlineData(null, typeof(object))]
+ public void SetBaseTypeConstraint(Type baseTypeConstraint, Type expectedBaseType)
{
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- Type expectedValue = typeof(string);
- Type actualValue;
-
- TFirst.SetBaseTypeConstraint(typeof(string));
- actualValue = TFirst.BaseType;
- Assert.Equal(expectedValue, actualValue);
- }
-
- [Fact]
- public void TestWithNullArgument()
- {
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- Type expectedValue = typeof(object);
- Type actualValue;
- TFirst.SetBaseTypeConstraint(null);
- actualValue = TFirst.BaseType;
- Assert.Equal(expectedValue, actualValue);
+ GenericTypeParameterBuilder firstParam = typeParams[0];
+ firstParam.SetBaseTypeConstraint(baseTypeConstraint);
+ Assert.Equal(expectedBaseType, firstParam.BaseType);
}
}
-
- public class ExampleBase { }
}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using System;
-using System.Reflection;
-using System.Reflection.Emit;
using Xunit;
namespace System.Reflection.Emit.Tests
public class GenericTypeParameterBuilderAssembly
{
[Fact]
- public void TestAssemblyProperty()
+ public void Assembly()
{
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
+ AssemblyBuilder assembly = Helpers.DynamicAssembly();
+ ModuleBuilder module = assembly.DefineDynamicModule("Module");
+ TypeBuilder type = module.DefineType("Sample", TypeAttributes.Public);
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- Assembly expectedValue = myAssembly;
- Assembly actualValue;
- actualValue = TFirst.Assembly;
-
- Assert.True(actualValue.Equals(expectedValue));
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+ Assert.Equal(assembly, typeParams[0].Assembly);
}
}
}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using System;
-using System.Reflection;
-using System.Reflection.Emit;
using Xunit;
namespace System.Reflection.Emit.Tests
public class GenericTypeParameterBuilderAssemblyQualifiedName
{
[Fact]
- public void TestAssemblyQualifiedNameProperty()
+ public void AssemblyQualifiedName_ReturnsNull()
{
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- string actualValue;
-
- actualValue = TFirst.AssemblyQualifiedName;
- //this method only returns null
-
- Assert.Null(actualValue);
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+ Assert.Null(typeParams[0].AssemblyQualifiedName);
}
}
}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using System;
-using System.Reflection;
-using System.Reflection.Emit;
using Xunit;
namespace System.Reflection.Emit.Tests
public class GenericTypeParameterBuilderBaseType
{
[Fact]
- public void TestBaseTypeWithNotSet()
+ public void BaseType_NotSet_ReturnsNull()
{
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- Type actualValue;
-
- actualValue = TFirst.BaseType;
-
- Assert.Null(actualValue);
- }
-
- [Fact]
- public void TestBaseTypeWithSetValue()
- {
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- TFirst.SetBaseTypeConstraint(typeof(string));
-
- Type expectedValue = typeof(string);
- Type actualValue;
-
- actualValue = TFirst.BaseType;
-
- Assert.Equal(expectedValue, actualValue);
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+ Assert.Null(typeParams[0].BaseType);
}
}
}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using System;
-using System.Reflection;
-using System.Reflection.Emit;
using Xunit;
namespace System.Reflection.Emit.Tests
public class GenericTypeParameterBuilderContainsGenericParameters
{
[Fact]
- public void TestContainsGenericParameters()
+ public void ContainsGenericParameters_ReturnsTrue()
{
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- bool expectedValue = true;
- bool actualValue;
-
- actualValue = TFirst.ContainsGenericParameters;
-
- Assert.Equal(expectedValue, actualValue);
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+ Assert.True(typeParams[0].ContainsGenericParameters);
}
}
}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using System;
-using System.Reflection;
-using System.Reflection.Emit;
using Xunit;
namespace System.Reflection.Emit.Tests
public class GenericTypeParameterBuilderDeclaringMethod
{
[Fact]
- public void TestDeclaringMethod()
+ public void DeclaringMethod_DefinedOnType_ReturnsNull()
{
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- MethodBase expectedValue = null;
- MethodBase actualValue;
-
- actualValue = TFirst.DeclaringMethod;
-
- Assert.Equal(expectedValue, actualValue);
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+ Assert.Null(typeParams[0].DeclaringMethod);
}
}
}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using System;
-using System.Reflection;
-using System.Reflection.Emit;
using Xunit;
namespace System.Reflection.Emit.Tests
public class GenericTypeParameterBuilderDeclaringType
{
[Fact]
- public void TestDeclaringType()
+ public void DeclaringType()
{
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- Type expectedValue = myType.AsType();
- Type actualValue;
-
- actualValue = TFirst.DeclaringType;
-
- Assert.Equal(expectedValue, actualValue);
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+ Assert.Equal(type.AsType(), typeParams[0].DeclaringType);
}
}
}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using System;
-using System.Reflection;
-using System.Reflection.Emit;
using Xunit;
namespace System.Reflection.Emit.Tests
public class GenericTypeParameterBuilderFullName
{
[Fact]
- public void TestFullNameProperty()
+ public void FullName_ReturnsNull()
{
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- string expectedValue = null;
- string actualValue;
-
- actualValue = TFirst.FullName;
-
- Assert.Equal(expectedValue, actualValue);
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+ Assert.Null(typeParams[0].FullName);
}
}
}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using System;
-using System.Reflection;
-using System.Reflection.Emit;
using Xunit;
namespace System.Reflection.Emit.Tests
public class GenericTypeParameterBuilderGUID
{
[Fact]
- public void TestThrowsExceptionForNotSupported()
+ public void Guid_ThrowsNotSupportedException()
{
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
- Assert.Throws<NotSupportedException>(() => { Guid guid = TFirst.GUID; });
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+
+ Assert.Throws<NotSupportedException>(() => typeParams[0].GUID);
}
}
}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using System;
-using System.Reflection;
-using System.Reflection.Emit;
using Xunit;
namespace System.Reflection.Emit.Tests
public class GenericTypeParameterBuilderGenericParameterPosition
{
[Fact]
- public void TestGenericParameterPositionProperty()
+ public void GenericParameterPosition()
{
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst", "TSecond" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst", "TSecond" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
- GenericTypeParameterBuilder TSecond = typeParams[1];
-
-
- int expectedValue = 0;
- int actualValue;
-
- actualValue = TFirst.GenericParameterPosition;
-
- Assert.Equal(expectedValue, actualValue);
- }
-
- [Fact]
- public void TestGenericParameterPositionWithDifferentPosition()
- {
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst", "TSecond" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
- GenericTypeParameterBuilder TSecond = typeParams[1];
-
-
- int expectedValue = 1;
- int actualValue;
- actualValue = TSecond.GenericParameterPosition;
-
- Assert.Equal(expectedValue, actualValue);
+ Assert.Equal(0, typeParams[0].GenericParameterPosition);
+ Assert.Equal(1, typeParams[1].GenericParameterPosition);
}
}
}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using System;
-using System.Reflection;
-using System.Reflection.Emit;
using Xunit;
namespace System.Reflection.Emit.Tests
public class GenericTypeParameterBuilderIsGenericParameter
{
[Fact]
- public void TestIsGenericParameter()
+ public void IsGenericParameter_ReturnsTrue()
{
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
-
- bool expectedValue = true;
- bool actualValue;
-
- actualValue = TFirst.IsGenericParameter;
-
- Assert.Equal(expectedValue, actualValue);
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+ Assert.True(typeParams[0].IsGenericParameter);
}
}
}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using System;
-using System.Reflection;
-using System.Reflection.Emit;
using Xunit;
namespace System.Reflection.Emit.Tests
public class GenericTypeParameterBuilderIsGenericType
{
[Fact]
- public void TestIsGenericType()
+ public void IsGenericType_ReturnsFalse()
{
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
-
- bool expectedValue = false;
- bool actualValue;
-
- actualValue = TFirst.IsGenericType;
-
- Assert.Equal(expectedValue, actualValue);
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+ Assert.False(typeParams[0].IsGenericType);
}
}
}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using System;
-using System.Reflection;
-using System.Reflection.Emit;
using Xunit;
namespace System.Reflection.Emit.Tests
public class GenericTypeParameterBuilderIsGenericTypeDefinition
{
[Fact]
- public void TestIsGenericTypeDefinition()
+ public void IsGenericTypeDefinition_ReturnsFalse()
{
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
-
- bool expectedValue = false;
- bool actualValue;
-
- actualValue = TFirst.IsGenericTypeDefinition;
-
- Assert.Equal(expectedValue, actualValue);
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+ Assert.False(typeParams[0].IsGenericTypeDefinition);
}
}
}
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Xunit;
+
+namespace System.Reflection.Emit.Tests
+{
+ public class GenericTypeParameterBuilderMakeArrayType
+ {
+ [Fact]
+ public void MakeArrayType()
+ {
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+
+ Assert.Equal("TFirst[]", typeParams[0].MakeArrayType().Name);
+ }
+
+ [Fact]
+ public void MakeArrayType_Int_RankOfOne()
+ {
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+
+ Assert.Equal("TFirst[*]", typeParams[0].MakeArrayType(1).Name);
+ }
+
+ [Fact]
+ public void MakeArrayType_Int_RankOfTwo()
+ {
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+
+ Assert.Equal("TFirst[,]", typeParams[0].MakeArrayType(2).Name);
+ }
+
+ [Theory]
+ [InlineData(0)]
+ [InlineData(-1)]
+ public void MakeArrayType_Int_RankLessThanOne_ThrowsIndexOutOfRangeException(int rank)
+ {
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+
+ Assert.Throws<IndexOutOfRangeException>(() => typeParams[0].MakeArrayType(rank));
+ }
+ }
+}
+++ /dev/null
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System;
-using System.Reflection;
-using System.Reflection.Emit;
-using Xunit;
-
-namespace System.Reflection.Emit.Tests
-{
- public class GenericTypeParameterBuilderMakeArrayType1
- {
- [Fact]
- public void TestMakeArrayType()
- {
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- string expectedValue = "TFirst[]";
- string actualValue;
-
- Type type = TFirst.MakeArrayType();
- actualValue = type.Name;
- Assert.Equal(expectedValue, actualValue);
- }
- }
-}
+++ /dev/null
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System;
-using System.Reflection;
-using System.Reflection.Emit;
-using Xunit;
-
-namespace System.Reflection.Emit.Tests
-{
- public class GenericTypeParameterBuilderMakeArrayType
- {
- [Fact]
- public void TestWithRankOne()
- {
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
- string expectedValue = "TFirst[*]";
- string actualValue;
-
- Type type = TFirst.MakeArrayType(1);
- actualValue = type.Name;
-
- Assert.Equal(expectedValue, actualValue);
- }
-
- [Fact]
- public void TestWithRankTwo()
- {
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- string expectedValue = "TFirst[,]";
- string actualValue;
-
- Type type = TFirst.MakeArrayType(2);
- actualValue = type.Name;
-
- Assert.Equal(expectedValue, actualValue);
- }
-
- [Fact]
- public void TestThrowsExceptionForZeroRank()
- {
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
- Assert.Throws<IndexOutOfRangeException>(() => { Type type = TFirst.MakeArrayType(0); });
- }
-
- [Fact]
- public void TestThrowsExceptionForNegativeRank()
- {
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
- Assert.Throws<IndexOutOfRangeException>(() => { Type type = TFirst.MakeArrayType(-1); });
- }
- }
-}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using System;
-using System.Reflection;
-using System.Reflection.Emit;
using Xunit;
namespace System.Reflection.Emit.Tests
public class GenericTypeParameterBuilderMakeByRefType
{
[Fact]
- public void TestMakeByRefType()
+ public void MakeByRefType()
{
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- bool expectedValue = true;
- bool actualValue;
-
- Type type = TFirst.MakeByRefType();
- actualValue = (type.Name == "TFirst&") && (type.GetTypeInfo().BaseType == typeof(Array));
- Assert.Equal(expectedValue, actualValue);
+ Type byRefType = typeParams[0].MakeByRefType();
+ Assert.Equal(typeof(Array), byRefType.GetTypeInfo().BaseType);
+ Assert.Equal("TFirst&", byRefType.Name);
}
}
}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using System;
-using System.Reflection;
-using System.Reflection.Emit;
using Xunit;
namespace System.Reflection.Emit.Tests
public class GenericTypeParameterBuilderMakeGenericType
{
[Fact]
- public void TestThrowsExceptionForNullTypeArguments()
+ public void MakeGenericType_NullTypeArguments_ThrowsInvalidOperationException()
{
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
- Assert.Throws<InvalidOperationException>(() => { Type type = TFirst.MakeGenericType(null); });
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+
+ Assert.Throws<InvalidOperationException>(() => typeParams[0].MakeGenericType(null));
}
[Fact]
- public void TestThrowsExceptionForOneMemberArray()
+ public void MakeGenericType_SingleTypeArgument_ThrowsInvalidOperationException()
{
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- Assert.Throws<InvalidOperationException>(() => { Type type = TFirst.MakeGenericType(new Type[] { typeof(Type) }); });
- //this method only throw exceptions
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+
+ Assert.Throws<InvalidOperationException>(() => typeParams[0].MakeGenericType(new Type[] { typeof(Type) }));
}
[Fact]
- public void TestThrowsExceptionForIncorrectNumberOfTypeParams()
+ public void MakeGenericType_TwoTypeArguments_ThrowsInvalidOperationException()
{
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
- Assert.Throws<InvalidOperationException>(() => { Type type = TFirst.MakeGenericType(new Type[] { typeof(int), typeof(string) }); });
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+
+ Assert.Throws<InvalidOperationException>(() => typeParams[0].MakeGenericType(new Type[] { typeof(int), typeof(string) }));
}
}
}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using System;
-using System.Reflection;
-using System.Reflection.Emit;
using Xunit;
namespace System.Reflection.Emit.Tests
public class GenericTypeParameterBuilderMakePointerType
{
[Fact]
- public void TestMakePointerType()
+ public void MakePointerType()
{
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- bool expectedValue = true;
- bool actualValue;
- Type type = TFirst.MakePointerType();
- actualValue = (type.Name == "TFirst*") && (type.GetTypeInfo().BaseType == typeof(Array));
- Assert.Equal(expectedValue, actualValue);
+ Type pointerType = typeParams[0].MakePointerType();
+ Assert.Equal(typeof(Array), pointerType.GetTypeInfo().BaseType);
+ Assert.Equal("TFirst*", pointerType.Name);
}
}
}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using System;
-using System.Reflection;
-using System.Reflection.Emit;
using Xunit;
namespace System.Reflection.Emit.Tests
public class GenericTypeParameterBuilderModule
{
[Fact]
- public void TestModuleProperty()
+ public void Module()
{
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
+ ModuleBuilder module = Helpers.DynamicModule();
+ TypeBuilder type = module.DefineType("TestType", TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
-
- Module expectedValue = myModule;
- Module actualValue;
-
- actualValue = TFirst.Module;
-
- Assert.Equal(expectedValue, actualValue);
+ Assert.Equal(module, typeParams[0].Module);
}
}
}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using System;
-using System.Reflection;
-using System.Reflection.Emit;
using Xunit;
namespace System.Reflection.Emit.Tests
public class GenericTypeParameterBuilderName
{
[Fact]
- public void TestNameProperty()
+ public void Name()
{
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
-
- string expectedValue = "TFirst";
- string actualValue;
-
- actualValue = TFirst.Name;
-
- Assert.Equal(expectedValue, actualValue);
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+ Assert.Equal("TFirst", typeParams[0].Name);
}
}
}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using System;
-using System.Reflection;
-using System.Reflection.Emit;
using Xunit;
namespace System.Reflection.Emit.Tests
public class GenericTypeParameterBuilderNamespace
{
[Fact]
- public void TestNamespaceProperty()
+ public void Namespace_ReturnsNull()
{
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
-
- string expectedValue = null;
- string actualValue;
-
- actualValue = TFirst.Namespace;
-
- Assert.Equal(expectedValue, actualValue);
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+ Assert.Null(typeParams[0].Namespace);
}
}
}
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Xunit;
+
+namespace System.Reflection.Emit.Tests
+{
+ public class GenericTypeParameterBuilderSetCustomAttribute
+ {
+ [Fact]
+ public void SetCustomAttribute_ConstructorInfo_ByteArray()
+ {
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+ ConstructorInfo attributeConstructor = typeof(HelperAttribute).GetConstructors()[0];
+ byte[] binaryAttribute = new byte[128];
+
+ typeParams[0].SetCustomAttribute(attributeConstructor, binaryAttribute);
+ }
+
+ [Fact]
+ public void SetCustomAttribute_ConstructorInfo_ByteArray_NullAttributeConstructor_ThrowsArgumentNullException()
+ {
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+
+ Assert.Throws<ArgumentNullException>("con", () => typeParams[0].SetCustomAttribute(null, new byte[128]));
+ }
+
+ [Fact]
+ public void SetCustomAttribute_ConstructorInfo_ByteArray_NullBinaryAttribute_ThrowsArgumentNullException()
+ {
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+ ConstructorInfo attributeConstructor = typeof(HelperAttribute).GetConstructor(new Type[0]);
+
+ Assert.Throws<ArgumentNullException>("binaryAttribute", () => typeParams[0].SetCustomAttribute(attributeConstructor, null));
+ }
+
+ [Fact]
+ public void SetCustomAttribute_CustomAttributeBuilder()
+ {
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+ ConstructorInfo constructorinfo = typeof(HelperAttribute).GetConstructor(new Type[] { typeof(string) });
+ CustomAttributeBuilder attributeBuilder = new CustomAttributeBuilder(constructorinfo, new object[] { "TestString" });
+
+ typeParams[0].SetCustomAttribute(attributeBuilder);
+ }
+
+ [Fact]
+ public void SetCustomAttribute_CustomAttributeBuilder_NullAttributeBuilder_ThrowsArgumentNullException()
+ {
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+
+ Assert.Throws<ArgumentNullException>("customBuilder", () => typeParams[0].SetCustomAttribute(null));
+ }
+ }
+
+ public class HelperAttribute
+ {
+ public HelperAttribute() { }
+ public HelperAttribute(string str) { }
+ }
+}
+++ /dev/null
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System;
-using System.Reflection;
-using System.Reflection.Emit;
-using Xunit;
-
-namespace System.Reflection.Emit.Tests
-{
- public class GenericTypeParameterBuilderSetCustomAttribute1
- {
- [Fact]
- public void TestSetCustomAttribute()
- {
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- ConstructorInfo[] cons = typeof(HelperAttribute).GetConstructors();
- ConstructorInfo constructorinfo = cons[0];
- byte[] binaryAttribute = new byte[128];
- TFirst.SetCustomAttribute(constructorinfo, binaryAttribute);
- }
-
- [Fact]
- public void TestThrowsExceptionOnNullConstructorInfo()
- {
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- byte[] binaryAttribute = new byte[128];
-
- Assert.Throws<ArgumentNullException>(() => { TFirst.SetCustomAttribute(null, binaryAttribute); });
- }
-
- [Fact]
- public void TestThrowsExceptionForNullByteArray()
- {
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
- ConstructorInfo con = typeof(HelperAttribute).GetConstructor(new Type[] { });
-
- Assert.Throws<ArgumentNullException>(() => { TFirst.SetCustomAttribute(con, null); });
- }
- }
-
- public class HelperAttribute
- {
- public HelperAttribute()
- {
- }
- public HelperAttribute(string str)
- {
- }
- }
-}
+++ /dev/null
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System;
-using System.Reflection;
-using System.Reflection.Emit;
-using Xunit;
-
-namespace System.Reflection.Emit.Tests
-{
- public class GenericTypeParameterBuilderSetCustomAttribute
- {
- [Fact]
- public void TestSetCustomAttribute()
- {
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- Type[] ctorParams = new Type[] { typeof(string) };
- ConstructorInfo constructorinfo = typeof(HelperAttribute).GetConstructor(ctorParams);
- CustomAttributeBuilder cABB = new CustomAttributeBuilder(constructorinfo, new object[] { "TestString" });
- TFirst.SetCustomAttribute(cABB);
- }
-
- [Fact]
- public void TestThrowsExceptionForNullBuilder()
- {
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- Assert.Throws<ArgumentNullException>(() => { TFirst.SetCustomAttribute(null); });
- }
- }
-}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using System;
-using System.Reflection;
-using System.Reflection.Emit;
using Xunit;
namespace System.Reflection.Emit.Tests
{
public class GenericTypeParameterBuilderSetGenericParameterAttributes
{
- [Fact]
- public void TestContravariantGenericParameterAttribute()
- {
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- GenericParameterAttributes gPA = GenericParameterAttributes.Contravariant;
-
-
- TFirst.SetGenericParameterAttributes(gPA);
- Assert.True(TFirst.GenericParameterAttributes.Equals(gPA));
- }
-
- [Fact]
- public void TestCovariantGenericParameterAttribute()
- {
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- GenericParameterAttributes gPA = GenericParameterAttributes.Covariant;
- TFirst.SetGenericParameterAttributes(gPA);
- Assert.True(TFirst.GenericParameterAttributes.Equals(gPA));
- }
-
- [Fact]
- public void TestConstraintGenericParameterAttribute()
- {
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- GenericParameterAttributes gPA = GenericParameterAttributes.DefaultConstructorConstraint;
-
- TFirst.SetGenericParameterAttributes(gPA);
- Assert.True(TFirst.GenericParameterAttributes.Equals(gPA));
- }
-
- [Fact]
- public void TestGenericParameterAttributeWithNoneOption()
- {
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- GenericParameterAttributes gPA = GenericParameterAttributes.None;
-
- TFirst.SetGenericParameterAttributes(gPA);
- Assert.True(TFirst.GenericParameterAttributes.Equals(gPA));
- }
-
- [Fact]
- public void TestNotNullableConstraintGenericParameterAttribute()
- {
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- GenericParameterAttributes gPA = GenericParameterAttributes.NotNullableValueTypeConstraint;
-
- TFirst.SetGenericParameterAttributes(gPA);
- Assert.True(TFirst.GenericParameterAttributes.Equals(gPA));
- }
-
- [Fact]
- public void TestReferenceConstraintGenericParameterAttribute()
- {
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- GenericParameterAttributes gPA = GenericParameterAttributes.ReferenceTypeConstraint;
-
- TFirst.SetGenericParameterAttributes(gPA);
- Assert.True(TFirst.GenericParameterAttributes.Equals(gPA));
- }
-
- [Fact]
- public void TestSpecialConstraintMaskGenericParameterAttribute()
- {
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- GenericParameterAttributes gPA = GenericParameterAttributes.SpecialConstraintMask;
-
- TFirst.SetGenericParameterAttributes(gPA);
- Assert.True(TFirst.GenericParameterAttributes.Equals(gPA));
- }
-
- [Fact]
- public void TestVarianceMaskGenericParameterAttribute()
- {
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- GenericParameterAttributes gPA = GenericParameterAttributes.VarianceMask;
-
- TFirst.SetGenericParameterAttributes(gPA);
- Assert.True(TFirst.GenericParameterAttributes.Equals(gPA));
+ [Theory]
+ [InlineData(GenericParameterAttributes.Contravariant)]
+ [InlineData(GenericParameterAttributes.Covariant)]
+ [InlineData(GenericParameterAttributes.DefaultConstructorConstraint)]
+ [InlineData(GenericParameterAttributes.None)]
+ [InlineData(GenericParameterAttributes.NotNullableValueTypeConstraint)]
+ [InlineData(GenericParameterAttributes.ReferenceTypeConstraint)]
+ [InlineData(GenericParameterAttributes.SpecialConstraintMask)]
+ [InlineData(GenericParameterAttributes.VarianceMask)]
+ public void SetGenericParameterAttributes(GenericParameterAttributes genericParameterAttributes)
+ {
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+ GenericTypeParameterBuilder firstTypeParam = typeParams[0];
+
+ firstTypeParam.SetGenericParameterAttributes(genericParameterAttributes);
+ Assert.Equal(genericParameterAttributes, firstTypeParam.GenericParameterAttributes);
}
}
}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using System;
-using System.Reflection;
-using System.Reflection.Emit;
using Xunit;
namespace System.Reflection.Emit.Tests
public class GenericTypeParameterBuilderSetInterfaceConstraints
{
[Fact]
- public void TestInterfaceConstraintsOnCustomInterface()
+ public void SetInterfaceConstraints_OneCustomInterface()
{
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+
+ typeParams[0].SetInterfaceConstraints(typeof(EmptyInterface1));
+ Type resultType = type.CreateTypeInfo().AsType();
+ Type[] genericTypeParams = resultType.GetGenericArguments();
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- TFirst.SetInterfaceConstraints(typeof(IExample));
- Type type = myType.CreateTypeInfo().AsType();
- Type[] genericTypeParams = type.GetGenericArguments();
Assert.Equal(1, genericTypeParams.Length);
- Assert.Equal(new Type[] { typeof(IExample) }, genericTypeParams[0].GetTypeInfo().GetGenericParameterConstraints());
+ Assert.Equal(new Type[] { typeof(EmptyInterface1) }, genericTypeParams[0].GetTypeInfo().GetGenericParameterConstraints());
}
[Fact]
- public void TestInterfaceConstraintsOnNull()
+ public void SetInterfaceConstraints_Null()
{
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+
+ typeParams[0].SetInterfaceConstraints(null);
+ Type resultType = type.CreateTypeInfo().AsType();
+ Type[] genericTypeParams = resultType.GetGenericArguments();
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
- TFirst.SetInterfaceConstraints(null);
- Type type = myType.CreateTypeInfo().AsType();
- Type[] genericTypeParams = type.GetGenericArguments();
Assert.Equal(1, genericTypeParams.Length);
- Assert.Equal(new Type[] { }, genericTypeParams[0].GetTypeInfo().GetGenericParameterConstraints());
+ Assert.Equal(new Type[0], genericTypeParams[0].GetTypeInfo().GetGenericParameterConstraints());
}
-
[Fact]
- public void TestMultipleInterfaceConstraints()
+ public void SetInterfaceConstraints_MultipleCustomInterfaces()
{
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+
+ typeParams[0].SetInterfaceConstraints(new Type[] { typeof(EmptyInterface1), typeof(EmptyInterface2) });
+ Type resultType = type.CreateTypeInfo().AsType();
+ Type[] genericTypeParams = resultType.GetGenericArguments();
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
- TFirst.SetInterfaceConstraints(new Type[] { typeof(IExample), typeof(IExampleA) });
- Type type = myType.CreateTypeInfo().AsType();
- Type[] genericTypeParams = type.GetGenericArguments();
Assert.Equal(1, genericTypeParams.Length);
- Assert.Equal(new Type[] { typeof(IExample), typeof(IExampleA) }, genericTypeParams[0].GetTypeInfo().GetGenericParameterConstraints());
+ Assert.Equal(new Type[] { typeof(EmptyInterface1), typeof(EmptyInterface2) }, genericTypeParams[0].GetTypeInfo().GetGenericParameterConstraints());
}
}
- public interface IExample { }
-
- public interface IExampleA { }
+ public interface EmptyInterface1 { }
+ public interface EmptyInterface2 { }
}
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-using System;
-using System.Reflection;
-using System.Reflection.Emit;
using Xunit;
namespace System.Reflection.Emit.Tests
public class GenericTypeParameterBuilderToString
{
[Fact]
- public void TestToString()
+ public void ToString_ReturnsName()
{
- AssemblyName myAsmName = new AssemblyName("GenericEmitExample1");
- AssemblyBuilder myAssembly = AssemblyBuilder.DefineDynamicAssembly(myAsmName, AssemblyBuilderAccess.Run);
- ModuleBuilder myModule = TestLibrary.Utilities.GetModuleBuilder(myAssembly, myAsmName.Name);
-
- Type baseType = typeof(ExampleBase);
-
- TypeBuilder myType = myModule.DefineType("Sample", TypeAttributes.Public);
-
- string[] typeParamNames = { "TFirst" };
- GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters(typeParamNames);
-
- GenericTypeParameterBuilder TFirst = typeParams[0];
-
- string expectedValue = TFirst.Name;
- string actualValue;
-
- actualValue = TFirst.ToString();
- Assert.Equal(expectedValue, actualValue);
+ TypeBuilder type = Helpers.DynamicType(TypeAttributes.Public);
+ string[] typeParamNames = new string[] { "TFirst" };
+ GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(typeParamNames);
+ Assert.Equal(typeParams[0].Name, typeParams[0].ToString());
}
}
}
<Compile Include="EnumBuilder\EnumBuilder.Properties.Tests.cs" />
<Compile Include="EventBuilder\EventBuilderAddOtherMethod.cs" />
<Compile Include="EventBuilder\EventBuilderSetAddOnMethod.cs" />
- <Compile Include="EventBuilder\EventBuilderSetCustomAttribute1.cs" />
- <Compile Include="EventBuilder\EventBuilderSetCustomAttribute2.cs" />
+ <Compile Include="EventBuilder\EventBuilderSetCustomAttribute.cs" />
<Compile Include="EventBuilder\EventBuilderSetRaiseMethod.cs" />
<Compile Include="EventBuilder\EventBuilderSetRemoveOnMethod.cs" />
<Compile Include="FieldBuilder\FieldBuilderAttributes.cs" />
<Compile Include="FieldBuilder\FieldBuilderGetValue.cs" />
<Compile Include="FieldBuilder\FieldBuilderName.cs" />
<Compile Include="FieldBuilder\FieldBuilderSetConstant.cs" />
- <Compile Include="FieldBuilder\FieldBuilderSetCustomAttribute1.cs" />
- <Compile Include="FieldBuilder\FieldBuilderSetCustomAttribute2.cs" />
+ <Compile Include="FieldBuilder\FieldBuilderSetCustomAttribute.cs" />
<Compile Include="FieldBuilder\FieldBuilderSetOffset.cs" />
<Compile Include="GenericTypeParameterBuilder\GenericTyepParameterBuilderSetBaseTypeConstraint.cs" />
<Compile Include="GenericTypeParameterBuilder\GenericTypeParameterBuilderAssembly.cs" />
<Compile Include="GenericTypeParameterBuilder\GenericTypeParameterBuilderIsGenericParameter.cs" />
<Compile Include="GenericTypeParameterBuilder\GenericTypeParameterBuilderIsGenericType.cs" />
<Compile Include="GenericTypeParameterBuilder\GenericTypeParameterBuilderIsGenericTypeDefinition.cs" />
- <Compile Include="GenericTypeParameterBuilder\GenericTypeParameterBuilderMakeArrayType1.cs" />
- <Compile Include="GenericTypeParameterBuilder\GenericTypeParameterBuilderMakeArrayType2.cs" />
+ <Compile Include="GenericTypeParameterBuilder\GenericTypeParameterBuilderMakeArrayType.cs" />
<Compile Include="GenericTypeParameterBuilder\GenericTypeParameterBuilderMakeByRefType.cs" />
<Compile Include="GenericTypeParameterBuilder\GenericTypeParameterBuilderMakeGenericType.cs" />
<Compile Include="GenericTypeParameterBuilder\GenericTypeParameterBuilderMakePointerType.cs" />
<Compile Include="GenericTypeParameterBuilder\GenericTypeParameterBuilderModule.cs" />
<Compile Include="GenericTypeParameterBuilder\GenericTypeParameterBuilderName.cs" />
<Compile Include="GenericTypeParameterBuilder\GenericTypeParameterBuilderNamespace.cs" />
- <Compile Include="GenericTypeParameterBuilder\GenericTypeParameterBuilderSetCustomAttribute1.cs" />
- <Compile Include="GenericTypeParameterBuilder\GenericTypeParameterBuilderSetCustomAttribute2.cs" />
+ <Compile Include="GenericTypeParameterBuilder\GenericTypeParameterBuilderSetCustomAttribute.cs" />
<Compile Include="GenericTypeParameterBuilder\GenericTypeParameterBuilderSetGenericParameterAttributes.cs" />
<Compile Include="GenericTypeParameterBuilder\GenericTypeParameterBuilderSetInterfaceConstraints.cs" />
<Compile Include="GenericTypeParameterBuilder\GenericTypeParameterBuilderToString.cs" />
namespace System.Reflection.Emit.Tests
{
+ public class EmptyAttribute : Attribute { }
+
public static class Helpers
{
public static AssemblyBuilder DynamicAssembly(string name = "TestAssembly")
projects / platform / upstream / dotnet / runtime.git / commitdiff