Viewing file:  test_ER.py (9.19 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
#._cv_part guppy.heapy.test.test_ER
# 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
class TestCase(support.TestCase):
pass
class FirstCase(TestCase):
if 1:
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]
# print 'k', k, 'ts', ts
# 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__, [])
import types
db = di.by('Rcs')
for i in (0, 1):
rk = repr(db[i].kind)
# print rk
ek = eval(rk)
self.aseq( ek, db[i].kind )
# print db & ek
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.Class(C)',
'hp.Class(C).dictof',
'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.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)
rx = repr(x)
self.aseq(eval(rx), 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]')",
)):
code = i + 1
x = eval(s)
rel = list(x.arg)[0]
self.aseq(rel.kind, code)
rx = repr(x)
self.aseq(eval(rx), 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.Class(X).dictof,
hp.Size(hp.iso(x).indisize).dictof,
hp.iso(x).bysize.kind.dictof,
(hp.iso(x).bysize.kind & hp.Class(X)).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__')")
#print repr(x)
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.__dict__, C, c, c.__dict__, d)&hp.Class.sokind(C).refdby
b = hp.iso(C.__dict__, C, c, c.__dict__, d)&hp.Clodo.sokind(C).refdby
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)
# print s
for i in range(len(s)):
a = s[i].kind
ra = repr(a)
# print ra
era = eval(ra)
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)), s)
def test_6(self):
' Test of .refdby on all others '
class C:
pass
c = C()
d = {}
cref = [c]
cref.append(cref)
c.cref = cref
hp = self.heapy.Use
hp.reprefix = 'hp.'
import sys
s = hp.iso(C.__dict__, C, c, c.__dict__, d, sys)
for pre in (
'Unity',
'Class',
'Clodo',
'Id',
'Module',
('Rcs', 0),
'Size',
'Type',
'Via')[:]:
if isinstance(pre, tuple):
pre, level = pre[:2]
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)
# print rer
self.aseq(eval(rer), er)
for s in (set,):
sby = s.by(er)
sk = sby.kind
rsk = repr(sk)
# print rsk
ske = eval(rsk)
self.aseq(ske, sk)
self.aseq(s & sk, s)
self.aseq(s & ske, s)
# 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.Class(D),
hp.Type(U),
hp.Class.sokind(D).refdby,
):
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
# print s.by(a.biper)
# print s.by(a.biper)[0].kind
# print s.by(a.biper)[1].kind
#print s & a
# A bug specific for refdby
# occured after gc when using biper
# noted Sep 21 2005
k=hp.Class.sokind(D).refdby
import gc
gc.collect()
a = s.by(k.alt('>=').biper)
b = s.by(k.alt('>=').biper)
# print a
self.assert_( hp.iso(d.__dict__) <= a[1] )
self.assert_( a == b )
gc.collect()
a = s.by(k.alt('<=').biper)
b = s.by(k.alt('<=').biper)
# print a
self.assert_( hp.iso(d.__dict__) <= a[0])
self.assert_( 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.Class(C), 1),
(hp.Type(dict), 0),
(hp.iso(c), 1),
(hp.iso(c, li), 1),
(hp.Type(dict) | hp.Class(C), 0)
):
p = s.by(k.biper)
# print p
self.aseq(p[i].kind.fam.classifier.kinds[0], k)
def test_9(self):
' Test the subrelation relation '
from guppy import hpy
ernames = ['Class', 'Clodo', 'Id', 'Idset',
'Module', 'Rcs', 'Size', 'Type',
'Unity']
hp=hpy()
ers = [(name, getattr(hp, name)) for name in ernames]
ers.append(('Size&Type', hp.Size&hp.Type))
from StringIO import StringIO
f = StringIO()
print >>f, ''.ljust(10),
for b in ers:
print >>f, b[0].ljust(7),
print >>f
for a in ers:
print >>f, a[0].ljust(10),
for b in ers:
print >>f, str((a[1] < b[1]))[:1].ljust(7),
print >>f
self.aseq( f.getvalue(), """\
Class Clodo Id Idset Module Rcs Size Type Unity Size&Type
Class F F F F F F F T T F
Clodo T F F F F F F T T F
Id F F F F F F F F T F
Idset F F F F F F F F T F
Module F F F F F F F F T F
Rcs F F F F F F F F T F
Size F F F F F F F F T F
Type F F F F F F F F T F
Unity F F F F F F F F F F
Size&Type F F F F F F T T T F
""")
def test_main(debug = 0):
support.run_unittest(FirstCase, debug)
if __name__ == "__main__":
from guppy.heapy.Remote import off
off()
test_main()
|