def test_weakref(create_weakref, create_weakref_with_callback): from weakref import getweakrefcount # Apparently, you cannot weakly reference an object() class WeaklyReferenced(object): pass def callback(wr): # No `nonlocal` in Python 2 callback.called = True obj = WeaklyReferenced() assert getweakrefcount(obj) == 0 wr = create_weakref(obj) assert getweakrefcount(obj) == 1 obj = WeaklyReferenced() assert getweakrefcount(obj) == 0 callback.called = False wr = create_weakref_with_callback(obj, callback) # noqa: F841 assert getweakrefcount(obj) == 1 assert not callback.called del obj pytest.gc_collect() assert callback.called
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") del ref1, ref2, proxy1, proxy2 gc.collect() self.assert_( weakref.getweakrefcount(o) == 0, "weak reference objects not unlinked from" " referent when discarded.") # assumes ints do not support weakrefs self.assert_( 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_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), k in d. # dict, objects = self.make_weak_keyed_dict() for o in objects: 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.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.assertTrue(len(dict) == (self.COUNT - 1), "deleting object did not cause dictionary update") del objects, o self.assertTrue(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_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 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 = list(dict.items()) items2 = list(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.keys())), self.COUNT - 1, "deleting object did not cause dictionary update") del objects, o gc.collect() self.assertEqual(len(list(dict.keys())), 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 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_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_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.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 self.assert_(len(dict) == self.COUNT) del objects[0] extra_collect() self.assert_( len(dict) == (self.COUNT - 1), "deleting object did not cause dictionary update") del objects, o extra_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() extra_collect() self.assertRaises(KeyError, dict.__getitem__, 2)
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) self.assertTrue(r2 is refs[0]) self.assertIn(r1, refs[1:]) self.assertIn(r3, refs[1:])
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] self.assertEqual(len(dict), self.COUNT - 1, "deleting object did not cause dictionary update") del objects, o 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() self.assertRaises(KeyError, dict.__getitem__, 2)
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_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_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 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_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), 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_comparable_garbage_collection(cache): a = Node(name="a") b = Node(name="b") c = Node(name="c") d = Node(name="d") cache[pair(a, b)] = True cache[pair(a, c)] = False cache[pair(c, d)] = True cache[pair(b, d)] = False assert weakref.getweakrefcount(a) == 2 del c assert weakref.getweakrefcount(a) == 1 del b assert weakref.getweakrefcount(a) == 0
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_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_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 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.isIota(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 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 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_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.' ) self.assertEqual(weakref.getweakrefcount(1), 0, 'got wrong number of weak reference objects for int')
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 test_weakref_session(self): ssh_session = self.app.ssh_session ssh_session.command('ls') self.assertEqual( 1, weakref.getweakrefcount( self.app.session_manager.sessions['ssh_session']))
def test_subclass_refs_dont_replace_standard_refs(self): if test_support.due_to_ironpython_bug("http://www.codeplex.com/IronPython/WorkItem/View.aspx?WorkItemId=21116"): return 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) self.assertTrue(r2 is refs[0]) self.assertIn(r1, refs[1:]) self.assertIn(r3, refs[1:])
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:])
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 show_weakref(): d = {'color': 'blue', 'value': 512, 'weight': 64} wd = WeakrefDict({'color': 'red', 'value': 255, 'weight': 128}) nwc = NotWeakableClass(12345) print(d, sys.getrefcount(d)) print(wd, weakref.getweakrefcount(wd)) try: dref = weakref.ref(d) except Exception as e: print('create weakref error:', e) else: print(dref, dref(), weakref.getweakrefcount(dref())) try: nwcref = weakref.ref(nwc) except Exception as e: print('create weakref error:', e) else: print(nwcref, nwcref(), weakref.getweakrefcount(nwcref())) try: NotWC = weakref.ref(NotWeakableClass) except Exception as e: print('create weakref error:', e) else: print(NotWC, NotWC(), weakref.getweakrefcount(NotWC())) wdref = weakref.ref(wd) print(wdref, wdref(), weakref.getweakrefcount(wdref())) del wd print(wdref()) # weakref value dictionary wvd = weakref.WeakValueDictionary() x = WeakrefDict({'width': 1366, 'height': 768}) print(wvd, x) xid = id(x) wvd[xid] = x print(wvd[xid]) # weakref key dictionary wkd = weakref.WeakKeyDictionary() wkd[nwc] = xid del xid print(wkd[nwc]) del nwc print([v for v in wkd.values()])
def test_weakref_works_on_coord(self): coord = plyparser.Coord(file='a', line=2, column=10, end_line=3, end_column=11) wr = weakref.ref(coord) cref = wr() self.assertEqual(cref.line, 2) self.assertEqual(cref.column, 10) self.assertEqual(cref.end_line, 3) self.assertEqual(cref.end_column, 11) self.assertEqual(weakref.getweakrefcount(coord), 1)
def test_ref_reuse(self): o = C() ref1 = weakref.ref(o) proxy = weakref.proxy(o) ref2 = weakref.ref(o) self.assertIs(ref1, 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.assertIs(ref1, ref2, 'reference object w/out callback should be re-used') self.assertEqual(weakref.getweakrefcount(o), 2, 'wrong weak ref count for object') del proxy self.assertEqual( weakref.getweakrefcount(o), 1, 'wrong weak ref count for object after deleting proxy')
def test_defaultInstance(self): # create an instance so we can test the rest of the interfaces inst = Entity() # Note by default no parameters are possible # not implemented by default, results in a type error by design self.assertRaises(TypeError, inst.serialize) self.assertEquals(str(inst), 'Entity()') self.assertListEqual(list(Entity.objects), [inst]) self.assertEqual(weakref.getweakrefcount(inst), 1) self.assertEqual(Entity.isValid(inst), True) Entity.delete(inst) #you must reap the instance yourself self.assertEqual(Entity.isValid(inst), False)
def show(s = ''): print(s) print('global dict', dict(d)) for ref in d.keyrefs(): k = ref() if k is None: continue count = weakref.getweakrefcount(k) print('weakref count', k, count, ref) print('weakref list', weakref.getweakrefs(k)) print('ref count', k, sys.getrefcount(k)) # == 4?????????? print('\n'*2)
def testWekRefs(self): sysobj = npython.sel('/sys') try: ref = weakref.ref(sysobj) except: assert 1 == 0, "Can't create weakref" weakrefscount = weakref.getweakrefcount(sysobj) assert weakrefscount, "Something strange with weak refs" try: ref().getcmds() except: assert 1 == 0, "Can't access weakrefed object"
def test_weakref(): """Weak references allow Platforms to be del'd while Scenarios live.""" mp = ixmp.Platform( backend='jdbc', driver='hsqldb', url='jdbc:hsqldb:mem:test_weakref', ) # There is one reference to the Platform, and zero weak references assert getrefcount(mp) - 1 == 1 assert getweakrefcount(mp) == 0 # Create a single Scenario s = ixmp.Scenario(mp, 'foo', 'bar', version='new') # Still one reference to the Platform assert getrefcount(mp) - 1 == 1 # …but additionally one weak reference assert getweakrefcount(mp) == 1 # Make a local reference to the backend backend = mp._backend # Delete the Platform. Note that this only has an effect if there are no # existing references to it del mp # s.platform is a dead weak reference, so it can't be accessed with pytest.raises(ReferenceError): s.platform._backend # There is only one remaining reference to the backend: the *backend* name # in the local scope assert getrefcount(backend) - 1 == 1 # The backend is garbage-collected at this point # The Scenario object still lives, but can't be used for anything assert s.model == 'foo'
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 runTest(): dict, objects = self.make_weak_keyed_dict() for o in objects: 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() del o self.assertTrue(set(items1) == set(items2), "cloning of weak-keyed dictionary did not work!") del items1, items2 self.assertTrue(len(dict) == self.COUNT) del objects[0] return dict, objects
def main3(): a = OBJ() b = weakref.proxy(a) print(a, b, type(a), type(b)) print(sys.getrefcount(a)) print(sys.getrefcount(b)) print(weakref.getweakrefs(a), weakref.getweakrefcount(a)) print(b is a) # False del a # print(b) # ReferenceError: weakly-referenced object no longer exists a = OBJ() c = weakref.ref(a) _c = c() print(c) print(_c is a) del a, _c print(c)
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.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!") if test_support.due_to_ironpython_incompatibility(): del o 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 test_support.force_gc_collect() self.assertTrue(len(dict) == self.COUNT) del objects[0] if test_support.due_to_ironpython_incompatibility(): gc.collect() del objects else: self.assertTrue( len(dict) == (self.COUNT - 1), "deleting object did not cause dictionary update") del objects, o test_support.force_gc_collect() if not test_support.due_to_ironpython_incompatibility(): # we currently fail because of some garbage alive on the stack self.assertTrue( 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() self.assertRaises(KeyError, dict.__getitem__, 2)
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
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.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!") if test_support.due_to_ironpython_incompatibility(): del o 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 test_support.force_gc_collect() self.assertTrue(len(dict) == self.COUNT) del objects[0] if test_support.due_to_ironpython_incompatibility(): gc.collect() del objects else: self.assertTrue(len(dict) == (self.COUNT - 1), "deleting object did not cause dictionary update") del objects, o test_support.force_gc_collect() if not test_support.due_to_ironpython_incompatibility(): # we currently fail because of some garbage alive on the stack self.assertTrue(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() self.assertRaises(KeyError, dict.__getitem__, 2)
def testWeakRefTester2(): # create a weakRefTester2 object called newList newList = weakRefTester2('WeakRefTester') print("New List Object:", newList) # create a weak reference to newList weakRef = weakref.ref(newList, refCallback) # get a reference to the list referenced by the weak reference newWeakList = weakRef() # create a proxy to newList which uses a weak reference newProxy = weakref.proxy(newList, proxyCallBack) print("Weak reference to New List Object:", newWeakList) print('The object using a proxy: ' + str(newProxy)) if newList is newWeakList: print("Original NewList is now a weak reference") print('The Weak reference count is: ' + str(weakref.getweakrefcount(newList))) del newList, newWeakList print("The weak reference is: " + str(weakRef()))
def to_yml_item(item, pp, name): global scalar refcount = weakref.getweakrefcount(item) if refcount > 0: name += " &" + str(id(item)) if type(item).__name__ in scalar: tag = fmt.end( '\n', fmt.sep( "", [ name, " ", yml_attr( type(item).__name__, repr(item) ) ] ) ) pp.append(tag) return if isinstance(item, weakref.ref): name += " *" + str(id(item())) tag = fmt.end('\n', fmt.sep("", [name, " ", repr(item)])) pp.append(tag) return if isinstance(item, bytes) or isinstance(item, bytearray): inner = fmt.tab([]) tag = fmt.block(name + " " + str(yml_attr('type', 'bytes')) + ':\n', '----' + name + '----\n', inner) inner.lsdata.append(fmt.sep(" ", [])) bindata = inner.lsdata[-1].lsdata i = 0 for b in item: bindata.append("%02X" % b) i += 1 if i > 16: bindata.append("\n") i = 0 bindata.append("\n") pp.append(tag) return if isinstance(item, object) and hasattr(item, '__dict__'): inner = fmt.tab([]) tag = fmt.block(name + " " + str(yml_attr('type', item.__class__.__name__)) + ':\n', '', inner) for attr in sorted(vars(item)): to_yml_item(getattr(item, attr), inner.lsdata, attr) if len(vars(item)) == 0: inner.lsdata.append("\n") pp.append(tag) return if isinstance(item, list): inner = fmt.tab([]) tag = fmt.block( name + " " + str(yml_attr('type', 'list')) + ':\n', '', inner ) i = 0 for subitem in item: idxname = str(fmt.sep(" ", ['[', i, ']'])) to_yml_item(subitem, inner.lsdata, idxname) i += 1 if len(item) == 0: inner.lsdata.append("\n") pp.append(tag) return if isinstance(item, tuple): inner = fmt.tab([]) tag = fmt.block(name + " " + str(yml_attr('type', 'tuple')) + ':\n', '', inner) i = 0 for subitem in item: idxname = str(fmt.sep(" ", ["[", i, "]"])) to_yml_item(subitem, inner.lsdata, idxname) i += 1 if len(item) == 0: inner.lsdata.append("\n") pp.append(tag) return if isinstance(item, dict): inner = fmt.tab([]) tag = fmt.block(name + " " + str(yml_attr('type', 'dict')) + ':\n', '', inner) for k in sorted(item.keys()): idxname = str(fmt.sep(" ", ["[", repr(k), "]"])) to_yml_item(item[k], inner.lsdata, idxname) if len(item.keys()) == 0: inner.lsdata.append("\n") pp.append(tag) return if isinstance(item, set): inner = fmt.tab([]) tag = fmt.block(name + " " + str(yml_attr('type', 'set')) + ':\n', '', inner) for subitem in sorted(item): inner.lsdata.append(fmt.sep(", "[repr(subitem)])) if len(item) == 0: inner.lsdata.append("\n") pp.append(tag) return if item is None: tag = fmt.end('\n', [name]) pp.append(tag) return
def idle(self): counter = 0 for conn in self._pool: if weakref.getweakrefcount(conn) < 1: counter += 1 return counter