using System;
using System.Diagnostics;
#if !__WATCHOS__
using System.Drawing;
#endif
using System.Runtime.InteropServices;
using System.Threading;

using CoreGraphics;
using Foundation;
using ObjCRuntime;
#if !__WATCHOS__
using SpriteKit;
#endif
#if !MONOMAC
using UIKit;
#endif
using NUnit.Framework;

using MonoTests.System.Net.Http;

namespace MonoTouchFixtures.ObjCRuntime {

	static class AssociatedObjects {
		public enum AssociationPolicy { // uintptr_t
			Assign			= 0,
			RetainNonAtomic	= 1,
			CopyNonAtomic	= 3,
			Retain			= 0x301,
			Copy			= 0x303,
		}

		[DllImport (Messaging.LIBOBJC_DYLIB)]
		static extern void objc_setAssociatedObject (IntPtr obj, IntPtr key, IntPtr value, IntPtr policy);

		public static void SetAssociatedObject (this NSObject self, IntPtr key, NSObject value, AssociationPolicy policy)
		{
			objc_setAssociatedObject (self.Handle, key, value.Handle, new IntPtr ((int) policy));
		}

		public static IntPtr GetAssociatedPointer (this NSObject self, IntPtr key)
		{
			throw new NotImplementedException ();
		}

		public static void RemoveAssociatedObjects (this NSObject self)
		{
			throw new NotImplementedException ();
		}
	}

	[TestFixture]
	[Preserve (AllMembers = true)]
	public class RuntimeTest {
		static bool connectMethodTestDone;
		[Test]
		public void ConnectMethodTest ()
		{
			if (connectMethodTestDone)
				Assert.Ignore ("This test can only be executed once, it modifies global state.");
			if (!Runtime.DynamicRegistrationSupported)
				Assert.Ignore ("This test requires support for dynamic registration.");
			connectMethodTestDone = true;
			// Bug 20013. This should not throw a KeyNotFoundException.
			Runtime.ConnectMethod (typeof (ConnectMethodClass).GetMethod ("Method"), new Selector ("method"));
		}

		class ConnectMethodClass : NSObject { 
			public void Method () {	}
		}

		[Test]
		public void GetNSObject_IntPtrZero ()
		{
			Assert.Null (Runtime.GetNSObject (IntPtr.Zero));
		}

		[Test]
		public void RegisterAssembly_null ()
		{
			Assert.Throws<ArgumentNullException> (() => Runtime.RegisterAssembly (null));
		}

#if __IOS__ && !__MACCATALYST__
		[Test]
		public void StartWWAN ()
		{
			Assert.Throws<ArgumentNullException> (delegate { Runtime.StartWWAN (null); }, "null");
			Assert.Throws<ArgumentException> (delegate { Runtime.StartWWAN (new Uri ("ftp://www.xamarin.com")); }, "ftp");
			Runtime.StartWWAN (new Uri ("http://www.xamarin.com"));
		}
#endif // __IOS__ && !__MACCATALYST__

		[Test]
		public void GetNSObject_Subclass ()
		{
			using (var c = new NSHttpCookie ("name", "value")) {
				// we want to ensure we get the NSMutableDictionary even if we ask for (the base) NSDictionary
				var d = Runtime.GetNSObject<NSDictionary> (Messaging.IntPtr_objc_msgSend (c.Handle, Selector.GetHandle ("properties")));
				Assert.That (d, Is.TypeOf<NSMutableDictionary> (), "NSMutableDictionary");
			}
		}

#if !__WATCHOS__
		[Test]
		public void GetNSObject_Different_Class ()
		{
			TestRuntime.AssertXcodeVersion (5, 0);
			TestRuntime.AssertSystemVersion (PlatformName.MacOSX, 10, 9, throwIfOtherPlatform: false);

			IntPtr class_ptr = Class.GetHandle ("SKPhysicsBody");
			var size = new CGSize (3, 2);
			using (var body = Runtime.GetNSObject<SKPhysicsBody> (Messaging.IntPtr_objc_msgSend_CGSize (class_ptr, Selector.GetHandle ("bodyWithRectangleOfSize:"), size))) {
				// This would normally return a PKPhysicsBody which is not a subclass but answers the same selectors
				// as a SKPhysicsBody. That's an issue since we can't register PKPhysicsBody (Apple won't like it since
				// it's a private type) and the non-generic version of GetNSObject (and bindings) would throw an 
				// InvalidaCastException (since it's Class will resolve to NSObject)
				// note: that's the internal PhysicKit shared by UIKit and SpriteKit
				Assert.That (body, Is.TypeOf<SKPhysicsBody> (), "SKPhysicsBody");
			}
		}
#endif // !__WATCHOS__

		[Test]
		public void GetNSObject_Posing_Class ()
		{
			TestRuntime.AssertXcodeVersion (5, 0);
			TestRuntime.AssertSystemVersion (PlatformName.MacOSX, 10, 9, throwIfOtherPlatform: false);

			NSUrlSession session = NSUrlSession.SharedSession;
			using (var request = new NSUrlRequest (new NSUrl (NetworkResources.MicrosoftUrl))) {
				// In iOS 8 the native CreateDownloadTask function returns an instance of a
				// __NSCFLocalDownloadTask, which does not derive from 
				// NSUrlSessionDownloadTask (which is the documented/expected return type from
				// CreateDownloadTask). But __NSCFLocalDownloadTask does override
				// isKindOfClass: to return true if asked about NSUrlSessionDownloadTask.
				// In other words it's posing as a NSUrlSessionDownloadTask.
				using (var o = session.CreateDownloadTask (request)) {
				}
			}
		}

		[Test]
		public void UsableUntilDead ()
		{
			// The test can be inconclusive once in a while.
			// 100 times in a row is a bit too much though.
			for (int i = 0; i < 100; i++) {
				if (UsableUntilDeadImpl ())
					return;
			}

			Assert.Inconclusive ("Failed to collect the notification object at least once in 100 runs.");
		}

		public bool UsableUntilDeadImpl ()
		{
			// This test ensure that the main thread can send messages to a garbage collected object,
			// until the final 'release' message for the managed reference has been sent
			// (on the main thread).

			var notifierHandle = IntPtr.Zero;

//			bool isDeallocated = false;
			Action deallocated = () => {
				//Console.WriteLine ("Final release!");
//				isDeallocated = true;
			};

			ManualResetEvent isCollected = new ManualResetEvent (false);
			Action collected = () => {
				//Console.WriteLine ("Garbage collected!");
				isCollected.Set ();
			};

			bool isNotified = false;
			Action notified = () => {
				//Console.WriteLine ("Notified");
				isNotified = true;
			};

			// Create an object whose handle we store in a local variable. We do not
			// store the object itself, since we want the object to be garbage collected.
			var t = new Thread (() => {
				var obj = new Notifier (collected, notified);
				ReleaseNotifier.NotifyWhenDeallocated (obj, deallocated);
				notifierHandle = obj.Handle;
			}) {
				IsBackground = true,
			};
			t.Start ();
			t.Join ();

			// Now we have a handle to an object that may be garbage collected at any time.
			int counter = 0;
			do {
				GC.Collect ();
				GC.WaitForPendingFinalizers ();
			} while (counter++ < 10 && !isCollected.WaitOne (10));

			// Now we have a handle to a garbage collected object.
			if (!isCollected.WaitOne (0)) {
				// Objects may randomly not end up collected (at least in Boehm), because
				// other objects may happen to contain a random value pointing to the
				// object we're waiting to become freed.
				return false;
			}

			// Send a message to the collected object.
			Messaging.void_objc_msgSend (notifierHandle, Selector.GetHandle ("notify"));
			Assert.IsTrue (isNotified, "notified");

			// We're done. Cleanup.
			NSRunLoop.Main.RunUntil (NSDate.Now.AddSeconds (0.1));
			// Don't verify cleanup, it's not consistent.
			// And in any case it's not what this test is about.
//			Assert.IsTrue (isDeallocated, "released");

			return true;
		}

		class Notifier : NSObject {
			Action collected;
			Action notified;

			public Notifier (Action collected, Action notified) 
			{
				this.collected = collected;
				this.notified = notified;
			}

			~Notifier ()
			{
				collected ();
			}

			[Export ("notify")]
			void Notify ()
			{
				Console.WriteLine ("{0} Notified", DateTime.Now.ToString ());
				notified ();
			}
		}

		class Level1 : NSObject {} // we need two levels of subclassing, since the XI will override 'release' on the first one, and we need to override it as well.
		class ReleaseNotifier : Level1 {
			Action deallocated;
			bool enabled;

			ReleaseNotifier (Action deallocated)
			{
				this.deallocated = deallocated;
			}

			[Export ("release")]
			new void Release ()
			{
				if (enabled)
					deallocated ();
				Messaging.objc_super super;
				super.Handle = Handle;
				super.SuperHandle = ClassHandle;
				Messaging.void_objc_msgSendSuper (ref super, Selector.GetHandle ("release"));
			}

			public static void NotifyWhenDeallocated (NSObject obj, Action deallocated)
			{
				// Add an associated object which will be 'released'd when the obj
				// to watch is deallocated. When 'release' is sent, then invoke
				// the 'deallocated' callback.
				var notifier = new ReleaseNotifier (deallocated);
				obj.SetAssociatedObject (IntPtr.Zero, notifier, AssociatedObjects.AssociationPolicy.Retain);
				notifier.Dispose (); // remove any managed references.
				notifier.enabled = true; // notify on the next 'release' message.
			}
		}

		[Test]
		public void FinalizationRaceCondition ()
		{
#if __WATCHOS__
			if (Runtime.Arch == Arch.DEVICE)
				Assert.Ignore ("This test uses too much memory for the watch.");
#endif

			NSDictionary dict = null;

			var thread = new Thread (() => {
				dict = new NSMutableDictionary();
				dict["Hello"] = new NSString(@"World");
				dict["Bye"] = new NSString(@"Bye");
			})
			{ 
				IsBackground = true
			};
			thread.Start ();
			thread.Join ();

			var getter1 = new Func<string, string> ((key) => dict [key] as NSString);
			var getter2 = new Func<string, NSString> ((key) => dict [key] as NSString);

			var broken = 0;
			var count = 0;

			thread = new Thread (() => {
				var watch = new Stopwatch ();
				watch.Start ();

				while (broken == 0 && watch.ElapsedMilliseconds < 10000) {
					// try getting using Systen.String key
					string hello = getter1("Hello");
					if (hello == null)
						broken = 1;

					string bye = getter1("Bye");
					if (bye == null)
						broken = 2;

					// try getting using NSString key
					string nHello = getter2(new NSString(@"Hello"));
					string nBye = getter2(new NSString(@"Bye"));

					if (nHello == null)
						broken = 3;

					if (nBye == null)
						broken = 4;

					count++;
				}
			}) {
				IsBackground = true,
			};
			thread.Start ();
			while (!thread.Join (1))
				NSRunLoop.Main.RunUntil (NSDate.Now.AddSeconds (0.1));

			Assert.AreEqual (0, broken, string.Format ("broken after {0} iterations", count));
		}

		[Test]
		public void ConnectMethod ()
		{
			if (!Runtime.DynamicRegistrationSupported)
				Assert.Ignore ("This test requires support for dynamic registration.");
			
			var minfo = typeof (RuntimeTest).GetMethod ("ConnectMethod");
			Assert.Throws<ArgumentNullException> (() => Runtime.ConnectMethod (null, new Selector ("")), "1");
			Assert.Throws<ArgumentNullException> (() => Runtime.ConnectMethod (minfo, null), "2");
			Assert.Throws<ArgumentNullException> (() => Runtime.ConnectMethod (null, minfo, new ExportAttribute ("foo")), "3");
			Assert.Throws<ArgumentNullException> (() => Runtime.ConnectMethod (typeof (RuntimeTest), null, new ExportAttribute ("foo")), "4");
			Assert.Throws<ArgumentNullException> (() => Runtime.ConnectMethod (typeof (RuntimeTest), minfo, (ExportAttribute) null), "5");

			Assert.Throws<ArgumentException> (() => Runtime.ConnectMethod (typeof (RuntimeTest), minfo, new Selector ("foo")), "6");
			Assert.Throws<ArgumentException> (() => Runtime.ConnectMethod (typeof (A), minfo, new Selector ("foo")), "7");
		}

		static bool connectMethod1Done;
		[Test]
		public void ConnectMethod1 ()
		{
			if (!Runtime.DynamicRegistrationSupported)
				Assert.Ignore ("This test requires support for dynamic registration.");
			
			if (connectMethod1Done)
				Assert.Ignore ("This is a one-shot test. Restart to run again.");
			connectMethod1Done = true;

			Runtime.ConnectMethod (typeof (A).GetMethod ("Test"), new Selector ("test1"));

			using (var a = new A ())
				Messaging.void_objc_msgSend (a.Handle, Selector.GetHandle ("test1"));
		}

		static bool connectMethod2Done;
		[Test]
		public void ConnectMethod2 ()
		{
			if (!Runtime.DynamicRegistrationSupported)
				Assert.Ignore ("This test requires support for dynamic registration.");
			
			if (connectMethod2Done)
				Assert.Ignore ("This is a one-shot test. Restart to run again.");
			connectMethod2Done = true;

			// the method is not declared on the type we're connecting to,but a completely different type.
			Runtime.ConnectMethod (typeof (A), typeof (RuntimeTest).GetMethod ("Test2"), new Selector ("test2"));

			Messaging.void_objc_msgSend (Class.GetHandle (typeof (A)), Selector.GetHandle ("test2"));
			Assert.IsTrue (calledTest2);
		}

		static bool calledTest2;
		public static void Test2 ()
		{
			calledTest2 = true;
		}


		static bool connectMethod3Done;
		[Test]
		public void ConnectMethod3 ()
		{
			if (!Runtime.DynamicRegistrationSupported)
				Assert.Ignore ("This test requires support for dynamic registration.");
			
			if (connectMethod3Done)
				Assert.Ignore ("This is a one-shot test. Restart to run again.");
			connectMethod3Done = true;

			Runtime.ConnectMethod (typeof (NSString), typeof (RuntimeTest).GetMethod ("Test3"), new Selector ("test3"));

			Messaging.void_objc_msgSend (Class.GetHandle (typeof (NSString)), Selector.GetHandle ("test3"));
			Assert.IsTrue (calledTest3);
		}

		static bool calledTest3;
		public static void Test3 ()
		{
			calledTest3 = true;
		}

		class A : NSObject {
			public void Test() {
				Console.WriteLine ("Tested!");
			}
		}

		[Test]
		public void GetINativeObjectTest ()
		{
			// create a string and try to get it.
			IntPtr strptr = IntPtr.Zero;
			IntPtr valueptr;
			NSString obj;
			try {
				strptr = Marshal.StringToHGlobalAuto ("value");

				valueptr = Messaging.IntPtr_objc_msgSend_IntPtr (Class.GetHandle (typeof (NSString)), Selector.GetHandle ("stringWithUTF8String:"), strptr);
				Assert.Throws<RuntimeException> (() => Runtime.GetINativeObject<INativeObject> (valueptr, false), "INativeObject");

				valueptr = Messaging.IntPtr_objc_msgSend_IntPtr (Class.GetHandle (typeof (NSString)), Selector.GetHandle ("stringWithUTF8String:"), strptr);
				obj = Runtime.GetINativeObject<NSObject> (valueptr, false) as NSString;
				Assert.AreEqual ("value", (string) obj, "NSObject");

				valueptr = Messaging.IntPtr_objc_msgSend_IntPtr (Class.GetHandle (typeof (NSString)), Selector.GetHandle ("stringWithUTF8String:"), strptr);
				obj = Runtime.GetINativeObject<NSString> (valueptr, false) as NSString;
				Assert.AreEqual ("value", (string) obj, "NSString");

				valueptr = Messaging.IntPtr_objc_msgSend_IntPtr (Class.GetHandle (typeof (NSString)), Selector.GetHandle ("stringWithUTF8String:"), strptr);
				var nscopying = Runtime.GetINativeObject<INSCopying> (valueptr, false);
				Assert.NotNull (nscopying, "INSCopying");
			} finally {
				Marshal.FreeHGlobal (strptr);
			}
		}

		[Test]
#if NET
		[Ignore ("https://github.com/dotnet/runtime/issues/32543")]
#endif
		public void NSAutoreleasePoolInThreadPool ()
		{
			var count = 100;
			var counter = new CountdownEvent (count);
			var obj = new NSObject ();

			for (int i = 0; i < count; i++) {
				ThreadPool.QueueUserWorkItem ((v) => {
					obj.DangerousRetain ().DangerousAutorelease ();
					counter.Signal ();
				});
			}

			Assert.IsTrue (counter.Wait (TimeSpan.FromSeconds (5)), "timed out");
			// there is a race condition here: we don't necessarily know when the
			// threadpool's autorelease pools are freed (in theory we can have X
			// threadpool threads stopped just after the 'counter.Signal' line,
			// before unwinding to the autorelease pool's dispose frame). So 
			// assert that the retain count has decreased, but not that it has
			// decreased to 1
			var max_iterations = 100;
			var iterations = 0;
			while ((long) obj.RetainCount > (long) count / 2 && iterations++ < max_iterations) {
				Thread.Sleep (100);
			}
			Assert.That (obj.RetainCount, Is.Not.GreaterThan ((nuint) (count / 2)), "RC. Iterations: " + iterations);

			obj.Dispose ();
		}


		class ResurrectedObjectsDisposedTestClass : NSObject {
			[Export ("invokeMe:wait:")]
			static bool InvokeMe (NSObject obj, int invokerWait)
			{
				Thread.Sleep (invokerWait);

				return obj.Handle != IntPtr.Zero;
			}
		}

		[Test]
#if !MONOMAC // Failing with 10 broken
		[TestCase (typeof (NSObject))]
#endif
		[TestCase (typeof (ResurrectedObjectsDisposedTestClass))]
		public void ResurrectedObjectsDisposedTest (Type type)
		{
#if __WATCHOS__
			if (Runtime.Arch == Arch.DEVICE)
				Assert.Ignore ("This test uses too much memory for the watch.");
#endif

			var invokerClassHandle = Class.GetHandle (typeof (ResurrectedObjectsDisposedTestClass));

			// Create a number of native objects with no managed wrappers.
			// We create more than one to try to minimize the random effects
			// of the GC (a random value somewhere can keep a single object
			// from being collected, but the chances of X random values keeping
			// X objects from being collected are much lower).
			// Also the consequences if the GC doesn't collect an object is
			// that the test unexpectedly succeeds.
			// 10 objects seem to be a fine number that will cause pretty much
			// all test executions to fail.
			var objects = new IntPtr [10];
			for (int i = 0; i < objects.Length; i++)
				objects [i] = Messaging.IntPtr_objc_msgSend (Messaging.IntPtr_objc_msgSend (Class.GetHandle (type), Selector.GetHandle ("alloc")), Selector.GetHandle ("init"));

			// Create a thread that creates managed wrappers for all of the above native objects.
			// We do this on a separate thread so that the GC finds no pointers to the managed
			// objects in any thread.
			var t1 = new Thread (() => {
				for (int i = 0; i < objects.Length; i++)
					Messaging.bool_objc_msgSend_IntPtr_int (invokerClassHandle, Selector.GetHandle ("invokeMe:wait:"), objects [i], 0);
			});
			t1.Start ();
			t1.Join ();

			// Collect all those managed wrappers, and make sure their finalizers are executed.
			GC.Collect ();
			GC.WaitForPendingFinalizers ();

			// Now all the managed wrappers should be on NSObject's drain queue on the main thread.

			// Spin up a thread for every native object, and invoke a managed method
			// that will fetch the managed wrapper and then wait for a while (500ms),
			// before verifying that the managed object hasn't been disposed while waiting.
			var invokerWait = 500;
			var threads = new Thread [objects.Length];
			var brokenCount = 0;
			var countdown = new CountdownEvent (threads.Length);
			for (int t = 0; t < threads.Length; t++) {
				var tt = t;
				var thread = new Thread (() => {
					var ok = Messaging.bool_objc_msgSend_IntPtr_int (invokerClassHandle, Selector.GetHandle ("invokeMe:wait:"), objects [tt], invokerWait);
					if (!ok) {
						//Console.WriteLine ("Broken #{0}: 0x{1}", tt, objects [tt].ToString ("x"));
						Interlocked.Increment (ref brokenCount);
					}
					countdown.Signal ();
				});
				thread.Start ();
			}

			// Now all those threads should be waiting.

			// Run the runloop on the main thread, which will drain the managed wrappers
			// on NSObject's drain queue.
			while (!countdown.IsSet) {
				NSRunLoop.Current.RunUntil ((NSDate) DateTime.Now.AddSeconds (0.1));
			}

			// Release all the native objects we created
			for (int i = 0; i < objects.Length; i++)
				Messaging.void_objc_msgSend (objects [i], Selector.GetHandle ("release"));

			Assert.AreEqual (0, brokenCount, "broken count");
		}

		[Test]
		public void MX8029 ()
		{
			var handle = Messaging.IntPtr_objc_msgSend (Messaging.IntPtr_objc_msgSend (Class.GetHandle (typeof (Dummy)), Selector.GetHandle ("alloc")), Selector.GetHandle ("init"));
			try {
				try {
					Messaging.void_objc_msgSend_IntPtr (Class.GetHandle (typeof (Dummy)), Selector.GetHandle ("doSomethingElse:"), handle);
					Assert.Fail ("Expected an MX8029 exception (A)");
				} catch (RuntimeException mex) {
					Assert.AreEqual (8029, mex.Code, "Exception code (A)");
					var failure = mex.ToString ();
					Assert.That (failure, Does.Contain ("Failed to marshal the Objective-C object"), "Failed to marshal (A)");
					Assert.That (failure, Does.Contain ("Additional information:"), "Additional information: (A)");
					Assert.That (failure, Does.Contain ("Selector: doSomethingElse:"), "Selector (A)");
					Assert.That (failure, Does.Contain ("DoSomethingElse"), "DoSomethingElse (A)");
				}

				try {
					Messaging.void_objc_msgSend_IntPtr (handle, Selector.GetHandle ("doSomething:"), handle);
					Assert.Fail ("Expected an MX8034 exception (B)");
				} catch (RuntimeException mex) {
					Assert.That (mex.Code, Is.EqualTo (8034).Or.EqualTo (8027), "Exception code (B)");
					var failure = mex.ToString ();
					Assert.That (failure, Does.Contain ("Failed to marshal the Objective-C object"), "Failed to marshal (B)");
					Assert.That (failure, Does.Contain ("Additional information:"), "Additional information: (B)");
					Assert.That (failure, Does.Contain ("Selector: doSomething:"), "Selector (B)");
					Assert.That (failure, Does.Contain ("DoSomething"), "DoSomething (B)");
				}
			} finally {
				Messaging.void_objc_msgSend (handle, Selector.GetHandle ("release"));
			}
		}

#if DYNAMIC_REGISTRAR
		[Test]
		public void MX8029_b ()
		{
			try {
				using (var arr = new NSArray ()) {
					Messaging.void_objc_msgSend_IntPtr (Class.GetHandle (typeof (Dummy)), Selector.GetHandle ("setIntArray:"), arr.Handle);
					Assert.Fail ("An exception should have been thrown");
				}
			} catch (RuntimeException re) {
				Assert.AreEqual (8029, re.Code, "Code");
				Assert.AreEqual (@"Unable to marshal the array parameter #1 whose managed type is 'System.Int32[]' to managed.
Additional information:
	Selector: setIntArray:
	Method: MonoTouchFixtures.ObjCRuntime.RuntimeTest/Dummy:SetIntArray (int[])
", re.Message, "Message");
				var inner = (RuntimeException)re.InnerException;
				Assert.AreEqual (8031, inner.Code, "Inner Code");
				Assert.AreEqual ("Unable to convert from an NSArray to a managed array of System.Int32.", inner.Message, "Inner Message");
			}
		}

		[Test]
		public void MX8033 ()
		{
			try {
				Messaging.IntPtr_objc_msgSend (Class.GetHandle (typeof (Dummy)), Selector.GetHandle ("intArray"));
				Assert.Fail ("An exception should have been thrown");
			} catch (RuntimeException re) {
				Assert.AreEqual (8033, re.Code, "Code");
				Assert.AreEqual (@"Unable to marshal the return value of type 'System.Int32[]' to Objective-C.
Additional information:
	Selector: intArray
	Method: MonoTouchFixtures.ObjCRuntime.RuntimeTest/Dummy:GetIntArray ()
", re.Message, "Message");
				var inner = (RuntimeException) re.InnerException;
				Assert.AreEqual (8032, inner.Code, "Inner Code");
				Assert.AreEqual ("Unable to convert from a managed array of System.Int32 to an NSArray.", inner.Message, "Inner Message");
			}
		}
#endif

		// does not have an IntPtr constructor
		class Dummy : NSObject {
			[Export ("initWithFoo:")]
			public Dummy (int foo)
			{
				// Prevent the default ctor from being exported.
			}

			[Export ("doSomething:")]
			public void DoSomething (Dummy dummy)
			{
			}

			[Export ("doSomethingElse:")]
			public static void DoSomethingElse (Dummy dummy)
			{
			}

#if DYNAMIC_REGISTRAR
			// This function makes the static registrar show an error, so it's only built when using the dynamic registrar.
			[Export ("intArray")]
			static int[] GetIntArray ()
			{
				return new int [] { };
			}
			// This function makes the static registrar show an error, so it's only built when using the dynamic registrar.
			[Export ("setIntArray:")]
			static void SetIntArray (int[] array)
			{
				Assert.Fail ("This method should never be called.");
			}
#endif
		} 

		[Test]
		public void GetINativeObject_ForcedType ()
		{
			using (var str = new NSString ("hello world")) {
				NSDate date;

				Assert.Throws<InvalidCastException> (() => Runtime.GetINativeObject<NSDate> (str.Handle, false), "EX1"); //
				Assert.Throws<InvalidCastException> (() => Runtime.GetINativeObject<NSDate> (str.Handle, false, false), "EX2"); //

				// Making a string quack like a date.
				// This is a big hack, but hopefully it works well enough for this particular test case.
				// Just don't inspect the date variable in a debugger (it will most likely crash the app).
				date = Runtime.GetINativeObject<NSDate> (str.Handle, true, false);
				Assert.AreEqual (date.Handle, str.Handle, "Same native pointer");
				date.Dispose ();
				date = null;
			}
		}
	}
}