Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2026-03-21 15:45
📄 __init__.py # Dummy file to make this directory a package.	47 B	2026-01-20 12:58
📁 __pycache__	-	2026-03-21 15:45
📄 support.py """Supporting definitions for the Heapy regression test. Addapted from Python standard module test_support. """ import contextlib import unittest import pdb import sys import tracemalloc class Error(Exception): """Base class for regression test exceptions.""" class TestFailed(Error): """Test failed.""" class TestSkipped(Error): """Test skipped. This can be raised to indicate that a test was deliberatly skipped, but not because a feature wasn't available. For example, if some resource can't be used, such as the network appears to be unavailable, this should be raised instead of TestFailed. """ verbose = 1 # Flag set to 0 by regrtest.py use_resources = None # Flag set to [] by regrtest.py # ======================================================================= # Preliminary PyUNIT integration. class BasicTestRunner: def run(self, test): result = unittest.TestResult() test(result) return result def run_suite(suite, testclass=None): """Run tests from a unittest.TestSuite-derived class.""" if verbose: runner = unittest.TextTestRunner(sys.stdout, verbosity=2) else: runner = BasicTestRunner() result = runner.run(suite) if not result.wasSuccessful(): if len(result.errors) == 1 and not result.failures: err = result.errors[0][1] elif len(result.failures) == 1 and not result.errors: err = result.failures[0][1] else: if testclass is None: msg = "errors occurred; run in verbose mode for details" else: msg = "errors occurred in %s.%s" \ % (testclass.__module__, testclass.__name__) raise TestFailed(msg) raise TestFailed(err) def run_unittest(testclass, debug=0): """Run tests from a unittest.TestCase-derived class.""" suite = unittest.makeSuite(testclass) if debug: suite.debug() else: run_suite(suite, testclass) def debug_unittest(testclass): """ Debug tests from a unittest.TestCase-derived class.""" run_unittest(testclass, debug=1) # Base test case, tailored for heapy class TestCase(unittest.TestCase): def setUp(self): from guppy import Root self.python = Root() self.guppy = self.python.guppy self.heapy = self.guppy.heapy self.Part = self.heapy.Part self.ImpSet = self.heapy.ImpSet self.Use = self.heapy.Use self.View = self.heapy.View self.iso = self.Use.iso self.idset = self.Use.idset self.version_info = sys.version_info def aseq(self, a, b, cont=0): if a != b: print("aseq: Expected: b = ", b) print("Got actually : a = ", a) if cont <= 0: if cont < 0: pdb.set_trace() else: self.assertTrue(0) def asis(self, a, b, cont=0): if a is not b: print("asis: Expected: b = ", b) print("Got actually : a = ", a) if cont <= 0: if cont < 0: pdb.set_trace() else: self.assertTrue(0) def tearDown(self): pass @contextlib.contextmanager def tracemalloc_state(enabled=True): orig_enabled = tracemalloc.is_tracing() def set_enabled(new_enabled): cur_enabled = tracemalloc.is_tracing() if cur_enabled == new_enabled: return if new_enabled: tracemalloc.start() else: tracemalloc.stop() set_enabled(enabled) try: yield finally: set_enabled(orig_enabled)	3.72 KB	2026-01-20 12:58
📄 test_Classifiers.py from guppy.heapy.test import support import textwrap PORTABLE_TEST = 1 # Relax tests to be more portable class TestCase(support.TestCase): def setUp(self): support.TestCase.setUp(self) self.View.is_rg_update_all = False self.US = US = self.heapy.UniSet self.Use = Use = self.heapy.Use Use.reprefix = 'hp.' self.do = lambda x: x.dictof self.un = Use.Anything.fam self.ty = Use.Type self.rc = Use.Rcs self.iso = Use.iso self.Anything = US.Anything self.Nothing = US.Nothing class C1: def x(self): return 0 class C2: pass c1 = C1() self.C1 = C1 self.C2 = C2 self.c1 = c1 def lt(self, a, b): self.assertTrue(a < b) def eq(self, a, b): self.assertTrue(a == b) def dj(self, a, b): # disjoint; not related by <= or >=, and not overlapping self.assertTrue(not a <= b) self.assertTrue(not b <= a) self.assertTrue(not a & b) self.assertTrue(a.disjoint(b)) def nr(self, a, b): # not related by <= or >=, and overlapping self.assertTrue(not a <= b) self.assertTrue(not b <= a) self.assertTrue(a & b) self.assertTrue(not a.disjoint(b)) class SpecialCases(TestCase): # Special tests that catch cases that came up during development & debugging def test_1(self): un = self.un ty = self.ty do = self.do rc = self.rc iso = self.iso All = self.Anything Nothing = self.Nothing C1 = self.C1 C2 = self.C2 c1 = self.c1 def eq(a, b): self.assertTrue(a == b) self.assertTrue(str(a) == str(b)) e1 = [] e2 = {} e3 = [] e4 = () a = ty(int) b = ty(dict) self.assertTrue(~a & ~b != Nothing) eq(ty(list) & iso(e1, e2, e3), iso(e1, e3)) eq((ty(list) \| ty(dict)) & iso(e1, e2, e3, e4), iso(e1, e2, e3)) eq(iso(e1, e3) \| ty(list), ty(list)) eq(ty(list) \| iso(e1, e3), ty(list)) eq(iso(e1, e3) - iso(e3), iso(e1)) eq(~iso(e3) & iso(e1, e3), iso(e1)) eq(iso(e1, e2, e3) - ty(dict), iso(e1, e3)) eq(~ty(dict) & iso(e1, e2, e3), iso(e1, e3)) eq(ty(dict) \| iso(e1, e2), ty(dict) \| iso(e1)) eq(iso(e1, e2) \| ty(dict), ty(dict) \| iso(e1)) eq((ty(dict) \| ty(tuple)) \| iso(e1, e2), (ty(dict) \| ty(tuple)) \| iso(e1)) eq(iso(e1, e2) \| (ty(dict) \| ty(tuple)), (ty(dict) \| ty(tuple)) \| iso(e1)) eq(~ty(dict) \| iso(e1, e2), ~ty(dict) \| iso(e2)) eq(iso(e1, e2) \| ~ty(dict), ~ty(dict) \| iso(e2)) eq(ty(dict) - iso(e1, e2), ty(dict) - iso(e2)) eq(~iso(e1, e2) & ty(dict), ty(dict) - iso(e2)) eq(iso(e1, e3) ^ iso(e2), iso(e1, e2, e3)) eq(iso(e1, e3) ^ iso(e2, e3), iso(e1, e2)) eq(iso(e1, e3) ^ iso(e1, e3), Nothing) eq(iso(e1, e3) <= ty(list), True) eq(iso(e1, e2) <= ty(list) \| ty(dict), True) eq(ty(list) >= iso(e1, e3), True) eq(ty(list) \| ty(dict) >= iso(e1, e2), True) def test_2(self): un = self.un ty = self.ty do = self.do rc = self.rc iso = self.iso All = self.Anything Nothing = self.Nothing C1 = self.C1 C2 = self.C2 c1 = self.c1 class C3(object): def x(self): return 1 def asrt(x): self.assertTrue(x) def no(x): self.assertTrue(not x) eq = self.aseq # Tests to do with Nothing being finite - having length and iteration no(dict in (ty(dict) \| ty(int))) no([] in (ty(dict) \| ty(int))) asrt({} in (ty(dict) \| ty(int))) asrt(dict in (ty(dict) \| ty(int) \| ty(type(dict)))) asrt(list(ty(list) & iso({})) == []) # When creating ISO classes, we don't want to memoize them # which would leak the elements. from sys import getrefcount as grc import sys import types c = C1() rc = grc(c) x = iso(c) x = None eq(grc(c), rc) def test_dictowner(self): # Special test for dict ownership # motivated by: dicts that are not found in traversal, should not # cause repeated (unsuccessfull) updates of dict ownership # This is a performance question, requires special kind of testing # # Also tests that dict & dict owners are not leaked import gc from sys import getrefcount as grc Use = self.Use C1 = self.C1 c1 = self.c1 iso = self.iso o = self.python.io.StringIO() # Create a dict hidden from view d1 = self.View.immnodeset([{}]) d3 = {} # Remember the initial ref counts for target objects gc.collect() rcd1 = grc(list(d1)[0]) rcd3 = grc(d3) rcC1 = grc(C1) rcc1 = grc(c1) rcdc1 = grc(c1.__dict__) clock = self.python.time.process_time N = 5 M = 50 # This was the fast case, when only reachable dicts are classified for i in range(N): print(iso(d3).kind, file=o) print(iso(c1.__dict__).kind, file=o) # Now measure it while 1: gc.collect() t = clock() for i in range(M): iso(d3).kind iso(c1.__dict__).kind fast = clock()-t if fast >= 0.5: # Enough resolution? break else: M = 2 # No, try more loops # This was a slow case; involving repeated classification of a unreachable dict # It was originally 4.97 times slower when N was 5 # The problem occurs for successive classifications of different dicts, # when at least one of them is unreachable. gc.collect() for i in range(N): print(iso(d1).kind, file=o) print(iso(c1.__dict__).kind, file=o) gc.collect() # Now measure it t = clock() for i in range(M): iso(d1).kind iso(c1.__dict__).kind slow = clock()-t self.assertTrue(slow <= 1.5fast) # This is another slow case according to notes Nov 18 2004. # A succession of different unreachable dicts. gc.collect() dn = self.View.immnodeset([{} for i in range(N)]) for i in range(N): print(iso(list(dn)[i]).kind, file=o) # Now measure it gc.collect() dn = self.View.immnodeset([{} for i in range(M)]) t = clock() for i in range(M): iso(list(dn)[i]).kind slow = clock()-t # Sometimes M might be huge, and the vast majority of time it is not # doing the classification. # self.assertTrue(slow <= 1.5fast) # Partition was likewise slow for unreachable dicts dn = self.View.immnodeset([{} for i in range(N)]) gc.collect() print([x[0] for x in Use.Clodo.classifier.partition(dn)], file=o) # Now measure it dn = self.View.immnodeset([{} for i in range(M)]) gc.collect() t = clock() [x[0] for x in Use.Clodo.classifier.partition(dn)] slow = clock()-t self.assertTrue(slow <= 1.5fast) # Check that ref counts for target objects are the same as initially gc.collect() gc.collect() # Note May 17 2005 self.aseq(grc(list(d1)[0]), rcd1) self.aseq(grc(d3), rcd3) self.aseq(grc(c1), rcc1) self.aseq(grc(C1), rcC1) self.aseq(grc(c1.__dict__), rcdc1) self.aseq(o.getvalue(), """\ dict (no owner) dict of <Module>.C1 dict (no owner) dict of <Module>.C1 dict (no owner) dict of <Module>.C1 dict (no owner) dict of <Module>.C1 dict (no owner) dict of <Module>.C1 dict (no owner) dict of <Module>.C1 dict (no owner) dict of <Module>.C1 dict (no owner) dict of <Module>.C1 dict (no owner) dict of <Module>.C1 dict (no owner) dict of <Module>.C1 dict (no owner) dict (no owner) dict (no owner) dict (no owner) dict (no owner) [hp.Nothing.dictof] """.replace('<Module>', self.__module__)) def test_retclaset(self): # Test (A) that referrer classifications don't leak their classes # and (B) that selection is not disturbed by list arguments # (This is removed since it doesnt always work) # and (C) that selection does update referrer graph correctly self.__module__ = '<Module>' # Make the rendering independent on our name from sys import getrefcount as grc import gc C1 = self.C1 c1 = self.c1 iso = self.iso rcC1 = grc(C1) o = self.python.io.StringIO() print(iso(C1).byrcs.kind, file=o) s = iso(c1).byrcs.kind print(s, file=o) self.aseq(s & iso(c1), iso(c1)) x = C1() self.aseq(s & iso(c1, x), iso(c1)) s = iso(x).byrcs.kind self.aseq(s & iso(c1, x), iso(x)) x = C1() # (C) make sure referrer graph is updated by select self.aseq(s & iso(c1, x), iso(x)) s = None x = None gc.collect() gc.collect() # Note May 17 2005 self.aseq(grc(C1), rcC1) # (A) def test_alt_retclaset(self): # Test the alternative referrer memo update # On low level, and the speed of selection import gc iso = self.iso a = [] b = self.View.immnodeset([[]]) x = [a, b] hv = self.View.hv rg = self.View.nodegraph() gc.collect() hv.update_referrers_completely(rg) self.assertTrue(x in rg[a]) self.assertTrue(rg[list(b)[0]] == (None,)) rg.clear() rg = None # Test View functionality self.View.is_rg_update_all = True gc.collect() iso(a).referrers self.assertTrue(a in self.View.rg.get_domain()) self.assertTrue(list(b)[0] in self.View.rg.get_domain()) clock = self.python.time.process_time s = iso(a) N = 1000 while 1: t = clock() for i in range(N): s.referrers fast = clock()-t if fast >= 0.5: break N = 2 # CPU is too fast to get good resolution, try more loops t = clock() for i in range(N): self.View.rg.domain_covers([a]) self.View.rg[a] faster = clock()-t s = iso(b) t = clock() for i in range(N): s.referrers slow = clock() - t self.assertTrue(not slow > fast * 4) def test_via(self, vlist=['v', ]): # vlist is just to make v unoptimizable # Special tests for the via classifier from sys import getrefcount as grc import gc iso = self.iso hp = self.Use d = {} k = ('k',) v = tuple(vlist) # Make sure v is not optimized to a constant d[k] = v d[v] = v rck = grc(k) rcv = grc(v) s = iso(v) self.assertTrue(s.byvia.kind == hp.Via("_.f_locals['v']", "_[('k',)]", "_[('v',)]", '_.keys()[1]') or s.byvia.kind == hp.Via("_.f_locals['v']", "_[('k',)]", "_[('v',)]", '_.keys()[0]')) del s gc.collect() gc.collect() self.aseq(grc(k), rck) self.aseq(grc(v), rcv) class RenderCase(TestCase): def test_rendering(self): import sys import types iso = self.iso C1 = self.C1 c1 = self.c1 class C3(object): def x(self): return 1 e1 = [] e2 = {} e3 = [] o = self.python.io.StringIO() # str'ing of homogenous & inhoumogenous values self.US.summary_str.str_address = lambda x: '<address>' def ps(x): print(x.brief, file=o) ps(iso(1, 2)) ps(iso(1, 2.0, 3.0)) ps(iso(e1)) ps(iso(e1, e2)) ps(iso(e1, e3)) ps(iso(self.python.builtins.TypeError())) # ps(iso(type('MetaType', (type,), {})('MetaTypeIns', (), {}))) ps(iso(None)) ps(iso(sys, support, types)) ps(iso(int, type, C3)) ps(iso(C1())) ps(iso(C3())) ps(iso(C1)) ps(iso(C3)) ps(iso(len)) ps(iso(self.setUp)) ps(iso(C1.x)) ps(iso(C1().x)) ps(iso(C3.x)) ps(iso(C3().x)) ps(iso({})) ps(iso(c1.__dict__)) ps(iso(types.__dict__)) try: 1/0 except ZeroDivisionError: typ, value, traceback = sys.exc_info() ps(iso(traceback)) ps(iso(traceback.tb_frame)) expected = textwrap.dedent("""\ <2 int: 1, 2> <3 (float \| int): <2 float: 2.0, 3.0> \| <1 int: 1>> <1 list: <address>0> <2 (dict (no owner) \| list): <1 dict (no owner): <address>0> \| <1 list: <ad...> <2 list: <address>0, <address>0> <1 TypeError: <address>> <1 builtins.NoneType: None> <3 module: guppy.heapy.test.support, sys, types> <3 type: <Module>.C3, int, type> <1 <Module>.C1: <address>> <1 <Module>.C3: <address>> <1 type: <Module>.C1> <1 type: <Module>.C3> <1 types.BuiltinMethodType: len> <1 types.MethodType: <<Module>.RenderCase at <addre...> <1 function: <Module>.x> <1 types.MethodType: <<Module>.C1 at <address>>.x> <1 function: <Module>.x> <1 types.MethodType: <<Module>.C3 at <address>>.x> <1 dict (no owner): <address>*0> <1 dict of <Module>.C1: <address>> <1 dict of module: types> <1 types.TracebackType: <in frame <test_rendering at <address>> at <address>>> <1 types.FrameType: <test_rendering at <address>>> """) expected = expected.replace('<Module>', self.__module__) if self.version_info >= (3, 10): expected = expected.replace('builtins.NoneType', 'types.NoneType') self.aseq(o.getvalue(), expected) if PORTABLE_TEST: return o = self.python.io.StringIO() # The following is nonportable, sizes may change # In particular, the list size changed from 2.3 to 2.4 # The following test is only for 2.3 in 32-bit python # pp'ing prints in a nice form # This tests all types currently defined in Classifiers.Summary_str # and then some # Except: frametype; its size varies from time to time! x = iso(len, C1, 1.0+3j, {1: 2, 3: 4}, 1.25, C1.x.__func__, 1, ['list'], 100000000000, None, C1.x, C1().x, C3.x, C3().x, sys, support, 'string', ('tuple',), C3, int, type(None), # and some types not defined C1(), C3(), c1.__dict__ ) print(x, file=o) print(x.more, file=o) # Test instancetype; we need to replace the classifier with bytype x = iso(C1()).bytype print(x, file=o) expected = """\ Partition of a set of 24 objects. Total size = 2128 bytes. Index Count % Size % Cumulative % Kind (class / dict of class) 0 3 12 1272 60 1272 60 type 1 4 17 144 7 1416 67 types.MethodType 2 1 4 136 6 1552 73 dict (no owner) 3 1 4 136 6 1688 79 dict of <Module>.C1 4 1 4 60 3 1748 82 list 5 1 4 56 3 1804 85 function 6 2 8 48 2 1852 87 module 7 1 4 44 2 1896 89 class 8 1 4 32 2 1928 91 <Module>.C1 9 1 4 32 2 1960 92 str <8 more rows. Type e.g. '_.more' to view.> Index Count % Size % Cumulative % Kind (class / dict of class) 10 1 4 32 2 1992 94 types.BuiltinMethodType 11 1 4 28 1 2020 95 <Module>.C3 12 1 4 28 1 2048 96 tuple 13 1 4 24 1 2072 97 complex 14 1 4 20 1 2092 98 long 15 1 4 16 1 2108 99 float 16 1 4 12 1 2120 100 int 17 1 4 8 0 2128 100 types.NoneType Partition of a set of 1 object. Total size = 32 bytes. Index Count % Size % Cumulative % Type 0 1 100 32 100 32 100 types.InstanceType """.replace('<Module>', self.__module__) self.aseq(o.getvalue(), expected) class BaseCase(TestCase): def test_minmax(self): s = self.guppy.sets.immbitset min = self.US.minimals max = self.US.maximals self.aseq(min([]), []) self.aseq(min([1]), [1]) self.aseq(min([1, 1]), [1]) self.aseq(min([1, 2]), [1]) self.aseq(min([[], []]), [[]]) self.aseq(min([s([1]), s([1, 2])]), [s([1])]) self.aseq(min([s([1]), s([1, 2]), s([3])]), [s([1]), s([3])]) self.aseq(max([]), []) self.aseq(max([1]), [1]) self.aseq(max([1, 1]), [1]) self.aseq(max([1, 2]), [2]) self.aseq(max([[], []]), [[]]) self.aseq(max([s([1]), s([1, 2])]), [s([1, 2])]) self.aseq(max([s([1]), s([1, 2]), s([3])]), [s([1, 2]), s([3])]) def test_base_classes(self): un = self.un ty = self.ty do = self.do rc = self.rc iso = self.iso All = self.Anything Nothing = self.Nothing C1 = self.C1 C2 = self.C2 c1 = self.c1 lt = self.lt eq = self.eq dj = self.dj nr = self.nr data = [ (All, eq, All), (ty(int), eq, ty(int)), (ty(int), dj, ty(dict)), (ty(int), lt, All), (rc(ty(dict)), eq, rc(ty(dict))), (rc(ty(dict)), lt, All), (rc(ty(dict)), dj, rc(ty(list))), (iso(1), eq, iso(1)), (iso(1), lt, All), (iso(1), dj, iso(2)), (iso(1), lt, ty(int)), (iso(1), dj, ty(dict)), (Nothing, eq, Nothing), (Nothing, lt, ty(int)), (Nothing, lt, iso(1)), ] # Test relation of base classifications for a, cmp, b in data: cmp(a, b) # Test the four set-operations: & \| - ^ # depending on the asserted argument relation if cmp is eq: eq(b, a) elif cmp is lt: self.assertTrue(b > a) eq(b ^ a, b - a) # Simple transformation eq(a ^ b, b - a) # -=-, indep. of type lt(a, b) elif cmp is dj: dj(b, a) # check that the dj relation is symmetric eq(a & b, Nothing) eq(b & a, Nothing) eq(a \| b, b \| a) eq(a - b, a) eq((a \| b) - b, a) eq(a ^ b, a \| b) eq(b ^ a, a \| b) lt(a, a \| b) lt(b, a \| b) elif cmp is nr: nr(b, a) # symmetric as well eq(a & b, b & a) eq(a & b & b, a & b) eq((a & b) - b, Nothing) eq((a \| b) - b, a - b) eq(a \| b, b \| a) lt(Nothing, a & b) lt(Nothing, b & a) lt(a & b, a) lt(a & b, b) lt(a - b, a) dj(a - b, b) lt(a ^ b, a \| b) lt(a, a \| b) lt(b, a \| b) def test_invalid_operations(self): US = self.US US.auto_convert_iter = False US.auto_convert_type = False ty = self.ty c1 = self.c1 self.assertRaises(TypeError, lambda: ty(c1)) self.assertRaises(TypeError, lambda: ty(int) <= None) self.assertRaises(TypeError, lambda: None >= ty(int)) self.assertRaises(TypeError, lambda: None <= ty(int)) self.assertRaises(TypeError, lambda: list(ty(int))) self.assertRaises(TypeError, lambda: len(ty(int))) self.assertRaises(TypeError, lambda: ty(int) & None) self.assertRaises(TypeError, lambda: None & ty(int)) self.assertRaises(TypeError, lambda: ty(int) \| None) self.assertRaises(TypeError, lambda: None \| ty(int)) self.assertRaises(TypeError, lambda: ty(int) - None) self.assertRaises(TypeError, lambda: None - ty(int)) self.assertRaises(TypeError, lambda: ty(int) ^ None) self.assertRaises(TypeError, lambda: None ^ ty(int)) self.assertRaises(TypeError, lambda: ty(int) \| [14]) self.assertRaises(TypeError, lambda: ty(int) \| dict) self.assertRaises(TypeError, lambda: ty(int) \| self.C1) def test_fancy_list_args(self): # Test the, normally disabled, possibility to use iterables as # right and left arguments in set expressions. # This option can cause problems as noted 22/11 2004. self.US.auto_convert_iter = True eq = self.eq iso = self.iso ty = self.ty e1 = [] e2 = {} e3 = [] e4 = () eq(ty(list) & [e1, e2, e3], iso(e1, e3)) eq([e1, e2, e3] & ty(list), iso(e1, e3)) # Requires __rand__ eq([e1, e2, e4] & (ty(dict) \| ty(list)) == [e1, e2], True) eq([e1, e2] & (ty(dict) \| ty(list)) == [e1, e2], True) eq(iso(e1, e2) & (ty(dict) \| ty(list)) == [e1, e2], True) eq(iso(e1, e2) & [e1, e3], iso(e1)) eq(iso(e1, e2) \| [e1, e3], iso(e1, e2, e3)) # Requires __ror__ eq([e1, e3] \| iso(e1, e2), iso(e1, e2, e3)) eq(iso(e1, e3) - [e3], iso(e1)) eq([e1, e3] - iso(e3), iso(e1)) # Requires __rsub__ eq([e1, e2, e3] - ty(dict), iso(e1, e3)) eq(~ty(dict) & [e1, e2, e3], iso(e1, e3)) eq(iso(e1, e3) ^ [e2], iso(e1, e2, e3)) eq([e2] ^ iso(e1, e3), iso(e1, e2, e3)) # Requires __rxor__ eq([e1, e2] <= iso(e1, e2, e3), True) eq([e1, e2] <= ty(list) \| ty(dict), True) eq((ty(list) \| ty(dict)) >= [e1, e2], True) eq([e1, e2] <= ty(list), False) eq([e1, e2] <= iso(e1), False) eq([e1, e2] >= iso(e1, e2, e3), False) eq([e1, e2] >= iso(e1, e2), True) eq(iso(e1, e2, e3) <= [e1, e2], False) eq(iso(e1, e2) <= [e1, e2], True) eq(iso(e1, e2, e3) >= [e1, e2], True) eq(iso(e1, e2) >= [e1, e2, e3], False) def test_fancy_type_conversions(self): # Test the, perhaps optional, possibility to use types and classes # in classification set expressions. self.US.auto_convert_type = True un = self.un ty = self.ty do = self.do rc = self.rc iso = self.iso All = self.Anything Nothing = self.Nothing C1 = self.C1 C2 = self.C2 c1 = self.c1 def eq(a, b): self.assertTrue(a == b) e1 = [] e2 = {} e3 = [] e4 = () eq(ty(dict), dict) eq(iso(e1, e2) & dict, iso(e2)) eq(dict & iso(e1, e2), iso(e2)) eq(iso(e1, e2) \| dict, iso(e1) \| ty(dict)) eq(dict \| iso(e1, e2), iso(e1) \| ty(dict)) eq(iso(e1, e2) - dict, iso(e1)) eq(dict - iso(e1, e2), ty(dict) - iso(e2)) eq(iso(e1, e2, e3) ^ dict, (ty(dict)-iso(e2)) \| iso(e1, e3)) class LawsCase(TestCase): def test_laws(self): un = self.un ty = self.ty do = self.do rc = self.rc iso = self.iso All = self.Anything Nothing = self.Nothing C1 = self.C1 C2 = self.C2 c1 = self.c1 lt = self.lt eq = self.eq t = self.guppy.sets.test absorption = t.absorption associative = t.associative commutative = t.commutative deMorgan = t.deMorgan distributive = t.distributive idempotence = t.idempotence inclusion = t.inclusion def ltr(a, b, level=3): lt(a, b) eq(a & b, a) eq(b & a, a) eq(a \| b, b) eq(b \| a, b) eq(a - b, Nothing) eqr(b - a, b - a) eq((b - a) \| a, b) eq(a \| (b - a), b) eq(a & (b - a), Nothing) eq((b - a) & a, Nothing) eq((b - a) - a, (b - a)) eq(a - (b - a), a) # note Nov 3 2004 if level > 0: if a is Nothing: eq(b - a, b) else: ltr(b - a, b, level-1) def eqr(a, b, level=1): eq(a, b) eq(a & b, a) eq(a \| b, a) eq(a - b, Nothing) eq(a ^ b, Nothing) if level: eqr(b, a, level - 1) classes = [All, ty(int), ty(type(c1)), rc(ty(dict)), iso(c1), Nothing] for a in classes: idempotence(a) for b in classes: if a <= b: if b <= a: eqr(a, b) else: ltr(a, b) elif b <= a: ltr(b, a) absorption(a, b) commutative(a, b) inclusion(a, b) deMorgan(a, b) for c in classes: associative(a, b, c) deMorgan(a, b, c) distributive(a, b, c) class ClassificationCase(TestCase): def test_classification(self): # Test classification by the standard classifiers self.View.is_rg_update_all = True # Tricky details Note Apr 22 2005 Use = self.Use iso = self.iso nodeset = self.heapy.UniSet.immnodeset class A: pass class B(object): pass a = A() b = B() li = [1, [], {}, a, b, a.__dict__, b.__dict__] for o in li: self.asis(iso(o).bytype.kind.arg, type(o)) for o in li: if o is a.__dict__: kind = iso(a).kind elif o is b.__dict__: kind = iso(b).kind elif type(o) is dict: kind = Use.Nothing elif o is a: kind = a.__class__ else: kind = type(o) self.aseq(iso(o).kind.arg, kind) cla = iso(()).byunity.kind self.asis(cla.arg, None) for o in li: self.aseq(iso(o).byunity.kind, cla) for o in li: self.aseq(iso(o).byid.kind, Use.Id(id(o))) # self.View.update_referrers(nodeset(li)) for i, o in enumerate(li): cl = iso(o).byrcs.kind if 1 <= i <= 2: self.aseq(cl, Use.Clodo.sokind(list).refdby) if i == 5: self.aseq(cl, Use.Clodo.sokind(A)(list).refdby) if i == 6: self.aseq(cl, Use.Clodo.sokind(B)(list).refdby) def test_selection(self): # Test classifications operations via selection invariant Use = self.Use class A: pass class B(object): pass a = A() b = B() li = Use.iso(135, [], {}, a, b, a.__dict__, b.__dict__) allers = (Use.Unity, Use.Type, Use.Clodo, Use.Rcs, Use.Via) # , Use.Id ps = {} for er in allers: # p = er.classifier.partition(li.nodes) p = [(av.kind, av) for av in li.by(er).partition] for ak, av in p: if ak in ps: self.aseq(ps[ak], av) else: ps[ak] = av for ak, av in list(ps.items()): self.aseq(ak & li, av) for bk, bv in list(ps.items()): # Test set operations by selection definition self.aseq((ak & bk) & li, av & bv) self.aseq((ak \| bk) & li, av \| bv) self.aseq((ak - bk) & li, av - bv) self.aseq((bk - ak) & li, bv - av) self.aseq((ak ^ bk) & li, av ^ bv) def test_main(testrender=1, debug=0): support.run_unittest(BaseCase, debug) support.run_unittest(ClassificationCase, debug) support.run_unittest(LawsCase, debug) support.run_unittest(RenderCase, debug) support.run_unittest(SpecialCases, debug)	28.38 KB	2026-01-20 12:58
📄 test_ER.py # Tests of equivalence relations. # These are also tested by test_Classifiers. # This is some more tests, tailored esp. to the user view. # (test_Classifiers was so slow already, so I start over) # o Intended to be exhaustive wrt all ER's defined # # o Intersection of ER's from guppy.heapy.test import support import inspect import os.path class TestCase(support.TestCase): pass class FirstCase(TestCase): def test_1(self): hp = self.heapy.Use hp.reprefix = 'hp.' a = hp.iso(1, '', 'asdf', 3.4, 3.7, 2) ts = (hp.Type & hp.Size) k = ts[a] # From Sep 1-2 2005 # (h&dict).by(hp.Id.dictof&hp.Size)._get_partition() # (h&dict).by((hp.Type&hp.Size).dictof&hp.Size) # These require with_referrers of refby/via classifier # after gc collect referrers graph will be empty # (h).by(hp.Module.refby.dictof) # (h).by(hp.Via.dictof) # How to construct RCS / refby # self.aseq(hp.Type.refby(int, list) , hp.Type.refby(list, int) class C: pass di = hp.iso(C.__dict__, []) # db = di.by('Rcs') # for i in (0, 1): # rk = repr(db[i].kind) # ek = eval(rk, {'hp': hp}, {}) # self.aseq(ek, db[i].kind) # self.aseq(db & ek, db[i]) def test_2(self): ' Systematically test all kind constructors: ' # wrt repr and evaluation of repr hp = self.heapy.Use hp.reprefix = 'hp.' class C: pass class T(object): pass c = C() t = T() import sys for s in ( 'hp.Clodo(dictof=C)', 'hp.Clodo(dictof=T)', 'hp.Clodo(dictof=())', 'hp.Clodo(C)', 'hp.Clodo(T)', 'hp.Id(id(c))', 'hp.Module("sys")', 'hp.Prod()', 'hp.Prod("<string>")', 'hp.Prod(T)', 'hp.Prod("/foo.py", 1)', 'hp.Prod("/foo.py", None)', 'hp.Prod(None, 1)', 'hp.Rcs(hp.Clodo.sokind(int)(dictof=C))', 'hp.Size(hp.iso(c).indisize)', 'hp.Size(hp.iso(C).indisize).dictof', 'hp.Type(T)', 'hp.Type(int)', 'hp.Unity()', 'hp.Via()', # Via is also specially tested below ): x = eval(s, {'hp': hp, 'C': C, 'T': T, 'c': c}, {}) rx = repr(x) self.aseq(eval(rx, {'hp': hp}, {}), x) for i, s in enumerate(( # Test Via construction. # One test for each relation kind defined in Path except IDENTITY and RELSRC. # In code order. "hp.Via('_.x')", "hp.Via('_[0]')", "hp.Via('_.keys()[0]')", "hp.Via('_->abc')", "hp.Via('_.__dict__.keys()[0]')", "hp.Via('_.f_locals[\"abc\"]')", "hp.Via('_.f_locals [\"abc\"]')", "hp.Via('_->f_valuestack[0]')", "hp.Via('list(_)[0]')", )): code = i + 1 x = eval(s, {'hp': hp}, {}) rel = list(x.arg)[0] self.aseq(rel.kind, code) rx = repr(x) self.aseq(eval(rx, {'hp': hp}, {}), x) def test_3(self): ' Test of dictof ' # Test of dictof on something that requires memoization, i.e. Size, & (and) hp = self.heapy.Use class C: pass class T(object): # The test works only if sizes of objects of class C and T differ. # At first test, T() was 4 bytes smaller than C(). # This might be brittle with different systems. # This is to make sure this diff gets significantly bigger: __slots__ = '__dict__', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h' c = C() t = T() dn = {} isod = hp.iso(c.__dict__, t.__dict__, dn) for x in ( t, c): X = x.__class__ for k in ( hp.Clodo(dictof=X), hp.Size(hp.iso(x).indisize).dictof, hp.iso(x).bysize.kind.dictof, hp.iso(x.__dict__).kind, ): self.aseq(isod & k, hp.iso(x.__dict__)) # Test no-owner selection for k in ( hp.Nothing.dictof, ): self.aseq(isod & k, hp.iso(dn)) def test_4(self): ' Test of via ' # Esp. representation, construction class C: pass c = C() hp = self.heapy.Use isod = hp.iso(c.__dict__) x = isod.by('Via').kind self.aseq(repr(x), "hpy().Via('.__dict__')") def test_5(self): ' Non-systematic tests that came up around Sep 14 2005 ' class C: pass c = C() d = {} cref = [c] cref.append(cref) c.cref = cref hp = self.heapy.Use hp.reprefix = 'hp.' # I thought these should be the same a = hp.iso(C, c, c.__dict__, d) b = hp.iso(C, c, c.__dict__, d) self.aseq(a, b) # This is a kind of nested refdby that has been a concern lately # -- how to represent it s = hp.iso(C.__dict__, C, c, c.__dict__, d).by(hp.Clodo.refdby.refdby) for i in range(len(s)): a = s[i].kind ra = repr(a) era = eval(ra, {'hp': hp}, {}) self.aseq(a, era) self.aseq(s & era, s[i]) import sys p = sys.path del sys s = hp.iso(p) x = s.by(hp.Module.dictof.refdby) self.aseq(s & eval(repr(x.kind), {'hp': hp}, {}), s) def test_6(self): ' Test of .refdby on all others ' with self.tracemalloc_state(): class C: pass c = C() d = {} cref = [c] cref.append(cref) c.cref = cref hp = self.heapy.Use hp.reprefix = 'hp.' s = hp.iso(C.__dict__, C, c, c.__dict__, d, inspect) for pre in ( 'Unity', 'Clodo', 'Id', 'Module', 'Prod', ('Rcs', 0), 'Size', 'Type', 'Via' ): if isinstance(pre, tuple): pre, level = pre else: level = 1 er = getattr(hp, pre) self.er_test(er, s, level) def er_test(self, er, set, level=1): # Tests what any eqv. rel. er should do hp = self.heapy.Use rer = repr(er) self.aseq(eval(rer, {'hp': hp}, {}), er) for s in (set,): sby = s.by(er) sk = sby.kind rsk = repr(sk) ske = eval(rsk, {'hp': hp}, {}) self.aseq(ske, sk, -1) self.aseq(s & sk, s, -1) self.aseq(s & ske, s, -1) # That it can do .refdby er_refdby = er.refdby # That it can do .dictof er_dictof = er.dictof if level > 0: self.er_test(er_refdby, set, level - 1) self.er_test(er_dictof, set, level - 1) def test_7(self): ' Test of alternative sets w. biper ' hp = self.heapy.Use class C: pass class D(C): pass class E(D): pass class T(object): pass class U(T): pass class V(U): pass c = C() d = D() e = E() t = T() u = U() v = V() s = hp.iso([], {}, c, d, e, t, u, v, d.__dict__) for k in ( hp.Size(32), hp.Type(U), ): lt = k.alt('<') le = k.alt('<=') ge = k.alt('>=') gt = k.alt('>=') ne = k.alt('!=') assert (s & le) & (s & ge) == s & k for a in (lt, le, ge, gt, ne, le & ~k): s & a import gc gc.collect() a = s.by(k.alt('>=').biper) b = s.by(k.alt('>=').biper) self.assertTrue(hp.iso(d.__dict__) <= a[0]) self.assertTrue(a == b) gc.collect() a = s.by(k.alt('<=').biper) b = s.by(k.alt('<=').biper) self.assertTrue(hp.iso(d.__dict__) <= a[0]) self.assertTrue(a == b) def test_8(self): ' Test of findex and biper ' # added Nov 3 2005 hp = self.heapy.Use class C: pass c = C() li = [] di = {} s = hp.iso(li, di, c, 1) for k, i in ( (hp.Type(dict), 0), (hp.iso(c), 1), (hp.iso(c, li), 1), ): p = s.by(k.biper) self.aseq(p[i].kind.fam.classifier.kinds[0], k) def test_9(self): ' Test the subrelation relation ' from guppy import hpy ernames = ['Clodo', 'Id', 'Idset', 'Module', 'Prod', 'Rcs', 'Size', 'Type', 'Unity'] hp = hpy() ers = [(name, getattr(hp, name)) for name in ernames] ers.append(('Size&Type', hp.Size & hp.Type)) from io import StringIO f = StringIO() print(''.ljust(10), end=' ', file=f) for b in ers: print(b[0].ljust(7), end=' ', file=f) print(file=f) for a in ers: print(a[0].ljust(10), end=' ', file=f) for b in ers: print(str((a[1] < b[1]))[:1].ljust(7), end=' ', file=f) print(file=f) self.aseq(f.getvalue(), """\ Clodo Id Idset Module Prod Rcs Size Type Unity Size&Type \n\ Clodo F F F F F F F T T F \n\ Id F F F F F F F F T F \n\ Idset F F F F F F F F T F \n\ Module F F F F F F F F T F \n\ Prod F F F F F F F F T F \n\ Rcs F F F F F F F F T F \n\ Size F F F F F F F F T F \n\ Type F F F F F F F F T F \n\ Unity F F F F F F F F F F \n\ Size&Type F F F F F F T T T F \n\ """) def test_10(self): ' Test of producer profile ' hp = self.heapy.Use with self.tracemalloc_state(): class C: pass file = inspect.currentframe().f_code.co_filename def lineno(): return inspect.currentframe().f_back.f_lineno str_aloc = eval('C()', {'C': C}, {}) test_aloc, test_aloc_line = C(), lineno() def subf(): return C(), lineno() subf_aloc, subf_aloc_line = subf() isod = hp.iso(None, str_aloc, test_aloc, subf_aloc) self.aseq(isod & hp.Prod(), hp.iso(None)) self.aseq(isod & hp.Prod('<string>', 1), hp.iso(str_aloc)) self.aseq(isod & hp.Prod(file, test_aloc_line), hp.iso(test_aloc)) self.aseq(isod & hp.Prod(file, subf_aloc_line), hp.iso(subf_aloc)) self.aseq(isod & hp.Prod(file), hp.iso(test_aloc, subf_aloc)) self.aseq(isod & hp.Prod(os.path.dirname(file)), hp.iso(test_aloc, subf_aloc)) self.aseq(isod & hp.Prod(self.test_10), hp.iso(test_aloc, subf_aloc)) self.aseq(isod & hp.Prod(subf), hp.iso(subf_aloc)) self.aseq(isod & hp.Prod(None, test_aloc_line).alt('>=') & hp.Prod(None, test_aloc_line).alt('<='), hp.iso(test_aloc)) with self.assertRaises(TypeError): hp.Prod('', lineno=1) with self.assertRaises(TypeError): hp.Prod(filename='', line=1) with self.assertRaises(TypeError): hp.Prod(None) with self.assertRaises(TypeError): hp.Prod(1, 1) with self.assertRaises(TypeError): hp.Prod('', '') with self.assertRaises(TypeError): hp.Prod('', 1, 2) def test_main(debug=0): support.run_unittest(FirstCase, debug) if __name__ == "__main__": from guppy.heapy.Remote import off off() test_main()	12.56 KB	2026-01-20 12:58
📄 test_OutputHandling.py from guppy.heapy.test import support class FirstCase(support.TestCase): def setUp(self): support.TestCase.setUp(self) self.OH = self.heapy.OutputHandling def test_1(self): class T: def __init__(self, test, numlines, get_num_lines=None, get_more_msg=None): mod = test.OH def get_line_iter(): for i in range(numlines): yield '%d' % i self.mod = mod mod.setup_printing( self, get_line_iter=get_line_iter, max_more_lines=4, get_num_lines=get_num_lines, get_more_msg=get_more_msg) self.aseq(str(T(self, 4)), '0\n1\n2\n3') t = T(self, 6, lambda: 6) self.aseq( str(t), "0\n1\n2\n3\n<Lines 0..3 of 6. Type e.g. '_.more' for more.>") x = t.more self.aseq(str(x), '4\n5') self.aseq( str(x.top), "0\n1\n2\n3\n<Lines 0..3 of 6. Type e.g. '_.more' for more.>") self.aseq(str(x.all), "0\n1\n2\n3\n4\n5") t = T(self, 6, get_more_msg=lambda f, t: '<%d more rows>' % (6-t)) self.aseq(str(t), '0\n1\n2\n3\n<3 more rows>') def test_main(debug=0): support.run_unittest(FirstCase, debug) if __name__ == "__main__": test_main()	1.34 KB	2026-01-20 12:58
📄 test_Part.py from guppy.heapy.test import support PORTABLE_TEST = 1 # Relax tests to be more portable class IdentityCase(support.TestCase): def test_1(self): import itertools import random import sys vs = list(range(100)) random.shuffle(vs) vs = [float(i) for i in vs] x = self.iso(vs).byid sz = sys.getsizeof(0.0) self.aseq(str(x)+'\n'+str(x.more)+'\n', """\ Set of 100 <float> objects. Total size = {sztotal} bytes. Index Size % Cumulative % Value 0 {sz:>3} 1.0 {szacc[0]:>4} 1.0 0.0 1 {sz:>3} 1.0 {szacc[1]:>4} 2.0 1.0 2 {sz:>3} 1.0 {szacc[2]:>4} 3.0 2.0 3 {sz:>3} 1.0 {szacc[3]:>4} 4.0 3.0 4 {sz:>3} 1.0 {szacc[4]:>4} 5.0 4.0 5 {sz:>3} 1.0 {szacc[5]:>4} 6.0 5.0 6 {sz:>3} 1.0 {szacc[6]:>4} 7.0 6.0 7 {sz:>3} 1.0 {szacc[7]:>4} 8.0 7.0 8 {sz:>3} 1.0 {szacc[8]:>4} 9.0 8.0 9 {sz:>3} 1.0 {szacc[9]:>4} 10.0 9.0 <90 more rows. Type e.g. '_.more' to view.> Index Size % Cumulative % Value 10 {sz:>3} 1.0 {szacc[10]:>4} 11.0 10.0 11 {sz:>3} 1.0 {szacc[11]:>4} 12.0 11.0 12 {sz:>3} 1.0 {szacc[12]:>4} 13.0 12.0 13 {sz:>3} 1.0 {szacc[13]:>4} 14.0 13.0 14 {sz:>3} 1.0 {szacc[14]:>4} 15.0 14.0 15 {sz:>3} 1.0 {szacc[15]:>4} 16.0 15.0 16 {sz:>3} 1.0 {szacc[16]:>4} 17.0 16.0 17 {sz:>3} 1.0 {szacc[17]:>4} 18.0 17.0 18 {sz:>3} 1.0 {szacc[18]:>4} 19.0 18.0 19 {sz:>3} 1.0 {szacc[19]:>4} 20.0 19.0 <80 more rows. Type e.g. '_.more' to view.> """.format(sz=sz, sztotal=sz100, szacc=list(itertools.accumulate([sz] * 20)))) self.aseq(str(x.all)+'\n', """\ Set of 100 <float> objects. Total size = {sztotal} bytes. Index Size % Cumulative % Value 0 {sz:>3} 1.0 {szacc[0]:>4} 1.0 0.0 1 {sz:>3} 1.0 {szacc[1]:>4} 2.0 1.0 2 {sz:>3} 1.0 {szacc[2]:>4} 3.0 2.0 3 {sz:>3} 1.0 {szacc[3]:>4} 4.0 3.0 4 {sz:>3} 1.0 {szacc[4]:>4} 5.0 4.0 5 {sz:>3} 1.0 {szacc[5]:>4} 6.0 5.0 6 {sz:>3} 1.0 {szacc[6]:>4} 7.0 6.0 7 {sz:>3} 1.0 {szacc[7]:>4} 8.0 7.0 8 {sz:>3} 1.0 {szacc[8]:>4} 9.0 8.0 9 {sz:>3} 1.0 {szacc[9]:>4} 10.0 9.0 10 {sz:>3} 1.0 {szacc[10]:>4} 11.0 10.0 11 {sz:>3} 1.0 {szacc[11]:>4} 12.0 11.0 12 {sz:>3} 1.0 {szacc[12]:>4} 13.0 12.0 13 {sz:>3} 1.0 {szacc[13]:>4} 14.0 13.0 14 {sz:>3} 1.0 {szacc[14]:>4} 15.0 14.0 15 {sz:>3} 1.0 {szacc[15]:>4} 16.0 15.0 16 {sz:>3} 1.0 {szacc[16]:>4} 17.0 16.0 17 {sz:>3} 1.0 {szacc[17]:>4} 18.0 17.0 18 {sz:>3} 1.0 {szacc[18]:>4} 19.0 18.0 19 {sz:>3} 1.0 {szacc[19]:>4} 20.0 19.0 20 {sz:>3} 1.0 {szacc[20]:>4} 21.0 20.0 21 {sz:>3} 1.0 {szacc[21]:>4} 22.0 21.0 22 {sz:>3} 1.0 {szacc[22]:>4} 23.0 22.0 23 {sz:>3} 1.0 {szacc[23]:>4} 24.0 23.0 24 {sz:>3} 1.0 {szacc[24]:>4} 25.0 24.0 25 {sz:>3} 1.0 {szacc[25]:>4} 26.0 25.0 26 {sz:>3} 1.0 {szacc[26]:>4} 27.0 26.0 27 {sz:>3} 1.0 {szacc[27]:>4} 28.0 27.0 28 {sz:>3} 1.0 {szacc[28]:>4} 29.0 28.0 29 {sz:>3} 1.0 {szacc[29]:>4} 30.0 29.0 30 {sz:>3} 1.0 {szacc[30]:>4} 31.0 30.0 31 {sz:>3} 1.0 {szacc[31]:>4} 32.0 31.0 32 {sz:>3} 1.0 {szacc[32]:>4} 33.0 32.0 33 {sz:>3} 1.0 {szacc[33]:>4} 34.0 33.0 34 {sz:>3} 1.0 {szacc[34]:>4} 35.0 34.0 35 {sz:>3} 1.0 {szacc[35]:>4} 36.0 35.0 36 {sz:>3} 1.0 {szacc[36]:>4} 37.0 36.0 37 {sz:>3} 1.0 {szacc[37]:>4} 38.0 37.0 38 {sz:>3} 1.0 {szacc[38]:>4} 39.0 38.0 39 {sz:>3} 1.0 {szacc[39]:>4} 40.0 39.0 40 {sz:>3} 1.0 {szacc[40]:>4} 41.0 40.0 41 {sz:>3} 1.0 {szacc[41]:>4} 42.0 41.0 42 {sz:>3} 1.0 {szacc[42]:>4} 43.0 42.0 43 {sz:>3} 1.0 {szacc[43]:>4} 44.0 43.0 44 {sz:>3} 1.0 {szacc[44]:>4} 45.0 44.0 45 {sz:>3} 1.0 {szacc[45]:>4} 46.0 45.0 46 {sz:>3} 1.0 {szacc[46]:>4} 47.0 46.0 47 {sz:>3} 1.0 {szacc[47]:>4} 48.0 47.0 48 {sz:>3} 1.0 {szacc[48]:>4} 49.0 48.0 49 {sz:>3} 1.0 {szacc[49]:>4} 50.0 49.0 50 {sz:>3} 1.0 {szacc[50]:>4} 51.0 50.0 51 {sz:>3} 1.0 {szacc[51]:>4} 52.0 51.0 52 {sz:>3} 1.0 {szacc[52]:>4} 53.0 52.0 53 {sz:>3} 1.0 {szacc[53]:>4} 54.0 53.0 54 {sz:>3} 1.0 {szacc[54]:>4} 55.0 54.0 55 {sz:>3} 1.0 {szacc[55]:>4} 56.0 55.0 56 {sz:>3} 1.0 {szacc[56]:>4} 57.0 56.0 57 {sz:>3} 1.0 {szacc[57]:>4} 58.0 57.0 58 {sz:>3} 1.0 {szacc[58]:>4} 59.0 58.0 59 {sz:>3} 1.0 {szacc[59]:>4} 60.0 59.0 60 {sz:>3} 1.0 {szacc[60]:>4} 61.0 60.0 61 {sz:>3} 1.0 {szacc[61]:>4} 62.0 61.0 62 {sz:>3} 1.0 {szacc[62]:>4} 63.0 62.0 63 {sz:>3} 1.0 {szacc[63]:>4} 64.0 63.0 64 {sz:>3} 1.0 {szacc[64]:>4} 65.0 64.0 65 {sz:>3} 1.0 {szacc[65]:>4} 66.0 65.0 66 {sz:>3} 1.0 {szacc[66]:>4} 67.0 66.0 67 {sz:>3} 1.0 {szacc[67]:>4} 68.0 67.0 68 {sz:>3} 1.0 {szacc[68]:>4} 69.0 68.0 69 {sz:>3} 1.0 {szacc[69]:>4} 70.0 69.0 70 {sz:>3} 1.0 {szacc[70]:>4} 71.0 70.0 71 {sz:>3} 1.0 {szacc[71]:>4} 72.0 71.0 72 {sz:>3} 1.0 {szacc[72]:>4} 73.0 72.0 73 {sz:>3} 1.0 {szacc[73]:>4} 74.0 73.0 74 {sz:>3} 1.0 {szacc[74]:>4} 75.0 74.0 75 {sz:>3} 1.0 {szacc[75]:>4} 76.0 75.0 76 {sz:>3} 1.0 {szacc[76]:>4} 77.0 76.0 77 {sz:>3} 1.0 {szacc[77]:>4} 78.0 77.0 78 {sz:>3} 1.0 {szacc[78]:>4} 79.0 78.0 79 {sz:>3} 1.0 {szacc[79]:>4} 80.0 79.0 80 {sz:>3} 1.0 {szacc[80]:>4} 81.0 80.0 81 {sz:>3} 1.0 {szacc[81]:>4} 82.0 81.0 82 {sz:>3} 1.0 {szacc[82]:>4} 83.0 82.0 83 {sz:>3} 1.0 {szacc[83]:>4} 84.0 83.0 84 {sz:>3} 1.0 {szacc[84]:>4} 85.0 84.0 85 {sz:>3} 1.0 {szacc[85]:>4} 86.0 85.0 86 {sz:>3} 1.0 {szacc[86]:>4} 87.0 86.0 87 {sz:>3} 1.0 {szacc[87]:>4} 88.0 87.0 88 {sz:>3} 1.0 {szacc[88]:>4} 89.0 88.0 89 {sz:>3} 1.0 {szacc[89]:>4} 90.0 89.0 90 {sz:>3} 1.0 {szacc[90]:>4} 91.0 90.0 91 {sz:>3} 1.0 {szacc[91]:>4} 92.0 91.0 92 {sz:>3} 1.0 {szacc[92]:>4} 93.0 92.0 93 {sz:>3} 1.0 {szacc[93]:>4} 94.0 93.0 94 {sz:>3} 1.0 {szacc[94]:>4} 95.0 94.0 95 {sz:>3} 1.0 {szacc[95]:>4} 96.0 95.0 96 {sz:>3} 1.0 {szacc[96]:>4} 97.0 96.0 97 {sz:>3} 1.0 {szacc[97]:>4} 98.0 97.0 98 {sz:>3} 1.0 {szacc[98]:>4} 99.0 98.0 99 {sz:>3} 1.0 {szacc[99]:>4} 100.0 99.0 """.format(sz=sz, sztotal=sz100, szacc=list(itertools.accumulate([sz] 100)))) def test_2(self): # Slicing ss = [] for i in range(100): for c in 'abc': ss.append(ci) x = self.iso(ss).byid def ae(x): lines = str(x).split('\n') datapos = lines[1].index('Representation') s = lines[2:] if s[-1].startswith('<'): s.pop() s = [line[datapos:] for line in s] return s def aeq(x, y): self.aseq(ae(x), ae(y)) for i in range(0, 300, 60): b = x[i:] aeq(b, b.byid) # (B) in Notes Aug 26 2005 self.aseq(x.bysize[2].kind, x.bysize[2].bysize.kind) def test_3(self): # Some indexing cases. # Came up Sep 29 2005. # The kind of the result of indexing is to be # the result of the er of the partition. hp = self.Use x = hp.iso([], [], *list(range(20))).byid eq = [x[-10], x[-10:-9], x[12], x[12:13], x.parts[-10], x.parts[12]] k = x[-10].byid.kind for i in range(len(eq)): self.aseq(eq[i], eq[(i + 1) % len(eq)]) self.aseq(eq[i].kind, eq[(i + 1) % len(eq)].kind) self.aseq(eq[i].kind, k) class MixedCase(support.TestCase): def test_1(self): x = self.iso(1, 2, 1.0, 2.0, '1', '2') if not PORTABLE_TEST: self.aseq(str(x), """\ Partition of a set of 6 objects. Total size = 204 bytes. Index Count % Size % Cumulative % Kind (class / dict of class) 0 2 33 100 49 100 49 str 1 2 33 56 27 156 76 int 2 2 33 48 24 204 100 float""") for row in x.partition.get_rows(): self.assertTrue(row.set <= row.kind) class StatCase(support.TestCase): def test_1(self): hp = self.Use class C: pass c0 = C() class C: pass c1 = C() x = hp.iso(c0, c1) y = hp.iso(c1) d = x.diff(y) self.aseq(d.count, 1) self.aseq(d[0].count, 1) d = y.diff(x) self.aseq(d.count, -1) self.aseq(d[0].count, -1) d = x.diff(hp.iso()) self.aseq(d.count, 2) self.aseq(d[0].count, 2) d = hp.iso().diff(x) self.aseq(d.count, -2) self.aseq(d[0].count, -2) def test_main(debug=0): support.run_unittest(StatCase, debug) support.run_unittest(IdentityCase, debug) support.run_unittest(MixedCase, debug) if __name__ == "__main__": test_main()	10.15 KB	2026-01-20 12:58
📄 test_Path.py from guppy.heapy.test import support import inspect import unittest class TestCase(support.TestCase): def setUp(self): support.TestCase.setUp(self) self.Path = self.heapy.Path def chkrel(self, src, dst, relstr=None, clas=None): rel = self.relation(src, dst) if clas is not None: self.assertTrue(isinstance(rel, clas)) if relstr is None: print(rel) else: sr = str(rel) if sr.startswith('<') and not relstr.startswith('<'): self.assertTrue(sr.endswith('>')) sr = sr[1:-1].split(',') self.assertTrue(relstr in sr) else: self.aseq(sr, relstr) def chkrelattr(self, src, attrs): for attr in attrs: self.chkrel(src, getattr(src, attr), '%s.'+attr) def chkpath(self, src, dst, expect=None): rel = self.shpaths(dst, src) if expect is None: print(rel) else: li = rel.aslist() if len(li) == 1: li = li[0] self.aseq(str(li), str(expect), -1) def relation(self, src, dst): return self.Path.relation(src, dst) def shpaths(self, dst, src=None, args, *kwds): # return self.Path.shpaths(dst, src, args, *kwds) dst = self.iso(dst) if src is not None: src = self.iso(src) return dst.get_shpaths(src, args, *kwds) class RelationTestCase(TestCase): # Test relations from standard types and some simple paths def test_cell_relation(self): cellvalue = [] def f(): return cellvalue self.chkrel(f.__closure__[0], cellvalue, '%s.cell_contents') def test_code_relation(self): def f(): a = 3 return self, a co = f.__code__ # xxx brittle test but catches a bug self.chkpath(co, 3, '%s.co_consts[1]') # commented in notes Sep 27 2004 relAttr = ('co_code', 'co_consts', 'co_names', 'co_filename', 'co_name') if self.version_info < (3, 11): relAttr += ('co_varnames', 'co_freevars', 'co_cellvars') else: relAttr += ('co_exceptiontable', 'co_qualname') if self.version_info >= (3, 10): relAttr += ('co_linetable',) else: relAttr += ('co_lnotab',) self.chkrelattr(co, relAttr) def test_dict_relation(self): k1 = 'k1' k2 = 'k2' v1 = 'v1' v2 = 'v2' k3 = tuple(range(100)) v3 = tuple(range(100, 200)) x = {k1: v1, k2: v2, k3: v3} self.chkrel(x, v1, "%s['k1']") self.chkrel(x, v2, "%s['k2']") self.chkrel(x, v3, "%s[(0, 1, 2, 3, 4, 5, ...)]") ks = [str(self.relation(x, k1)), str(self.relation(x, k2)), str(self.relation(x, k3))] ks.sort() self.aseq(ks, ['%s.keys()[0]', '%s.keys()[1]', '%s.keys()[2]']) def test_dictproxy_relation(self): v1 = 'v1' class T(object): k1 = v1 x = T.__dict__ self.chkpath(x, v1, "%s->mapping['k1']") self.chkrel(x, v1, "%s['k1']") def test_frame_relation(self): f = inspect.currentframe() f.f_trace = lambda: None self.chkrelattr(f, 'f_back', 'f_builtins', 'f_code', 'f_globals', 'f_locals', 'f_trace') a = [] # The representation of local variables is how they may be accessed # - not how they are really stored. # xxx this may be confusing/lack information? # The information is available in the relation object class, # it is just not represented with str()... self.chkrel(f, a, "%s.f_locals['a']", clas=self.Path.R_LOCAL_VAR) x = [] z = [] def func(x, y=3): frame = inspect.currentframe() return self, frame, z _, frame, __ = func(0) del _, __ self.chkrel(frame, self, "%s.f_locals ['self']", clas=self.Path.R_CELL) self.chkrel(f, x, "%s.f_locals['x']", clas=self.Path.R_LOCAL_VAR) self.chkrel(f, z, "%s.f_locals ['z']", clas=self.Path.R_CELL) # self becomes both a local var and a cell var, since it is an argument. # FIXME: But not in py3... it seems # self.chkrel(f, self, "<%s.f_locals['self'],%s.f_locals ['self']>") # Stack variables doesn't work (Because ceval.c doesn't update # the f_stacktop index.) so the corresponding part of frame_relate is not tested. def test_function_relation(self): def f(x, y=3): return self f.a = [] self.chkrelattr(f, '__code__', '__globals__', '__defaults__', '__closure__', '__doc__', '__name__', '__dict__', 'a') def test_instancemethod_relation(self): class T: def f(x): pass t = T() self.chkrelattr(t.f, '__func__', '__self__') def test_list_relation(self): v1 = 'v1' v2 = 'v2' v3 = list(range(100, 200)) x = [v1, v2, v3] self.chkrel(x, v1, '%s[0]') self.chkrel(x, v2, '%s[1]') self.chkrel(x, v3, '%s[2]') def test_meth_relation(self): x = [] self.chkrel(x.append, x, '%s.__self__') def test_module_relation(self): self.chkrelattr(unittest, '__dict__', 'TestCase') def test_nodegraph_relation(self): a = 0 b = 1 rl = [a, b] rg = self.heapy.heapyc.NodeGraph([(a, rl), (b, rl)]) self.chkrel(rg, a, '%s->edges[0].src') self.chkrel(rg, b, '%s->edges[1].src') self.chkrel(rg, rl, '<%s->edges[0].tgt,%s->edges[1].tgt>') self.chkpath(rg, a, '%s->edges[0].src') self.chkpath(rg, rl, ['%s->edges[0].tgt', '%s->edges[1].tgt']) def test_nodeset_relation(self): from guppy.sets import immnodeset, mutnodeset x = ['a'] for s in (immnodeset(x), mutnodeset(x)): for i in range(len(x)): self.chkrel(s, x[i], 'list(%%s)[%s]' % i) def test_object_relation(self): class T(object): __slots__ = 'a', 'b' t = T() a = [] t.a = a b = [] t.b = b # self.chkrel(t, T, 'type(%s)') self.chkrel(t, T, '%s->ob_type') self.chkrelattr(t, 'a', 'b') # We shouldn't have a __dict__ here - just make sure this is the case self.assertRaises(AttributeError, lambda: t.__dict__) class U(T): pass u = U() u.a = a self.chkpath(u, T, "%s->ob_type.__base__") self.chkrel(u, a, '%s.a') c = [] u.c = c self.chkrel(u, c, '%s.c') self.chkrel(u, u.__dict__, '%s.__dict__') class V(U): pass v = V() v.c = c self.chkrelattr(v, '__dict__') class W(V): __slots__ = 'c', 'd', 'b' pass w = W() w.a = a w.b = b w.c = c w.d = [] w.e = [] self.chkrelattr(w, '__dict__', 'a', 'b', 'c', 'd', 'e') self.chkpath(w, w.a, '%s.a') self.chkpath(w, w.b, '%s.b') self.chkpath(w, w.c, '%s.c') self.chkpath(w, w.d, '%s.d') self.chkpath(w, w.e, "%s.__dict__['e']") class R(object): rvar = [] class S(R, T): svar = [] s = S() s.a = a s.b = b s.c = c self.chkrelattr(s, '__dict__', 'a', 'b', 'c') self.chkpath(s, s.a, '%s.a') self.chkpath(s, s.b, '%s.b') self.chkpath(s, s.c, "%s.__dict__['c']") # Class variables are not directly related- should they be that? # Possibly, but the compression could as well be done in Python. # We just check that we can get the path. self.chkpath(s, s.svar, "%s->ob_type.__dict__['svar']") self.chkpath(s, s.rvar, ["%s->ob_type.__bases__[0].__dict__['rvar']", "%s->ob_type.__mro__[1].__dict__['rvar']"]) self.chkpath(s, s.__slots__, "%s->ob_type.__base__.__dict__['__slots__']") def test_traceback_relation(self): import sys try: def g(): 1/0 g() except ZeroDivisionError: type, value, traceback = sys.exc_info() self.chkrelattr(traceback, 'tb_next', 'tb_frame') def test_tuple_relation(self): v1 = 'v1' v2 = 'v2' v3 = list(range(100, 200)) x = (v1, v2, v3) self.chkrel(x, v1, '%s[0]') self.chkrel(x, v2, '%s[1]') self.chkrel(x, v3, '%s[2]') def test_type_relation(self): name = 'T' base = object bases = (base,) dict = {'__slots__': ('a', 'b')} T = type(name, bases, dict) # tp_dict can't be directly tested since .__dict__ returns a proxy # and the dict passed is not used directly. # We test it indirectly by getting a path through it. self.chkpath(T, T.a, "%s.__dict__['a']") # The C-struct __slots__ field can't be tested directly # This just tests the ordinary attribute self.chkpath(T, T.__slots__, "%s.__dict__['__slots__']") self.chkrelattr(T, '__mro__', '__base__', '__bases__') # tp_cache and tp_subclasses can also not be tested directly # Inheritance is tested via test_object_relation() class RootTestCase(TestCase): def test_1(self): import sys import builtins root = self.View.root # Interpreter attributes rel = str(self.relation(root, sys.modules)) self.assertTrue(eval(rel % 'root') is sys.modules) self.aseq(rel, '%s.i0_modules') rel = str(self.relation(root, sys.__dict__)) self.assertTrue(eval(rel % 'root') is sys.__dict__) self.aseq(rel, '%s.i0_sysdict') rel = str(self.relation(root, builtins.__dict__)) self.assertTrue(eval(rel % 'root') is builtins.__dict__) self.aseq(rel, '%s.i0_builtins') for name in "codec_search_path", "codec_search_cache", "codec_error_registry": attr = "i0_%s" % name rel = str(self.relation(root, getattr(root, attr))) self.aseq(rel, '%%s.%s' % attr) # Thread attributes try: 1/0 except ZeroDivisionError: exc_type, exc_value, exc_traceback = sys.exc_info() if sys.version_info >= (3, 11): rel = str(self.relation(root, exc_value)) self.asis(eval(rel % 'root'), exc_value) else: for name in 'exc_type', 'exc_value', 'exc_traceback': rel = str(self.relation(root, eval(name))) self.asis(eval(rel % 'root'), eval(name)) # There are more, untested, attributes, but the code is farily regular... # More complication is to do with frames which I concentrate on for now. # We need to find out what level we are at - count to lowest frame level = 0 frame = exc_traceback.tb_frame while frame.f_back: frame = frame.f_back level += 1 rel = str(self.relation(root, frame)) self.assertTrue(rel.endswith('_f0')) rel = str(self.relation(root, exc_traceback.tb_frame)) self.asis(eval(rel % 'root'), exc_traceback.tb_frame) self.assertTrue(rel.endswith('_f%d' % level)) def test_thread(self): try: import _thread except ImportError: print('threading not enabled - skipping test') return root = self.View.root def task(self): import sys try: 1/0 except ZeroDivisionError: exc_type, exc_value, exc_traceback = sys.exc_info() self.exc_value = exc_value self.sync = 1 while self.sync: pass self.sync = 1 self.sync = 0 _thread.start_new_thread(task, (self,)) while not self.sync: pass exc_value = self.exc_value rel = str(self.relation(root, exc_value)) self.asis(eval(rel % 'root'), exc_value) self.sync = 0 while not self.sync: pass def task(self): self.test_1() self.sync = 1 self.sync = 0 _thread.start_new_thread(task, (self,)) while not self.sync: pass def test_secondary_interpreter(self): import sys if sys.version_info >= (3, 9): print('multi-interpreter not supported past Python 3.9') return try: import _thread except ImportError: print('threading not enabled - skipping test') return import_remote = """\ import sys import _thread import time def task(): time.sleep(1) self.sysdict = sys.__dict__ self.sync = 1 while self.sync: pass _thread.start_new_thread(task, ()) """ self.sync = 0 thid = self.heapy.heapyc.interpreter(import_remote, {'self': self}) root = self.View.root import sys sysdict = sys.__dict__ rel = str(self.relation(root, sysdict)) self.aseq(rel, '%s.i0_sysdict') while not self.sync: pass rel = str(self.relation(root, self.sysdict)) self.aseq(rel, '%s.i1_sysdict') self.sync = 0 class PathTestCase(TestCase): def makegraph(self, width, length): # Generate a structure which will yield a high number # of shortest paths. # Returns a pair src, dst which are connected via a noncyclic graph # with many edges. # The length of each path (all shortest), number of edges will be length # The number of nodes will be 2 + width * (length - 1) # The number of paths will be # width ** length, if width >= 1 and length >= 1 dst = [] ls = [] for i in range(width): ls.append([dst]) ls = [dst] * width for i in range(length-1): xs = [] for j in range(width): ys = [] xs.append(ys) for k in range(width): ys.append(ls[k]) ls = xs src = ls return src, dst def chkgraph(self, width, length, expect=None): src, dst = self.makegraph(width, length) self.chkpath(src, dst, expect) def test_path(self): dst = 'dst' self.chkpath([dst], dst, '%s[0]') self.chkpath([[], dst], dst, '%s[1]') self.chkpath([dst, dst], dst, "['%s[0]', '%s[1]']") self.chkpath([[dst, 0], dst, [dst, 2]], dst, "%s[1]") self.chkpath([[dst, 0], [dst, 2]], dst, "['%s[0][0]', '%s[1][0]']") src, dst = self.makegraph(1, 1) self.chkgraph(1, 1, '%s[0]') self.chkgraph(1, 2, '%s[0][0]') self.chkgraph(2, 1, ['%s[0]', '%s[1]']) self.chkgraph(3, 2, ['%s[0][0]', '%s[0][1]', '%s[0][2]', '%s[1][0]', '%s[1][1]', '%s[1][2]', '%s[2][0]', '%s[2][1]', '%s[2][2]']) def test_numpaths(self): for (width, length) in [(2, 1), (7, 3), (3, 7), (10, 20)]: src, dst = self.makegraph(width, length) p = self.shpaths(dst, src) self.aseq(p.numpaths, width*length) def test_iter(self): src, dst = self.makegraph(2, 2) p = self.shpaths(dst, src) it = iter(p) ss = [] for i in it: ss.append(str(i)) ss.sort() self.aseq(ss, ['%s[0][0]', '%s[0][1]', '%s[1][0]', '%s[1][1]']) # Check that we can get some of the first values from the iterator # of a graph with an astronomical number of paths. width = 11 length = 13 numpaths = 20 src, dst = self.makegraph(width, length) p = self.shpaths(dst, src) it = iter(p) for i in range(numpaths): path = next(it) sp = str(path) div, mod = divmod(i, width) self.aseq(sp, '%s'+'[0]'(length-2)+'[%d][%d]' % (div, mod)) # Check that the iterator works even if the graph initially # would yield astronomical numbers of dead ends. # (The initial algorithm took astronomically long time.) osrc = src src, dst = self.makegraph(width, length) src[0] = osrc p = self.shpaths(dst, src) it = iter(p) for i in range(numpaths): path = next(it) sp = str(path) div, mod = divmod(i, width) self.aseq(sp, '%s[1]'+'[0]'(length-3)+'[%d][%d]' % (div, mod)) # Test iterating with a negative start and a large positive start numfromend = width / 2 for it in [p.iter(-numfromend), p.iter(p.numpaths-numfromend)]: for i, path in enumerate(it): sp = str(path) self.aseq(sp, '%s'+('[%d]' % (width-1)) (length-1)+'[%d]' % (width-numfromend+i)) # Test iterating with start and stop start = 5 stop = 25 i = start for path in p.iter(start, stop): sp = str(path) div, mod = divmod(i, width) self.aseq(sp, '%s[1]'+'[0]'(length-3)+'[%d][%d]' % (div, mod)) self.aseq(path.index, i) i += 1 self.aseq(i, stop) def test_str(self): # Make sure large number of paths will yield reasonable representations width = 11 length = 4 src, dst = self.makegraph(width, length) p = self.shpaths(dst, src) p.maxpaths = 1 self.aseq(str(p), " 0: Src[0][0][0][0]\n<... 14640 more paths ...>") p.maxpaths = 2 self.aseq( str(p), " 0: Src[0][0][0][0]\n 1: Src[0][0][0][1]\n<... 14639 more paths ...>") def test_printing(self): # Test the pretty-printing and moreing methods from io import StringIO output = StringIO() self.Path.output = output width = 11 length = 4 src, dst = self.makegraph(width, length) p = self.shpaths(dst, src) p.maxpaths = 2 self.aseq(str(p), """\ 0: Src[0][0][0][0] 1: Src[0][0][0][1] <... 14639 more paths ...>""") self.aseq(str(p.more), """\ 2: Src[0][0][0][2] 3: Src[0][0][0][3] <... 14637 more paths ...>""") def test_subscript(self): # Test subscripting width = 3 length = 40 src, dst = self.makegraph(width, length) p = self.shpaths(dst, src) np = widthlength self.aseq(np, p.numpaths) # p[0].pp(p.output) self.aseq(str(p[0]), '%s'+'[0]'length) self.aseq(str(p[-np]), '%s'+'[0]'length) self.aseq(str(p[width-1]), '%s'+'[0]'(length-1) + '[%d]' % (width-1)) self.aseq(str(p[width]), '%s'+'[0]'(length-2) + '[1][0]') self.aseq(str(p[width+1]), '%s'+'[0]'(length-2) + '[1][1]') self.aseq(str(p[np-1]), '%s'+('[%d]' % (width-1))length) self.aseq(str(p[-1]), '%s'+('[%d]' % (width-1))length) self.assertRaises(IndexError, lambda: p[np]) self.assertRaises(IndexError, lambda: p[-np-1]) class MultiTestCase(TestCase): def test_pp(self): # Test printing of multi relations iso = self.iso dst = [[], []] src = iso(dst[:]2) dst = [iso(x) for x in dst] p = self.Path.shpgraph(dst, src) self.aseq(str(p), """\ --- Dst[0] --- 0: Src[0] 1: Src[2] --- Dst[1] --- 0: Src[1] 1: Src[3]""") p = self.Path.shpgraph(dst, src, srcname='A', dstname='B') self.aseq(str(p), """\ --- B[0] --- 0: A[0] 1: A[2] --- B[1] --- 0: A[1] 1: A[3]""") class AvoidTestCase(TestCase): def test_1(self): # Test that we can find new paths by avoiding edges # selected from previously found paths. # First we generate a graph with paths of various lengths... src = ['src'] a = src for i in range(3): b = ['b%d' % i] c = ['c%d' % i, b] a.append(b) a.append(c) a = b dst = a p = self.shpaths(dst, src) for avoid, result in [ ([], '%s[1][1][1]'), ([0], '%s[2][1][1][1]'), ([1], '%s[1][2][1][1]'), ([2], '%s[1][1][2][1]'), ([0, 1], '%s[2][1][2][1][1]'), ([1, 2], '%s[1][2][1][2][1]'), # ([1, -1], '%s[1][2][1][2][1]'), ([0, 2], '%s[2][1][1][2][1]'), ([0, 1, 2], '%s[2][1][2][1][2][1]'), ([2, 1, 0], '%s[2][1][2][1][2][1]'), ]: result = result % ' 0: Src' # Find new path by avoiding edges from the original path q = self.shpaths(dst, src, avoid_edges=p.edges_at(avoid)) self.aseq(str(q), result) # Find the same path but via a direct method q = p.copy_but_avoid_edges_at_levels(avoid) self.aseq(str(q), result) # The same, but via a shorter method name q = p.avoided(avoid) self.aseq(str(q), result) # Test that the avoided set is carried on to copies q = p.avoided(0).avoided(2) self.aseq(str(q), ' 0: Src[2][1][2][1][1]') class NewTestCase(TestCase): def test_1(self): import sys o = self.python.io.StringIO() iso = self.iso x = iso(sys.__dict__) print(x.shpaths, file=o) # This used to include a path via parameter avoid_edges # which was confusing print(x.shpaths.avoided(0), file=o) # repr() used to be quite useless. I have it now defined as .pp(), # but without trailin newline. print(repr(x.shpaths), file=o) print(repr(x.shpaths), file=o) # The shpaths object could sometimes disturb a shpath calculation # because dst was free in it. x = [] y = [[[x]]] sp = iso(x).get_shpaths(iso(y)) print(sp, file=o) y.append(sp) print(iso(x).get_shpaths(iso(y)), file=o) # Test that the shortest paths to a set of objects, is the shortest # paths to those that can be reached by the shortest paths, only x = [] y = [x] z = [y] print(iso(x, y).get_shpaths(iso(z)), file=o) # Test that we can relate objects that inherits from a class and object # (Used to segfault) class C: pass class O(C, object): __slots__ = 'x', ob = O() ob.x = x print(iso(x).get_shpaths(iso(ob)), file=o) # Test that generalization to a set of sources makes some sense # The shortest paths are from the closest sources # Hack to make a constant address rendering, for test comparison. # This doesn't change anything permanently. # XXX come up with an official way to do this. summary_str = self.heapy.UniSet.summary_str def str_address(x): return '<address>' str_address._idpart_header = getattr( summary_str.str_address, '_idpart_header', None) str_address._idpart_sortrender = getattr( summary_str.str_address, '_idpart_sortrender', None) summary_str.str_address = str_address S = iso() shp = iso(x).get_shpaths(iso(y, z)) print(shp, file=o) print(repr(shp), file=o) for p in shp: S = S ^ p.src self.aseq(S, iso(y)) shp = iso(x).get_shpaths(iso(ob, y, z)) print(str(shp), file=o) print(repr(shp), file=o) S = iso() for i, p in enumerate(shp): S = S ^ p.src self.aseq(p.src, shp[i].src) self.aseq(S, iso(ob, y)) # Test that the iter can be restarted # even after multiple sources handling was added it = iter(shp) a = list(it) it.isatend = 0 b = list(it) self.aseq(str(a), str(b)) # The sort order is based on the source set's byid partition (see # Path.PathsIter.reset), which sorts based on the size, then render # (see Part.IdentityPartition.__init__) if sys.getsizeof(y) > sys.getsizeof(ob): self.aseq(o.getvalue(), """\ 0: hpy().Root.i0_sysdict 0: Src.i0_modules['sys'].__dict__ 0: hpy().Root.i0_sysdict 0: hpy().Root.i0_sysdict 0: Src[0][0][0] 0: Src[0][0][0] 0: Src[0] 0: Src.x 0: <1 list: <address>1>[0] 0: <1 list: <address>1>[0] 0: <1 list: <address>1>[0] 1: <1 __main__.O: <address>>.x 0: <1 list: <address>1>[0] 1: <1 __main__.O: <address>>.x """.replace('__main__', self.__module__)) else: self.aseq(o.getvalue(), """\ 0: hpy().Root.i0_sysdict 0: Src.i0_modules['sys'].__dict__ 0: hpy().Root.i0_sysdict 0: hpy().Root.i0_sysdict 0: Src[0][0][0] 0: Src[0][0][0] 0: Src[0] 0: Src.x 0: <1 list: <address>1>[0] 0: <1 list: <address>1>[0] 0: <1 __main__.O: <address>>.x 1: <1 list: <address>1>[0] 0: <1 __main__.O: <address>>.x 1: <1 list: <address>1>[0] """.replace('__main__', self.__module__)) def test_2(self): # To assist interactivity, # the more attribute is defined to return an object which # the repr() of gives more lines; and has a similar more attribute. # Testing this functionality here. o = self.python.io.StringIO() iso = self.iso dst = [] src = [dst]20 print(repr(iso(dst).get_shpaths(iso(src))), file=o) print(repr(iso(dst).get_shpaths(iso(src)).more), file=o) p = iso(dst).get_shpaths(iso(src)) print(repr(p.more), file=o) self.aseq(o.getvalue(), """\ 0: Src[0] 1: Src[1] 2: Src[2] 3: Src[3] 4: Src[4] 5: Src[5] 6: Src[6] 7: Src[7] 8: Src[8] 9: Src[9] <... 10 more paths ...> 10: Src[10] 11: Src[11] 12: Src[12] 13: Src[13] 14: Src[14] 15: Src[15] 16: Src[16] 17: Src[17] 18: Src[18] 19: Src[19] 10: Src[10] 11: Src[11] 12: Src[12] 13: Src[13] 14: Src[14] 15: Src[15] 16: Src[16] 17: Src[17] 18: Src[18] 19: Src[19] """) def test_empty(self): # Test empty paths iso = self.iso dst = [] self.assertTrue(len(list(iso(dst).get_shpaths(iso()))) == 0) def test_3(self): # Test that Edges is not included in the shortest path iso = self.iso dst = [] shp = iso(dst).shpaths del dst self.assertTrue('Edges' not in str(shp.avoided(0))) dst = [] src = [dst] shp = iso(dst).get_shpaths(iso(src)) src[0] = shp dst = iso(dst) src = iso(src) self.assertTrue(dst.get_shpaths(src).numpaths == 0) # Test the sets attribute dst = [] src = [dst] dst = iso(dst) src = iso(src) self.aseq(dst.get_shpaths(src).sets, (src, dst)) # Test that srs doesn't disturb the path calculation class C: pass c = C() cd = iso(c.__dict__) p = cd.shpaths repr(p) del c q = cd.shpaths self.aseq(repr(q).strip(), "") del p, q # Test that internals of ShortestPath are hidden in general # (via hiding_tag), to consistent result when used interactively, # as commented on in notes.txt per Nov 30 2004. dst = [] src = [[[[dst]]]] d = iso(dst) s = iso(src) p = d.get_shpaths(s) self.aseq(str(p), " 0: Src[0][0][0][0]") src.append(p) p._XX_ = dst # A shorter path, but it should be hidden self.aseq(str(d.get_shpaths(s)), " 0: Src[0][0][0][0]") # Test what .more prints finally self.aseq(str(p.more), '<No more paths>') # Test that .top is idempotent self.asis(p.more.top.top, p) def test_4(self): # Test that if one extra path will be printed if there are # exactly 11 paths iso = self.iso o = self.python.io.StringIO() dst = [] src = [dst] 11 shp = iso(dst).get_shpaths(iso(src)) print(str(shp), file=o) self.aseq(o.getvalue(), """\ 0: Src[0] 1: Src[1] 2: Src[2] 3: Src[3] 4: Src[4] 5: Src[5] 6: Src[6] 7: Src[7] 8: Src[8] 9: Src[9] 10: Src[10] """) def test_comparison(self): # Test that non-compariable keys won't crash # output order may be arbitrary not the output is not tested iso = self.iso dst = [] shp = iso(dst).get_shpaths(iso({0: dst, '': dst})) str(shp) shp = iso(dst).get_shpaths(iso({object(): dst, object(): dst})) str(shp) def run_test(case, debug=0): support.run_unittest(case, debug) def test_main(debug=0): run_test(NewTestCase, debug) run_test(RelationTestCase, debug) run_test(RootTestCase, debug) run_test(PathTestCase, debug) run_test(MultiTestCase, debug) run_test(AvoidTestCase, debug) if __name__ == "__main__": test_main()	28.82 KB	2026-01-20 12:58
📄 test_RefPat.py from guppy.heapy.test import support import io import sys import types import unittest class TestCase(support.TestCase): def setUp(self): support.TestCase.setUp(self) self.RefPat = self.heapy.RefPat self.iso = self.Use.iso def makegraph(self, width, length): # Generate a structure which will yield a high number # of shortest paths. # Returns a pair src, dst which are connected via a noncyclic graph # with many edges. # The length of each path (all shortest), number of edges will be length # The number of nodes will be 2 + width * (length - 1) # The number of paths will be # width ** length, if width >= 1 and length >= 1 dst = [] ls = [] for i in range(width): ls.append([dst]) ls = [dst] * width for i in range(length-1): xs = [] for j in range(width): ys = [] xs.append(ys) for k in range(width): ys.append(ls[k]) ls = xs src = ls return src, dst def rp(self, dst, src, kwds): iso = self.iso if src is not None: src = iso(src) rp = iso(dst).get_rp(src=src, kwds) rp.mod.UniSet.summary_str.str_address = lambda a: '<address>' return rp class RefPatCase(TestCase): def test_basic_methods(self): # Test basic methods: iteration, indexing, length, tree addressing via attribute access # Test iteration dst = src = [] lists = [dst] for i in range(5): src = [src] lists.append(src) rp = self.rp(dst, src, depth=10) for i, x in enumerate(rp): if i < len(lists): self.asis(lists[i], x.theone) # Test indexing # First case, when already iterated over self.asis(rp[0].theone, lists[0]) self.asis(rp[-2].theone, lists[-1]) # Second case, when not iterated over before rp = self.rp(dst, src, depth=10) self.asis(rp[0].theone, lists[0]) self.asis(rp[-2].theone, lists[-1]) # Test length self.aseq(len(rp), len(lists) + 1) rp = self.rp(dst, src, depth=10) self.aseq(len(rp), len(lists) + 1) # Test attribute access self.asis(rp._.theone, lists[0]) self.asis(rp.a.theone, lists[1]) # Test attribute access, when not iterated over before rp = self.rp(dst, src, depth=10) self.asis(rp.a2.theone, lists[2]) self.asis(rp.a.theone, lists[1]) # Make sure attribute access is cached: # so it doesn't change when struct is changed lists[2].append(lists[0]) rp.View.clear_retainers() rp.View.update_referrers(self.iso(lists[0])) self.asis(rp.a.theone, lists[1]) # Test with recursive structure dst = [] dst.append(dst) src = [dst] rp = self.rp(dst, src) self.asis(rp._.theone, dst) self.aseq(rp.a, self.iso(dst, src)) self.aseq(rp.a, rp.a2) self.aseq(rp.a, rp[1]) def test_presentation(self): output = io.StringIO() src = [] def write(x): print(x, file=output) R = self.RefPat def test_pp(dst, src, result=None, kwds): rp = self.rp(dst, src, kwds) write(repr(rp)) return rp dst = [] src.append(dst) test_pp(dst, src) for i in range(5): x = dst dst = [] x.append(dst) test_pp(dst, src) src, dst = self.makegraph(5, 7) test_pp(dst, src, depth=10) # Test that pp() prints limited number of lines src, dst = self.makegraph(5, 17) rp = test_pp(dst, src, depth=17) write(repr(rp.more)) # Test more of more src, dst = self.makegraph(1, 30) rp = test_pp(dst, src, depth=35) m = rp.more write(repr(m)) write(repr(m.more)) m1 = m.more write(repr(m1)) m2 = m.more write(repr(m2.more)) write(str(m1.more)) # Test also that str() is the same as repr() # Test that we get back to start by .top write(m1.top) # Test that we get back to previous by .prev write(m1.prev) # Test that they won't say '...more lines...' if the # of lines is what is printed src, dst = self.makegraph(1, 30) rp = test_pp(dst, src, depth=10) # Test how no more lines is printed write(rp.more) write(rp.more.more) # Test that one more line is printed rather than '1 more line' src, dst = self.makegraph(1, 30) rp = test_pp(dst, src, depth=21) write(rp.more) # Test that we can do more without first printing rp = self.rp(dst, src, depth=20) write(rp.more) self.aseq(output.getvalue(), """\ Reference Pattern by <[dict of] class>. 0: _ --- [-] 1 list: <address>0 1: a [-] 1 list: <address>1 2: aa ---- [R] 1 tuple: <address>1 Reference Pattern by <[dict of] class>. 0: _ --- [-] 1 list: <address>0 1: a [-] 1 list: <address>1 2: aa ---- [-] 1 list: <address>1 3: a3 [-] 1 list: <address>1 4: a4 ------ [-] 1 list: <address>1 5: a5 [-] 1 list: <address>1 6: a6 -------- [-] 1 list: <address>1 7: a7 [R] 1 tuple: <address>1 Reference Pattern by <[dict of] class>. 0: _ --- [-] 1 list: <address>0 1: a [-] 5 list: <address>5, <address>5, <address>5, <address>5... 2: aa ---- [-] 5 list: <address>5, <address>5, <address>5, <address>5... 3: a3 [-] 5 list: <address>5, <address>5, <address>5, <address>5... 4: a4 ------ [-] 5 list: <address>5, <address>5, <address>5, <address>5... 5: a5 [-] 5 list: <address>5, <address>5, <address>5, <address>5... 6: a6 -------- [-] 5 list: <address>5, <address>5, <address>5... 7: a7 [-] 1 list: <address>5 8: a8 ---------- [R] 1 tuple: <address>1 Reference Pattern by <[dict of] class>. 0: _ --- [-] 1 list: <address>0 1: a [-] 5 list: <address>5, <address>5, <address>5, <address>5... 2: aa ---- [-] 5 list: <address>5, <address>5, <address>5, <address>5... 3: a3 [-] 5 list: <address>5, <address>5, <address>5, <address>5... 4: a4 ------ [-] 5 list: <address>5, <address>5, <address>5, <address>5... 5: a5 [-] 5 list: <address>5, <address>5, <address>5, <address>5... 6: a6 -------- [-] 5 list: <address>5, <address>5, <address>5... 7: a7 [-] 5 list: <address>5, <address>5, <address>5... 8: a8 ---------- [-] 5 list: <address>5, <address>5, <address>5... 9: a9 [-] 5 list: <address>5, <address>5, <address>5... <Type e.g. '_.more' for more.> 10: a10 ----------- [-] 5 list: <address>5, <address>5, <address>5... 11: a11 [-] 5 list: <address>5, <address>5, <address>5... 12: a12 ------------- [-] 5 list: <address>5, <address>5, <address>5... 13: a13 [-] 5 list: <address>5, <address>5, <address>5... 14: a14 --------------- [-] 5 list: <address>5, <address>5, <address>5... 15: a15 [-] 5 list: <address>5, <address>5, <address>5... 16: a16 ----------------- [-] 5 list: <address>5, <address>5, <address>5... 17: a17 [+] 1 list: <address>5 Reference Pattern by <[dict of] class>. 0: _ --- [-] 1 list: <address>0 1: a [-] 1 list: <address>1 2: aa ---- [-] 1 list: <address>1 3: a3 [-] 1 list: <address>1 4: a4 ------ [-] 1 list: <address>1 5: a5 [-] 1 list: <address>1 6: a6 -------- [-] 1 list: <address>1 7: a7 [-] 1 list: <address>1 8: a8 ---------- [-] 1 list: <address>1 9: a9 [-] 1 list: <address>1 <Type e.g. '_.more' for more.> 10: a10 ----------- [-] 1 list: <address>1 11: a11 [-] 1 list: <address>1 12: a12 ------------- [-] 1 list: <address>1 13: a13 [-] 1 list: <address>1 14: a14 --------------- [-] 1 list: <address>1 15: a15 [-] 1 list: <address>1 16: a16 ----------------- [-] 1 list: <address>1 17: a17 [-] 1 list: <address>1 18: a18 ------------------- [-] 1 list: <address>1 19: a19 [-] 1 list: <address>1 <Type e.g. '_.more' for more.> 20: a20 --------------------- [-] 1 list: <address>1 21: a21 [-] 1 list: <address>1 22: a22 ----------------------- [-] 1 list: <address>1 23: a23 [-] 1 list: <address>1 24: a24 ------------------------- [-] 1 list: <address>1 25: a25 [-] 1 list: <address>1 26: a26 --------------------------- [-] 1 list: <address>1 27: a27 [-] 1 list: <address>1 28: a28 ----------------------------- [-] 1 list: <address>1 29: a29 [-] 1 list: <address>1 <Type e.g. '_.more' for more.> 20: a20 --------------------- [-] 1 list: <address>1 21: a21 [-] 1 list: <address>1 22: a22 ----------------------- [-] 1 list: <address>1 23: a23 [-] 1 list: <address>1 24: a24 ------------------------- [-] 1 list: <address>1 25: a25 [-] 1 list: <address>1 26: a26 --------------------------- [-] 1 list: <address>1 27: a27 [-] 1 list: <address>1 28: a28 ----------------------------- [-] 1 list: <address>1 29: a29 [-] 1 list: <address>1 <Type e.g. '_.more' for more.> 30: a30 ------------------------------- [-] 1 list: <address>1 31: a31 [R] 1 tuple: <address>1 30: a30 ------------------------------- [-] 1 list: <address>1 31: a31 [R] 1 tuple: <address>1 Reference Pattern by <[dict of] class>. 0: _ --- [-] 1 list: <address>0 1: a [-] 1 list: <address>1 2: aa ---- [-] 1 list: <address>1 3: a3 [-] 1 list: <address>1 4: a4 ------ [-] 1 list: <address>1 5: a5 [-] 1 list: <address>1 6: a6 -------- [-] 1 list: <address>1 7: a7 [-] 1 list: <address>1 8: a8 ---------- [-] 1 list: <address>1 9: a9 [-] 1 list: <address>1 <22 more lines. Type e.g. '_.more' for more.> 10: a10 ----------- [-] 1 list: <address>1 11: a11 [-] 1 list: <address>1 12: a12 ------------- [-] 1 list: <address>1 13: a13 [-] 1 list: <address>1 14: a14 --------------- [-] 1 list: <address>1 15: a15 [-] 1 list: <address>1 16: a16 ----------------- [-] 1 list: <address>1 17: a17 [-] 1 list: <address>1 18: a18 ------------------- [-] 1 list: <address>1 19: a19 [-] 1 list: <address>1 <12 more lines. Type e.g. '_.more' for more.> Reference Pattern by <[dict of] class>. 0: _ --- [-] 1 list: <address>0 1: a [-] 1 list: <address>1 2: aa ---- [-] 1 list: <address>1 3: a3 [-] 1 list: <address>1 4: a4 ------ [-] 1 list: <address>1 5: a5 [-] 1 list: <address>1 6: a6 -------- [-] 1 list: <address>1 7: a7 [-] 1 list: <address>1 8: a8 ---------- [-] 1 list: <address>1 9: a9 [-] 1 list: <address>1 10: a10 ----------- [+] 1 list: <address>1 Reference Pattern by <[dict of] class>. 0: _ --- [-] 1 list: <address>0 1: a [-] 1 list: <address>1 2: aa ---- [-] 1 list: <address>1 3: a3 [-] 1 list: <address>1 4: a4 ------ [-] 1 list: <address>1 5: a5 [-] 1 list: <address>1 6: a6 -------- [-] 1 list: <address>1 7: a7 [-] 1 list: <address>1 8: a8 ---------- [-] 1 list: <address>1 9: a9 [-] 1 list: <address>1 <Type e.g. '_.more' for more.> 10: a10 ----------- [-] 1 list: <address>1 11: a11 [-] 1 list: <address>1 12: a12 ------------- [-] 1 list: <address>1 13: a13 [-] 1 list: <address>1 14: a14 --------------- [-] 1 list: <address>1 15: a15 [-] 1 list: <address>1 16: a16 ----------------- [-] 1 list: <address>1 17: a17 [-] 1 list: <address>1 18: a18 ------------------- [-] 1 list: <address>1 19: a19 [-] 1 list: <address>1 <Type e.g. '_.more' for more.> 10: a10 ----------- [-] 1 list: <address>1 11: a11 [-] 1 list: <address>1 12: a12 ------------- [-] 1 list: <address>1 13: a13 [-] 1 list: <address>1 14: a14 --------------- [-] 1 list: <address>1 15: a15 [-] 1 list: <address>1 16: a16 ----------------- [-] 1 list: <address>1 17: a17 [-] 1 list: <address>1 18: a18 ------------------- [-] 1 list: <address>1 19: a19 [-] 1 list: <address>1 20: a20 --------------------- [+] 1 list: <address>1 """) def test_referrer_registration(self): import gc # The reference pattern should register itself as referrer target # so that after a gc, the rp target will still be included in the referrer target # Since the target is passed to referrers and update, it will still find the # referrers. It is an optimization issue: it should cover the referrers. # We test this by having two different-typed referrers # Accessing a referrer of the first one, then gc collecting, then checking that # the second one can be accessed without update: it was created automatically. # The test failed when not registering, but succeeded when registering was added. # It succeeds any case if no GC collection is made. dst = [] a = [dst] aa = [a] b = (dst,) ba = [b] src = [aa, ba] rp = self.rp(dst, src) self.asis(rp._.theone, dst) gc.collect() self.asis(rp.aa.theone, aa) self.asis(rp.View.rg[b][0], ba) def test_some_more_advanced_usages(self): import gc # Test immediate dominators dst = [] src = [dst] src.append([dst]) rp = self.rp(dst, src, depth=10, imdom=1) self.asis(rp._.theone, dst) self.asis(rp.a.theone, src) # Test with mixed types # In particular, dict owned by an instance dst = [] class A: pass a = A() a.dst = dst b = {'dst': dst} src = (a, b) gc.collect() rp = self.rp(dst, src, depth=10) rp.mod.View._is_clear_drg_enabled = 0 # Note Apr 19 2005 if sys.getsizeof(b) > sys.getsizeof(a.__dict__): self.asis(rp.a.theone, b) self.asis(rp.b.theone, a.__dict__) else: self.asis(rp.a.theone, a.__dict__) self.asis(rp.b.theone, b) # Test that the dict is eventually automatically removed from dictowners - # First test that dictowners is nonzero ln = len(rp.mod.View.dict_ownership) self.assertTrue(ln > 0) del src del a mod = rp.mod rp.mod.View._is_clear_drg_enabled = 1 del rp # It is cleared after GC gc.collect() lnnow = len(mod.View.dict_ownership) self.assertTrue(lnnow == 0) class NewCase(TestCase): # Some new tests as they come up def test_reset(self): # Test the .reset() method dst = [] a = [dst] b = [dst] src = [a, b] rp = self.rp(dst, src) self.aseq(rp.a, self.iso(a, b)) b.pop() rp.reset() self.aseq(rp.a, self.iso(a)) def test_paths(self): # Test the .paths() method dst = [] a = [dst]+[None]40 # Make order well-defined. Note May 2 2005. b = [dst] src = [a, b] rp = self.rp(dst, src) expected = """\ Paths from source 'a3' to target '_'. 0: a3 [0] @ [0] 1: aa [0] @ [0] 2: a [0] @ [0] 3: _ [0] = <1 list: <address>0> 4: aa [0] @ [1] 5: a [1] @ [0] -> #3""" self.aseq(str(rp.paths('a3')), expected) expected = expected[:expected.index('\n 4:')] # Test the andsets argument, given as a dict self.aseq(str(rp.paths('a3', andsets={'a': self.iso(a)})), expected) # Test the andsets argument, given as a list self.aseq( str(rp.paths('a3', andsets=[None, None, self.iso(a)])), expected) def test_main(debug=0): support.run_unittest(RefPatCase, debug) support.run_unittest(NewCase, debug) def test_leak(): # Runs the tests in a loop and prints memory statistics, # to see if there are underlying low-level memory problems. # Requires Python to be compiled with debug support. from guppy.heapy.heapyc import xmemstats import gc import sys import time i = 0 xmemstats() while 1: print('[%d]' % i, time.asctime()) i += 1 test_main() gc.collect() xmemstats() if __name__ == "__main__": test_main()	16.75 KB	2026-01-20 12:58
📄 test_RetaGraph.py from guppy.heapy.test import test_support import sys import unittest from pprint import pprint	95 B	2026-01-20 12:58
📄 test_Spec.py from guppy.heapy.test import support import sys import unittest class TestCase(support.TestCase): pass class FirstCase(TestCase): def test_1(self): Spec = self.heapy.Spec TestEnv = Spec.mkTestEnv(Spec._Specification_) TestEnv.test_contains(Spec) if __name__ == "__main__": support.run_unittest(FirstCase, 1)	351 B	2026-01-20 12:58
📄 test_UniSet.py from guppy.heapy.test import support class FirstCase(support.TestCase): def setUp(self): support.TestCase.setUp(self) def test_1(self): asrt = self.assertTrue a = [] b = [] c = self.iso(a, b) asrt(len(c.nodes) == 2) asrt(a in c) asrt(b in c) asrt([] not in c) asrt(c not in c) d = self.idset(c.nodes) asrt(c.nodes == d.nodes) asrt(c == d) def test_2(self): # Test standard set operations H = self.idset e1 = [] e2 = {} e3 = () la = [], [e1], [e1, e2], [e1, e2, e3], [e2], [e2, e3], [e3] self.guppy.sets.test.test_set_operations( [H(x) for x in la], [H(x) for x in la], [H(x) for x in la]) def test_3(self): # Test out-reaching iso = self.iso a = [] b = [a] c = [b] self.View.root = c x = iso(b) self.assertTrue(x.referrers == iso(c)) self.aseq(x.referents, iso(a)) self.aseq(x.referents.referrers, x) self.aseq(x.dominos, iso(a, b)) def test_main(debug=False): support.run_unittest(FirstCase, debug) if __name__ == "__main__": test_main()	1.21 KB	2026-01-20 12:58
📄 test_View.py from guppy.heapy.test import support class TestCase(support.TestCase): def setUp(self): support.TestCase.setUp(self) self.types = self.heapy.UniSet.types class FirstCase(TestCase): def test_cal_hiding(self): V = self.View iso = self.iso # Tests that our workspace nodesets are hidden. a = [] b = [] as_ = iso(a) bs = iso(b) ab = as_ \| bs # Make sure hiding is carried on with set operations self.assertTrue(ab.referrers.kind == self.types.FrameType) self.assertTrue((as_ \| bs).referrers.kind == self.types.FrameType) self.assertTrue(V.referrers(iso(a)).kind == self.types.FrameType) self.assertTrue(V.referrers(iso(b)).kind == self.types.FrameType) # Test that we can still see nodesets created with other hiding_tag c = [] chold = self.guppy.sets.immnodeset( [c], hiding_tag=[] # Make sure we see it whether or not View uses default or not ) cs = iso(c) del c self.assertTrue(cs.referrers.kind == type( self.guppy.sets.immnodeset())) h = self.View.heap() self.aseq(h & self.iso(self.Use), self.Use.Nothing) self.aseq(h & self.iso(self.Use.__dict__), self.Use.Nothing) def test_dominos(self): # Test dominos and domisize iso = self.iso x = [] y = [x, []] z = [y] self.aseq(iso(y).dominos, iso(y, y[1])) self.aseq(iso(y).domisize, iso(y, y[1]).indisize) self.aseq(iso(z).dominos, iso(z)) del y self.aseq(iso(z).dominos, iso(z, z[0], z[0][1])) def test_exports(self): # Test a few exports; the other defined in _unp_exports use the same mechanism iso = self.iso x = [] y = [x, []] z = [y] p = iso(z).referents.indisize self.aseq(p, iso(y).indisize) def test_horizon(self): iso = self.iso h = self.View.horizon() x = [] hn = h.news() self.aseq(hn, iso(x)) del hn hn = h.news() self.aseq(hn, iso(x)) del x, hn hn = h.news() self.aseq(hn, iso()) def test_imdom(self): iso = self.iso x = [] y = [x, []] z = [x, y] del x, y self.aseq(iso(z[0]).imdom, iso(z)) def test_referents(self): iso = self.iso x = [] y = [x, []] z = [y] self.aseq(iso(x).referents, iso()) self.aseq(iso(y).referents, iso(x, y[1])) self.aseq(iso(z).referents, iso(y)) self.aseq(iso(y, z).referents, iso(x, y, y[1])) def test_root(self): old_root = self.View.root self.assertIs(self.View.root, old_root) self.assertIs(self.Use.View.root, old_root) self.assertIs(self.View.hv.root, old_root) obj = object() self.View.root = obj self.assertIs(self.View.root, obj) self.assertIs(self.Use.View.root, obj) self.assertIs(self.View.hv.root, obj) self.View.root = old_root self.assertIs(self.View.root, old_root) self.assertIs(self.Use.View.root, old_root) self.assertIs(self.View.hv.root, old_root) class GCCase(TestCase): def test_gc_mechanism(self): # Test the underlying GC system for having the properties that # support the method of automatic reclamation of nodegraphs # that is relied on in other tests. Failure here, dependent on # changed GC behaviour, would explain the other failures. from weakref import ref import gc class C: pass c = C() cbs = [] def cb(wr): cbs.append(wr) wr = ref(c, cb) c.x = c gc.collect() strc = str(c) self.aseq(str(wr()), strc) self.asis(wr(), c) c = None self.aseq(str(wr()), strc) self.aseq(cbs, []) gc.collect() self.asis(wr(), None) self.aseq(cbs, [wr]) def test_gc_hook(self): # Test the GC hook as implemented in View hos = [] def ho(): hos.append(1) import gc gc.collect() hook = self.heapy.View.gchook(ho) self.aseq(hos, []) gc.collect() self.aseq(hos, [1]) hook = None gc.collect() self.aseq(hos, [1]) def test_gc_drg(self): # Test automatic reclamation issues for dict owner nodegraph # This mechanism changed so the old test here is # not valid anymore # FIXME MAKE NEW TEST return import gc View = self.View hv = View.hv drg = View.nodegraph() def clear_drg(): if drg.is_sorted: drg.clear() else: pass _clear_drg_hook = View.gchook(clear_drg) hv.update_dictowners(drg) gc.collect() lendrg = len(drg) self.assertTrue(lendrg > 0) # Before any use, it will not be cleared # Now it is used by taking its length gc.collect() self.aseq(len(drg), 0) byclodo = hv.cli_clodo(drg, {}) class C: pass c = C() byclodo.partition([c.__dict__]) self.assertTrue(len(drg) > 0) gc.collect() self.assertTrue(len(drg) == 0) def test_gc_rg(self): # Test automatic reclamation issues for referrer nodegraph iso = self.iso immnodeset = self.guppy.sets.immnodeset self.View.is_rg_update_all = False import gc gc.collect() dst = [] gc.collect() self.assertTrue(len(self.View.rg) == 0) # Test that rg is automatically updated with the set target(s) a = [dst] b = [dst] c = [a, b] class T: def __init__(self, set): self.set = set ta = T(iso(a)) self.View.referrers_add_target(ta) tb = T(iso(b)) self.View.referrers_add_target(tb) self.View.referrers(iso(c)) self.assertTrue(c in immnodeset(self.View.rg[a])) self.assertTrue(c in immnodeset(self.View.rg[b])) # Test that a referrers target is automatically collected when not referenced tb = None gc.collect() self.View.referrers(iso(c)) self.assertTrue(c in immnodeset(self.View.rg[a])) self.assertTrue(c not in immnodeset(self.View.rg[b])) # Test that adding a source automatically updates rg # even though domain of rg already includes its target # This requires gc collection d = [c] self.assertTrue(d not in self.View.referrers(iso(c))) gc.collect() self.assertTrue(d in self.View.referrers(iso(c))) class AltHeapCase(TestCase): # Tests for support of alternative heap as implemented around 27 Oct 2005 # and discussed in Notes at that time. def test_observation_containers(self): # Test the View.observation_containers method iso = self.iso idset = self.idset # These are to be included a = iso([], {}) b = self.ImpSet.mutnodeset() c = self.View.observation_list() # These are not to be included - have another hiding tag excla = self.guppy.sets.mutnodeset() exclb = self.guppy.sets.immnodeset() # Get possible containers oc = idset(self.View.observation_containers()) self.assertTrue(iso(a.nodes, b, c) <= oc) self.assertTrue(not (iso(excla, exclb) & oc)) class SpecialTypesCase(TestCase): # Some tests for special types def test_array(self): iso = self.iso import array a = array.array('b', b'asdf') iso(a).size def test_main(debug=0): from guppy.heapy.Remote import off off() support.run_unittest(FirstCase, debug) support.run_unittest(GCCase, debug) support.run_unittest(AltHeapCase, debug) support.run_unittest(SpecialTypesCase, debug) if __name__ == "__main__": test_main()	7.99 KB	2026-01-20 12:58
📄 test_all.py import importlib import sys autotests = ( 'dependencies', 'gsl', 'Classifiers', 'heapyc', 'ER', 'OutputHandling', 'Part', 'Path', 'RefPat', 'UniSet', 'View', ) # These are not tested here others = ( 'menuleak', 'sf', ) def test_main(debug=False): for name in autotests: testname = 'guppy.heapy.test.test_'+name try: del sys.modules[testname] except KeyError: pass x = importlib.import_module(testname) print('imported:', testname) f = x.test_main f(debug=debug) del sys.modules[testname] if __name__ == '__main__': test_main()	682 B	2026-01-20 12:58
📄 test_dependencies.py # Test the libraries we are dependent on # Only sets right now. def test_main(debug=0): print('Testing sets') from guppy.sets import test test.test_main() if __name__ == "__main__": test_main()	214 B	2026-01-20 12:58
📄 test_gsl.py # Test the gsl subpackage # Ideally this should be a top level test. def test_main(debug=0): from guppy import Root gsl = Root().guppy.gsl gsl.Document._test_main_() gsl.DottedTree.test_main() gsl.FileIO.set_test_mode() gsl.Filer._test_main_() gsl.Gsml._test_main_() gsl.Main._test_main_() gsl.SpecNodes.test_main() # gsl.Text.test() if __name__ == "__main__": test_main()	421 B	2026-01-20 12:58
📄 test_heapyc.py from guppy.heapy.test import support class TestCase(support.TestCase): def setUp(self): support.TestCase.setUp(self) self.sets = self.guppy.sets heapdefs = getattr(self.sets.setsc, '_NyHeapDefs_'), self.root = [] self.heapyc = self.guppy.heapy.heapyc self.hv = self.heapyc.HeapView(self.root, heapdefs) self.nodeset = self.sets.immnodeset self.mutnodeset = self.sets.mutnodeset self.nodegraph = self.heapyc.NodeGraph class TestHeapView(TestCase): def test_hiding_tag(self): hiding_tag = self.hv._hiding_tag_ a = [] ns = self.mutnodeset([a]) ng = self.nodegraph([(a, a)]) self.aseq(self.hv.relimg([ns]), self.nodeset([a])) self.aseq(self.hv.relimg([ng]), self.nodeset([a])) ns._hiding_tag_ = hiding_tag self.aseq(self.hv.relimg([ns]), self.nodeset([])) ng._hiding_tag_ = hiding_tag self.aseq(self.hv.relimg([ng]), self.nodeset([])) self.hv._hiding_tag_ = [] self.aseq(self.hv.relimg([ns]), self.nodeset([a, None])) self.aseq(self.hv.relimg([ng]), self.nodeset([a, None])) def test_inheritance_from_heapview(self): # I am not using inheritance from HeapView, # but it would be kinda weird if it didn't work. HeapView = self.guppy.heapy.heapyc.HeapView x = 'x' newroot = [x] class HV(HeapView): def __new__(self): return HeapView.__new__(HV, newroot, ()) hv = HV() assert hv.heap() == self.nodeset([x, newroot]) def test_inheritance_from_special_types(self): # Test that relate, size & traverse function correctly for inherited types # as discussed in Notes Apr 14 2005. # Testing with a standard type (list) with specially size and relate definitions, # and a heapdef'd type (mutnodeset) with size, relate and traverse defs. # Test includes more than 1 level of inheritance, since the generic # method needs to go over all bases and not just the (first) base. hv = self.hv hv._hiding_tag_ = [] # Different from default nodeset's hiding_tag immnodeset = self.sets.immnodeset mutnodeset = self.sets.mutnodeset for base in (list, mutnodeset): class T(base): __slots__ = 't', class U(T): __slots__ = 'u', a = base() t = T() t.t = [] u = U() u.t = [] u.u = [] data = list(range(16)) for x in data: a.append(x) t.append(x) u.append(x) # Test size za = hv.indisize_sum([a]) zt = hv.indisize_sum([t]) zu = hv.indisize_sum([u]) self.assertTrue(za < zt < zu) # Test traverse self.aseq(hv.relimg([a]), immnodeset(data)) self.aseq(hv.relimg([t]), immnodeset(data+[T, t.t])) self.aseq(hv.relimg([u]), immnodeset(data+[U, u.t, u.u])) # Test relate def rel(src, tgt): r = hv.relate(src, tgt) self.assertTrue(r != ((),)len(r)) return r self.aseq(rel(t, data[1]), rel(a, data[1])) self.aseq(rel(u, data[1]), rel(a, data[1])) self.aseq(rel(u, u.t), rel(t, t.t)) rel(u, u.u) def test_nodeset_circularity(self): # The traversal to function correctly for types inherited from nodeset # required a fix as discussed in Notes Apr 14 2005. # This method intends to test that this fix was harmless wrt gc & circularity. # To make this method fail, it was necessary to disable nodeset gc traversal. # xxx It seems I have not yet come around to write this test... pass def test_registered_hiding(self): hv = self.hv class Set(object): __slots__ = 'some', '_hiding_tag_', 'other' class Der(Set): pass hv.register__hiding_tag__type(Set) # Der is inherited and registration follows its base type. s = Set() d = Der() t = Set() some = [] other = [] dother = [] s.some = some s.other = other d.some = some d.other = dother self.root.append([s, t, d]) self.root.append(s) self.root.append(d) self.root.append(t) x = hv.heap() assert dother in x assert some in x assert other in x assert s in x assert d in x assert t in x s._hiding_tag_ = hv._hiding_tag_ d._hiding_tag_ = hv._hiding_tag_ x = hv.heap() assert some not in x assert other not in x assert s not in x assert d not in x assert t in x he = [] hv._hiding_tag_ = he x = hv.heap() assert dother in x assert some in x assert other in x assert s in x assert d in x assert t in x def test_timing(self): # Test some timing aspects of heap traversal from time import process_time as clock hv = self.hv d = [] h = [d] self.root.extend(100000[h]) self.root.extend(list(range(100000))) start = clock() x = hv.heap() elapsed0 = clock() - start print('elapsed0', elapsed0, 'len(x)', len(x)) class Set(object): __slots__ = 'some', '_hiding_tag_', 'other' class Der(Set): pass hv.register__hiding_tag__type(Set) s = Set() s._hiding_tag_ = hv._hiding_tag_ d = Der() d._hiding_tag_ = hv._hiding_tag_ self.root[0:50000] = 25000[s, d] start = clock() x = hv.heap() elapsed1 = clock() - start print('elapsed1', elapsed1, 'len(x)', len(x)) # This has failed a couple of times so I remove it now, (apr 5 2008) # xxx should look into this later ... #self.assert_(elapsed1 < 3.0 elapsed0) class TestLeak(support.TestCase): def test_1(self): import gc from sys import getrefcount as grc support.TestCase.setUp(self) sets = self.guppy.sets heapdefs = getattr(sets.setsc, '_NyHeapDefs_'), root = [] heapyc = self.guppy.heapy.heapyc nodeset = sets.mutnodeset nodegraph = heapyc.NodeGraph class T(object): __slots__ = 'a', '_hiding_tag_', 'tonly' pass class U(T): __slots__ = 'b', pass class V(object): __slots__ = 'c', gc.collect() ns = nodeset() a = [ns] a.append(a) b = [] he = [] c = [] t = T() tonly = [] t.a = a t._hiding_tag_ = he t.tonly = tonly u = U() u.a = a u._hiding_tag_ = he u.b = b v = V() v.c = c a = [x for x in [list]] li = [he, a, b, c, t, u, v, T, U, V, ns, nodeset, list] rcli0 = [grc(x) for x in li] ns \|= li + list(range(10000, 10010)) root.extend(li) rcli = [grc(x) for x in li] rec = nodeset([x for x in li]) x = None rec.append(rec) ns.add(rec) rec._hiding_tag_ = rec hv = heapyc.HeapView(root, heapdefs) hv.register__hiding_tag__type(T) h = hv.heap() assert a in h assert c in h assert tonly in h hv._hiding_tag_ = he h = hv.heap() del x del h del hv ns.discard(rec) rec = None gc.collect() nrcli = [grc(x) for x in li] self.aseq(rcli, nrcli) root[:] = [] ns.clear() nrcli0 = [grc(x) for x in li] self.aseq(rcli0, nrcli0) def test_weaky(self): # Test that the extra-type information in heapview # will still allow types to come, be used, and go, and be collected # This depends on that they are weakly-referenced # so internal heapview structures can remove them when they are # to be collected. import gc from sys import getrefcount as grc support.TestCase.setUp(self) sets = self.guppy.sets heapdefs = getattr(sets.setsc, '_NyHeapDefs_'), root = [] heapyc = self.guppy.heapy.heapyc nodeset = sets.NodeSet nodegraph = heapyc.NodeGraph gc.collect() probe = [] rcprobe = grc(probe) class T(object): x = probe class U(T): pass T.U = U # Make circular dependency t = T() u = U() root.append(t) root.append(u) hv = heapyc.HeapView(root, heapdefs) x = hv.heap() assert t in x x = None T = t = U = u = None root[:] = [] gc.collect() # 2 collections needed sometimes? Note Apr 15 2005 nrcprobe = grc(probe) self.aseq(nrcprobe, rcprobe) class TestNodeGraph(TestCase): def test_constructor_and_methods(self): # Test constructor w no arg ng = self.nodegraph() # Test add_edge ng.add_edge(1, 2) # Test add_edges_n1 ng.add_edges_n1([3, 4], 5) lng = list(ng) lng.sort() assert lng == [(1, 2), (3, 5), (4, 5)] # Test as_flat_list fl = ng.as_flat_list() fl.sort() assert fl == [1, 2, 3, 4, 5, 5] # Test copy cp = ng.copy() cp.add_edge(5, 6) # Test __iter__ explicitly lng1 = list(ng.__iter__()) lng1.sort() assert lng1 == lng lcp = list(cp) lcp.sort() assert lcp == [(1, 2), (3, 5), (4, 5), (5, 6)] # Test domain_covers assert ng.domain_covers([1, 3, 4]) assert not ng.domain_covers([1, 3, 4, 5]) # Test domain_restricted rng = ng.domain_restricted([1, 3]) # Test get_domain assert rng.get_domain() == self.nodeset([1, 3]) lrng = list(rng) lrng.sort() assert lrng == [(1, 2), (3, 5)] # Test get_range assert rng.get_range() == self.nodeset([2, 5]) # Test invert rng.invert() lrng = list(rng) lrng.sort() assert lrng == [(2, 1), (5, 3)] # Test inverted ing = ng.inverted() ling = list(ing) ling.sort() assert ling == [(2, 1), (5, 3), (5, 4)] # Test relimg assert ing.relimg([2]) == self.nodeset([1]) assert ing.relimg([2, 5, 3]) == self.nodeset([1, 3, 4]) # Test update ing.update([(3, 7), (4, 8)]) assert ing.relimg([2, 5, 3]) == self.nodeset([1, 3, 4, 7]) # Test updated uing = ing.updated([(2, 9)]) assert ing.relimg([2, 5, 3]) == self.nodeset([1, 3, 4, 7]) assert uing.relimg([2, 5, 3]) == self.nodeset([1, 3, 4, 7, 9]) # Test __getitem__ tgts = list(uing[2]) tgts.sort() assert tgts == [1, 9] # Test __len__ assert len(uing) == 6 uing[2] = (2, 8) # Test __setitem__ tgts = list(uing[2]) tgts.sort() assert tgts == [2, 8] # Test clear ng.clear() assert list(ng) == [] # Test constructor with iterable ng = self.nodegraph([(1, 2)]) assert list(ng) == [(1, 2)] assert not ng.is_mapping # Test constructor with is_mapping flag ng = self.nodegraph(is_mapping=True) assert ng.is_mapping assert list(ng) == [] ng.add_edge(1, 2) assert list(ng) == [(1, 2)] assert ng[1] == 2 ng = self.nodegraph(is_mapping=False) assert not ng.is_mapping # Test constructor with iterable & is_mapping flag for ng in (self.nodegraph([(1, 2)], True), self.nodegraph(iterable=[(1, 2)], is_mapping=True), self.nodegraph([(1, 2)], is_mapping=True), self.nodegraph(is_mapping=True, iterable=[(1, 2)]) ): assert ng.is_mapping assert list(ng) == [(1, 2)] assert ng[1] == 2 ng[1] = 3 assert ng[1] == 3 # Test is_sorted flag # though this behaviour is not fixed - may change with implementation ng = self.nodegraph() ng.add_edge(1, 2) ng.add_edge(2, 1) assert not ng.is_sorted ng[1] assert ng.is_sorted def test_inheritance(self): class T(self.heapyc.NodeGraph): __slots__ = 'x' def as_sorted_list(self): a = list(self) a.sort() return a t = T() t.add_edge(1, 2) t.add_edge(2, 3) assert t.as_sorted_list() == [(1, 2), (2, 3)] t = T([(4, 5), (6, 7)]) assert t.as_sorted_list() == [(4, 5), (6, 7)] # Test that the base type functionality has been inherited # by making test_constructor_and_methods think NodeGraph is T self.nodegraph = T self.test_constructor_and_methods() # Test with a constructor with new argument # and some more attributes class R(T): __slots__ = 'stop', def __new__(self, stop): r = T.__new__(R, is_mapping=1) r.add_edges_n1(list(range(stop)), 0) r.stop = stop return r def keys(self): return list(self.get_domain()) def values(self): return [self[k] for k in list(self.keys())] r = R(10) assert r.stop == 10 assert r.is_mapping lr = list(r) lr.sort() assert lr[-2:] == [(8, 0), (9, 0)] keys = list(r.keys()) keys.sort() assert keys == list(range(10)) values = list(r.values()) assert values == [0]*10 class TestClassifiers(TestCase): # Some new standalone classifiers tests. # Some old are also tested via test_Classifiers. def test_inrel(self): def str_inrel(c): c = list(c) c.sort() return ', '.join(['(%s, %r)' % (x.kind, x.relator) for x in c]) hv = self.hv rg = self.nodegraph() x = [] y = [x] rg.add_edge(x, y) cli = hv.cli_inrel(rg, {}, {}) c = cli.classify(x) self.aseq(str_inrel(c), '(2, 0)') for i in range(5): y.append(x) c = cli.classify(x) self.aseq(str_inrel(c), '(2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5)') for i in range(5): r = {str(i): x} rg.add_edge(x, r) c = cli.classify(x) def test_nodetuple_richcompare(self): hv = self.hv cli = hv.cli_and((hv.cli_id(),), {}) a, b = cli.classify(1), cli.classify(2) self.assertTrue(a != b) self.assertFalse(a == b) self.assertTrue(a >= b or a <= b) self.assertFalse(a >= b and a <= b) self.assertTrue(a > b or a < b) self.assertFalse(a > b and a < b) a, b = cli.classify(1), cli.classify(1) self.assertFalse(a != b) self.assertTrue(a == b) self.assertTrue(a >= b or a <= b) self.assertTrue(a >= b and a <= b) self.assertFalse(a > b or a < b) self.assertFalse(a > b and a < b) def test_main(debug=False): support.run_unittest(TestClassifiers, debug) support.run_unittest(TestNodeGraph, debug) support.run_unittest(TestLeak, debug) support.run_unittest(TestHeapView, debug) if __name__ == "__main__": test_main()	15.6 KB	2026-01-20 12:58
📄 test_menuleak.py from tkinter import * import sys import gc class FixedMenu(Menu): # A fix for the .delete() method in Menu. # To delete commands defined in the menu items deleted. # Also changed the comment: INDEX2 is actually INCLUDED. def delete(self, index1, index2=None): """Delete menu items between INDEX1 and INDEX2 (included).""" print(self._tclCommands) if index2 is None: index2 = index1 # First find out what entries have defined commands. cmds = [] for i in range(self.index(index1), self.index(index2)+1): c = str(self.entrycget(i, 'command')) if c in self._tclCommands: # I don't want to delete the command already, since it # seems mystical to do that while the entry is not yet deleted. cmds.append(c) # Delete the menu entries. self.tk.call(self._w, 'delete', index1, index2) # Now that the menu entries have been deleted, we can delete their commands. for c in cmds: self.deletecommand(c) def test1(M): # Test with a single command gc.collect() root = Tk() button = Menubutton(root, text='Window') menu = M(button) button['menu'] = menu def command(): print('command button pressed') rc = sys.getrefcount(command) menu.add_command(command=command) # or add_radiobutton etc idx = menu.index(END) menu.delete(idx) gc.collect() rc1 = sys.getrefcount(command) print('leak test with class', M, end=' ') if rc1 != rc: print('failed: command is now hold by', rc1, 'references') else: print('succeeded: command is now hold by', rc1, 'references') root.destroy() def test2(M): # Test with 3 commands, especially to see that deleting a range works. gc.collect() root = Tk() button = Menubutton(root, text='Window') menu = M(button) button['menu'] = menu def command0(): print('command 0 button pressed') 'deleting 0 and 1' menu.delete(idx0, idx1) def command1(): print('command 1 button pressed') def command2(): print('command 2 button pressed') print('deleting at END') menu.delete(END) root.quit() rc = [sys.getrefcount(x) for x in (command0, command1, command0)] button.pack() # or add_radiobutton etc menu.add_command(command=command0, label='press first') idx0 = menu.index(END) menu.add_radiobutton(command=command1, label='command1') # to see that delete works even when no command supplied menu.add_command(label='no Command') idx1 = menu.index(END) menu.add_command(command=command2, label='press last') idx2 = menu.index(END) root.mainloop() gc.collect() rc1 = [sys.getrefcount(x) for x in (command0, command1, command0)] print('leak test with class', M, end=' ') if rc1 != rc: print('failed: command is now hold by', rc1, 'references, should be', rc) else: print('succeeded: command is now hold by', rc1, 'references') root.destroy() for M in (Menu, FixedMenu,): test1(M) test2(M)	3.12 KB	2026-01-20 12:58
📄 test_sf.py import importlib # This is to see that the total memory usage doesn't increase with time # i.e. no leakage / link between consecutive usages of hsp. # This will run for ever, to be monitored by the printout and some external monitor. def t(): from guppy import hsp while 1: import guppy.heapy.UniSet import gc importlib.reload(guppy.heapy.UniSet) hp = hsp() x = None x = hp.heap() print(x) gc.collect() print(x[0]) print(x[1]) print(x[2]) gc.collect() print(x & dict)	583 B	2026-01-20 12:58

Edit File:

Terminal