[netcore] Implement/fix enum/nullable comparers.

[mono-project.git] / mono / tests / appdomain-unload.cs

using System;
using System.Threading;
using System.Reflection;
using System.Runtime.Remoting;

[Serializable]
public class Foo {

        ~Foo () {
                Console.WriteLine ("FINALIZING IN DOMAIN " + AppDomain.CurrentDomain.FriendlyName + ": " + AppDomain.CurrentDomain.IsFinalizingForUnload ());
        }
}

public class Bar : MarshalByRefObject {
        public int test (int x) {
                Console.WriteLine ("in " + Thread.GetDomain ().FriendlyName);
                return x + 1;
        }

        public void start_wait () {
                Action a = delegate () {
                        Thread.Sleep (10000);
                };
                a.BeginInvoke (null, null);
        }
}

[Serializable]
public class SlowFinalize {

        ~SlowFinalize () {
                Console.WriteLine ("FINALIZE1.");
                try {
                        Thread.Sleep (500);
                }
                catch (Exception ex) {
                        Console.WriteLine ("A: " + ex);
                }
                Console.WriteLine ("FINALIZE2.");
        }
}

[Serializable]
public class AThread {

        public AThread () {
                new Thread (new ThreadStart (Run)).Start ();
        }

        public void Run () {
                try {
                        while (true)
                                Thread.Sleep (100);
                }
                catch (ThreadAbortException ex) {
                        Console.WriteLine ("Thread aborted correctly.");
                }
        }
}

// A Thread which refuses to die
public class BThread : MarshalByRefObject {

        bool stop;

        public BThread () {
                new Thread (new ThreadStart (Run)).Start ();
        }

        public void Stop () {
                stop = true;
        }

        public void Run () {
                try {
                        while (true)
                                Thread.Sleep (100);
                }
                catch (ThreadAbortException ex) {
                        while (!stop)
                                Thread.Sleep (100);
                }
        }
}

public interface IRunnable {
        void Run ();
}

public class MBRObject : MarshalByRefObject, IRunnable {
        /* XDomain wrappers for invocation */
        public void Run () {
                while (true) {
                        try {
                                while (true)
                                        Thread.Sleep (100);
                        }
                        catch (ThreadAbortException ex) {
                                Thread.ResetAbort ();
                        }
                }
        }
}

public class CBObject : ContextBoundObject, IRunnable {
        /* Slow corlib path for invocation */
        public void Run () {
                while (true) {
                        try {
                                while (true)
                                        Thread.Sleep (100);
                        }
                        catch (ThreadAbortException ex) {
                                Thread.ResetAbort ();
                        }
                }
        }
}

public class UnloadThread {

        AppDomain domain;

        public UnloadThread (AppDomain domain) {
                this.domain = domain;
        }

        public void Run () {
                Console.WriteLine ("UNLOAD1");
                AppDomain.Unload (domain);
                Console.WriteLine ("UNLOAD2");
        }
}

class CrossDomainTester : MarshalByRefObject
{
}

public class Tests
{
        public static int Main(string[] args) {
                if (args.Length == 0)
                        return TestDriver.RunTests (typeof (Tests), new String[] { "-v" });
                else
                        return TestDriver.RunTests (typeof (Tests), args);
        }

        public static int test_0_unload () {
                for (int i = 0; i < 10; ++i) {
                        AppDomain appDomain = AppDomain.CreateDomain("Test-unload" + i);

                        appDomain.CreateInstanceAndUnwrap (
                                typeof (CrossDomainTester).Assembly.FullName, "CrossDomainTester");

                        AppDomain.Unload(appDomain);
                }

                return 0;
        }

        public static int test_0_unload_default () {
                try {
                        AppDomain.Unload (Thread.GetDomain ());
                }
                catch (CannotUnloadAppDomainException) {
                        return 0;
                }
                return 1;
        }

        public static int test_0_unload_after_unload () {
                AppDomain domain = AppDomain.CreateDomain ("Test2");
                AppDomain.Unload (domain);

                try {
                        AppDomain.Unload (domain);
                }
                catch (Exception) {
                        return 0;
                }

                return 1;
        }

        public static int test_0_is_finalizing () {
                AppDomain domain = AppDomain.CreateDomain ("Test-is-finalizing");
                object o = domain.CreateInstanceFromAndUnwrap (typeof (Tests).Assembly.Location, "Foo");

                if (domain.IsFinalizingForUnload ())
                        return 1;

                AppDomain.Unload (domain);

                return 0;
        }

        public static int test_0_unload_with_active_threads () {
                AppDomain domain = AppDomain.CreateDomain ("Test3");
                object o = domain.CreateInstanceFromAndUnwrap (typeof (Tests).Assembly.Location, "AThread");
                Thread.Sleep (100);

                AppDomain.Unload (domain);

                return 0;
        }

        /* In recent mono versions, there is no unload timeout */
        /*
        public static int test_0_unload_with_active_threads_timeout () {
                AppDomain domain = AppDomain.CreateDomain ("Test4");
                BThread o = (BThread)domain.CreateInstanceFromAndUnwrap (typeof (Tests).Assembly.Location, "BThread");
                Thread.Sleep (100);

                try {
                        AppDomain.Unload (domain);
                }
                catch (Exception) {
                        // Try again
                        o.Stop ();
                        AppDomain.Unload (domain);
                        return 0;
                }

                return 1;
        }
        */

        public static void ThreadStart (object obj)
        {
                IRunnable runnable = (IRunnable)obj;

                try {
                        runnable.Run ();
                } catch (AppDomainUnloadedException) {
                        Console.WriteLine ("OK");
                } catch (ThreadAbortException) {
                        throw new Exception ();
                }
        }

        public static int test_0_unload_reset_abort () {
                AppDomain domain = AppDomain.CreateDomain ("test_0_unload_reset_abort");
                MBRObject mbro = (MBRObject) domain.CreateInstanceFromAndUnwrap (typeof (Tests).Assembly.Location, "MBRObject");
                CBObject cbo = (CBObject) domain.CreateInstanceFromAndUnwrap (typeof (Tests).Assembly.Location, "CBObject");

                new Thread (ThreadStart).Start (mbro);
                new Thread (ThreadStart).Start (cbo);
                Thread.Sleep (100);

                AppDomain.Unload (domain);
                return 0;
        }

        static void Worker (object x) {
                Thread.Sleep (100000);
        }

        public static void invoke_workers () {
                for (int i = 0; i < 1; i ++)
                        ThreadPool.QueueUserWorkItem (Worker);
        }

        public static int test_0_unload_with_threadpool () {
                AppDomain domain = AppDomain.CreateDomain ("test_0_unload_with_threadpool");

                domain.DoCallBack (new CrossAppDomainDelegate (invoke_workers));
                AppDomain.Unload (domain);

                return 0;
        }

        /*
         * This test is not very deterministic since the thread which enqueues
         * the work item might or might not be inside the domain when the unload
         * happens. So disable this for now.
         */
        /*
        public static void DoUnload (object state) {
                AppDomain.Unload (AppDomain.CurrentDomain);
        }

        public static void Callback () {
                Console.WriteLine (AppDomain.CurrentDomain);
                WaitCallback unloadDomainCallback = new WaitCallback (DoUnload);
                ThreadPool.QueueUserWorkItem (unloadDomainCallback);
        }               

        public static int test_0_unload_inside_appdomain_async () {
                AppDomain domain = AppDomain.CreateDomain ("Test3");

                domain.DoCallBack (new CrossAppDomainDelegate (Callback));

                return 0;
        }
        */

        public static void SyncCallback () {
                AppDomain.Unload (AppDomain.CurrentDomain);
        }               

        public static int test_0_unload_inside_appdomain_sync () {
                AppDomain domain = AppDomain.CreateDomain ("Test3");
                bool caught = false;

                try {
                        domain.DoCallBack (new CrossAppDomainDelegate (SyncCallback));
                }
                catch (AppDomainUnloadedException ex) {
                        caught = true;
                }

                if (!caught)
                        return 1;

                return 0;
        }

        public static int test_0_invoke_after_unload () {
                AppDomain domain = AppDomain.CreateDomain ("DeadInvokeTest");
                Bar bar = (Bar)domain.CreateInstanceAndUnwrap (typeof (Tests).Assembly.FullName, "Bar");
                int x;

                if (!RemotingServices.IsTransparentProxy(bar))
                        return 3;

                AppDomain.Unload (domain);

                try {
                        x = bar.test (123);
                        if (x == 124)
                                return 1;
                        return 2;
                } catch (Exception e) {
                        return 0;
                }
        }

        public static int test_0_abort_wait () {
                AppDomain domain = AppDomain.CreateDomain ("AbortWait");
                Bar bar = (Bar)domain.CreateInstanceAndUnwrap (typeof (Tests).Assembly.FullName, "Bar");
                int x;

                bar.start_wait ();
                AppDomain.Unload (domain);
                return 0;
        }

        // FIXME: This does not work yet, because the thread is finalized too
        // early
        /*
        public static int test_0_unload_during_unload () {
                AppDomain domain = AppDomain.CreateDomain ("Test3");
                object o = domain.CreateInstanceFromAndUnwrap (typeof (Tests).Assembly.Location, "SlowFinalize");

                UnloadThread t = new UnloadThread (domain);

                // Start unloading in a separate thread
                new Thread (new ThreadStart (t.Run)).Start ();

                Thread.Sleep (100);

                try {
                        AppDomain.Unload (domain);
                }
                catch (Exception) {
                        Console.WriteLine ("OK");
                }

                return 0;
        }       
*/
}