def test_getweakrefcount(self):
        o = C()
        
        def runTest():
            ref1 = weakref.ref(o)
            ref2 = weakref.ref(o, self.callback)
            self.assertTrue(weakref.getweakrefcount(o) == 2,
                         "got wrong number of weak reference objects")

            proxy1 = weakref.proxy(o)
            proxy2 = weakref.proxy(o, self.callback)
            self.assertTrue(weakref.getweakrefcount(o) == 4,
                         "got wrong number of weak reference objects")

            del ref1, ref2, proxy1, proxy2

        runTest()
        test_support.force_gc_collect()
        self.assertTrue(weakref.getweakrefcount(o) == 0,
                     "weak reference objects not unlinked from"
                     " referent when discarded.")

        # assumes ints do not support weakrefs
        self.assertTrue(weakref.getweakrefcount(1) == 0,
                     "got wrong number of weak reference objects for int")

    def test_getweakrefcount(self):
        o = C()
        ref1 = weakref.ref(o)
        ref2 = weakref.ref(o, self.callback)
        self.assert_(weakref.getweakrefcount(o) == 2,
                     "got wrong number of weak reference objects")

        proxy1 = weakref.proxy(o)
        proxy2 = weakref.proxy(o, self.callback)
        self.assert_(weakref.getweakrefcount(o) == 4,
                     "got wrong number of weak reference objects")

        def runTest():
            ref1 = weakref.ref(o)
            ref2 = weakref.ref(o, self.callback)
            self.assertTrue(weakref.getweakrefcount(o) == 2,
                         "got wrong number of weak reference objects")

            proxy1 = weakref.proxy(o)
            proxy2 = weakref.proxy(o, self.callback)
            self.assertTrue(weakref.getweakrefcount(o) == 4,
                         "got wrong number of weak reference objects")

            del ref1, ref2, proxy1, proxy2

 def test_weak_keys(self):
     #
     #  This exercises d.copy(), d.items(), d[] = v, d[], del d[],
     #  len(d), d.has_key().
     #
     import gc
     dict, objects = self.make_weak_keyed_dict()
     for o in objects:
         self.assert_(weakref.getweakrefcount(o) == 1,
                      "wrong number of weak references to %r!" % o)
         self.assert_(o.arg is dict[o],
                      "wrong object returned by weak dict!")
     items1 = dict.items()
     items2 = dict.copy().items()
     self.assert_(set(items1) == set(items2),
                  "cloning of weak-keyed dictionary did not work!")
     del items1, items2
     test_support.gc_collect()
     self.assert_(len(dict) == self.COUNT)
     del objects[0]
     test_support.gc_collect()
     self.assert_(len(dict) == (self.COUNT - 1),
                  "deleting object did not cause dictionary update")
     del objects, o
     test_support.gc_collect()
     self.assert_(len(dict) == 0,
                  "deleting the keys did not clear the dictionary")
     o = Object(42)
     dict[o] = "What is the meaning of the universe?"
     self.assert_(dict.has_key(o))
     self.assert_(not dict.has_key(34))

    def test_ref_reuse(self):
        def runTest():
            o = C()
            ref1 = weakref.ref(o)
            # create a proxy to make sure that there's an intervening creation
            # between these two; it should make no difference
            proxy = weakref.proxy(o)
            ref2 = weakref.ref(o)
            self.assertTrue(ref1 is ref2,
                         "reference object w/out callback should be re-used")

            o = C()
            proxy = weakref.proxy(o)
            ref1 = weakref.ref(o)
            ref2 = weakref.ref(o)
            self.assertTrue(ref1 is ref2,
                         "reference object w/out callback should be re-used")
            self.assertTrue(weakref.getweakrefcount(o) == 2,
                         "wrong weak ref count for object")
            del proxy
            return o, ref1

        o, ref1 = runTest()
        test_support.force_gc_collect()
        self.assertTrue(weakref.getweakrefcount(o) == 1,
                     "wrong weak ref count for object after deleting proxy")

 def test_weak_keys(self):
     #
     #  This exercises d.copy(), d.items(), d[] = v, d[], del d[],
     #  len(d), in d.
     #
     dict, objects = self.make_weak_keyed_dict()
     for o in objects:
         if not test_support.is_jython:  # Such dictionaries now use MapMaker
             self.assertTrue(weakref.getweakrefcount(o) == 1,
                             "wrong number of weak references to %r!" % o)
         self.assertTrue(o.arg is dict[o],
                      "wrong object returned by weak dict!")
     items1 = dict.items()
     items2 = dict.copy().items()
     self.assertTrue(set(items1) == set(items2),
                  "cloning of weak-keyed dictionary did not work!")
     del items1, items2
     self.assertEqual(len(list(dict.iterkeys())), self.COUNT)
     del objects[0]
     gc.collect()
     self.assertEqual(len(list(dict.iterkeys())), self.COUNT - 1,
                  "deleting object did not cause dictionary update")
     del objects, o
     gc.collect()
     self.assertEqual(len(list(dict.iterkeys())), 0,
                  "deleting the keys did not clear the dictionary")
     o = Object(42)
     dict[o] = "What is the meaning of the universe?"
     self.assertIn(o, dict)
     self.assertNotIn(34, dict)

 def test_weak_values(self):
     #
     #  This exercises d.copy(), d.items(), d[], del d[], len(d).
     #
     dict, objects = self.make_weak_valued_dict()
     for o in objects:
         self.assertEqual(weakref.getweakrefcount(o), 1)
         self.assertTrue(o is dict[o.arg],
                      "wrong object returned by weak dict!")
     items1 = list(dict.items())
     items2 = list(dict.copy().items())
     items1.sort()
     items2.sort()
     self.assertEqual(items1, items2,
                  "cloning of weak-valued dictionary did not work!")
     del items1, items2
     self.assertEqual(len(dict), self.COUNT)
     del objects[0]
     gc_collect()
     self.assertEqual(len(dict), self.COUNT - 1,
                  "deleting object did not cause dictionary update")
     del objects, o
     gc_collect()
     self.assertEqual(len(dict), 0,
                  "deleting the values did not clear the dictionary")
     # regression on SF bug #447152:
     dict = weakref.WeakValueDictionary()
     self.assertRaises(KeyError, dict.__getitem__, 1)
     dict[2] = C()
     gc_collect()
     self.assertRaises(KeyError, dict.__getitem__, 2)

 def test_weak_values(self):
     #
     #  This exercises d.copy(), d.items(), d[], del d[], len(d).
     #
     dict, objects = self.make_weak_valued_dict()
     for o in objects:
         if not test_support.is_jython:  # Such dictionaries now use MapMaker
             self.assertTrue(weakref.getweakrefcount(o) == 1,
                             "wrong number of weak references to %r!" % o)
         self.assertTrue(o is dict[o.arg],
                      "wrong object returned by weak dict!")
     items1 = dict.items()
     items2 = dict.copy().items()
     items1.sort()
     items2.sort()
     self.assertTrue(items1 == items2,
                  "cloning of weak-valued dictionary did not work!")
     del items1, items2
     self.assertTrue(len(dict) == self.COUNT)
     del objects[0]
     gc.collect()
     # underlying Map.size is guaranteed only to be eventually consistent for MapMaker
     self.assertEqual(len(list(dict.iterkeys())), self.COUNT - 1,
                  "deleting object did not cause dictionary update")
     del objects, o
     gc.collect()
     self.assertEqual(len(list(dict.iterkeys())), 0,
                  "deleting the values did not clear the dictionary")
     # regression on SF bug #447152:
     dict = weakref.WeakValueDictionary()
     self.assertRaises(KeyError, dict.__getitem__, 1)
     dict[2] = C()
     gc.collect()
     self.assertRaises(KeyError, dict.__getitem__, 2)

 def test_weak_keys(self):
     #
     #  This exercises d.copy(), d.items(), d[] = v, d[], del d[],
     #  len(d), in d.
     #
     dict, objects = self.make_weak_keyed_dict()
     for o in objects:
         self.assertEqual(weakref.getweakrefcount(o), 1,
                      "wrong number of weak references to %r!" % o)
         self.assertIs(o.arg, dict[o],
                      "wrong object returned by weak dict!")
     items1 = dict.items()
     items2 = dict.copy().items()
     self.assertEqual(set(items1), set(items2),
                  "cloning of weak-keyed dictionary did not work!")
     del items1, items2
     self.assertEqual(len(dict), self.COUNT)
     del objects[0]
     self.assertEqual(len(dict), (self.COUNT - 1),
                  "deleting object did not cause dictionary update")
     del objects, o
     self.assertEqual(len(dict), 0,
                  "deleting the keys did not clear the dictionary")
     o = Object(42)
     dict[o] = "What is the meaning of the universe?"
     self.assertIn(o, dict)
     self.assertNotIn(34, dict)

    def test_weak_keys(self):
        dict = weakref.WeakKeyDictionary()
        objects = map(Object, range(self.COUNT))
        for o in objects:
            dict[o] = o.arg

        for o in objects:
            self.assert_(weakref.getweakrefcount(o) == 1,
                         "wrong number of weak references to %r!" % o)
            self.assert_(o.arg is dict[o],
                         "wrong object returned by weak dict!")
        items1 = dict.items()
        items2 = dict.copy().items()
        items1.sort()
        items2.sort()
        self.assert_(items1 == items2,
                     "cloning of weak-keyed dictionary did not work!")
        del items1, items2
        self.assert_(len(dict) == self.COUNT)
        del objects[0]
        self.assert_(len(dict) == (self.COUNT - 1),
                     "deleting object did not cause dictionary update")
        del objects, o
        self.assert_(len(dict) == 0,
                     "deleting the keys did not clear the dictionary")

    def get(self):
        # clean if need
        if self._clean_counter >= self._clean_interval:
           self._clean()

        self._clean_counter += 1

        # do grant
        if self.idle > 0:
            for conn in self.busy_array:
                if weakref.getweakrefcount(conn) > 0:
                    continue

                conn = weakref.proxy(conn)
                if not conn.ping():
                    conn.connect()
                elif not conn.reusable:
                    conn.make_reusable()

                plog("get: conn(%d) [idle/total/max: %d/%d/%d]" % (id(conn), self.idle, self.total, self._max))
                return conn

        elif self.total < self._max:
            conn = self._conn_cls(**self._db_config)
            self._pool.append(conn)

            conn = weakref.proxy(conn)
            conn.connect()

            # dig the pool

            plog("new: conn(%d) [idle/total/max: %d/%d/%d]" % (id(conn), self.idle, self.total, self._max))
            return conn

        return None

 def test_subclass_refs_dont_replace_standard_refs(self):
     class MyRef(weakref.ref):
         pass
     o = Object(42)
     r1 = MyRef(o)
     r2 = weakref.ref(o)
     self.assert_(r1 is not r2)
     self.assertEqual(weakref.getweakrefs(o), [r2, r1])
     self.assertEqual(weakref.getweakrefcount(o), 2)
     r3 = MyRef(o)
     self.assertEqual(weakref.getweakrefcount(o), 3)
     refs = weakref.getweakrefs(o)
     self.assertEqual(len(refs), 3)
     self.assert_(r2 is refs[0])
     self.assert_(r1 in refs[1:])
     self.assert_(r3 in refs[1:])

 def test_weak_values(self):
     #
     #  This exercises d.copy(), d.items(), d[], del d[], len(d).
     #
     import gc
     dict, objects = self.make_weak_valued_dict()
     for o in objects:
         self.assert_(weakref.getweakrefcount(o) == 1,
                      "wrong number of weak references to %r!" % o)
         self.assert_(o is dict[o.arg],
                      "wrong object returned by weak dict!")
     items1 = dict.items()
     items2 = dict.copy().items()
     items1.sort()
     items2.sort()
     self.assert_(items1 == items2,
                  "cloning of weak-valued dictionary did not work!")
     del items1, items2
     test_support.gc_collect()
     self.assert_(len(dict) == self.COUNT)
     del objects[0]
     test_support.gc_collect()
     self.assert_(len(dict) == (self.COUNT - 1),
                  "deleting object did not cause dictionary update")
     del objects, o
     test_support.gc_collect()
     self.assert_(len(dict) == 0,
                  "deleting the values did not clear the dictionary")
     # regression on SF bug #447152:
     dict = weakref.WeakValueDictionary()
     self.assertRaises(KeyError, dict.__getitem__, 1)
     dict[2] = C()
     test_support.gc_collect()
     self.assertRaises(KeyError, dict.__getitem__, 2)

    def test_getweakrefcount(self):
        o = C()
        ref1 = weakref.ref(o)
        ref2 = weakref.ref(o, self.callback)
        self.assertEqual(weakref.getweakrefcount(o), 2, "got wrong number of weak reference objects")

        proxy1 = weakref.proxy(o)
        proxy2 = weakref.proxy(o, self.callback)
        self.assertEqual(weakref.getweakrefcount(o), 4, "got wrong number of weak reference objects")

        del ref1, ref2, proxy1, proxy2
        self.assertEqual(
            weakref.getweakrefcount(o), 0, "weak reference objects not unlinked from" " referent when discarded."
        )

        # assumes ints do not support weakrefs
        self.assertEqual(weakref.getweakrefcount(1), 0, "got wrong number of weak reference objects for int")

    def test_ref_reuse(self):
        o = C()
        ref1 = weakref.ref(o)
        # create a proxy to make sure that there's an intervening creation
        # between these two; it should make no difference
        proxy = weakref.proxy(o)
        ref2 = weakref.ref(o)
        self.assert_(ref1 is ref2, "reference object w/out callback should be re-used")

        o = C()
        proxy = weakref.proxy(o)
        ref1 = weakref.ref(o)
        ref2 = weakref.ref(o)
        self.assert_(ref1 is ref2, "reference object w/out callback should be re-used")
        self.assert_(weakref.getweakrefcount(o) == 2, "wrong weak ref count for object")
        del proxy
        self.assert_(weakref.getweakrefcount(o) == 1, "wrong weak ref count for object after deleting proxy")

    def test_ipy2_gh437(self):
        """https://github.com/IronLanguages/ironpython2/issues/437"""
        import weakref
        class SomeWeakReferenceableObject(object): pass

        o = SomeWeakReferenceableObject()
        x = [weakref.ref(o) for i in range(10)]
        self.assertEqual(weakref.getweakrefcount(o), 1)

    def _pop_idle(self):
        for conn in self.busy_array:
            if weakref.getweakrefcount(conn) > 0:
                continue

            return id(conn), weakref.proxy(conn)

        return None, None

 def test5(self):
     a=arange(20,dtype=int32)
     self.assertEqual(weakref.getweakrefcount(a),0)
     d=DataArrayInt(a)
     self.assertEqual(weakref.getweakrefcount(a),1)
     self.assertTrue(not a.flags["OWNDATA"])
     self.assertTrue(d.isIdentity())
     self.assertEqual(len(d),20)
     a[:]=2 # modifying a and d because a and d share the same chunk of data
     self.assertTrue(d.isUniform(2))
     del d # d is destroyed, a retrieves its ownership of its initial chunk of data
     ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called 
     import gc
     gc.collect()
     self.assertTrue(a.flags["OWNDATA"])
     a[:]=4 # a can be used has usual
     self.assertTrue(DataArrayInt(a).isUniform(4))
     pass

 def test13(self):
     a=arange(20,dtype=float64)
     self.assertEqual(weakref.getweakrefcount(a),0)
     d=DataArrayDouble(a)
     self.assertEqual(weakref.getweakrefcount(a),1)
     self.assertTrue(not a.flags["OWNDATA"])
     self.assertTrue(d.isEqual(DataArrayDouble([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]),1e-14))
     self.assertEqual(len(d),20)
     a[:]=2 # modifying a and d because a and d share the same chunk of data
     self.assertTrue(d.isUniform(2,1e-14))
     del d # d is destroyed, a retrieves its ownership of its initial chunk of data
     ##@@ Ensure a pass of the garbage collector so that the de-allocator of d is called
     import gc
     gc.collect()
     self.assertTrue(a.flags["OWNDATA"])
     a[:]=4 # a can be used has usual
     self.assertTrue(DataArrayDouble(a).isUniform(4,1e-14))
     pass

 def test_subclass_refs_dont_replace_standard_refs(self):
     class MyRef(weakref.ref):
         pass
     o = Object(42)
     r1 = MyRef(o)
     r2 = weakref.ref(o)
     self.assertTrue(r1 is not r2)
     self.assertEqual(weakref.getweakrefs(o), [r2, r1])
     self.assertEqual(weakref.getweakrefcount(o), 2)
     r3 = MyRef(o)
     self.assertEqual(weakref.getweakrefcount(o), 3)
     refs = weakref.getweakrefs(o)
     self.assertEqual(len(refs), 3)
     assert set(refs) == set((r1, r2, r3))
     if test_support.check_impl_detail():
         self.assertTrue(r2 is refs[0])
         self.assertIn(r1, refs[1:])
         self.assertIn(r3, refs[1:])