//
// EnumBuiderTest - NUnit Test Cases for the EnumBuider class
//
// Keerti Narayan (keertiln@rediffmail.com)
// Gert Driesen (drieseng@users.sourceforge.net)
//
// (C) Ximian, Inc.  http://www.ximian.com
//
//

using System;
using System.IO;
using System.Reflection;
using System.Reflection.Emit;
using System.Collections;
using System.Threading;

using NUnit.Framework;

namespace MonoTests.System.Reflection.Emit
{
	[TestFixture]
	public class EnumBuilderTest
	{
		private static string _assemblyName = "MonoTests.System.Reflection.Emit.EnumBuilder";
		private static string _moduleName = "EmittedModule";
		private static string _enumNamespace = "MyNameSpace";
		private static string _enumName = "MyEnum";
		private static Type _enumType = typeof (Int32);
		private static string _fieldName = "MyField";
		private static object _fieldValue = 1;

		[Test]
		public void TestEnumBuilder ()
		{
			EnumBuilder enumBuilder = GenerateEnum ();
			VerifyType (enumBuilder);

			Assert.IsNotNull (enumBuilder.TypeToken, "#1");
			Assert.IsNotNull (enumBuilder.UnderlyingField, "#2");
			Assert.IsNull (enumBuilder.DeclaringType, "#3");
			Assert.IsNull (enumBuilder.ReflectedType, "#4");
			Assert.AreEqual (_enumType, enumBuilder.UnderlyingSystemType, "#5");
			Assert.IsFalse (enumBuilder.IsSerializable);
		}

		[Test]
		[Category ("NotWorking")]
		public void TestHasElementTypeEnumBuilderIncomplete ()
		{
			EnumBuilder enumBuilder = GenerateEnum ();
			bool hasElementType = enumBuilder.HasElementType;
			Assert.IsFalse (hasElementType);
		}

		[Test]
		public void TestHasElementTypeEnumBuilderComplete ()
		{
			EnumBuilder enumBuilder = GenerateEnum ();
			enumBuilder.CreateType ();
			bool hasElementType = enumBuilder.HasElementType;
			Assert.IsFalse (hasElementType);
		}

		[Test]
		[ExpectedException (typeof (InvalidOperationException))]
		public void TestDefineLiteralTypeComplete ()
		{
			EnumBuilder enumBuilder = GenerateEnum ();
			Type enumType = enumBuilder.CreateType ();
			// you should not be able to define literal after type 
			// has been created
			enumBuilder.DefineLiteral (_fieldName, _fieldValue);
		}

		[Test]
		public void TestDefineLiteralTypeIncomplete ()
		{
			EnumBuilder enumBuilder = GenerateEnum ();
			FieldBuilder fieldBuilder = enumBuilder.DefineLiteral (_fieldName, _fieldValue);
			Type enumType = enumBuilder.CreateType ();

			Assert.IsTrue (fieldBuilder.IsPublic, "#1");
			Assert.IsTrue (fieldBuilder.IsStatic, "#2");
			Assert.IsTrue (fieldBuilder.IsLiteral, "#3");
			Assert.AreEqual (_fieldName, fieldBuilder.Name, "#4");
			Assert.IsFalse (enumType == fieldBuilder.DeclaringType, "#5");
			Assert.IsFalse (enumBuilder == fieldBuilder.DeclaringType, "#6");
			Assert.AreEqual (enumType.FullName, fieldBuilder.DeclaringType.FullName, "#7");
			Assert.IsFalse (enumType == fieldBuilder.FieldType, "#8");
			Assert.AreEqual (enumBuilder, fieldBuilder.FieldType, "#9");
		}

		[Test]
		public void TestEnumType ()
		{
			AssemblyBuilder assemblyBuilder = GenerateAssembly ();

			ModuleBuilder modBuilder = GenerateModule (assemblyBuilder);
			EnumBuilder enumBuilder = GenerateEnum (modBuilder);
			enumBuilder.CreateType ();

			Type enumType = assemblyBuilder.GetType (_enumNamespace + "." + _enumName, true);

			VerifyType (enumType);
		}

		[Test]
		[ExpectedException (typeof (NotSupportedException))]
		public void TestEnumBuilderGUIDIncomplete ()
		{
			EnumBuilder enumBuilder = GenerateEnum ();
			Guid guid = enumBuilder.GUID;
		}

		[Test]
		public void TestEnumBuilderGUIDComplete ()
		{
			EnumBuilder enumBuilder = GenerateEnum ();
			enumBuilder.CreateType ();
			Assert.AreEqual (new Guid ("71780918-965d-31e4-b24c-cd0a1420d84b"), enumBuilder.GUID);
		}

		[Test]
		public void TestEnumTypeGUID ()
		{
			AssemblyBuilder assemblyBuilder = GenerateAssembly ();
			ModuleBuilder modBuilder = GenerateModule (assemblyBuilder);
			EnumBuilder enumBuilder = GenerateEnum (modBuilder);
			enumBuilder.CreateType ();

			Type enumType = assemblyBuilder.GetType (_enumNamespace + "." + _enumName, true);

			// Tested in above test: Assert (enumType.GUID != Guid.Empty);
			Assert.IsNull (enumType.DeclaringType);
		}

		[Test]
		public void TestFieldProperties ()
		{
			AssemblyBuilder assemblyBuilder = GenerateAssembly ();
			ModuleBuilder modBuilder = GenerateModule (assemblyBuilder);
			EnumBuilder enumBuilder = GenerateEnum (modBuilder);
			FieldBuilder fieldBuilder = GenerateField (enumBuilder);
			enumBuilder.CreateType ();

			Type enumType = assemblyBuilder.GetType (_enumNamespace + "." + _enumName, true);
			FieldInfo fi = enumType.GetField (_fieldName);
			Object o = fi.GetValue (enumType);

			Assert.IsTrue (fi.IsLiteral, "#1");
			Assert.IsTrue (fi.IsPublic, "#2");
			Assert.IsTrue (fi.IsStatic, "#3");
			Assert.AreEqual (enumBuilder, fieldBuilder.FieldType, "#4");
			Assert.IsFalse (enumType == fieldBuilder.FieldType, "#5");
			Assert.AreEqual (enumType.FullName, fieldBuilder.FieldType.FullName, "#6");
			Assert.IsFalse (_enumType == fieldBuilder.FieldType, "#7");

			object fieldValue = fi.GetValue (enumType);
			Assert.IsFalse (_fieldValue == fieldValue, "#8");
			Assert.IsTrue (fieldValue.GetType ().IsEnum, "#9");
			Assert.AreEqual (enumType, fieldValue.GetType (), "#10");
			Assert.AreEqual (_fieldValue, (int) fieldValue, "#11");
		}

		[Test]
		public void TestFindInterfaces ()
		{
			EnumBuilder enumBuilder = GenerateEnum ();

			Type [] interfaces = enumBuilder.FindInterfaces (
				new TypeFilter (MyInterfaceFilter),
				"System.Collections.IEnumerable");
			Assert.AreEqual (0, interfaces.Length);
		}

		[Test]
		[ExpectedException (typeof (NotSupportedException))]
		public void TestFindMembersIncomplete ()
		{
			EnumBuilder enumBuilder = GenerateEnum ();
			GenerateField (enumBuilder);

			MemberInfo [] members = enumBuilder.FindMembers (
				MemberTypes.All, BindingFlags.Static |
				BindingFlags.Public, new MemberFilter (MemberNameFilter),
				_fieldName);
		}

		[Test]
		public void GetEnumUnderlyingType ()
		{
			var @enum = GenerateEnum ();

			Assert.AreEqual (_enumType, @enum.GetEnumUnderlyingType ());
		}

		[Test]
		public void TestFindMembersComplete ()
		{
			EnumBuilder enumBuilder = GenerateEnum ();
			GenerateField (enumBuilder);
			enumBuilder.CreateType ();

			MemberInfo [] members = enumBuilder.FindMembers (
				MemberTypes.Field, BindingFlags.Static |
				BindingFlags.Public, new MemberFilter (MemberNameFilter),
				_fieldName);
			Assert.AreEqual (1, members.Length, "#1");

			members = enumBuilder.FindMembers (
				MemberTypes.Field, BindingFlags.Static |
				BindingFlags.Public, new MemberFilter (MemberNameFilter),
				"doesntmatter");
			Assert.AreEqual (0, members.Length, "#2");
		}

		[Test]
		[ExpectedException (typeof (NotSupportedException))]
		public void TestGetConstructorIncomplete ()
		{
			EnumBuilder enumBuilder = GenerateEnum ();
			enumBuilder.GetConstructor (BindingFlags.Public, null,
				CallingConventions.Any, Type.EmptyTypes, new ParameterModifier [0]);
		}

		[Test]
		public void TestGetConstructorComplete ()
		{
			EnumBuilder enumBuilder = GenerateEnum ();
			enumBuilder.CreateType ();
			ConstructorInfo ctor = enumBuilder.GetConstructor (
				BindingFlags.Public, null, CallingConventions.Any,
				Type.EmptyTypes, new ParameterModifier [0]);
			Assert.IsNull (ctor);
		}

		[Test]
		[ExpectedException (typeof (ArgumentNullException))]
		public void TestGetConstructorNullTypes ()
		{
			EnumBuilder enumBuilder = GenerateEnum ();
			enumBuilder.CreateType ();
			ConstructorInfo ctor = enumBuilder.GetConstructor (
				BindingFlags.Public, null, CallingConventions.Any,
				null, new ParameterModifier [0]);
		}

		[Test]
		[Category ("NotWorking")]
		[ExpectedException (typeof (ArgumentNullException))]
		public void TestGetConstructorNullElementType ()
		{
			EnumBuilder enumBuilder = GenerateEnum ();
			enumBuilder.CreateType ();
			ConstructorInfo ctor = enumBuilder.GetConstructor (
				BindingFlags.Public, null, CallingConventions.Any,
				new Type [] { null }, new ParameterModifier [0]);
		}

		[Test]
		[ExpectedException (typeof (NotSupportedException))]
		[Category ("NotWorking")]
		public void TestGetConstructorsIncomplete ()
		{
			EnumBuilder enumBuilder = GenerateEnum ();

			ConstructorInfo [] ctors = enumBuilder.GetConstructors (
				BindingFlags.Instance | BindingFlags.Public);
			Assert.AreEqual (0, ctors.Length);
		}

		[Test]
		public void TestGetConstructorsComplete ()
		{
			EnumBuilder enumBuilder = GenerateEnum ();
			enumBuilder.CreateType ();

			ConstructorInfo [] ctors = enumBuilder.GetConstructors (
				BindingFlags.Instance | BindingFlags.Public);
			Assert.AreEqual (0, ctors.Length);
		}

		[Test]
		public void TestIsValue__SpecialName ()
		{
			EnumBuilder enumBuilder = GenerateEnum ();
			Type enumType = enumBuilder.CreateType ();
			FieldInfo value = enumType.GetField ("value__", BindingFlags.Instance | BindingFlags.NonPublic);
			Assert.AreEqual (FieldAttributes.RTSpecialName, value.Attributes & FieldAttributes.RTSpecialName);
		}

		[Test]
		public void TestCreateTypeIncompleteEnumStaticField ()
		{
			ModuleBuilder modBuilder = GenerateModule ();
			EnumBuilder enumBuilder = GenerateEnum (modBuilder);
			GenerateField (enumBuilder);

			var tb = modBuilder.DefineType ("T", TypeAttributes.Public);

			tb.DefineDefaultConstructor (MethodAttributes.Public);
			tb.DefineField ("e", enumBuilder, FieldAttributes.Static | FieldAttributes.Public);

			var t = tb.CreateType ();
			Assert.IsNotNull (t);
			bool caught = false;
			try {
				object x = Activator.CreateInstance (t);
			} catch (TypeLoadException exn) {
				Assert.AreEqual (t.Name, exn.TypeName);
				caught = true;
			}
			if (!caught)
				Assert.Fail ("Expected CreateInstance of a broken type to throw TLE");
		}

		[Test]
		public void TestCreateInvalidEnumWithAnIncompleteUnderlyingEnumType ()
		{
			var mb = GenerateModule ();
			var incomplete = GenerateEnum (mb);
			GenerateField (incomplete);

			var eb = mb.DefineEnum (
				_enumNamespace + ".IncompleteUnderlying",
				TypeAttributes.Public,
				incomplete);

			bool caught = false;
			try {
				var t = eb.CreateType ();
			} catch (TypeLoadException exn) {
				caught = true;
			}
			if (!caught)
				Assert.Fail ("Expected CreateType of a broken type to throw TLE");
		}

		[Test]
		public void TestEnumBuilderTokenUsable () {
			// Regression test for https://bugzilla.xamarin.com/show_bug.cgi?id=58361
			// Create an EnumBuilder and use it in an ILGenerator that consumes its token.
			var modBuilder = GenerateModule ();
			EnumBuilder enumBuilder = GenerateEnum (modBuilder);

			var tb = modBuilder.DefineType ("Foo", TypeAttributes.Public);

			var cb = tb.DefineConstructor (MethodAttributes.Public, CallingConventions.Standard,
						       Type.EmptyTypes);

			var ilg = cb.GetILGenerator ();

			ilg.Emit (OpCodes.Ldtoken, enumBuilder);
			ilg.Emit (OpCodes.Pop);
			ilg.Emit (OpCodes.Ret);

			var t = tb.CreateType ();
			enumBuilder.CreateType ();

			var ci = t.GetConstructor (Type.EmptyTypes);
			var x = ci.Invoke (null);
			Assert.IsNotNull (x);
		}

		[Test]
		public void TestEnumBuilderTokenUsableCrossAssembly () {
			// Regression test for https://bugzilla.xamarin.com/show_bug.cgi?id=58361
			// Create an EnumBuilder and use it in an ILGenerator that consumes its token in a different assembly.
			var modBuilder = GenerateModule ();
			var modBuilder2 = GenerateModule ();
			EnumBuilder enumBuilder = GenerateEnum (modBuilder2);

			// N.B. "tb" is in modBuilder but enumBuilder is in modBuilder2
			var tb = modBuilder.DefineType ("Foo", TypeAttributes.Public);

			var cb = tb.DefineConstructor (MethodAttributes.Public, CallingConventions.Standard,
						       Type.EmptyTypes);

			var ilg = cb.GetILGenerator ();

			ilg.Emit (OpCodes.Ldtoken, enumBuilder);
			ilg.Emit (OpCodes.Pop);
			ilg.Emit (OpCodes.Ret);

			var t = tb.CreateType ();
			enumBuilder.CreateType ();

			var ci = t.GetConstructor (Type.EmptyTypes);
			var x = ci.Invoke (null);
			Assert.IsNotNull (x);
		}


		private static void VerifyType (Type type)
		{
			Assert.IsNotNull (type.Assembly, "#V1");
			Assert.IsNotNull (type.AssemblyQualifiedName, "#V2");
			Assert.IsNotNull (type.BaseType, "#V3");
			Assert.IsNotNull (type.FullName, "#V4");
			Assert.IsNotNull (type.Module, "#V5");
			Assert.IsNotNull (type.Name, "#V6");
			Assert.IsNotNull (type.Namespace, "#V7");
			Assert.IsNotNull (type.UnderlyingSystemType, "#V8");

			Assert.AreEqual (_enumNamespace, type.Namespace, "#V10");
			Assert.AreEqual (_enumName, type.Name, "#V11");
			Assert.AreEqual (typeof (Enum), type.BaseType, "#V12");
			Assert.AreEqual (MemberTypes.TypeInfo, type.MemberType, "#V13");
			Assert.AreEqual (typeof (int), Enum.GetUnderlyingType (type), "#V14");

			Assert.IsFalse (type.IsArray, "#V15");
			Assert.IsFalse (type.IsAutoClass, "#V16");
			Assert.IsTrue (type.IsAutoLayout, "#V17");
			Assert.IsFalse (type.IsByRef, "#V18");
			Assert.IsFalse (type.IsClass, "#V19");
			Assert.IsFalse (type.IsCOMObject, "#V20");
			Assert.IsFalse (type.IsContextful, "#V21");
			Assert.IsTrue (type.IsEnum, "#V22");
			Assert.IsFalse (type.IsExplicitLayout, "#V23");
			Assert.IsFalse (type.IsImport, "#V24");
			Assert.IsFalse (type.IsInterface, "#V25");
			Assert.IsFalse (type.IsLayoutSequential, "#V26");
			Assert.IsFalse (type.IsMarshalByRef, "#V27");
			Assert.IsFalse (type.IsNestedAssembly, "#V28");
			Assert.IsFalse (type.IsNestedFamily, "#V29");
			Assert.IsFalse (type.IsNestedPublic, "#V30");
			Assert.IsFalse (type.IsNestedPrivate, "#V31");
			Assert.IsFalse (type.IsNotPublic, "#V32");
			Assert.IsFalse (type.IsPrimitive, "#V33");
			Assert.IsFalse (type.IsPointer, "#V34");
			Assert.IsTrue (type.IsPublic, "#V35");
			Assert.IsTrue (type.IsSealed, "#V36");
			Assert.IsFalse (type.IsUnicodeClass, "#V37");
			Assert.IsFalse (type.IsSpecialName, "#V38");
			Assert.IsTrue (type.IsValueType, "#V39");
		}

		public static bool MyInterfaceFilter (Type t, object filterCriteria)
		{
			if (t.ToString () == filterCriteria.ToString ())
				return true;
			else
				return false;
		}

		public static bool MemberNameFilter (MemberInfo m, object filterCriteria)
		{
			if (m.Name == filterCriteria.ToString ())
				return true;
			else
				return false;
		}

		private static AssemblyName GetAssemblyName ()
		{
			AssemblyName assemblyName = new AssemblyName ();
			assemblyName.Name = _assemblyName;
			return assemblyName;
		}

		private static AssemblyBuilder GenerateAssembly ()
		{
			return AppDomain.CurrentDomain.DefineDynamicAssembly (
				GetAssemblyName (), AssemblyBuilderAccess.RunAndSave);
		}

		private static ModuleBuilder GenerateModule ()
		{
			AssemblyBuilder assemblyBuilder = GenerateAssembly ();
			return assemblyBuilder.DefineDynamicModule (_moduleName);
		}

		private static ModuleBuilder GenerateModule (AssemblyBuilder assemblyBuilder)
		{
			return assemblyBuilder.DefineDynamicModule (_moduleName);
		}

		private static EnumBuilder GenerateEnum ()
		{
			ModuleBuilder modBuilder = GenerateModule ();
			return modBuilder.DefineEnum (_enumNamespace + "."
				+ _enumName, TypeAttributes.Public, _enumType);
		}

		private static EnumBuilder GenerateEnum (ModuleBuilder modBuilder)
		{
			return modBuilder.DefineEnum (_enumNamespace + "."
				+ _enumName, TypeAttributes.Public, _enumType);
		}

		private static FieldBuilder GenerateField ()
		{
			EnumBuilder enumBuilder = GenerateEnum ();
			return enumBuilder.DefineLiteral (_fieldName, _fieldValue);
		}

		private static FieldBuilder GenerateField (EnumBuilder enumBuilder)
		{
			return enumBuilder.DefineLiteral (_fieldName, _fieldValue);
		}
	}
}