public static int Main() {
        CreateArray();

        WeakReference weak = new WeakReference(array);
                
        bool ans1 = weak.IsAlive;
        Console.WriteLine(ans1);

        if(ans1==false) { // GC.Collect() has already occurred..under GCStress
            Console.WriteLine("Test for WeakReference.IsAlive passed!");
            return 100;
        }

        //else, do an expicit collect.
        DestroyArray();
        GC.Collect();
        
        bool ans2 = weak.IsAlive;
        Console.WriteLine(ans2);

        if((ans1 == true) && (ans2==false)) {
            Console.WriteLine("Test for WeakReference.IsAlive passed!");
            return 100;
        }
        else {
            Console.WriteLine("Test for WeakReference.IsAlive failed!");
            return 1;
        }
    }

    public bool PosTest1()
    {
        bool retVal = true;

        TestLibrary.TestFramework.BeginScenario("PosTest1: TrackResurrection will return correct value when construct the WeakReference for an object instance");

        try
        {
            Object obj = new Object();
            WeakReference reference = new WeakReference(obj, true);

            if (!reference.TrackResurrection)
            {
                TestLibrary.TestFramework.LogError("001.1", "TrackResurrection returns false when construct the WeakReference for an object instance");
                retVal = false;
            }

            reference = new WeakReference(obj, false);

            if (reference.TrackResurrection)
            {
                TestLibrary.TestFramework.LogError("001.2", "TrackResurrection returns true when construct the WeakReference for an object instance");
                retVal = false;
            }
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("001.3", "Unexpected exception: " + e);
            TestLibrary.TestFramework.LogInformation(e.StackTrace);
            retVal = false;
        }

        return retVal;
    }

        private void MetadataCachingWithGarbageCollectionTemplate(Action garbageCollection)
        {
            MetadataWorkspace.ClearCache();
            var weakReferences = new WeakReference[3];

            // load metadata
            using (var connection1 = new EntityConnection(connectionString))
            {
                connection1.Open();

                weakReferences[0] = new WeakReference(connection1.GetMetadataWorkspace().GetItemCollection(DataSpace.CSpace));
                weakReferences[1] = new WeakReference(connection1.GetMetadataWorkspace().GetItemCollection(DataSpace.SSpace));
                weakReferences[2] = new WeakReference(connection1.GetMetadataWorkspace().GetItemCollection(DataSpace.CSSpace));
            }

            // perform necessary garbage collection steps
            garbageCollection();

            // verify that metadata was cached
            using (var connection2 = new EntityConnection(connectionString))
            {
                connection2.Open();

                Assert.Same(weakReferences[0].Target, connection2.GetMetadataWorkspace().GetItemCollection(DataSpace.CSpace));
                Assert.Same(weakReferences[1].Target, connection2.GetMetadataWorkspace().GetItemCollection(DataSpace.SSpace));
                Assert.Same(weakReferences[2].Target, connection2.GetMetadataWorkspace().GetItemCollection(DataSpace.CSSpace));
            }
        }

    public bool PosTest1()
    {
        bool retVal = true;

        TestLibrary.TestFramework.BeginScenario("PosTest1: Call Ctor with valid target reference and set trackResurrection to false");

        try
        {
            Object obj = new Object();
            WeakReference reference = new WeakReference(obj, false);

            if ((reference.TrackResurrection != false) || (!reference.Target.Equals(obj)) )
            {
                TestLibrary.TestFramework.LogError("001.1", "Calling Ctor with valid target reference and set trackResurrection to false constructs wrong instance");
                TestLibrary.TestFramework.LogInformation("WARNING [LOCAL VARIABLES] reference.TrackResurrection = " + reference.TrackResurrection.ToString() +
                                                                                                                  ", reference.Target = " + reference.Target.ToString() +
                                                                                                                  ", obj = " + obj.ToString());
                retVal = false;
            }
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError("001.2", "Unexpected exception: " + e);
            TestLibrary.TestFramework.LogInformation(e.StackTrace);
            retVal = false;
        }

        return retVal;
    }

    // ATTENTION!!! ATTENTION!!! ATTENTION!!!
    //
    // If you encounter issues with object lifetime, please see more comments in WeakReferenceCtor2.cs

    public bool PosTest1()
    {
        bool retVal = true;
        TestFramework.BeginScenario("Test IsAlive with short WeakReference");

        try
        {
            WeakReference extWR = new WeakReference(WRHelper.CreateAnObject("Test"), false);

            if (!extWR.IsAlive)
            {
                TestFramework.LogError("001", "WeakReference IsAlive not as expected. Expected : True; Actual: " + extWR.IsAlive);
                retVal = false;
            }

            GC.Collect();
            GC.WaitForPendingFinalizers();

            //Dev10 Bug #413556: WeakReference object incorrectly kept alive. Enable after the test is fixed.
            //
            //if (extWR.IsAlive)
            //{
            //    TestFramework.LogError("002", "WeakReference IsAlive not as expected. Expected : False; Actual: " + extWR.IsAlive);
            //    retVal = false;
            //}
        }
        catch (Exception e)
        {
            TestFramework.LogError("003", "Unexpected exception occured: " + e);
            retVal = false;
        }

        return retVal;
    }

 /// <summary>
 /// Initializes a new instance of the <see cref="DependencyObserver"/> class.
 /// </summary>
 /// <param name="messageHandler">The message handler.</param>
 /// <param name="methodFactory">The method factory.</param>
 /// <param name="notifier">The notifier.</param>
 public DependencyObserver(IRoutedMessageHandler messageHandler, IMethodFactory methodFactory, INotifyPropertyChanged notifier)
 {
     _messageHandler = messageHandler;
     _methodFactory = methodFactory;
     _weakNotifier = new WeakReference<INotifyPropertyChanged>(notifier);
     _monitoringInfos = new Dictionary<string, MonitoringInfo>();
 }

    public bool GetTargetTest()
    {
        int[] array = new int[50];
        Object[] obj = new Object[25];

        WeakReference weakarray = new WeakReference(array); // array has only weak reference

        // obj has both strong and weak ref and so should not get collected

        WeakReference weakobj = new WeakReference(obj);
        GCHandle objhandle = GCHandle.Alloc(obj, GCHandleType.Normal);

        // ensuring GC.Collect() occurs even with /debug option
        array = null;
        obj = null;

        GC.Collect();

        Object target1 = weakarray.Target; // should be null
        Object target2 = weakobj.Target;   // should be System.Object[]

        Console.WriteLine("{0},{1}", target1, target2);

        if ((target1 == null) && (target2 != null))
        {
            Console.WriteLine("Test for WeakReference.get_Target passed!");
            return true;
        }
        else
        {
            Console.WriteLine("Test for WeakReference.get_Target failed!");
            return false;
        }
    }

 public static bool VerifyObject(WeakReference wr, string s)
 {
     if (((myClass)wr.Target).myString != s)
         return false;
     else
         return true;
 }

    public bool GetTargetTest()
    {
        CreateArrays();
        WeakReference weakarray = new WeakReference(array); // array has only weak reference

        // obj has both strong and weak ref and so should not get collected

        WeakReference weakobj = new WeakReference(obj);
        GCHandle objhandle = GCHandle.Alloc(obj, GCHandleType.Normal);
        
        DestroyArrays();
        GC.Collect();

        Object target1 = weakarray.Target; // should be null
        Object target2 = weakobj.Target;   // should be System.Object[]

        Console.WriteLine("{0},{1}", target1, target2);

        if ((target1 == null) && (target2 != null))
        {
            Console.WriteLine("Test for WeakReference.get_Target passed!");
            return true;
        }
        else
        {
            Console.WriteLine("Test for WeakReference.get_Target failed!");
            return false;
        }
    }

        /// <summary>
        /// Initializes a new instance of the <see cref="ActionMessageHandler"/> class.
        /// </summary>
        /// <param name="host">The host.</param>
        /// <param name="target">The target.</param>
        public ActionMessageHandler(IActionHost host, object target)
        {
            _weakTarget = new WeakReference<object>(target);
            _host = host;

            _host.SelectMany(x => x.Filters.HandlerAware)
                .Union(_host.Filters.HandlerAware)
                .Apply(x => x.MakeAwareOf(this));
        }

	static void SetupLinks () {
		var a = new Bridge () { id = "bridge" };
		var b = new Bridge () { id = "child" };
		a.link.Add (b);
		a.__test = 1;
		b.__test = 0;
		root = new WeakReference<Bridge> (a, true);
		child = new WeakReference<Bridge> (b, true);
	}

 public void doWork()
 {
     ServiceProvider service;
     if((provider == null) || !provider.TryGetTarget(out service)){
         service = new ServiceProvider();
         provider = new WeakReference<ServiceProvider>(service); // !!!!! podem evitar instanciar uma nova WeakReference fazendo o SetTarget(T)
     }
     service.doWork();
 }

	static void Swap(ref WeakReference refNmsp, object o)
	{
		WeakReference wref = refNmsp;
		if (wref != null)
		{
			Console.WriteLine ("Need this to make it pass");
		}
		Interlocked.CompareExchange<WeakReference>(ref refNmsp, new WeakReference(o), wref);
	}

        internal ObjectViewListener(IObjectView view, IList list, object dataSource)
        {
            _viewWeak = new WeakReference(view);
            _dataSource = dataSource;
            _list = list;

            RegisterCollectionEvents();
            RegisterEntityEvents();
        }

    public DebugComponent(Game game)
        : base(game)
    {
        // Load up our content manager
        content = new ContentManager(game.Services);

        // Create the very first weak ref instance for GC checking.
        // This will be dealt with in Update() from now on.
        this.weakReference = new WeakReference(new object());
    }

    float _nPropValueStart; // Value of our CProp at start of 'quick mouse edit'

    #endregion Fields

    #region Constructors

    public CKeyHook(CProp oProp, KeyCode oKeyCode, EKeyHookType eKeyHookType, string sDescription, float nRatio=1.0f, bool bSelectedBodyOnly = true)
    {
        _oProp			= oProp;
        _oKeyCode		= oKeyCode;
        _eKeyHookType	= eKeyHookType;
        _sDescription	= sDescription;
        _nRatio			= nRatio;
        _bSelectedBodyOnly = bSelectedBodyOnly;
        _oWeakRef		= new WeakReference(this, false);
        CGame.INSTANCE._aKeyHooks.Add(_oWeakRef);		//###NOTE: Add a weak reference to CGame so that it can automatically remove dead objects as the owner of this CKeyHook destroys us.
    }

	static void SetupLinks () {
		var r = new Toggleref () { id = "root" };
		var c = new Toggleref () { id = "child" };
		r.link.Add (c);
		r.__test = Toggleref.STRONG;
		c.__test = Toggleref.WEAK;
		Register (r);
		Register (c);
		root = new WeakReference<Toggleref> (r, false);
		child = new WeakReference<Toggleref> (c, false);
	}

	static void SetupLinks () {
		var a = new Toggleref () { id = "root" };
		var b = new Toggleref () { id = "child" };
		a.link.Add (b);
		a.__test = Toggleref.STRONG;
		b.__test = Toggleref.WEAK;
		Register (a);
		Register (b);
		root = new WeakReference<Toggleref> (a, false);
		child = new WeakReference<Toggleref> (b, false);
	}

	static int Main ()
	{
		WeakReference wr = new WeakReference (new MainForm ());
		Application.Run ((Form) wr.Target);

		GC.Collect ();
		System.Threading.Thread.Sleep (200);
		GC.Collect ();

		return wr.IsAlive ? 1 : 0;
	}

        static UnpackedObjectCache()
        {
            Dead = new WeakReference<Entry>(null);
            _maxByteCount = new WindowCacheConfig().DeltaBaseCacheLimit;

            Cache = new Slot[CacheSize];
            for (int i = 0; i < CacheSize; i++)
            {
                Cache[i] = new Slot();
            }
        }