AlkantarClanX12
Your IP : 18.223.237.246
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.5*fast)
# 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.5*fast)
# 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.5*fast)
# 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)