!C99Shell v. 2.0 [PHP 7 Update] [25.02.2019]!

Software: Apache. PHP/5.6.40 

uname -a: Linux cpanel06wh.bkk1.cloud.z.com 2.6.32-954.3.5.lve1.4.80.el6.x86_64 #1 SMP Thu Sep 24
01:42:00 EDT 2020 x86_64
 

uid=851(cp949260) gid=853(cp949260) groups=853(cp949260) 

Safe-mode: OFF (not secure)

/opt/alt/python27/lib64/python2.7/site-packages/guppy/heapy/test/   drwxr-xr-x
Free 221.41 GB of 981.82 GB (22.55%)
Home    Back    Forward    UPDIR    Refresh    Search    Buffer    Encoder    Tools    Proc.    FTP brute    Sec.    SQL    PHP-code    Update    Feedback    Self remove    Logout    


Viewing file:     test_Classifiers.py (25.85 KB)      -rw-r--r--
Select action/file-type:
(+) | (+) | (+) | Code (+) | Session (+) | (+) | SDB (+) | (+) | (+) | (+) | (+) | (+) |
#._cv_part guppy.heapy.test.test_Classifiers

from guppy.heapy.test import support

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.cl = Use.Class
    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.assert_(a < b)

    def eq(self, a, b):
    self.assert_(a == b)

    def dj(self, a, b):
    # disjoint; not related by <= or >=, and not overlapping
    self.assert_(not a <= b)
    self.assert_(not b <= a)
    self.assert_(not a & b)
    self.assert_(a.disjoint(b))

    def nr(self, a, b):
    # not related by <= or >=, and overlapping
    self.assert_(not a <= b)
    self.assert_(not b <= a)
    self.assert_(a & b)
    self.assert_(not a.disjoint(b))


class NewCases(TestCase):
    # New cases that came up after all the original tests had passed,
    # according to notes at Tue Nov 23 06:40:59 MET 2004.
    # To keep original tests intact, for consistency, speed reasons.

    def test_owners(self):
    # Test the .owners attribute
    iso = self.iso
    class C:
        pass
    class D:
        pass
    c = C()
    d = D()
    self.aseq(iso(c.__dict__, d.__dict__, C.__dict__).owners,
          iso(c, d, C))


class SpecialCases(TestCase):
    # Special tests that catch cases that came up during development & debugging
    def test_1(self):

    un = self.un
    ty = self.ty
    cl = self.cl
    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.assert_(a == b)
        self.assert_(str(a) == str(b))
        
    e1 = []
    e2 = {}
    e3 = []
    e4 = ()

    a = rc(cl(C1)) & ty(type(c1))
    b = rc(cl(C1))
    eq((b - a) | a, b)
    eq(a | (b - a), b)

    a = rc(cl(C1)) & ~ty(type(c1))
    b = ty(type(c1)) & ~rc(cl(C1))

    eq(a | b, b | a)

    a = ty(int)
    b = cl(C1)
    c = All

    eq(c - (a & b), (c - a) | (c - b))

    a = cl(C1)
    b = rc(ty(dict))
    c = iso(c1)

    eq( (a | b) | c , a | (b | c))

    a = ty(int)
    b = ty(dict)
    self.assert_( ~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( (ty(list) &~rc(cl(C1))) & iso(e1, e2, e3), iso(e1, 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) & ~rc(cl(C1))) | iso(e1,e2), (ty(dict)  & ~rc(cl(C1))) | iso(e1))
    eq( iso(e1,e2) | (ty(dict) & ~rc(cl(C1))), (ty(dict)  & ~rc(cl(C1))) | 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
    cl = self.cl
    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.assert_(x)

    def no(x):
        self.assert_(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, 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 sys
    if sys.hexversion >= 0x02070000:
        print "XXX SKIPPING test_dictowner TEST BECAUSE OF SLUGGISHNESS WITH PYTHON 2.7"      
        return
    import gc
    from sys import getrefcount as grc
    Use = self.Use
    C1 = self.C1
    c1 = self.c1
    iso = self.iso

    o = self.python.StringIO.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.time

    N = 5
        M = 50

    # This was the fast case, when only reachable dicts are classified
    for i in range(N):
        print >>o, iso(d3).kind
        print >>o, iso(c1.__dict__).kind

        # 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 >>o, iso(*d1).kind
        print >>o, iso(c1.__dict__).kind

    gc.collect()
        # Now measure it

    t = clock()
    for i in range(M):
        iso(*d1).kind
        iso(c1.__dict__).kind
    slow = clock()-t

        #print 'slow,fast',slow,fast
    self.assert_( 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 >>o, iso(list(dn)[i]).kind

        # 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

        #print 'slow,fast',slow,fast
    self.assert_( slow <= 1.5*fast )

    # Partition was likewise slow for unreachable dicts
    dn = self.View.immnodeset([{} for i in range(N)])
    gc.collect()
    print >>o, [x[0] for x in Use.Clodo.classifier.partition(dn)]

        # 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
        #print 'slow,fast',slow,fast
    self.assert_( 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.StringIO.StringIO()
    print >>o, iso(C1).byrcs.kind

    s = iso(c1).byrcs.kind
    print >>o, s
    self.aseq(s & iso(c1), iso(c1))

    x = C1()

    # set_trace()

    if 0:
        self.aseq( s & [c1, x], iso(c1))# (B) makes sure arg is removed from frame when converted
    else:
        self.aseq(s & iso(c1, x), iso(c1))

    s = iso(x).byrcs.kind
    self.aseq( s & iso(c1, x), iso(x))
    x = C1()
    self.aseq( s & iso(c1, x), iso(x)) # (C) make sure referrer graph is updated by select

    s = None
    x = None
    locals().clear()
    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]
    if 1:
        hv = self.View.hv

        rg = self.View.nodegraph()

        gc.collect()
        hv.update_referrers_completely(rg)
        self.assert_( x in rg[a] )


        self.assert_(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.assert_( a in self.View.rg.get_domain() )
    self.assert_( list(b)[0] in self.View.rg.get_domain())

    clock = self.python.time.clock
        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
    #print 'slow,fast,faster',slow, fast, faster
    self.assert_(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.assert_( 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, types
    iso = self.iso
    C1 = self.C1
    c1 = self.c1
    class C3(object):
        def x(self):
        return 1

    e1 = []
    e2 = {}
    e3 = []

    o = self.python.StringIO.StringIO()
    # str'ing of homogenous & inhoumogenous values

    self.US.summary_str.str_address = lambda x:'<address>'

    def ps(x):
        print >>o, x.brief

    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.exceptions.TypeError()) )
    ps( iso(None) )
    ps( iso(sys, support, types) )
    ps( iso(int, types.ClassType, 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.im_func) )
    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:
        typ, value, traceback = sys.exc_info()

    ps( iso(traceback) )
    ps( iso(traceback.tb_frame) )


        expected = """\
<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 exceptions.TypeError: <address>>
<1 types.NoneType: None>
<3 module: guppy.heapy.test.support, sys, types>
<3 type: class, <Module>.C3, int>
<1 <Module>.C1: <address>>
<1 <Module>.C3: <address>>
<1 class: <Module>.C1>
<1 type: <Module>.C3>
<1 types.BuiltinFunctionType: len>
<1 types.MethodType: <<Module>.RenderCase at <addre...>
<1 types.MethodType: <Module>.C1.x>
<1 function: <Module>.x>
<1 types.MethodType: <<Module>.C1 at <address>>.x>
<1 types.MethodType: <Module>.C3.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>>>
""".replace('<Module>', self.__module__)
        self.aseq(o.getvalue(), expected)

        if PORTABLE_TEST:
            return

    o = self.python.StringIO.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.im_func, 1, ['list'],
       100000000000l, 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 >>o, x
    print >>o, x.more

    # Test instancetype; we need to replace the classifier with bytype

    x = iso(C1()).bytype
    print >>o, x

    if 0:
        print o.getvalue()
    else:
        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.BuiltinFunctionType
    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
    cl = self.cl
    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),

        (cl(C1),    eq,    cl(C1)),
        (cl(C1),    dj,    cl(C2)),
        (cl(C1),    lt,    ty(type(C1()))),
        (cl(C1),    dj,    ty(int)),
        (cl(C1),    lt,    All),

        (do(cl(C1)), eq,    do(cl(C1))),
        (do(cl(C1)), lt,    All),
        (do(cl(C1)), dj,    do(cl(C2))),
        (do(cl(C1)), dj,    cl(C1)),
        (do(cl(C1)), dj,    ty(int)),
        (do(cl(C1)), dj,    do(ty(type(C1())))),
        (do(cl(C1)), lt,    ty(dict)),
        (do(cl(C1)), dj,    do(rc(ty(dict)))),

        (rc(ty(dict)),eq,    rc(ty(dict))),
        (rc(ty(dict)),lt,    All),
        (rc(ty(dict)),dj,    rc(ty(list))),
        (rc(cl(C1)), dj,    rc(ty(type(C1())))),
        (rc(cl(C1)), nr,    ty(type(C1()))),
        (rc(cl(C1)), nr,    cl(C1)),
        # (rc(cl(C1)), dj,    rc(rc(cl(C1)))), # Not allowed form anymore / Nov 4 2005
        (rc(cl(C1)), dj,    rc(do(cl(C1)))),
        
        (iso(1),    eq,    iso(1)),
        (iso(1),    lt,    All),
        (iso(1),    dj,    iso(2)),
        (iso(1),    lt,    ty(int)),
        (iso(1),    dj,    ty(dict)),
        (iso(1),    dj,    cl(C1)),
        (iso(c1),    lt,    cl(C1)),
        (iso(c1.__dict__),lt,do(cl(C1))),
        (iso(1),    dj,    do(cl(C1))),
        (iso(1),    dj,    rc(cl(C1))),


        (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.assert_(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
    US.auto_convert_class = False

    cl = self.cl
    ty = self.ty
    c1 = self.c1

    self.failUnlessRaises(TypeError, lambda : cl(c1))
    self.failUnlessRaises(TypeError, lambda : ty(c1))
    self.failUnlessRaises(TypeError, lambda:ty(int) <= None)
    self.failUnlessRaises(TypeError, lambda:None >= ty(int))
    self.failUnlessRaises(TypeError, lambda:None <= ty(int))
    
    self.failUnlessRaises(TypeError, lambda:list(ty(int)))
    self.failUnlessRaises(TypeError, lambda:len(ty(int)))

    self.failUnlessRaises(TypeError, lambda:ty(int) & None)
    self.failUnlessRaises(TypeError, lambda:None & ty(int))
    self.failUnlessRaises(TypeError, lambda:ty(int) | None)
    self.failUnlessRaises(TypeError, lambda:None | ty(int))
    self.failUnlessRaises(TypeError, lambda:ty(int) - None)
    self.failUnlessRaises(TypeError, lambda:None - ty(int))
    self.failUnlessRaises(TypeError, lambda:ty(int) ^ None)
    self.failUnlessRaises(TypeError, lambda:None ^ ty(int))

    self.failUnlessRaises(TypeError, lambda: ty(int) | [14])
    self.failUnlessRaises(TypeError, lambda: ty(int) | dict)
    self.failUnlessRaises(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))
    eq( [e1, e3] | iso(e1,e2), iso(e1,e2,e3))        # Requires __ror__
    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
    self.US.auto_convert_class = True

    un = self.un
    ty = self.ty
    cl = self.cl
    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.assert_(a == b)
        
    e1 = []
    e2 = {}
    e3 = []
    e4 = ()

    eq( ty(dict), dict)
    eq( cl(C1), C1)
    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
    cl = self.cl
    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)), cl(C1), do(cl(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:
        kind = type(o)
        if kind == type(a):
        kind = o.__class__
        self.asis(iso(o).byclass.kind.arg, kind)
    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(135l, [], {}, a, b, a.__dict__, b.__dict__)

    allers = (Use.Unity, Use.Type, Use.Class, 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 ps.items():
        self.aseq ( ak & li, av )
        for bk, bv in 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):

    if 0 or not debug:
    support.run_unittest(BaseCase, debug)

    if 1 or not debug:
    support.run_unittest(ClassificationCase, debug)

    if 0 or not debug:
    support.run_unittest(LawsCase, debug)

    if 0 or not debug:
    support.run_unittest(NewCases, debug)

    if 0 or (testrender and not debug):
    support.run_unittest(RenderCase, debug)

    if 0 or not debug:
    support.run_unittest(SpecialCases, debug)

if 0 and __name__ == "__main__":
    # It doesn't like to be run under name __main__,
    # needs to have its actual module name.
    import guppy.heapy.test.test_Classifiers as x
    if 1:
    reload(x)
    x.test_main()

:: Command execute ::

Enter:
 
Select:
 

:: Search ::
  - regexp 

:: Upload ::
 
[ Read-Only ]

:: Make Dir ::
 
[ Read-Only ]
:: Make File ::
 
[ Read-Only ]

:: Go Dir ::
 
:: Go File ::
 

--[ c99shell v. 2.0 [PHP 7 Update] [25.02.2019] maintained by KaizenLouie | C99Shell Github | Generation time: 0.0751 ]--