//
// TypeBuilderTest.cs - NUnit Test Cases for the TypeBuilder class
//
// Zoltan Varga (vargaz@freemail.hu)
//
// (C) Ximian, Inc.  http://www.ximian.com
//
// TODO:
//  - implement a mechnanism for easier testing of null argument exceptions
//  - with overloaded methods like DefineNestedType (), check the defaults
//    on the shorter versions.
//  - ToString on enums with the flags attribute set should print all
//    values which match, e.g. 0 == AutoLayou,AnsiClass,NotPublic
//

using System;
using System.Collections;
using System.Threading;
using System.Reflection;
using System.Reflection.Emit;
using System.IO;
using System.Security;
using System.Security.Permissions;
using System.Runtime.InteropServices;
using NUnit.Framework;
using System.Runtime.CompilerServices;
using System.Collections.Generic;

namespace MonoTests.System.Reflection.Emit
{
	public interface EmptyInterface
	{
	}

	public interface OneMethodInterface
	{
		void foo ();
	}

	public class SimpleTestAttribute : Attribute
	{
	}
	public class EmptyIfaceImpl : EmptyInterface
	{
	}

	public class Gen<T> {
		public static T field = default(T);
	}

	[TestFixture]
	public class TypeBuilderTest
	{
		public interface AnInterface
		{
		}

		public interface Foo
		{
		}

		public interface Bar : Foo
		{
		}

		public interface Baz : Bar
		{
		}

		public interface IMoveable
		{
		}

		public interface IThrowable : IMoveable
		{
		}

		public interface ILiquid
		{
		}

		public interface IWater : ILiquid
		{
		}

		public interface IAir
		{
		}

		public interface IDestroyable
		{
		}

		public class Tuple <A,B> {
			public A a;
			public B b;
		}

		private AssemblyBuilder assembly;

		private ModuleBuilder module;

		static string ASSEMBLY_NAME = "MonoTests.System.Reflection.Emit.TypeBuilderTest";

		[SetUp]
		protected void SetUp ()
		{
			AssemblyName assemblyName = new AssemblyName ();
			assemblyName.Name = ASSEMBLY_NAME;

			assembly =
				Thread.GetDomain ().DefineDynamicAssembly (
					assemblyName, AssemblyBuilderAccess.RunAndSave, Path.GetTempPath ());

			module = assembly.DefineDynamicModule ("module1");
		}

		static int typeIndexer = 0;

		// Return a unique type name
		private string genTypeName ()
		{
			return "t" + (typeIndexer++);
		}

		private string nullName ()
		{
			return String.Format ("{0}", (char) 0);
		}

		[Test]
		public void TestAssembly ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public);
			Assert.AreEqual (assembly, tb.Assembly);
		}

		[Test]
		public void TestAssemblyQualifiedName ()
		{
			TypeBuilder tb = module.DefineType ("A.B.C.D", TypeAttributes.Public);
			Assert.AreEqual ("A.B.C.D, " + assembly.GetName ().FullName,
				tb.AssemblyQualifiedName);
		}

		[Test]
		public void TestAttributes ()
		{
			TypeAttributes attrs = TypeAttributes.Public | TypeAttributes.BeforeFieldInit;
			TypeBuilder tb = module.DefineType (genTypeName (), attrs);
			Assert.AreEqual (attrs, tb.Attributes);
		}

		[Test]
		public void TestBaseTypeClass ()
		{
			TypeAttributes attrs = TypeAttributes.Public;
			TypeBuilder tb = module.DefineType (genTypeName (), attrs);
			Assert.AreEqual (typeof (object), tb.BaseType, "#1");

			TypeBuilder tb2 = module.DefineType (genTypeName (), attrs, tb);
			Assert.AreEqual (tb, tb2.BaseType, "#2");
		}

		[Test] // bug #71301
		public void TestBaseTypeInterface ()
		{
			TypeBuilder tb3 = module.DefineType (genTypeName (), TypeAttributes.Interface | TypeAttributes.Abstract);
			Assert.IsNull (tb3.BaseType);
		}

		[Test]
		public void TestDeclaringType ()
		{
			TypeAttributes attrs = 0;
			TypeBuilder tb = module.DefineType (genTypeName (), attrs);
			Assert.IsNull (tb.DeclaringType, "#1");

			attrs = TypeAttributes.NestedPublic;
			TypeBuilder tb2 = tb.DefineNestedType (genTypeName (), attrs);
			TypeBuilder tb3 = tb2.DefineNestedType (genTypeName (), attrs);
			Assert.AreEqual (tb3.DeclaringType.DeclaringType, tb, "#2");
		}

		[Test]
		public void TestFullName ()
		{
			string name = genTypeName ();
			TypeAttributes attrs = 0;
			TypeBuilder tb = module.DefineType (name, attrs);
			Assert.AreEqual (name, tb.FullName, "#1");

			string name2 = genTypeName ();
			attrs = TypeAttributes.NestedPublic;
			TypeBuilder tb2 = tb.DefineNestedType (name2, attrs);

			string name3 = genTypeName ();
			attrs = TypeAttributes.NestedPublic;
			TypeBuilder tb3 = tb2.DefineNestedType (name3, attrs);

			Assert.AreEqual (name + "+" + name2 + "+" + name3, tb3.FullName, "#2");
		}

		[Test]
		public void DefineCtorUsingDefineMethod ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public | TypeAttributes.Class);
			MethodBuilder mb = tb.DefineMethod(
				".ctor", MethodAttributes.Public | MethodAttributes.RTSpecialName | MethodAttributes.SpecialName,
				null, null);
			ILGenerator ilgen = mb.GetILGenerator();
			ilgen.Emit(OpCodes.Ldarg_0);
			ilgen.Emit(OpCodes.Call,
					   typeof(object).GetConstructor(Type.EmptyTypes));
			ilgen.Emit(OpCodes.Ret);
			Type t = tb.CreateType();

			Assert.AreEqual (1, t.GetConstructors ().Length);
		}

		[Test]
		public void TestGUIDIncomplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			try {
				Guid g = tb.GUID;
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test] // bug #71302
		[Category ("NotWorking")]
		public void TestGUIDComplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.CreateType ();
			Assert.IsTrue (tb.GUID != Guid.Empty);
		}

		[Test]
		[Category ("NotWorking")]
		public void TestFixedGUIDComplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());

			Guid guid = Guid.NewGuid ();

			ConstructorInfo guidCtor = typeof (GuidAttribute).GetConstructor (
				new Type [] { typeof (string) });

			CustomAttributeBuilder caBuilder = new CustomAttributeBuilder (guidCtor,
				new object [] { guid.ToString ("D") }, new FieldInfo [0], new object [0]);

			tb.SetCustomAttribute (caBuilder);
			tb.CreateType ();
			Assert.AreEqual (guid, tb.GUID);
		}

		[Test]
		public void TestHasElementType_Incomplete ()
		{
			// According to the MSDN docs, this member works, but in reality, it
			// returns a NotSupportedException
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.IsFalse (tb.HasElementType);
		}

		[Test]
		public void TestHasElementType_Complete ()
		{
			// According to the MSDN docs, this member works, but in reality, it
			// returns a NotSupportedException
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.CreateType ();
			Assert.IsFalse (tb.HasElementType);
		}

		[Test] // bug #324692
		public void CreateType_Enum_NoInstanceField ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (),
				TypeAttributes.Sealed | TypeAttributes.Serializable,
				typeof (Enum));

			try {
				tb.CreateType ();
				Assert.Fail ("#1: must throw TypeLoadException");
			} catch (TypeLoadException) {
			}

			Assert.IsTrue (tb.IsCreated (), "#2");
		}

		[Test] // bug #324692
		public void TestCreateTypeReturnsNullOnSecondCallForBadType ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (),
				TypeAttributes.Sealed | TypeAttributes.Serializable,
				typeof (Enum));

			try {
				tb.CreateType ();
				Assert.Fail ("#A1");
			} catch (TypeLoadException ex) {
				Assert.AreEqual (typeof (TypeLoadException), ex.GetType (), "#A2");
				Assert.IsNull (ex.InnerException, "#A3");
				Assert.IsNotNull (ex.Message, "#A4");
			}

			Assert.IsTrue (tb.IsCreated (), "#B1");
			Assert.IsNull (tb.CreateType (), "#B2");
			Assert.IsTrue (tb.IsCreated (), "#B3");
		}

		[Test]
		public void TestEnumWithEmptyInterfaceBuildsOk ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (),
				TypeAttributes.Sealed | TypeAttributes.Serializable,
				typeof (Enum));
			tb.DefineField ("value__", typeof (int), FieldAttributes.SpecialName |
				FieldAttributes.Private | FieldAttributes.RTSpecialName);

			tb.AddInterfaceImplementation (typeof (EmptyInterface));

			try {
				tb.CreateType ();
			} catch (TypeLoadException) {
				Assert.Fail ("#1: must build enum type ok");
			}

			Assert.IsTrue (tb.IsCreated (), "#2");
		}

		[Test]
		[Category ("NotWorking")]
		public void TestEnumWithNonEmptyInterfaceBuildsFails ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (),
				TypeAttributes.Sealed | TypeAttributes.Serializable,
				typeof (Enum));
			tb.DefineField ("value__", typeof (int), FieldAttributes.SpecialName |
				FieldAttributes.Private | FieldAttributes.RTSpecialName);

			tb.AddInterfaceImplementation (typeof (OneMethodInterface));

			try {
				tb.CreateType ();
				Assert.Fail ("#1: type doesn't have all interface methods");
			} catch (TypeLoadException) {
			}

			Assert.IsTrue (tb.IsCreated (), "#2");
		}

		[Test]
		[Category ("NotWorking")]
		public void TestTypeDontImplementInterfaceMethodBuildsFails ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (),
				TypeAttributes.Sealed | TypeAttributes.Serializable,
				typeof (object));

			tb.AddInterfaceImplementation (typeof (OneMethodInterface));

			try {
				tb.CreateType ();
				Assert.Fail ("#1: type doesn't have all interface methods");
			} catch (TypeLoadException) {
			}

			Assert.IsTrue (tb.IsCreated (), "#2");
		}

		[Test]
		public void TestEnumWithSequentialLayoutBuildsFails ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (),
				TypeAttributes.Sealed | TypeAttributes.Serializable |
				TypeAttributes.SequentialLayout, typeof (Enum));
			tb.DefineField ("value__", typeof (int), FieldAttributes.SpecialName |
				FieldAttributes.Private | FieldAttributes.RTSpecialName);

			try {
				tb.CreateType ();
				Assert.Fail ("#1: type doesn't have all interface methods");
			} catch (TypeLoadException) {
			}

			Assert.IsTrue (tb.IsCreated (), "#2");
		}

		[Test]
		public void TestEnumWithExplicitLayoutBuildsFails ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (),
				TypeAttributes.Sealed | TypeAttributes.Serializable |
				TypeAttributes.ExplicitLayout, typeof (Enum));
			tb.DefineField ("value__", typeof (int), FieldAttributes.SpecialName |
				FieldAttributes.Private | FieldAttributes.RTSpecialName);

			try {
				tb.CreateType ();
				Assert.Fail ("#1: type doesn't have all interface methods");
			} catch (TypeLoadException) {
			}

			Assert.IsTrue (tb.IsCreated (), "#2");
		}

		[Test]
		public void TestEnumWithMethodsBuildFails ()
		{
			TypeBuilder tb = module.DefineType ("FooEnum7",
				TypeAttributes.Sealed | TypeAttributes.Serializable,
				typeof (Enum));
			tb.DefineField ("value__", typeof (int), FieldAttributes.SpecialName |
				FieldAttributes.Private | FieldAttributes.RTSpecialName);

			MethodBuilder methodBuilder = tb.DefineMethod("mmm",
				MethodAttributes.Public | MethodAttributes.Virtual,
				null,
				new Type[] { });

			methodBuilder.GetILGenerator().Emit(OpCodes.Ret);
			try {
				tb.CreateType ();
				Assert.Fail ("#1: enum has method");
			} catch (TypeLoadException) {
			}

			Assert.IsTrue (tb.IsCreated (), "#2");
		}

		[Test]
		public void TestEnumWithBadTypeValueFieldBuildFails ()
		{
			Type[] badTypes = {
				typeof (object),
				typeof (string),
				typeof (DateTime)
			};

			foreach (Type type in badTypes) {
				TypeBuilder tb = module.DefineType (genTypeName (),
					TypeAttributes.Sealed | TypeAttributes.Serializable,
					typeof (Enum));
				tb.DefineField ("value__", type, FieldAttributes.SpecialName |
					FieldAttributes.Private | FieldAttributes.RTSpecialName);

				try {
					tb.CreateType ();
					Assert.Fail ("#1: enum using bad type: " + type);
				} catch (TypeLoadException) {
				}

				Assert.IsTrue (tb.IsCreated (), "#2");
			}
		}

		[Test]
		public void TestEnumWithGoodTypeValueFieldBuildOk ()
		{
			Type[] goodTypes = {
				typeof (byte),typeof (sbyte),typeof (bool),
				typeof (ushort),typeof (short),typeof (char),
				typeof (uint),typeof (int),
				typeof (ulong),typeof (long),
				typeof (UIntPtr),typeof (IntPtr),
			};

			foreach (Type type in goodTypes) {
				TypeBuilder tb = module.DefineType (genTypeName (),
					TypeAttributes.Sealed | TypeAttributes.Serializable,
					typeof (Enum));
				tb.DefineField ("value__", type, FieldAttributes.SpecialName |
					FieldAttributes.Private | FieldAttributes.RTSpecialName);

				try {
					tb.CreateType ();
				} catch (TypeLoadException) {
					Assert.Fail ("#1: enum using good type: " + type);
				}
			}
		}

		[Test]
		public void TestEnumWithMultipleValueFieldsBuildFals ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (),
				TypeAttributes.Sealed | TypeAttributes.Serializable,
				typeof (Enum));
			tb.DefineField ("value__", typeof (int), FieldAttributes.SpecialName |
				FieldAttributes.Private | FieldAttributes.RTSpecialName);
			tb.DefineField ("value2__", typeof (int), FieldAttributes.SpecialName |
				FieldAttributes.Private | FieldAttributes.RTSpecialName);

			try {
				tb.CreateType ();
				Assert.Fail ("#1: invalid enum type");
			} catch (TypeLoadException) {
			}

			Assert.IsTrue (tb.IsCreated (), "#2");
		}

		[Test]
		[Category ("NotWorking")]
		public void TestEnumWithEmptyInterfaceCanBeCasted ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (),
				TypeAttributes.Sealed | TypeAttributes.Serializable,
				typeof (Enum));
			tb.DefineField ("value__", typeof (int), FieldAttributes.SpecialName |
				FieldAttributes.Private | FieldAttributes.RTSpecialName);
			tb.AddInterfaceImplementation (typeof (EmptyInterface));

			try {
				tb.CreateType ();
			} catch (TypeLoadException) {
				Assert.Fail ("#1: must build enum type ok");
			}

			try {
				EmptyInterface obj = (EmptyInterface) Activator.CreateInstance (tb);
				Assert.IsNotNull (obj, "#2");
			} catch (TypeLoadException) {
				Assert.Fail ("#3: must cast enum to interface");
			}
		}

		[Test]
		public void TestEnumWithValueFieldBuildOk ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (),
				TypeAttributes.Sealed | TypeAttributes.Serializable,
				typeof (Enum));
			tb.DefineField ("value__", typeof (int), FieldAttributes.SpecialName |
				FieldAttributes.Private | FieldAttributes.RTSpecialName);

			try {
				tb.CreateType ();
			} catch (TypeLoadException) {
				Assert.Fail ("#1: must build enum type ok");
			}
		}

		[Test]
		public void TestIsAbstract ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.IsFalse (tb.IsAbstract, "#1");

			TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.Abstract);
			Assert.IsTrue (tb2.IsAbstract, "#2");
		}

		[Test]
		public void TestIsAnsiClass ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.IsTrue (tb.IsAnsiClass, "#1");

			TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.UnicodeClass);
			Assert.IsFalse (tb2.IsAnsiClass, "#2");
		}

		[Test]
		public void TestIsArray ()
		{
			// How can a TypeBuilder be an array ?
			string name = genTypeName ();
			TypeBuilder tb = module.DefineType (name);
			Assert.IsFalse (tb.IsArray);
		}

		[Test]
		public void TestIsAutoClass ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.IsFalse (tb.IsAutoClass, "#1");

			TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.AutoClass);
			Assert.IsTrue (tb2.IsAutoClass, "#2");
		}

		[Test]
		public void TestIsAutoLayout ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.IsTrue (tb.IsAutoLayout, "#1");

			TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.ExplicitLayout);
			Assert.IsFalse (tb2.IsAutoLayout, "#2");
		}

		[Test]
		public void TestIsByRef ()
		{
			// How can a TypeBuilder be ByRef ?
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.IsFalse (tb.IsByRef);
		}

		[Test]
		public void TestIsClass ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.IsTrue (tb.IsClass, "#1");

			TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.Interface | TypeAttributes.Abstract);
			Assert.IsFalse (tb2.IsClass, "#2");

			TypeBuilder tb3 = module.DefineType (genTypeName (), 0, typeof (ValueType));
			Assert.IsFalse (tb3.IsClass, "#3");

			TypeBuilder tb4 = module.DefineType (genTypeName (), 0, typeof (Enum));
			Assert.IsFalse (tb4.IsClass, "#4");
		}

		[Test] // bug #71304
		public void TestIsCOMObject ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.IsFalse (tb.IsCOMObject, "#1");

			tb = module.DefineType (genTypeName (), TypeAttributes.Import);
			Assert.IsTrue (tb.IsCOMObject, "#2");
		}

		[Test]
		public void TestIsContextful ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.IsFalse (tb.IsContextful, "#1");

			TypeBuilder tb2 = module.DefineType (genTypeName (), 0, typeof (ContextBoundObject));
			Assert.IsTrue (tb2.IsContextful, "#2");
		}

		[Test]
		public void TestIsEnum ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.IsFalse (tb.IsEnum, "#1");

			TypeBuilder tb2 = module.DefineType (genTypeName (), 0, typeof (ValueType));
			Assert.IsFalse (tb2.IsEnum, "#2");

			TypeBuilder tb3 = module.DefineType (genTypeName (), 0, typeof (Enum));
			Assert.IsTrue (tb3.IsEnum, "#3");
		}

		[Test]
		public void TestIsExplicitLayout ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.IsFalse (tb.IsExplicitLayout, "#1");

			TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.ExplicitLayout);
			Assert.IsTrue (tb2.IsExplicitLayout, "#2");
		}

		[Test]
		public void TestIsImport ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.IsFalse (tb.IsImport, "#1");

			tb = module.DefineType (genTypeName (), TypeAttributes.Import);
			Assert.IsTrue (tb.IsImport, "#2");
		}

		[Test]
		public void TestIsInterface ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.IsFalse (tb.IsInterface, "#1");

			TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.Interface | TypeAttributes.Abstract);
			Assert.IsTrue (tb2.IsInterface, "#2");

			TypeBuilder tb3 = module.DefineType (genTypeName (), 0, typeof (ValueType));
			Assert.IsFalse (tb3.IsInterface, "#3");
		}

		[Test]
		public void TestIsLayoutSequential ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.IsFalse (tb.IsLayoutSequential, "#1");

			TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.SequentialLayout);
			Assert.IsTrue (tb2.IsLayoutSequential, "#2");
		}

		[Test]
		public void TestIsMarshalByRef ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.IsFalse (tb.IsMarshalByRef, "#1");

			TypeBuilder tb2 = module.DefineType (genTypeName (), 0, typeof (MarshalByRefObject));
			Assert.IsTrue (tb2.IsMarshalByRef, "#2");

			TypeBuilder tb3 = module.DefineType (genTypeName (), 0, typeof (ContextBoundObject));
			Assert.IsTrue (tb3.IsMarshalByRef, "#3");
		}

		// TODO: Visibility properties

		[Test]
		public void TestIsPointer ()
		{
			// How can this be true?
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.IsFalse (tb.IsPointer);
		}

		[Test]
		public void TestIsPrimitive ()
		{
			TypeBuilder tb = module.DefineType ("int");
			Assert.IsFalse (tb.IsPrimitive);
		}

		[Test]
		public void IsSealed ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.IsFalse (tb.IsSealed, "#1");

			TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.Sealed);
			Assert.IsTrue (tb2.IsSealed, "#2");
		}

		static string CreateTempAssembly ()
		{
			FileStream f = null;
			string path;
			Random rnd;
			int num = 0;

			rnd = new Random ();
			do {
				num = rnd.Next ();
				num++;
				path = Path.Combine (Path.GetTempPath (), "tmp" + num.ToString ("x") + ".dll");

				try {
					f = new FileStream (path, FileMode.CreateNew);
				} catch { }
			} while (f == null);

			f.Close ();


			return "tmp" + num.ToString ("x") + ".dll";
		}

		[Test]
		public void IsSerializable ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.IsFalse (tb.IsSerializable, "#1");

			ConstructorInfo [] ctors = typeof (SerializableAttribute).GetConstructors (BindingFlags.Instance | BindingFlags.Public);
			Assert.IsTrue (ctors.Length > 0, "#2");

			tb.SetCustomAttribute (new CustomAttributeBuilder (ctors [0], new object [0]));
			Type createdType = tb.CreateType ();

			string an = CreateTempAssembly ();
			assembly.Save (an);
			Assert.IsTrue (createdType.IsSerializable, "#3");
			File.Delete (Path.Combine (Path.GetTempPath (), an));
		}

		[Test]
		public void TestIsSpecialName ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.IsFalse (tb.IsSpecialName, "#1");

			TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.SpecialName);
			Assert.IsTrue (tb2.IsSpecialName, "#2");
		}

		[Test]
		public void TestIsUnicodeClass ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.IsFalse (tb.IsUnicodeClass, "#1");

			TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.UnicodeClass);
			Assert.IsTrue (tb2.IsUnicodeClass, "#2");
		}

		[Test]
		public void TestIsValueType ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.IsFalse (tb.IsValueType, "#1");

			TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.Interface | TypeAttributes.Abstract);
			Assert.IsFalse (tb2.IsValueType, "#2");

			TypeBuilder tb3 = module.DefineType (genTypeName (), 0, typeof (ValueType));
			Assert.IsTrue (tb3.IsValueType, "#3");

			TypeBuilder tb4 = module.DefineType (genTypeName (), 0, typeof (Enum));
			Assert.IsTrue (tb4.IsValueType, "#4");
		}

		[Test]
		public void TestMemberType ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.AreEqual (MemberTypes.TypeInfo, tb.MemberType);
		}

		[Test]
		public void TestModule ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.AreEqual (module, tb.Module);
		}

		[Test]
		public void TestName ()
		{
			TypeBuilder tb = module.DefineType ("A");
			Assert.AreEqual ("A", tb.Name, "#1");

			TypeBuilder tb2 = module.DefineType ("A.B.C.D.E");
			Assert.AreEqual ("E", tb2.Name, "#2");

			TypeBuilder tb3 = tb2.DefineNestedType ("A");
			Assert.AreEqual ("A", tb3.Name, "#3");

			/* Is .E a valid name ?
			TypeBuilder tb4 = module.DefineType (".E");
			Assert.AreEqual ("E", tb4.Name);
			*/
		}

		[Test]
		public void TestNamespace ()
		{
			TypeBuilder tb = module.DefineType ("A");
			Assert.AreEqual (string.Empty, tb.Namespace, "#1");

			TypeBuilder tb2 = module.DefineType ("A.B.C.D.E");
			Assert.AreEqual ("A.B.C.D", tb2.Namespace, "#2");

			TypeBuilder tb3 = tb2.DefineNestedType ("A");
			Assert.AreEqual (string.Empty, tb3.Namespace, "#3");

			/* Is .E a valid name ?
			TypeBuilder tb4 = module.DefineType (".E");
			Assert.AreEqual ("E", tb4.Name);
			*/
		}

		[Test]
		public void TestPackingSize ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.AreEqual (PackingSize.Unspecified, tb.PackingSize, "#1");

			TypeBuilder tb2 = module.DefineType (genTypeName (), 0, typeof (object),
				PackingSize.Size16, 16);
			Assert.AreEqual (PackingSize.Size16, tb2.PackingSize, "#2");
		}

		[Test]
		public void TestReflectedType ()
		{
			// It is the same as DeclaringType, but why?
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.IsNull (tb.ReflectedType, "#1");

			TypeBuilder tb2 = tb.DefineNestedType (genTypeName ());
			Assert.AreEqual (tb, tb2.ReflectedType, "#2");
		}

		[Test]
		public void SetParent_Parent_Null ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Class,
				typeof (Attribute));
			tb.SetParent (null);
			Assert.AreEqual (typeof (object), tb.BaseType, "#A1");

			tb = module.DefineType (genTypeName (), TypeAttributes.Interface |
				TypeAttributes.Abstract);
			tb.SetParent (null);
			Assert.IsNull (tb.BaseType, "#B1");

			tb = module.DefineType (genTypeName (), TypeAttributes.Interface |
				TypeAttributes.Abstract, typeof (ICloneable));
			Assert.AreEqual (typeof (ICloneable), tb.BaseType, "#C1");
			tb.SetParent (null);
			Assert.IsNull (tb.BaseType, "#C2");

			tb = module.DefineType (genTypeName (), TypeAttributes.Interface,
				typeof (IDisposable));
			try {
				tb.SetParent (null);
				Assert.Fail ("#D1");
			} catch (InvalidOperationException ex) {
				// Interface must be declared abstract
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
				Assert.IsNull (ex.InnerException, "#D3");
				Assert.IsNotNull (ex.Message, "#D4");
			}
		}

		[Test]
		public void SetParent_Parent_Interface ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Class);
			tb.SetParent (typeof (ICloneable));
			Assert.AreEqual (typeof (ICloneable), tb.BaseType);
		}

		[Test]
		public void TestSetParentIncomplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.SetParent (typeof (Attribute));
			Assert.AreEqual (typeof (Attribute), tb.BaseType, "#1");

			tb = module.DefineType (genTypeName (), TypeAttributes.Interface |
				TypeAttributes.Abstract);
			tb.SetParent (typeof (IDisposable));
			Assert.AreEqual (typeof (IDisposable), tb.BaseType, "#2");

			tb = module.DefineType (genTypeName ());
			tb.SetParent (typeof (IDisposable));
			Assert.AreEqual (typeof (IDisposable), tb.BaseType, "#3");

			tb = module.DefineType (genTypeName (), TypeAttributes.Interface |
				TypeAttributes.Abstract, typeof (IDisposable));
			tb.SetParent (typeof (ICloneable));
			Assert.AreEqual (typeof (ICloneable), tb.BaseType, "#4");

			tb = module.DefineType (genTypeName (), TypeAttributes.Interface |
				TypeAttributes.Abstract, typeof (IDisposable));
			tb.SetParent (typeof (ICloneable));
			Assert.AreEqual (typeof (ICloneable), tb.BaseType, "#5");
		}

		[Test]
		public void TestSetParentComplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.CreateType ();
			try {
				tb.SetParent (typeof (Attribute));
				Assert.Fail ("#1");
			} catch (InvalidOperationException ex) {
				// Unable to change after type has been created
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void TestSize ()
		{
			{
				TypeBuilder tb = module.DefineType (genTypeName ());
				Assert.AreEqual (0, tb.Size, "#1");
				tb.CreateType ();
				Assert.AreEqual (0, tb.Size, "#2");
			}

			{
				TypeBuilder tb = module.DefineType (genTypeName (), 0, typeof (object),
					PackingSize.Size16, 32);
				Assert.AreEqual (32, tb.Size, "#3");
			}
		}

		[Test]
		public void TestTypeHandle ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			try {
				RuntimeTypeHandle handle = tb.TypeHandle;
				Assert.Fail ("#1:" + handle);
			} catch (NotSupportedException ex) {
				// The invoked member is not supported in a
				// dynamic module
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void TestTypeInitializerIncomplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			try {
				ConstructorInfo cb = tb.TypeInitializer;
				Assert.Fail ("#1:" + (cb != null));
			} catch (NotSupportedException ex) {
				// The invoked member is not supported in a
				// dynamic module
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void TestTypeInitializerComplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.CreateType ();
			ConstructorInfo cb = tb.TypeInitializer;
		}

		[Test]
		public void TestTypeToken ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			TypeToken token = tb.TypeToken;
		}

		[Test]
		public void UnderlyingSystemType ()
		{
			TypeBuilder tb;
			Type emitted_type;

			tb = module.DefineType (genTypeName ());
			Assert.AreSame (tb, tb.UnderlyingSystemType, "#A1");
			emitted_type = tb.CreateType ();
			Assert.AreSame (emitted_type, tb.UnderlyingSystemType, "#A2");

			tb = module.DefineType (genTypeName (), TypeAttributes.Interface | TypeAttributes.Abstract);
			Assert.AreSame (tb, tb.UnderlyingSystemType, "#B1");
			emitted_type = tb.CreateType ();
			Assert.AreSame (emitted_type, tb.UnderlyingSystemType, "#B2");

			tb = module.DefineType (genTypeName (), 0, typeof (ValueType));
			Assert.AreSame (tb, tb.UnderlyingSystemType, "#C1");
			emitted_type = tb.CreateType ();
			Assert.AreSame (emitted_type, tb.UnderlyingSystemType, "#C2");

			tb = module.DefineType (genTypeName (), 0, typeof (Enum));
			try {
				Type t = tb.UnderlyingSystemType;
				Assert.Fail ("#D1:" + t);
			} catch (InvalidOperationException ex) {
				// Underlying type information on enumeration
				// is not specified
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
				Assert.IsNull (ex.InnerException, "#D3");
				Assert.IsNotNull (ex.Message, "#D4");
			}
			tb.DefineField ("val", typeof (int), FieldAttributes.Private);
			Assert.AreEqual (typeof (int), tb.UnderlyingSystemType, "#D5");
			emitted_type = tb.CreateType ();
			Assert.AreSame (emitted_type, tb.UnderlyingSystemType, "#D6");

			tb = module.DefineType (genTypeName (), 0, typeof (Enum));
			tb.DefineField ("val", typeof (int), FieldAttributes.Static);
			try {
				Type t = tb.UnderlyingSystemType;
				Assert.Fail ("#E1:" + t);
			} catch (InvalidOperationException ex) {
				// Underlying type information on enumeration
				// is not specified
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");
				Assert.IsNull (ex.InnerException, "#E3");
				Assert.IsNotNull (ex.Message, "#E4");
			}
			tb.DefineField ("foo", typeof (long), FieldAttributes.Private);
			Assert.AreEqual (typeof (long), tb.UnderlyingSystemType, "#E5");
			tb.DefineField ("bar", typeof (short), FieldAttributes.Private);
			Assert.AreEqual (typeof (long), tb.UnderlyingSystemType, "#E6");
			tb.DefineField ("boo", typeof (int), FieldAttributes.Static);
			Assert.AreEqual (typeof (long), tb.UnderlyingSystemType, "#E7");
		}

		[Test]
		public void AddInterfaceImplementation_InterfaceType_Null ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			try {
				tb.AddInterfaceImplementation (null);
				Assert.Fail ("#1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
				Assert.AreEqual ("interfaceType", ex.ParamName, "#5");
			}
		}

		[Test]
		public void TestAddInterfaceImplementation ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.AddInterfaceImplementation (typeof (AnInterface));
			tb.AddInterfaceImplementation (typeof (AnInterface));

			Type t = tb.CreateType ();
			Assert.AreEqual (1, tb.GetInterfaces ().Length, "#2");

			// Can not be called on a created type
			try {
				tb.AddInterfaceImplementation (typeof (AnInterface));
				Assert.Fail ("#3");
			} catch (InvalidOperationException) {
			}
		}

		[Test]
		public void TestCreateType_Created ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.IsFalse (tb.IsCreated (), "#A1");

			Type emittedType1 = tb.CreateType ();
			Assert.IsTrue (tb.IsCreated (), "#A2");
			Assert.IsNotNull (emittedType1, "#A3");

			Type emittedType2 = tb.CreateType ();
			Assert.IsNotNull (emittedType2, "#B1");
			Assert.IsTrue (tb.IsCreated (), "#B2");
			Assert.AreSame (emittedType1, emittedType2, "#B3");
		}

		[Test]
		public void TestDefineConstructor ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());

			ConstructorBuilder cb = tb.DefineConstructor (0, 0, null);
			cb.GetILGenerator ().Emit (OpCodes.Ret);
			tb.CreateType ();

			// Can not be called on a created type
			try {
				tb.DefineConstructor (0, 0, null);
				Assert.Fail ("#1");
			} catch (InvalidOperationException ex) {
				// Unable to change after type has been created
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void DefineDefaultConstructor ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.DefineDefaultConstructor (0);
			tb.CreateType ();

			// Can not be called on a created type, altough the MSDN docs does not mention this
			try {
				tb.DefineDefaultConstructor (0);
				Assert.Fail ("#1");
			} catch (InvalidOperationException ex) {
				// Unable to change after type has been created
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		[Category ("AndroidNotWorking")] // Fails with System.MethodAccessException : Method `t17:.ctor ()' is inaccessible from method `t18:.ctor ()'
		public void DefineDefaultConstructor_Parent_DefaultCtorInaccessible ()
		{
			TypeBuilder tb;
			
			tb = module.DefineType (genTypeName ());
			tb.DefineDefaultConstructor (MethodAttributes.Private);
			Type parent_type = tb.CreateType ();

			tb = module.DefineType (genTypeName (), TypeAttributes.Class,
				parent_type);
			tb.DefineDefaultConstructor (MethodAttributes.Public);
			Type emitted_type = tb.CreateType ();
			try {
				Activator.CreateInstance (emitted_type);
				Assert.Fail ("#1");
			} catch (TargetInvocationException ex) {
				Assert.AreEqual (typeof (TargetInvocationException), ex.GetType (), "#2");
				Assert.IsNotNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");

				MethodAccessException mae = ex.InnerException as MethodAccessException;
				Assert.IsNotNull (mae, "#5");
				Assert.AreEqual (typeof (MethodAccessException), mae.GetType (), "#6");
				Assert.IsNull (mae.InnerException, "#7");
				Assert.IsNotNull (mae.Message, "#8");
				Assert.IsTrue (mae.Message.IndexOf (parent_type.FullName) != -1, "#9:" + mae.Message);
				Assert.IsTrue (mae.Message.IndexOf (".ctor") != -1, "#10:" + mae.Message);
			}
		}

		[Test]
		public void DefineDefaultConstructor_Parent_DefaultCtorMissing ()
		{
			TypeBuilder tb;

			tb = module.DefineType (genTypeName ());
			ConstructorBuilder cb = tb.DefineConstructor (
				MethodAttributes.Public,
				CallingConventions.Standard,
				new Type [] { typeof (string) });
			cb.GetILGenerator ().Emit (OpCodes.Ret);
			Type parent_type = tb.CreateType ();

			tb = module.DefineType (genTypeName (), TypeAttributes.Class,
				parent_type);
			try {
				tb.DefineDefaultConstructor (MethodAttributes.Public);
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				// Parent does not have a default constructor.
				// The default constructor must be explicitly defined
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void DefineEvent_Name_NullChar ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());

			try {
				tb.DefineEvent ("\0test", EventAttributes.None,
					typeof (int));
				Assert.Fail ("#A1");
			} catch (ArgumentException ex) {
				// Illegal name
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
				Assert.IsNull (ex.InnerException, "#A3");
				Assert.IsNotNull (ex.Message, "#A4");
				Assert.AreEqual ("name", ex.ParamName, "#A5");
			}

			EventBuilder eb = tb.DefineEvent ("te\0st", EventAttributes.None,
				typeof (int));
			Assert.IsNotNull (eb, "#B1");
		}

		[Test]
		public void TestDefineEvent ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());

			// Test invalid arguments
			try {
				tb.DefineEvent (null, 0, typeof (int));
				Assert.Fail ("#A1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
				Assert.IsNull (ex.InnerException, "#A3");
				Assert.IsNotNull (ex.Message, "#A4");
				Assert.AreEqual ("name", ex.ParamName, "#A5");
			}

			try {
				tb.DefineEvent ("FOO", 0, null);
				Assert.Fail ("#B1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
				Assert.IsNull (ex.InnerException, "#B3");
				Assert.IsNotNull (ex.Message, "#B4");
				Assert.AreEqual ("type", ex.ParamName, "#B5");
			}

			try {
				tb.DefineEvent (string.Empty, 0, typeof (int));
				Assert.Fail ("#C1");
			} catch (ArgumentException ex) {
				// Empty name is not legal
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
				Assert.IsNull (ex.InnerException, "#C3");
				Assert.IsNotNull (ex.Message, "#C4");
				Assert.AreEqual ("name", ex.ParamName, "#C5");
			}

			tb.CreateType ();

			// Can not be called on a created type
			try {
				tb.DefineEvent ("BAR", 0, typeof (int));
				Assert.Fail ("#D1");
			} catch (InvalidOperationException ex) {
				// Unable to change after type has been created
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
				Assert.IsNull (ex.InnerException, "#D3");
				Assert.IsNotNull (ex.Message, "#D4");
			}
		}

		[Test] // DefineField (String, Type, FieldAttributes)
		public void DefineField1 ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());

			// Check invalid arguments
			try {
				tb.DefineField (null, typeof (int), 0);
				Assert.Fail ("#A1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
				Assert.IsNull (ex.InnerException, "#A3");
				Assert.IsNotNull (ex.Message, "#A4");
				Assert.AreEqual ("fieldName", ex.ParamName, "#A5");
			}

			try {
				tb.DefineField (string.Empty, typeof (int), 0);
				Assert.Fail ("#B1");
			} catch (ArgumentException ex) {
				// Empty name is not legal
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
				Assert.IsNull (ex.InnerException, "#B3");
				Assert.IsNotNull (ex.Message, "#B4");
				Assert.AreEqual ("fieldName", ex.ParamName, "#B5");
			}

			try {
				// Strangely, 'A<NULL>' is accepted...
				string name = String.Format ("{0}", (char) 0);
				tb.DefineField (name, typeof (int), 0);
				Assert.Fail ("#C1");
			} catch (ArgumentException ex) {
				// Illegal name
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
				Assert.IsNull (ex.InnerException, "#C3");
				Assert.IsNotNull (ex.Message, "#C4");
				Assert.AreEqual ("fieldName", ex.ParamName, "#C5");
			}

			try {
				tb.DefineField ("A", typeof (void), 0);
				Assert.Fail ("#D1");
			} catch (ArgumentException ex) {
				// Bad field type in defining field
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
				Assert.IsNull (ex.InnerException, "#D3");
				Assert.IsNotNull (ex.Message, "#D4");
				Assert.IsNull (ex.ParamName, "#D5");
			}

			tb.CreateType ();

			// Can not be called on a created type
			try {
				tb.DefineField ("B", typeof (int), 0);
				Assert.Fail ("#E1");
			} catch (InvalidOperationException ex) {
				// Unable to change after type has been created
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#E2");
				Assert.IsNull (ex.InnerException, "#E3");
				Assert.IsNotNull (ex.Message, "#E4");
			}
		}

		[Test] // DefineField (String, Type, FieldAttributes)
		public void DefineField1_Name_NullChar ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());

			try {
				tb.DefineField ("\0test", typeof (int),
					FieldAttributes.Private);
				Assert.Fail ("#A1");
			} catch (ArgumentException ex) {
				// Illegal name
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
				Assert.IsNull (ex.InnerException, "#A3");
				Assert.IsNotNull (ex.Message, "#A4");
				Assert.AreEqual ("fieldName", ex.ParamName, "#A5");
			}

			FieldBuilder fb = tb.DefineField ("te\0st", typeof (int),
				FieldAttributes.Private);
			Assert.IsNotNull (fb, "#B1");
			Assert.AreEqual ("te\0st", fb.Name, "#B2");
		}

		[Test] // DefineField (String, Type, FieldAttributes)
		public void DefineField1_Type_Null ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());

			try {
				tb.DefineField ("test", (Type) null,
					FieldAttributes.Private);
				Assert.Fail ("#1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
				Assert.AreEqual ("type", ex.ParamName, "#5");
			}
		}

		[Test] // DefineField (String, Type, Type [], Type [], FieldAttributes)
		public void DefineField2_Type_Null ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());

			try {
				tb.DefineField ("test", (Type) null, Type.EmptyTypes,
					Type.EmptyTypes, FieldAttributes.Private);
				Assert.Fail ("#1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
				Assert.AreEqual ("type", ex.ParamName, "#5");
			}
		}

		[Test]
		public void TestDefineInitializedData ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());

			// Check invalid arguments
			try {
				tb.DefineInitializedData (null, new byte [1], 0);
				Assert.Fail ("#A1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
				Assert.IsNull (ex.InnerException, "#A3");
				Assert.IsNotNull (ex.Message, "#A4");
				Assert.AreEqual ("name", ex.ParamName, "#A5");
			}

			try {
				tb.DefineInitializedData ("FOO", null, 0);
				Assert.Fail ("#B1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
				Assert.IsNull (ex.InnerException, "#B3");
				Assert.IsNotNull (ex.Message, "#B4");
				Assert.AreEqual ("data", ex.ParamName, "#B5");
			}

			try {
				tb.DefineInitializedData (string.Empty, new byte [1], 0);
				Assert.Fail ("#C1");
			} catch (ArgumentException ex) {
				// Empty name is not legal
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
				Assert.IsNull (ex.InnerException, "#C3");
				Assert.IsNotNull (ex.Message, "#C4");
				Assert.AreEqual ("name", ex.ParamName, "#C5");
			}

			// The size of the data is less than or equal to zero ???
			try {
				tb.DefineInitializedData ("BAR", new byte [0], 0);
				Assert.Fail ("#D1");
			} catch (ArgumentException ex) {
				// Data size must be > 0 and < 0x3f0000
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
				Assert.IsNull (ex.InnerException, "#D3");
				Assert.IsNotNull (ex.Message, "#D4");
				Assert.IsNull (ex.ParamName, "#D5");
			}

			try {
				string name = String.Format ("{0}", (char) 0);
				tb.DefineInitializedData (name, new byte [1], 0);
				Assert.Fail ("#E1");
			} catch (ArgumentException ex) {
				// Illegal name
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#E2");
				Assert.IsNull (ex.InnerException, "#E3");
				Assert.IsNotNull (ex.Message, "#E4");
				Assert.AreEqual ("fieldName", ex.ParamName, "#E5");
			}

			tb.CreateType ();

			// Can not be called on a created type, altough the MSDN docs does not mention this
			try {
				tb.DefineInitializedData ("BAR2", new byte [1], 0);
				Assert.Fail ("#F1");
			} catch (InvalidOperationException ex) {
				// Unable to change after type has been created
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#F2");
				Assert.IsNull (ex.InnerException, "#F3");
				Assert.IsNotNull (ex.Message, "#F4");
			}
		}

		[Test]
		public void DefineUninitializedDataInvalidArgs ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());

			try {
				tb.DefineUninitializedData (null, 1, 0);
				Assert.Fail ("#A1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
				Assert.IsNull (ex.InnerException, "#A3");
				Assert.IsNotNull (ex.Message, "#A4");
				Assert.AreEqual ("name", ex.ParamName, "#A5");
			}

			try {
				tb.DefineUninitializedData (string.Empty, 1, 0);
				Assert.Fail ("#B1");
			} catch (ArgumentException ex) {
				// Empty name is not legal
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
				Assert.IsNull (ex.InnerException, "#B3");
				Assert.IsNotNull (ex.Message, "#B4");
				Assert.AreEqual ("name", ex.ParamName, "#B5");
			}

			// The size of the data is less than or equal to zero ???
			try {
				tb.DefineUninitializedData ("BAR", 0, 0);
				Assert.Fail ("#C1");
			} catch (ArgumentException ex) {
				// Data size must be > 0 and < 0x3f0000
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
				Assert.IsNull (ex.InnerException, "#C3");
				Assert.IsNotNull (ex.Message, "#C4");
				Assert.IsNull (ex.ParamName, "#C5");
			}

			try {
				string name = String.Format ("{0}", (char) 0);
				tb.DefineUninitializedData (name, 1, 0);
				Assert.Fail ("#D1");
			} catch (ArgumentException ex) {
				// Illegal name
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
				Assert.IsNull (ex.InnerException, "#D3");
				Assert.IsNotNull (ex.Message, "#D4");
				Assert.AreEqual ("fieldName", ex.ParamName, "#D5");
			}
		}

		[Test]
		public void DefineUninitializedDataAlreadyCreated ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.CreateType ();
			try {
				tb.DefineUninitializedData ("BAR2", 1, 0);
				Assert.Fail ("#1");
			} catch (InvalidOperationException ex) {
				// Unable to change after type has been created
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void DefineUninitializedData ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());

			tb.DefineUninitializedData ("foo", 4, FieldAttributes.Public);

			Type t = tb.CreateType ();

			object o = Activator.CreateInstance (t);

			FieldInfo fi = t.GetField ("foo");

			object fieldVal = fi.GetValue (o);

			IntPtr ptr = Marshal.AllocHGlobal (4);
			Marshal.StructureToPtr (fieldVal, ptr, true);
			Marshal.FreeHGlobal (ptr);
		}

		[Test]
		public void DefineMethod_Name_NullChar ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			try {
				tb.DefineMethod ("\0test", MethodAttributes.Private,
					typeof (string), Type.EmptyTypes);
				Assert.Fail ("#A1");
			} catch (ArgumentException ex) {
				// Illegal name
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
				Assert.IsNull (ex.InnerException, "#A3");
				Assert.IsNotNull (ex.Message, "#A4");
				Assert.AreEqual ("name", ex.ParamName, "#A5");
			}

			MethodBuilder mb = tb.DefineMethod ("te\0st", MethodAttributes.Private,
				typeof (string), Type.EmptyTypes);
			Assert.IsNotNull (mb, "#B1");
			Assert.AreEqual ("te\0st", mb.Name, "#B2");
		}

		[Test]
		public void TestDefineMethod ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());

			// Check invalid arguments
			try {
				tb.DefineMethod (null, 0, null, null);
				Assert.Fail ("#A1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
				Assert.IsNull (ex.InnerException, "#A3");
				Assert.IsNotNull (ex.Message, "#A4");
				Assert.AreEqual ("name", ex.ParamName, "#A5");
			}

			try {
				tb.DefineMethod (string.Empty, 0, null, null);
				Assert.Fail ("#B1");
			} catch (ArgumentException ex) {
				// Empty name is not legal
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
				Assert.IsNull (ex.InnerException, "#B3");
				Assert.IsNotNull (ex.Message, "#B4");
				Assert.AreEqual ("name", ex.ParamName, "#B5");
			}

			// Check non-virtual methods on an interface
			TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.Interface | TypeAttributes.Abstract);
			try {
				tb2.DefineMethod ("FOO", MethodAttributes.Abstract, null, null);
				Assert.Fail ("#C1");
			} catch (ArgumentException ex) {
				// Interface method must be abstract and virtual
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
				Assert.IsNull (ex.InnerException, "#C3");
				Assert.IsNotNull (ex.Message, "#C4");
				Assert.IsNull (ex.ParamName, "#C5");
			}

			// Check static methods on an interface
			tb2.DefineMethod ("BAR", MethodAttributes.Public | MethodAttributes.Static,
							  typeof (void),
							  Type.EmptyTypes);

			tb.CreateType ();
			// Can not be called on a created type
			try {
				tb.DefineMethod ("bar", 0, null, null);
				Assert.Fail ("#D1");
			} catch (InvalidOperationException ex) {
				// Unable to change after type has been created
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#D2");
				Assert.IsNull (ex.InnerException, "#D3");
				Assert.IsNotNull (ex.Message, "#D4");
			}
		}

		[Test] // bug #327484
		[Category ("NotWorking")]
		public void TestDefineMethod_Abstract ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.DefineMethod ("Run", MethodAttributes.Public |
				MethodAttributes.Abstract | MethodAttributes.Virtual,
				typeof (void), Type.EmptyTypes);

			try {
				tb.CreateType ();
				Assert.Fail ("#A1");
			} catch (InvalidOperationException ex) {
				// Type must be declared abstract if any of its
				// methods are abstract
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#A2");
				Assert.IsNull (ex.InnerException, "#A3");
				Assert.IsNotNull (ex.Message, "#A4");
			}

			tb = module.DefineType (genTypeName (), TypeAttributes.Abstract);
			tb.DefineMethod ("Run", MethodAttributes.Public |
				MethodAttributes.Abstract, typeof (void),
				Type.EmptyTypes);

			try {
				tb.CreateType ();
				Assert.Fail ("#B1");
			} catch (TypeLoadException ex) {
				// Non-virtual abstract method
				Assert.AreEqual (typeof (TypeLoadException), ex.GetType (), "#B2");
				Assert.IsNull (ex.InnerException, "#B3");
				Assert.IsNotNull (ex.Message, "#B4");
			}

			tb = module.DefineType (genTypeName (), TypeAttributes.Abstract |
				TypeAttributes.Public);
			tb.DefineMethod ("Run", MethodAttributes.Public |
				MethodAttributes.Abstract | MethodAttributes.Virtual,
				typeof (void), Type.EmptyTypes);
			Type emittedType = tb.CreateType ();

			MethodInfo mi1 = emittedType.GetMethod ("Run");
			Assert.IsNotNull (mi1, "#C1");
			Assert.IsTrue (mi1.IsAbstract, "#C2");

			MethodInfo mi2 = tb.GetMethod ("Run");
			Assert.IsNotNull (mi2, "#D1");
			Assert.IsTrue (mi2.IsAbstract, "#D2");
		}

		// TODO: DefineMethodOverride

		[Test]
		public void TestDefineNestedType ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());

			// Check invalid arguments
			try {
				tb.DefineNestedType (null);
				Assert.Fail ("#A1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
				Assert.IsNull (ex.InnerException, "#A3");
				Assert.IsNotNull (ex.Message, "#A4");
				Assert.AreEqual ("fullname", ex.ParamName, "#A5");
			}

			try {
				tb.DefineNestedType (string.Empty);
				Assert.Fail ("#B1");
			} catch (ArgumentException ex) {
				// Empty name is not legal
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
				Assert.IsNull (ex.InnerException, "#B3");
				Assert.IsNotNull (ex.Message, "#B4");
				Assert.AreEqual ("fullname", ex.ParamName, "#B5");
			}

			try {
				tb.DefineNestedType (nullName ());
				Assert.Fail ("#C1");
			} catch (ArgumentException ex) {
				// Illegal name
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
				Assert.IsNull (ex.InnerException, "#C3");
				Assert.IsNotNull (ex.Message, "#C4");
				Assert.AreEqual ("fullname", ex.ParamName, "#C5");
			}

			// If I fix the code so this works then mcs breaks -> how can mcs
			// works under MS .NET in the first place ???
			/*
			try {
				tb.DefineNestedType ("AA", TypeAttributes.Public, null, null);
				Fail ("Nested visibility must be specified.");
			}
			catch (ArgumentException) {
			}
			*/

			try {
				tb.DefineNestedType ("BB", TypeAttributes.NestedPublic, null,
									 new Type [1]);
				Assert.Fail ("#D1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#D2");
				Assert.IsNull (ex.InnerException, "#D3");
				Assert.IsNotNull (ex.Message, "#D4");
				Assert.AreEqual ("interfaces", ex.ParamName, "#D5");
			}

			// I think this should reject non-interfaces, but it does not
			tb.DefineNestedType ("BB", TypeAttributes.NestedPublic, null,
								 new Type [1] { typeof (object) });

			// Normal invocation
			tb.DefineNestedType ("Nest");

			tb.CreateType ();

			// According to the MSDN docs, this cannnot be called after the type
			// is created, but it works.
			tb.DefineNestedType ("Nest2");

			// According to the MSDN docs, a Sealed class can't contain nested 
			// types, but this is not true
			TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.Sealed);
			tb2.DefineNestedType ("AA");

			// According to the MSDN docs, interfaces can only contain interfaces,
			// but this is not true
			TypeBuilder tb3 = module.DefineType (genTypeName (), TypeAttributes.Interface | TypeAttributes.Abstract);

			tb3.DefineNestedType ("AA");

			// Check shorter versions
			{
				TypeBuilder nested = tb.DefineNestedType ("N1");

				Assert.AreEqual ("N1", nested.Name, "#E1");
				Assert.AreEqual (typeof (object), nested.BaseType, "#E2");
				Assert.AreEqual (TypeAttributes.NestedPrivate, nested.Attributes, "#E3");
				Assert.AreEqual (0, nested.GetInterfaces ().Length, "#E4");
			}

			// TODO:
		}

		[Test]
		public void DefinePInvokeMethod_Name_NullChar ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			try {
				tb.DefinePInvokeMethod ("\0test", "B", "C",
					MethodAttributes.Private, CallingConventions.Standard,
					typeof (string),Type.EmptyTypes, CallingConvention.Cdecl,
					CharSet.Unicode);
				Assert.Fail ("#A1");
			} catch (ArgumentException ex) {
				// Illegal name
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
				Assert.IsNull (ex.InnerException, "#A3");
				Assert.IsNotNull (ex.Message, "#A4");
				Assert.AreEqual ("name", ex.ParamName, "#A5");
			}

			MethodBuilder mb = tb.DefinePInvokeMethod ("te\0st", "B", "C",
				MethodAttributes.Private, CallingConventions.Standard,
				typeof (string), Type.EmptyTypes, CallingConvention.Cdecl,
				CharSet.Unicode);
			Assert.IsNotNull (mb, "#B1");
			Assert.AreEqual ("te\0st", mb.Name, "#B2");
		}

		[Test]
		public void TestDefinePInvokeMethod ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());

			tb.DefinePInvokeMethod ("A", "B", "C", 0, 0, null, null, 0, 0);

			// Try invalid parameters
			try {
				tb.DefinePInvokeMethod (null, "B", "C", 0, 0, null, null, 0, 0);
				Assert.Fail ("#A1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
				Assert.IsNull (ex.InnerException, "#A3");
				Assert.IsNotNull (ex.Message, "#A4");
				Assert.AreEqual ("name", ex.ParamName, "#A5");
			}
			// etc...

			// Try invalid attributes
			try {
				tb.DefinePInvokeMethod ("A2", "B", "C", MethodAttributes.Abstract, 0, null, null, 0, 0);
				Assert.Fail ("#B1");
			} catch (ArgumentException ex) {
				// PInvoke methods must be static and native and
				// cannot be abstract
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
				Assert.IsNull (ex.InnerException, "#B3");
				Assert.IsNotNull (ex.Message, "#B4");
				Assert.IsNull (ex.ParamName, "#B5");
			}

			// Try an interface parent
			TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.Interface | TypeAttributes.Abstract);

			try {
				tb2.DefinePInvokeMethod ("A", "B", "C", 0, 0, null, null, 0, 0);
				Assert.Fail ("#C1");
			} catch (ArgumentException ex) {
				// PInvoke methods cannot exist on interfaces
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
				Assert.IsNull (ex.InnerException, "#B3");
				Assert.IsNotNull (ex.Message, "#B4");
				Assert.IsNull (ex.ParamName, "#B5");
			}
		}

		[Test]
		public void DefineProperty_Name_NullChar ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());

			try {
				tb.DefineProperty ("\0test", 0, typeof (string), Type.EmptyTypes);
				Assert.Fail ("#A1");
			} catch (ArgumentException ex) {
				// Illegal name
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#A2");
				Assert.IsNull (ex.InnerException, "#A3");
				Assert.IsNotNull (ex.Message, "#A4");
				Assert.AreEqual ("name", ex.ParamName, "#A5");
			}

			PropertyBuilder pb = tb.DefineProperty ("te\0st", 0,
				typeof (string), Type.EmptyTypes); 
			Assert.IsNotNull (pb, "#B1");
			Assert.AreEqual ("te\0st", pb.Name, "#B2");
		}

		[Test]
		public void DefineProperty_ParameterTypes_ItemNull ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());

			try {
				tb.DefineProperty ("A", 0, typeof (string), new Type [1]);
				Assert.Fail ("#1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void DefineProperty_ReturnType_Null ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.DefineProperty ("A", 0, null, Type.EmptyTypes);
		}

		[Test]
		public void GetMethod_WorksWithTypeBuilderParameter () {
			TypeBuilder tb = module.DefineType (genTypeName ());
			var garg = tb.DefineGenericParameters ("T") [0];
			MethodBuilder mb = tb.DefineMethod ("create", MethodAttributes.Public, typeof (void), Type.EmptyTypes);
		
			var mi = TypeBuilder.GetMethod (tb, mb);
			var decl = mi.DeclaringType;

			Assert.IsTrue (decl.IsGenericType, "#1");
			Assert.IsFalse (decl.IsGenericTypeDefinition, "#2");
			Assert.AreEqual (tb, decl.GetGenericTypeDefinition (), "#3");
			Assert.AreEqual (garg, decl.GetGenericArguments () [0], "#4");
		}

		[Test]
		public void GetConstructor_FailWithTypeBuilderParameter () {
			TypeBuilder tb = module.DefineType (genTypeName ());
			var garg = tb.DefineGenericParameters ("T") [0];
			var cb = tb.DefineConstructor (MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes);

			try {
				TypeBuilder.GetConstructor (tb, cb);
				Assert.Fail ("#1");
			} catch (ArgumentException ex) {
				Assert.AreEqual ("type", ex.ParamName, "#2");
			}
		}

		[Test]
		public void GetField_FailWithTypeBuilderParameter () {
			TypeBuilder tb = module.DefineType (genTypeName ());
			var garg = tb.DefineGenericParameters ("T") [0];
			var fb = tb.DefineField ("TestField", typeof (int), FieldAttributes.Public);

			try {
				TypeBuilder.GetField (tb, fb);
				Assert.Fail ("#1");
			} catch (ArgumentException ex) {
				Assert.AreEqual ("type", ex.ParamName, "#2");
			}
		}

		[Test]
		public void GetMethod_RejectMethodFromInflatedTypeBuilder () {
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.DefineGenericParameters ("T");
			MethodBuilder mb = tb.DefineMethod ("create", MethodAttributes.Public, typeof (void), Type.EmptyTypes);

			Type ginst = tb.MakeGenericType (typeof (int));
			
			MethodInfo mi = TypeBuilder.GetMethod (ginst, mb);
			try {
				TypeBuilder.GetMethod (ginst, mi);
				Assert.Fail ("#1");
			} catch (ArgumentException ex) {
				Assert.AreEqual ("method", ex.ParamName, "#5");
			}
		}

		[Test]
		public void GetMethod_WorkWithInstancesOfCreatedTypeBuilder () {
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.DefineGenericParameters ("T");
			MethodBuilder mb = tb.DefineMethod ("create", MethodAttributes.Public, typeof (void), Type.EmptyTypes);
			ILGenerator ig = mb.GetILGenerator ();
			ig.Emit (OpCodes.Ret);
			
			tb.CreateType ();
			
			MethodInfo mi = TypeBuilder.GetMethod (tb.MakeGenericType (typeof (int)), mb);
			Assert.IsNotNull (mi);
		}

		[Test]
		[Category ("NotDotNet")]
		[Category ("NotWorking")]
		public void GetMethod_AcceptMethodFromInflatedTypeBuilder_UnderCompilerContext () {
			AssemblyName assemblyName = new AssemblyName ();
			assemblyName.Name = ASSEMBLY_NAME;

			assembly =
				Thread.GetDomain ().DefineDynamicAssembly (
					assemblyName, AssemblyBuilderAccess.RunAndSave | (AssemblyBuilderAccess)0x800, Path.GetTempPath ());

			module = assembly.DefineDynamicModule ("module1");
			
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.DefineGenericParameters ("T");
			MethodBuilder mb = tb.DefineMethod ("create", MethodAttributes.Public, typeof (void), Type.EmptyTypes);

			Type ginst = tb.MakeGenericType (typeof (int));
			
			MethodInfo mi = TypeBuilder.GetMethod (ginst, mb);

			try {
				TypeBuilder.GetMethod (ginst, mi);
			} catch (ArgumentException ex) {
				Assert.Fail ("#1");
			}
		}


		[Test]
		// Test that changes made to the method builder after a call to GetMethod ()
		// are visible
		public void TestGetMethod ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			GenericTypeParameterBuilder [] typeParams = tb.DefineGenericParameters ("T");

			ConstructorBuilder cb = tb.DefineConstructor (MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes);
			ILGenerator ig;
			ig = cb.GetILGenerator ();
			ig.Emit (OpCodes.Ret);

			Type fooOfT = tb.MakeGenericType (typeParams [0]);

			// Create a method builder but do not emit IL yet
			MethodBuilder mb1 = tb.DefineMethod ("create", MethodAttributes.Public|MethodAttributes.Static, fooOfT, Type.EmptyTypes);

			Type t = tb.MakeGenericType (typeof (int));

			MethodBuilder mb = tb.DefineMethod ("foo", MethodAttributes.Public|MethodAttributes.Static, t, Type.EmptyTypes);

			ig = mb.GetILGenerator ();
			ig.Emit (OpCodes.Call, TypeBuilder.GetMethod (t, mb1));
			ig.Emit (OpCodes.Ret);

			// Finish the method
			ig = mb1.GetILGenerator ();
			ig.Emit (OpCodes.Newobj, TypeBuilder.GetConstructor (fooOfT, cb));
			ig.Emit (OpCodes.Ret);

			Type t2 = tb.CreateType ();

			Assert.AreEqual (tb.Name + "[System.Int32]", t2.MakeGenericType (typeof (int)).GetMethod ("foo").Invoke (null, null).GetType ().ToString ());
		}

		[Test]
		public void TestGetConstructor ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			GenericTypeParameterBuilder [] typeParams = tb.DefineGenericParameters ("T");

			ConstructorBuilder cb = tb.DefineConstructor (MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes);
			ILGenerator ig;

			Type t = tb.MakeGenericType (typeof (int));

			MethodBuilder mb = tb.DefineMethod ("foo", MethodAttributes.Public|MethodAttributes.Static, t, Type.EmptyTypes);

			ig = mb.GetILGenerator ();

			ConstructorInfo ci = TypeBuilder.GetConstructor (t, cb);
			
			ig.Emit (OpCodes.Newobj, ci);
			ig.Emit (OpCodes.Ret);

			// Finish the ctorbuilder
			ig = cb.GetILGenerator ();
			ig.Emit(OpCodes.Ldarg_0);
			ig.Emit(OpCodes.Call, tb.BaseType.GetConstructor(Type.EmptyTypes));		
			ig.Emit (OpCodes.Ret);

			Type t2 = tb.CreateType ();

			Assert.AreEqual (tb.Name + "[System.Int32]", t2.MakeGenericType (typeof (int)).GetMethod ("foo").Invoke (null, null).GetType ().ToString ());
		}

		[Test]
		[ExpectedException (typeof (ArgumentException))]
		public void Static_GetConstructor_TypeNull ()
		{
			ConstructorInfo ci = typeof (object).GetConstructor (Type.EmptyTypes);
			// null is non-generic (from exception message)
			TypeBuilder.GetConstructor (null, ci);
		}

		[Test]
		[ExpectedException (typeof (ArgumentException))]
		public void Static_GetConstructor_TypeGeneric ()
		{
			Type t = typeof (List<>).MakeGenericType (typeof (int));
			ConstructorInfo ci = typeof (object).GetConstructor (Type.EmptyTypes);
			// type is not 'TypeBuilder' (from exception message)
			TypeBuilder.GetConstructor (t, ci);
		}

		[Test]
		public void Static_GetConstructor_TypeBuilderGeneric_ConstructorInfoNull ()
		{
			TypeBuilder tb = module.DefineType ("XXX");
			GenericTypeParameterBuilder [] typeParams = tb.DefineGenericParameters ("T");
			Type fooOfT = tb.MakeGenericType (typeParams [0]);
			try {
				TypeBuilder.GetConstructor (fooOfT, null);
				Assert.Fail ("Expected NullReferenceException");
			}
			catch (NullReferenceException) {
			}
		}

		[Test] //#536243
		public void CreateTypeThrowsForMethodsWithBadLabels ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());

			MethodBuilder mb = tb.DefineMethod("F", MethodAttributes.Public, typeof(string), null);
			ILGenerator il_gen = mb.GetILGenerator ();
			il_gen.DefineLabel ();
			il_gen.Emit (OpCodes.Leave, new Label ());
			try {
				tb.CreateType ();
				Assert.Fail ();
			} catch (ArgumentException) {}
		}

		[Test]
		[Category ("NotWorking")]
		public void TestIsDefinedIncomplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			try {
				tb.IsDefined (typeof (int), true);
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				// The invoked member is not supported in a
				// dynamic module
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void TestIsDefinedComplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());

			ConstructorInfo obsoleteCtor = typeof (ObsoleteAttribute).GetConstructor (
				new Type [] { typeof (string) });

			CustomAttributeBuilder caBuilder = new CustomAttributeBuilder (obsoleteCtor,
				new object [] { "obsolete message" }, new FieldInfo [0], new object [0]);

			tb.SetCustomAttribute (caBuilder);
			tb.CreateType ();
			Assert.IsTrue (tb.IsDefined (typeof (ObsoleteAttribute), false));
		}

		[Test]
		[Category ("NotDotNet")] // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=293659
		public void IsDefined_AttributeType_Null ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.CreateType ();

			try {
				tb.IsDefined ((Type) null, false);
				Assert.Fail ("#1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
				Assert.AreEqual ("attributeType", ex.ParamName, "#5");
			}
		}

		[Test] // GetConstructor (Type [])
		public void GetConstructor1_Incomplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			ConstructorBuilder cb = tb.DefineConstructor (
				MethodAttributes.Public,
				CallingConventions.Standard,
				Type.EmptyTypes);
			cb.GetILGenerator ().Emit (OpCodes.Ret);

			try {
				tb.GetConstructor (Type.EmptyTypes);
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				// The invoked member is not supported in a
				// dynamic module
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test] // GetConstructor (BindingFlags, Binder, Type [], ParameterModifier [])
		public void GetConstructor2_Complete ()
		{
			BindingFlags flags;
			ConstructorInfo ctor;

			TypeBuilder redType = module.DefineType (genTypeName (),
				TypeAttributes.Public);
			CreateMembers (redType, "Red", true);

			TypeBuilder greenType = module.DefineType (genTypeName (),
				TypeAttributes.Public, redType);
			CreateMembers (greenType, "Green", false);
			ConstructorBuilder cb = greenType.DefineConstructor (
				MethodAttributes.Public,
				CallingConventions.Standard,
				Type.EmptyTypes);
			cb.GetILGenerator ().Emit (OpCodes.Ret);

			redType.CreateType ();
			greenType.CreateType ();

			flags = BindingFlags.Instance | BindingFlags.NonPublic;

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#A1");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#A2");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#A3");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#A4");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#A5");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#A6");

			ctor = greenType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#A7");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#A8a");
			Assert.IsTrue (ctor.IsPrivate, "#A8b");
			Assert.IsFalse (ctor.IsStatic, "#A8c");
			Assert.AreEqual (2, ctor.GetParameters ().Length, "#A8d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#A8e");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#A9a");
			Assert.IsTrue (ctor.IsFamily, "#A9b");
			Assert.IsFalse (ctor.IsStatic, "#A9c");
			Assert.AreEqual (1, ctor.GetParameters ().Length, "#A9d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#A9e");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#A10a");
			Assert.IsTrue (ctor.IsFamilyAndAssembly, "#A10b");
			Assert.IsFalse (ctor.IsStatic, "#A10c");
			Assert.AreEqual (2, ctor.GetParameters ().Length, "#A10d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#A10e");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#A11a");
			Assert.IsTrue (ctor.IsFamilyOrAssembly, "#A11b");
			Assert.IsFalse (ctor.IsStatic, "#A11c");
			Assert.AreEqual (1, ctor.GetParameters ().Length, "#A11d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#A11e");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#A12");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#A13a");
			Assert.IsTrue (ctor.IsAssembly, "#A13b");
			Assert.IsFalse (ctor.IsStatic, "#A13c");
			Assert.AreEqual (2, ctor.GetParameters ().Length, "#A13d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#A13e");

			ctor = redType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#A14");

			flags = BindingFlags.Instance | BindingFlags.Public;

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#B1");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#B2");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#B3");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#B4");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#B5");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#B6");

			ctor = greenType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#B7a");
			Assert.IsTrue (ctor.IsPublic, "#B7b");
			Assert.IsFalse (ctor.IsStatic, "#B7c");
			Assert.AreEqual (0, ctor.GetParameters ().Length, "#B7d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#B7e");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#B8");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#B9");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#B10");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#B11");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#B12a");
			Assert.IsTrue (ctor.IsPublic, "#B12b");
			Assert.IsFalse (ctor.IsStatic, "#B12c");
			Assert.AreEqual (2, ctor.GetParameters ().Length, "#B12d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#B12e");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#B13");

			ctor = redType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#B14");

			flags = BindingFlags.Static | BindingFlags.Public;

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#C1");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#C2");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#C3");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#C4");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#C5");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#C6");

			ctor = greenType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#C7");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#C8");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#C9");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#C10");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#C11a");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#C12");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#C13");

			ctor = redType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#C14");

			flags = BindingFlags.Static | BindingFlags.NonPublic;

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#D1");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#D2");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#D3");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#D4");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#D5");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#D6");

			ctor = greenType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#D7");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#D8");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#D9");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#D10");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#D11");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#D12");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#D13");

			ctor = redType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#D14a");
			Assert.IsTrue (ctor.IsPrivate, "#D14b");
			Assert.IsTrue (ctor.IsStatic, "#B14c");
			Assert.AreEqual (0, ctor.GetParameters ().Length, "#B14d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#B14e");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.FlattenHierarchy;

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#E1");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#E2");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#E3");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#E4");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#E5");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#E6");

			ctor = greenType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#E7");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#E8a");
			Assert.IsTrue (ctor.IsPrivate, "#E8b");
			Assert.IsFalse (ctor.IsStatic, "#E8c");
			Assert.AreEqual (2, ctor.GetParameters ().Length, "#E8d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#E8e");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#E9a");
			Assert.IsTrue (ctor.IsFamily, "#E9b");
			Assert.IsFalse (ctor.IsStatic, "#E9c");
			Assert.AreEqual (1, ctor.GetParameters ().Length, "#E9d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#E9e");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#E10a");
			Assert.IsTrue (ctor.IsFamilyAndAssembly, "#E10b");
			Assert.IsFalse (ctor.IsStatic, "#E10c");
			Assert.AreEqual (2, ctor.GetParameters ().Length, "#E10d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#E10e");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#E11a");
			Assert.IsTrue (ctor.IsFamilyOrAssembly, "#E11b");
			Assert.IsFalse (ctor.IsStatic, "#E11c");
			Assert.AreEqual (1, ctor.GetParameters ().Length, "#E11d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#E11e");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#E12");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#E13a");
			Assert.IsTrue (ctor.IsAssembly, "#E13b");
			Assert.IsFalse (ctor.IsStatic, "#E13c");
			Assert.AreEqual (2, ctor.GetParameters ().Length, "#E13d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#E13e");

			ctor = redType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#E14");

			flags = BindingFlags.Instance | BindingFlags.Public |
				BindingFlags.FlattenHierarchy;

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#F1");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#F2");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#F3");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#F4");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#F5");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#F6");

			ctor = greenType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#F7a");
			Assert.IsTrue (ctor.IsPublic, "#F7b");
			Assert.IsFalse (ctor.IsStatic, "#F7c");
			Assert.AreEqual (0, ctor.GetParameters ().Length, "#F7d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#F7e");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#F8");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#F9");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#F10");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#F11");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#F12a");
			Assert.IsTrue (ctor.IsPublic, "#F12b");
			Assert.IsFalse (ctor.IsStatic, "#F12c");
			Assert.AreEqual (2, ctor.GetParameters ().Length, "#F12d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#F12e");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#F13");

			ctor = redType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#F14");

			flags = BindingFlags.Static | BindingFlags.Public |
				BindingFlags.FlattenHierarchy;

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#G1");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#G2");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#G3");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#G4");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#G5");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#G6");

			ctor = greenType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#G7");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#G8");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#G9");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#G10");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#G11");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#G12");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#G13");

			ctor = redType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#G14");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.FlattenHierarchy;

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#H1");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#H2");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#H3");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#H4");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#H5");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#H6");

			ctor = greenType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#H7");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#H8");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#H9");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#H10");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#H11");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#H12");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#H13");

			ctor = redType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#H14");
			Assert.IsTrue (ctor.IsPrivate, "#H14b");
			Assert.IsTrue (ctor.IsStatic, "#H14c");
			Assert.AreEqual (0, ctor.GetParameters ().Length, "#H14d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#H14e");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.DeclaredOnly;

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#I1");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#I2");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#I3");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#I4");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#I5");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#I6");

			ctor = greenType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#I7");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#I8a");
			Assert.IsTrue (ctor.IsPrivate, "#I8b");
			Assert.IsFalse (ctor.IsStatic, "#I8c");
			Assert.AreEqual (2, ctor.GetParameters ().Length, "#I8d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#I8e");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#I9a");
			Assert.IsTrue (ctor.IsFamily, "#I9b");
			Assert.IsFalse (ctor.IsStatic, "#I9c");
			Assert.AreEqual (1, ctor.GetParameters ().Length, "#I9d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#I9e");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#I10a");
			Assert.IsTrue (ctor.IsFamilyAndAssembly, "#I10b");
			Assert.IsFalse (ctor.IsStatic, "#I10c");
			Assert.AreEqual (2, ctor.GetParameters ().Length, "#I10d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#I10e");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#I11a");
			Assert.IsTrue (ctor.IsFamilyOrAssembly, "#I11b");
			Assert.IsFalse (ctor.IsStatic, "#I11c");
			Assert.AreEqual (1, ctor.GetParameters ().Length, "#I11d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#I11e");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#I12");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#I13a");
			Assert.IsTrue (ctor.IsAssembly, "#I13b");
			Assert.IsFalse (ctor.IsStatic, "#I13c");
			Assert.AreEqual (2, ctor.GetParameters ().Length, "#I13d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#I13e");

			ctor = redType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#I14");

			flags = BindingFlags.Instance | BindingFlags.Public |
				BindingFlags.DeclaredOnly;

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#J1");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#J2");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#J3");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#J4");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#J5");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#J6");

			ctor = greenType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#J7a");
			Assert.IsTrue (ctor.IsPublic, "#J7b");
			Assert.IsFalse (ctor.IsStatic, "#J7c");
			Assert.AreEqual (0, ctor.GetParameters ().Length, "#J7d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#J7e");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#J8");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#J9");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#J10");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#J11");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#J12a");
			Assert.IsTrue (ctor.IsPublic, "#J12b");
			Assert.IsFalse (ctor.IsStatic, "#J12c");
			Assert.AreEqual (2, ctor.GetParameters ().Length, "#J12d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#J12e");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#J13");

			ctor = redType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#J14");

			flags = BindingFlags.Static | BindingFlags.Public |
				BindingFlags.DeclaredOnly;

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#K1");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#K2");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#K3");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#K4");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#K5");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#K6");

			ctor = greenType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#K7");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#K8");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#K9");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#K10");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#K11");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#K12");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#K13");

			ctor = redType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#K14");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.DeclaredOnly;

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#L1");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#L2");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#L3");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#L4");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#L5");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#L6");

			ctor = greenType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#L7");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#L8");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#L9");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#L10");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#L11");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#L12");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#L13");

			ctor = redType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#L14a");
			Assert.IsTrue (ctor.IsPrivate, "#L14b");
			Assert.IsTrue (ctor.IsStatic, "#L14c");
			Assert.AreEqual (0, ctor.GetParameters ().Length, "#L14d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#L14e");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.Public;

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#M1");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#M2");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#M3");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#M4");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#M5");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#M6");

			ctor = greenType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#M7a");
			Assert.IsTrue (ctor.IsPublic, "#M7b");
			Assert.IsFalse (ctor.IsStatic, "#M7c");
			Assert.AreEqual (0, ctor.GetParameters ().Length, "#M7d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#M7e");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#M8a");
			Assert.IsTrue (ctor.IsPrivate, "#M8b");
			Assert.IsFalse (ctor.IsStatic, "#M8c");
			Assert.AreEqual (2, ctor.GetParameters ().Length, "#M8d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#M8e");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#M9a");
			Assert.IsTrue (ctor.IsFamily, "#M9b");
			Assert.IsFalse (ctor.IsStatic, "#M9c");
			Assert.AreEqual (1, ctor.GetParameters ().Length, "#M9d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#M9e");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#M10a");
			Assert.IsTrue (ctor.IsFamilyAndAssembly, "#M10b");
			Assert.IsFalse (ctor.IsStatic, "#M10c");
			Assert.AreEqual (2, ctor.GetParameters ().Length, "#M10d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#M10e");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#M11a");
			Assert.IsTrue (ctor.IsFamilyOrAssembly, "#M11b");
			Assert.IsFalse (ctor.IsStatic, "#M11c");
			Assert.AreEqual (1, ctor.GetParameters ().Length, "#M11d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#M11e");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#M12a");
			Assert.IsTrue (ctor.IsPublic, "#M12b");
			Assert.IsFalse (ctor.IsStatic, "#M12c");
			Assert.AreEqual (2, ctor.GetParameters ().Length, "#M12d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#M12e");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#M13a");
			Assert.IsTrue (ctor.IsAssembly, "#M13b");
			Assert.IsFalse (ctor.IsStatic, "#M13c");
			Assert.AreEqual (2, ctor.GetParameters ().Length, "#M13d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#M13e");

			ctor = redType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#M14");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.Public;

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#N1");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#N2");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#N3");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#N4");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#N5");

			ctor = greenType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#N6");

			ctor = greenType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#N7");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#N8");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#N9");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (string) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#N10");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#N11");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (int), typeof (bool) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#N12");

			ctor = redType.GetConstructor (flags, null,
				new Type [] { typeof (string), typeof (int) },
				new ParameterModifier [0]);
			Assert.IsNull (ctor, "#N13");

			ctor = redType.GetConstructor (flags, null,
				Type.EmptyTypes,
				new ParameterModifier [0]);
			Assert.IsNotNull (ctor, "#N14a");
			Assert.IsTrue (ctor.IsPrivate, "#N14b");
			Assert.IsTrue (ctor.IsStatic, "#N14c");
			Assert.AreEqual (0, ctor.GetParameters ().Length, "#N14d");
			Assert.IsFalse (ctor is ConstructorBuilder, "#N14e");
		}

		[Test] // GetConstructor (BindingFlags, Binder, Type [], ParameterModifier [])
		public void GetConstructor2_Incomplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			ConstructorBuilder cb = tb.DefineConstructor (
				MethodAttributes.Public,
				CallingConventions.Standard,
				Type.EmptyTypes);
			cb.GetILGenerator ().Emit (OpCodes.Ret);

			try {
				tb.GetConstructor (BindingFlags.Public | BindingFlags.Instance,
					null, Type.EmptyTypes, new ParameterModifier [0]);
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test] // GetConstructor (BindingFlags, Binder, CallingConventions, Type [], ParameterModifier [])
		public void GetConstructor3_Incomplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			ConstructorBuilder cb = tb.DefineConstructor (
				MethodAttributes.Public,
				CallingConventions.Standard,
				Type.EmptyTypes);
			cb.GetILGenerator ().Emit (OpCodes.Ret);

			try {
				tb.GetConstructor (BindingFlags.Public | BindingFlags.Instance,
					null, CallingConventions.Standard, Type.EmptyTypes,
					new ParameterModifier [0]);
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				// The invoked member is not supported in a
				// dynamic module
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test] // GetConstructors ()
		[Category ("NotWorking")] // mcs depends on this
		public void GetConstructors1_Incomplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			ConstructorBuilder cb = tb.DefineConstructor (
				MethodAttributes.Public,
				CallingConventions.Standard,
				Type.EmptyTypes);
			cb.GetILGenerator ().Emit (OpCodes.Ret);

			try {
				tb.GetConstructors ();
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				// The invoked member is not supported in a
				// dynamic module
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test] // GetConstructors (BindingFlags)
		public void GetConstructors2_Complete ()
		{
			BindingFlags flags;
			ConstructorInfo [] ctors;

			TypeBuilder redType = module.DefineType (genTypeName (),
				TypeAttributes.Public);
			CreateMembers (redType, "Red", true);

			TypeBuilder greenType = module.DefineType (genTypeName (),
				TypeAttributes.Public, redType);
			CreateMembers (greenType, "Green", false);
			ConstructorBuilder cb = greenType.DefineConstructor (
				MethodAttributes.Public,
				CallingConventions.Standard,
				Type.EmptyTypes);
			cb.GetILGenerator ().Emit (OpCodes.Ret);

			redType.CreateType ();
			greenType.CreateType ();

			flags = BindingFlags.Instance | BindingFlags.NonPublic;

			ctors = greenType.GetConstructors (flags);
			Assert.AreEqual (0, ctors.Length, "#A1");

			ctors = redType.GetConstructors (flags);
			Assert.AreEqual (5, ctors.Length, "#A2");
			Assert.IsTrue (ctors [0].IsPrivate, "#A3a");
			Assert.IsFalse (ctors [0].IsStatic, "#A3b");
			Assert.AreEqual (2, ctors [0].GetParameters ().Length, "#A3c");
			Assert.IsFalse (ctors [0] is ConstructorBuilder, "#A3d");
			Assert.IsTrue (ctors [1].IsFamily, "#A4a");
			Assert.IsFalse (ctors [1].IsStatic, "#A4b");
			Assert.AreEqual (1, ctors [1].GetParameters ().Length, "#A4c");
			Assert.IsFalse (ctors [1] is ConstructorBuilder, "#A4d");
			Assert.IsTrue (ctors [2].IsFamilyAndAssembly, "#A5a");
			Assert.IsFalse (ctors [2].IsStatic, "#A5b");
			Assert.AreEqual (2, ctors [2].GetParameters ().Length, "#A5c");
			Assert.IsFalse (ctors [2] is ConstructorBuilder, "#A5d");
			Assert.IsTrue (ctors [3].IsFamilyOrAssembly, "#A6a");
			Assert.IsFalse (ctors [3].IsStatic, "#A6b");
			Assert.AreEqual (1, ctors [3].GetParameters ().Length, "#A6c");
			Assert.IsFalse (ctors [3] is ConstructorBuilder, "#A6d");
			Assert.IsTrue (ctors [4].IsAssembly, "#A7a");
			Assert.IsFalse (ctors [4].IsStatic, "#A7b");
			Assert.AreEqual (2, ctors [4].GetParameters ().Length, "#A7c");
			Assert.IsFalse (ctors [4] is ConstructorBuilder, "#A7d");

			flags = BindingFlags.Instance | BindingFlags.Public;

			ctors = greenType.GetConstructors (flags);
			Assert.AreEqual (1, ctors.Length, "#B1");
			Assert.IsTrue (ctors [0].IsPublic, "#B2a");
			Assert.IsFalse (ctors [0].IsStatic, "#B2b");
			Assert.AreEqual (0, ctors [0].GetParameters ().Length, "#B2c");
			Assert.IsFalse (ctors [0] is ConstructorBuilder, "#B2d");

			ctors = redType.GetConstructors (flags);
			Assert.AreEqual (1, ctors.Length, "#B3");
			Assert.IsTrue (ctors [0].IsPublic, "#B4a");
			Assert.IsFalse (ctors [0].IsStatic, "#B4b");
			Assert.AreEqual (2, ctors [0].GetParameters ().Length, "#B4c");
			Assert.IsFalse (ctors [0] is ConstructorBuilder, "#B4d");

			flags = BindingFlags.Static | BindingFlags.Public;

			ctors = greenType.GetConstructors (flags);
			Assert.AreEqual (0, ctors.Length, "#C1");

			ctors = redType.GetConstructors (flags);
			Assert.AreEqual (0, ctors.Length, "#C2");

			flags = BindingFlags.Static | BindingFlags.NonPublic;

			ctors = greenType.GetConstructors (flags);
			Assert.AreEqual (0, ctors.Length, "#D1");

			ctors = redType.GetConstructors (flags);
			Assert.AreEqual (1, ctors.Length, "#D2");
			Assert.IsTrue (ctors [0].IsPrivate, "#D3a");
			Assert.IsTrue (ctors [0].IsStatic, "#D3b");
			Assert.AreEqual (0, ctors [0].GetParameters ().Length, "#D3c");
			Assert.IsFalse (ctors [0] is ConstructorBuilder, "#D3d");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.FlattenHierarchy;

			ctors = greenType.GetConstructors (flags);
			Assert.AreEqual (0, ctors.Length, "#E1");

			ctors = redType.GetConstructors (flags);
			Assert.AreEqual (5, ctors.Length, "#E2");
			Assert.IsTrue (ctors [0].IsPrivate, "#E3a");
			Assert.IsFalse (ctors [0].IsStatic, "#E3b");
			Assert.AreEqual (2, ctors [0].GetParameters ().Length, "#E3c");
			Assert.IsFalse (ctors [0] is ConstructorBuilder, "#E3d");
			Assert.IsTrue (ctors [1].IsFamily, "#E4a");
			Assert.IsFalse (ctors [1].IsStatic, "#E4b");
			Assert.AreEqual (1, ctors [1].GetParameters ().Length, "#E4c");
			Assert.IsFalse (ctors [1] is ConstructorBuilder, "#E4d");
			Assert.IsTrue (ctors [2].IsFamilyAndAssembly, "#E5a");
			Assert.IsFalse (ctors [2].IsStatic, "#A5b");
			Assert.AreEqual (2, ctors [2].GetParameters ().Length, "#E5c");
			Assert.IsFalse (ctors [2] is ConstructorBuilder, "#E5d");
			Assert.IsTrue (ctors [3].IsFamilyOrAssembly, "#E6a");
			Assert.IsFalse (ctors [3].IsStatic, "#E6b");
			Assert.AreEqual (1, ctors [3].GetParameters ().Length, "#E6c");
			Assert.IsFalse (ctors [3] is ConstructorBuilder, "#E6d");
			Assert.IsTrue (ctors [4].IsAssembly, "#E7a");
			Assert.IsFalse (ctors [4].IsStatic, "#E7b");
			Assert.AreEqual (2, ctors [4].GetParameters ().Length, "#E7c");
			Assert.IsFalse (ctors [4] is ConstructorBuilder, "#E7d");

			flags = BindingFlags.Instance | BindingFlags.Public |
				BindingFlags.FlattenHierarchy;

			ctors = greenType.GetConstructors (flags);
			Assert.AreEqual (1, ctors.Length, "#F1");
			Assert.IsTrue (ctors [0].IsPublic, "#F2a");
			Assert.IsFalse (ctors [0].IsStatic, "#F2b");
			Assert.AreEqual (0, ctors [0].GetParameters ().Length, "#F2c");
			Assert.IsFalse (ctors [0] is ConstructorBuilder, "#F2d");

			ctors = redType.GetConstructors (flags);
			Assert.AreEqual (1, ctors.Length, "#F3");
			Assert.IsTrue (ctors [0].IsPublic, "#F4a");
			Assert.IsFalse (ctors [0].IsStatic, "#F4b");
			Assert.AreEqual (2, ctors [0].GetParameters ().Length, "#F4c");
			Assert.IsFalse (ctors [0] is ConstructorBuilder, "#F4d");

			flags = BindingFlags.Static | BindingFlags.Public |
				BindingFlags.FlattenHierarchy;

			ctors = greenType.GetConstructors (flags);
			Assert.AreEqual (0, ctors.Length, "#G1");

			ctors = redType.GetConstructors (flags);
			Assert.AreEqual (0, ctors.Length, "#G2");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.FlattenHierarchy;

			ctors = greenType.GetConstructors (flags);
			Assert.AreEqual (0, ctors.Length, "#H1");

			ctors = redType.GetConstructors (flags);
			Assert.AreEqual (1, ctors.Length, "#H2");
			Assert.IsTrue (ctors [0].IsPrivate, "#H3a");
			Assert.IsTrue (ctors [0].IsStatic, "#H3b");
			Assert.AreEqual (0, ctors [0].GetParameters ().Length, "#H3c");
			Assert.IsFalse (ctors [0] is ConstructorBuilder, "#H3d");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.DeclaredOnly;

			ctors = greenType.GetConstructors (flags);
			Assert.AreEqual (0, ctors.Length, "#I1");

			ctors = redType.GetConstructors (flags);
			Assert.AreEqual (5, ctors.Length, "#I2");
			Assert.IsTrue (ctors [0].IsPrivate, "#I3a");
			Assert.IsFalse (ctors [0].IsStatic, "#I3b");
			Assert.AreEqual (2, ctors [0].GetParameters ().Length, "#I3c");
			Assert.IsFalse (ctors [0] is ConstructorBuilder, "#I3d");
			Assert.IsTrue (ctors [1].IsFamily, "#I4a");
			Assert.IsFalse (ctors [1].IsStatic, "#I4b");
			Assert.AreEqual (1, ctors [1].GetParameters ().Length, "#I4c");
			Assert.IsFalse (ctors [1] is ConstructorBuilder, "#I4d");
			Assert.IsTrue (ctors [2].IsFamilyAndAssembly, "#I5a");
			Assert.IsFalse (ctors [2].IsStatic, "#I5b");
			Assert.AreEqual (2, ctors [2].GetParameters ().Length, "#I5c");
			Assert.IsFalse (ctors [2] is ConstructorBuilder, "#I5d");
			Assert.IsTrue (ctors [3].IsFamilyOrAssembly, "#I6a");
			Assert.IsFalse (ctors [3].IsStatic, "#I6b");
			Assert.AreEqual (1, ctors [3].GetParameters ().Length, "#I6c");
			Assert.IsFalse (ctors [3] is ConstructorBuilder, "#I6d");
			Assert.IsTrue (ctors [4].IsAssembly, "#I7a");
			Assert.IsFalse (ctors [4].IsStatic, "#I7b");
			Assert.AreEqual (2, ctors [4].GetParameters ().Length, "#I7c");
			Assert.IsFalse (ctors [4] is ConstructorBuilder, "#I7d");

			flags = BindingFlags.Instance | BindingFlags.Public |
				BindingFlags.DeclaredOnly;

			ctors = greenType.GetConstructors (flags);
			Assert.AreEqual (1, ctors.Length, "#J1");
			Assert.IsTrue (ctors [0].IsPublic, "#J2a");
			Assert.IsFalse (ctors [0].IsStatic, "#J2b");
			Assert.AreEqual (0, ctors [0].GetParameters ().Length, "#J2c");
			Assert.IsFalse (ctors [0] is ConstructorBuilder, "#J2d");

			ctors = redType.GetConstructors (flags);
			Assert.AreEqual (1, ctors.Length, "#J3");
			Assert.IsTrue (ctors [0].IsPublic, "#J4a");
			Assert.IsFalse (ctors [0].IsStatic, "#J4b");
			Assert.AreEqual (2, ctors [0].GetParameters ().Length, "#J4c");
			Assert.IsFalse (ctors [0] is ConstructorBuilder, "#J4d");

			flags = BindingFlags.Static | BindingFlags.Public |
				BindingFlags.DeclaredOnly;

			ctors = greenType.GetConstructors (flags);
			Assert.AreEqual (0, ctors.Length, "#K1");

			ctors = redType.GetConstructors (flags);
			Assert.AreEqual (0, ctors.Length, "#K2");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.DeclaredOnly;

			ctors = greenType.GetConstructors (flags);
			Assert.AreEqual (0, ctors.Length, "#L1");

			ctors = redType.GetConstructors (flags);
			Assert.AreEqual (1, ctors.Length, "#L2");
			Assert.IsTrue (ctors [0].IsPrivate, "#L3a");
			Assert.IsTrue (ctors [0].IsStatic, "#L3b");
			Assert.AreEqual (0, ctors [0].GetParameters ().Length, "#L3c");
			Assert.IsFalse (ctors [0] is ConstructorBuilder, "#L3d");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.Public;

			ctors = greenType.GetConstructors (flags);
			Assert.AreEqual (1, ctors.Length, "#M1");
			Assert.IsTrue (ctors [0].IsPublic, "#M2a");
			Assert.IsFalse (ctors [0].IsStatic, "#M2b");
			Assert.AreEqual (0, ctors [0].GetParameters ().Length, "#M2c");
			Assert.IsFalse (ctors [0] is ConstructorBuilder, "#M2d");

			ctors = redType.GetConstructors (flags);
			Assert.AreEqual (6, ctors.Length, "#M3");
			Assert.IsTrue (ctors [0].IsPrivate, "#M4a");
			Assert.IsFalse (ctors [0].IsStatic, "#M4b");
			Assert.AreEqual (2, ctors [0].GetParameters ().Length, "#M4c");
			Assert.IsFalse (ctors [0] is ConstructorBuilder, "#M4d");
			Assert.IsTrue (ctors [1].IsFamily, "#M5a");
			Assert.IsFalse (ctors [1].IsStatic, "#M5b");
			Assert.AreEqual (1, ctors [1].GetParameters ().Length, "#M5c");
			Assert.IsFalse (ctors [1] is ConstructorBuilder, "#M5d");
			Assert.IsTrue (ctors [2].IsFamilyAndAssembly, "#M6a");
			Assert.IsFalse (ctors [2].IsStatic, "#M6b");
			Assert.AreEqual (2, ctors [2].GetParameters ().Length, "#M6c");
			Assert.IsFalse (ctors [2] is ConstructorBuilder, "#M6d");
			Assert.IsTrue (ctors [3].IsFamilyOrAssembly, "#M7a");
			Assert.IsFalse (ctors [3].IsStatic, "#M7b");
			Assert.AreEqual (1, ctors [3].GetParameters ().Length, "#M7c");
			Assert.IsFalse (ctors [3] is ConstructorBuilder, "#M7d");
			Assert.IsTrue (ctors [4].IsPublic, "#M8a");
			Assert.IsFalse (ctors [4].IsStatic, "#M8b");
			Assert.AreEqual (2, ctors [4].GetParameters ().Length, "#M8c");
			Assert.IsFalse (ctors [4] is ConstructorBuilder, "#M8d");
			Assert.IsTrue (ctors [5].IsAssembly, "#M9a");
			Assert.IsFalse (ctors [5].IsStatic, "#M9b");
			Assert.AreEqual (2, ctors [5].GetParameters ().Length, "#M9c");
			Assert.IsFalse (ctors [5] is ConstructorBuilder, "#M9d");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.Public;

			ctors = greenType.GetConstructors (flags);
			Assert.AreEqual (0, ctors.Length, "#N1");

			ctors = redType.GetConstructors (flags);
			Assert.AreEqual (1, ctors.Length, "#N2");
			Assert.IsTrue (ctors [0].IsPrivate, "#N3a");
			Assert.IsTrue (ctors [0].IsStatic, "#N3b");
			Assert.AreEqual (0, ctors [0].GetParameters ().Length, "#N3c");
			Assert.IsFalse (ctors [0] is ConstructorBuilder, "#N3d");
		}

		[Test] // GetConstructors (BindingFlags)
		[Category ("NotWorking")] // mcs depends on this
		public void GetConstructors2_Incomplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			ConstructorBuilder cb = tb.DefineConstructor (
				MethodAttributes.Public,
				CallingConventions.Standard,
				Type.EmptyTypes);
			cb.GetILGenerator ().Emit (OpCodes.Ret);

			try {
				tb.GetConstructors (BindingFlags.Public |
					BindingFlags.Instance);
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				// The invoked member is not supported in a
				// dynamic module
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void TestGetCustomAttributesIncomplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			try {
				tb.GetCustomAttributes (false);
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				// The invoked member is not supported in a
				// dynamic module
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void TestGetCustomAttributesComplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());

			ConstructorInfo guidCtor = typeof (GuidAttribute).GetConstructor (
				new Type [] { typeof (string) });

			CustomAttributeBuilder caBuilder = new CustomAttributeBuilder (guidCtor,
				new object [] { Guid.NewGuid ().ToString ("D") }, new FieldInfo [0], new object [0]);

			tb.SetCustomAttribute (caBuilder);
			tb.CreateType ();

			Assert.AreEqual (1, tb.GetCustomAttributes (false).Length);
		}

		[Test]
		public void TestGetCustomAttributesOfTypeIncomplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			try {
				tb.GetCustomAttributes (typeof (ObsoleteAttribute), false);
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				// The invoked member is not supported in a
				// dynamic module
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void TestGetCustomAttributesOfTypeComplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());

			ConstructorInfo guidCtor = typeof (GuidAttribute).GetConstructor (
				new Type [] { typeof (string) });

			CustomAttributeBuilder caBuilder = new CustomAttributeBuilder (guidCtor,
				new object [] { Guid.NewGuid ().ToString ("D") }, new FieldInfo [0], new object [0]);

			tb.SetCustomAttribute (caBuilder);
			tb.CreateType ();

			Assert.AreEqual (1, tb.GetCustomAttributes (typeof (GuidAttribute), false).Length, "#1");
			Assert.AreEqual (0, tb.GetCustomAttributes (typeof (ObsoleteAttribute), false).Length, "#2");
		}

		[Test]
		public void TestGetCustomAttributesOfNullTypeComplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.CreateType ();
			try {
				tb.GetCustomAttributes (null, false);
				Assert.Fail ("#1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
				Assert.AreEqual ("attributeType", ex.ParamName, "#5");
			}
		}

		[Test]
		[Ignore ("mcs depends on this")]
		public void TestGetEventsIncomplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			try {
				tb.GetEvents ();
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
				throw;
			}
		}

		[Test]
		public void TestGetEventsComplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());

			MethodBuilder onclickMethod = tb.DefineMethod ("OnChange", MethodAttributes.Public,
				typeof (void), new Type [] { typeof (Object) });
			onclickMethod.GetILGenerator ().Emit (OpCodes.Ret);

			// create public event
			EventBuilder eventbuilder = tb.DefineEvent ("Change", EventAttributes.None,
				typeof (ResolveEventHandler));
			eventbuilder.SetRaiseMethod (onclickMethod);

			Type emittedType = tb.CreateType ();

			Assert.AreEqual (1, tb.GetEvents ().Length, "#1");
			Assert.AreEqual (tb.GetEvents ().Length, emittedType.GetEvents ().Length, "#2");
		}


		[Test]
		[Ignore ("mcs depends on this")]
		public void TestGetEventsFlagsIncomplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			try {
				tb.GetEvents (BindingFlags.Public);
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
				throw;
			}
		}

		[Test]
		public void TestGetEventsFlagsComplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());

			MethodBuilder onchangeMethod = tb.DefineMethod ("OnChange", MethodAttributes.Public,
				typeof (void), new Type [] { typeof (Object) });
			onchangeMethod.GetILGenerator ().Emit (OpCodes.Ret);

			// create public event
			EventBuilder changeEvent = tb.DefineEvent ("Change", EventAttributes.None,
				typeof (ResolveEventHandler));
			changeEvent.SetRaiseMethod (onchangeMethod);

			// create non-public event
			EventBuilder redoChangeEvent = tb.DefineEvent ("RedoChange", EventAttributes.None,
				typeof (ResolveEventHandler));

			Type emittedType = tb.CreateType ();

			Assert.AreEqual (1, tb.GetEvents (BindingFlags.Instance | BindingFlags.Public).Length);
			Assert.AreEqual (1, tb.GetEvents (BindingFlags.Instance | BindingFlags.NonPublic).Length);
			Assert.AreEqual (2, tb.GetEvents (BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Length);
			Assert.AreEqual (tb.GetEvents (BindingFlags.Instance | BindingFlags.Public).Length,
				emittedType.GetEvents (BindingFlags.Instance | BindingFlags.Public).Length);
			Assert.AreEqual (tb.GetEvents (BindingFlags.Instance | BindingFlags.NonPublic).Length,
				emittedType.GetEvents (BindingFlags.Instance | BindingFlags.NonPublic).Length);
			Assert.AreEqual (tb.GetEvents (BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Length,
				emittedType.GetEvents (BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Length);
		}

		[Test]
		public void TestGetEventsFlagsComplete_Inheritance ()
		{
			EventInfo [] events;
			BindingFlags flags;

			TypeBuilder blueType = module.DefineType (genTypeName (),
				TypeAttributes.Public);
			CreateMembers (blueType, "Blue", false);

			TypeBuilder redType = module.DefineType (genTypeName (),
				TypeAttributes.Public, blueType);
			CreateMembers (redType, "Red", false);

			TypeBuilder greenType = module.DefineType (genTypeName (),
				TypeAttributes.Public, redType);
			CreateMembers (greenType, "Green", false);

			blueType.CreateType ();
			redType.CreateType ();
			greenType.CreateType ();

			flags = BindingFlags.Instance | BindingFlags.NonPublic;
			events = greenType.GetEvents (flags);

			Assert.AreEqual (13, events.Length, "#A1");
			Assert.AreEqual ("OnPrivateInstanceGreen", events [0].Name, "#A2");
			Assert.AreEqual ("OnFamilyInstanceGreen", events [1].Name, "#A3");
			Assert.AreEqual ("OnFamANDAssemInstanceGreen", events [2].Name, "#A4");
			Assert.AreEqual ("OnFamORAssemInstanceGreen", events [3].Name, "#A5");
			Assert.AreEqual ("OnAssemblyInstanceGreen", events [4].Name, "#A6");
			Assert.AreEqual ("OnFamilyInstanceRed", events [5].Name, "#A7");
			Assert.AreEqual ("OnFamANDAssemInstanceRed", events [6].Name, "#A8");
			Assert.AreEqual ("OnFamORAssemInstanceRed", events [7].Name, "#A9");
			Assert.AreEqual ("OnAssemblyInstanceRed", events [8].Name, "#A10");
			Assert.AreEqual ("OnFamilyInstanceBlue", events [9].Name, "#A11");
			Assert.AreEqual ("OnFamANDAssemInstanceBlue", events [10].Name, "#A12");
			Assert.AreEqual ("OnFamORAssemInstanceBlue", events [11].Name, "#A13");
			Assert.AreEqual ("OnAssemblyInstanceBlue", events [12].Name, "#A14");

			flags = BindingFlags.Instance | BindingFlags.Public;
			events = greenType.GetEvents (flags);

			Assert.AreEqual (3, events.Length, "#B1");
			Assert.AreEqual ("OnPublicInstanceGreen", events [0].Name, "#B2");
			Assert.AreEqual ("OnPublicInstanceRed", events [1].Name, "#B3");
			Assert.AreEqual ("OnPublicInstanceBlue", events [2].Name, "#B4");

			flags = BindingFlags.Static | BindingFlags.Public;
			events = greenType.GetEvents (flags);

			Assert.AreEqual (1, events.Length, "#C1");
			Assert.AreEqual ("OnPublicStaticGreen", events [0].Name, "#C2");

			flags = BindingFlags.Static | BindingFlags.NonPublic;
			events = greenType.GetEvents (flags);

			Assert.AreEqual (5, events.Length, "#D1");
			Assert.AreEqual ("OnPrivateStaticGreen", events [0].Name, "#D2");
			Assert.AreEqual ("OnFamilyStaticGreen", events [1].Name, "#D3");
			Assert.AreEqual ("OnFamANDAssemStaticGreen", events [2].Name, "#D4");
			Assert.AreEqual ("OnFamORAssemStaticGreen", events [3].Name, "#D5");
			Assert.AreEqual ("OnAssemblyStaticGreen", events [4].Name, "#D6");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.FlattenHierarchy;
			events = greenType.GetEvents (flags);

			Assert.AreEqual (13, events.Length, "#E1");
			Assert.AreEqual ("OnPrivateInstanceGreen", events [0].Name, "#E2");
			Assert.AreEqual ("OnFamilyInstanceGreen", events [1].Name, "#E3");
			Assert.AreEqual ("OnFamANDAssemInstanceGreen", events [2].Name, "#E4");
			Assert.AreEqual ("OnFamORAssemInstanceGreen", events [3].Name, "#E5");
			Assert.AreEqual ("OnAssemblyInstanceGreen", events [4].Name, "#E6");
			Assert.AreEqual ("OnFamilyInstanceRed", events [5].Name, "#E7");
			Assert.AreEqual ("OnFamANDAssemInstanceRed", events [6].Name, "#E8");
			Assert.AreEqual ("OnFamORAssemInstanceRed", events [7].Name, "#E9");
			Assert.AreEqual ("OnAssemblyInstanceRed", events [8].Name, "#E10");
			Assert.AreEqual ("OnFamilyInstanceBlue", events [9].Name, "#E11");
			Assert.AreEqual ("OnFamANDAssemInstanceBlue", events [10].Name, "#E12");
			Assert.AreEqual ("OnFamORAssemInstanceBlue", events [11].Name, "#E13");
			Assert.AreEqual ("OnAssemblyInstanceBlue", events [12].Name, "#E14");

			flags = BindingFlags.Instance | BindingFlags.Public |
				BindingFlags.FlattenHierarchy;
			events = greenType.GetEvents (flags);

			Assert.AreEqual (3, events.Length, "#F1");
			Assert.AreEqual ("OnPublicInstanceGreen", events [0].Name, "#F2");
			Assert.AreEqual ("OnPublicInstanceRed", events [1].Name, "#F3");
			Assert.AreEqual ("OnPublicInstanceBlue", events [2].Name, "#F4");

			flags = BindingFlags.Static | BindingFlags.Public |
				BindingFlags.FlattenHierarchy;
			events = greenType.GetEvents (flags);

			Assert.AreEqual (3, events.Length, "#G1");
			Assert.AreEqual ("OnPublicStaticGreen", events [0].Name, "#G2");
			Assert.AreEqual ("OnPublicStaticRed", events [1].Name, "#G3");
			Assert.AreEqual ("OnPublicStaticBlue", events [2].Name, "#G4");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.FlattenHierarchy;
			events = greenType.GetEvents (flags);

			Assert.AreEqual (13, events.Length, "#H1");
			Assert.AreEqual ("OnPrivateStaticGreen", events [0].Name, "#H2");
			Assert.AreEqual ("OnFamilyStaticGreen", events [1].Name, "#H3");
			Assert.AreEqual ("OnFamANDAssemStaticGreen", events [2].Name, "#H4");
			Assert.AreEqual ("OnFamORAssemStaticGreen", events [3].Name, "#H5");
			Assert.AreEqual ("OnAssemblyStaticGreen", events [4].Name, "#H6");
			Assert.AreEqual ("OnFamilyStaticRed", events [5].Name, "#H7");
			Assert.AreEqual ("OnFamANDAssemStaticRed", events [6].Name, "#H8");
			Assert.AreEqual ("OnFamORAssemStaticRed", events [7].Name, "#H9");
			Assert.AreEqual ("OnAssemblyStaticRed", events [8].Name, "#H10");
			Assert.AreEqual ("OnFamilyStaticBlue", events [9].Name, "#H11");
			Assert.AreEqual ("OnFamANDAssemStaticBlue", events [10].Name, "#H12");
			Assert.AreEqual ("OnFamORAssemStaticBlue", events [11].Name, "#H13");
			Assert.AreEqual ("OnAssemblyStaticBlue", events [12].Name, "#H14");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.DeclaredOnly;
			events = greenType.GetEvents (flags);

			Assert.AreEqual (5, events.Length, "#I1");
			Assert.AreEqual ("OnPrivateInstanceGreen", events [0].Name, "#I2");
			Assert.AreEqual ("OnFamilyInstanceGreen", events [1].Name, "#I3");
			Assert.AreEqual ("OnFamANDAssemInstanceGreen", events [2].Name, "#I4");
			Assert.AreEqual ("OnFamORAssemInstanceGreen", events [3].Name, "#I5");
			Assert.AreEqual ("OnAssemblyInstanceGreen", events [4].Name, "#I6");

			flags = BindingFlags.Instance | BindingFlags.Public |
				BindingFlags.DeclaredOnly;
			events = greenType.GetEvents (flags);

			Assert.AreEqual (1, events.Length, "#J1");
			Assert.AreEqual ("OnPublicInstanceGreen", events [0].Name, "#J2");

			flags = BindingFlags.Static | BindingFlags.Public |
				BindingFlags.DeclaredOnly;
			events = greenType.GetEvents (flags);

			Assert.AreEqual (1, events.Length, "#K1");
			Assert.AreEqual ("OnPublicStaticGreen", events [0].Name, "#K2");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.DeclaredOnly;
			events = greenType.GetEvents (flags);

			Assert.AreEqual (5, events.Length, "#L1");
			Assert.AreEqual ("OnPrivateStaticGreen", events [0].Name, "#L2");
			Assert.AreEqual ("OnFamilyStaticGreen", events [1].Name, "#L3");
			Assert.AreEqual ("OnFamANDAssemStaticGreen", events [2].Name, "#L4");
			Assert.AreEqual ("OnFamORAssemStaticGreen", events [3].Name, "#L5");
			Assert.AreEqual ("OnAssemblyStaticGreen", events [4].Name, "#L6");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.Public;
			events = greenType.GetEvents (flags);

			Assert.AreEqual (16, events.Length, "#M1");
			Assert.AreEqual ("OnPrivateInstanceGreen", events [0].Name, "#M2");
			Assert.AreEqual ("OnFamilyInstanceGreen", events [1].Name, "#M3");
			Assert.AreEqual ("OnFamANDAssemInstanceGreen", events [2].Name, "#M4");
			Assert.AreEqual ("OnFamORAssemInstanceGreen", events [3].Name, "#M5");
			Assert.AreEqual ("OnPublicInstanceGreen", events [4].Name, "#M6");
			Assert.AreEqual ("OnAssemblyInstanceGreen", events [5].Name, "#M7");
			Assert.AreEqual ("OnFamilyInstanceRed", events [6].Name, "#M8");
			Assert.AreEqual ("OnFamANDAssemInstanceRed", events [7].Name, "#M9");
			Assert.AreEqual ("OnFamORAssemInstanceRed", events [8].Name, "#M10");
			Assert.AreEqual ("OnPublicInstanceRed", events [9].Name, "#M11");
			Assert.AreEqual ("OnAssemblyInstanceRed", events [10].Name, "#M12");
			Assert.AreEqual ("OnFamilyInstanceBlue", events [11].Name, "#M13");
			Assert.AreEqual ("OnFamANDAssemInstanceBlue", events [12].Name, "#M14");
			Assert.AreEqual ("OnFamORAssemInstanceBlue", events [13].Name, "#M15");
			Assert.AreEqual ("OnPublicInstanceBlue", events [14].Name, "#M16");
			Assert.AreEqual ("OnAssemblyInstanceBlue", events [15].Name, "#M17");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.Public;
			events = greenType.GetEvents (flags);

			Assert.AreEqual (6, events.Length, "#N1");
			Assert.AreEqual ("OnPrivateStaticGreen", events [0].Name, "#N2");
			Assert.AreEqual ("OnFamilyStaticGreen", events [1].Name, "#N3");
			Assert.AreEqual ("OnFamANDAssemStaticGreen", events [2].Name, "#N4");
			Assert.AreEqual ("OnFamORAssemStaticGreen", events [3].Name, "#N5");
			Assert.AreEqual ("OnPublicStaticGreen", events [4].Name, "#N6");
			Assert.AreEqual ("OnAssemblyStaticGreen", events [5].Name, "#N7");
		}

		[Test]
		[Ignore ("mcs depends on this")]
		public void TestGetEventIncomplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			try {
				tb.GetEvent ("FOO");
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
				throw;
			}
		}

		[Test]
		public void TestGetEventComplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());

			MethodBuilder onclickMethod = tb.DefineMethod ("OnChange", MethodAttributes.Public,
				typeof (void), new Type [] { typeof (Object) });
			onclickMethod.GetILGenerator ().Emit (OpCodes.Ret);

			EventBuilder eventbuilder = tb.DefineEvent ("Change", EventAttributes.None,
				typeof (ResolveEventHandler));
			eventbuilder.SetRaiseMethod (onclickMethod);

			Type emittedType = tb.CreateType ();

			Assert.IsNotNull (tb.GetEvent ("Change"));
			Assert.AreEqual (tb.GetEvent ("Change"), emittedType.GetEvent ("Change"));
			Assert.IsNull (tb.GetEvent ("NotChange"));
			Assert.AreEqual (tb.GetEvent ("NotChange"), emittedType.GetEvent ("NotChange"));
		}

		[Test]
		[Ignore ("mcs depends on this")]
		public void TestGetEventFlagsIncomplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			try {
				tb.GetEvent ("FOO", BindingFlags.Public);
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
				throw;
			}
		}

		[Test]
		public void TestGetEventFlagsComplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());

			MethodBuilder onclickMethod = tb.DefineMethod ("OnChange", MethodAttributes.Public,
				typeof (void), new Type [] { typeof (Object) });
			onclickMethod.GetILGenerator ().Emit (OpCodes.Ret);

			EventBuilder eventbuilder = tb.DefineEvent ("Change", EventAttributes.None,
				typeof (ResolveEventHandler));
			eventbuilder.SetRaiseMethod (onclickMethod);

			Type emittedType = tb.CreateType ();

			Assert.IsNotNull (tb.GetEvent ("Change", BindingFlags.Instance | BindingFlags.Public));
			Assert.AreEqual (tb.GetEvent ("Change", BindingFlags.Instance | BindingFlags.Public),
				emittedType.GetEvent ("Change", BindingFlags.Instance | BindingFlags.Public));
			Assert.IsNull (tb.GetEvent ("Change", BindingFlags.Instance | BindingFlags.NonPublic));
			Assert.AreEqual (tb.GetEvent ("Change", BindingFlags.Instance | BindingFlags.NonPublic),
				emittedType.GetEvent ("Change", BindingFlags.Instance | BindingFlags.NonPublic));
		}

		[Test]
		public void TestGetEventFlagsComplete_Inheritance ()
		{
			BindingFlags flags;

			TypeBuilder blueType = module.DefineType (genTypeName (),
				TypeAttributes.Public);
			CreateMembers (blueType, "Blue", false);

			TypeBuilder redType = module.DefineType (genTypeName (),
				TypeAttributes.Public, blueType);
			CreateMembers (redType, "Red", false);

			TypeBuilder greenType = module.DefineType (genTypeName (),
				TypeAttributes.Public, redType);
			CreateMembers (greenType, "Green", false);

			blueType.CreateType ();
			redType.CreateType ();
			greenType.CreateType ();

			flags = BindingFlags.Instance | BindingFlags.NonPublic;

			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceBlue", flags), "#A1");
			Assert.IsNotNull (greenType.GetEvent ("OnFamilyInstanceBlue", flags), "#A2");
			Assert.IsNotNull (greenType.GetEvent ("OnFamANDAssemInstanceBlue", flags), "#A3");
			Assert.IsNotNull (greenType.GetEvent ("OnFamORAssemInstanceBlue", flags), "#A4");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceBlue", flags), "#A5");
			Assert.IsNotNull (greenType.GetEvent ("OnAssemblyInstanceBlue", flags), "#A6");
			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceRed", flags), "#A7");
			Assert.IsNotNull (greenType.GetEvent ("OnFamilyInstanceRed", flags), "#A8");
			Assert.IsNotNull (greenType.GetEvent ("OnFamANDAssemInstanceRed", flags), "#A9");
			Assert.IsNotNull (greenType.GetEvent ("OnFamORAssemInstanceRed", flags), "#A10");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceRed", flags), "#A11");
			Assert.IsNotNull (greenType.GetEvent ("OnAssemblyInstanceRed", flags), "#A12");
			Assert.IsNotNull (greenType.GetEvent ("OnPrivateInstanceGreen", flags), "#A13");
			Assert.IsNotNull (greenType.GetEvent ("OnFamilyInstanceGreen", flags), "#A14");
			Assert.IsNotNull (greenType.GetEvent ("OnFamANDAssemInstanceGreen", flags), "#A15");
			Assert.IsNotNull (greenType.GetEvent ("OnFamORAssemInstanceGreen", flags), "#A16");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceGreen", flags), "#A17");
			Assert.IsNotNull (greenType.GetEvent ("OnAssemblyInstanceGreen", flags), "#A18");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticBlue", flags), "#A19");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticBlue", flags), "#A20");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticBlue", flags), "#A21");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticBlue", flags), "#A22");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticBlue", flags), "#A23");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticBlue", flags), "#A24");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticRed", flags), "#A25");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticRed", flags), "#A26");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticRed", flags), "#A27");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticRed", flags), "#A28");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticRed", flags), "#A29");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticRed", flags), "#A30");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticGreen", flags), "#A31");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticGreen", flags), "#A32");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticGreen", flags), "#A33");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticGreen", flags), "#A34");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticGreen", flags), "#A35");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticGreen", flags), "#A36");

			flags = BindingFlags.Instance | BindingFlags.Public;

			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceBlue", flags), "#B1");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceBlue", flags), "#B2");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceBlue", flags), "#B3");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceBlue", flags), "#B4");
			Assert.IsNotNull (greenType.GetEvent ("OnPublicInstanceBlue", flags), "#B5");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceBlue", flags), "#B6");
			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceRed", flags), "#B7");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceRed", flags), "#B8");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceRed", flags), "#B9");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceRed", flags), "#B10");
			Assert.IsNotNull (greenType.GetEvent ("OnPublicInstanceRed", flags), "#B11");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceRed", flags), "#B12");
			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceGreen", flags), "#B13");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceGreen", flags), "#B14");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceGreen", flags), "#B15");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceGreen", flags), "#B16");
			Assert.IsNotNull (greenType.GetEvent ("OnPublicInstanceGreen", flags), "#B17");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceGreen", flags), "#B18");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticBlue", flags), "#B19");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticBlue", flags), "#B20");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticBlue", flags), "#B21");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticBlue", flags), "#B22");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticBlue", flags), "#B23");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticBlue", flags), "#B24");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticRed", flags), "#B25");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticRed", flags), "#B26");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticRed", flags), "#B27");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticRed", flags), "#B28");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticRed", flags), "#B29");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticRed", flags), "#B30");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticGreen", flags), "#B31");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticGreen", flags), "#B32");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticGreen", flags), "#B33");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticGreen", flags), "#B34");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticGreen", flags), "#B35");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticGreen", flags), "#B36");

			flags = BindingFlags.Static | BindingFlags.Public;

			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceBlue", flags), "#C1");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceBlue", flags), "#C2");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceBlue", flags), "#C3");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceBlue", flags), "#C4");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceBlue", flags), "#C5");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceBlue", flags), "#C6");
			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceRed", flags), "#C7");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceRed", flags), "#C8");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceRed", flags), "#C9");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceRed", flags), "#C10");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceRed", flags), "#C11");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceRed", flags), "#C12");
			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceGreen", flags), "#C13");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceGreen", flags), "#C14");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceGreen", flags), "#C15");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceGreen", flags), "#C16");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceGreen", flags), "#C17");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceGreen", flags), "#C18");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticBlue", flags), "#C19");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticBlue", flags), "#C20");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticBlue", flags), "#C21");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticBlue", flags), "#C22");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticBlue", flags), "#C23");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticBlue", flags), "#C24");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticRed", flags), "#C25");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticRed", flags), "#C26");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticRed", flags), "#C27");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticRed", flags), "#C28");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticRed", flags), "#C29");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticRed", flags), "#C30");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticGreen", flags), "#C31");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticGreen", flags), "#C32");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticGreen", flags), "#C33");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticGreen", flags), "#C34");
			Assert.IsNotNull (greenType.GetEvent ("OnPublicStaticGreen", flags), "#C35");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticGreen", flags), "#C36");

			flags = BindingFlags.Static | BindingFlags.NonPublic;

			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceBlue", flags), "#D1");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceBlue", flags), "#D2");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceBlue", flags), "#D3");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceBlue", flags), "#D4");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceBlue", flags), "#D5");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceBlue", flags), "#D6");
			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceRed", flags), "#D7");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceRed", flags), "#D8");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceRed", flags), "#D9");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceRed", flags), "#D10");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceRed", flags), "#D11");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceRed", flags), "#D12");
			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceGreen", flags), "#D13");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceGreen", flags), "#D14");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceGreen", flags), "#D15");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceGreen", flags), "#D16");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceGreen", flags), "#D17");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceGreen", flags), "#D18");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticBlue", flags), "#D19");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticBlue", flags), "#D20");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticBlue", flags), "#D21");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticBlue", flags), "#D22");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticBlue", flags), "#D23");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticBlue", flags), "#D24");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticRed", flags), "#D25");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticRed", flags), "#D26");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticRed", flags), "#D27");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticRed", flags), "#D28");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticRed", flags), "#D29");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticRed", flags), "#D30");
			Assert.IsNotNull (greenType.GetEvent ("OnPrivateStaticGreen", flags), "#D31");
			Assert.IsNotNull (greenType.GetEvent ("OnFamilyStaticGreen", flags), "#D32");
			Assert.IsNotNull (greenType.GetEvent ("OnFamANDAssemStaticGreen", flags), "#D33");
			Assert.IsNotNull (greenType.GetEvent ("OnFamORAssemStaticGreen", flags), "#D34");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticGreen", flags), "#D35");
			Assert.IsNotNull (greenType.GetEvent ("OnAssemblyStaticGreen", flags), "#D36");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.FlattenHierarchy;

			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceBlue", flags), "#E1");
			Assert.IsNotNull (greenType.GetEvent ("OnFamilyInstanceBlue", flags), "#E2");
			Assert.IsNotNull (greenType.GetEvent ("OnFamANDAssemInstanceBlue", flags), "#E3");
			Assert.IsNotNull (greenType.GetEvent ("OnFamORAssemInstanceBlue", flags), "#E4");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceBlue", flags), "#E5");
			Assert.IsNotNull (greenType.GetEvent ("OnAssemblyInstanceBlue", flags), "#E6");
			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceRed", flags), "#E7");
			Assert.IsNotNull (greenType.GetEvent ("OnFamilyInstanceRed", flags), "#E8");
			Assert.IsNotNull (greenType.GetEvent ("OnFamANDAssemInstanceRed", flags), "#E9");
			Assert.IsNotNull (greenType.GetEvent ("OnFamORAssemInstanceRed", flags), "#E10");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceRed", flags), "#E11");
			Assert.IsNotNull (greenType.GetEvent ("OnAssemblyInstanceRed", flags), "#E12");
			Assert.IsNotNull (greenType.GetEvent ("OnPrivateInstanceGreen", flags), "#E13");
			Assert.IsNotNull (greenType.GetEvent ("OnFamilyInstanceGreen", flags), "#E14");
			Assert.IsNotNull (greenType.GetEvent ("OnFamANDAssemInstanceGreen", flags), "#E15");
			Assert.IsNotNull (greenType.GetEvent ("OnFamORAssemInstanceGreen", flags), "#E16");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceGreen", flags), "#E17");
			Assert.IsNotNull (greenType.GetEvent ("OnAssemblyInstanceGreen", flags), "#E18");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticBlue", flags), "#E19");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticBlue", flags), "#E20");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticBlue", flags), "#E21");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticBlue", flags), "#E22");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticBlue", flags), "#E23");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticBlue", flags), "#E24");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticRed", flags), "#E25");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticRed", flags), "#E26");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticRed", flags), "#E27");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticRed", flags), "#E28");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticRed", flags), "#E29");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticRed", flags), "#E30");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticGreen", flags), "#E31");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticGreen", flags), "#E32");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticGreen", flags), "#E33");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticGreen", flags), "#E34");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticGreen", flags), "#E35");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticGreen", flags), "#E36");

			flags = BindingFlags.Instance | BindingFlags.Public |
				BindingFlags.FlattenHierarchy;

			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceBlue", flags), "#F1");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceBlue", flags), "#F2");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceBlue", flags), "#F3");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceBlue", flags), "#F4");
			Assert.IsNotNull (greenType.GetEvent ("OnPublicInstanceBlue", flags), "#F5");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceBlue", flags), "#F6");
			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceRed", flags), "#F7");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceRed", flags), "#F8");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceRed", flags), "#F9");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceRed", flags), "#F10");
			Assert.IsNotNull (greenType.GetEvent ("OnPublicInstanceRed", flags), "#F11");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceRed", flags), "#F12");
			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceGreen", flags), "#F13");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceGreen", flags), "#F14");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceGreen", flags), "#F15");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceGreen", flags), "#F16");
			Assert.IsNotNull (greenType.GetEvent ("OnPublicInstanceGreen", flags), "#F17");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceGreen", flags), "#F18");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticBlue", flags), "#F19");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticBlue", flags), "#F20");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticBlue", flags), "#F21");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticBlue", flags), "#F22");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticBlue", flags), "#F23");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticBlue", flags), "#F24");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticRed", flags), "#F25");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticRed", flags), "#F26");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticRed", flags), "#F27");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticRed", flags), "#F28");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticRed", flags), "#F29");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticRed", flags), "#F30");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticGreen", flags), "#F31");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticGreen", flags), "#F32");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticGreen", flags), "#F33");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticGreen", flags), "#F34");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticGreen", flags), "#F35");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticGreen", flags), "#F36");

			flags = BindingFlags.Static | BindingFlags.Public |
				BindingFlags.FlattenHierarchy;

			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceBlue", flags), "#G1");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceBlue", flags), "#G2");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceBlue", flags), "#G3");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceBlue", flags), "#G4");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceBlue", flags), "#G5");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceBlue", flags), "#G6");
			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceRed", flags), "#G7");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceRed", flags), "#G8");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceRed", flags), "#G9");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceRed", flags), "#G10");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceRed", flags), "#G11");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceRed", flags), "#G12");
			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceGreen", flags), "#G13");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceGreen", flags), "#G14");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceGreen", flags), "#G15");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceGreen", flags), "#G16");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceGreen", flags), "#G17");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceGreen", flags), "#G18");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticBlue", flags), "#G19");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticBlue", flags), "#G20");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticBlue", flags), "#G21");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticBlue", flags), "#G22");
			Assert.IsNotNull (greenType.GetEvent ("OnPublicStaticBlue", flags), "#G23");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticBlue", flags), "#G24");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticRed", flags), "#G25");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticRed", flags), "#G26");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticRed", flags), "#G27");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticRed", flags), "#G28");
			Assert.IsNotNull (greenType.GetEvent ("OnPublicStaticRed", flags), "#G29");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticRed", flags), "#G30");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticGreen", flags), "#G31");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticGreen", flags), "#G32");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticGreen", flags), "#G33");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticGreen", flags), "#G34");
			Assert.IsNotNull (greenType.GetEvent ("OnPublicStaticGreen", flags), "#G35");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticGreen", flags), "#G36");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.FlattenHierarchy;

			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceBlue", flags), "#H1");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceBlue", flags), "#H2");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceBlue", flags), "#H3");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceBlue", flags), "#H4");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceBlue", flags), "#H5");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceBlue", flags), "#H6");
			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceRed", flags), "#H7");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceRed", flags), "#H8");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceRed", flags), "#H9");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceRed", flags), "#H10");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceRed", flags), "#H11");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceRed", flags), "#H12");
			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceGreen", flags), "#H13");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceGreen", flags), "#H14");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceGreen", flags), "#H15");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceGreen", flags), "#H16");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceGreen", flags), "#H17");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceGreen", flags), "#H18");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticBlue", flags), "#H19");
			Assert.IsNotNull (greenType.GetEvent ("OnFamilyStaticBlue", flags), "#H20");
			Assert.IsNotNull (greenType.GetEvent ("OnFamANDAssemStaticBlue", flags), "#H21");
			Assert.IsNotNull (greenType.GetEvent ("OnFamORAssemStaticBlue", flags), "#H22");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticBlue", flags), "#H23");
			Assert.IsNotNull (greenType.GetEvent ("OnAssemblyStaticBlue", flags), "#H24");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticRed", flags), "#H25");
			Assert.IsNotNull (greenType.GetEvent ("OnFamilyStaticRed", flags), "#H26");
			Assert.IsNotNull (greenType.GetEvent ("OnFamANDAssemStaticRed", flags), "#H27");
			Assert.IsNotNull (greenType.GetEvent ("OnFamORAssemStaticRed", flags), "#H28");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticRed", flags), "#H29");
			Assert.IsNotNull (greenType.GetEvent ("OnAssemblyStaticRed", flags), "#H30");
			Assert.IsNotNull (greenType.GetEvent ("OnPrivateStaticGreen", flags), "#H31");
			Assert.IsNotNull (greenType.GetEvent ("OnFamilyStaticGreen", flags), "#H32");
			Assert.IsNotNull (greenType.GetEvent ("OnFamANDAssemStaticGreen", flags), "#H33");
			Assert.IsNotNull (greenType.GetEvent ("OnFamORAssemStaticGreen", flags), "#H34");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticGreen", flags), "#H35");
			Assert.IsNotNull (greenType.GetEvent ("OnAssemblyStaticGreen", flags), "#H36");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.DeclaredOnly;

			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceBlue", flags), "#I1");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceBlue", flags), "#I2");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceBlue", flags), "#I3");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceBlue", flags), "#I4");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceBlue", flags), "#I5");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceBlue", flags), "#I6");
			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceRed", flags), "#I7");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceRed", flags), "#I8");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceRed", flags), "#I9");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceRed", flags), "#I10");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceRed", flags), "#I11");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceRed", flags), "#I12");
			Assert.IsNotNull (greenType.GetEvent ("OnPrivateInstanceGreen", flags), "#I13");
			Assert.IsNotNull (greenType.GetEvent ("OnFamilyInstanceGreen", flags), "#I14");
			Assert.IsNotNull (greenType.GetEvent ("OnFamANDAssemInstanceGreen", flags), "#I15");
			Assert.IsNotNull (greenType.GetEvent ("OnFamORAssemInstanceGreen", flags), "#I16");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceGreen", flags), "#I17");
			Assert.IsNotNull (greenType.GetEvent ("OnAssemblyInstanceGreen", flags), "#I18");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticBlue", flags), "#I19");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticBlue", flags), "#I20");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticBlue", flags), "#I21");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticBlue", flags), "#I22");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticBlue", flags), "#I23");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticBlue", flags), "#I24");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticRed", flags), "#I25");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticRed", flags), "#I26");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticRed", flags), "#I27");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticRed", flags), "#I28");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticRed", flags), "#I29");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticRed", flags), "#I30");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticGreen", flags), "#I31");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticGreen", flags), "#I32");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticGreen", flags), "#I33");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticGreen", flags), "#I34");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticGreen", flags), "#I35");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticGreen", flags), "#I36");

			flags = BindingFlags.Instance | BindingFlags.Public |
				BindingFlags.DeclaredOnly;

			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceBlue", flags), "#J1");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceBlue", flags), "#J2");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceBlue", flags), "#J3");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceBlue", flags), "#J4");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceBlue", flags), "#J5");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceBlue", flags), "#J6");
			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceRed", flags), "#J7");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceRed", flags), "#J8");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceRed", flags), "#J9");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceRed", flags), "#J10");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceRed", flags), "#J11");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceRed", flags), "#J12");
			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceGreen", flags), "#J13");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceGreen", flags), "#J14");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceGreen", flags), "#J15");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceGreen", flags), "#J16");
			Assert.IsNotNull (greenType.GetEvent ("OnPublicInstanceGreen", flags), "#J17");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceGreen", flags), "#J18");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticBlue", flags), "#J19");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticBlue", flags), "#J20");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticBlue", flags), "#J21");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticBlue", flags), "#J22");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticBlue", flags), "#J23");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticBlue", flags), "#J24");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticRed", flags), "#J25");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticRed", flags), "#J26");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticRed", flags), "#J27");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticRed", flags), "#J28");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticRed", flags), "#J29");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticRed", flags), "#J30");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticGreen", flags), "#J31");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticGreen", flags), "#J32");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticGreen", flags), "#J33");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticGreen", flags), "#J34");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticGreen", flags), "#J35");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticGreen", flags), "#J36");

			flags = BindingFlags.Static | BindingFlags.Public |
				BindingFlags.DeclaredOnly;

			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceBlue", flags), "#K1");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceBlue", flags), "#K2");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceBlue", flags), "#K3");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceBlue", flags), "#K4");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceBlue", flags), "#K5");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceBlue", flags), "#K6");
			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceRed", flags), "#K7");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceRed", flags), "#K8");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceRed", flags), "#K9");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceRed", flags), "#K10");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceRed", flags), "#K11");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceRed", flags), "#K12");
			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceGreen", flags), "#K13");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceGreen", flags), "#K14");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceGreen", flags), "#K15");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceGreen", flags), "#K16");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceGreen", flags), "#K17");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceGreen", flags), "#K18");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticBlue", flags), "#K19");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticBlue", flags), "#K20");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticBlue", flags), "#K21");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticBlue", flags), "#K22");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticBlue", flags), "#K23");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticBlue", flags), "#K24");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticRed", flags), "#K25");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticRed", flags), "#K26");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticRed", flags), "#K27");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticRed", flags), "#K28");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticRed", flags), "#K29");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticRed", flags), "#K30");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticGreen", flags), "#K31");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticGreen", flags), "#K32");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticGreen", flags), "#K33");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticGreen", flags), "#K34");
			Assert.IsNotNull (greenType.GetEvent ("OnPublicStaticGreen", flags), "#K35");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticGreen", flags), "#K36");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.DeclaredOnly;

			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceBlue", flags), "#L1");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceBlue", flags), "#L2");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceBlue", flags), "#L3");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceBlue", flags), "#L4");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceBlue", flags), "#L5");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceBlue", flags), "#L6");
			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceRed", flags), "#L7");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceRed", flags), "#L8");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceRed", flags), "#L9");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceRed", flags), "#L10");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceRed", flags), "#L11");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceRed", flags), "#L12");
			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceGreen", flags), "#L13");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceGreen", flags), "#L14");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceGreen", flags), "#L15");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceGreen", flags), "#L16");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceGreen", flags), "#L17");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceGreen", flags), "#L18");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticBlue", flags), "#L19");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticBlue", flags), "#L20");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticBlue", flags), "#L21");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticBlue", flags), "#L22");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticBlue", flags), "#L23");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticBlue", flags), "#L24");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticRed", flags), "#L25");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticRed", flags), "#L26");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticRed", flags), "#L27");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticRed", flags), "#L28");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticRed", flags), "#L29");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticRed", flags), "#L30");
			Assert.IsNotNull (greenType.GetEvent ("OnPrivateStaticGreen", flags), "#L31");
			Assert.IsNotNull (greenType.GetEvent ("OnFamilyStaticGreen", flags), "#L32");
			Assert.IsNotNull (greenType.GetEvent ("OnFamANDAssemStaticGreen", flags), "#L33");
			Assert.IsNotNull (greenType.GetEvent ("OnFamORAssemStaticGreen", flags), "#L34");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticGreen", flags), "#L35");
			Assert.IsNotNull (greenType.GetEvent ("OnAssemblyStaticGreen", flags), "#L36");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.Public;

			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceBlue", flags), "#M1");
			Assert.IsNotNull (greenType.GetEvent ("OnFamilyInstanceBlue", flags), "#M2");
			Assert.IsNotNull (greenType.GetEvent ("OnFamANDAssemInstanceBlue", flags), "#M3");
			Assert.IsNotNull (greenType.GetEvent ("OnFamORAssemInstanceBlue", flags), "#M4");
			Assert.IsNotNull (greenType.GetEvent ("OnPublicInstanceBlue", flags), "#M5");
			Assert.IsNotNull (greenType.GetEvent ("OnAssemblyInstanceBlue", flags), "#M6");
			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceRed", flags), "#M7");
			Assert.IsNotNull (greenType.GetEvent ("OnFamilyInstanceRed", flags), "#M8");
			Assert.IsNotNull (greenType.GetEvent ("OnFamANDAssemInstanceRed", flags), "#M9");
			Assert.IsNotNull (greenType.GetEvent ("OnFamORAssemInstanceRed", flags), "#M10");
			Assert.IsNotNull (greenType.GetEvent ("OnPublicInstanceRed", flags), "#M11");
			Assert.IsNotNull (greenType.GetEvent ("OnAssemblyInstanceRed", flags), "#M12");
			Assert.IsNotNull (greenType.GetEvent ("OnPrivateInstanceGreen", flags), "#M13");
			Assert.IsNotNull (greenType.GetEvent ("OnFamilyInstanceGreen", flags), "#M14");
			Assert.IsNotNull (greenType.GetEvent ("OnFamANDAssemInstanceGreen", flags), "#M15");
			Assert.IsNotNull (greenType.GetEvent ("OnFamORAssemInstanceGreen", flags), "#M16");
			Assert.IsNotNull (greenType.GetEvent ("OnPublicInstanceGreen", flags), "#M17");
			Assert.IsNotNull (greenType.GetEvent ("OnAssemblyInstanceGreen", flags), "#M18");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticBlue", flags), "#M19");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticBlue", flags), "#M20");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticBlue", flags), "#M21");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticBlue", flags), "#M22");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticBlue", flags), "#M23");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticBlue", flags), "#M24");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticRed", flags), "#M25");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticRed", flags), "#M26");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticRed", flags), "#M27");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticRed", flags), "#M28");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticRed", flags), "#M29");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticRed", flags), "#M30");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticGreen", flags), "#M31");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticGreen", flags), "#M32");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticGreen", flags), "#M33");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticGreen", flags), "#M34");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticGreen", flags), "#M35");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticGreen", flags), "#M36");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.Public;

			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceBlue", flags), "#N1");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceBlue", flags), "#N2");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceBlue", flags), "#N3");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceBlue", flags), "#N4");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceBlue", flags), "#N5");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceBlue", flags), "#N6");
			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceRed", flags), "#N7");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceRed", flags), "#N8");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceRed", flags), "#N9");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceRed", flags), "#N10");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceRed", flags), "#N11");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceRed", flags), "#N12");
			Assert.IsNull (greenType.GetEvent ("OnPrivateInstanceGreen", flags), "#N13");
			Assert.IsNull (greenType.GetEvent ("OnFamilyInstanceGreen", flags), "#N14");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemInstanceGreen", flags), "#N15");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemInstanceGreen", flags), "#N16");
			Assert.IsNull (greenType.GetEvent ("OnPublicInstanceGreen", flags), "#N17");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyInstanceGreen", flags), "#N18");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticBlue", flags), "#N19");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticBlue", flags), "#N20");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticBlue", flags), "#N21");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticBlue", flags), "#N22");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticBlue", flags), "#N23");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticBlue", flags), "#N24");
			Assert.IsNull (greenType.GetEvent ("OnPrivateStaticRed", flags), "#N25");
			Assert.IsNull (greenType.GetEvent ("OnFamilyStaticRed", flags), "#N26");
			Assert.IsNull (greenType.GetEvent ("OnFamANDAssemStaticRed", flags), "#N27");
			Assert.IsNull (greenType.GetEvent ("OnFamORAssemStaticRed", flags), "#N28");
			Assert.IsNull (greenType.GetEvent ("OnPublicStaticRed", flags), "#N29");
			Assert.IsNull (greenType.GetEvent ("OnAssemblyStaticRed", flags), "#N30");
			Assert.IsNotNull (greenType.GetEvent ("OnPrivateStaticGreen", flags), "#N31");
			Assert.IsNotNull (greenType.GetEvent ("OnFamilyStaticGreen", flags), "#N32");
			Assert.IsNotNull (greenType.GetEvent ("OnFamANDAssemStaticGreen", flags), "#N33");
			Assert.IsNotNull (greenType.GetEvent ("OnFamORAssemStaticGreen", flags), "#N34");
			Assert.IsNotNull (greenType.GetEvent ("OnPublicStaticGreen", flags), "#N35");
			Assert.IsNotNull (greenType.GetEvent ("OnAssemblyStaticGreen", flags), "#N36");
		}

		[Test]
		[Category ("NotWorking")] // mcs depends on this
		public void TestGetFieldsIncomplete_MS ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.DefineField ("TestField", typeof (int), FieldAttributes.Public);
			try {
				tb.GetFields ();
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		[Category ("NotDotNet")] // mcs depends on this
		public void TestGetFieldsIncomplete_Mono ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.DefineField ("name", typeof (string), FieldAttributes.Private);
			tb.DefineField ("Sex", typeof (int), FieldAttributes.Public);
			tb.DefineField ("MALE", typeof (int), FieldAttributes.Public | FieldAttributes.Static);
			tb.DefineField ("FEMALE", typeof (int), FieldAttributes.Private | FieldAttributes.Static);

			FieldInfo [] fields = tb.GetFields ();
			Assert.AreEqual (2, fields.Length, "#A1");
			Assert.AreEqual ("Sex", fields [0].Name, "#A2");
			Assert.AreEqual ("MALE", fields [1].Name, "#A3");

			tb = module.DefineType (genTypeName ());
			GenericTypeParameterBuilder [] typeParams = tb.DefineGenericParameters ("K", "V");
			tb.DefineField ("First", typeParams [0], FieldAttributes.Public);
			tb.DefineField ("Second", typeParams [1], FieldAttributes.Public);
			tb.DefineField ("Sex", typeof (int), FieldAttributes.Public);
			tb.DefineField ("MALE", typeof (int), FieldAttributes.Public | FieldAttributes.Static);
			tb.DefineField ("FEMALE", typeof (int), FieldAttributes.Private | FieldAttributes.Static);

			fields = tb.GetFields ();
			Assert.AreEqual (4, fields.Length, "#B1");
			Assert.AreEqual ("First", fields [0].Name, "#B2");
			Assert.AreEqual ("Second", fields [1].Name, "#B3");
			Assert.AreEqual ("Sex", fields [2].Name, "#B4");
			Assert.AreEqual ("MALE", fields [3].Name, "#B5");
		}

		[Test]
		public void TestGetFieldsComplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.DefineField ("TestField", typeof (int), FieldAttributes.Public);

			Type emittedType = tb.CreateType ();
			FieldInfo [] dynamicFields = tb.GetFields ();
			FieldInfo [] emittedFields = emittedType.GetFields ();

			Assert.AreEqual (1, dynamicFields.Length, "#A1");
			Assert.AreEqual (dynamicFields.Length, emittedFields.Length, "#A2");
			Assert.IsFalse ((dynamicFields [0]) is FieldBuilder, "#A3");
			Assert.IsFalse ((emittedFields [0]) is FieldBuilder, "#A4");

			// bug #81638
			object value = Activator.CreateInstance (emittedType);
			emittedFields [0].SetValue (value, 5);
			Assert.AreEqual (5, emittedFields [0].GetValue (value), "#B1");
			Assert.AreEqual (5, dynamicFields [0].GetValue (value), "#B2");
			dynamicFields [0].SetValue (value, 4);
			Assert.AreEqual (4, emittedFields [0].GetValue (value), "#B3");
			Assert.AreEqual (4, dynamicFields [0].GetValue (value), "#B4");
		}

		[Test] // bug #82625 / 325292
		public void TestGetFieldsComplete_Generic ()
		{
			// FIXME: merge this with TestGetFieldsComplete when
			// bug #82625 is fixed

			TypeBuilder tb;
			Type emittedType;
			FieldInfo [] dynamicFields;
			FieldInfo [] emittedFields;

			tb = module.DefineType (genTypeName ());
			GenericTypeParameterBuilder [] typeParams = tb.DefineGenericParameters ("K", "V");
			tb.DefineField ("First", typeParams [0], FieldAttributes.Public);
			tb.DefineField ("Second", typeParams [1], FieldAttributes.Public);
			tb.DefineField ("Sex", typeof (int), FieldAttributes.Public);
			tb.DefineField ("MALE", typeof (int), FieldAttributes.Public | FieldAttributes.Static);
			tb.DefineField ("FEMALE", typeof (int), FieldAttributes.Private | FieldAttributes.Static);

			emittedType = tb.CreateType ();
			dynamicFields = tb.GetFields ();
			emittedFields = emittedType.GetFields ();

			Assert.AreEqual (4, dynamicFields.Length, "#C1");
			Assert.IsFalse ((dynamicFields [0]) is FieldBuilder, "#C2");
			Assert.IsFalse ((dynamicFields [1]) is FieldBuilder, "#C3");
			Assert.IsFalse ((dynamicFields [2]) is FieldBuilder, "#C4");
			Assert.IsFalse ((dynamicFields [3]) is FieldBuilder, "#C5");
			Assert.AreEqual ("First", dynamicFields [0].Name, "#C6");
			Assert.AreEqual ("Second", dynamicFields [1].Name, "#C7");
			Assert.AreEqual ("Sex", dynamicFields [2].Name, "#C8");
			Assert.AreEqual ("MALE", dynamicFields [3].Name, "#C9");

			Assert.AreEqual (4, emittedFields.Length, "#D1");
			Assert.IsFalse ((emittedFields [0]) is FieldBuilder, "#D2");
			Assert.IsFalse ((emittedFields [1]) is FieldBuilder, "#D3");
			Assert.IsFalse ((emittedFields [2]) is FieldBuilder, "#D4");
			Assert.IsFalse ((emittedFields [3]) is FieldBuilder, "#D5");
			Assert.AreEqual ("First", emittedFields [0].Name, "#D6");
			Assert.AreEqual ("Second", emittedFields [1].Name, "#D7");
			Assert.AreEqual ("Sex", emittedFields [2].Name, "#D8");
			Assert.AreEqual ("MALE", emittedFields [3].Name, "#D9");
		}

		[Test]
		[Category ("NotWorking")] // mcs depends on this
		public void TestGetFieldsFlagsIncomplete_MS ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.DefineField ("TestField", typeof (int), FieldAttributes.Public);
			try {
				tb.GetFields (BindingFlags.Instance | BindingFlags.Public);
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				// The invoked member is not supported in a
				// dynamic module
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		[Category ("NotDotNet")] // mcs depends on this
		public void TestGetFieldsFlagsIncomplete_Mono ()
		{
			FieldInfo [] fields;

			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.DefineField ("name", typeof (string), FieldAttributes.Private);
			tb.DefineField ("Sex", typeof (int), FieldAttributes.Public);
			tb.DefineField ("MALE", typeof (int), FieldAttributes.Public | FieldAttributes.Static);
			tb.DefineField ("FEMALE", typeof (int), FieldAttributes.Private | FieldAttributes.Static);

			fields = tb.GetFields (BindingFlags.Public |
				BindingFlags.NonPublic | BindingFlags.Instance);
			Assert.AreEqual (2, fields.Length, "#A1");
			Assert.AreEqual ("name", fields [0].Name, "#A2");
			Assert.AreEqual ("Sex", fields [1].Name, "#A3");

			fields = tb.GetFields (BindingFlags.Public |
				BindingFlags.Instance | BindingFlags.Static);
			Assert.AreEqual (2, fields.Length, "#B1");
			Assert.AreEqual ("Sex", fields [0].Name, "#B2");
			Assert.AreEqual ("MALE", fields [1].Name, "#B3");

			fields = tb.GetFields (BindingFlags.Public |
				BindingFlags.NonPublic | BindingFlags.Instance |
				BindingFlags.Static);
			Assert.AreEqual (4, fields.Length, "#C1");
			Assert.AreEqual ("name", fields [0].Name, "#C2");
			Assert.AreEqual ("Sex", fields [1].Name, "#C3");
			Assert.AreEqual ("MALE", fields [2].Name, "#C4");
			Assert.AreEqual ("FEMALE", fields [3].Name, "#C5");
		}

		[Test]
		public void TestGetFieldsFlagsComplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.DefineField ("TestField", typeof (int), FieldAttributes.Public);

			Type emittedType = tb.CreateType ();

			Assert.AreEqual (1, tb.GetFields (BindingFlags.Instance | BindingFlags.Public).Length);
			Assert.AreEqual (tb.GetFields (BindingFlags.Instance | BindingFlags.Public).Length,
				emittedType.GetFields (BindingFlags.Instance | BindingFlags.Public).Length);
			Assert.AreEqual (0, tb.GetFields (BindingFlags.Instance | BindingFlags.NonPublic).Length);
			Assert.AreEqual (tb.GetFields (BindingFlags.Instance | BindingFlags.NonPublic).Length,
				emittedType.GetFields (BindingFlags.Instance | BindingFlags.NonPublic).Length);
		}

		[Test]
		public void TestGetFieldsFlagsComplete_Inheritance ()
		{
			FieldInfo [] fields;
			BindingFlags flags;

			TypeBuilder blueType = module.DefineType (genTypeName (),
				TypeAttributes.Public);
			CreateMembers (blueType, "Blue", false);

			TypeBuilder redType = module.DefineType (genTypeName (),
				TypeAttributes.Public, blueType);
			CreateMembers (redType, "Red", false);

			TypeBuilder greenType = module.DefineType (genTypeName (),
				TypeAttributes.Public, redType);
			CreateMembers (greenType, "Green", false);

			blueType.CreateType ();
			redType.CreateType ();
			greenType.CreateType ();

			flags = BindingFlags.Instance | BindingFlags.NonPublic;
			fields = greenType.GetFields (flags);

			Assert.AreEqual (13, fields.Length, "#A1");
			Assert.AreEqual ("privateInstanceGreen", fields [0].Name, "#A2");
			Assert.AreEqual ("familyInstanceGreen", fields [1].Name, "#A3");
			Assert.AreEqual ("famANDAssemInstanceGreen", fields [2].Name, "#A4");
			Assert.AreEqual ("famORAssemInstanceGreen", fields [3].Name, "#A5");
			Assert.AreEqual ("assemblyInstanceGreen", fields [4].Name, "#A6");
			Assert.AreEqual ("familyInstanceRed", fields [5].Name, "#A7");
			Assert.AreEqual ("famANDAssemInstanceRed", fields [6].Name, "#A8");
			Assert.AreEqual ("famORAssemInstanceRed", fields [7].Name, "#A9");
			Assert.AreEqual ("assemblyInstanceRed", fields [8].Name, "#A10");
			Assert.AreEqual ("familyInstanceBlue", fields [9].Name, "#A11");
			Assert.AreEqual ("famANDAssemInstanceBlue", fields [10].Name, "#A12");
			Assert.AreEqual ("famORAssemInstanceBlue", fields [11].Name, "#A13");
			Assert.AreEqual ("assemblyInstanceBlue", fields [12].Name, "#A14");

			flags = BindingFlags.Instance | BindingFlags.Public;
			fields = greenType.GetFields (flags);

			Assert.AreEqual (3, fields.Length, "#B1");
			Assert.AreEqual ("publicInstanceGreen", fields [0].Name, "#B2");
			Assert.AreEqual ("publicInstanceRed", fields [1].Name, "#B3");
			Assert.AreEqual ("publicInstanceBlue", fields [2].Name, "#B4");

			flags = BindingFlags.Static | BindingFlags.Public;
			fields = greenType.GetFields (flags);

			Assert.AreEqual (1, fields.Length, "#C1");
			Assert.AreEqual ("publicStaticGreen", fields [0].Name, "#C2");

			flags = BindingFlags.Static | BindingFlags.NonPublic;
			fields = greenType.GetFields (flags);

			Assert.AreEqual (5, fields.Length, "#D1");
			Assert.AreEqual ("privateStaticGreen", fields [0].Name, "#D2");
			Assert.AreEqual ("familyStaticGreen", fields [1].Name, "#D3");
			Assert.AreEqual ("famANDAssemStaticGreen", fields [2].Name, "#D4");
			Assert.AreEqual ("famORAssemStaticGreen", fields [3].Name, "#D5");
			Assert.AreEqual ("assemblyStaticGreen", fields [4].Name, "#D6");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.FlattenHierarchy;
			fields = greenType.GetFields (flags);

			Assert.AreEqual (13, fields.Length, "#E1");
			Assert.AreEqual ("privateInstanceGreen", fields [0].Name, "#E2");
			Assert.AreEqual ("familyInstanceGreen", fields [1].Name, "#E3");
			Assert.AreEqual ("famANDAssemInstanceGreen", fields [2].Name, "#E4");
			Assert.AreEqual ("famORAssemInstanceGreen", fields [3].Name, "#E5");
			Assert.AreEqual ("assemblyInstanceGreen", fields [4].Name, "#E6");
			Assert.AreEqual ("familyInstanceRed", fields [5].Name, "#E7");
			Assert.AreEqual ("famANDAssemInstanceRed", fields [6].Name, "#E8");
			Assert.AreEqual ("famORAssemInstanceRed", fields [7].Name, "#E9");
			Assert.AreEqual ("assemblyInstanceRed", fields [8].Name, "#E10");
			Assert.AreEqual ("familyInstanceBlue", fields [9].Name, "#E11");
			Assert.AreEqual ("famANDAssemInstanceBlue", fields [10].Name, "#E12");
			Assert.AreEqual ("famORAssemInstanceBlue", fields [11].Name, "#E13");
			Assert.AreEqual ("assemblyInstanceBlue", fields [12].Name, "#E14");

			flags = BindingFlags.Instance | BindingFlags.Public |
				BindingFlags.FlattenHierarchy;
			fields = greenType.GetFields (flags);

			Assert.AreEqual (3, fields.Length, "#F1");
			Assert.AreEqual ("publicInstanceGreen", fields [0].Name, "#F2");
			Assert.AreEqual ("publicInstanceRed", fields [1].Name, "#F3");
			Assert.AreEqual ("publicInstanceBlue", fields [2].Name, "#F4");

			flags = BindingFlags.Static | BindingFlags.Public |
				BindingFlags.FlattenHierarchy;
			fields = greenType.GetFields (flags);

			Assert.AreEqual (3, fields.Length, "#G1");
			Assert.AreEqual ("publicStaticGreen", fields [0].Name, "#G2");
			Assert.AreEqual ("publicStaticRed", fields [1].Name, "#G3");
			Assert.AreEqual ("publicStaticBlue", fields [2].Name, "#G4");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.FlattenHierarchy;
			fields = greenType.GetFields (flags);

			Assert.AreEqual (13, fields.Length, "#H1");
			Assert.AreEqual ("privateStaticGreen", fields [0].Name, "#H2");
			Assert.AreEqual ("familyStaticGreen", fields [1].Name, "#H3");
			Assert.AreEqual ("famANDAssemStaticGreen", fields [2].Name, "#H4");
			Assert.AreEqual ("famORAssemStaticGreen", fields [3].Name, "#H5");
			Assert.AreEqual ("assemblyStaticGreen", fields [4].Name, "#H6");
			Assert.AreEqual ("familyStaticRed", fields [5].Name, "#H7");
			Assert.AreEqual ("famANDAssemStaticRed", fields [6].Name, "#H8");
			Assert.AreEqual ("famORAssemStaticRed", fields [7].Name, "#H9");
			Assert.AreEqual ("assemblyStaticRed", fields [8].Name, "#H10");
			Assert.AreEqual ("familyStaticBlue", fields [9].Name, "#H11");
			Assert.AreEqual ("famANDAssemStaticBlue", fields [10].Name, "#H12");
			Assert.AreEqual ("famORAssemStaticBlue", fields [11].Name, "#H13");
			Assert.AreEqual ("assemblyStaticBlue", fields [12].Name, "#H14");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.DeclaredOnly;
			fields = greenType.GetFields (flags);

			Assert.AreEqual (5, fields.Length, "#I1");
			Assert.AreEqual ("privateInstanceGreen", fields [0].Name, "#I2");
			Assert.AreEqual ("familyInstanceGreen", fields [1].Name, "#I3");
			Assert.AreEqual ("famANDAssemInstanceGreen", fields [2].Name, "#I4");
			Assert.AreEqual ("famORAssemInstanceGreen", fields [3].Name, "#I5");
			Assert.AreEqual ("assemblyInstanceGreen", fields [4].Name, "#I6");

			flags = BindingFlags.Instance | BindingFlags.Public |
				BindingFlags.DeclaredOnly;
			fields = greenType.GetFields (flags);

			Assert.AreEqual (1, fields.Length, "#J1");
			Assert.AreEqual ("publicInstanceGreen", fields [0].Name, "#J2");

			flags = BindingFlags.Static | BindingFlags.Public |
				BindingFlags.DeclaredOnly;
			fields = greenType.GetFields (flags);

			Assert.AreEqual (1, fields.Length, "#K1");
			Assert.AreEqual ("publicStaticGreen", fields [0].Name, "#K2");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.DeclaredOnly;
			fields = greenType.GetFields (flags);

			Assert.AreEqual (5, fields.Length, "#L1");
			Assert.AreEqual ("privateStaticGreen", fields [0].Name, "#L2");
			Assert.AreEqual ("familyStaticGreen", fields [1].Name, "#L3");
			Assert.AreEqual ("famANDAssemStaticGreen", fields [2].Name, "#L4");
			Assert.AreEqual ("famORAssemStaticGreen", fields [3].Name, "#L5");
			Assert.AreEqual ("assemblyStaticGreen", fields [4].Name, "#L6");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.Public;
			fields = greenType.GetFields (flags);

			Assert.AreEqual (16, fields.Length, "#M1");
			Assert.AreEqual ("privateInstanceGreen", fields [0].Name, "#M2");
			Assert.AreEqual ("familyInstanceGreen", fields [1].Name, "#M3");
			Assert.AreEqual ("famANDAssemInstanceGreen", fields [2].Name, "#M4");
			Assert.AreEqual ("famORAssemInstanceGreen", fields [3].Name, "#M5");
			Assert.AreEqual ("publicInstanceGreen", fields [4].Name, "#M6");
			Assert.AreEqual ("assemblyInstanceGreen", fields [5].Name, "#M7");
			Assert.AreEqual ("familyInstanceRed", fields [6].Name, "#M8");
			Assert.AreEqual ("famANDAssemInstanceRed", fields [7].Name, "#M9");
			Assert.AreEqual ("famORAssemInstanceRed", fields [8].Name, "#M10");
			Assert.AreEqual ("publicInstanceRed", fields [9].Name, "#M11");
			Assert.AreEqual ("assemblyInstanceRed", fields [10].Name, "#M12");
			Assert.AreEqual ("familyInstanceBlue", fields [11].Name, "#M13");
			Assert.AreEqual ("famANDAssemInstanceBlue", fields [12].Name, "#M14");
			Assert.AreEqual ("famORAssemInstanceBlue", fields [13].Name, "#M15");
			Assert.AreEqual ("publicInstanceBlue", fields [14].Name, "#M16");
			Assert.AreEqual ("assemblyInstanceBlue", fields [15].Name, "#M17");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.Public;
			fields = greenType.GetFields (flags);

			Assert.AreEqual (6, fields.Length, "#N1");
			Assert.AreEqual ("privateStaticGreen", fields [0].Name, "#N2");
			Assert.AreEqual ("familyStaticGreen", fields [1].Name, "#N3");
			Assert.AreEqual ("famANDAssemStaticGreen", fields [2].Name, "#N4");
			Assert.AreEqual ("famORAssemStaticGreen", fields [3].Name, "#N5");
			Assert.AreEqual ("publicStaticGreen", fields [4].Name, "#N6");
			Assert.AreEqual ("assemblyStaticGreen", fields [5].Name, "#N7");
		}

		[Test]
		[Category ("NotWorking")] // mcs depends on this
		public void TestGetFieldIncomplete_MS ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.DefineField ("test", typeof (int), FieldAttributes.Public);
			try {
				tb.GetField ("test");
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				// The invoked member is not supported in a
				// dynamic module
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		[Category ("NotDotNet")] // mcs depends on this
		public void TestGetFieldIncomplete_Mono ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.DefineField ("TestField", typeof (int), FieldAttributes.Public);
			tb.DefineField ("OtherField", typeof (int), FieldAttributes.Private);

			FieldInfo field = tb.GetField ("TestField");
			Assert.IsNotNull (field, "#A1");
			Assert.AreEqual ("TestField", field.Name, "#A2");
			Assert.IsTrue (field is FieldBuilder, "#A3");

			Assert.IsNull (tb.GetField ("OtherField"), "#B1");
			Assert.IsNull (tb.GetField ("TestOtherField"), "#B2");
		}

		[Test]
		public void TestGetFieldComplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.DefineField ("TestField", typeof (int), FieldAttributes.Public);

			Type emittedType = tb.CreateType ();

			FieldInfo dynamicField = tb.GetField ("TestField");
			FieldInfo emittedField = emittedType.GetField ("TestField");
			Assert.IsNotNull (dynamicField, "#A1");
			Assert.AreEqual (dynamicField.Name, emittedField.Name, "#A2");
			Assert.IsNull (tb.GetField ("TestOtherField"), "#A3");
			Assert.IsFalse (emittedField is FieldBuilder, "#A4");
			Assert.IsFalse (dynamicField is FieldBuilder, "#A5");

			// bug #81638
			object value = Activator.CreateInstance (emittedType);
			emittedField.SetValue (value, 5);
			Assert.AreEqual (5, emittedField.GetValue (value), "#B1");
			Assert.AreEqual (5, dynamicField.GetValue (value), "#B2");
			dynamicField.SetValue (value, 4);
			Assert.AreEqual (4, emittedField.GetValue (value), "#B3");
			Assert.AreEqual (4, dynamicField.GetValue (value), "#B4");
		}

		[Test] // bug #81640
		public void TestGetFieldComplete_Type ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.DefineField ("TestField", typeof (int), FieldAttributes.Public);
			Type emittedType = tb.CreateType ();
			FieldInfo dynamicField = tb.GetField ("TestField");
			Assert.IsFalse (dynamicField is FieldBuilder, "#1");

			object value = Activator.CreateInstance (emittedType);
			Assert.AreEqual (0, dynamicField.GetValue (value), "#2");
		}

		[Test]
		[Category ("NotWorking")] // mcs depends on this
		public void TestGetFieldFlagsIncomplete_MS ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.DefineField ("TestField", typeof (int), FieldAttributes.Public);
			tb.DefineField ("OtherField", typeof (int), FieldAttributes.Private);
			try {
				tb.GetField ("test", BindingFlags.Public);
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				// The invoked member is not supported in a
				// dynamic module
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		[Category ("NotDotNet")] // mcs depends on this
		public void TestGetFieldFlagsIncomplete_Mono ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.DefineField ("TestField", typeof (int), FieldAttributes.Public);
			tb.DefineField ("OtherField", typeof (int), FieldAttributes.Private);

			FieldInfo field = tb.GetField ("TestField", BindingFlags.Public
				| BindingFlags.Instance);
			Assert.IsNotNull (field, "#A1");
			Assert.AreEqual ("TestField", field.Name, "#A2");
			Assert.IsTrue (field is FieldBuilder, "#A3");

			field = tb.GetField ("OtherField", BindingFlags.NonPublic |
				BindingFlags.Instance);
			Assert.IsNotNull (field, "#B1");
			Assert.AreEqual ("OtherField", field.Name, "#B2");
			Assert.IsTrue (field is FieldBuilder, "#B3");

			Assert.IsNull (tb.GetField ("TestField", BindingFlags.NonPublic |
				BindingFlags.Instance), "#C1");
			Assert.IsNull (tb.GetField ("TestField", BindingFlags.Public |
				BindingFlags.Static), "#C2");
			Assert.IsNull (tb.GetField ("OtherField", BindingFlags.Public |
				BindingFlags.Instance), "#C3");
			Assert.IsNull (tb.GetField ("OtherField", BindingFlags.Public |
				BindingFlags.Static), "#C4");
			Assert.IsNull (tb.GetField ("NotExist", BindingFlags.NonPublic |
				BindingFlags.Instance), "#C5");
			Assert.IsNull (tb.GetField ("NotExist", BindingFlags.Public |
				BindingFlags.Instance), "#C6");
		}

		[Test]
		public void TestGetFieldFlagsComplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.DefineField ("TestField", typeof (int), FieldAttributes.Public);

			Type emittedType = tb.CreateType ();

			Assert.IsNotNull (tb.GetField ("TestField", BindingFlags.Instance | BindingFlags.Public));
			Assert.AreEqual (tb.GetField ("TestField", BindingFlags.Instance | BindingFlags.Public).Name,
				emittedType.GetField ("TestField", BindingFlags.Instance | BindingFlags.Public).Name);
			Assert.IsNull (tb.GetField ("TestField", BindingFlags.Instance | BindingFlags.NonPublic));
			Assert.AreEqual (tb.GetField ("TestField", BindingFlags.Instance | BindingFlags.NonPublic),
				emittedType.GetField ("TestField", BindingFlags.Instance | BindingFlags.NonPublic));
		}

		[Test]
		public void TestGetFieldFlagsComplete_Inheritance ()
		{
			BindingFlags flags;

			TypeBuilder blueType = module.DefineType (genTypeName (),
				TypeAttributes.Public);
			CreateMembers (blueType, "Blue", false);

			TypeBuilder redType = module.DefineType (genTypeName (),
				TypeAttributes.Public, blueType);
			CreateMembers (redType, "Red", false);

			TypeBuilder greenType = module.DefineType (genTypeName (),
				TypeAttributes.Public, redType);
			CreateMembers (greenType, "Green", false);

			blueType.CreateType ();
			redType.CreateType ();
			greenType.CreateType ();

			flags = BindingFlags.Instance | BindingFlags.NonPublic;

			Assert.IsNull (greenType.GetField ("privateInstanceBlue", flags), "#A1");
			Assert.IsNotNull (greenType.GetField ("familyInstanceBlue", flags), "#A2");
			Assert.IsNotNull (greenType.GetField ("famANDAssemInstanceBlue", flags), "#A3");
			Assert.IsNotNull (greenType.GetField ("famORAssemInstanceBlue", flags), "#A4");
			Assert.IsNull (greenType.GetField ("publicInstanceBlue", flags), "#A5");
			Assert.IsNotNull (greenType.GetField ("assemblyInstanceBlue", flags), "#A6");
			Assert.IsNull (greenType.GetField ("privateInstanceRed", flags), "#A7");
			Assert.IsNotNull (greenType.GetField ("familyInstanceRed", flags), "#A8");
			Assert.IsNotNull (greenType.GetField ("famANDAssemInstanceRed", flags), "#A9");
			Assert.IsNotNull (greenType.GetField ("famORAssemInstanceRed", flags), "#A10");
			Assert.IsNull (greenType.GetField ("publicInstanceRed", flags), "#A11");
			Assert.IsNotNull (greenType.GetField ("assemblyInstanceRed", flags), "#A12");
			Assert.IsNotNull (greenType.GetField ("privateInstanceGreen", flags), "#A13");
			Assert.IsNotNull (greenType.GetField ("familyInstanceGreen", flags), "#A14");
			Assert.IsNotNull (greenType.GetField ("famANDAssemInstanceGreen", flags), "#A15");
			Assert.IsNotNull (greenType.GetField ("famORAssemInstanceGreen", flags), "#A16");
			Assert.IsNull (greenType.GetField ("publicInstanceGreen", flags), "#A17");
			Assert.IsNotNull (greenType.GetField ("assemblyInstanceGreen", flags), "#A18");
			Assert.IsNull (greenType.GetField ("privateStaticBlue", flags), "#A19");
			Assert.IsNull (greenType.GetField ("familyStaticBlue", flags), "#A20");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticBlue", flags), "#A21");
			Assert.IsNull (greenType.GetField ("famORAssemStaticBlue", flags), "#A22");
			Assert.IsNull (greenType.GetField ("publicStaticBlue", flags), "#A23");
			Assert.IsNull (greenType.GetField ("assemblyStaticBlue", flags), "#A24");
			Assert.IsNull (greenType.GetField ("privateStaticRed", flags), "#A25");
			Assert.IsNull (greenType.GetField ("familyStaticRed", flags), "#A26");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticRed", flags), "#A27");
			Assert.IsNull (greenType.GetField ("famORAssemStaticRed", flags), "#A28");
			Assert.IsNull (greenType.GetField ("publicStaticRed", flags), "#A29");
			Assert.IsNull (greenType.GetField ("assemblyStaticRed", flags), "#A30");
			Assert.IsNull (greenType.GetField ("privateStaticGreen", flags), "#A31");
			Assert.IsNull (greenType.GetField ("familyStaticGreen", flags), "#A32");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticGreen", flags), "#A33");
			Assert.IsNull (greenType.GetField ("famORAssemStaticGreen", flags), "#A34");
			Assert.IsNull (greenType.GetField ("publicStaticGreen", flags), "#A35");
			Assert.IsNull (greenType.GetField ("assemblyStaticGreen", flags), "#A36");

			flags = BindingFlags.Instance | BindingFlags.Public;

			Assert.IsNull (greenType.GetField ("privateInstanceBlue", flags), "#B1");
			Assert.IsNull (greenType.GetField ("familyInstanceBlue", flags), "#B2");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceBlue", flags), "#B3");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceBlue", flags), "#B4");
			Assert.IsNotNull (greenType.GetField ("publicInstanceBlue", flags), "#B5");
			Assert.IsNull (greenType.GetField ("assemblyInstanceBlue", flags), "#B6");
			Assert.IsNull (greenType.GetField ("privateInstanceRed", flags), "#B7");
			Assert.IsNull (greenType.GetField ("familyInstanceRed", flags), "#B8");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceRed", flags), "#B9");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceRed", flags), "#B10");
			Assert.IsNotNull (greenType.GetField ("publicInstanceRed", flags), "#B11");
			Assert.IsNull (greenType.GetField ("assemblyInstanceRed", flags), "#B12");
			Assert.IsNull (greenType.GetField ("privateInstanceGreen", flags), "#B13");
			Assert.IsNull (greenType.GetField ("familyInstanceGreen", flags), "#B14");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceGreen", flags), "#B15");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceGreen", flags), "#B16");
			Assert.IsNotNull (greenType.GetField ("publicInstanceGreen", flags), "#B17");
			Assert.IsNull (greenType.GetField ("assemblyInstanceGreen", flags), "#B18");
			Assert.IsNull (greenType.GetField ("privateStaticBlue", flags), "#B19");
			Assert.IsNull (greenType.GetField ("familyStaticBlue", flags), "#B20");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticBlue", flags), "#B21");
			Assert.IsNull (greenType.GetField ("famORAssemStaticBlue", flags), "#B22");
			Assert.IsNull (greenType.GetField ("publicStaticBlue", flags), "#B23");
			Assert.IsNull (greenType.GetField ("assemblyStaticBlue", flags), "#B24");
			Assert.IsNull (greenType.GetField ("privateStaticRed", flags), "#B25");
			Assert.IsNull (greenType.GetField ("familyStaticRed", flags), "#B26");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticRed", flags), "#B27");
			Assert.IsNull (greenType.GetField ("famORAssemStaticRed", flags), "#B28");
			Assert.IsNull (greenType.GetField ("publicStaticRed", flags), "#B29");
			Assert.IsNull (greenType.GetField ("assemblyStaticRed", flags), "#B30");
			Assert.IsNull (greenType.GetField ("privateStaticGreen", flags), "#B31");
			Assert.IsNull (greenType.GetField ("familyStaticGreen", flags), "#B32");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticGreen", flags), "#B33");
			Assert.IsNull (greenType.GetField ("famORAssemStaticGreen", flags), "#B34");
			Assert.IsNull (greenType.GetField ("publicStaticGreen", flags), "#B35");
			Assert.IsNull (greenType.GetField ("assemblyStaticGreen", flags), "#B36");

			flags = BindingFlags.Static | BindingFlags.Public;

			Assert.IsNull (greenType.GetField ("privateInstanceBlue", flags), "#C1");
			Assert.IsNull (greenType.GetField ("familyInstanceBlue", flags), "#C2");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceBlue", flags), "#C3");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceBlue", flags), "#C4");
			Assert.IsNull (greenType.GetField ("publicInstanceBlue", flags), "#C5");
			Assert.IsNull (greenType.GetField ("assemblyInstanceBlue", flags), "#C6");
			Assert.IsNull (greenType.GetField ("privateInstanceRed", flags), "#C7");
			Assert.IsNull (greenType.GetField ("familyInstanceRed", flags), "#C8");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceRed", flags), "#C9");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceRed", flags), "#C10");
			Assert.IsNull (greenType.GetField ("publicInstanceRed", flags), "#C11");
			Assert.IsNull (greenType.GetField ("assemblyInstanceRed", flags), "#C12");
			Assert.IsNull (greenType.GetField ("privateInstanceGreen", flags), "#C13");
			Assert.IsNull (greenType.GetField ("familyInstanceGreen", flags), "#C14");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceGreen", flags), "#C15");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceGreen", flags), "#C16");
			Assert.IsNull (greenType.GetField ("publicInstanceGreen", flags), "#C17");
			Assert.IsNull (greenType.GetField ("assemblyInstanceGreen", flags), "#C18");
			Assert.IsNull (greenType.GetField ("privateStaticBlue", flags), "#C19");
			Assert.IsNull (greenType.GetField ("familyStaticBlue", flags), "#C20");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticBlue", flags), "#C21");
			Assert.IsNull (greenType.GetField ("famORAssemStaticBlue", flags), "#C22");
			Assert.IsNull (greenType.GetField ("publicStaticBlue", flags), "#C23");
			Assert.IsNull (greenType.GetField ("assemblyStaticBlue", flags), "#C24");
			Assert.IsNull (greenType.GetField ("privateStaticRed", flags), "#C25");
			Assert.IsNull (greenType.GetField ("familyStaticRed", flags), "#C26");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticRed", flags), "#C27");
			Assert.IsNull (greenType.GetField ("famORAssemStaticRed", flags), "#C28");
			Assert.IsNull (greenType.GetField ("publicStaticRed", flags), "#C29");
			Assert.IsNull (greenType.GetField ("assemblyStaticRed", flags), "#C30");
			Assert.IsNull (greenType.GetField ("privateStaticGreen", flags), "#C31");
			Assert.IsNull (greenType.GetField ("familyStaticGreen", flags), "#C32");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticGreen", flags), "#C33");
			Assert.IsNull (greenType.GetField ("famORAssemStaticGreen", flags), "#C34");
			Assert.IsNotNull (greenType.GetField ("publicStaticGreen", flags), "#C35");
			Assert.IsNull (greenType.GetField ("assemblyStaticGreen", flags), "#C36");

			flags = BindingFlags.Static | BindingFlags.NonPublic;

			Assert.IsNull (greenType.GetField ("privateInstanceBlue", flags), "#D1");
			Assert.IsNull (greenType.GetField ("familyInstanceBlue", flags), "#D2");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceBlue", flags), "#D3");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceBlue", flags), "#D4");
			Assert.IsNull (greenType.GetField ("publicInstanceBlue", flags), "#D5");
			Assert.IsNull (greenType.GetField ("assemblyInstanceBlue", flags), "#D6");
			Assert.IsNull (greenType.GetField ("privateInstanceRed", flags), "#D7");
			Assert.IsNull (greenType.GetField ("familyInstanceRed", flags), "#D8");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceRed", flags), "#D9");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceRed", flags), "#D10");
			Assert.IsNull (greenType.GetField ("publicInstanceRed", flags), "#D11");
			Assert.IsNull (greenType.GetField ("assemblyInstanceRed", flags), "#D12");
			Assert.IsNull (greenType.GetField ("privateInstanceGreen", flags), "#D13");
			Assert.IsNull (greenType.GetField ("familyInstanceGreen", flags), "#D14");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceGreen", flags), "#D15");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceGreen", flags), "#D16");
			Assert.IsNull (greenType.GetField ("publicInstanceGreen", flags), "#D17");
			Assert.IsNull (greenType.GetField ("assemblyInstanceGreen", flags), "#D18");
			Assert.IsNull (greenType.GetField ("privateStaticBlue", flags), "#D19");
			Assert.IsNull (greenType.GetField ("familyStaticBlue", flags), "#D20");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticBlue", flags), "#D21");
			Assert.IsNull (greenType.GetField ("famORAssemStaticBlue", flags), "#D22");
			Assert.IsNull (greenType.GetField ("publicStaticBlue", flags), "#D23");
			Assert.IsNull (greenType.GetField ("assemblyStaticBlue", flags), "#D24");
			Assert.IsNull (greenType.GetField ("privateStaticRed", flags), "#D25");
			Assert.IsNull (greenType.GetField ("familyStaticRed", flags), "#D26");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticRed", flags), "#D27");
			Assert.IsNull (greenType.GetField ("famORAssemStaticRed", flags), "#D28");
			Assert.IsNull (greenType.GetField ("publicStaticRed", flags), "#D29");
			Assert.IsNull (greenType.GetField ("assemblyStaticRed", flags), "#D30");
			Assert.IsNotNull (greenType.GetField ("privateStaticGreen", flags), "#D31");
			Assert.IsNotNull (greenType.GetField ("familyStaticGreen", flags), "#D32");
			Assert.IsNotNull (greenType.GetField ("famANDAssemStaticGreen", flags), "#D33");
			Assert.IsNotNull (greenType.GetField ("famORAssemStaticGreen", flags), "#D34");
			Assert.IsNull (greenType.GetField ("publicStaticGreen", flags), "#D35");
			Assert.IsNotNull (greenType.GetField ("assemblyStaticGreen", flags), "#D36");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.FlattenHierarchy;

			Assert.IsNull (greenType.GetField ("privateInstanceBlue", flags), "#E1");
			Assert.IsNotNull (greenType.GetField ("familyInstanceBlue", flags), "#E2");
			Assert.IsNotNull (greenType.GetField ("famANDAssemInstanceBlue", flags), "#E3");
			Assert.IsNotNull (greenType.GetField ("famORAssemInstanceBlue", flags), "#E4");
			Assert.IsNull (greenType.GetField ("publicInstanceBlue", flags), "#E5");
			Assert.IsNotNull (greenType.GetField ("assemblyInstanceBlue", flags), "#E6");
			Assert.IsNull (greenType.GetField ("privateInstanceRed", flags), "#E7");
			Assert.IsNotNull (greenType.GetField ("familyInstanceRed", flags), "#E8");
			Assert.IsNotNull (greenType.GetField ("famANDAssemInstanceRed", flags), "#E9");
			Assert.IsNotNull (greenType.GetField ("famORAssemInstanceRed", flags), "#E10");
			Assert.IsNull (greenType.GetField ("publicInstanceRed", flags), "#E11");
			Assert.IsNotNull (greenType.GetField ("assemblyInstanceRed", flags), "#E12");
			Assert.IsNotNull (greenType.GetField ("privateInstanceGreen", flags), "#E13");
			Assert.IsNotNull (greenType.GetField ("familyInstanceGreen", flags), "#E14");
			Assert.IsNotNull (greenType.GetField ("famANDAssemInstanceGreen", flags), "#E15");
			Assert.IsNotNull (greenType.GetField ("famORAssemInstanceGreen", flags), "#E16");
			Assert.IsNull (greenType.GetField ("publicInstanceGreen", flags), "#E17");
			Assert.IsNotNull (greenType.GetField ("assemblyInstanceGreen", flags), "#E18");
			Assert.IsNull (greenType.GetField ("privateStaticBlue", flags), "#E19");
			Assert.IsNull (greenType.GetField ("familyStaticBlue", flags), "#E20");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticBlue", flags), "#E21");
			Assert.IsNull (greenType.GetField ("famORAssemStaticBlue", flags), "#E22");
			Assert.IsNull (greenType.GetField ("publicStaticBlue", flags), "#E23");
			Assert.IsNull (greenType.GetField ("assemblyStaticBlue", flags), "#E24");
			Assert.IsNull (greenType.GetField ("privateStaticRed", flags), "#E25");
			Assert.IsNull (greenType.GetField ("familyStaticRed", flags), "#E26");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticRed", flags), "#E27");
			Assert.IsNull (greenType.GetField ("famORAssemStaticRed", flags), "#E28");
			Assert.IsNull (greenType.GetField ("publicStaticRed", flags), "#E29");
			Assert.IsNull (greenType.GetField ("assemblyStaticRed", flags), "#E30");
			Assert.IsNull (greenType.GetField ("privateStaticGreen", flags), "#E31");
			Assert.IsNull (greenType.GetField ("familyStaticGreen", flags), "#E32");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticGreen", flags), "#E33");
			Assert.IsNull (greenType.GetField ("famORAssemStaticGreen", flags), "#E34");
			Assert.IsNull (greenType.GetField ("publicStaticGreen", flags), "#E35");
			Assert.IsNull (greenType.GetField ("assemblyStaticGreen", flags), "#E36");

			flags = BindingFlags.Instance | BindingFlags.Public |
				BindingFlags.FlattenHierarchy;

			Assert.IsNull (greenType.GetField ("privateInstanceBlue", flags), "#F1");
			Assert.IsNull (greenType.GetField ("familyInstanceBlue", flags), "#F2");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceBlue", flags), "#F3");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceBlue", flags), "#F4");
			Assert.IsNotNull (greenType.GetField ("publicInstanceBlue", flags), "#F5");
			Assert.IsNull (greenType.GetField ("assemblyInstanceBlue", flags), "#F6");
			Assert.IsNull (greenType.GetField ("privateInstanceRed", flags), "#F7");
			Assert.IsNull (greenType.GetField ("familyInstanceRed", flags), "#F8");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceRed", flags), "#F9");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceRed", flags), "#F10");
			Assert.IsNotNull (greenType.GetField ("publicInstanceRed", flags), "#F11");
			Assert.IsNull (greenType.GetField ("assemblyInstanceRed", flags), "#F12");
			Assert.IsNull (greenType.GetField ("privateInstanceGreen", flags), "#F13");
			Assert.IsNull (greenType.GetField ("familyInstanceGreen", flags), "#F14");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceGreen", flags), "#F15");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceGreen", flags), "#F16");
			Assert.IsNotNull (greenType.GetField ("publicInstanceGreen", flags), "#F17");
			Assert.IsNull (greenType.GetField ("assemblyInstanceGreen", flags), "#F18");
			Assert.IsNull (greenType.GetField ("privateStaticBlue", flags), "#F19");
			Assert.IsNull (greenType.GetField ("familyStaticBlue", flags), "#F20");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticBlue", flags), "#F21");
			Assert.IsNull (greenType.GetField ("famORAssemStaticBlue", flags), "#F22");
			Assert.IsNull (greenType.GetField ("publicStaticBlue", flags), "#F23");
			Assert.IsNull (greenType.GetField ("assemblyStaticBlue", flags), "#F24");
			Assert.IsNull (greenType.GetField ("privateStaticRed", flags), "#F25");
			Assert.IsNull (greenType.GetField ("familyStaticRed", flags), "#F26");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticRed", flags), "#F27");
			Assert.IsNull (greenType.GetField ("famORAssemStaticRed", flags), "#F28");
			Assert.IsNull (greenType.GetField ("publicStaticRed", flags), "#F29");
			Assert.IsNull (greenType.GetField ("assemblyStaticRed", flags), "#F30");
			Assert.IsNull (greenType.GetField ("privateStaticGreen", flags), "#F31");
			Assert.IsNull (greenType.GetField ("familyStaticGreen", flags), "#F32");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticGreen", flags), "#F33");
			Assert.IsNull (greenType.GetField ("famORAssemStaticGreen", flags), "#F34");
			Assert.IsNull (greenType.GetField ("publicStaticGreen", flags), "#F35");
			Assert.IsNull (greenType.GetField ("assemblyStaticGreen", flags), "#F36");

			flags = BindingFlags.Static | BindingFlags.Public |
				BindingFlags.FlattenHierarchy;

			Assert.IsNull (greenType.GetField ("privateInstanceBlue", flags), "#G1");
			Assert.IsNull (greenType.GetField ("familyInstanceBlue", flags), "#G2");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceBlue", flags), "#G3");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceBlue", flags), "#G4");
			Assert.IsNull (greenType.GetField ("publicInstanceBlue", flags), "#G5");
			Assert.IsNull (greenType.GetField ("assemblyInstanceBlue", flags), "#G6");
			Assert.IsNull (greenType.GetField ("privateInstanceRed", flags), "#G7");
			Assert.IsNull (greenType.GetField ("familyInstanceRed", flags), "#G8");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceRed", flags), "#G9");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceRed", flags), "#G10");
			Assert.IsNull (greenType.GetField ("publicInstanceRed", flags), "#G11");
			Assert.IsNull (greenType.GetField ("assemblyInstanceRed", flags), "#G12");
			Assert.IsNull (greenType.GetField ("privateInstanceGreen", flags), "#G13");
			Assert.IsNull (greenType.GetField ("familyInstanceGreen", flags), "#G14");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceGreen", flags), "#G15");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceGreen", flags), "#G16");
			Assert.IsNull (greenType.GetField ("publicInstanceGreen", flags), "#G17");
			Assert.IsNull (greenType.GetField ("assemblyInstanceGreen", flags), "#G18");
			Assert.IsNull (greenType.GetField ("privateStaticBlue", flags), "#G19");
			Assert.IsNull (greenType.GetField ("familyStaticBlue", flags), "#G20");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticBlue", flags), "#G21");
			Assert.IsNull (greenType.GetField ("famORAssemStaticBlue", flags), "#G22");
			Assert.IsNotNull (greenType.GetField ("publicStaticBlue", flags), "#G23");
			Assert.IsNull (greenType.GetField ("assemblyStaticBlue", flags), "#G24");
			Assert.IsNull (greenType.GetField ("privateStaticRed", flags), "#G25");
			Assert.IsNull (greenType.GetField ("familyStaticRed", flags), "#G26");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticRed", flags), "#G27");
			Assert.IsNull (greenType.GetField ("famORAssemStaticRed", flags), "#G28");
			Assert.IsNotNull (greenType.GetField ("publicStaticRed", flags), "#G29");
			Assert.IsNull (greenType.GetField ("assemblyStaticRed", flags), "#G30");
			Assert.IsNull (greenType.GetField ("privateStaticGreen", flags), "#G31");
			Assert.IsNull (greenType.GetField ("familyStaticGreen", flags), "#G32");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticGreen", flags), "#G33");
			Assert.IsNull (greenType.GetField ("famORAssemStaticGreen", flags), "#G34");
			Assert.IsNotNull (greenType.GetField ("publicStaticGreen", flags), "#G35");
			Assert.IsNull (greenType.GetField ("assemblyStaticGreen", flags), "#G36");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.FlattenHierarchy;

			Assert.IsNull (greenType.GetField ("privateInstanceBlue", flags), "#H1");
			Assert.IsNull (greenType.GetField ("familyInstanceBlue", flags), "#H2");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceBlue", flags), "#H3");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceBlue", flags), "#H4");
			Assert.IsNull (greenType.GetField ("publicInstanceBlue", flags), "#H5");
			Assert.IsNull (greenType.GetField ("assemblyInstanceBlue", flags), "#H6");
			Assert.IsNull (greenType.GetField ("privateInstanceRed", flags), "#H7");
			Assert.IsNull (greenType.GetField ("familyInstanceRed", flags), "#H8");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceRed", flags), "#H9");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceRed", flags), "#H10");
			Assert.IsNull (greenType.GetField ("publicInstanceRed", flags), "#H11");
			Assert.IsNull (greenType.GetField ("assemblyInstanceRed", flags), "#H12");
			Assert.IsNull (greenType.GetField ("privateInstanceGreen", flags), "#H13");
			Assert.IsNull (greenType.GetField ("familyInstanceGreen", flags), "#H14");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceGreen", flags), "#H15");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceGreen", flags), "#H16");
			Assert.IsNull (greenType.GetField ("publicInstanceGreen", flags), "#H17");
			Assert.IsNull (greenType.GetField ("assemblyInstanceGreen", flags), "#H18");
			Assert.IsNull (greenType.GetField ("privateStaticBlue", flags), "#H19");
			Assert.IsNotNull (greenType.GetField ("familyStaticBlue", flags), "#H20");
			Assert.IsNotNull (greenType.GetField ("famANDAssemStaticBlue", flags), "#H21");
			Assert.IsNotNull (greenType.GetField ("famORAssemStaticBlue", flags), "#H22");
			Assert.IsNull (greenType.GetField ("publicStaticBlue", flags), "#H23");
			Assert.IsNotNull (greenType.GetField ("assemblyStaticBlue", flags), "#H24");
			Assert.IsNull (greenType.GetField ("privateStaticRed", flags), "#H25");
			Assert.IsNotNull (greenType.GetField ("familyStaticRed", flags), "#H26");
			Assert.IsNotNull (greenType.GetField ("famANDAssemStaticRed", flags), "#H27");
			Assert.IsNotNull (greenType.GetField ("famORAssemStaticRed", flags), "#H28");
			Assert.IsNull (greenType.GetField ("publicStaticRed", flags), "#H29");
			Assert.IsNotNull (greenType.GetField ("assemblyStaticRed", flags), "#H30");
			Assert.IsNotNull (greenType.GetField ("privateStaticGreen", flags), "#H31");
			Assert.IsNotNull (greenType.GetField ("familyStaticGreen", flags), "#H32");
			Assert.IsNotNull (greenType.GetField ("famANDAssemStaticGreen", flags), "#H33");
			Assert.IsNotNull (greenType.GetField ("famORAssemStaticGreen", flags), "#H34");
			Assert.IsNull (greenType.GetField ("publicStaticGreen", flags), "#H35");
			Assert.IsNotNull (greenType.GetField ("assemblyStaticGreen", flags), "#H36");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.DeclaredOnly;

			Assert.IsNull (greenType.GetField ("privateInstanceBlue", flags), "#I1");
			Assert.IsNull (greenType.GetField ("familyInstanceBlue", flags), "#I2");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceBlue", flags), "#I3");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceBlue", flags), "#I4");
			Assert.IsNull (greenType.GetField ("publicInstanceBlue", flags), "#I5");
			Assert.IsNull (greenType.GetField ("assemblyInstanceBlue", flags), "#I6");
			Assert.IsNull (greenType.GetField ("privateInstanceRed", flags), "#I7");
			Assert.IsNull (greenType.GetField ("familyInstanceRed", flags), "#I8");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceRed", flags), "#I9");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceRed", flags), "#I10");
			Assert.IsNull (greenType.GetField ("publicInstanceRed", flags), "#I11");
			Assert.IsNull (greenType.GetField ("assemblyInstanceRed", flags), "#I12");
			Assert.IsNotNull (greenType.GetField ("privateInstanceGreen", flags), "#I13");
			Assert.IsNotNull (greenType.GetField ("familyInstanceGreen", flags), "#I14");
			Assert.IsNotNull (greenType.GetField ("famANDAssemInstanceGreen", flags), "#I15");
			Assert.IsNotNull (greenType.GetField ("famORAssemInstanceGreen", flags), "#I16");
			Assert.IsNull (greenType.GetField ("publicInstanceGreen", flags), "#I17");
			Assert.IsNotNull (greenType.GetField ("assemblyInstanceGreen", flags), "#I18");
			Assert.IsNull (greenType.GetField ("privateStaticBlue", flags), "#I19");
			Assert.IsNull (greenType.GetField ("familyStaticBlue", flags), "#I20");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticBlue", flags), "#I21");
			Assert.IsNull (greenType.GetField ("famORAssemStaticBlue", flags), "#I22");
			Assert.IsNull (greenType.GetField ("publicStaticBlue", flags), "#I23");
			Assert.IsNull (greenType.GetField ("assemblyStaticBlue", flags), "#I24");
			Assert.IsNull (greenType.GetField ("privateStaticRed", flags), "#I25");
			Assert.IsNull (greenType.GetField ("familyStaticRed", flags), "#I26");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticRed", flags), "#I27");
			Assert.IsNull (greenType.GetField ("famORAssemStaticRed", flags), "#I28");
			Assert.IsNull (greenType.GetField ("publicStaticRed", flags), "#I29");
			Assert.IsNull (greenType.GetField ("assemblyStaticRed", flags), "#I30");
			Assert.IsNull (greenType.GetField ("privateStaticGreen", flags), "#I31");
			Assert.IsNull (greenType.GetField ("familyStaticGreen", flags), "#I32");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticGreen", flags), "#I33");
			Assert.IsNull (greenType.GetField ("famORAssemStaticGreen", flags), "#I34");
			Assert.IsNull (greenType.GetField ("publicStaticGreen", flags), "#I35");
			Assert.IsNull (greenType.GetField ("assemblyStaticGreen", flags), "#I36");

			flags = BindingFlags.Instance | BindingFlags.Public |
				BindingFlags.DeclaredOnly;

			Assert.IsNull (greenType.GetField ("privateInstanceBlue", flags), "#J1");
			Assert.IsNull (greenType.GetField ("familyInstanceBlue", flags), "#J2");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceBlue", flags), "#J3");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceBlue", flags), "#J4");
			Assert.IsNull (greenType.GetField ("publicInstanceBlue", flags), "#J5");
			Assert.IsNull (greenType.GetField ("assemblyInstanceBlue", flags), "#J6");
			Assert.IsNull (greenType.GetField ("privateInstanceRed", flags), "#J7");
			Assert.IsNull (greenType.GetField ("familyInstanceRed", flags), "#J8");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceRed", flags), "#J9");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceRed", flags), "#J10");
			Assert.IsNull (greenType.GetField ("publicInstanceRed", flags), "#J11");
			Assert.IsNull (greenType.GetField ("assemblyInstanceRed", flags), "#J12");
			Assert.IsNull (greenType.GetField ("privateInstanceGreen", flags), "#J13");
			Assert.IsNull (greenType.GetField ("familyInstanceGreen", flags), "#J14");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceGreen", flags), "#J15");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceGreen", flags), "#J16");
			Assert.IsNotNull (greenType.GetField ("publicInstanceGreen", flags), "#J17");
			Assert.IsNull (greenType.GetField ("assemblyInstanceGreen", flags), "#J18");
			Assert.IsNull (greenType.GetField ("privateStaticBlue", flags), "#J19");
			Assert.IsNull (greenType.GetField ("familyStaticBlue", flags), "#J20");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticBlue", flags), "#J21");
			Assert.IsNull (greenType.GetField ("famORAssemStaticBlue", flags), "#J22");
			Assert.IsNull (greenType.GetField ("publicStaticBlue", flags), "#J23");
			Assert.IsNull (greenType.GetField ("assemblyStaticBlue", flags), "#J24");
			Assert.IsNull (greenType.GetField ("privateStaticRed", flags), "#J25");
			Assert.IsNull (greenType.GetField ("familyStaticRed", flags), "#J26");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticRed", flags), "#J27");
			Assert.IsNull (greenType.GetField ("famORAssemStaticRed", flags), "#J28");
			Assert.IsNull (greenType.GetField ("publicStaticRed", flags), "#J29");
			Assert.IsNull (greenType.GetField ("assemblyStaticRed", flags), "#J30");
			Assert.IsNull (greenType.GetField ("privateStaticGreen", flags), "#J31");
			Assert.IsNull (greenType.GetField ("familyStaticGreen", flags), "#J32");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticGreen", flags), "#J33");
			Assert.IsNull (greenType.GetField ("famORAssemStaticGreen", flags), "#J34");
			Assert.IsNull (greenType.GetField ("publicStaticGreen", flags), "#J35");
			Assert.IsNull (greenType.GetField ("assemblyStaticGreen", flags), "#J36");

			flags = BindingFlags.Static | BindingFlags.Public |
				BindingFlags.DeclaredOnly;

			Assert.IsNull (greenType.GetField ("privateInstanceBlue", flags), "#K1");
			Assert.IsNull (greenType.GetField ("familyInstanceBlue", flags), "#K2");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceBlue", flags), "#K3");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceBlue", flags), "#K4");
			Assert.IsNull (greenType.GetField ("publicInstanceBlue", flags), "#K5");
			Assert.IsNull (greenType.GetField ("assemblyInstanceBlue", flags), "#K6");
			Assert.IsNull (greenType.GetField ("privateInstanceRed", flags), "#K7");
			Assert.IsNull (greenType.GetField ("familyInstanceRed", flags), "#K8");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceRed", flags), "#K9");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceRed", flags), "#K10");
			Assert.IsNull (greenType.GetField ("publicInstanceRed", flags), "#K11");
			Assert.IsNull (greenType.GetField ("assemblyInstanceRed", flags), "#K12");
			Assert.IsNull (greenType.GetField ("privateInstanceGreen", flags), "#K13");
			Assert.IsNull (greenType.GetField ("familyInstanceGreen", flags), "#K14");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceGreen", flags), "#K15");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceGreen", flags), "#K16");
			Assert.IsNull (greenType.GetField ("publicInstanceGreen", flags), "#K17");
			Assert.IsNull (greenType.GetField ("assemblyInstanceGreen", flags), "#K18");
			Assert.IsNull (greenType.GetField ("privateStaticBlue", flags), "#K19");
			Assert.IsNull (greenType.GetField ("familyStaticBlue", flags), "#K20");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticBlue", flags), "#K21");
			Assert.IsNull (greenType.GetField ("famORAssemStaticBlue", flags), "#K22");
			Assert.IsNull (greenType.GetField ("publicStaticBlue", flags), "#K23");
			Assert.IsNull (greenType.GetField ("assemblyStaticBlue", flags), "#K24");
			Assert.IsNull (greenType.GetField ("privateStaticRed", flags), "#K25");
			Assert.IsNull (greenType.GetField ("familyStaticRed", flags), "#K26");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticRed", flags), "#K27");
			Assert.IsNull (greenType.GetField ("famORAssemStaticRed", flags), "#K28");
			Assert.IsNull (greenType.GetField ("publicStaticRed", flags), "#K29");
			Assert.IsNull (greenType.GetField ("assemblyStaticRed", flags), "#K30");
			Assert.IsNull (greenType.GetField ("privateStaticGreen", flags), "#K31");
			Assert.IsNull (greenType.GetField ("familyStaticGreen", flags), "#K32");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticGreen", flags), "#K33");
			Assert.IsNull (greenType.GetField ("famORAssemStaticGreen", flags), "#K34");
			Assert.IsNotNull (greenType.GetField ("publicStaticGreen", flags), "#K35");
			Assert.IsNull (greenType.GetField ("assemblyStaticGreen", flags), "#K36");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.DeclaredOnly;

			Assert.IsNull (greenType.GetField ("privateInstanceBlue", flags), "#L1");
			Assert.IsNull (greenType.GetField ("familyInstanceBlue", flags), "#L2");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceBlue", flags), "#L3");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceBlue", flags), "#L4");
			Assert.IsNull (greenType.GetField ("publicInstanceBlue", flags), "#L5");
			Assert.IsNull (greenType.GetField ("assemblyInstanceBlue", flags), "#L6");
			Assert.IsNull (greenType.GetField ("privateInstanceRed", flags), "#L7");
			Assert.IsNull (greenType.GetField ("familyInstanceRed", flags), "#L8");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceRed", flags), "#L9");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceRed", flags), "#L10");
			Assert.IsNull (greenType.GetField ("publicInstanceRed", flags), "#L11");
			Assert.IsNull (greenType.GetField ("assemblyInstanceRed", flags), "#L12");
			Assert.IsNull (greenType.GetField ("privateInstanceGreen", flags), "#L13");
			Assert.IsNull (greenType.GetField ("familyInstanceGreen", flags), "#L14");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceGreen", flags), "#L15");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceGreen", flags), "#L16");
			Assert.IsNull (greenType.GetField ("publicInstanceGreen", flags), "#L17");
			Assert.IsNull (greenType.GetField ("assemblyInstanceGreen", flags), "#L18");
			Assert.IsNull (greenType.GetField ("privateStaticBlue", flags), "#L19");
			Assert.IsNull (greenType.GetField ("familyStaticBlue", flags), "#L20");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticBlue", flags), "#L21");
			Assert.IsNull (greenType.GetField ("famORAssemStaticBlue", flags), "#L22");
			Assert.IsNull (greenType.GetField ("publicStaticBlue", flags), "#L23");
			Assert.IsNull (greenType.GetField ("assemblyStaticBlue", flags), "#L24");
			Assert.IsNull (greenType.GetField ("privateStaticRed", flags), "#L25");
			Assert.IsNull (greenType.GetField ("familyStaticRed", flags), "#L26");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticRed", flags), "#L27");
			Assert.IsNull (greenType.GetField ("famORAssemStaticRed", flags), "#L28");
			Assert.IsNull (greenType.GetField ("publicStaticRed", flags), "#L29");
			Assert.IsNull (greenType.GetField ("assemblyStaticRed", flags), "#L30");
			Assert.IsNotNull (greenType.GetField ("privateStaticGreen", flags), "#L31");
			Assert.IsNotNull (greenType.GetField ("familyStaticGreen", flags), "#L32");
			Assert.IsNotNull (greenType.GetField ("famANDAssemStaticGreen", flags), "#L33");
			Assert.IsNotNull (greenType.GetField ("famORAssemStaticGreen", flags), "#L34");
			Assert.IsNull (greenType.GetField ("publicStaticGreen", flags), "#L35");
			Assert.IsNotNull (greenType.GetField ("assemblyStaticGreen", flags), "#L36");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.Public;

			Assert.IsNull (greenType.GetField ("privateInstanceBlue", flags), "#M1");
			Assert.IsNotNull (greenType.GetField ("familyInstanceBlue", flags), "#M2");
			Assert.IsNotNull (greenType.GetField ("famANDAssemInstanceBlue", flags), "#M3");
			Assert.IsNotNull (greenType.GetField ("famORAssemInstanceBlue", flags), "#M4");
			Assert.IsNotNull (greenType.GetField ("publicInstanceBlue", flags), "#M5");
			Assert.IsNotNull (greenType.GetField ("assemblyInstanceBlue", flags), "#M6");
			Assert.IsNull (greenType.GetField ("privateInstanceRed", flags), "#M7");
			Assert.IsNotNull (greenType.GetField ("familyInstanceRed", flags), "#M8");
			Assert.IsNotNull (greenType.GetField ("famANDAssemInstanceRed", flags), "#M9");
			Assert.IsNotNull (greenType.GetField ("famORAssemInstanceRed", flags), "#M10");
			Assert.IsNotNull (greenType.GetField ("publicInstanceRed", flags), "#M11");
			Assert.IsNotNull (greenType.GetField ("assemblyInstanceRed", flags), "#M12");
			Assert.IsNotNull (greenType.GetField ("privateInstanceGreen", flags), "#M13");
			Assert.IsNotNull (greenType.GetField ("familyInstanceGreen", flags), "#M14");
			Assert.IsNotNull (greenType.GetField ("famANDAssemInstanceGreen", flags), "#M15");
			Assert.IsNotNull (greenType.GetField ("famORAssemInstanceGreen", flags), "#M16");
			Assert.IsNotNull (greenType.GetField ("publicInstanceGreen", flags), "#M17");
			Assert.IsNotNull (greenType.GetField ("assemblyInstanceGreen", flags), "#M18");
			Assert.IsNull (greenType.GetField ("privateStaticBlue", flags), "#M19");
			Assert.IsNull (greenType.GetField ("familyStaticBlue", flags), "#M20");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticBlue", flags), "#M21");
			Assert.IsNull (greenType.GetField ("famORAssemStaticBlue", flags), "#M22");
			Assert.IsNull (greenType.GetField ("publicStaticBlue", flags), "#M23");
			Assert.IsNull (greenType.GetField ("assemblyStaticBlue", flags), "#M24");
			Assert.IsNull (greenType.GetField ("privateStaticRed", flags), "#M25");
			Assert.IsNull (greenType.GetField ("familyStaticRed", flags), "#M26");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticRed", flags), "#M27");
			Assert.IsNull (greenType.GetField ("famORAssemStaticRed", flags), "#M28");
			Assert.IsNull (greenType.GetField ("publicStaticRed", flags), "#M29");
			Assert.IsNull (greenType.GetField ("assemblyStaticRed", flags), "#M30");
			Assert.IsNull (greenType.GetField ("privateStaticGreen", flags), "#M31");
			Assert.IsNull (greenType.GetField ("familyStaticGreen", flags), "#M32");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticGreen", flags), "#M33");
			Assert.IsNull (greenType.GetField ("famORAssemStaticGreen", flags), "#M34");
			Assert.IsNull (greenType.GetField ("publicStaticGreen", flags), "#M35");
			Assert.IsNull (greenType.GetField ("assemblyStaticGreen", flags), "#M36");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.Public;

			Assert.IsNull (greenType.GetField ("privateInstanceBlue", flags), "#N1");
			Assert.IsNull (greenType.GetField ("familyInstanceBlue", flags), "#N2");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceBlue", flags), "#N3");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceBlue", flags), "#N4");
			Assert.IsNull (greenType.GetField ("publicInstanceBlue", flags), "#N5");
			Assert.IsNull (greenType.GetField ("assemblyInstanceBlue", flags), "#N6");
			Assert.IsNull (greenType.GetField ("privateInstanceRed", flags), "#N7");
			Assert.IsNull (greenType.GetField ("familyInstanceRed", flags), "#N8");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceRed", flags), "#N9");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceRed", flags), "#N10");
			Assert.IsNull (greenType.GetField ("publicInstanceRed", flags), "#N11");
			Assert.IsNull (greenType.GetField ("assemblyInstanceRed", flags), "#N12");
			Assert.IsNull (greenType.GetField ("privateInstanceGreen", flags), "#N13");
			Assert.IsNull (greenType.GetField ("familyInstanceGreen", flags), "#N14");
			Assert.IsNull (greenType.GetField ("famANDAssemInstanceGreen", flags), "#N15");
			Assert.IsNull (greenType.GetField ("famORAssemInstanceGreen", flags), "#N16");
			Assert.IsNull (greenType.GetField ("publicInstanceGreen", flags), "#N17");
			Assert.IsNull (greenType.GetField ("assemblyInstanceGreen", flags), "#N18");
			Assert.IsNull (greenType.GetField ("privateStaticBlue", flags), "#N19");
			Assert.IsNull (greenType.GetField ("familyStaticBlue", flags), "#N20");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticBlue", flags), "#N21");
			Assert.IsNull (greenType.GetField ("famORAssemStaticBlue", flags), "#N22");
			Assert.IsNull (greenType.GetField ("publicStaticBlue", flags), "#N23");
			Assert.IsNull (greenType.GetField ("assemblyStaticBlue", flags), "#N24");
			Assert.IsNull (greenType.GetField ("privateStaticRed", flags), "#N25");
			Assert.IsNull (greenType.GetField ("familyStaticRed", flags), "#N26");
			Assert.IsNull (greenType.GetField ("famANDAssemStaticRed", flags), "#N27");
			Assert.IsNull (greenType.GetField ("famORAssemStaticRed", flags), "#N28");
			Assert.IsNull (greenType.GetField ("publicStaticRed", flags), "#N29");
			Assert.IsNull (greenType.GetField ("assemblyStaticRed", flags), "#N30");
			Assert.IsNotNull (greenType.GetField ("privateStaticGreen", flags), "#N31");
			Assert.IsNotNull (greenType.GetField ("familyStaticGreen", flags), "#N32");
			Assert.IsNotNull (greenType.GetField ("famANDAssemStaticGreen", flags), "#N33");
			Assert.IsNotNull (greenType.GetField ("famORAssemStaticGreen", flags), "#N34");
			Assert.IsNotNull (greenType.GetField ("publicStaticGreen", flags), "#N35");
			Assert.IsNotNull (greenType.GetField ("assemblyStaticGreen", flags), "#N36");
		}

		[Test]
		[Category ("NotDotNet")] // mcs depends on this
		public void TestGetPropertiesIncomplete_Mono ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			DefineStringProperty (tb, "Name", "name", MethodAttributes.Public);
			DefineStringProperty (tb, "Income", "income", MethodAttributes.Private);
			DefineStringProperty (tb, "FirstName", "firstName", MethodAttributes.Public);

			PropertyInfo [] properties = tb.GetProperties ();
			Assert.AreEqual (2, properties.Length, "#1");
			Assert.AreEqual ("Name", properties [0].Name, "#2");
			Assert.AreEqual ("FirstName", properties [1].Name, "#3");
		}

		[Test]
		[Category ("NotWorking")] // mcs depends on this
		public void TestGetPropertiesIncomplete_MS ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			DefineStringProperty (tb, "Name", "name", MethodAttributes.Public);
			DefineStringProperty (tb, "FirstName", "firstName", MethodAttributes.Public);
			DefineStringProperty (tb, "Income", "income", MethodAttributes.Private);

			try {
				tb.GetProperties ();
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void TestGetPropertiesComplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			DefineStringProperty (tb, "CustomerName", "customerName", MethodAttributes.Public);

			Type emittedType = tb.CreateType ();

			Assert.AreEqual (1, tb.GetProperties ().Length);
			Assert.AreEqual (tb.GetProperties ().Length, emittedType.GetProperties ().Length);
		}

		[Test]
		[Category ("NotDotNet")] // mcs depends on this
		public void TestGetPropertiesFlagsIncomplete_Mono ()
		{
			PropertyInfo [] properties;

			TypeBuilder tb = module.DefineType (genTypeName ());
			DefineStringProperty (tb, "Name", "name", MethodAttributes.Public);
			DefineStringProperty (tb, "Income", "income", MethodAttributes.Private);
			DefineStringProperty (tb, "FirstName", "firstName", MethodAttributes.Public);

			properties = tb.GetProperties (BindingFlags.Public | 
				BindingFlags.NonPublic | BindingFlags.Instance);
			Assert.AreEqual (3, properties.Length, "#A1");
			Assert.AreEqual ("Name", properties [0].Name, "#A2");
			Assert.AreEqual ("Income", properties [1].Name, "#A3");
			Assert.AreEqual ("FirstName", properties [2].Name, "#A4");

			properties = tb.GetProperties (BindingFlags.Public |
				BindingFlags.Instance);
			Assert.AreEqual (2, properties.Length, "#B1");
			Assert.AreEqual ("Name", properties [0].Name, "#B2");
			Assert.AreEqual ("FirstName", properties [1].Name, "#B3");

			properties = tb.GetProperties (BindingFlags.NonPublic |
				BindingFlags.Instance);
			Assert.AreEqual (1, properties.Length, "#C1");
			Assert.AreEqual ("Income", properties [0].Name, "#C2");
		}

		[Test]
		[Category ("NotWorking")] // mcs depends on this
		public void TestGetPropertiesFlagsIncomplete_MS ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			DefineStringProperty (tb, "Name", "name", MethodAttributes.Public);
			DefineStringProperty (tb, "Income", "income", MethodAttributes.Private);
			DefineStringProperty (tb, "FirstName", "firstName", MethodAttributes.Public);

			try {
				tb.GetProperties (BindingFlags.Public);
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void TestGetPropertiesFlagsComplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			DefineStringProperty (tb, "CustomerName", "customerName", MethodAttributes.Public);

			Type emittedType = tb.CreateType ();

			Assert.AreEqual (1, tb.GetProperties (BindingFlags.Instance | BindingFlags.Public).Length);
			Assert.AreEqual (tb.GetProperties (BindingFlags.Instance | BindingFlags.Public).Length,
				emittedType.GetProperties (BindingFlags.Instance | BindingFlags.Public).Length);
			Assert.AreEqual (0, tb.GetProperties (BindingFlags.Instance | BindingFlags.NonPublic).Length);
			Assert.AreEqual (tb.GetProperties (BindingFlags.Instance | BindingFlags.NonPublic).Length,
				emittedType.GetProperties (BindingFlags.Instance | BindingFlags.NonPublic).Length);
		}

		[Test]
		public void TestGetPropertiesFlagsComplete_Inheritance ()
		{
			PropertyInfo [] props;
			BindingFlags flags;

			TypeBuilder blueType = module.DefineType (genTypeName (),
				TypeAttributes.Public);
			CreateMembers (blueType, "Blue", false);

			TypeBuilder redType = module.DefineType (genTypeName (),
				TypeAttributes.Public, blueType);
			CreateMembers (redType, "Red", false);

			TypeBuilder greenType = module.DefineType (genTypeName (),
				TypeAttributes.Public, redType);
			CreateMembers (greenType, "Green", false);

			blueType.CreateType ();
			redType.CreateType ();
			greenType.CreateType ();

			flags = BindingFlags.Instance | BindingFlags.NonPublic;
			props = greenType.GetProperties (flags);

			Assert.AreEqual (13, props.Length, "#A1");
			Assert.AreEqual ("PrivateInstanceGreen", props [0].Name, "#A2");
			Assert.AreEqual ("FamilyInstanceGreen", props [1].Name, "#A3");
			Assert.AreEqual ("FamANDAssemInstanceGreen", props [2].Name, "#A4");
			Assert.AreEqual ("FamORAssemInstanceGreen", props [3].Name, "#A5");
			Assert.AreEqual ("AssemblyInstanceGreen", props [4].Name, "#A6");
			Assert.AreEqual ("FamilyInstanceRed", props [5].Name, "#A7");
			Assert.AreEqual ("FamANDAssemInstanceRed", props [6].Name, "#A8");
			Assert.AreEqual ("FamORAssemInstanceRed", props [7].Name, "#A9");
			Assert.AreEqual ("AssemblyInstanceRed", props [8].Name, "#A10");
			Assert.AreEqual ("FamilyInstanceBlue", props [9].Name, "#A11");
			Assert.AreEqual ("FamANDAssemInstanceBlue", props [10].Name, "#A12");
			Assert.AreEqual ("FamORAssemInstanceBlue", props [11].Name, "#A13");
			Assert.AreEqual ("AssemblyInstanceBlue", props [12].Name, "#A15");

			flags = BindingFlags.Instance | BindingFlags.Public;
			props = greenType.GetProperties (flags);

			Assert.AreEqual (3, props.Length, "#B1");
			Assert.AreEqual ("PublicInstanceGreen", props [0].Name, "#B2");
			Assert.AreEqual ("PublicInstanceRed", props [1].Name, "#B3");
			Assert.AreEqual ("PublicInstanceBlue", props [2].Name, "#B4");

			flags = BindingFlags.Static | BindingFlags.Public;
			props = greenType.GetProperties (flags);

			Assert.AreEqual (1, props.Length, "#C1");
			Assert.AreEqual ("PublicStaticGreen", props [0].Name, "#C2");

			flags = BindingFlags.Static | BindingFlags.NonPublic;
			props = greenType.GetProperties (flags);

			Assert.AreEqual (5, props.Length, "#D1");
			Assert.AreEqual ("PrivateStaticGreen", props [0].Name, "#D2");
			Assert.AreEqual ("FamilyStaticGreen", props [1].Name, "#D3");
			Assert.AreEqual ("FamANDAssemStaticGreen", props [2].Name, "#D4");
			Assert.AreEqual ("FamORAssemStaticGreen", props [3].Name, "#D5");
			Assert.AreEqual ("AssemblyStaticGreen", props [4].Name, "#D6");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.FlattenHierarchy;
			props = greenType.GetProperties (flags);

			Assert.AreEqual (13, props.Length, "#E1");
			Assert.AreEqual ("PrivateInstanceGreen", props [0].Name, "#E2");
			Assert.AreEqual ("FamilyInstanceGreen", props [1].Name, "#E3");
			Assert.AreEqual ("FamANDAssemInstanceGreen", props [2].Name, "#E4");
			Assert.AreEqual ("FamORAssemInstanceGreen", props [3].Name, "#E5");
			Assert.AreEqual ("AssemblyInstanceGreen", props [4].Name, "#E6");
			Assert.AreEqual ("FamilyInstanceRed", props [5].Name, "#E7");
			Assert.AreEqual ("FamANDAssemInstanceRed", props [6].Name, "#E8");
			Assert.AreEqual ("FamORAssemInstanceRed", props [7].Name, "#E9");
			Assert.AreEqual ("AssemblyInstanceRed", props [8].Name, "#E10");
			Assert.AreEqual ("FamilyInstanceBlue", props [9].Name, "#E11");
			Assert.AreEqual ("FamANDAssemInstanceBlue", props [10].Name, "#E12");
			Assert.AreEqual ("FamORAssemInstanceBlue", props [11].Name, "#E13");
			Assert.AreEqual ("AssemblyInstanceBlue", props [12].Name, "#E14");

			flags = BindingFlags.Instance | BindingFlags.Public |
				BindingFlags.FlattenHierarchy;
			props = greenType.GetProperties (flags);

			Assert.AreEqual (3, props.Length, "#F1");
			Assert.AreEqual ("PublicInstanceGreen", props [0].Name, "#F2");
			Assert.AreEqual ("PublicInstanceRed", props [1].Name, "#F3");
			Assert.AreEqual ("PublicInstanceBlue", props [2].Name, "#F4");

			flags = BindingFlags.Static | BindingFlags.Public |
				BindingFlags.FlattenHierarchy;
			props = greenType.GetProperties (flags);

			Assert.AreEqual (3, props.Length, "#G1");
			Assert.AreEqual ("PublicStaticGreen", props [0].Name, "#G2");
			Assert.AreEqual ("PublicStaticRed", props [1].Name, "#G3");
			Assert.AreEqual ("PublicStaticBlue", props [2].Name, "#G4");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.FlattenHierarchy;
			props = greenType.GetProperties (flags);

			Assert.AreEqual (13, props.Length, "#H1");
			Assert.AreEqual ("PrivateStaticGreen", props [0].Name, "#H2");
			Assert.AreEqual ("FamilyStaticGreen", props [1].Name, "#H3");
			Assert.AreEqual ("FamANDAssemStaticGreen", props [2].Name, "#H4");
			Assert.AreEqual ("FamORAssemStaticGreen", props [3].Name, "#H5");
			Assert.AreEqual ("AssemblyStaticGreen", props [4].Name, "#H6");
			Assert.AreEqual ("FamilyStaticRed", props [5].Name, "#H7");
			Assert.AreEqual ("FamANDAssemStaticRed", props [6].Name, "#H8");
			Assert.AreEqual ("FamORAssemStaticRed", props [7].Name, "#H9");
			Assert.AreEqual ("AssemblyStaticRed", props [8].Name, "#H10");
			Assert.AreEqual ("FamilyStaticBlue", props [9].Name, "#H11");
			Assert.AreEqual ("FamANDAssemStaticBlue", props [10].Name, "#H12");
			Assert.AreEqual ("FamORAssemStaticBlue", props [11].Name, "#H13");
			Assert.AreEqual ("AssemblyStaticBlue", props [12].Name, "#H14");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.DeclaredOnly;
			props = greenType.GetProperties (flags);

			Assert.AreEqual (5, props.Length, "#I1");
			Assert.AreEqual ("PrivateInstanceGreen", props [0].Name, "#I2");
			Assert.AreEqual ("FamilyInstanceGreen", props [1].Name, "#I3");
			Assert.AreEqual ("FamANDAssemInstanceGreen", props [2].Name, "#I4");
			Assert.AreEqual ("FamORAssemInstanceGreen", props [3].Name, "#I5");
			Assert.AreEqual ("AssemblyInstanceGreen", props [4].Name, "#I6");

			flags = BindingFlags.Instance | BindingFlags.Public |
				BindingFlags.DeclaredOnly;
			props = greenType.GetProperties (flags);

			Assert.AreEqual (1, props.Length, "#J1");
			Assert.AreEqual ("PublicInstanceGreen", props [0].Name, "#J2");

			flags = BindingFlags.Static | BindingFlags.Public |
				BindingFlags.DeclaredOnly;
			props = greenType.GetProperties (flags);

			Assert.AreEqual (1, props.Length, "#K1");
			Assert.AreEqual ("PublicStaticGreen", props [0].Name, "#K2");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.DeclaredOnly;
			props = greenType.GetProperties (flags);

			Assert.AreEqual (5, props.Length, "#L1");
			Assert.AreEqual ("PrivateStaticGreen", props [0].Name, "#L2");
			Assert.AreEqual ("FamilyStaticGreen", props [1].Name, "#L3");
			Assert.AreEqual ("FamANDAssemStaticGreen", props [2].Name, "#L4");
			Assert.AreEqual ("FamORAssemStaticGreen", props [3].Name, "#L5");
			Assert.AreEqual ("AssemblyStaticGreen", props [4].Name, "#L6");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.Public;
			props = greenType.GetProperties (flags);

			Assert.AreEqual (16, props.Length, "#M1");
			Assert.AreEqual ("PrivateInstanceGreen", props [0].Name, "#M2");
			Assert.AreEqual ("FamilyInstanceGreen", props [1].Name, "#M3");
			Assert.AreEqual ("FamANDAssemInstanceGreen", props [2].Name, "#M4");
			Assert.AreEqual ("FamORAssemInstanceGreen", props [3].Name, "#M5");
			Assert.AreEqual ("PublicInstanceGreen", props [4].Name, "#M6");
			Assert.AreEqual ("AssemblyInstanceGreen", props [5].Name, "#M7");
			Assert.AreEqual ("FamilyInstanceRed", props [6].Name, "#M8");
			Assert.AreEqual ("FamANDAssemInstanceRed", props [7].Name, "#M9");
			Assert.AreEqual ("FamORAssemInstanceRed", props [8].Name, "#M10");
			Assert.AreEqual ("PublicInstanceRed", props [9].Name, "#M11");
			Assert.AreEqual ("AssemblyInstanceRed", props [10].Name, "#M12");
			Assert.AreEqual ("FamilyInstanceBlue", props [11].Name, "#M13");
			Assert.AreEqual ("FamANDAssemInstanceBlue", props [12].Name, "#M14");
			Assert.AreEqual ("FamORAssemInstanceBlue", props [13].Name, "#M15");
			Assert.AreEqual ("PublicInstanceBlue", props [14].Name, "#M16");
			Assert.AreEqual ("AssemblyInstanceBlue", props [15].Name, "#M17");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.Public;
			props = greenType.GetProperties (flags);

			Assert.AreEqual (6, props.Length, "#N1");
			Assert.AreEqual ("PrivateStaticGreen", props [0].Name, "#N2");
			Assert.AreEqual ("FamilyStaticGreen", props [1].Name, "#N3");
			Assert.AreEqual ("FamANDAssemStaticGreen", props [2].Name, "#N4");
			Assert.AreEqual ("FamORAssemStaticGreen", props [3].Name, "#N5");
			Assert.AreEqual ("PublicStaticGreen", props [4].Name, "#N6");
			Assert.AreEqual ("AssemblyStaticGreen", props [5].Name, "#N7");
		}

		[Test]
		public void TestGetPropertyIncomplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			try {
				tb.GetProperty ("test");
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				// The invoked member is not supported in a
				// dynamic module
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void TestGetPropertyComplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			DefineStringProperty (tb, "CustomerName", "customerName", MethodAttributes.Public);

			Type emittedType = tb.CreateType ();

			Assert.IsNotNull (emittedType.GetProperty ("CustomerName"));
			Assert.IsNull (emittedType.GetProperty ("OtherCustomerName"));

			try {
				tb.GetProperty ("CustomerName");
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				// The invoked member is not supported in a
				// dynamic module
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void TestGetPropertyFlagsIncomplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			try {
				tb.GetProperty ("test", BindingFlags.Public);
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				// The invoked member is not supported in a
				// dynamic module
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void TestGetPropertyFlagsComplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			DefineStringProperty (tb, "CustomerName", "customerName", MethodAttributes.Public);

			Type emittedType = tb.CreateType ();

			Assert.IsNotNull (emittedType.GetProperty ("CustomerName", BindingFlags.Instance |
				BindingFlags.Public));
			Assert.IsNull (emittedType.GetProperty ("CustomerName", BindingFlags.Instance |
				BindingFlags.NonPublic));

			try {
				tb.GetProperty ("CustomerName", BindingFlags.Instance | BindingFlags.Public);
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void TestGetMethodFlagsComplete ()
		{
			BindingFlags flags;

			TypeBuilder blueType = module.DefineType (genTypeName (),
				TypeAttributes.Public);
			CreateMembers (blueType, "Blue", false);

			TypeBuilder redType = module.DefineType (genTypeName (),
				TypeAttributes.Public, blueType);
			CreateMembers (redType, "Red", false);

			TypeBuilder greenType = module.DefineType (genTypeName (),
				TypeAttributes.Public, redType);
			CreateMembers (greenType, "Green", false);

			blueType.CreateType ();
			redType.CreateType ();
			greenType.CreateType ();

			flags = BindingFlags.Instance | BindingFlags.NonPublic;

			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceBlue", flags), "#A1");
			Assert.IsNotNull (greenType.GetMethod ("GetFamilyInstanceBlue", flags), "#A2");
			Assert.IsNotNull (greenType.GetMethod ("GetFamANDAssemInstanceBlue", flags), "#A3");
			Assert.IsNotNull (greenType.GetMethod ("GetFamORAssemInstanceBlue", flags), "#A4");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceBlue", flags), "#A5");
			Assert.IsNotNull (greenType.GetMethod ("GetAssemblyInstanceBlue", flags), "#A6");
			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceRed", flags), "#A7");
			Assert.IsNotNull (greenType.GetMethod ("GetFamilyInstanceRed", flags), "#A8");
			Assert.IsNotNull (greenType.GetMethod ("GetFamANDAssemInstanceRed", flags), "#A9");
			Assert.IsNotNull (greenType.GetMethod ("GetFamORAssemInstanceRed", flags), "#A10");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceRed", flags), "#A11");
			Assert.IsNotNull (greenType.GetMethod ("GetAssemblyInstanceRed", flags), "#A12");
			Assert.IsNotNull (greenType.GetMethod ("GetPrivateInstanceGreen", flags), "#A13");
			Assert.IsNotNull (greenType.GetMethod ("GetFamilyInstanceGreen", flags), "#A14");
			Assert.IsNotNull (greenType.GetMethod ("GetFamANDAssemInstanceGreen", flags), "#A15");
			Assert.IsNotNull (greenType.GetMethod ("GetFamORAssemInstanceGreen", flags), "#A16");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceGreen", flags), "#A17");
			Assert.IsNotNull (greenType.GetMethod ("GetAssemblyInstanceGreen", flags), "#A18");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticBlue", flags), "#A19");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticBlue", flags), "#A20");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticBlue", flags), "#A21");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticBlue", flags), "#A22");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticBlue", flags), "#A23");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticBlue", flags), "#A24");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticRed", flags), "#A25");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticRed", flags), "#A26");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticRed", flags), "#A27");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticRed", flags), "#A28");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticRed", flags), "#A29");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticRed", flags), "#A30");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticGreen", flags), "#A31");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticGreen", flags), "#A32");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticGreen", flags), "#A33");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticGreen", flags), "#A34");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticGreen", flags), "#A35");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticGreen", flags), "#A36");

			flags = BindingFlags.Instance | BindingFlags.Public;

			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceBlue", flags), "#B1");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceBlue", flags), "#B2");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceBlue", flags), "#B3");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceBlue", flags), "#B4");
			Assert.IsNotNull (greenType.GetMethod ("GetPublicInstanceBlue", flags), "#B5");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceBlue", flags), "#B6");
			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceRed", flags), "#B7");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceRed", flags), "#B8");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceRed", flags), "#B9");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceRed", flags), "#B10");
			Assert.IsNotNull (greenType.GetMethod ("GetPublicInstanceRed", flags), "#B11");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceRed", flags), "#B12");
			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceGreen", flags), "#B13");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceGreen", flags), "#B14");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceGreen", flags), "#B15");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceGreen", flags), "#B16");
			Assert.IsNotNull (greenType.GetMethod ("GetPublicInstanceGreen", flags), "#B17");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceGreen", flags), "#B18");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticBlue", flags), "#B19");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticBlue", flags), "#B20");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticBlue", flags), "#B21");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticBlue", flags), "#B22");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticBlue", flags), "#B23");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticBlue", flags), "#B24");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticRed", flags), "#B25");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticRed", flags), "#B26");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticRed", flags), "#B27");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticRed", flags), "#B28");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticRed", flags), "#B29");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticRed", flags), "#B30");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticGreen", flags), "#B31");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticGreen", flags), "#B32");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticGreen", flags), "#B33");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticGreen", flags), "#B34");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticGreen", flags), "#B35");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticGreen", flags), "#B36");

			flags = BindingFlags.Static | BindingFlags.Public;

			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceBlue", flags), "#C1");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceBlue", flags), "#C2");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceBlue", flags), "#C3");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceBlue", flags), "#C4");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceBlue", flags), "#C5");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceBlue", flags), "#C6");
			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceRed", flags), "#C7");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceRed", flags), "#C8");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceRed", flags), "#C9");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceRed", flags), "#C10");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceRed", flags), "#C11");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceRed", flags), "#C12");
			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceGreen", flags), "#C13");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceGreen", flags), "#C14");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceGreen", flags), "#C15");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceGreen", flags), "#C16");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceGreen", flags), "#C17");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceGreen", flags), "#C18");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticBlue", flags), "#C19");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticBlue", flags), "#C20");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticBlue", flags), "#C21");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticBlue", flags), "#C22");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticBlue", flags), "#C23");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticBlue", flags), "#C24");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticRed", flags), "#C25");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticRed", flags), "#C26");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticRed", flags), "#C27");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticRed", flags), "#C28");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticRed", flags), "#C29");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticRed", flags), "#C30");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticGreen", flags), "#C31");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticGreen", flags), "#C32");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticGreen", flags), "#C33");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticGreen", flags), "#C34");
			Assert.IsNotNull (greenType.GetMethod ("GetPublicStaticGreen", flags), "#C35");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticGreen", flags), "#C36");

			flags = BindingFlags.Static | BindingFlags.NonPublic;

			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceBlue", flags), "#D1");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceBlue", flags), "#D2");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceBlue", flags), "#D3");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceBlue", flags), "#D4");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceBlue", flags), "#D5");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceBlue", flags), "#D6");
			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceRed", flags), "#D7");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceRed", flags), "#D8");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceRed", flags), "#D9");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceRed", flags), "#D10");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceRed", flags), "#D11");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceRed", flags), "#D12");
			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceGreen", flags), "#D13");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceGreen", flags), "#D14");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceGreen", flags), "#D15");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceGreen", flags), "#D16");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceGreen", flags), "#D17");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceGreen", flags), "#D18");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticBlue", flags), "#D19");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticBlue", flags), "#D20");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticBlue", flags), "#D21");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticBlue", flags), "#D22");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticBlue", flags), "#D23");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticBlue", flags), "#D24");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticRed", flags), "#D25");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticRed", flags), "#D26");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticRed", flags), "#D27");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticRed", flags), "#D28");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticRed", flags), "#D29");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticRed", flags), "#D30");
			Assert.IsNotNull (greenType.GetMethod ("GetPrivateStaticGreen", flags), "#D31");
			Assert.IsNotNull (greenType.GetMethod ("GetFamilyStaticGreen", flags), "#D32");
			Assert.IsNotNull (greenType.GetMethod ("GetFamANDAssemStaticGreen", flags), "#D33");
			Assert.IsNotNull (greenType.GetMethod ("GetFamORAssemStaticGreen", flags), "#D34");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticGreen", flags), "#D35");
			Assert.IsNotNull (greenType.GetMethod ("GetAssemblyStaticGreen", flags), "#D36");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.FlattenHierarchy;

			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceBlue", flags), "#E1");
			Assert.IsNotNull (greenType.GetMethod ("GetFamilyInstanceBlue", flags), "#E2");
			Assert.IsNotNull (greenType.GetMethod ("GetFamANDAssemInstanceBlue", flags), "#E3");
			Assert.IsNotNull (greenType.GetMethod ("GetFamORAssemInstanceBlue", flags), "#E4");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceBlue", flags), "#E5");
			Assert.IsNotNull (greenType.GetMethod ("GetAssemblyInstanceBlue", flags), "#E6");
			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceRed", flags), "#E7");
			Assert.IsNotNull (greenType.GetMethod ("GetFamilyInstanceRed", flags), "#E8");
			Assert.IsNotNull (greenType.GetMethod ("GetFamANDAssemInstanceRed", flags), "#E9");
			Assert.IsNotNull (greenType.GetMethod ("GetFamORAssemInstanceRed", flags), "#E10");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceRed", flags), "#E11");
			Assert.IsNotNull (greenType.GetMethod ("GetAssemblyInstanceRed", flags), "#E12");
			Assert.IsNotNull (greenType.GetMethod ("GetPrivateInstanceGreen", flags), "#E13");
			Assert.IsNotNull (greenType.GetMethod ("GetFamilyInstanceGreen", flags), "#E14");
			Assert.IsNotNull (greenType.GetMethod ("GetFamANDAssemInstanceGreen", flags), "#E15");
			Assert.IsNotNull (greenType.GetMethod ("GetFamORAssemInstanceGreen", flags), "#E16");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceGreen", flags), "#E17");
			Assert.IsNotNull (greenType.GetMethod ("GetAssemblyInstanceGreen", flags), "#E18");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticBlue", flags), "#E19");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticBlue", flags), "#E20");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticBlue", flags), "#E21");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticBlue", flags), "#E22");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticBlue", flags), "#E23");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticBlue", flags), "#E24");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticRed", flags), "#E25");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticRed", flags), "#E26");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticRed", flags), "#E27");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticRed", flags), "#E28");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticRed", flags), "#E29");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticRed", flags), "#E30");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticGreen", flags), "#E31");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticGreen", flags), "#E32");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticGreen", flags), "#E33");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticGreen", flags), "#E34");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticGreen", flags), "#E35");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticGreen", flags), "#E36");

			flags = BindingFlags.Instance | BindingFlags.Public |
				BindingFlags.FlattenHierarchy;

			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceBlue", flags), "#F1");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceBlue", flags), "#F2");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceBlue", flags), "#F3");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceBlue", flags), "#F4");
			Assert.IsNotNull (greenType.GetMethod ("GetPublicInstanceBlue", flags), "#F5");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceBlue", flags), "#F6");
			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceRed", flags), "#F7");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceRed", flags), "#F8");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceRed", flags), "#F9");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceRed", flags), "#F10");
			Assert.IsNotNull (greenType.GetMethod ("GetPublicInstanceRed", flags), "#F11");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceRed", flags), "#F12");
			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceGreen", flags), "#F13");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceGreen", flags), "#F14");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceGreen", flags), "#F15");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceGreen", flags), "#F16");
			Assert.IsNotNull (greenType.GetMethod ("GetPublicInstanceGreen", flags), "#F17");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceGreen", flags), "#F18");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticBlue", flags), "#F19");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticBlue", flags), "#F20");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticBlue", flags), "#F21");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticBlue", flags), "#F22");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticBlue", flags), "#F23");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticBlue", flags), "#F24");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticRed", flags), "#F25");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticRed", flags), "#F26");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticRed", flags), "#F27");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticRed", flags), "#F28");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticRed", flags), "#F29");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticRed", flags), "#F30");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticGreen", flags), "#F31");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticGreen", flags), "#F32");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticGreen", flags), "#F33");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticGreen", flags), "#F34");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticGreen", flags), "#F35");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticGreen", flags), "#F36");

			flags = BindingFlags.Static | BindingFlags.Public |
				BindingFlags.FlattenHierarchy;

			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceBlue", flags), "#G1");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceBlue", flags), "#G2");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceBlue", flags), "#G3");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceBlue", flags), "#G4");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceBlue", flags), "#G5");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceBlue", flags), "#G6");
			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceRed", flags), "#G7");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceRed", flags), "#G8");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceRed", flags), "#G9");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceRed", flags), "#G10");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceRed", flags), "#G11");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceRed", flags), "#G12");
			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceGreen", flags), "#G13");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceGreen", flags), "#G14");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceGreen", flags), "#G15");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceGreen", flags), "#G16");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceGreen", flags), "#G17");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceGreen", flags), "#G18");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticBlue", flags), "#G19");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticBlue", flags), "#G20");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticBlue", flags), "#G21");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticBlue", flags), "#G22");
			Assert.IsNotNull (greenType.GetMethod ("GetPublicStaticBlue", flags), "#G23");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticBlue", flags), "#G24");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticRed", flags), "#G25");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticRed", flags), "#G26");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticRed", flags), "#G27");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticRed", flags), "#G28");
			Assert.IsNotNull (greenType.GetMethod ("GetPublicStaticRed", flags), "#G29");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticRed", flags), "#G30");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticGreen", flags), "#G31");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticGreen", flags), "#G32");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticGreen", flags), "#G33");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticGreen", flags), "#G34");
			Assert.IsNotNull (greenType.GetMethod ("GetPublicStaticGreen", flags), "#G35");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticGreen", flags), "#G36");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.FlattenHierarchy;

			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceBlue", flags), "#H1");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceBlue", flags), "#H2");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceBlue", flags), "#H3");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceBlue", flags), "#H4");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceBlue", flags), "#H5");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceBlue", flags), "#H6");
			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceRed", flags), "#H7");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceRed", flags), "#H8");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceRed", flags), "#H9");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceRed", flags), "#H10");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceRed", flags), "#H11");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceRed", flags), "#H12");
			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceGreen", flags), "#H13");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceGreen", flags), "#H14");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceGreen", flags), "#H15");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceGreen", flags), "#H16");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceGreen", flags), "#H17");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceGreen", flags), "#H18");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticBlue", flags), "#H19");
			Assert.IsNotNull (greenType.GetMethod ("GetFamilyStaticBlue", flags), "#H20");
			Assert.IsNotNull (greenType.GetMethod ("GetFamANDAssemStaticBlue", flags), "#H21");
			Assert.IsNotNull (greenType.GetMethod ("GetFamORAssemStaticBlue", flags), "#H22");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticBlue", flags), "#H23");
			Assert.IsNotNull (greenType.GetMethod ("GetAssemblyStaticBlue", flags), "#H24");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticRed", flags), "#H25");
			Assert.IsNotNull (greenType.GetMethod ("GetFamilyStaticRed", flags), "#H26");
			Assert.IsNotNull (greenType.GetMethod ("GetFamANDAssemStaticRed", flags), "#H27");
			Assert.IsNotNull (greenType.GetMethod ("GetFamORAssemStaticRed", flags), "#H28");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticRed", flags), "#H29");
			Assert.IsNotNull (greenType.GetMethod ("GetAssemblyStaticRed", flags), "#H30");
			Assert.IsNotNull (greenType.GetMethod ("GetPrivateStaticGreen", flags), "#H31");
			Assert.IsNotNull (greenType.GetMethod ("GetFamilyStaticGreen", flags), "#H32");
			Assert.IsNotNull (greenType.GetMethod ("GetFamANDAssemStaticGreen", flags), "#H33");
			Assert.IsNotNull (greenType.GetMethod ("GetFamORAssemStaticGreen", flags), "#H34");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticGreen", flags), "#H35");
			Assert.IsNotNull (greenType.GetMethod ("GetAssemblyStaticGreen", flags), "#H36");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.DeclaredOnly;

			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceBlue", flags), "#I1");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceBlue", flags), "#I2");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceBlue", flags), "#I3");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceBlue", flags), "#I4");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceBlue", flags), "#I5");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceBlue", flags), "#I6");
			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceRed", flags), "#I7");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceRed", flags), "#I8");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceRed", flags), "#I9");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceRed", flags), "#I10");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceRed", flags), "#I11");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceRed", flags), "#I12");
			Assert.IsNotNull (greenType.GetMethod ("GetPrivateInstanceGreen", flags), "#I13");
			Assert.IsNotNull (greenType.GetMethod ("GetFamilyInstanceGreen", flags), "#I14");
			Assert.IsNotNull (greenType.GetMethod ("GetFamANDAssemInstanceGreen", flags), "#I15");
			Assert.IsNotNull (greenType.GetMethod ("GetFamORAssemInstanceGreen", flags), "#I16");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceGreen", flags), "#I17");
			Assert.IsNotNull (greenType.GetMethod ("GetAssemblyInstanceGreen", flags), "#I18");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticBlue", flags), "#I19");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticBlue", flags), "#I20");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticBlue", flags), "#I21");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticBlue", flags), "#I22");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticBlue", flags), "#I23");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticBlue", flags), "#I24");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticRed", flags), "#I25");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticRed", flags), "#I26");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticRed", flags), "#I27");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticRed", flags), "#I28");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticRed", flags), "#I29");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticRed", flags), "#I30");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticGreen", flags), "#I31");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticGreen", flags), "#I32");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticGreen", flags), "#I33");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticGreen", flags), "#I34");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticGreen", flags), "#I35");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticGreen", flags), "#I36");

			flags = BindingFlags.Instance | BindingFlags.Public |
				BindingFlags.DeclaredOnly;

			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceBlue", flags), "#J1");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceBlue", flags), "#J2");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceBlue", flags), "#J3");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceBlue", flags), "#J4");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceBlue", flags), "#J5");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceBlue", flags), "#J6");
			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceRed", flags), "#J7");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceRed", flags), "#J8");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceRed", flags), "#J9");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceRed", flags), "#J10");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceRed", flags), "#J11");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceRed", flags), "#J12");
			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceGreen", flags), "#J13");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceGreen", flags), "#J14");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceGreen", flags), "#J15");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceGreen", flags), "#J16");
			Assert.IsNotNull (greenType.GetMethod ("GetPublicInstanceGreen", flags), "#J17");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceGreen", flags), "#J18");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticBlue", flags), "#J19");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticBlue", flags), "#J20");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticBlue", flags), "#J21");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticBlue", flags), "#J22");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticBlue", flags), "#J23");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticBlue", flags), "#J24");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticRed", flags), "#J25");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticRed", flags), "#J26");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticRed", flags), "#J27");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticRed", flags), "#J28");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticRed", flags), "#J29");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticRed", flags), "#J30");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticGreen", flags), "#J31");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticGreen", flags), "#J32");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticGreen", flags), "#J33");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticGreen", flags), "#J34");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticGreen", flags), "#J35");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticGreen", flags), "#J36");

			flags = BindingFlags.Static | BindingFlags.Public |
				BindingFlags.DeclaredOnly;

			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceBlue", flags), "#K1");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceBlue", flags), "#K2");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceBlue", flags), "#K3");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceBlue", flags), "#K4");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceBlue", flags), "#K5");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceBlue", flags), "#K6");
			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceRed", flags), "#K7");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceRed", flags), "#K8");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceRed", flags), "#K9");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceRed", flags), "#K10");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceRed", flags), "#K11");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceRed", flags), "#K12");
			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceGreen", flags), "#K13");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceGreen", flags), "#K14");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceGreen", flags), "#K15");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceGreen", flags), "#K16");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceGreen", flags), "#K17");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceGreen", flags), "#K18");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticBlue", flags), "#K19");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticBlue", flags), "#K20");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticBlue", flags), "#K21");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticBlue", flags), "#K22");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticBlue", flags), "#K23");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticBlue", flags), "#K24");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticRed", flags), "#K25");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticRed", flags), "#K26");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticRed", flags), "#K27");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticRed", flags), "#K28");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticRed", flags), "#K29");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticRed", flags), "#K30");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticGreen", flags), "#K31");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticGreen", flags), "#K32");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticGreen", flags), "#K33");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticGreen", flags), "#K34");
			Assert.IsNotNull (greenType.GetMethod ("GetPublicStaticGreen", flags), "#K35");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticGreen", flags), "#K36");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.DeclaredOnly;

			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceBlue", flags), "#L1");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceBlue", flags), "#L2");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceBlue", flags), "#L3");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceBlue", flags), "#L4");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceBlue", flags), "#L5");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceBlue", flags), "#L6");
			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceRed", flags), "#L7");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceRed", flags), "#L8");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceRed", flags), "#L9");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceRed", flags), "#L10");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceRed", flags), "#L11");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceRed", flags), "#L12");
			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceGreen", flags), "#L13");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceGreen", flags), "#L14");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceGreen", flags), "#L15");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceGreen", flags), "#L16");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceGreen", flags), "#L17");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceGreen", flags), "#L18");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticBlue", flags), "#L19");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticBlue", flags), "#L20");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticBlue", flags), "#L21");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticBlue", flags), "#L22");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticBlue", flags), "#L23");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticBlue", flags), "#L24");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticRed", flags), "#L25");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticRed", flags), "#L26");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticRed", flags), "#L27");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticRed", flags), "#L28");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticRed", flags), "#L29");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticRed", flags), "#L30");
			Assert.IsNotNull (greenType.GetMethod ("GetPrivateStaticGreen", flags), "#L31");
			Assert.IsNotNull (greenType.GetMethod ("GetFamilyStaticGreen", flags), "#L32");
			Assert.IsNotNull (greenType.GetMethod ("GetFamANDAssemStaticGreen", flags), "#L33");
			Assert.IsNotNull (greenType.GetMethod ("GetFamORAssemStaticGreen", flags), "#L34");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticGreen", flags), "#L35");
			Assert.IsNotNull (greenType.GetMethod ("GetAssemblyStaticGreen", flags), "#L36");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.Public;

			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceBlue", flags), "#M1");
			Assert.IsNotNull (greenType.GetMethod ("GetFamilyInstanceBlue", flags), "#M2");
			Assert.IsNotNull (greenType.GetMethod ("GetFamANDAssemInstanceBlue", flags), "#M3");
			Assert.IsNotNull (greenType.GetMethod ("GetFamORAssemInstanceBlue", flags), "#M4");
			Assert.IsNotNull (greenType.GetMethod ("GetPublicInstanceBlue", flags), "#M5");
			Assert.IsNotNull (greenType.GetMethod ("GetAssemblyInstanceBlue", flags), "#M6");
			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceRed", flags), "#M7");
			Assert.IsNotNull (greenType.GetMethod ("GetFamilyInstanceRed", flags), "#M8");
			Assert.IsNotNull (greenType.GetMethod ("GetFamANDAssemInstanceRed", flags), "#M9");
			Assert.IsNotNull (greenType.GetMethod ("GetFamORAssemInstanceRed", flags), "#M10");
			Assert.IsNotNull (greenType.GetMethod ("GetPublicInstanceRed", flags), "#M11");
			Assert.IsNotNull (greenType.GetMethod ("GetAssemblyInstanceRed", flags), "#M12");
			Assert.IsNotNull (greenType.GetMethod ("GetPrivateInstanceGreen", flags), "#M13");
			Assert.IsNotNull (greenType.GetMethod ("GetFamilyInstanceGreen", flags), "#M14");
			Assert.IsNotNull (greenType.GetMethod ("GetFamANDAssemInstanceGreen", flags), "#M15");
			Assert.IsNotNull (greenType.GetMethod ("GetFamORAssemInstanceGreen", flags), "#M16");
			Assert.IsNotNull (greenType.GetMethod ("GetPublicInstanceGreen", flags), "#M17");
			Assert.IsNotNull (greenType.GetMethod ("GetAssemblyInstanceGreen", flags), "#M18");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticBlue", flags), "#M19");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticBlue", flags), "#M20");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticBlue", flags), "#M21");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticBlue", flags), "#M22");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticBlue", flags), "#M23");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticBlue", flags), "#M24");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticRed", flags), "#M25");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticRed", flags), "#M26");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticRed", flags), "#M27");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticRed", flags), "#M28");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticRed", flags), "#M29");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticRed", flags), "#M30");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticGreen", flags), "#M31");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticGreen", flags), "#M32");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticGreen", flags), "#M33");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticGreen", flags), "#M34");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticGreen", flags), "#M35");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticGreen", flags), "#M36");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.Public;

			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceBlue", flags), "#N1");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceBlue", flags), "#N2");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceBlue", flags), "#N3");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceBlue", flags), "#N4");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceBlue", flags), "#N5");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceBlue", flags), "#N6");
			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceRed", flags), "#N7");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceRed", flags), "#N8");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceRed", flags), "#N9");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceRed", flags), "#N10");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceRed", flags), "#N11");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceRed", flags), "#N12");
			Assert.IsNull (greenType.GetMethod ("GetPrivateInstanceGreen", flags), "#N13");
			Assert.IsNull (greenType.GetMethod ("GetFamilyInstanceGreen", flags), "#N14");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemInstanceGreen", flags), "#N15");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemInstanceGreen", flags), "#N16");
			Assert.IsNull (greenType.GetMethod ("GetPublicInstanceGreen", flags), "#N17");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyInstanceGreen", flags), "#N18");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticBlue", flags), "#N19");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticBlue", flags), "#N20");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticBlue", flags), "#N21");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticBlue", flags), "#N22");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticBlue", flags), "#N23");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticBlue", flags), "#N24");
			Assert.IsNull (greenType.GetMethod ("GetPrivateStaticRed", flags), "#N25");
			Assert.IsNull (greenType.GetMethod ("GetFamilyStaticRed", flags), "#N26");
			Assert.IsNull (greenType.GetMethod ("GetFamANDAssemStaticRed", flags), "#N27");
			Assert.IsNull (greenType.GetMethod ("GetFamORAssemStaticRed", flags), "#N28");
			Assert.IsNull (greenType.GetMethod ("GetPublicStaticRed", flags), "#N29");
			Assert.IsNull (greenType.GetMethod ("GetAssemblyStaticRed", flags), "#N30");
			Assert.IsNotNull (greenType.GetMethod ("GetPrivateStaticGreen", flags), "#N31");
			Assert.IsNotNull (greenType.GetMethod ("GetFamilyStaticGreen", flags), "#N32");
			Assert.IsNotNull (greenType.GetMethod ("GetFamANDAssemStaticGreen", flags), "#N33");
			Assert.IsNotNull (greenType.GetMethod ("GetFamORAssemStaticGreen", flags), "#N34");
			Assert.IsNotNull (greenType.GetMethod ("GetPublicStaticGreen", flags), "#N35");
			Assert.IsNotNull (greenType.GetMethod ("GetAssemblyStaticGreen", flags), "#N36");
		}

		[Test]
		[Category ("NotDotNet")] // mcs depends on this
		public void TestGetMethodsIncomplete_Mono ()
		{
			MethodBuilder mb;
			ILGenerator ilgen;

			TypeBuilder tb = module.DefineType (genTypeName (),
				TypeAttributes.Abstract);
			mb = tb.DefineMethod ("Hello", MethodAttributes.Public,
				typeof (void), Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ret);

			mb = tb.DefineMethod ("Run", MethodAttributes.Private,
				typeof (void), Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ret);

			mb = tb.DefineMethod ("Execute", MethodAttributes.Public |
				MethodAttributes.Static,
				typeof (void), Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ret);

			mb = tb.DefineMethod ("Init", MethodAttributes.Public |
				MethodAttributes.Abstract | MethodAttributes.Virtual,
				typeof (void), Type.EmptyTypes);

			MethodInfo [] methods = tb.GetMethods ();
			Assert.AreEqual (7, methods.Length, "#A");

			Assert.AreEqual ("Equals", methods [0].Name, "#B1");
			Assert.IsFalse (methods [0].IsStatic, "#B2");
			Assert.IsFalse (methods [0].IsAbstract, "#B3");

			Assert.AreEqual ("GetHashCode", methods [1].Name, "#C1");
			Assert.IsFalse (methods [1].IsStatic, "#C2");
			Assert.IsFalse (methods [1].IsAbstract, "#C3");

			Assert.AreEqual ("GetType", methods [2].Name, "#D1");
			Assert.IsFalse (methods [2].IsStatic, "#D2");
			Assert.IsFalse (methods [2].IsAbstract, "#D3");

			Assert.AreEqual ("ToString", methods [3].Name, "#E1");
			Assert.IsFalse (methods [3].IsStatic, "#E2");
			Assert.IsFalse (methods [3].IsAbstract, "#E3");

			Assert.AreEqual ("Hello", methods [4].Name, "#F1");
			Assert.IsFalse (methods [4].IsStatic, "#F2");
			Assert.IsFalse (methods [4].IsAbstract, "#F3");

			Assert.AreEqual ("Execute", methods [5].Name, "#G1");
			Assert.IsTrue (methods [5].IsStatic, "#G2");
			Assert.IsFalse (methods [5].IsAbstract, "#G3");

			Assert.AreEqual ("Init", methods [6].Name, "#H1");
			Assert.IsFalse (methods [6].IsStatic, "#H2");
			Assert.IsTrue (methods [6].IsAbstract, "#H3");
		}

		[Test]
		[Category ("NotWorking")] // mcs depends on this
		public void TestGetMethodsIncomplete_MS ()
		{
			MethodBuilder mb;
			ILGenerator ilgen;

			TypeBuilder tb = module.DefineType (genTypeName (),
				TypeAttributes.Abstract);
			mb = tb.DefineMethod ("Hello", MethodAttributes.Public,
				typeof (void), Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ret);

			mb = tb.DefineMethod ("Run", MethodAttributes.Private,
				typeof (void), Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ret);

			mb = tb.DefineMethod ("Execute", MethodAttributes.Public |
				MethodAttributes.Static,
				typeof (void), Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ret);

			mb = tb.DefineMethod ("Init", MethodAttributes.Public |
				MethodAttributes.Abstract | MethodAttributes.Virtual,
				typeof (void), Type.EmptyTypes);

			try {
				tb.GetMethods ();
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void TestGetMethodsComplete ()
		{
			MethodBuilder mb;
			ILGenerator ilgen;
			MethodInfo mi;

			TypeBuilder tb = module.DefineType (genTypeName (),
				TypeAttributes.Abstract);
			mb = tb.DefineMethod ("Hello", MethodAttributes.Public,
				typeof (string), Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ldstr, "Hi! ");
			ilgen.Emit (OpCodes.Ldarg_1);
			MethodInfo infoMethod = typeof (string).GetMethod ("Concat",
				new Type [] { typeof (string), typeof (string) });
			ilgen.Emit (OpCodes.Call, infoMethod);
			ilgen.Emit (OpCodes.Ret);

			mb = tb.DefineMethod ("Run", MethodAttributes.Private,
				typeof (void), Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ret);

			mb = tb.DefineMethod ("Execute", MethodAttributes.Public |
				MethodAttributes.Static,
				typeof (void), Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ret);

			mb = tb.DefineMethod ("Init", MethodAttributes.Public |
				MethodAttributes.Abstract | MethodAttributes.Virtual,
				typeof (void), Type.EmptyTypes);

			Type emittedType = tb.CreateType ();

			MethodInfo [] methods = emittedType.GetMethods ();
			Assert.AreEqual (7, methods.Length, "#A1");
			Assert.AreEqual (7, tb.GetMethods ().Length, "#A2");

			mi = GetMethodByName (methods, "Hello");
			Assert.IsNotNull (mi, "#B1");
			Assert.IsFalse (mi.IsStatic, "#B2");
			Assert.IsFalse (mi.IsAbstract, "#B3");

			mi = GetMethodByName (methods, "Execute");
			Assert.IsNotNull (mi, "#C1");
			Assert.IsTrue (mi.IsStatic, "#C2");
			Assert.IsFalse (mi.IsAbstract, "#C3");

			mi = GetMethodByName (methods, "Init");
			Assert.IsNotNull (mi, "#D1");
			Assert.IsFalse (mi.IsStatic, "#D2");
			Assert.IsTrue (mi.IsAbstract, "#D3");

			mi = GetMethodByName (methods, "GetType");
			Assert.IsNotNull (mi, "#E1");
			Assert.IsFalse (methods [3].IsStatic, "#E2");
			Assert.IsFalse (methods [3].IsAbstract, "#E3");

			mi = GetMethodByName (methods, "ToString");
			Assert.IsNotNull (mi, "#F1");
			Assert.IsFalse (mi.IsStatic, "#F2");
			Assert.IsFalse (mi.IsAbstract, "#F3");

			mi = GetMethodByName (methods, "Equals");
			Assert.IsNotNull (mi, "#G1");
			Assert.IsFalse (mi.IsStatic, "#G2");
			Assert.IsFalse (mi.IsAbstract, "#G3");

			mi = GetMethodByName (methods, "GetHashCode");
			Assert.IsNotNull (mi, "#H1");
			Assert.IsFalse (mi.IsStatic, "#H2");
			Assert.IsFalse (mi.IsAbstract, "#H3");
		}

		[Test]
		[Category ("NotDotNet")] // mcs depends on this
		public void TestGetMethodsFlagsIncomplete_Inheritance ()
		{
			MethodInfo [] methods;
			BindingFlags flags;

			TypeBuilder blueType = module.DefineType (genTypeName (),
				TypeAttributes.Public);
			CreateMembers (blueType, "Blue", false);

			TypeBuilder redType = module.DefineType (genTypeName (),
				TypeAttributes.Public, blueType);
			CreateMembers (redType, "Red", false);

			TypeBuilder greenType = module.DefineType (genTypeName (),
				TypeAttributes.Public, redType);
			CreateMembers (greenType, "Green", false);

			flags = BindingFlags.Instance | BindingFlags.NonPublic;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#A1");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#A2");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#A3");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#A4");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#A5");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#A6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#A7");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#A8");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#A9");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#A10");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#A11");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#A12");
			Assert.IsNotNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#A13");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#A14");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#A15");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#A16");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#A17");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#A18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#A19");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#A20");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#A21");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#A22");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#A23");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#A24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#A25");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#A26");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#A27");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#A28");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticRed"), "#A29");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#A30");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#A31");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#A32");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#A33");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#A34");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#A35");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#A36");

			flags = BindingFlags.Instance | BindingFlags.Public;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#B1");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#B2");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#B3");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#B4");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#B5");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#B6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#B7");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#B8");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#B9");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#B10");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#B11");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#B12");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#B13");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#B14");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#B15");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#B16");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#B17");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#B18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#B19");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#B20");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#B21");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#B22");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#B23");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#B24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#B25");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#B26");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#B27");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#B28");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticRed"), "#B29");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#B30");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#B31");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#B32");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#B33");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#B34");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#B35");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#B36");

			flags = BindingFlags.Static | BindingFlags.Public;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#C1");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#C2");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#C3");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#C4");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#C5");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#C6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#C7");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#C8");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#C9");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#C10");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#C11");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#C12");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#C13");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#C14");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#C15");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#C16");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#C17");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#C18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#C19");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#C20");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#C21");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#C22");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#C23");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#C24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#C25");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#C26");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#C27");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#C28");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticRed"), "#C29");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#C30");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#C31");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#C32");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#C33");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#C34");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#C35");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#C36");

			flags = BindingFlags.Static | BindingFlags.NonPublic;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#D1");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#D2");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#D3");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#D4");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#D5");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#D6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#D7");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#D8");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#D9");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#D10");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#D11");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#D12");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#D13");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#D14");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#D15");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#D16");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#D17");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#D18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#D19");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#D20");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#D21");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#D22");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#D23");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#D24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#D25");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#D26");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#D27");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#D28");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticRed"), "#D29");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#D30");
			Assert.IsNotNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#D31");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#D32");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#D33");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#D34");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#D35");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#D36");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.FlattenHierarchy;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#E1");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#E2");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#E3");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#E4");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#E5");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#E6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#E7");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#E8");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#E9");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#E10");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#E11");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#E12");
			Assert.IsNotNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#E13");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#E14");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#E15");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#E16");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#E17");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#E18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#E19");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#E20");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#E21");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#E22");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#E23");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#E24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#E25");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#E26");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#E27");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#E28");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticRed"), "#E29");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#E30");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#E31");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#E32");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#E33");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#E34");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#E35");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#E36");

			flags = BindingFlags.Instance | BindingFlags.Public |
				BindingFlags.FlattenHierarchy;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#F1");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#F2");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#F3");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#F4");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#F5");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#F6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#F7");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#F8");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#F9");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#F10");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#F11");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#F12");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#F13");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#F14");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#F15");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#F16");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#F17");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#F18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#F19");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#F20");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#F21");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#F22");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#F23");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#F24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#F25");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#F26");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#F27");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#F28");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticRed"), "#F29");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#F30");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#F31");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#F32");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#F33");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#F34");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#F35");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#F36");

			flags = BindingFlags.Static | BindingFlags.Public |
				BindingFlags.FlattenHierarchy;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#G1");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#G2");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#G3");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#G4");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#G5");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#G6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#G7");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#G8");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#G9");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#G10");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#G11");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#G12");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#G13");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#G14");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#G15");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#G16");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#G17");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#G18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#G19");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#G20");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#G21");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#G22");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#G23");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#G24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#G25");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#G26");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#G27");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#G28");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicStaticRed"), "#G29");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#G30");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#G31");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#G32");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#G33");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#G34");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#G35");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#G36");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.FlattenHierarchy;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#H1");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#H2");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#H3");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#H4");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#H5");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#H6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#H7");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#H8");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#H9");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#H10");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#H11");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#H12");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#H13");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#H14");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#H15");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#H16");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#H17");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#H18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#H19");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#H20");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#H21");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#H22");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#H23");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#H24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#H25");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#H26");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#H27");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#H28");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticRed"), "#H29");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#H30");
			Assert.IsNotNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#H31");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#H32");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#H33");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#H34");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#H35");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#H36");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.DeclaredOnly;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#I1");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#I2");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#I3");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#I4");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#I5");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#I6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#I7");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#I8");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#I9");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#I10");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#I11");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#I12");
			Assert.IsNotNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#I13");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#I14");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#I15");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#I16");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#I17");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#I18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#I19");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#I20");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#I21");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#I22");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#I23");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#I24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#I25");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#I26");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#I27");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#I28");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticRed"), "#I29");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#I30");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#I31");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#I32");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#I33");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#I34");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#I35");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#I36");

			flags = BindingFlags.Instance | BindingFlags.Public |
				BindingFlags.DeclaredOnly;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#J1");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#J2");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#J3");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#J4");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#J5");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#J6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#J7");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#J8");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#J9");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#J10");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#J11");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#J12");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#J13");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#J14");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#J15");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#J16");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#J17");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#J18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#J19");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#J20");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#J21");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#J22");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#J23");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#J24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#J25");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#J26");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#J27");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#J28");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticRed"), "#J29");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#J30");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#J31");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#J32");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#J33");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#J34");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#J35");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#J36");

			flags = BindingFlags.Static | BindingFlags.Public |
				BindingFlags.DeclaredOnly;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#K1");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#K2");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#K3");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#K4");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#K5");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#K6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#K7");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#K8");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#K9");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#K10");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#K11");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#K12");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#K13");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#K14");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#K15");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#K16");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#K17");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#K18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#K19");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#K20");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#K21");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#K22");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#K23");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#K24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#K25");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#K26");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#K27");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#K28");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticRed"), "#K29");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#K30");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#K31");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#K32");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#K33");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#K34");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#K35");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#K36");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.DeclaredOnly;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#L1");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#L2");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#L3");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#L4");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#L5");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#L6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#L7");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#L8");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#L9");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#L10");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#L11");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#L12");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#L13");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#L14");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#L15");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#L16");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#L17");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#L18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#L19");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#L20");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#L21");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#L22");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#L23");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#L24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#L25");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#L26");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#L27");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#L28");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticRed"), "#L29");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#L30");
			Assert.IsNotNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#L31");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#L32");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#L33");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#L34");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#L35");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#L36");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.Public;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#M1");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#M2");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#M3");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#M4");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#M5");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#M6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#M7");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#M8");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#M9");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#M10");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#M11");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#M12");
			Assert.IsNotNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#M13");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#M14");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#M15");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#M16");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#M17");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#M18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#M19");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#M20");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#M21");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#M22");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#M23");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#M24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#M25");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#M26");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#M27");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#M28");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticRed"), "#M29");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#M30");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#M31");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#M32");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#M33");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#M34");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#M35");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#M36");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.Public;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#N1");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#N2");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#N3");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#N4");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#N5");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#N6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#N7");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#N8");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#N9");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#N10");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#N11");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#N12");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#N13");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#N14");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#N15");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#N16");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#N17");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#N18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#N19");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#N20");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#N21");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#N22");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#N23");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#N24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#N25");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#N26");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#N27");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#N28");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticRed"), "#N29");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#N30");
			Assert.IsNotNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#N31");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#N32");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#N33");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#N34");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#N35");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#N36");
		}

		[Test]
		[Category ("NotDotNet")] // mcs depends on this
		public void TestGetMethodsFlagsIncomplete_Mono ()
		{
			MethodBuilder mb;
			ILGenerator ilgen;
			MethodInfo [] methods;

			TypeBuilder tb = module.DefineType (genTypeName (),
				TypeAttributes.Abstract);
			mb = tb.DefineMethod ("Hello", MethodAttributes.Public,
				typeof (void), Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ret);

			mb = tb.DefineMethod ("Run", MethodAttributes.Private,
				typeof (void), Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ret);

			mb = tb.DefineMethod ("Execute", MethodAttributes.Public |
				MethodAttributes.Static,
				typeof (void), Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ret);

			mb = tb.DefineMethod ("Init", MethodAttributes.Public |
				MethodAttributes.Abstract | MethodAttributes.Virtual,
				typeof (void), Type.EmptyTypes);

			methods = tb.GetMethods (BindingFlags.Public |
				BindingFlags.Instance);
			Assert.AreEqual (6, methods.Length, "#A1");
			Assert.IsNotNull (GetMethodByName (methods, "Hello"), "#A2");
			Assert.IsNotNull (GetMethodByName (methods, "Init"), "#A3");
			Assert.IsNotNull (GetMethodByName (methods, "ToString"), "#A4");
			Assert.IsNotNull (GetMethodByName (methods, "Equals"), "#A5");
			Assert.IsNotNull (GetMethodByName (methods, "GetHashCode"), "#A6");

			methods = tb.GetMethods (BindingFlags.Public |
				BindingFlags.Instance | BindingFlags.DeclaredOnly);
			Assert.AreEqual (2, methods.Length, "#B1");
			Assert.IsNotNull (GetMethodByName (methods, "Hello"), "#B2");
			Assert.IsNotNull (GetMethodByName (methods, "Init"), "#B3");

			methods = tb.GetMethods (BindingFlags.Public |
				BindingFlags.Instance | BindingFlags.Static);
			Assert.AreEqual (7, methods.Length, "#C1");
			Assert.IsNotNull (GetMethodByName (methods, "Hello"), "#C2");
			Assert.IsNotNull (GetMethodByName (methods, "Init"), "#C3");
			Assert.IsNotNull (GetMethodByName (methods, "Execute"), "#C4");
			Assert.IsNotNull (GetMethodByName (methods, "ToString"), "#C5");
			Assert.IsNotNull (GetMethodByName (methods, "Equals"), "#C6");
			Assert.IsNotNull (GetMethodByName (methods, "GetHashCode"), "#C7");

			methods = tb.GetMethods (BindingFlags.NonPublic |
				BindingFlags.Instance | BindingFlags.DeclaredOnly);
			Assert.AreEqual (1, methods.Length, "#D1");
			Assert.IsNotNull (GetMethodByName (methods, "Run"), "#D2");
		}


		[Test]
		[Category ("NotWorking")] // mcs depends on this
		public void TestGetMethodsFlagsIncomplete_MS ()
		{
			MethodBuilder mb;
			ILGenerator ilgen;

			TypeBuilder tb = module.DefineType (genTypeName (),
				TypeAttributes.Abstract);
			mb = tb.DefineMethod ("Hello", MethodAttributes.Public,
				typeof (void), Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ret);

			mb = tb.DefineMethod ("Run", MethodAttributes.Private,
				typeof (void), Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ret);

			mb = tb.DefineMethod ("Execute", MethodAttributes.Public |
				MethodAttributes.Static,
				typeof (void), Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ret);

			mb = tb.DefineMethod ("Init", MethodAttributes.Public |
				MethodAttributes.Abstract | MethodAttributes.Virtual,
				typeof (void), Type.EmptyTypes);

			try {
				tb.GetMethods (BindingFlags.Public | BindingFlags.Instance);
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void TestGetMethodsFlagsComplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			MethodBuilder helloMethod = tb.DefineMethod ("HelloMethod",
				MethodAttributes.Public, typeof (string), Type.EmptyTypes);
			ILGenerator helloMethodIL = helloMethod.GetILGenerator ();
			helloMethodIL.Emit (OpCodes.Ldstr, "Hi! ");
			helloMethodIL.Emit (OpCodes.Ldarg_1);
			MethodInfo infoMethod = typeof (string).GetMethod ("Concat",
				new Type [] { typeof (string), typeof (string) });
			helloMethodIL.Emit (OpCodes.Call, infoMethod);
			helloMethodIL.Emit (OpCodes.Ret);

			Type emittedType = tb.CreateType ();

			Assert.AreEqual (1, tb.GetMethods (BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly).Length, "#1");
			Assert.AreEqual (tb.GetMethods (BindingFlags.Instance | BindingFlags.Public).Length,
				emittedType.GetMethods (BindingFlags.Instance | BindingFlags.Public).Length, "#2");
			Assert.AreEqual (0, tb.GetMethods (BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.DeclaredOnly).Length, "#3");
			Assert.AreEqual (tb.GetMethods (BindingFlags.Instance | BindingFlags.NonPublic).Length,
				emittedType.GetMethods (BindingFlags.Instance | BindingFlags.NonPublic).Length, "#4");
		}

		[Test]
		public void TestGetMethodsFlagsComplete_Inheritance ()
		{
			MethodInfo [] methods;
			BindingFlags flags;

			TypeBuilder blueType = module.DefineType (genTypeName (),
				TypeAttributes.Public);
			CreateMembers (blueType, "Blue", false);

			TypeBuilder redType = module.DefineType (genTypeName (),
				TypeAttributes.Public, blueType);
			CreateMembers (redType, "Red", false);

			TypeBuilder greenType = module.DefineType (genTypeName (),
				TypeAttributes.Public, redType);
			CreateMembers (greenType, "Green", false);

			blueType.CreateType ();
			redType.CreateType ();
			greenType.CreateType ();

			flags = BindingFlags.Instance | BindingFlags.NonPublic;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#A1");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#A2");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#A3");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#A4");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#A5");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#A6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#A7");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#A8");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#A9");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#A10");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#A11");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#A12");
			Assert.IsNotNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#A13");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#A14");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#A15");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#A16");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#A17");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#A18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#A19");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#A20");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#A21");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#A22");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#A23");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#A24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#A25");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#A26");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#A27");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#A28");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticRed"), "#A29");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#A30");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#A31");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#A32");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#A33");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#A34");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#A35");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#A36");

			flags = BindingFlags.Instance | BindingFlags.Public;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#B1");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#B2");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#B3");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#B4");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#B5");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#B6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#B7");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#B8");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#B9");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#B10");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#B11");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#B12");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#B13");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#B14");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#B15");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#B16");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#B17");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#B18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#B19");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#B20");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#B21");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#B22");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#B23");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#B24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#B25");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#B26");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#B27");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#B28");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticRed"), "#B29");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#B30");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#B31");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#B32");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#B33");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#B34");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#B35");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#B36");

			flags = BindingFlags.Static | BindingFlags.Public;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#C1");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#C2");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#C3");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#C4");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#C5");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#C6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#C7");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#C8");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#C9");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#C10");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#C11");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#C12");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#C13");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#C14");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#C15");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#C16");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#C17");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#C18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#C19");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#C20");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#C21");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#C22");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#C23");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#C24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#C25");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#C26");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#C27");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#C28");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticRed"), "#C29");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#C30");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#C31");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#C32");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#C33");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#C34");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#C35");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#C36");

			flags = BindingFlags.Static | BindingFlags.NonPublic;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#D1");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#D2");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#D3");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#D4");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#D5");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#D6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#D7");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#D8");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#D9");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#D10");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#D11");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#D12");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#D13");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#D14");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#D15");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#D16");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#D17");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#D18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#D19");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#D20");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#D21");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#D22");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#D23");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#D24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#D25");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#D26");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#D27");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#D28");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticRed"), "#D29");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#D30");
			Assert.IsNotNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#D31");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#D32");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#D33");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#D34");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#D35");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#D36");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.FlattenHierarchy;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#E1");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#E2");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#E3");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#E4");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#E5");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#E6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#E7");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#E8");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#E9");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#E10");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#E11");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#E12");
			Assert.IsNotNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#E13");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#E14");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#E15");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#E16");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#E17");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#E18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#E19");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#E20");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#E21");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#E22");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#E23");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#E24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#E25");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#E26");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#E27");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#E28");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticRed"), "#E29");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#E30");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#E31");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#E32");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#E33");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#E34");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#E35");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#E36");

			flags = BindingFlags.Instance | BindingFlags.Public |
				BindingFlags.FlattenHierarchy;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#F1");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#F2");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#F3");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#F4");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#F5");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#F6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#F7");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#F8");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#F9");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#F10");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#F11");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#F12");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#F13");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#F14");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#F15");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#F16");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#F17");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#F18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#F19");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#F20");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#F21");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#F22");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#F23");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#F24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#F25");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#F26");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#F27");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#F28");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticRed"), "#F29");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#F30");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#F31");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#F32");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#F33");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#F34");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#F35");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#F36");

			flags = BindingFlags.Static | BindingFlags.Public |
				BindingFlags.FlattenHierarchy;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#G1");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#G2");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#G3");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#G4");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#G5");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#G6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#G7");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#G8");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#G9");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#G10");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#G11");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#G12");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#G13");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#G14");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#G15");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#G16");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#G17");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#G18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#G19");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#G20");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#G21");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#G22");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#G23");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#G24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#G25");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#G26");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#G27");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#G28");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicStaticRed"), "#G29");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#G30");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#G31");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#G32");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#G33");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#G34");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#G35");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#G36");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.FlattenHierarchy;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#H1");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#H2");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#H3");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#H4");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#H5");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#H6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#H7");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#H8");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#H9");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#H10");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#H11");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#H12");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#H13");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#H14");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#H15");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#H16");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#H17");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#H18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#H19");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#H20");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#H21");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#H22");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#H23");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#H24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#H25");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#H26");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#H27");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#H28");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticRed"), "#H29");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#H30");
			Assert.IsNotNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#H31");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#H32");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#H33");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#H34");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#H35");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#H36");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.DeclaredOnly;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#I1");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#I2");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#I3");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#I4");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#I5");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#I6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#I7");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#I8");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#I9");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#I10");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#I11");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#I12");
			Assert.IsNotNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#I13");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#I14");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#I15");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#I16");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#I17");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#I18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#I19");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#I20");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#I21");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#I22");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#I23");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#I24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#I25");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#I26");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#I27");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#I28");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticRed"), "#I29");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#I30");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#I31");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#I32");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#I33");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#I34");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#I35");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#I36");

			flags = BindingFlags.Instance | BindingFlags.Public |
				BindingFlags.DeclaredOnly;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#J1");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#J2");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#J3");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#J4");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#J5");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#J6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#J7");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#J8");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#J9");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#J10");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#J11");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#J12");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#J13");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#J14");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#J15");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#J16");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#J17");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#J18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#J19");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#J20");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#J21");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#J22");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#J23");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#J24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#J25");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#J26");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#J27");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#J28");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticRed"), "#J29");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#J30");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#J31");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#J32");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#J33");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#J34");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#J35");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#J36");

			flags = BindingFlags.Static | BindingFlags.Public |
				BindingFlags.DeclaredOnly;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#K1");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#K2");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#K3");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#K4");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#K5");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#K6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#K7");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#K8");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#K9");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#K10");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#K11");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#K12");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#K13");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#K14");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#K15");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#K16");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#K17");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#K18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#K19");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#K20");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#K21");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#K22");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#K23");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#K24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#K25");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#K26");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#K27");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#K28");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticRed"), "#K29");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#K30");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#K31");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#K32");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#K33");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#K34");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#K35");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#K36");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.DeclaredOnly;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#L1");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#L2");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#L3");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#L4");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#L5");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#L6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#L7");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#L8");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#L9");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#L10");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#L11");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#L12");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#L13");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#L14");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#L15");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#L16");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#L17");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#L18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#L19");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#L20");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#L21");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#L22");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#L23");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#L24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#L25");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#L26");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#L27");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#L28");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticRed"), "#L29");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#L30");
			Assert.IsNotNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#L31");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#L32");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#L33");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#L34");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#L35");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#L36");

			flags = BindingFlags.Instance | BindingFlags.NonPublic |
				BindingFlags.Public;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#M1");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#M2");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#M3");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#M4");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#M5");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#M6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#M7");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#M8");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#M9");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#M10");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#M11");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#M12");
			Assert.IsNotNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#M13");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#M14");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#M15");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#M16");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#M17");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#M18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#M19");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#M20");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#M21");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#M22");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#M23");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#M24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#M25");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#M26");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#M27");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#M28");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticRed"), "#M29");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#M30");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#M31");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#M32");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#M33");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#M34");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#M35");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#M36");

			flags = BindingFlags.Static | BindingFlags.NonPublic |
				BindingFlags.Public;
			methods = greenType.GetMethods (flags);

			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceBlue"), "#N1");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceBlue"), "#N2");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceBlue"), "#N3");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceBlue"), "#N4");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceBlue"), "#N5");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceBlue"), "#N6");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceRed"), "#N7");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceRed"), "#N8");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceRed"), "#N9");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceRed"), "#N10");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceRed"), "#N11");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceRed"), "#N12");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateInstanceGreen"), "#N13");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyInstanceGreen"), "#N14");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemInstanceGreen"), "#N15");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemInstanceGreen"), "#N16");
			Assert.IsNull (GetMethodByName (methods, "GetPublicInstanceGreen"), "#N17");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyInstanceGreen"), "#N18");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticBlue"), "#N19");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticBlue"), "#N20");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticBlue"), "#N21");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticBlue"), "#N22");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticBlue"), "#N23");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticBlue"), "#N24");
			Assert.IsNull (GetMethodByName (methods, "GetPrivateStaticRed"), "#N25");
			Assert.IsNull (GetMethodByName (methods, "GetFamilyStaticRed"), "#N26");
			Assert.IsNull (GetMethodByName (methods, "GetFamANDAssemStaticRed"), "#N27");
			Assert.IsNull (GetMethodByName (methods, "GetFamORAssemStaticRed"), "#N28");
			Assert.IsNull (GetMethodByName (methods, "GetPublicStaticRed"), "#N29");
			Assert.IsNull (GetMethodByName (methods, "GetAssemblyStaticRed"), "#N30");
			Assert.IsNotNull (GetMethodByName (methods, "GetPrivateStaticGreen"), "#N31");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamilyStaticGreen"), "#N32");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamANDAssemStaticGreen"), "#N33");
			Assert.IsNotNull (GetMethodByName (methods, "GetFamORAssemStaticGreen"), "#N34");
			Assert.IsNotNull (GetMethodByName (methods, "GetPublicStaticGreen"), "#N35");
			Assert.IsNotNull (GetMethodByName (methods, "GetAssemblyStaticGreen"), "#N36");
		}

		[Test]
		public void TestGetMemberIncomplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			try {
				tb.GetMember ("FOO", MemberTypes.All, BindingFlags.Public);
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				// The invoked member is not supported in a
				// dynamic module
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void TestGetMemberComplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.DefineField ("FOO", typeof (int), FieldAttributes.Private);

			Type emittedType = tb.CreateType ();

			Assert.AreEqual (1, tb.GetMember ("FOO", MemberTypes.Field, BindingFlags.Instance | BindingFlags.NonPublic).Length);
			Assert.AreEqual (0, tb.GetMember ("FOO", MemberTypes.Field, BindingFlags.Instance | BindingFlags.Public).Length);
		}

		[Test]
		public void TestGetMembersIncomplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			try {
				tb.GetMembers ();
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				// The invoked member is not supported in a
				// dynamic module
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void TestGetMembersComplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Type emittedType = tb.CreateType ();

			Assert.AreEqual (tb.GetMembers ().Length, emittedType.GetMembers ().Length);
		}

		[Test]
		public void TestGetMembersFlagsIncomplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			try {
				tb.GetMembers (BindingFlags.Public);
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				// The invoked member is not supported in a
				// dynamic module
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void TestGetMembersFlagsComplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.DefineField ("FOO", typeof (int), FieldAttributes.Public);

			Type emittedType = tb.CreateType ();

			Assert.IsTrue (tb.GetMembers (BindingFlags.Instance | BindingFlags.Public).Length != 0);
			Assert.AreEqual (tb.GetMembers (BindingFlags.Instance | BindingFlags.Public).Length,
				emittedType.GetMembers (BindingFlags.Instance | BindingFlags.Public).Length);
			Assert.AreEqual (tb.GetMembers (BindingFlags.Instance | BindingFlags.NonPublic).Length,
				emittedType.GetMembers (BindingFlags.Instance | BindingFlags.NonPublic).Length);
		}

		[Test]
		public void TestGetInterfaceIncomplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			try {
				tb.GetInterface ("FOO", true);
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				// The invoked member is not supported in a
				// dynamic module
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void TestGetInterfaces ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Type [] interfaces = tb.GetInterfaces ();
			Assert.AreEqual (0, interfaces.Length);

			TypeBuilder tbInterface = module.DefineType (genTypeName (), TypeAttributes.Public | TypeAttributes.Interface | TypeAttributes.Abstract);
			Type emittedInterface = tbInterface.CreateType ();

			tb = module.DefineType (genTypeName (), TypeAttributes.Public, typeof (object), new Type [] { emittedInterface });
			interfaces = tb.GetInterfaces ();
			Assert.AreEqual (1, interfaces.Length);
		}

		[Test]
		[Category ("MobileNotWorking")] // Not available in the 2.1 profile
		public void TestAddDeclarativeSecurityAlreadyCreated ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.CreateType ();

			PermissionSet set = new PermissionSet (PermissionState.Unrestricted);
			try {
				tb.AddDeclarativeSecurity (SecurityAction.Demand, set);
				Assert.Fail ("#1");
			} catch (InvalidOperationException ex) {
				// Unable to change after type has been created
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		[Category ("MobileNotWorking")] // Not available in the 2.1 profile
		public void TestAddDeclarativeSecurityNullPermissionSet ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			try {
				tb.AddDeclarativeSecurity (SecurityAction.Demand, null);
				Assert.Fail ("#1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
				Assert.AreEqual ("pset", ex.ParamName, "#5");
			}

		}

		[Test]
		[Category ("MobileNotWorking")] // Not available in the 2.1 profile
		public void TestAddDeclarativeSecurityInvalidAction ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());

			SecurityAction [] actions = new SecurityAction [] { 
			SecurityAction.RequestMinimum,
			SecurityAction.RequestOptional,
			SecurityAction.RequestRefuse };
			PermissionSet set = new PermissionSet (PermissionState.Unrestricted);

			foreach (SecurityAction action in actions) {
				try {
					tb.AddDeclarativeSecurity (action, set);
					Assert.Fail ();
				} catch (ArgumentOutOfRangeException) {
				}
			}
		}

		[Test]
		[Category ("MobileNotWorking")] // Not available in the 2.1 profile
		public void TestAddDeclarativeSecurityDuplicateAction ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());

			PermissionSet set = new PermissionSet (PermissionState.Unrestricted);
			tb.AddDeclarativeSecurity (SecurityAction.Demand, set);
			try {
				tb.AddDeclarativeSecurity (SecurityAction.Demand, set);
				Assert.Fail ("#1");
			} catch (InvalidOperationException ex) {
				// Multiple permission sets specified with the
				// same SecurityAction
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void TestEnums ()
		{
			TypeAttributes typeAttrs = TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.Sealed;
			TypeBuilder enumToCreate = module.DefineType (genTypeName (), typeAttrs,
														 typeof (Enum));
			enumToCreate.SetCustomAttribute (new CustomAttributeBuilder (typeof (FlagsAttribute).GetConstructors () [0], Type.EmptyTypes));
			// add value__ field, see DefineEnum method of ModuleBuilder
			enumToCreate.DefineField ("value__", typeof (Int32),
				FieldAttributes.Public | FieldAttributes.SpecialName | FieldAttributes.RTSpecialName);

			// add enum entries
			FieldBuilder fb = enumToCreate.DefineField ("A", enumToCreate,
				FieldAttributes.Public | FieldAttributes.Static | FieldAttributes.Literal);
			fb.SetConstant ((Int32) 0);

			fb = enumToCreate.DefineField ("B", enumToCreate,
				FieldAttributes.Public | FieldAttributes.Static | FieldAttributes.Literal);
			fb.SetConstant ((Int32) 1);

			fb = enumToCreate.DefineField ("C", enumToCreate,
				FieldAttributes.Public | FieldAttributes.Static | FieldAttributes.Literal);
			fb.SetConstant ((Int32) 2);

			Type enumType = enumToCreate.CreateType ();

			object enumVal = Enum.ToObject (enumType, (Int32) 3);

			Assert.AreEqual ("B, C", enumVal.ToString ());
			Assert.AreEqual (3, (Int32) enumVal);
		}

		[Test]
		public void DefineEnum ()
		{
			TypeBuilder typeBuilder = module.DefineType (genTypeName (),
														 TypeAttributes.Public);
			EnumBuilder enumBuilder = module.DefineEnum (genTypeName (),
														 TypeAttributes.Public, typeof (int));
			typeBuilder.DefineField ("myField", enumBuilder, FieldAttributes.Private);
			enumBuilder.CreateType ();
			typeBuilder.CreateType ();
		}

		[Test]
		[Category ("NotWorking")]
		public void DefineEnumThrowIfTypeBuilderCalledBeforeEnumBuilder ()
		{
			TypeBuilder typeBuilder = module.DefineType (genTypeName (),
														 TypeAttributes.Public);
			EnumBuilder enumBuilder = module.DefineEnum (genTypeName (),
														 TypeAttributes.Public, typeof (int));
			typeBuilder.DefineField ("myField", enumBuilder, FieldAttributes.Private);
			try {
				typeBuilder.CreateType ();
				Assert.Fail ("#1");
			} catch (TypeLoadException) {
				// Could not load type '...' from assembly
				// 'MonoTests.System.Reflection.Emit.TypeBuilderTest, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null'
			}
			Assert.IsTrue (typeBuilder.IsCreated (), "#2");
			Assert.IsNull (typeBuilder.CreateType (), "#3");
		}

		[Test]
		public void SetCustomAttribute_SuppressUnmanagedCodeSecurity ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			ConstructorInfo attrCtor = typeof (SuppressUnmanagedCodeSecurityAttribute).
				GetConstructor (Type.EmptyTypes);
			CustomAttributeBuilder caBuilder = new CustomAttributeBuilder (
				attrCtor, new object [0]);
			Assert.IsTrue ((tb.Attributes & TypeAttributes.HasSecurity) == 0, "#1");
			tb.SetCustomAttribute (caBuilder);
			//Assert.IsTrue ((tb.Attributes & TypeAttributes.HasSecurity) == 0, "#2");
			Type emittedType = tb.CreateType ();
			Assert.AreEqual (TypeAttributes.HasSecurity, emittedType.Attributes & TypeAttributes.HasSecurity, "#3");
			//Assert.IsTrue ((tb.Attributes & TypeAttributes.HasSecurity) == 0, "#4");
			object [] emittedAttrs = emittedType.GetCustomAttributes (typeof (SuppressUnmanagedCodeSecurityAttribute), true);
			Assert.AreEqual (1, emittedAttrs.Length, "#5");
		}

		private PropertyBuilder DefineStringProperty (TypeBuilder tb, string propertyName, string fieldName, MethodAttributes methodAttribs)
		{
			// define the field holding the property value
			FieldBuilder fieldBuilder = tb.DefineField (fieldName,
				typeof (string), FieldAttributes.Private);

			PropertyBuilder propertyBuilder = tb.DefineProperty (
				propertyName, PropertyAttributes.HasDefault, typeof (string),
				new Type [] { typeof (string) });

			// First, we'll define the behavior of the "get" property for CustomerName as a method.
			MethodBuilder getMethodBuilder = tb.DefineMethod ("Get" + propertyName,
									methodAttribs,
									typeof (string),
									new Type [] { });

			ILGenerator getIL = getMethodBuilder.GetILGenerator ();

			getIL.Emit (OpCodes.Ldarg_0);
			getIL.Emit (OpCodes.Ldfld, fieldBuilder);
			getIL.Emit (OpCodes.Ret);

			// Now, we'll define the behavior of the "set" property for CustomerName.
			MethodBuilder setMethodBuilder = tb.DefineMethod ("Set" + propertyName,
									methodAttribs,
									null,
									new Type [] { typeof (string) });

			ILGenerator setIL = setMethodBuilder.GetILGenerator ();

			setIL.Emit (OpCodes.Ldarg_0);
			setIL.Emit (OpCodes.Ldarg_1);
			setIL.Emit (OpCodes.Stfld, fieldBuilder);
			setIL.Emit (OpCodes.Ret);

			// Last, we must map the two methods created above to our PropertyBuilder to 
			// their corresponding behaviors, "get" and "set" respectively. 
			propertyBuilder.SetGetMethod (getMethodBuilder);
			propertyBuilder.SetSetMethod (setMethodBuilder);
			return propertyBuilder;
		}

		static int handler_called = 0;

		[Test]
		public void TestTypeResolve ()
		{
			string typeName = genTypeName ();

			ResolveEventHandler handler = new ResolveEventHandler (TypeResolve);
			AppDomain.CurrentDomain.TypeResolve += handler;
			handler_called = 0;
			Type t = Type.GetType (typeName);
			Assert.AreEqual (typeName, t.Name);
			Assert.AreEqual (1, handler_called);
			AppDomain.CurrentDomain.TypeResolve -= handler;
		}

		Assembly TypeResolve (object sender, ResolveEventArgs args)
		{
			TypeBuilder tb = module.DefineType (args.Name, TypeAttributes.Public);
			tb.CreateType ();
			handler_called++;
			return tb.Assembly;
		}

		[Test]
		public void IsAssignableFrom_Created ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (),
				TypeAttributes.Public, typeof (MemoryStream),
				new Type [] { typeof (IThrowable), typeof (Bar) });
			tb.AddInterfaceImplementation (typeof (IDestroyable));
			Type emitted_type = tb.CreateType ();

			Assert.IsTrue (typeof (IThrowable).IsAssignableFrom (tb), "#A1");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (IThrowable)), "#A2");
			Assert.IsTrue (typeof (IMoveable).IsAssignableFrom (tb), "#A3");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (IMoveable)), "#A4");
			Assert.IsTrue (typeof (Foo).IsAssignableFrom (tb), "#A5");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (Foo)), "#A6");
			Assert.IsTrue (typeof (Bar).IsAssignableFrom (tb), "#A7");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (Bar)), "#A8");
			Assert.IsFalse (typeof (Baz).IsAssignableFrom (tb), "#A9");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (Baz)), "#A10");
			Assert.IsTrue (typeof (IDestroyable).IsAssignableFrom (tb), "#A11");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (IDestroyable)), "#A12");
			Assert.IsFalse (typeof (IAir).IsAssignableFrom (tb), "#A13");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (IAir)), "#A14");
			Assert.IsFalse (typeof (IWater).IsAssignableFrom (tb), "#A15");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (IWater)), "#A16");
			Assert.IsFalse (typeof (ILiquid).IsAssignableFrom (tb), "#A17");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (ILiquid)), "#A18");

			Assert.IsTrue (typeof (MemoryStream).IsAssignableFrom (tb), "#B1");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (MemoryStream)), "#B2");
			Assert.IsTrue (typeof (Stream).IsAssignableFrom (tb), "#B3");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (Stream)), "#B4");
			Assert.IsFalse (typeof (FileStream).IsAssignableFrom (tb), "#B5");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (FileStream)), "#B6");
			Assert.IsTrue (typeof (object).IsAssignableFrom (tb), "#B7");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (object)), "#B8");
			Assert.IsTrue (typeof (IDisposable).IsAssignableFrom (tb), "#B9");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (IDisposable)), "#B10");

			Assert.IsTrue (tb.IsAssignableFrom (tb), "#C1");
			Assert.IsFalse (tb.IsAssignableFrom ((Type) null), "#C2");
			Assert.IsTrue (tb.IsAssignableFrom (emitted_type), "#C3");
			Assert.IsTrue (emitted_type.IsAssignableFrom (tb), "#C4");
			Assert.IsFalse (emitted_type.IsAssignableFrom ((Type) null), "#C5");

			Assert.IsTrue (typeof (IThrowable).IsAssignableFrom (emitted_type), "#D1");
			Assert.IsFalse (emitted_type.IsAssignableFrom (typeof (IThrowable)), "#D2");
			Assert.IsTrue (typeof (IMoveable).IsAssignableFrom (emitted_type), "#D3");
			Assert.IsFalse (emitted_type.IsAssignableFrom (typeof (IMoveable)), "#D4");
			Assert.IsTrue (typeof (Foo).IsAssignableFrom (emitted_type), "#D5");
			Assert.IsFalse (emitted_type.IsAssignableFrom (typeof (Foo)), "#D6");
			Assert.IsTrue (typeof (Bar).IsAssignableFrom (emitted_type), "#D7");
			Assert.IsFalse (emitted_type.IsAssignableFrom (typeof (Bar)), "#D8");
			Assert.IsFalse (typeof (Baz).IsAssignableFrom (emitted_type), "#D9");
			Assert.IsFalse (emitted_type.IsAssignableFrom (typeof (Baz)), "#D10");
			Assert.IsTrue (typeof (IDestroyable).IsAssignableFrom (emitted_type), "#D11");
			Assert.IsFalse (emitted_type.IsAssignableFrom (typeof (IDestroyable)), "#D12");
			Assert.IsFalse (typeof (IAir).IsAssignableFrom (emitted_type), "#D13");
			Assert.IsFalse (emitted_type.IsAssignableFrom (typeof (IAir)), "#D14");
			Assert.IsFalse (typeof (IWater).IsAssignableFrom (emitted_type), "#D15");
			Assert.IsFalse (emitted_type.IsAssignableFrom (typeof (IWater)), "#D16");
			Assert.IsFalse (typeof (ILiquid).IsAssignableFrom (emitted_type), "#D17");
			Assert.IsFalse (emitted_type.IsAssignableFrom (typeof (ILiquid)), "#D18");

			Assert.IsTrue (typeof (MemoryStream).IsAssignableFrom (emitted_type), "#E1");
			Assert.IsFalse (emitted_type.IsAssignableFrom (typeof (MemoryStream)), "#E2");
			Assert.IsTrue (typeof (Stream).IsAssignableFrom (emitted_type), "#E3");
			Assert.IsFalse (emitted_type.IsAssignableFrom (typeof (Stream)), "#E4");
			Assert.IsFalse (typeof (FileStream).IsAssignableFrom (emitted_type), "#E5");
			Assert.IsFalse (emitted_type.IsAssignableFrom (typeof (FileStream)), "#E6");
			Assert.IsTrue (typeof (object).IsAssignableFrom (emitted_type), "#E7");
			Assert.IsFalse (emitted_type.IsAssignableFrom (typeof (object)), "#E8");
			Assert.IsTrue (typeof (IDisposable).IsAssignableFrom (emitted_type), "#E9");
			Assert.IsFalse (emitted_type.IsAssignableFrom (typeof (IDisposable)), "#E10");

			Assert.IsTrue (typeof (Foo []).IsAssignableFrom (module.GetType (
				tb.FullName + "[]")), "#F1");
			Assert.IsTrue (typeof (Bar []).IsAssignableFrom (module.GetType (
				tb.FullName + "[]")), "#F2");
			Assert.IsFalse (typeof (Baz []).IsAssignableFrom (module.GetType (
				tb.FullName + "[]")), "#F3");

			TypeBuilder tb2 = module.DefineType (genTypeName (),
				TypeAttributes.Public, tb,
				new Type [] { typeof (IAir) });
			Type emitted_type2 = tb2.CreateType ();

			Assert.IsTrue (typeof (IThrowable).IsAssignableFrom (tb2), "#G1");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (IThrowable)), "#G2");
			Assert.IsTrue (typeof (IMoveable).IsAssignableFrom (tb2), "#G3");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (IMoveable)), "#G4");
			Assert.IsTrue (typeof (Foo).IsAssignableFrom (tb2), "#G5");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (Foo)), "#G6");
			Assert.IsTrue (typeof (Bar).IsAssignableFrom (tb2), "#G7");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (Bar)), "#G8");
			Assert.IsFalse (typeof (Baz).IsAssignableFrom (tb2), "#G9");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (Baz)), "#G10");
			Assert.IsTrue (typeof (IDestroyable).IsAssignableFrom (tb2), "#G11");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (IDestroyable)), "#G12");
			Assert.IsTrue (typeof (IAir).IsAssignableFrom (tb2), "#G13");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (IAir)), "#G14");
			Assert.IsFalse (typeof (IWater).IsAssignableFrom (tb2), "#G15");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (IWater)), "#G16");
			Assert.IsFalse (typeof (ILiquid).IsAssignableFrom (tb2), "#G17");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (ILiquid)), "#G18");

			Assert.IsTrue (typeof (MemoryStream).IsAssignableFrom (tb2), "#H1");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (MemoryStream)), "#H2");
			Assert.IsTrue (typeof (Stream).IsAssignableFrom (tb2), "#H3");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (Stream)), "#H4");
			Assert.IsFalse (typeof (FileStream).IsAssignableFrom (tb2), "#H5");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (FileStream)), "#H6");
			Assert.IsTrue (typeof (object).IsAssignableFrom (tb2), "#H7");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (object)), "#H8");
			Assert.IsTrue (typeof (IDisposable).IsAssignableFrom (tb2), "#H9");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (IDisposable)), "#H10");

			Assert.IsTrue (tb2.IsAssignableFrom (tb2), "#I1");
			Assert.IsFalse (tb2.IsAssignableFrom (tb), "#I2");
			Assert.IsTrue (tb2.IsAssignableFrom (emitted_type2), "#I3");
			Assert.IsFalse (tb2.IsAssignableFrom (emitted_type), "#I4");
			Assert.IsFalse (tb2.IsAssignableFrom ((Type) null), "#I5");
			Assert.IsTrue (emitted_type2.IsAssignableFrom (emitted_type2), "#I6");
			Assert.IsFalse (emitted_type2.IsAssignableFrom (emitted_type), "#I7");
			Assert.IsTrue (emitted_type2.IsAssignableFrom (tb2), "#I8");
			Assert.IsFalse (emitted_type2.IsAssignableFrom (tb), "#I9");
			Assert.IsFalse (emitted_type2.IsAssignableFrom ((Type) null), "#I10");
			Assert.IsTrue (tb.IsAssignableFrom (tb2), "#I11");
			Assert.IsTrue (tb.IsAssignableFrom (emitted_type2), "#I12");
			Assert.IsTrue (emitted_type.IsAssignableFrom (tb2), "#I13");
			Assert.IsTrue (emitted_type.IsAssignableFrom (emitted_type2), "#I14");

			Assert.IsTrue (typeof (IThrowable).IsAssignableFrom (emitted_type2), "#J1");
			Assert.IsFalse (emitted_type2.IsAssignableFrom (typeof (IThrowable)), "#J2");
			Assert.IsTrue (typeof (IMoveable).IsAssignableFrom (emitted_type2), "#J3");
			Assert.IsFalse (emitted_type2.IsAssignableFrom (typeof (IMoveable)), "#J4");
			Assert.IsTrue (typeof (Foo).IsAssignableFrom (emitted_type2), "#J5");
			Assert.IsFalse (emitted_type2.IsAssignableFrom (typeof (Foo)), "#J6");
			Assert.IsTrue (typeof (Bar).IsAssignableFrom (emitted_type2), "#J7");
			Assert.IsFalse (emitted_type2.IsAssignableFrom (typeof (Bar)), "#J8");
			Assert.IsFalse (typeof (Baz).IsAssignableFrom (emitted_type2), "#J9");
			Assert.IsFalse (emitted_type2.IsAssignableFrom (typeof (Baz)), "#J10");
			Assert.IsTrue (typeof (IDestroyable).IsAssignableFrom (tb2), "#J11");
			Assert.IsFalse (emitted_type2.IsAssignableFrom (typeof (IDestroyable)), "#J12");
			Assert.IsTrue (typeof (IAir).IsAssignableFrom (emitted_type2), "#J13");
			Assert.IsFalse (emitted_type2.IsAssignableFrom (typeof (IAir)), "#J14");
			Assert.IsFalse (typeof (IWater).IsAssignableFrom (emitted_type2), "#J15");
			Assert.IsFalse (emitted_type2.IsAssignableFrom (typeof (IWater)), "#J16");
			Assert.IsFalse (typeof (ILiquid).IsAssignableFrom (emitted_type2), "#J17");
			Assert.IsFalse (emitted_type2.IsAssignableFrom (typeof (ILiquid)), "#J18");

			Assert.IsTrue (typeof (MemoryStream).IsAssignableFrom (emitted_type2), "#K1");
			Assert.IsFalse (emitted_type2.IsAssignableFrom (typeof (MemoryStream)), "#K2");
			Assert.IsTrue (typeof (Stream).IsAssignableFrom (emitted_type2), "#K3");
			Assert.IsFalse (emitted_type2.IsAssignableFrom (typeof (Stream)), "#K4");
			Assert.IsFalse (typeof (FileStream).IsAssignableFrom (emitted_type2), "#K5");
			Assert.IsFalse (emitted_type2.IsAssignableFrom (typeof (FileStream)), "#K6");
			Assert.IsTrue (typeof (object).IsAssignableFrom (emitted_type2), "#K7");
			Assert.IsFalse (emitted_type2.IsAssignableFrom (typeof (object)), "#K8");
			Assert.IsTrue (typeof (IDisposable).IsAssignableFrom (emitted_type2), "#K9");
			Assert.IsFalse (emitted_type2.IsAssignableFrom (typeof (IDisposable)), "#K10");

			Assert.IsTrue (typeof (Foo []).IsAssignableFrom (module.GetType (
				tb2.FullName + "[]")), "#L1");
			Assert.IsTrue (typeof (Bar []).IsAssignableFrom (module.GetType (
				tb2.FullName + "[]")), "#L2");
			Assert.IsFalse (typeof (Baz []).IsAssignableFrom (module.GetType (
				tb2.FullName + "[]")), "#L3");

			TypeBuilder tb3 = module.DefineType (genTypeName (),
				TypeAttributes.Public, tb2,
				new Type [] { typeof (IWater) });
			Type emitted_type3 = tb3.CreateType ();

			Assert.IsTrue (typeof (IThrowable).IsAssignableFrom (tb3), "#M1");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (IThrowable)), "#M2");
			Assert.IsTrue (typeof (IMoveable).IsAssignableFrom (tb3), "#M3");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (IMoveable)), "#M4");
			Assert.IsTrue (typeof (Foo).IsAssignableFrom (tb3), "#M5");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (Foo)), "#M6");
			Assert.IsTrue (typeof (Bar).IsAssignableFrom (tb3), "#M7");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (Bar)), "#M8");
			Assert.IsFalse (typeof (Baz).IsAssignableFrom (tb3), "#M9");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (Baz)), "#M10");
			Assert.IsTrue (typeof (IDestroyable).IsAssignableFrom (tb3), "#M11");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (IDestroyable)), "#M12");
			Assert.IsTrue (typeof (IAir).IsAssignableFrom (tb3), "#M13");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (IAir)), "#M14");
			Assert.IsTrue (typeof (IWater).IsAssignableFrom (tb3), "#M15");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (IWater)), "#M16");
			Assert.IsTrue (typeof (ILiquid).IsAssignableFrom (tb3), "#M17");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (ILiquid)), "#M18");

			Assert.IsTrue (typeof (MemoryStream).IsAssignableFrom (tb3), "#N1");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (MemoryStream)), "#N2");
			Assert.IsTrue (typeof (Stream).IsAssignableFrom (tb3), "#N3");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (Stream)), "#N4");
			Assert.IsFalse (typeof (FileStream).IsAssignableFrom (tb3), "#N5");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (FileStream)), "#N6");
			Assert.IsTrue (typeof (object).IsAssignableFrom (tb3), "#N7");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (object)), "#N8");
			Assert.IsTrue (typeof (IDisposable).IsAssignableFrom (tb3), "#N9");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (IDisposable)), "#N10");

			Assert.IsTrue (tb3.IsAssignableFrom (tb3), "#O1");
			Assert.IsFalse (tb3.IsAssignableFrom (tb2), "#O2");
			Assert.IsFalse (tb3.IsAssignableFrom (tb), "#O3");
			Assert.IsTrue (tb3.IsAssignableFrom (emitted_type3), "#O4");
			Assert.IsFalse (tb3.IsAssignableFrom (emitted_type2), "#O5");
			Assert.IsFalse (tb3.IsAssignableFrom (emitted_type), "#O6");
			Assert.IsFalse (tb3.IsAssignableFrom ((Type) null), "#O7");
			Assert.IsTrue (emitted_type3.IsAssignableFrom (emitted_type3), "#O8");
			Assert.IsFalse (emitted_type3.IsAssignableFrom (emitted_type2), "#O9");
			Assert.IsFalse (emitted_type3.IsAssignableFrom (emitted_type), "#O10");
			Assert.IsTrue (emitted_type3.IsAssignableFrom (tb3), "#O11");
			Assert.IsFalse (emitted_type3.IsAssignableFrom (tb2), "#O12");
			Assert.IsFalse (emitted_type3.IsAssignableFrom (tb), "#O13");
			Assert.IsFalse (emitted_type3.IsAssignableFrom ((Type) null), "#O14");
			Assert.IsTrue (tb2.IsAssignableFrom (tb3), "#O15");
			Assert.IsTrue (tb2.IsAssignableFrom (emitted_type3), "#O16");
			Assert.IsTrue (emitted_type2.IsAssignableFrom (emitted_type3), "#O17");
			Assert.IsTrue (emitted_type2.IsAssignableFrom (tb3), "#O18");
			Assert.IsTrue (tb.IsAssignableFrom (tb3), "#O19");
			Assert.IsTrue (tb.IsAssignableFrom (emitted_type3), "#O20");
			Assert.IsTrue (emitted_type.IsAssignableFrom (tb3), "#021");
			Assert.IsTrue (emitted_type.IsAssignableFrom (emitted_type3), "#O22");

			Assert.IsTrue (typeof (IThrowable).IsAssignableFrom (emitted_type3), "#P1");
			Assert.IsFalse (emitted_type3.IsAssignableFrom (typeof (IThrowable)), "#P2");
			Assert.IsTrue (typeof (IMoveable).IsAssignableFrom (emitted_type3), "#P3");
			Assert.IsFalse (emitted_type3.IsAssignableFrom (typeof (IMoveable)), "#P4");
			Assert.IsTrue (typeof (Foo).IsAssignableFrom (emitted_type3), "#P5");
			Assert.IsFalse (emitted_type3.IsAssignableFrom (typeof (Foo)), "#P6");
			Assert.IsTrue (typeof (Bar).IsAssignableFrom (emitted_type3), "#P7");
			Assert.IsFalse (emitted_type3.IsAssignableFrom (typeof (Bar)), "#P8");
			Assert.IsFalse (typeof (Baz).IsAssignableFrom (emitted_type3), "#P9");
			Assert.IsFalse (emitted_type3.IsAssignableFrom (typeof (Baz)), "#P10");
			Assert.IsTrue (typeof (IDestroyable).IsAssignableFrom (emitted_type3), "#P11");
			Assert.IsFalse (emitted_type3.IsAssignableFrom (typeof (IDestroyable)), "#P12");
			Assert.IsTrue (typeof (IAir).IsAssignableFrom (emitted_type3), "#P13");
			Assert.IsFalse (emitted_type3.IsAssignableFrom (typeof (IAir)), "#P14");
			Assert.IsTrue (typeof (IWater).IsAssignableFrom (emitted_type3), "#P15");
			Assert.IsFalse (emitted_type3.IsAssignableFrom (typeof (IWater)), "#P16");
			Assert.IsTrue (typeof (ILiquid).IsAssignableFrom (emitted_type3), "#P17");
			Assert.IsFalse (emitted_type3.IsAssignableFrom (typeof (ILiquid)), "#P18");

			Assert.IsTrue (typeof (MemoryStream).IsAssignableFrom (emitted_type3), "#Q1");
			Assert.IsFalse (emitted_type3.IsAssignableFrom (typeof (MemoryStream)), "#Q2");
			Assert.IsTrue (typeof (Stream).IsAssignableFrom (emitted_type3), "#Q3");
			Assert.IsFalse (emitted_type3.IsAssignableFrom (typeof (Stream)), "#Q4");
			Assert.IsFalse (typeof (FileStream).IsAssignableFrom (emitted_type3), "#Q5");
			Assert.IsFalse (emitted_type3.IsAssignableFrom (typeof (FileStream)), "#Q6");
			Assert.IsTrue (typeof (object).IsAssignableFrom (emitted_type3), "#Q7");
			Assert.IsFalse (emitted_type3.IsAssignableFrom (typeof (object)), "#Q8");
			Assert.IsTrue (typeof (IDisposable).IsAssignableFrom (emitted_type3), "#Q9");
			Assert.IsFalse (emitted_type3.IsAssignableFrom (typeof (IDisposable)), "#Q10");

			Assert.IsTrue (typeof (Foo []).IsAssignableFrom (module.GetType (
				tb3.FullName + "[]")), "#R1");
			Assert.IsTrue (typeof (Bar []).IsAssignableFrom (module.GetType (
				tb3.FullName + "[]")), "#R2");
			Assert.IsFalse (typeof (Baz []).IsAssignableFrom (module.GetType (
				tb3.FullName + "[]")), "#R3");

			TypeBuilder tb4 = module.DefineType (genTypeName (),
				TypeAttributes.Public, null,
				new Type [] { typeof (IWater) });
			tb4.DefineGenericParameters ("T");

			Type inst = tb4.MakeGenericType (typeof (int));
			Type emitted_type4 = tb4.CreateType ();
			Assert.IsFalse (typeof (IComparable).IsAssignableFrom (inst));
			// This returns True if CreateType () is called _before_ MakeGenericType...
			//Assert.IsFalse (typeof (IWater).IsAssignableFrom (inst));
		}

		[Test]
		public void IsAssignableFrom_NotCreated ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (),
				TypeAttributes.Public, typeof (MemoryStream),
				new Type [] {
					typeof (IThrowable), typeof (Bar),
					typeof (IComparable)
					});

			Assert.IsTrue (typeof (IThrowable).IsAssignableFrom (tb), "#A1");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (IThrowable)), "#A2");
			//Assert.IsFalse (typeof (IMoveable).IsAssignableFrom (tb), "#A3");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (IMoveable)), "#A4");
			Assert.IsTrue (typeof (IComparable).IsAssignableFrom (tb), "#A5");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (IComparable)), "#A6");
			Assert.IsFalse (typeof (IAir).IsAssignableFrom (tb), "#A7");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (IAir)), "#A8");
			Assert.IsFalse (typeof (IWater).IsAssignableFrom (tb), "#A9");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (IWater)), "#A10");
			Assert.IsFalse (typeof (ILiquid).IsAssignableFrom (tb), "#A11");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (ILiquid)), "#A12");

			//Assert.IsFalse (typeof (Foo).IsAssignableFrom (tb), "#B1");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (Foo)), "#B2");
			Assert.IsTrue (typeof (Bar).IsAssignableFrom (tb), "#B3");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (Bar)), "#B4");
			Assert.IsFalse (typeof (Baz).IsAssignableFrom (tb), "#B5");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (Baz)), "#B6");

			Assert.IsTrue (typeof (MemoryStream).IsAssignableFrom (tb), "#C1");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (MemoryStream)), "#C2");
			Assert.IsTrue (typeof (Stream).IsAssignableFrom (tb), "#C3");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (Stream)), "#C4");
			Assert.IsFalse (typeof (FileStream).IsAssignableFrom (tb), "#C5");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (FileStream)), "#C6");
			Assert.IsTrue (typeof (object).IsAssignableFrom (tb), "#C7");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (object)), "#C8");
			Assert.IsTrue (typeof (IDisposable).IsAssignableFrom (tb), "#C9");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (IDisposable)), "#C10");

			Assert.IsTrue (tb.IsAssignableFrom (tb), "#D1");
			Assert.IsFalse (tb.IsAssignableFrom ((Type) null), "#D2");

			TypeBuilder tb2 = module.DefineType (genTypeName (),
				TypeAttributes.Public, tb,
				new Type[] { typeof (IAir) });

			Assert.IsTrue (typeof (IThrowable).IsAssignableFrom (tb2), "#E1");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (IThrowable)), "#E2");
			Assert.IsTrue (typeof (IMoveable).IsAssignableFrom (tb2), "#E3");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (IMoveable)), "#E4");
			Assert.IsTrue (typeof (IComparable).IsAssignableFrom (tb2), "#E5");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (IComparable)), "#E6");
			Assert.IsTrue (typeof (IAir).IsAssignableFrom (tb2), "#E7");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (IAir)), "#E8");
			Assert.IsFalse (typeof (IWater).IsAssignableFrom (tb2), "#E9");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (IWater)), "#E10");
			Assert.IsFalse (typeof (ILiquid).IsAssignableFrom (tb2), "#E11");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (ILiquid)), "#E12");

			Assert.IsTrue (typeof (Foo).IsAssignableFrom (tb2), "#F1");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (Foo)), "#F2");
			Assert.IsTrue (typeof (Bar).IsAssignableFrom (tb2), "#F3");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (Bar)), "#F4");
			Assert.IsFalse (typeof (Baz).IsAssignableFrom (tb2), "#F5");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (Baz)), "#F6");

			Assert.IsTrue (typeof (MemoryStream).IsAssignableFrom (tb2), "#G1");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (MemoryStream)), "#G2");
			Assert.IsTrue (typeof (Stream).IsAssignableFrom (tb2), "#G3");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (Stream)), "#G4");
			Assert.IsFalse (typeof (FileStream).IsAssignableFrom (tb2), "#G5");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (FileStream)), "#G6");
			Assert.IsTrue (typeof (object).IsAssignableFrom (tb2), "#G7");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (object)), "#G8");
			Assert.IsTrue (typeof (IDisposable).IsAssignableFrom (tb2), "#G9");
			Assert.IsFalse (tb2.IsAssignableFrom (typeof (IDisposable)), "#G10");

			Assert.IsTrue (tb2.IsAssignableFrom (tb2), "#H1");
			Assert.IsFalse (tb2.IsAssignableFrom (tb), "#H2");
			Assert.IsTrue (tb.IsAssignableFrom (tb2), "#H3");

			TypeBuilder tb3 = module.DefineType (genTypeName (),
				TypeAttributes.Public, tb2,
				new Type[] { typeof (IWater) });

			Assert.IsTrue (typeof (IThrowable).IsAssignableFrom (tb3), "#I1");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (IThrowable)), "#I2");
			Assert.IsTrue (typeof (IMoveable).IsAssignableFrom (tb3), "#I3");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (IMoveable)), "#I4");
			Assert.IsTrue (typeof (IComparable).IsAssignableFrom (tb3), "#I5");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (IComparable)), "#I6");
			Assert.IsTrue (typeof (IAir).IsAssignableFrom (tb3), "#I7");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (IAir)), "#I8");
			Assert.IsTrue (typeof (IWater).IsAssignableFrom (tb3), "#I9");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (IWater)), "#I10");
			//Assert.IsFalse (typeof (ILiquid).IsAssignableFrom (tb3), "#I11");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (ILiquid)), "#I12");

			Assert.IsTrue (typeof (Foo).IsAssignableFrom (tb3), "#J1");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (Foo)), "#J2");
			Assert.IsTrue (typeof (Bar).IsAssignableFrom (tb3), "#J3");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (Bar)), "#J4");
			Assert.IsFalse (typeof (Baz).IsAssignableFrom (tb3), "#J5");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (Baz)), "#J6");

			Assert.IsTrue (typeof (MemoryStream).IsAssignableFrom (tb3), "#K1");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (MemoryStream)), "#K2");
			Assert.IsTrue (typeof (Stream).IsAssignableFrom (tb3), "#K3");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (Stream)), "#K4");
			Assert.IsFalse (typeof (FileStream).IsAssignableFrom (tb3), "#K5");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (FileStream)), "#K6");
			Assert.IsTrue (typeof (object).IsAssignableFrom (tb3), "#K7");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (object)), "#K8");
			Assert.IsTrue (typeof (IDisposable).IsAssignableFrom (tb3), "#K9");
			Assert.IsFalse (tb3.IsAssignableFrom (typeof (IDisposable)), "#K10");

			Assert.IsTrue (tb3.IsAssignableFrom (tb3), "#L1");
			Assert.IsFalse (tb3.IsAssignableFrom (tb2), "#L2");
			Assert.IsFalse (tb3.IsAssignableFrom (tb), "#L3");
			Assert.IsTrue (tb2.IsAssignableFrom (tb3), "#L4");
			Assert.IsTrue (tb.IsAssignableFrom (tb3), "#L5");
		}

		[Test]
		[Category ("NotDotNet")] // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=344549
		public void IsAssignableFrom_NotCreated_AddInterfaceImplementation_Mono ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (),
				TypeAttributes.Public, typeof (FormatException),
				new Type [] { typeof (IThrowable) });
			tb.AddInterfaceImplementation (typeof (IDestroyable));

			Assert.IsTrue (typeof (IThrowable).IsAssignableFrom (tb), "#A1");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (IThrowable)), "#A2");

			Assert.IsTrue (typeof (IDestroyable).IsAssignableFrom (tb), "#B1");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (IDestroyable)), "#B2");
		}

		[Test]
		[Category ("NotWorking")] // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=344549
		public void IsAssignableFrom_NotCreated_AddInterfaceImplementation_MS ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (),
				TypeAttributes.Public, typeof (FormatException),
				new Type [] { typeof (IThrowable) });
			tb.AddInterfaceImplementation (typeof (IDestroyable));

			Assert.IsTrue (typeof (IThrowable).IsAssignableFrom (tb), "#A1");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (IThrowable)), "#A2");

			Assert.IsFalse (typeof (IDestroyable).IsAssignableFrom (tb), "#B1");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (IDestroyable)), "#B2");
		}


		[Test]
		// Casts don't work with unfinished types
		[Category ("NotWorking")]
		[Category ("NotDotNet")]
		public void IsAssignableFrom_NotCreated_Array ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (),
				TypeAttributes.Public, typeof (FormatException),
				new Type [] {
					typeof (IThrowable), typeof (Bar),
					typeof (IComparable)
					});

			Assert.IsTrue (typeof (Foo []).IsAssignableFrom (module.GetType (
				tb.FullName + "[]")), "#1");
			Assert.IsTrue (typeof (Bar []).IsAssignableFrom (module.GetType (
				tb.FullName + "[]")), "#2");
			Assert.IsFalse (typeof (Baz []).IsAssignableFrom (module.GetType (
				tb.FullName + "[]")), "#3");
		}

		[Test]
		[Category ("NotDotNet")] // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=344353
		public void IsAssignableFrom_NotCreated_BaseInterface_Mono ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (),
				TypeAttributes.Public, typeof (FormatException),
				new Type [] {
					typeof (IThrowable), typeof (Bar),
					typeof (IComparable)
					});

			Assert.IsTrue (typeof (IMoveable).IsAssignableFrom (tb), "#1");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (IMoveable)), "#2");
		}

		[Test]
		[Category ("NotWorking")] // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=344353
		public void IsAssignableFrom_NotCreated_BaseInterface_MS ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (),
				TypeAttributes.Public, typeof (FormatException),
				new Type [] {
					typeof (IThrowable), typeof (Bar),
					typeof (IComparable)
					});

			Assert.IsFalse (typeof (IMoveable).IsAssignableFrom (tb), "#1");
			Assert.IsFalse (tb.IsAssignableFrom (typeof (IMoveable)), "#2");
		}

		[Test]
		public void CreateType_EmptyMethodBody ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public);

			tb.DefineMethod ("foo", MethodAttributes.Public, typeof (void), new Type [] { });
			try {
				tb.CreateType ();
				Assert.Fail ("#1");
			} catch (InvalidOperationException ex) {
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void CreateType_EmptyCtorBody ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public);

			tb.DefineConstructor (0, CallingConventions.Standard, null);
			try {
				tb.CreateType ();
				Assert.Fail ("#1");
			} catch (InvalidOperationException ex) {
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		[Category ("NotWorking")]
		public void CreateType_Interface_ParentInvalid ()
		{
			TypeBuilder tb;

			tb = module.DefineType (genTypeName (), TypeAttributes.Interface,
				typeof (Exception));
			Assert.AreEqual (typeof (Exception), tb.BaseType, "#A1");
			try {
				tb.CreateType ();
				Assert.Fail ("#A2");
			} catch (TypeLoadException ex) {
				// Could not load interface 't5' from assembly '...'
				// because it must extend from Object
				Assert.AreEqual (typeof (TypeLoadException), ex.GetType (), "#A3");
				Assert.IsNull (ex.InnerException, "#A4");
				Assert.IsNotNull (ex.Message, "#A5");
				Assert.IsTrue (ex.Message.IndexOf (tb.Name) != -1, "#A6");
				Assert.IsTrue (ex.Message.IndexOf (assembly.FullName) != -1, "#A7");
			}

			tb = module.DefineType (genTypeName (), TypeAttributes.Interface,
				typeof (object));
			Assert.AreEqual (typeof (object), tb.BaseType, "#B1");
			try {
				tb.CreateType ();
				Assert.Fail ("#B2");
			} catch (TypeLoadException ex) {
				// Failure has occurred while loading a type
				Assert.AreEqual (typeof (TypeLoadException), ex.GetType (), "#B3");
				Assert.IsNull (ex.InnerException, "#B4");
				Assert.IsNotNull (ex.Message, "#B5");
			}

			tb = module.DefineType (genTypeName (), TypeAttributes.Interface,
				typeof (EmptyInterface));
			Assert.AreEqual (typeof (EmptyInterface), tb.BaseType, "#C1");
			try {
				tb.CreateType ();
				Assert.Fail ("#C2");
			} catch (TypeLoadException ex) {
				// Could not load interface 't5' from assembly '...'
				// because the parent type is an interface
				Assert.AreEqual (typeof (TypeLoadException), ex.GetType (), "#C3");
				Assert.IsNull (ex.InnerException, "#C4");
				Assert.IsNotNull (ex.Message, "#C5");
				Assert.IsTrue (ex.Message.IndexOf (tb.Name) != -1, "#C6");
				Assert.IsTrue (ex.Message.IndexOf (assembly.FullName) != -1, "#C7");
			}
		}

		[Test]
		public void CreateType_Parent_DefaultCtorMissing ()
		{
			TypeBuilder tb;

			tb = module.DefineType (genTypeName ());
			ConstructorBuilder cb = tb.DefineConstructor (
				MethodAttributes.Public,
				CallingConventions.Standard,
				new Type [] { typeof (string) });
			cb.GetILGenerator ().Emit (OpCodes.Ret);
			Type parent_type = tb.CreateType ();

			tb = module.DefineType (genTypeName (), TypeAttributes.Class,
				parent_type);
			try {
				tb.CreateType ();
				Assert.Fail ("#1");
			} catch (NotSupportedException ex) {
				// Parent does not have a default constructor.
				// The default constructor must be explicitly defined
				Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void CreateType_Parent_Null ()
		{
			TypeBuilder tb;
			Type emitted_type;
			
			tb = module.DefineType (genTypeName (), TypeAttributes.Public, null);
			Assert.AreEqual (typeof (object), tb.BaseType, "#A1");
			emitted_type = tb.CreateType ();
			Assert.AreEqual (typeof (object), emitted_type.BaseType, "#A2");

			tb = module.DefineType (genTypeName (), TypeAttributes.Interface | TypeAttributes.Abstract, null);
			Assert.IsNull (tb.BaseType, "#B1");
			emitted_type = tb.CreateType ();
			Assert.IsNull (emitted_type.BaseType, "#B2");
		}

		[Test]
		[Category ("NotWorking")]
		public void DefineGenericParameters_AlreadyDefined ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public);
			tb.DefineGenericParameters ("K");
			try {
				tb.DefineGenericParameters ("V");
				Assert.Fail ("#1");
			} catch (InvalidOperationException ex) {
				// Operation is not valid due to the current
				// state of the object
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		public void DefineGenericParameters_Names_Empty ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public);

			try {
				tb.DefineGenericParameters (new string [0]);
				Assert.Fail ("#1");
			} catch (ArgumentException ex) {
				// Value does not fall within the expected range
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
				Assert.IsNull (ex.ParamName, "#5");
			}
		}

		[Test]
		public void DefineGenericParameters_Names_Null ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public);

			try {
				tb.DefineGenericParameters ((string []) null);
				Assert.Fail ("#A1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
				Assert.IsNull (ex.InnerException, "#A3");
				Assert.IsNotNull (ex.Message, "#A4");
				Assert.AreEqual ("names", ex.ParamName, "#A5");
			}

			try {
				tb.DefineGenericParameters ("K", null, "V");
				Assert.Fail ("#B1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
				Assert.IsNull (ex.InnerException, "#B3");
				Assert.IsNotNull (ex.Message, "#B4");
				Assert.AreEqual ("names", ex.ParamName, "#B5");
			}
		}

		[Test]
		public void GenericType ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public);
			tb.DefineGenericParameters ("T");

			Assert.IsTrue (tb.IsGenericType, "#A1");
			Assert.IsTrue (tb.IsGenericTypeDefinition, "#A2");
			Assert.IsTrue (tb.ContainsGenericParameters, "#A3");
			Assert.IsFalse (tb.IsGenericParameter, "#A4");

			Type[] args = tb.GetGenericArguments ();
			Assert.IsFalse (args [0].IsGenericType, "#B1");
			Assert.IsFalse (args [0].IsGenericTypeDefinition, "#B2");
			Assert.IsTrue (args [0].ContainsGenericParameters, "#B3");
			Assert.IsTrue (args [0].IsGenericParameter, "#B4");
		}

		[Test]
		public void MakeGenericType ()
		{
			TypeBuilder tb;
			Type generic_type;
		
			tb = module.DefineType (genTypeName (), TypeAttributes.Public);
			tb.DefineGenericParameters ("T");

			generic_type = tb.MakeGenericType (typeof (int));
			Assert.IsTrue (generic_type.IsGenericType, "#A1");
			Assert.IsFalse (generic_type.IsGenericTypeDefinition, "#A2");
			Assert.IsFalse (generic_type.ContainsGenericParameters, "#A3");
			Assert.IsFalse (generic_type.IsGenericParameter, "#A4");

			generic_type = tb.MakeGenericType (typeof (List<>).GetGenericArguments ());
			Assert.IsTrue (generic_type.IsGenericType, "#B1");
			Assert.IsFalse (generic_type.IsGenericTypeDefinition, "#B2");
			Assert.IsTrue (generic_type.ContainsGenericParameters, "#B3");
			Assert.IsFalse (generic_type.IsGenericParameter, "#B4");

			tb = module.DefineType (genTypeName (), TypeAttributes.Interface
				| TypeAttributes.Abstract | TypeAttributes.Public);
			tb.DefineGenericParameters ("T");

			generic_type = tb.MakeGenericType (typeof (int));
			Assert.IsTrue (generic_type.IsGenericType, "#C1");
			Assert.IsFalse (generic_type.IsGenericTypeDefinition, "#C2");
			Assert.IsFalse (generic_type.ContainsGenericParameters, "#C3");
			Assert.IsFalse (generic_type.IsGenericParameter, "#C4");

			generic_type = tb.MakeGenericType (typeof (List<>).GetGenericArguments ());
			Assert.IsTrue (generic_type.IsGenericType, "#D1");
			Assert.IsFalse (generic_type.IsGenericTypeDefinition, "#D2");
			Assert.IsTrue (generic_type.ContainsGenericParameters, "#D3");
			Assert.IsFalse (generic_type.IsGenericParameter, "#D4");
		}

		[Test]
		public void MakeGenericType_NoGenericTypeDefinition ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public);
			try {
				tb.MakeGenericType (typeof (int));
				Assert.Fail ("#1");
			} catch (InvalidOperationException ex) {
				// Operation is not valid due to the current
				// state of the object
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
			}
		}

		[Test]
		[Category ("NotDotNet")] // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=351169
		public void MakeGenericType_TypeArguments_Null_Mono ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public);
			tb.DefineGenericParameters ("K", "V");

			try {
				tb.MakeGenericType ((Type []) null);
				Assert.Fail ("#A1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
				Assert.IsNull (ex.InnerException, "#A3");
				Assert.IsNotNull (ex.Message, "#A4");
				Assert.AreEqual ("typeArguments", ex.ParamName, "#A5");
			}

			try {
				tb.MakeGenericType (typeof (string), (Type) null);
				Assert.Fail ("#B1");
			} catch (ArgumentNullException ex) {
				Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
				Assert.IsNull (ex.InnerException, "#B3");
				Assert.IsNotNull (ex.Message, "#B4");
				Assert.AreEqual ("typeArguments", ex.ParamName, "#B5");
			}
		}

		[Test]
		[Category ("NotWorking")] // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=351169
		public void MakeGenericType_TypeArguments_Null_MS ()
		{
			Type generic_type;
			Type [] type_args;

			TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public);
			tb.DefineGenericParameters ("K", "V");

			generic_type = tb.MakeGenericType ((Type []) null);
			Assert.IsNotNull (generic_type, "#A1");
			Assert.IsTrue (generic_type.IsGenericType, "#A2");
			Assert.IsFalse (generic_type.IsGenericTypeDefinition, "#A3");
			type_args = generic_type.GetGenericArguments ();
			Assert.IsNull (type_args, "#A4");

			generic_type  = tb.MakeGenericType (typeof (string), (Type) null);
			Assert.IsNotNull (generic_type, "#B1");
			Assert.IsTrue (generic_type.IsGenericType, "#B2");
			Assert.IsFalse (generic_type.IsGenericTypeDefinition, "#B3");
			type_args = generic_type.GetGenericArguments ();
			Assert.IsNotNull (type_args, "#B4");
			Assert.AreEqual (2, type_args.Length, "#B5");
			Assert.AreEqual (typeof (string), type_args [0], "#B6");
			Assert.IsNull (type_args [1], "#B7");
		}

		[Test]
		[Category ("NotDotNet")] // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=351143
		public void MakeGenericType_TypeArguments_Mismatch_Mono ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public);
			tb.DefineGenericParameters ("K", "V");
			try {
				tb.MakeGenericType (typeof (int));
				Assert.Fail ("#1");
			} catch (ArgumentException ex) {
				// The type or method has 2 generic prarameter(s)
				// but 1 generic argument(s) were provided. A
				// generic argument must be provided for each
				// generic parameter
				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
				Assert.AreEqual ("typeArguments", ex.ParamName, "#5");
			}
		}

		[Test]
		[Category ("NotWorking")] // https://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=351143
		public void MakeGenericType_TypeArguments_Mismatch_MS ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public);
			tb.DefineGenericParameters ("K", "V");
			
			Type generic_type = tb.MakeGenericType (typeof (int));
			Assert.IsTrue (generic_type.IsGenericType, "#1");
			Assert.IsFalse (generic_type.IsGenericTypeDefinition, "#2");
			Type [] type_args = generic_type.GetGenericArguments ();
			Assert.IsNotNull (type_args, "#3");
			Assert.AreEqual (1, type_args.Length, "#4");
			Assert.AreEqual (typeof (int), type_args [0], "#5");
		}

		[Test]
		public void MakeArrayType_Complete ()
		{
			// reference type
			TypeBuilder tb = module.DefineType (genTypeName (),
				TypeAttributes.Sealed | TypeAttributes.Serializable,
				typeof (ContextBoundObject));
			Type emittedType = tb.CreateType ();
			Type arrayType = tb.MakeArrayType ();
			Assert.IsTrue (arrayType.IsArray, "#A1");
			Assert.IsTrue (arrayType.HasElementType, "#A2");
			Assert.AreEqual (tb, arrayType.GetElementType (), "#A3");
			Assert.IsFalse (tb.HasElementType, "#A4");
			Assert.IsTrue (tb.IsCreated (), "#A5");

			// value type
			tb = module.DefineType (genTypeName (),
				TypeAttributes.Sealed | TypeAttributes.Serializable,
				typeof (ValueType));
			emittedType = tb.CreateType ();
			arrayType = tb.MakeArrayType ();
			Assert.IsTrue (arrayType.IsArray, "#B1");
			Assert.IsTrue (arrayType.HasElementType, "#B2");
			Assert.AreEqual (tb, arrayType.GetElementType (), "#B3");
			Assert.IsFalse (tb.HasElementType, "#B4");
			Assert.IsTrue (tb.IsCreated (), "#B5");

			tb = module.DefineType (genTypeName (),
				TypeAttributes.Sealed | TypeAttributes.Serializable,
				typeof (Enum));
			tb.DefineField ("value__", typeof (int), FieldAttributes.SpecialName |
				FieldAttributes.Private | FieldAttributes.RTSpecialName);
			emittedType = tb.CreateType ();
			arrayType = tb.MakeArrayType ();
			Assert.IsTrue (arrayType.IsArray, "#C1");
			Assert.IsTrue (arrayType.HasElementType, "#C2");
			Assert.AreEqual (tb, arrayType.GetElementType (), "#C3");
			Assert.IsFalse (tb.HasElementType, "#C4");
			Assert.IsTrue (tb.IsCreated (), "#C5");
		}

		[Test] // bug #82015
		public void MakeArrayType_Incomplete ()
		{
			// reference type
			TypeBuilder tb = module.DefineType (genTypeName (),
				TypeAttributes.Sealed | TypeAttributes.Serializable,
				typeof (ContextBoundObject));
			Type arrayType = tb.MakeArrayType ();
			Assert.IsTrue (arrayType.IsArray, "#A1");
			Assert.IsTrue (arrayType.HasElementType, "#A2");
			Assert.AreEqual (tb, arrayType.GetElementType (), "#A3");
			Assert.IsFalse (tb.HasElementType, "#A4");
			Assert.IsFalse (tb.IsCreated (), "#A5");

			// value type
			tb = module.DefineType (genTypeName (),
				TypeAttributes.Sealed | TypeAttributes.Serializable,
				typeof (ValueType));
			arrayType = tb.MakeArrayType ();
			Assert.IsTrue (arrayType.IsArray, "#B1");
			Assert.IsTrue (arrayType.HasElementType, "#B2");
			Assert.AreEqual (tb, arrayType.GetElementType (), "#B3");
			Assert.IsFalse (tb.HasElementType, "#B4");
			Assert.IsFalse (tb.IsCreated (), "#B5");

			// enum
			tb = module.DefineType (genTypeName (),
				TypeAttributes.Sealed | TypeAttributes.Serializable,
				typeof (Enum));
			arrayType = tb.MakeArrayType ();
			Assert.IsTrue (arrayType.IsArray, "#C1");
			Assert.IsTrue (arrayType.HasElementType, "#C2");
			Assert.IsFalse (tb.HasElementType, "#C3");
			Assert.IsFalse (tb.IsCreated (), "#C4");
		}

		[Test]
		public void GetCustomAttributes_InflatedType ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.DefineGenericParameters (new string[] { "FOO" });

			ConstructorInfo guidCtor = typeof (GuidAttribute).GetConstructor (
				new Type [] { typeof (string) });

			CustomAttributeBuilder caBuilder = new CustomAttributeBuilder (guidCtor,
				new object [] { Guid.NewGuid ().ToString ("D") }, new FieldInfo [0], new object [0]);

			tb.SetCustomAttribute (caBuilder);
			Type t = tb.CreateType ();

			Type inflated = t.MakeGenericType (new Type [] { typeof (int) });

			Assert.AreEqual (1, inflated.GetCustomAttributes (false).Length);
		}

		[Test]
		public void GetField ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public);
			GenericTypeParameterBuilder [] typeParams = tb.DefineGenericParameters ("T");

			ConstructorBuilder cb = tb.DefineDefaultConstructor (MethodAttributes.Public);

			FieldBuilder fb1 = tb.DefineField ("field1", typeParams [0], FieldAttributes.Public);

			Type t = tb.MakeGenericType (typeof (int));

			// Chect that calling MakeArrayType () does not initialize the class
			// (bug #351172)
			t.MakeArrayType ();

			// Check that the instantiation of a type builder contains live data
			TypeBuilder.GetField (t, fb1);
			FieldBuilder fb2 = tb.DefineField ("field2", typeParams [0], FieldAttributes.Public);
			FieldInfo fi2 = TypeBuilder.GetField (t, fb1);

			MethodBuilder mb = tb.DefineMethod ("get_int", MethodAttributes.Public|MethodAttributes.Static, typeof (int), Type.EmptyTypes);
			ILGenerator ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Newobj, TypeBuilder.GetConstructor (t, cb));
			ilgen.Emit (OpCodes.Dup);
			ilgen.Emit (OpCodes.Ldc_I4, 42);
			ilgen.Emit (OpCodes.Stfld, fi2);
			ilgen.Emit (OpCodes.Ldfld, fi2);
			ilgen.Emit (OpCodes.Ret);

			// Check GetField on a type instantiated with type parameters
			Type t3 = tb.MakeGenericType (typeParams [0]);
			FieldBuilder fb3 = tb.DefineField ("field3", typeParams [0], FieldAttributes.Public);
			FieldInfo fi3 = TypeBuilder.GetField (t3, fb3);

			MethodBuilder mb3 = tb.DefineMethod ("get_T", MethodAttributes.Public|MethodAttributes.Static, typeParams [0], Type.EmptyTypes);
			ILGenerator ilgen3 = mb3.GetILGenerator ();
			ilgen3.Emit (OpCodes.Newobj, TypeBuilder.GetConstructor (t3, cb));
			ilgen3.Emit (OpCodes.Ldfld, fi3);
			ilgen3.Emit (OpCodes.Ret);

			Type created = tb.CreateType ();

			Type inst = created.MakeGenericType (typeof (object));

			Assert.AreEqual (42, inst.GetMethod ("get_int").Invoke (null, null));

			Assert.AreEqual (null, inst.GetMethod ("get_T").Invoke (null, null));
		}
		
		[Test] //bug #354047
		public void CreatedTypeInstantiationOverTypeBuilderArgsIsNotAGenericTypeDefinition ()
		{
			TypeBuilder tb = module.DefineType ("TheType", TypeAttributes.Public, typeof (object), new Type [] {typeof (IDelegateFactory)});
			GenericTypeParameterBuilder[] typeParams = tb.DefineGenericParameters (new String[] { "T" });
			Type t = tb.CreateType ();

			Type inst = tb.MakeGenericType (typeParams [0]);
			Assert.IsFalse (inst.IsGenericTypeDefinition, "#1 create type instance is not a generic type definition");
		}

		[Test] //bug #354047
		public void CreatedTypeAndTypeBuilderOwnTheirGenericArguments ()
		{
			TypeBuilder tb = module.DefineType ("TheType", TypeAttributes.Public, typeof (object), new Type [] {typeof (IDelegateFactory)});
			GenericTypeParameterBuilder[] typeParams = tb.DefineGenericParameters (new String[] { "T" });
			Type t = tb.CreateType ();

			Assert.IsTrue (tb.GetGenericArguments()[0].DeclaringType == tb, "#1 TypeBuilder owns its arguments");
			Assert.IsTrue (t.GetGenericArguments()[0].DeclaringType == t, "#1 create type owns its arguments");
		}

		[Test] //bug #354047
		public void CreatedTypeAndTypeBuilderDontShareGenericArguments ()
		{
			TypeBuilder tb = module.DefineType ("TheType", TypeAttributes.Public, typeof (object), new Type [] {typeof (IDelegateFactory)});
			GenericTypeParameterBuilder[] typeParams = tb.DefineGenericParameters (new String[] { "T" });
			Type t = tb.CreateType ();

			Assert.IsTrue (tb.GetGenericArguments()[0] != t.GetGenericArguments()[0], "#1 TypeBuilder and create type arguments are diferent");
		}

		[Test] //bug #399047
		public void FieldOnTypeBuilderInstDontInflateWhenEncoded () {
				assembly = Thread.GetDomain ().DefineDynamicAssembly (new AssemblyName (ASSEMBLY_NAME), AssemblyBuilderAccess.RunAndSave, Path.GetTempPath ());

				module = assembly.DefineDynamicModule ("Instance.exe");
  
                TypeBuilder G = module.DefineType ("G", TypeAttributes.Public);
                Type T = G.DefineGenericParameters ("T") [0];
				ConstructorInfo ctor = G.DefineDefaultConstructor (MethodAttributes.Public);
                Type GObj = G.MakeGenericType (new Type [] { T });

                FieldBuilder F = G.DefineField ("F", T, FieldAttributes.Public);

                TypeBuilder P = module.DefineType ("P", TypeAttributes.Public);

                MethodBuilder Test = P.DefineMethod ("Test", MethodAttributes.Public);
                Type TATest = Test.DefineGenericParameters ("TA") [0];
                {
                        Type TestGObj = G.MakeGenericType (new Type [] { TATest });

                        ILGenerator il = Test.GetILGenerator ();

                        il.Emit (OpCodes.Newobj, TypeBuilder.GetConstructor (TestGObj, ctor));
                        il.Emit (OpCodes.Ldfld, TypeBuilder.GetField (TestGObj, F));
                        il.Emit (OpCodes.Pop);

                        il.Emit (OpCodes.Ret);
                }

 				MethodBuilder main = P.DefineMethod ("Main", MethodAttributes.Public | MethodAttributes.Static);
				{
					ILGenerator il = main.GetILGenerator ();
					il.Emit(OpCodes.Newobj, P.DefineDefaultConstructor (MethodAttributes.Public));
					il.Emit(OpCodes.Call, Test.MakeGenericMethod (typeof (int)));
					il.Emit (OpCodes.Ret);
				}

				assembly.SetEntryPoint (main);
                G.CreateType ();
                P.CreateType ();

                assembly.Save ("Instance.exe");
				Thread.GetDomain ().ExecuteAssembly(Path.GetTempPath () + Path.DirectorySeparatorChar + "Instance.exe");
		}

		[Test]
		public void FieldWithInitializedDataWorksWithCompilerRuntimeHelpers ()
		{
			TypeBuilder tb = module.DefineType ("Type1", TypeAttributes.Public);
			FieldBuilder fb = tb.DefineInitializedData ("Foo", new byte [] {1,2,3,4}, FieldAttributes.Static|FieldAttributes.Public);
			tb.CreateType ();

			assembly = Thread.GetDomain ().DefineDynamicAssembly (new AssemblyName (ASSEMBLY_NAME+"2"), AssemblyBuilderAccess.RunAndSave, Path.GetTempPath ());
			module = assembly.DefineDynamicModule ("Instance.exe");

			TypeBuilder tb2 = module.DefineType ("Type2", TypeAttributes.Public);
			MethodBuilder mb = tb2.DefineMethod ("Test", MethodAttributes.Public | MethodAttributes.Static, typeof (object), new Type [0]);
			ILGenerator il = mb.GetILGenerator ();

			il.Emit (OpCodes.Ldc_I4_1);
			il.Emit (OpCodes.Newarr, typeof (int));
			il.Emit (OpCodes.Dup);
			il.Emit (OpCodes.Ldtoken, fb);
			il.Emit (OpCodes.Call, typeof (RuntimeHelpers).GetMethod ("InitializeArray"));
			il.Emit (OpCodes.Ret);

			Type t = tb2.CreateType ();
			int[] res = (int[])t.GetMethod ("Test").Invoke (null, new object[0]);
			//Console.WriteLine (res[0]);
		}

		[Test]
		public void FieldWithInitializedDataWorksWithCompilerRuntimeHelpers2 ()
		{
			TypeBuilder tb = module.DefineType ("Type1", TypeAttributes.Public);
			var garg = tb.DefineGenericParameters ("T") [0];
			FieldBuilder fb = tb.DefineInitializedData ("Foo", new byte [] {1,2,3,4}, FieldAttributes.Static|FieldAttributes.Public);
			tb.CreateType ();

			assembly = Thread.GetDomain ().DefineDynamicAssembly (new AssemblyName (ASSEMBLY_NAME+"2"), AssemblyBuilderAccess.RunAndSave, Path.GetTempPath ());
			module = assembly.DefineDynamicModule ("Instance.exe");

			TypeBuilder tb2 = module.DefineType ("Type2", TypeAttributes.Public);
			MethodBuilder mb = tb2.DefineMethod ("Test", MethodAttributes.Public | MethodAttributes.Static, typeof (object), new Type [0]);
			ILGenerator il = mb.GetILGenerator ();

			il.Emit (OpCodes.Ldc_I4_1);
			il.Emit (OpCodes.Newarr, typeof (int));
			il.Emit (OpCodes.Dup);
			il.Emit (OpCodes.Ldtoken, fb);
			il.Emit (OpCodes.Call, typeof (RuntimeHelpers).GetMethod ("InitializeArray"));
			il.Emit (OpCodes.Ret);

			Type t = tb2.CreateType ();
			int[] res = (int[])t.GetMethod ("Test").Invoke (null, new object[0]);
			//Console.WriteLine (res[0]);
		}

		public interface IDelegateFactory
		{
			Delegate Create (Delegate del);
		}

		[Test]
		public void CreateType_Ctor_NoBody ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.DefineConstructor (MethodAttributes.Public,
				CallingConventions.Standard,
				new Type [] { typeof (string) });
			try {
				tb.CreateType ();
				Assert.Fail ("#1");
			} catch (InvalidOperationException ex) {
				// Method '.ctor' does not have a method body
				Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
				Assert.IsNull (ex.InnerException, "#3");
				Assert.IsNotNull (ex.Message, "#4");
				Assert.IsTrue (ex.Message.IndexOf (".ctor") != -1, "#5");
			}
		}

		[Test] //bug #361689
		public void CreateTypeFailsWithInvalidMethodOverride ()
		{
			TypeBuilder tb = module.DefineType ("TheType", TypeAttributes.Public, typeof (object), new Type [] {typeof (IDelegateFactory)});

			MethodBuilder mc = tb.DefineMethod ("Create", MethodAttributes.Public, typeof (Delegate), new Type[] {typeof (Delegate)});
			ILGenerator gen = mc.GetILGenerator ();
			gen.Emit (OpCodes.Ldarg_0);
			gen.Emit (OpCodes.Ret);
			tb.DefineMethodOverride (mc, typeof (IDelegateFactory).GetMethod ("Create"));
			try {
				tb.CreateType ();
				Assert.Fail ("#1 create type did not throw TypeLoadException");
			} catch (TypeLoadException) {
			
			}
		}

		[Test] //bug #349194
		public void IsAssignableToWorksWithInterfacesOnParent ()
		{
            TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public, typeof (EmptyIfaceImpl));
			TypeBuilder tb2 = module.DefineType (genTypeName (), TypeAttributes.Public, tb);

			Assert.IsTrue (typeof (EmptyInterface).IsAssignableFrom (tb));
			Type t = tb.CreateType ();
			Assert.IsTrue (typeof (EmptyInterface).IsAssignableFrom (tb));
			Assert.IsTrue (typeof (EmptyInterface).IsAssignableFrom (t));
			
			
			Assert.IsTrue (typeof (EmptyInterface).IsAssignableFrom (tb2));
			Type t2 = tb2.CreateType ();
			Assert.IsTrue (typeof (EmptyInterface).IsAssignableFrom (tb2));
			Assert.IsTrue (typeof (EmptyInterface).IsAssignableFrom (t2));
		}


		[Test] //bug #430508
		public void MakeGenericTypeRespectBaseType ()
		{
            TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public, typeof (EmptyIfaceImpl));
			EnumBuilder eb = module.DefineEnum (genTypeName (), TypeAttributes.Public, typeof (int));

			MethodBuilder mb = tb.DefineMethod ("Test",
												MethodAttributes.Public,
												typeof (Tuple<,>).MakeGenericType (typeof (int), eb),
												new Type [0]);
			ILGenerator il = mb.GetILGenerator();
			il.Emit (OpCodes.Ldnull);
			il.Emit (OpCodes.Ret);
	
			Type e = eb.CreateType ();
			Type c = tb.CreateType ();
		
			Assert.AreEqual (c.GetMethod ("Test").ReturnType.GetGenericArguments ()[1], e, "#1");
		}

		[Test]
		public void GetCustomAttrOnFieldOfInflatedType ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public);
			tb.DefineGenericParameters ("T");

			CustomAttributeBuilder caBuilder = new CustomAttributeBuilder (
				typeof (SimpleTestAttribute).GetConstructors ()[0],
				new object [0]);

			FieldBuilder field = tb.DefineField ("OI", typeof (int), 0);
			field.SetCustomAttribute (caBuilder);

			Type t = tb.CreateType ();

			FieldInfo fi = t.GetFields (BindingFlags.NonPublic | BindingFlags.Instance)[0];
			object[] cattrs = fi.GetCustomAttributes (false);
			Assert.AreEqual (1, cattrs.Length);

			fi = t.MakeGenericType (typeof (int)).GetFields (BindingFlags.NonPublic | BindingFlags.Instance)[0];
			cattrs = fi.GetCustomAttributes (false);
			Assert.AreEqual (1, cattrs.Length);
		}

		[Test]
		public void GetCustomAttrOnPropertyOfInflatedType ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.DefineGenericParameters ("T");

			CustomAttributeBuilder caBuilder = new CustomAttributeBuilder (
				typeof (SimpleTestAttribute).GetConstructors ()[0],
				new object [0]);

			PropertyBuilder property = DefineStringProperty (tb, "Name", "name", MethodAttributes.Public);
			property.SetCustomAttribute (caBuilder);

			Type t = tb.CreateType ();

			PropertyInfo pi = t.GetProperties ()[0];
			object[] cattrs = pi.GetCustomAttributes (false);
			Assert.AreEqual (1, cattrs.Length);

			pi = t.MakeGenericType (typeof (int)).GetProperties ()[0];
			cattrs = pi.GetCustomAttributes (false);
			Assert.AreEqual (1, cattrs.Length);
		}

		[Test]
		public void GetCustomAttrOnEventOfInflatedType ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.DefineGenericParameters ("T");

			CustomAttributeBuilder caBuilder = new CustomAttributeBuilder (
				typeof (SimpleTestAttribute).GetConstructors ()[0],
				new object [0]);

			EventBuilder evt = tb.DefineEvent ("OI", 0, typeof (int));
			evt.SetCustomAttribute (caBuilder);

			Type t = tb.CreateType ();

			EventInfo ei = t.GetEvents (BindingFlags.NonPublic | BindingFlags.Instance)[0];
			object[] cattrs = ei.GetCustomAttributes (false);
			Assert.AreEqual (1, cattrs.Length);

			ei = t.MakeGenericType (typeof (int)).GetEvents (BindingFlags.NonPublic | BindingFlags.Instance)[0];
			cattrs = ei.GetCustomAttributes (false);
			Assert.AreEqual (1, cattrs.Length);
		}

		public void TestDoubleInitializationOfMonoGenericClass () //bug #400643
		{
			TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public);
			tb.DefineGenericParameters ("T");
 
			CustomAttributeBuilder caBuilder = new CustomAttributeBuilder (
				typeof (SimpleTestAttribute).GetConstructors ()[0],
				new object [0]);

			FieldBuilder field = tb.DefineField ("OI", typeof (int), 0);
			field.SetCustomAttribute (caBuilder);


			tb.MakeGenericType (typeof (int)).GetMethods ();
			tb.MakeGenericType (typeof (double)).GetMethods ();
			
			Type t = tb.CreateType ();
			
			t.MakeGenericType (typeof (int)).GetMethods ();
			t.MakeGenericType (typeof (double)).GetMethods ();
		}

		[Test]
		public void TestGenericFieldAccess () // bug #467415
		{
			AssemblyName asmName = new AssemblyName("DemoMethodBuilder1");
			AppDomain domain = AppDomain.CurrentDomain;
			AssemblyBuilder demoAssembly =
				domain.DefineDynamicAssembly(asmName,
						AssemblyBuilderAccess.RunAndSave);

			// Define the module that contains the code. For an
			// assembly with one module, the module name is the
			// assembly name plus a file extension.
			ModuleBuilder demoModule =
				demoAssembly.DefineDynamicModule(asmName.Name,
						asmName.Name+".dll");

			TypeBuilder demoType =
				demoModule.DefineType("DemoType", TypeAttributes.Public);

			MethodBuilder factory =
				demoType.DefineMethod("Factory",
						MethodAttributes.Public | MethodAttributes.Static);

			string[] typeParameterNames = {"T"};
			GenericTypeParameterBuilder[] typeParameters =
				factory.DefineGenericParameters(typeParameterNames);

			GenericTypeParameterBuilder T = typeParameters[0];

			Type[] parms = {};
			factory.SetParameters(parms);

			factory.SetReturnType(T);

			ILGenerator ilgen = factory.GetILGenerator();

			Type G = typeof(Gen<>);
			Type GT = G.MakeGenericType (T);
			FieldInfo GF = G.GetField("field");
			FieldInfo GTF = TypeBuilder.GetField(GT, GF);

			ilgen.Emit(OpCodes.Ldsfld, GTF);
			ilgen.Emit(OpCodes.Ret);

			// Complete the type.
			Type dt = demoType.CreateType();
			// Save the assembly, so it can be examined with Ildasm.exe.
			//demoAssembly.Save(asmName.Name+".dll");

			MethodInfo m = dt.GetMethod("Factory");
			MethodInfo bound = m.MakeGenericMethod(typeof(int));

			// Display a string representing the bound method.
			//Console.WriteLine(bound);

			object[] parameters = {};
			int result = (int)(bound.Invoke(null, parameters));

			Assert.AreEqual (0, result, "#1");
		}

		static MethodInfo GetMethodByName (MethodInfo [] methods, string name)
		{
			foreach (MethodInfo mi in methods)
				if (mi.Name == name)
					return mi;
			return null;
		}

		void CreateMembers (TypeBuilder tb, string suffix, bool defineCtors)
		{
			ConstructorBuilder cb;
			MethodBuilder mb;
			PropertyBuilder pb;
			EventBuilder eb;
			ILGenerator ilgen;

			if (defineCtors) {
				//
				// instance constructors
				//
				cb = tb.DefineConstructor (MethodAttributes.Private,
					CallingConventions.Standard,
					new Type [] { typeof (int), typeof (int) });
				cb.GetILGenerator ().Emit (OpCodes.Ret);

				cb = tb.DefineConstructor (MethodAttributes.Family,
					CallingConventions.Standard,
					new Type [] { typeof (string) });
				cb.GetILGenerator ().Emit (OpCodes.Ret);

				cb = tb.DefineConstructor (MethodAttributes.FamANDAssem,
					CallingConventions.Standard,
					new Type [] { typeof (string), typeof (string) });
				cb.GetILGenerator ().Emit (OpCodes.Ret);

				cb = tb.DefineConstructor (MethodAttributes.FamORAssem,
					CallingConventions.Standard,
					new Type [] { typeof (int) });
				cb.GetILGenerator ().Emit (OpCodes.Ret);

				cb = tb.DefineConstructor (MethodAttributes.Public,
					CallingConventions.Standard,
					new Type [] { typeof (int), typeof (bool) });
				cb.GetILGenerator ().Emit (OpCodes.Ret);

				cb = tb.DefineConstructor (MethodAttributes.Assembly,
					CallingConventions.Standard,
					new Type [] { typeof (string), typeof (int) });
				cb.GetILGenerator ().Emit (OpCodes.Ret);

				//
				// static constructors
				//

				cb = tb.DefineConstructor (MethodAttributes.Private |
					MethodAttributes.Static,
					CallingConventions.Standard,
					Type.EmptyTypes);
				cb.GetILGenerator ().Emit (OpCodes.Ret);
			}

			//
			// instance methods
			//

			mb = tb.DefineMethod ("GetPrivateInstance" + suffix,
				MethodAttributes.Private, typeof (void),
				Type.EmptyTypes);
			mb.GetILGenerator ().Emit (OpCodes.Ret);

			mb = tb.DefineMethod ("GetFamilyInstance" + suffix,
				MethodAttributes.Family, typeof (void),
				Type.EmptyTypes);
			mb.GetILGenerator ().Emit (OpCodes.Ret);

			mb = tb.DefineMethod ("GetFamANDAssemInstance" + suffix,
				MethodAttributes.FamANDAssem, typeof (void),
				Type.EmptyTypes);
			mb.GetILGenerator ().Emit (OpCodes.Ret);

			mb = tb.DefineMethod ("GetFamORAssemInstance" + suffix,
				MethodAttributes.FamORAssem, typeof (void),
				Type.EmptyTypes);
			mb.GetILGenerator ().Emit (OpCodes.Ret);

			mb = tb.DefineMethod ("GetPublicInstance" + suffix,
				MethodAttributes.Public, typeof (void),
				Type.EmptyTypes);
			mb.GetILGenerator ().Emit (OpCodes.Ret);

			mb = tb.DefineMethod ("GetAssemblyInstance" + suffix,
				MethodAttributes.Assembly, typeof (void),
				Type.EmptyTypes);
			mb.GetILGenerator ().Emit (OpCodes.Ret);

			//
			// static methods
			//

			mb = tb.DefineMethod ("GetPrivateStatic" + suffix,
				MethodAttributes.Private | MethodAttributes.Static,
				typeof (void), Type.EmptyTypes);
			mb.GetILGenerator ().Emit (OpCodes.Ret);

			mb = tb.DefineMethod ("GetFamilyStatic" + suffix,
				MethodAttributes.Family | MethodAttributes.Static,
				typeof (void), Type.EmptyTypes);
			mb.GetILGenerator ().Emit (OpCodes.Ret);

			mb = tb.DefineMethod ("GetFamANDAssemStatic" + suffix,
				MethodAttributes.FamANDAssem | MethodAttributes.Static,
				typeof (void), Type.EmptyTypes);
			mb.GetILGenerator ().Emit (OpCodes.Ret);

			mb = tb.DefineMethod ("GetFamORAssemStatic" + suffix,
				MethodAttributes.FamORAssem | MethodAttributes.Static,
				typeof (void), Type.EmptyTypes);
			mb.GetILGenerator ().Emit (OpCodes.Ret);

			mb = tb.DefineMethod ("GetPublicStatic" + suffix,
				MethodAttributes.Public | MethodAttributes.Static,
				typeof (void), Type.EmptyTypes);
			mb.GetILGenerator ().Emit (OpCodes.Ret);

			mb = tb.DefineMethod ("GetAssemblyStatic" + suffix,
				MethodAttributes.Assembly | MethodAttributes.Static,
				typeof (void), Type.EmptyTypes);
			mb.GetILGenerator ().Emit (OpCodes.Ret);

			//
			// instance fields
			//

			tb.DefineField ("privateInstance" + suffix,
				typeof (string), FieldAttributes.Private);
			tb.DefineField ("familyInstance" + suffix,
				typeof (string), FieldAttributes.Family);
			tb.DefineField ("famANDAssemInstance" + suffix,
				typeof (string), FieldAttributes.FamANDAssem);
			tb.DefineField ("famORAssemInstance" + suffix,
				typeof (string), FieldAttributes.FamORAssem);
			tb.DefineField ("publicInstance" + suffix,
				typeof (string), FieldAttributes.Public);
			tb.DefineField ("assemblyInstance" + suffix,
				typeof (string), FieldAttributes.Assembly);

			//
			// static fields
			//

			tb.DefineField ("privateStatic" + suffix,
				typeof (string), FieldAttributes.Private |
				FieldAttributes.Static);
			tb.DefineField ("familyStatic" + suffix,
				typeof (string), FieldAttributes.Family |
				FieldAttributes.Static);
			tb.DefineField ("famANDAssemStatic" + suffix,
				typeof (string), FieldAttributes.FamANDAssem |
				FieldAttributes.Static);
			tb.DefineField ("famORAssemStatic" + suffix,
				typeof (string), FieldAttributes.FamORAssem |
				FieldAttributes.Static);
			tb.DefineField ("publicStatic" + suffix,
				typeof (string), FieldAttributes.Public |
				FieldAttributes.Static);
			tb.DefineField ("assemblyStatic" + suffix,
				typeof (string), FieldAttributes.Assembly |
				FieldAttributes.Static);

			//
			// instance properties
			//

			pb = tb.DefineProperty ("PrivateInstance" + suffix,
				PropertyAttributes.None, typeof (string),
				Type.EmptyTypes);
			mb = tb.DefineMethod ("get_PrivateInstance" + suffix,
				MethodAttributes.Private, typeof (string),
				Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ldnull);
			ilgen.Emit (OpCodes.Ret);
			pb.SetGetMethod (mb);

			pb = tb.DefineProperty ("FamilyInstance" + suffix,
				PropertyAttributes.None, typeof (string),
				Type.EmptyTypes);
			mb = tb.DefineMethod ("get_FamilyInstance" + suffix,
				MethodAttributes.Family, typeof (string),
				Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ldnull);
			ilgen.Emit (OpCodes.Ret);
			pb.SetGetMethod (mb);

			pb = tb.DefineProperty ("FamANDAssemInstance" + suffix,
				PropertyAttributes.None, typeof (string),
				Type.EmptyTypes);
			mb = tb.DefineMethod ("get_FamANDAssemInstance" + suffix,
				MethodAttributes.FamANDAssem, typeof (string),
				Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ldnull);
			ilgen.Emit (OpCodes.Ret);
			pb.SetGetMethod (mb);

			pb = tb.DefineProperty ("FamORAssemInstance" + suffix,
				PropertyAttributes.None, typeof (string),
				Type.EmptyTypes);
			mb = tb.DefineMethod ("get_FamORAssemInstance" + suffix,
				MethodAttributes.FamORAssem, typeof (string),
				Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ldnull);
			ilgen.Emit (OpCodes.Ret);
			pb.SetGetMethod (mb);

			pb = tb.DefineProperty ("PublicInstance" + suffix,
				PropertyAttributes.None, typeof (string),
				Type.EmptyTypes);
			mb = tb.DefineMethod ("get_PublicInstance" + suffix,
				MethodAttributes.Public, typeof (string),
				Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ldnull);
			ilgen.Emit (OpCodes.Ret);
			pb.SetGetMethod (mb);

			pb = tb.DefineProperty ("AssemblyInstance" + suffix,
				PropertyAttributes.None, typeof (string),
				Type.EmptyTypes);
			mb = tb.DefineMethod ("get_AssemblyInstance" + suffix,
				MethodAttributes.Assembly, typeof (string),
				Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ldnull);
			ilgen.Emit (OpCodes.Ret);
			pb.SetGetMethod (mb);

			//
			// static properties
			//

			pb = tb.DefineProperty ("PrivateStatic" + suffix,
				PropertyAttributes.None, typeof (string),
				Type.EmptyTypes);
			mb = tb.DefineMethod ("get_PrivateStatic" + suffix,
				MethodAttributes.Private | MethodAttributes.Static,
				typeof (string), Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ldnull);
			ilgen.Emit (OpCodes.Ret);
			pb.SetGetMethod (mb);

			pb = tb.DefineProperty ("FamilyStatic" + suffix,
				PropertyAttributes.None, typeof (string),
				Type.EmptyTypes);
			mb = tb.DefineMethod ("get_FamilyStatic" + suffix,
				MethodAttributes.Family | MethodAttributes.Static,
				typeof (string), Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ldnull);
			ilgen.Emit (OpCodes.Ret);
			pb.SetGetMethod (mb);

			pb = tb.DefineProperty ("FamANDAssemStatic" + suffix,
				PropertyAttributes.None, typeof (string),
				Type.EmptyTypes);
			mb = tb.DefineMethod ("get_FamANDAssemStatic" + suffix,
				MethodAttributes.FamANDAssem | MethodAttributes.Static,
				typeof (string), Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ldnull);
			ilgen.Emit (OpCodes.Ret);
			pb.SetGetMethod (mb);

			pb = tb.DefineProperty ("FamORAssemStatic" + suffix,
				PropertyAttributes.None, typeof (string),
				Type.EmptyTypes);
			mb = tb.DefineMethod ("get_FamORAssemStatic" + suffix,
				MethodAttributes.FamORAssem | MethodAttributes.Static,
				typeof (string), Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ldnull);
			ilgen.Emit (OpCodes.Ret);
			pb.SetGetMethod (mb);

			pb = tb.DefineProperty ("PublicStatic" + suffix,
				PropertyAttributes.None, typeof (string),
				Type.EmptyTypes);
			mb = tb.DefineMethod ("get_PublicStatic" + suffix,
				MethodAttributes.Public | MethodAttributes.Static,
				typeof (string), Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ldnull);
			ilgen.Emit (OpCodes.Ret);
			pb.SetGetMethod (mb);

			pb = tb.DefineProperty ("AssemblyStatic" + suffix,
				PropertyAttributes.None, typeof (string),
				Type.EmptyTypes);
			mb = tb.DefineMethod ("get_AssemblyStatic" + suffix,
				MethodAttributes.Assembly | MethodAttributes.Static,
				typeof (string), Type.EmptyTypes);
			ilgen = mb.GetILGenerator ();
			ilgen.Emit (OpCodes.Ldnull);
			ilgen.Emit (OpCodes.Ret);
			pb.SetGetMethod (mb);

			//
			// instance events
			//

			eb = tb.DefineEvent ("OnPrivateInstance" + suffix,
				EventAttributes.None, typeof (EventHandler));
			mb = tb.DefineMethod ("add_OnPrivateInstance" + suffix,
				MethodAttributes.Private, typeof (void),
				Type.EmptyTypes);
			mb.GetILGenerator ().Emit (OpCodes.Ret);
			eb.SetAddOnMethod (mb);

			eb = tb.DefineEvent ("OnFamilyInstance" + suffix,
				EventAttributes.None, typeof (EventHandler));
			mb = tb.DefineMethod ("add_OnFamilyInstance" + suffix,
				MethodAttributes.Family, typeof (void),
				Type.EmptyTypes);
			mb.GetILGenerator ().Emit (OpCodes.Ret);
			eb.SetAddOnMethod (mb);

			eb = tb.DefineEvent ("OnFamANDAssemInstance" + suffix,
				EventAttributes.None, typeof (EventHandler));
			mb = tb.DefineMethod ("add_OnFamANDAssemInstance" + suffix,
				MethodAttributes.FamANDAssem, typeof (void),
				Type.EmptyTypes);
			mb.GetILGenerator ().Emit (OpCodes.Ret);
			eb.SetAddOnMethod (mb);

			eb = tb.DefineEvent ("OnFamORAssemInstance" + suffix,
				EventAttributes.None, typeof (EventHandler));
			mb = tb.DefineMethod ("add_OnFamORAssemInstance" + suffix,
				MethodAttributes.FamORAssem, typeof (void),
				Type.EmptyTypes);
			mb.GetILGenerator ().Emit (OpCodes.Ret);
			eb.SetAddOnMethod (mb);

			eb = tb.DefineEvent ("OnPublicInstance" + suffix,
				EventAttributes.None, typeof (EventHandler));
			mb = tb.DefineMethod ("add_OnPublicInstance" + suffix,
				MethodAttributes.Public, typeof (void),
				Type.EmptyTypes);
			mb.GetILGenerator ().Emit (OpCodes.Ret);
			eb.SetAddOnMethod (mb);

			eb = tb.DefineEvent ("OnAssemblyInstance" + suffix,
				EventAttributes.None, typeof (EventHandler));
			mb = tb.DefineMethod ("add_OnAssemblyInstance" + suffix,
				MethodAttributes.Family, typeof (void),
				Type.EmptyTypes);
			mb.GetILGenerator ().Emit (OpCodes.Ret);
			eb.SetAddOnMethod (mb);

			//
			// static events
			//

			eb = tb.DefineEvent ("OnPrivateStatic" + suffix,
				EventAttributes.None, typeof (EventHandler));
			mb = tb.DefineMethod ("add_OnPrivateStatic" + suffix,
				MethodAttributes.Private | MethodAttributes.Static,
				typeof (void), Type.EmptyTypes);
			mb.GetILGenerator ().Emit (OpCodes.Ret);
			eb.SetAddOnMethod (mb);

			eb = tb.DefineEvent ("OnFamilyStatic" + suffix,
				EventAttributes.None, typeof (EventHandler));
			mb = tb.DefineMethod ("add_OnFamilyStatic" + suffix,
				MethodAttributes.Family | MethodAttributes.Static,
				typeof (void), Type.EmptyTypes);
			mb.GetILGenerator ().Emit (OpCodes.Ret);
			eb.SetAddOnMethod (mb);

			eb = tb.DefineEvent ("OnFamANDAssemStatic" + suffix,
				EventAttributes.None, typeof (EventHandler));
			mb = tb.DefineMethod ("add_OnFamANDAssemStatic" + suffix,
				MethodAttributes.FamANDAssem | MethodAttributes.Static,
				typeof (void), Type.EmptyTypes);
			mb.GetILGenerator ().Emit (OpCodes.Ret);
			eb.SetAddOnMethod (mb);

			eb = tb.DefineEvent ("OnFamORAssemStatic" + suffix,
				EventAttributes.None, typeof (EventHandler));
			mb = tb.DefineMethod ("add_OnFamORAssemStatic" + suffix,
				MethodAttributes.FamORAssem | MethodAttributes.Static,
				typeof (void), Type.EmptyTypes);
			mb.GetILGenerator ().Emit (OpCodes.Ret);
			eb.SetAddOnMethod (mb);

			eb = tb.DefineEvent ("OnPublicStatic" + suffix,
				EventAttributes.None, typeof (EventHandler));
			mb = tb.DefineMethod ("add_OnPublicStatic" + suffix,
				MethodAttributes.Public | MethodAttributes.Static,
				typeof (void), Type.EmptyTypes);
			mb.GetILGenerator ().Emit (OpCodes.Ret);
			eb.SetAddOnMethod (mb);

			eb = tb.DefineEvent ("OnAssemblyStatic" + suffix,
				EventAttributes.None, typeof (EventHandler));
			mb = tb.DefineMethod ("add_OnAssemblyStatic" + suffix,
				MethodAttributes.Family | MethodAttributes.Static,
				typeof (void), Type.EmptyTypes);
			mb.GetILGenerator ().Emit (OpCodes.Ret);
			eb.SetAddOnMethod (mb);
		}

		static TypeBuilder Resolve1_Tb;
		static bool Resolve1_Called;

		public class Lookup<T>
		{
			public static Type t = typeof(T);
		}

		Assembly Resolve1 (object sender, ResolveEventArgs args) {
			Resolve1_Called = true;
			Resolve1_Tb.CreateType ();
			return Resolve1_Tb.Assembly;
		}

		[Test]
		public void TypeResolveGenericInstances () {
			// Test that TypeResolve is called for generic instances (#483852)
			TypeBuilder tb1 = null;

			AppDomain.CurrentDomain.TypeResolve += Resolve1;

			tb1 = module.DefineType("Foo");
			Resolve1_Tb = tb1;
			FieldInfo field = TypeBuilder.GetField(typeof(Lookup<>).MakeGenericType(tb1), typeof(Lookup<>).GetField("t"));
			TypeBuilder tb2 = module.DefineType("Bar");
			ConstructorBuilder cb = tb2.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes);
			ILGenerator ilgen = cb.GetILGenerator();
			
			ilgen.Emit(OpCodes.Ldarg_0);
			ilgen.Emit(OpCodes.Call, tb2.BaseType.GetConstructor(Type.EmptyTypes));

			ilgen.Emit(OpCodes.Ldsfld, field);
			ilgen.Emit(OpCodes.Pop);
			ilgen.Emit(OpCodes.Ret);
			Activator.CreateInstance(tb2.CreateType());

			Assert.IsTrue (Resolve1_Called);
		}

		[Test]
		public void CreateConcreteTypeWithAbstractMethod ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			tb.DefineMethod("method", MethodAttributes.Abstract | MethodAttributes.Public, typeof (void), Type.EmptyTypes);
			try {
				tb.CreateType ();
				Assert.Fail ("#1");
			} catch (InvalidOperationException) {}
		}

		[Test]
		public void ConcreteTypeDontLeakGenericParamFromItSelf ()
		{
            var tb = module.DefineType (genTypeName ());
			var gps = tb.DefineGenericParameters ("T");
            var mb = tb.DefineMethod ("m", MethodAttributes.Public | MethodAttributes.Static);
            mb.SetParameters (gps);
            mb.GetILGenerator ().Emit (OpCodes.Ret);

            var ti = tb.CreateType ();
            var mi = ti.GetMethod ("m");
			var arg0 = mi.GetParameters () [0].ParameterType;

			Assert.AreNotSame (arg0, gps [0], "#1");
		}

		[Test]
		public void ConcreteTypeDontLeakGenericParamFromMethods ()
		{
            var tb = module.DefineType (genTypeName ());
            var mb = tb.DefineMethod("m", MethodAttributes.Public | MethodAttributes.Static);
            var gps = mb.DefineGenericParameters ("T");
            mb.SetParameters (gps);
            mb.GetILGenerator ().Emit (OpCodes.Ret);

            var ti = tb.CreateType ();
            var mi = ti.GetMethod ("m");
 			var arg0 = mi.GetParameters () [0].ParameterType;

			Assert.AreNotSame (arg0, gps [0], "#1");
		}

		[Test]
		public void DeclaringMethodReturnsNull ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.IsNull (tb.DeclaringMethod, null, "#1");
		}

		[Test]
		public void GenericParameterPositionReturns0 ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.AreEqual (0, tb.GenericParameterPosition, "#1");
		}

		[Test]
		public void GetGenericTypeDefinitionBehavior ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			try {
				tb.GetGenericTypeDefinition ();
				Assert.Fail ("#1");
			} catch (InvalidOperationException) {}

			tb.DefineGenericParameters ("T");
			Assert.AreEqual (tb, tb.GetGenericTypeDefinition (), "#2");

			tb.CreateType ();
			Assert.AreEqual (tb, tb.GetGenericTypeDefinition (), "#3");
		}

		[Test]
		public void GetElementTypeNotSupported ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			try {
				tb.GetElementType ();
				Assert.Fail ("#1");
			} catch (NotSupportedException) {}
		}

		[Test]
		public void GenericParameterAttributesReturnsNone ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.AreEqual (GenericParameterAttributes.None, tb.GenericParameterAttributes, "#1");

			tb.DefineGenericParameters ("T");
			Assert.AreEqual (GenericParameterAttributes.None, tb.GenericParameterAttributes, "#2");

			tb.CreateType ();
			Assert.AreEqual (GenericParameterAttributes.None, tb.GenericParameterAttributes, "#3");
		}

		[Test]
		public void GetGenericArgumentsReturnsNullForNonGenericTypeBuilder ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			Assert.IsNull (tb.GetGenericArguments (), "#1");
		}

		public interface IFaceA {}
		public interface IFaceB : IFaceA {}
		[Test]
		public void GetInterfacesAfterCreate ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public, typeof (object), new Type[] { typeof (IFaceB) });

			Type[] ifaces = tb.GetInterfaces ();
			Assert.AreEqual (1, ifaces.Length, "#1");
			Assert.AreEqual (typeof (IFaceB), ifaces [0], "#2");

			tb.CreateType ();
			ifaces = tb.GetInterfaces ();
			Assert.AreEqual (2, ifaces.Length, "#3");
			//Interfaces can come in any particular order
			if (ifaces [0] == typeof (IFaceB)) {
				Assert.AreEqual (typeof (IFaceB), ifaces [0], "#4");
				Assert.AreEqual (typeof (IFaceA), ifaces [1], "#5");
			} else {
				Assert.AreEqual (typeof (IFaceB), ifaces [1], "#4");
				Assert.AreEqual (typeof (IFaceA), ifaces [0], "#5");
			}
		}

		public interface MB_Iface
		{
		    int Test ();
		}

		public class MB_Impl : MB_Iface
		{
		    public virtual int Test () { return 1; }
		}
		[Test]
		public void MethodOverrideBodyMustBelongToTypeBuilder ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			MethodInfo md = typeof (MB_Iface).GetMethod("Test");
            MethodInfo md2 = typeof (MB_Impl).GetMethod("Test");
			try {
            	tb.DefineMethodOverride (md, md2);
            	Assert.Fail ("#1");
			} catch (ArgumentException) {}
		}

		[Test]
		public void GetConstructorsThrowWhenIncomplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			try {
				tb.GetConstructors (BindingFlags.Instance);
				Assert.Fail ("#1");
			} catch (NotSupportedException) { }

			tb.CreateType ();
			Assert.IsNotNull (tb.GetConstructors (BindingFlags.Instance), "#2");
		}

		[Test]
		public void GetEventsThrowWhenIncomplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			try {
				tb.GetEvents (BindingFlags.Instance);
				Assert.Fail ("#1");
			} catch (NotSupportedException) { }

			tb.CreateType ();
			Assert.IsNotNull (tb.GetEvents (BindingFlags.Instance), "#2");
		}

		[Test]
		public void GetNestedTypeCreatedAfterTypeIsCreated ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			TypeBuilder nested = tb.DefineNestedType ("Bar", TypeAttributes.Class | TypeAttributes.NestedPrivate);
			tb.CreateType ();
			Assert.IsNull (tb.GetNestedType ("Bar", BindingFlags.NonPublic), "#1");
			Type res = nested.CreateType ();
			Assert.AreEqual (res, tb.GetNestedType ("Bar", BindingFlags.NonPublic), "#2");

			TypeBuilder nested2 = tb.DefineNestedType ("Bar2", TypeAttributes.Class | TypeAttributes.NestedPrivate);
			Assert.IsNull (tb.GetNestedType ("Bar2", BindingFlags.NonPublic), "#3");
			res = nested2.CreateType ();
			Assert.AreEqual (res, tb.GetNestedType ("Bar2", BindingFlags.NonPublic), "#4");
		}


		[Test]
		public void IsDefinedThrowWhenIncomplete ()
		{
			TypeBuilder tb = module.DefineType (genTypeName ());
			try {
				tb.IsDefined (typeof (string), true);
				Assert.Fail ("#1");
			} catch (NotSupportedException) { }

			tb.CreateType ();
			Assert.IsNotNull (tb.IsDefined (typeof (string), true), "#2");
		}

		[Test] //Bug #594728
		public void IsSubclassOfWorksIfSetParentIsCalledOnParent ()
		{
			var tb_a = module.DefineType ("A", TypeAttributes.Public);
			var tb_b = module.DefineType ("B", TypeAttributes.Public);
	
			tb_b.SetParent (tb_a);
			tb_a.SetParent (typeof (Attribute));
	
			Assert.IsTrue (tb_b.IsSubclassOf (tb_a), "#1");
			Assert.IsTrue (tb_b.IsSubclassOf (typeof (Attribute)), "#2");
			Assert.IsFalse (tb_a.IsSubclassOf (tb_b), "#3");
	
	
			var a = tb_a.CreateType ();
			var b = tb_b.CreateType ();
	
			Assert.IsTrue (b.IsSubclassOf (a), "#4");
			Assert.IsTrue (b.IsSubclassOf (typeof (Attribute)), "#5");
			Assert.IsFalse (a.IsSubclassOf (b), "#6");
		}

		[Test]
		public void DefinedDefaultConstructorWorksWithGenericBaseType ()
		{
			AssemblyName assemblyName = new AssemblyName ("a");
			AssemblyBuilder ass = AppDomain.CurrentDomain.DefineDynamicAssembly (assemblyName, AssemblyBuilderAccess.RunAndSave);
			var mb = ass.DefineDynamicModule ("a.dll");

			var tb = mb.DefineType ("Base");
			tb.DefineGenericParameters ("F");

			var inst = tb.MakeGenericType (typeof (int));
			var tb2 = mb.DefineType ("Child", TypeAttributes.Public, inst);

			tb.CreateType ();
			var res = tb2.CreateType ();

			Assert.IsNotNull (res, "#1");
			Assert.AreEqual (1, res.GetConstructors ().Length, "#2");
		}

		/* 
		 * Tests for passing user types to Ref.Emit. Currently these only test
		 * whenever the runtime code can handle them without crashing, since we
		 * don't support user types yet.
		 * These tests are disabled for windows since the MS runtime trips on them.
		 */
		[Test]
		[Category ("NotDotNet")] //Proper UT handling is a mono extension to SRE bugginess
		public void UserTypes () {
			TypeDelegator t = new TypeDelegator (typeof (int));

			try {
				/* Parent */
				TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public, t);
			} catch {
			}

			try {
				/* Interfaces */
				TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public, typeof (object), new Type [] { t });
				tb.CreateType ();
			} catch {
			}

			try {
				/* Fields */
				TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public, typeof (object));
				tb.DefineField ("Foo", t, FieldAttributes.Public);
				tb.CreateType ();
			} catch {
			}

			try {
				/* Custom modifiers on fields */
				TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public, typeof (object));
				tb.DefineField ("Foo", typeof (int), new Type [] { t }, new Type [] { t }, FieldAttributes.Public);
				tb.CreateType ();
			} catch {
			}
/* this is mono only
			try {
				UnmanagedMarshal m = UnmanagedMarshal.DefineCustom (t, "foo", "bar", Guid.Empty);
				TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public, typeof (object));
				FieldBuilder fb = tb.DefineField ("Foo", typeof (int), FieldAttributes.Public);
				fb.SetMarshal (m);
				tb.CreateType ();
			} catch {
			}
*/
			try {
				/* Properties */
				TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public, typeof (object));
				tb.DefineProperty ("Foo", PropertyAttributes.None, t, null);
				tb.CreateType ();
			} catch {
			}

			try {
				/* Custom modifiers on properties */
				TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public, typeof (object));
				// FIXME: These seems to be ignored
				tb.DefineProperty ("Foo", PropertyAttributes.None, typeof (int), new Type [] { t }, new Type [] { t }, null, null, null);
				tb.CreateType ();
			} catch {
			}

			try {
				/* Method return types */
				TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public, typeof (object));
				MethodBuilder mb = tb.DefineMethod ("foo", MethodAttributes.Public, t, null);
				mb.GetILGenerator ().Emit (OpCodes.Ret);
				tb.CreateType ();
			} catch {
			}

			try {
				/* Custom modifiers on method return types */
				TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public, typeof (object));
				MethodBuilder mb = tb.DefineMethod ("foo", MethodAttributes.Public, CallingConventions.Standard, typeof (int), new Type [] { t }, new Type [] { t }, null, null, null);
				mb.GetILGenerator ().Emit (OpCodes.Ret);
				tb.CreateType ();
			} catch {
			}

			try {
				/* Method parameters */
				TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public, typeof (object));
				MethodBuilder mb = tb.DefineMethod ("foo", MethodAttributes.Public, typeof (int), new Type [] { t });
				mb.GetILGenerator ().Emit (OpCodes.Ret);
				tb.CreateType ();
			} catch {
			}

			try {
				/* Custom modifiers on method parameters */
				TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public, typeof (object));
				MethodBuilder mb = tb.DefineMethod ("foo", MethodAttributes.Public, CallingConventions.Standard, typeof (int), null, null, new Type [] { typeof (int) }, new Type [][] { new Type [] { t }}, new Type[][] { new Type [] { t }});
				mb.GetILGenerator ().Emit (OpCodes.Ret);
				tb.CreateType ();
			} catch {
			}

			try {
				/* Ctor parameters */
				TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public, typeof (object));
				ConstructorBuilder mb = tb.DefineConstructor (MethodAttributes.Public, CallingConventions.Standard, new Type [] { t });
				mb.GetILGenerator ().Emit (OpCodes.Ret);
				tb.CreateType ();
			} catch {
			}
			
			try {
				/* Custom modifiers on ctor parameters */
				TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public, typeof (object));
				ConstructorBuilder mb = tb.DefineConstructor (MethodAttributes.Public, CallingConventions.Standard, new Type [] { typeof (int) }, new Type [][] { new Type [] { t }}, new Type[][] { new Type [] { t }});
				mb.GetILGenerator ().Emit (OpCodes.Ret);
				tb.CreateType ();
			} catch {
			}

			try {
				/* SignatureHelper arguments */
				SignatureHelper sighelper = SignatureHelper.GetFieldSigHelper (module);
				sighelper.AddArgument (t, false);
				byte[] arr = sighelper.GetSignature ();
			} catch {
			}

			try {
				SignatureHelper sighelper = SignatureHelper.GetLocalVarSigHelper (module);
				sighelper.AddArgument (t, false);
				byte[] arr = sighelper.GetSignature ();
			} catch {
			}

			try {
				/* Custom modifiers on SignatureHelper arguments */
				SignatureHelper sighelper = SignatureHelper.GetFieldSigHelper (module);
				sighelper.AddArgument (typeof (int), new Type [] { t }, new Type [] { t });
				byte[] arr = sighelper.GetSignature ();
			} catch {
			}

			try {
				/* Custom modifiers on SignatureHelper arguments */
				SignatureHelper sighelper = SignatureHelper.GetLocalVarSigHelper (module);
				sighelper.AddArgument (typeof (int), new Type [] { t }, new Type [] { t });
				byte[] arr = sighelper.GetSignature ();
			} catch {
			}

			/* Arguments to ILGenerator methods */
			try {
				/* Emit () */
				TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public, typeof (object));
				MethodBuilder mb = tb.DefineMethod ("foo", MethodAttributes.Public, CallingConventions.Standard, typeof (int), new Type [] { });
				ILGenerator ig = mb.GetILGenerator ();
				ig.Emit (OpCodes.Ldnull);
				ig.Emit (OpCodes.Castclass, t);
				ig.Emit (OpCodes.Pop);
				ig.Emit (OpCodes.Ret);
				tb.CreateType ();
			} catch {
			}

			try {
				/* DeclareLocal () */
				TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public, typeof (object));
				MethodBuilder mb = tb.DefineMethod ("foo", MethodAttributes.Public, CallingConventions.Standard, typeof (int), new Type [] { });
				ILGenerator ig = mb.GetILGenerator ();
				ig.DeclareLocal (t);
				ig.Emit (OpCodes.Ret);
				tb.CreateType ();
			} catch {
			}

			try {
				/* BeginExceptionCatchBlock () */
				TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public, typeof (object));
				MethodBuilder mb = tb.DefineMethod ("foo", MethodAttributes.Public, CallingConventions.Standard, typeof (int), new Type [] { });
				ILGenerator ig = mb.GetILGenerator ();
				ig.BeginExceptionBlock ();
				ig.BeginCatchBlock (t);
				ig.Emit (OpCodes.Ret);
				tb.CreateType ();
			} catch {
			}

			try {
				/* EmitCalli () */
				TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Public, typeof (object));
				MethodBuilder mb = tb.DefineMethod ("foo", MethodAttributes.Public, CallingConventions.Standard, typeof (int), new Type [] { });
				ILGenerator ig = mb.GetILGenerator ();
				ig.EmitCalli (OpCodes.Call, CallingConventions.Standard, typeof (void), new Type [] { t }, null);
				ig.Emit (OpCodes.Ret);
				tb.CreateType ();
			} catch {
			}
		}

		//Test for #572660
        [Test]
        [Category ("MobileNotWorking")] // Mono.CompilerServices.SymbolWriter not available in XA
        public void CircularArrayType()
        {
			var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName("Test"), AssemblyBuilderAccess.RunAndSave);
			var moduleBuilder = assemblyBuilder.DefineDynamicModule("Test", "Test.dll", true);
			var typeBuilder = moduleBuilder.DefineType("Foo", TypeAttributes.Public);
			var fieldBuilder = typeBuilder.DefineField("Foos", typeBuilder.MakeArrayType(), FieldAttributes.Public);

			var fooType = typeBuilder.CreateType();
			Assert.AreSame(fooType.MakeArrayType(), fooType.GetField("Foos").FieldType);
        }


		[Test] //Test for #422113
		[ExpectedException (typeof (TypeLoadException))]
		public void CreateInstanceOfIncompleteType ()
		{
			TypeBuilder tb = module.DefineType (genTypeName (), TypeAttributes.Class, null, new Type[] { typeof (IComparable) });
			Type proxyType = tb.CreateType();
			Activator.CreateInstance(proxyType);
		}

		[Test] //Test for #640780
		public void StaticMethodNotUsedInIfaceVtable ()
		{
			TypeBuilder tb1 = module.DefineType("Interface", TypeAttributes.Interface | TypeAttributes.Abstract);
			tb1.DefineTypeInitializer().GetILGenerator().Emit(OpCodes.Ret);
			tb1.DefineMethod("m", MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.Abstract);
			tb1.CreateType();
			
			TypeBuilder tb2 = module.DefineType("Class", TypeAttributes.Sealed);
			tb2.AddInterfaceImplementation(tb1);
			tb2.DefineMethod("m", MethodAttributes.Public | MethodAttributes.Virtual)
			    .GetILGenerator().Emit(OpCodes.Ret);
			tb2.DefineDefaultConstructor(MethodAttributes.Public);
			
			Activator.CreateInstance(tb2.CreateType());
		}

		[Test] //Test for #648391
		public void GetConstructorCheckCtorDeclaringType ()
		{
			TypeBuilder myType = module.DefineType ("Sample", TypeAttributes.Public);
			string[] typeParamNames = { "TFirst" };
			GenericTypeParameterBuilder[] typeParams = myType.DefineGenericParameters (typeParamNames);
			var ctor = myType.DefineDefaultConstructor (MethodAttributes.Public);
			var ctori = TypeBuilder.GetConstructor (myType.MakeGenericType (typeof (int)), ctor);
			try {
				TypeBuilder.GetConstructor (myType.MakeGenericType (typeof (bool)), ctori);
				Assert.Fail ("#1");
			} catch (ArgumentException) {
				//OK
			}
		}

		[Test] //Test for #649237
		public void GetFieldCheckFieldDeclaringType () {
			TypeBuilder myType = module.DefineType ("Sample", TypeAttributes.Public);
			myType.DefineGenericParameters ( "TFirst");
			TypeBuilder otherType = module.DefineType ("Sample2", TypeAttributes.Public);
			otherType.DefineGenericParameters ( "TFirst");

			var field = myType.DefineField ("field", typeof (object), FieldAttributes.Public);

			try {
				TypeBuilder.GetField (otherType.MakeGenericType (typeof (int)), field);
				Assert.Fail ("#1");
			} catch (ArgumentException) {
				//OK
			}
		}

		[Test]
		public void TypeWithFieldRVAWorksUnderSgen () {
	        AssemblyName an = new AssemblyName("MAIN");
	        AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly(an,
	            AssemblyBuilderAccess.Run, ".");
	        ModuleBuilder mob = ab.DefineDynamicModule("MAIN");
	        TypeBuilder tb = mob.DefineType("MAIN", TypeAttributes.Public |
	            TypeAttributes.Sealed | TypeAttributes.Abstract |
	            TypeAttributes.Class | TypeAttributes.BeforeFieldInit);

	        byte[] source = new byte[] { 42 };
	        FieldBuilder fb = tb.DefineInitializedData("A0", source, 0);

	        MethodBuilder mb = tb.DefineMethod("EVAL", MethodAttributes.Static |
	            MethodAttributes.Public, typeof(byte[]), new Type[] { });
	        ILGenerator il = mb.GetILGenerator();

	        il.Emit(OpCodes.Ldc_I4_1);
	        il.Emit(OpCodes.Newarr, typeof(byte));
	        il.Emit(OpCodes.Dup);
	        il.Emit(OpCodes.Ldtoken, fb);
	        il.Emit(OpCodes.Call, typeof(RuntimeHelpers).GetMethod("InitializeArray"));
	        il.Emit(OpCodes.Ret);

	        Type t = tb.CreateType();

	        GC.Collect();

	        byte[] res = (byte[]) t.InvokeMember("EVAL", BindingFlags.Public |
	            BindingFlags.Static | BindingFlags.InvokeMethod, null, null,
	            new object[] { });

	        Assert.AreEqual (42, res[0]);
	    }


		[Test]
		public void Ldfld_Regress_9531 () {
			Build<Example<int>> ();
		}

		void Build<T> () {
            var base_class = typeof(T);

            var builder = module.DefineType(genTypeName (),
                TypeAttributes.Class | TypeAttributes.Sealed | TypeAttributes.Public,
                base_class);

            var field = builder.BaseType.GetField("Field", BindingFlags.Instance | BindingFlags.Public);
            
            var cb = builder.DefineConstructor(
                MethodAttributes.Public | MethodAttributes.SpecialName,
                CallingConventions.HasThis,
                new[] { typeof(string) });
            
            var il = cb.GetILGenerator();
            
            if (field == null)
            {
                throw new InvalidOperationException("wtf");
            }
            
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Ldarg_1);
            il.Emit(OpCodes.Stfld, field);
            il.Emit(OpCodes.Ret);
            
            builder.CreateType();
		}

		public class Example<T> {
			public string Field;
			public T Field2;
		}

		[Test]
		[Category ("AndroidNotWorking")]
		// It's not possible to save the assembly in the current directory on Android and AssemblyBuilder.DefineDynamicModule will not
		// allow a full path to the assembly to be passed to it. Trying to change the current directory before saving will not work either as
		// FileStream will then prepend / to the file name (perhaps it's another bug) and write access to the filesystem root is, obviously, denied
		public void Ldfld_Encoding_10122 () {
			Build2<Example<int>> ();
		}

		void Build2<T> () {
			var base_class = typeof(T);

	        string AssemblyName = genTypeName ();
	        string AssemblyFileName = AssemblyName + ".dll";

			var assemblyBuilderAccess = AssemblyBuilderAccess.Save;
			var assemblyName = new AssemblyName(AssemblyName);
			var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, assemblyBuilderAccess);
			var moduleBuilder = assemblyBuilder.DefineDynamicModule(AssemblyName, AssemblyFileName);


			var builder = moduleBuilder.DefineType("Wrapped",
                TypeAttributes.Class | TypeAttributes.Sealed | TypeAttributes.Public,
                base_class);

            var field = builder.BaseType.GetField("Field", BindingFlags.Instance | BindingFlags.Public);
            
            var cb = builder.DefineConstructor(
                MethodAttributes.Public | MethodAttributes.SpecialName,
                CallingConventions.HasThis,
                new[] { typeof(string) });
            
            var il = cb.GetILGenerator();
            
            if (field == null)
            {
                throw new InvalidOperationException("wtf");
            }
            
            il.Emit(OpCodes.Ldarg_0);
            il.Emit(OpCodes.Ldarg_1);
            il.Emit(OpCodes.Stfld, field);
            il.Emit(OpCodes.Ret);
            
            builder.CreateType();

			assemblyBuilder.Save (AssemblyFileName);

			var fromDisk = Assembly.Load (AssemblyName);
			Console.WriteLine (fromDisk);
			var t = fromDisk.GetType ("Wrapped");
			Activator.CreateInstance (t, new object[] { "string"});
		}

		public interface IFace16096 {
			object Bar ();
		}

		[Test]
		public void MemberRef_Caching_16096 () {
			var outer_class = module.DefineType(
				"container",
				TypeAttributes.Class | TypeAttributes.Public,
				typeof(object));

			var builder = outer_class.DefineNestedType(
				"bind@32-1",
				TypeAttributes.Class | TypeAttributes.Public,
				typeof(object));

			builder.AddInterfaceImplementation (typeof (IFace16096));

			var ctor = builder.DefineDefaultConstructor (MethodAttributes.Public);
			var field = builder.DefineField ("Field", typeof (object), FieldAttributes.Public);
			var g_args = builder.DefineGenericParameters("b","a");
			var method = builder.DefineMethod ("Bar", MethodAttributes.Public | MethodAttributes.Virtual, typeof (object), new Type [0]);

			var il = method.GetILGenerator();
			il.Emit (OpCodes.Ldarg_0);
			il.Emit (OpCodes.Ldfld, TypeBuilder.GetField (builder.MakeGenericType (g_args), field));
			il.Emit (OpCodes.Pop);
			il.Emit (OpCodes.Newobj, TypeBuilder.GetConstructor (builder.MakeGenericType (g_args), ctor));
			il.Emit (OpCodes.Ret);

			var type = builder.CreateType ();

			/*Build a gshared instance. */
			var ginst = type.MakeGenericType (typeof (List<char>), typeof (object));
			var ins = (IFace16096)Activator.CreateInstance (ginst);

			/* This will trigger the runtime to cache the MEMBER_REF to the .ctor as it won't have a context. */
			var ins2 = ins.Bar ();
			Assert.IsNotNull (ins2);

			/* Build an unsharable version. */
			var ginst2 = type.MakeGenericType (typeof (List<char>), typeof (char));
			var ins3 = (IFace16096)Activator.CreateInstance (ginst2);

			/* This will trigger the runtime to use the cached version, which is wrong as it's an open type. */
			var ins4 = ins3.Bar ();
			Assert.IsNotNull (ins4);
		}

		// #22059
		[Test]
		[ExpectedException (typeof (TypeLoadException))]
		public void PrivateIface ()
		{
			TypeBuilder tb = module.DefineType ("Sample", TypeAttributes.Public, typeof (object), new[] { typeof (IFoo) });
            tb.CreateType();
		}

		interface IFoo {
		}
	}
}