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)