3792165026

Build Type

push

github

Committed by GitHub

Commit Message

Drop support for Python 2.7, 3.5, 3.6. (#189)

Run Details

1685 of 1788 branches covered (94.24%)

Branch coverage included in aggregate %.

129 of 130 new or added lines in 13 files covered. (99.23%)

2 existing lines in 2 files now uncovered.

7737 of 8241 relevant lines covered (93.88%)

5.62 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.39

/src/BTrees/tests/testBTrees.py

##############################################################################
#
# Copyright (c) 2001, 2002 Zope Foundation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE
#
##############################################################################
import unittest

from BTrees.tests.common import permutations


class DegenerateBTree(unittest.TestCase):
    # Build a degenerate tree (set).  Boxes are BTree nodes.  There are
    # 5 leaf buckets, each containing a single int.  Keys in the BTree
    # nodes don't appear in the buckets.  Seven BTree nodes are purely
    # indirection nodes (no keys).  Buckets aren't all at the same depth:
    #
    #     +------------------------+
    #     |          4             |
    #     +------------------------+
    #         |              |
    #         |              v
    #         |             +-+
    #         |             | |
    #         |             +-+
    #         |              |
    #         v              v
    #     +-------+   +-------------+
    #     |   2   |   |   6     10  |
    #     +-------+   +-------------+
    #      |     |     |     |     |
    #      v     v     v     v     v
    #     +-+   +-+   +-+   +-+   +-+
    #     | |   | |   | |   | |   | |
    #     +-+   +-+   +-+   +-+   +-+
    #      |     |     |     |     |
    #      v     v     v     v     v
    #      1     3    +-+    7     11
    #                 | |
    #                 +-+
    #                  |
    #                  v
    #                  5
    #
    # This is nasty for many algorithms.  Consider a high-end range search
    # for 4.  The BTree nodes direct it to the 5 bucket, but the correct
    # answer is the 3 bucket, which requires going in a different direction
    # at the very top node already.  Consider a low-end range search for
    # 9.  The BTree nodes direct it to the 7 bucket, but the correct answer
    # is the 11 bucket.  This is also a nasty-case tree for deletions.

    def _build_degenerate_tree(self):
        # Build the buckets and chain them together.
        from BTrees.IIBTree import IISet
        from BTrees.IIBTree import IITreeSet
        from BTrees.check import check
        bucket11 = IISet([11])

        bucket7 = IISet()
        bucket7.__setstate__(((7,), bucket11))

        bucket5 = IISet()
        bucket5.__setstate__(((5,), bucket7))

        bucket3 = IISet()
        bucket3.__setstate__(((3,), bucket5))

        bucket1 = IISet()
        bucket1.__setstate__(((1,), bucket3))

        # Build the deepest layers of indirection nodes.
        ts = IITreeSet
        tree1 = ts()
        tree1.__setstate__(((bucket1,), bucket1))

        tree3 = ts()
        tree3.__setstate__(((bucket3,), bucket3))

        tree5lower = ts()
        tree5lower.__setstate__(((bucket5,), bucket5))
        tree5 = ts()
        tree5.__setstate__(((tree5lower,), bucket5))

        tree7 = ts()
        tree7.__setstate__(((bucket7,), bucket7))

        tree11 = ts()
        tree11.__setstate__(((bucket11,), bucket11))

        # Paste together the middle layers.
        tree13 = ts()
        tree13.__setstate__(((tree1, 2, tree3), bucket1))

        tree5711lower = ts()
        tree5711lower.__setstate__(((tree5, 6, tree7, 10, tree11), bucket5))
        tree5711 = ts()
        tree5711.__setstate__(((tree5711lower,), bucket5))

        # One more.
        t = ts()
        t.__setstate__(((tree13, 4, tree5711), bucket1))
        t._check()
        check(t)
        return t, [1, 3, 5, 7, 11]

    def testBasicOps(self):
        t, keys = self._build_degenerate_tree()
        self.assertEqual(len(t), len(keys))
        self.assertEqual(list(t.keys()), keys)

        self.assertTrue(t.has_key(1))
        self.assertTrue(t.has_key(3))
        self.assertTrue(t.has_key(5))
        self.assertTrue(t.has_key(7))
        self.assertTrue(t.has_key(11))
        for i in 0, 2, 4, 6, 8, 9, 10, 12:
            self.assertNotIn(i, t)

    def _checkRanges(self, tree, keys):
        self.assertEqual(len(tree), len(keys))
        sorted_keys = keys[:]
        sorted_keys.sort()
        self.assertEqual(list(tree.keys()), sorted_keys)
        for k in keys:
            self.assertTrue(k in tree)
        if keys:
            lokey = sorted_keys[0]
            hikey = sorted_keys[-1]
            self.assertEqual(lokey, tree.minKey())
            self.assertEqual(hikey, tree.maxKey())
        else:
            lokey = hikey = 42

        # Try all range searches.
        for lo in range(lokey - 1, hikey + 2):
            for hi in range(lo - 1, hikey + 2):
                for skipmin in False, True:
                    for skipmax in False, True:
                        wantlo, wanthi = lo, hi
                        if skipmin:
                            wantlo += 1
                        if skipmax:
                            wanthi -= 1
                        want = [k for k in keys if wantlo <= k <= wanthi]
                        got = list(tree.keys(lo, hi, skipmin, skipmax))
                        self.assertEqual(want, got)

    def testRanges(self):
        t, keys = self._build_degenerate_tree()
        self._checkRanges(t, keys)

    def testDeletes(self):
        # Delete keys in all possible orders, checking each tree along
        # the way.

        # This is a tough test.  Previous failure modes included:
        # 1. A variety of assertion failures in _checkRanges.
        # 2. Assorted "Invalid firstbucket pointer" failures at
        #    seemingly random times, coming out of the BTree destructor.
        # 3. Under Python 2.3 CVS, some baffling
        #      RuntimeWarning: tp_compare didn't return -1 or -2 for exception
        #    warnings, possibly due to memory corruption after a BTree
        #    goes insane.
        # On CPython in PURE_PYTHON mode, this is a *slow* test, taking 15+s
        # on a 2015 laptop.
        from BTrees.check import check
        t, keys = self._build_degenerate_tree()
        for oneperm in permutations(keys):
            t, keys = self._build_degenerate_tree()
            for key in oneperm:
                t.remove(key)
                keys.remove(key)
                t._check()
                check(t)
                self._checkRanges(t, keys)
            # We removed all the keys, so the tree should be empty now.
            self.assertEqual(t.__getstate__(), None)

            # A damaged tree may trigger an "invalid firstbucket pointer"
            # failure at the time its destructor is invoked.  Try to force
            # that to happen now, so it doesn't look like a baffling failure
            # at some unrelated line.
            del t   # trigger destructor


LP294788_ids = {}


class ToBeDeleted:
    def __init__(self, id):
        assert isinstance(id, int) #we don't want to store any object ref here
        self.id = id

        global LP294788_ids
        LP294788_ids[id] = 1

    def __del__(self):
        global LP294788_ids
        LP294788_ids.pop(self.id, None)

    def __cmp__(self, other):
        return cmp(self.id, other.id)

    def __le__(self, other):
        return self.id <= other.id

    def __lt__(self, other):
        return self.id < other.id

    def __eq__(self, other):
        return self.id == other.id

    def __ne__(self, other):
        return self.id != other.id

    def __gt__(self, other):
        return self.id > other.id

    def __ge__(self, other):
        return self.id >= other.id

    def __hash__(self):
        return hash(self.id)


class TestBugFixes(unittest.TestCase):

    # Collector 1843.  Error returns were effectively ignored in
    # Bucket_rangeSearch(), leading to "delayed" errors, or worse.
    def testFixed1843(self):
        from BTrees.IIBTree import IISet
        t = IISet()
        t.insert(1)
        # This one used to fail to raise the TypeError when it occurred.
        self.assertRaises(TypeError, t.keys, "")
        # This one used to segfault.
        self.assertRaises(TypeError, t.keys, 0, "")

    def test_LP294788(self):
        # https://bugs.launchpad.net/bugs/294788
        # BTree keeps some deleted objects referenced

        # The logic here together with the ToBeDeleted class is that
        # a separate reference dict is populated on object creation
        # and removed in __del__
        # That means what's left in the reference dict is never GC'ed
        # therefore referenced somewhere
        # To simulate real life, some random data is used to exercise the tree
        import gc
        import random
        from BTrees.OOBTree import OOBTree

        t = OOBTree()

        trandom = random.Random('OOBTree')

        global LP294788_ids

        # /// BTree keys are integers, value is an object
        LP294788_ids = {}
        ids = {}
        for i in range(1024):
            if trandom.random() > 0.1 or not ids:
                #add
                id = None
                while id is None or id in ids:
                    id = trandom.randint(0, 1000000)

                ids[id] = 1
                t[id] = ToBeDeleted(id)
            else:
                #del
                keys = list(ids.keys())
                if keys:
                    id = trandom.choice(list(ids.keys()))
                    del t[id]
                    del ids[id]

        ids = ids.keys()
        trandom.shuffle(list(ids))
        for id in ids:
            del t[id]
        ids = None

        #to be on the safe side run a full GC
        gc.collect()

        #print LP294788_ids

        self.assertEqual(len(t), 0)
        self.assertEqual(len(LP294788_ids), 0)
        # \\\

        # /// BTree keys are integers, value is a tuple having an object
        LP294788_ids = {}
        ids = {}
        for i in range(1024):
            if trandom.random() > 0.1 or not ids:
                #add
                id = None
                while id is None or id in ids:
                    id = trandom.randint(0, 1000000)

                ids[id] = 1
                t[id] = (id, ToBeDeleted(id), 'somename')
            else:
                #del
                keys = list(ids.keys())
                if keys:
                    id = trandom.choice(keys)
                    del t[id]
                    del ids[id]

        ids = ids.keys()
        trandom.shuffle(list(ids))
        for id in ids:
            del t[id]
        ids = None

        #to be on the safe side run a full GC
        gc.collect()

        #print LP294788_ids

        self.assertEqual(len(t), 0)
        self.assertEqual(len(LP294788_ids), 0)
        # \\\


        # /// BTree keys are objects, value is an int
        t = OOBTree()
        LP294788_ids = {}
        ids = {}
        for i in range(1024):
            if trandom.random() > 0.1 or not ids:
                #add
                id = None
                while id is None or id in ids:
                    id = ToBeDeleted(trandom.randint(0, 1000000))

                ids[id] = 1
                t[id] = 1
            else:
                #del
                id = trandom.choice(list(ids.keys()))
                del ids[id]
                del t[id]

        ids = ids.keys()
        trandom.shuffle(list(ids))
        for id in ids:
            del t[id]
        #release all refs
        ids = id = None

        #to be on the safe side run a full GC
        gc.collect()

        #print LP294788_ids

        self.assertEqual(len(t), 0)
        self.assertEqual(len(LP294788_ids), 0)

        # /// BTree keys are tuples having objects, value is an int
        t = OOBTree()
        LP294788_ids = {}
        ids = {}
        for i in range(1024):
            if trandom.random() > 0.1 or not ids:
                #add
                id = None
                while id is None or id in ids:
                    id = trandom.randint(0, 1000000)
                    id = (id, ToBeDeleted(id), 'somename')

                ids[id] = 1
                t[id] = 1
            else:
                #del
                id = trandom.choice(list(ids.keys()))
                del ids[id]
                del t[id]

        ids = ids.keys()
        trandom.shuffle(list(ids))
        for id in ids:
            del t[id]
        #release all refs
        ids = id = key = None

        #to be on the safe side run a full GC
        gc.collect()

        #print LP294788_ids

        self.assertEqual(len(t), 0)
        self.assertEqual(len(LP294788_ids), 0)


# cmp error propagation tests


class DoesntLikeBeingCompared:

    def __cmp__(self, other):
        raise ValueError('incomparable')
    __lt__ = __le__ = __eq__ = __ne__ = __ge__ = __gt__ = __cmp__

class TestCmpError(unittest.TestCase):

    def testFoo(self):
        from BTrees.OOBTree import OOBTree
        t = OOBTree()
        t['hello world'] = None
        try:
            t[DoesntLikeBeingCompared()] = None
        except ValueError as e:
            self.assertEqual(str(e), 'incomparable')
        else:
            self.fail('incomarable objects should not be allowed into '
                      'the tree')


class FamilyTest(unittest.TestCase):
    def test32(self):
        from zope.interface.verify import verifyObject
        import BTrees
        from BTrees.IOBTree import IOTreeSet
        verifyObject(BTrees.Interfaces.IBTreeFamily, BTrees.family32)
        self.assertEqual(
            BTrees.family32.IO, BTrees.IOBTree)
        self.assertEqual(
            BTrees.family32.OI, BTrees.OIBTree)
        self.assertEqual(
            BTrees.family32.II, BTrees.IIBTree)
        self.assertEqual(
            BTrees.family32.IF, BTrees.IFBTree)
        self.assertEqual(
            BTrees.family32.UO, BTrees.UOBTree)
        self.assertEqual(
            BTrees.family32.OU, BTrees.OUBTree)
        self.assertEqual(
            BTrees.family32.UU, BTrees.UUBTree)
        self.assertEqual(
            BTrees.family32.UF, BTrees.UFBTree)
        self.assertEqual(
            BTrees.family32.OO, BTrees.OOBTree)
        self.assertEqual(
            BTrees.family32.OU, BTrees.OUBTree)
        s = IOTreeSet()
        s.insert(BTrees.family32.maxint)
        self.assertTrue(BTrees.family32.maxint in s)
        s = IOTreeSet()
        s.insert(BTrees.family32.minint)
        self.assertTrue(BTrees.family32.minint in s)
        s = IOTreeSet()
        # this next bit illustrates an, um, "interesting feature".  If
        # the characteristics change to match the 64 bit version, please
        # feel free to change.
        with self.assertRaises((TypeError, OverflowError)):
            s.insert(BTrees.family32.maxint + 1)

        with self.assertRaises((TypeError, OverflowError)):
            s.insert(BTrees.family32.minint - 1)
        self.check_pickling(BTrees.family32)

    def test64(self):
        from zope.interface.verify import verifyObject
        import BTrees
        from BTrees.LOBTree import LOTreeSet
        verifyObject(BTrees.Interfaces.IBTreeFamily, BTrees.family64)
        self.assertEqual(
            BTrees.family64.IO, BTrees.LOBTree)
        self.assertEqual(
            BTrees.family64.OI, BTrees.OLBTree)
        self.assertEqual(
            BTrees.family64.II, BTrees.LLBTree)
        self.assertEqual(
            BTrees.family64.IF, BTrees.LFBTree)
        self.assertEqual(
            BTrees.family64.UO, BTrees.QOBTree)
        self.assertEqual(
            BTrees.family64.OU, BTrees.OQBTree)
        self.assertEqual(
            BTrees.family64.UU, BTrees.QQBTree)
        self.assertEqual(
            BTrees.family64.UF, BTrees.QFBTree)
        self.assertEqual(
            BTrees.family64.OO, BTrees.OOBTree)
        self.assertEqual(
            BTrees.family64.OU, BTrees.OQBTree)
        s = LOTreeSet()
        s.insert(BTrees.family64.maxint)
        self.assertTrue(BTrees.family64.maxint in s)
        s = LOTreeSet()
        s.insert(BTrees.family64.minint)
        self.assertTrue(BTrees.family64.minint in s)
        s = LOTreeSet()
        # XXX why oh why do we expect ValueError here, but TypeError in test32?
        self.assertRaises((TypeError, OverflowError), s.insert, BTrees.family64.maxint + 1)
        self.assertRaises((TypeError, OverflowError), s.insert, BTrees.family64.minint - 1)
        self.check_pickling(BTrees.family64)

    def check_pickling(self, family):
        # The "family" objects are singletons; they can be pickled and
        # unpickled, and the same instances will always be returned on
        # unpickling, whether from the same unpickler or different
        # unpicklers.
        import pickle
        from io import BytesIO

        s = pickle.dumps((family, family))
        (f1, f2) = pickle.loads(s)
        self.assertIs(f1, family)
        self.assertIs(f2, family)

        # Using a single memo across multiple pickles:
        sio = BytesIO()
        p = pickle.Pickler(sio)
        p.dump(family)
        p.dump([family])
        u = pickle.Unpickler(BytesIO(sio.getvalue()))
        f1 = u.load()
        f2, = u.load()
        self.assertTrue(f1 is family)
        self.assertTrue(f2 is family)

        # Using separate memos for each pickle:
        sio = BytesIO()
        p = pickle.Pickler(sio)
        p.dump(family)
        p.clear_memo()
        p.dump([family])
        u = pickle.Unpickler(BytesIO(sio.getvalue()))
        f1 = u.load()
        f2, = u.load()
        self.assertTrue(f1 is family)
        self.assertTrue(f2 is family)

1	##############################################################################
2	#
3	# Copyright (c) 2001, 2002 Zope Foundation and Contributors.
4	# All Rights Reserved.
5	#
6	# This software is subject to the provisions of the Zope Public License,
7	# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
8	# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
9	# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
10	# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
11	# FOR A PARTICULAR PURPOSE
12	#
13	##############################################################################
14	import unittest	6✔
15
16	from BTrees.tests.common import permutations	6✔
17
18
19	class DegenerateBTree(unittest.TestCase):	6✔
20	# Build a degenerate tree (set). Boxes are BTree nodes. There are
21	# 5 leaf buckets, each containing a single int. Keys in the BTree
22	# nodes don't appear in the buckets. Seven BTree nodes are purely
23	# indirection nodes (no keys). Buckets aren't all at the same depth:
24	#
25	# +------------------------+
26	# \| 4 \|
27	# +------------------------+
28	# \| \|
29	# \| v
30	# \| +-+
31	# \| \| \|
32	# \| +-+
33	# \| \|
34	# v v
35	# +-------+ +-------------+
36	# \| 2 \| \| 6 10 \|
37	# +-------+ +-------------+
38	# \| \| \| \| \|
39	# v v v v v
40	# +-+ +-+ +-+ +-+ +-+
41	# \| \| \| \| \| \| \| \| \| \|
42	# +-+ +-+ +-+ +-+ +-+
43	# \| \| \| \| \|
44	# v v v v v
45	# 1 3 +-+ 7 11
46	# \| \|
47	# +-+
48	# \|
49	# v
50	# 5
51	#
52	# This is nasty for many algorithms. Consider a high-end range search
53	# for 4. The BTree nodes direct it to the 5 bucket, but the correct
54	# answer is the 3 bucket, which requires going in a different direction
55	# at the very top node already. Consider a low-end range search for
56	# 9. The BTree nodes direct it to the 7 bucket, but the correct answer
57	# is the 11 bucket. This is also a nasty-case tree for deletions.
58
59	def _build_degenerate_tree(self):	6✔
60	# Build the buckets and chain them together.
61	from BTrees.IIBTree import IISet	6✔
62	from BTrees.IIBTree import IITreeSet	6✔
63	from BTrees.check import check	6✔
64	bucket11 = IISet([11])	6✔
65
66	bucket7 = IISet()	6✔
67	bucket7.__setstate__(((7,), bucket11))	6✔
68
69	bucket5 = IISet()	6✔
70	bucket5.__setstate__(((5,), bucket7))	6✔
71
72	bucket3 = IISet()	6✔
73	bucket3.__setstate__(((3,), bucket5))	6✔
74
75	bucket1 = IISet()	6✔
76	bucket1.__setstate__(((1,), bucket3))	6✔
77
78	# Build the deepest layers of indirection nodes.
79	ts = IITreeSet	6✔
80	tree1 = ts()	6✔
81	tree1.__setstate__(((bucket1,), bucket1))	6✔
82
83	tree3 = ts()	6✔
84	tree3.__setstate__(((bucket3,), bucket3))	6✔
85
86	tree5lower = ts()	6✔
87	tree5lower.__setstate__(((bucket5,), bucket5))	6✔
88	tree5 = ts()	6✔
89	tree5.__setstate__(((tree5lower,), bucket5))	6✔
90
91	tree7 = ts()	6✔
92	tree7.__setstate__(((bucket7,), bucket7))	6✔
93
94	tree11 = ts()	6✔
95	tree11.__setstate__(((bucket11,), bucket11))	6✔
96
97	# Paste together the middle layers.
98	tree13 = ts()	6✔
99	tree13.__setstate__(((tree1, 2, tree3), bucket1))	6✔
100
101	tree5711lower = ts()	6✔
102	tree5711lower.__setstate__(((tree5, 6, tree7, 10, tree11), bucket5))	6✔
103	tree5711 = ts()	6✔
104	tree5711.__setstate__(((tree5711lower,), bucket5))	6✔
105
106	# One more.
107	t = ts()	6✔
108	t.__setstate__(((tree13, 4, tree5711), bucket1))	6✔
109	t._check()	6✔
110	check(t)	6✔
111	return t, [1, 3, 5, 7, 11]	6✔
112
113	def testBasicOps(self):	6✔
114	t, keys = self._build_degenerate_tree()	6✔
115	self.assertEqual(len(t), len(keys))	6✔
116	self.assertEqual(list(t.keys()), keys)	6✔
117
118	self.assertTrue(t.has_key(1))	6✔
119	self.assertTrue(t.has_key(3))	6✔
120	self.assertTrue(t.has_key(5))	6✔
121	self.assertTrue(t.has_key(7))	6✔
122	self.assertTrue(t.has_key(11))	6✔
123	for i in 0, 2, 4, 6, 8, 9, 10, 12:	6✔
124	self.assertNotIn(i, t)	6✔
125
126	def _checkRanges(self, tree, keys):	6✔
127	self.assertEqual(len(tree), len(keys))	6✔
128	sorted_keys = keys[:]	6✔
129	sorted_keys.sort()	6✔
130	self.assertEqual(list(tree.keys()), sorted_keys)	6✔
131	for k in keys:	6✔
132	self.assertTrue(k in tree)	6✔
133	if keys:	6✔
134	lokey = sorted_keys[0]	6✔
135	hikey = sorted_keys[-1]	6✔
136	self.assertEqual(lokey, tree.minKey())	6✔
137	self.assertEqual(hikey, tree.maxKey())	6✔
138	else:
139	lokey = hikey = 42	6✔
140
141	# Try all range searches.
142	for lo in range(lokey - 1, hikey + 2):	6✔
143	for hi in range(lo - 1, hikey + 2):	6✔
144	for skipmin in False, True:	6✔
145	for skipmax in False, True:	6✔
146	wantlo, wanthi = lo, hi	6✔
147	if skipmin:	6✔
148	wantlo += 1	6✔
149	if skipmax:	6✔
150	wanthi -= 1	6✔
151	want = [k for k in keys if wantlo <= k <= wanthi]	6✔
152	got = list(tree.keys(lo, hi, skipmin, skipmax))	6✔
153	self.assertEqual(want, got)	6✔
154
155	def testRanges(self):	6✔
156	t, keys = self._build_degenerate_tree()	6✔
157	self._checkRanges(t, keys)	6✔
158
159	def testDeletes(self):	6✔
160	# Delete keys in all possible orders, checking each tree along
161	# the way.
162
163	# This is a tough test. Previous failure modes included:
164	# 1. A variety of assertion failures in _checkRanges.
165	# 2. Assorted "Invalid firstbucket pointer" failures at
166	# seemingly random times, coming out of the BTree destructor.
167	# 3. Under Python 2.3 CVS, some baffling
168	# RuntimeWarning: tp_compare didn't return -1 or -2 for exception
169	# warnings, possibly due to memory corruption after a BTree
170	# goes insane.
171	# On CPython in PURE_PYTHON mode, this is a slow test, taking 15+s
172	# on a 2015 laptop.
173	from BTrees.check import check	6✔
174	t, keys = self._build_degenerate_tree()	6✔
175	for oneperm in permutations(keys):	6✔
176	t, keys = self._build_degenerate_tree()	6✔
177	for key in oneperm:	6✔
178	t.remove(key)	6✔
179	keys.remove(key)	6✔
180	t._check()	6✔
181	check(t)	6✔
182	self._checkRanges(t, keys)	6✔
183	# We removed all the keys, so the tree should be empty now.
184	self.assertEqual(t.__getstate__(), None)	6✔
185
186	# A damaged tree may trigger an "invalid firstbucket pointer"
187	# failure at the time its destructor is invoked. Try to force
188	# that to happen now, so it doesn't look like a baffling failure
189	# at some unrelated line.
190	del t # trigger destructor	6✔
191
192
193	LP294788_ids = {}	6✔
194
195
196	class ToBeDeleted:	6✔
197	def __init__(self, id):	6✔
198	assert isinstance(id, int) #we don't want to store any object ref here	6✔
199	self.id = id	6✔
200
201	global LP294788_ids
202	LP294788_ids[id] = 1	6✔
203
204	def __del__(self):	6✔
205	global LP294788_ids
206	LP294788_ids.pop(self.id, None)	6✔
207
208	def __cmp__(self, other):	6✔
UNCOV 209	return cmp(self.id, other.id)	×
210
211	def __le__(self, other):	6✔
212	return self.id <= other.id	×
213
214	def __lt__(self, other):	6✔
215	return self.id < other.id	5✔
216
217	def __eq__(self, other):	6✔
218	return self.id == other.id	6✔
219
220	def __ne__(self, other):	6✔
221	return self.id != other.id	×
222
223	def __gt__(self, other):	6✔
224	return self.id > other.id	6✔
225
226	def __ge__(self, other):	6✔
227	return self.id >= other.id	×
228
229	def __hash__(self):	6✔
230	return hash(self.id)	6✔
231
232
233	class TestBugFixes(unittest.TestCase):	6✔
234
235	# Collector 1843. Error returns were effectively ignored in
236	# Bucket_rangeSearch(), leading to "delayed" errors, or worse.
237	def testFixed1843(self):	6✔
238	from BTrees.IIBTree import IISet	6✔
239	t = IISet()	6✔
240	t.insert(1)	6✔
241	# This one used to fail to raise the TypeError when it occurred.
242	self.assertRaises(TypeError, t.keys, "")	6✔
243	# This one used to segfault.
244	self.assertRaises(TypeError, t.keys, 0, "")	6✔
245
246	def test_LP294788(self):	6✔
247	# https://bugs.launchpad.net/bugs/294788
248	# BTree keeps some deleted objects referenced
249
250	# The logic here together with the ToBeDeleted class is that
251	# a separate reference dict is populated on object creation
252	# and removed in __del__
253	# That means what's left in the reference dict is never GC'ed
254	# therefore referenced somewhere
255	# To simulate real life, some random data is used to exercise the tree
256	import gc	6✔
257	import random	6✔
258	from BTrees.OOBTree import OOBTree	6✔
259
260	t = OOBTree()	6✔
261
262	trandom = random.Random('OOBTree')	6✔
263
264	global LP294788_ids
265
266	# /// BTree keys are integers, value is an object
267	LP294788_ids = {}	6✔
268	ids = {}	6✔
269	for i in range(1024):	6✔
270	if trandom.random() > 0.1 or not ids:	6✔
271	#add
272	id = None	6✔
273	while id is None or id in ids:	6✔
274	id = trandom.randint(0, 1000000)	6✔
275
276	ids[id] = 1	6✔
277	t[id] = ToBeDeleted(id)	6✔
278	else:
279	#del
280	keys = list(ids.keys())	6✔
281	if keys:	6!
282	id = trandom.choice(list(ids.keys()))	6✔
283	del t[id]	6✔
284	del ids[id]	6✔
285
286	ids = ids.keys()	6✔
287	trandom.shuffle(list(ids))	6✔
288	for id in ids:	6✔
289	del t[id]	6✔
290	ids = None	6✔
291
292	#to be on the safe side run a full GC
293	gc.collect()	6✔
294
295	#print LP294788_ids
296
297	self.assertEqual(len(t), 0)	6✔
298	self.assertEqual(len(LP294788_ids), 0)	6✔
299	# \\\
300
301	# /// BTree keys are integers, value is a tuple having an object
302	LP294788_ids = {}	6✔
303	ids = {}	6✔
304	for i in range(1024):	6✔
305	if trandom.random() > 0.1 or not ids:	6✔
306	#add
307	id = None	6✔
308	while id is None or id in ids:	6✔
309	id = trandom.randint(0, 1000000)	6✔
310
311	ids[id] = 1	6✔
312	t[id] = (id, ToBeDeleted(id), 'somename')	6✔
313	else:
314	#del
315	keys = list(ids.keys())	6✔
316	if keys:	6!
317	id = trandom.choice(keys)	6✔
318	del t[id]	6✔
319	del ids[id]	6✔
320
321	ids = ids.keys()	6✔
322	trandom.shuffle(list(ids))	6✔
323	for id in ids:	6✔
324	del t[id]	6✔
325	ids = None	6✔
326
327	#to be on the safe side run a full GC
328	gc.collect()	6✔
329
330	#print LP294788_ids
331
332	self.assertEqual(len(t), 0)	6✔
333	self.assertEqual(len(LP294788_ids), 0)	6✔
334	# \\\
335
336
337	# /// BTree keys are objects, value is an int
338	t = OOBTree()	6✔
339	LP294788_ids = {}	6✔
340	ids = {}	6✔
341	for i in range(1024):	6✔
342	if trandom.random() > 0.1 or not ids:	6✔
343	#add
344	id = None	6✔
345	while id is None or id in ids:	6✔
346	id = ToBeDeleted(trandom.randint(0, 1000000))	6✔
347
348	ids[id] = 1	6✔
349	t[id] = 1	6✔
350	else:
351	#del
352	id = trandom.choice(list(ids.keys()))	6✔
353	del ids[id]	6✔
354	del t[id]	6✔
355
356	ids = ids.keys()	6✔
357	trandom.shuffle(list(ids))	6✔
358	for id in ids:	6✔
359	del t[id]	6✔
360	#release all refs
361	ids = id = None	6✔
362
363	#to be on the safe side run a full GC
364	gc.collect()	6✔
365
366	#print LP294788_ids
367
368	self.assertEqual(len(t), 0)	6✔
369	self.assertEqual(len(LP294788_ids), 0)	6✔
370
371	# /// BTree keys are tuples having objects, value is an int
372	t = OOBTree()	6✔
373	LP294788_ids = {}	6✔
374	ids = {}	6✔
375	for i in range(1024):	6✔
376	if trandom.random() > 0.1 or not ids:	6✔
377	#add
378	id = None	6✔
379	while id is None or id in ids:	6✔
380	id = trandom.randint(0, 1000000)	6✔
381	id = (id, ToBeDeleted(id), 'somename')	6✔
382
383	ids[id] = 1	6✔
384	t[id] = 1	6✔
385	else:
386	#del
387	id = trandom.choice(list(ids.keys()))	6✔
388	del ids[id]	6✔
389	del t[id]	6✔
390
391	ids = ids.keys()	6✔
392	trandom.shuffle(list(ids))	6✔
393	for id in ids:	6✔
394	del t[id]	6✔
395	#release all refs
396	ids = id = key = None	6✔
397
398	#to be on the safe side run a full GC
399	gc.collect()	6✔
400
401	#print LP294788_ids
402
403	self.assertEqual(len(t), 0)	6✔
404	self.assertEqual(len(LP294788_ids), 0)	6✔
405
406
407	# cmp error propagation tests
408
409
410	class DoesntLikeBeingCompared:	6✔
411
412	def __cmp__(self, other):	6✔
413	raise ValueError('incomparable')	6✔
414	__lt__ = __le__ = __eq__ = __ne__ = __ge__ = __gt__ = __cmp__	6✔
415
416	class TestCmpError(unittest.TestCase):	6✔
417
418	def testFoo(self):	6✔
419	from BTrees.OOBTree import OOBTree	6✔
420	t = OOBTree()	6✔
421	t['hello world'] = None	6✔
422	try:	6✔
423	t[DoesntLikeBeingCompared()] = None	6✔
424	except ValueError as e:	6✔
425	self.assertEqual(str(e), 'incomparable')	6✔
426	else:
427	self.fail('incomarable objects should not be allowed into '
428	'the tree')
429
430
431	class FamilyTest(unittest.TestCase):	6✔
432	def test32(self):	6✔
433	from zope.interface.verify import verifyObject	6✔
434	import BTrees	6✔
435	from BTrees.IOBTree import IOTreeSet	6✔
436	verifyObject(BTrees.Interfaces.IBTreeFamily, BTrees.family32)	6✔
437	self.assertEqual(	6✔
438	BTrees.family32.IO, BTrees.IOBTree)
439	self.assertEqual(	6✔
440	BTrees.family32.OI, BTrees.OIBTree)
441	self.assertEqual(	6✔
442	BTrees.family32.II, BTrees.IIBTree)
443	self.assertEqual(	6✔
444	BTrees.family32.IF, BTrees.IFBTree)
445	self.assertEqual(	6✔
446	BTrees.family32.UO, BTrees.UOBTree)
447	self.assertEqual(	6✔
448	BTrees.family32.OU, BTrees.OUBTree)
449	self.assertEqual(	6✔
450	BTrees.family32.UU, BTrees.UUBTree)
451	self.assertEqual(	6✔
452	BTrees.family32.UF, BTrees.UFBTree)
453	self.assertEqual(	6✔
454	BTrees.family32.OO, BTrees.OOBTree)
455	self.assertEqual(	6✔
456	BTrees.family32.OU, BTrees.OUBTree)
457	s = IOTreeSet()	6✔
458	s.insert(BTrees.family32.maxint)	6✔
459	self.assertTrue(BTrees.family32.maxint in s)	6✔
460	s = IOTreeSet()	6✔
461	s.insert(BTrees.family32.minint)	6✔
462	self.assertTrue(BTrees.family32.minint in s)	6✔
463	s = IOTreeSet()	6✔
464	# this next bit illustrates an, um, "interesting feature". If
465	# the characteristics change to match the 64 bit version, please
466	# feel free to change.
467	with self.assertRaises((TypeError, OverflowError)):	6✔
468	s.insert(BTrees.family32.maxint + 1)	6✔
469
470	with self.assertRaises((TypeError, OverflowError)):	6✔
471	s.insert(BTrees.family32.minint - 1)	6✔
472	self.check_pickling(BTrees.family32)	6✔
473
474	def test64(self):	6✔
475	from zope.interface.verify import verifyObject	6✔
476	import BTrees	6✔
477	from BTrees.LOBTree import LOTreeSet	6✔
478	verifyObject(BTrees.Interfaces.IBTreeFamily, BTrees.family64)	6✔
479	self.assertEqual(	6✔
480	BTrees.family64.IO, BTrees.LOBTree)
481	self.assertEqual(	6✔
482	BTrees.family64.OI, BTrees.OLBTree)
483	self.assertEqual(	6✔
484	BTrees.family64.II, BTrees.LLBTree)
485	self.assertEqual(	6✔
486	BTrees.family64.IF, BTrees.LFBTree)
487	self.assertEqual(	6✔
488	BTrees.family64.UO, BTrees.QOBTree)
489	self.assertEqual(	6✔
490	BTrees.family64.OU, BTrees.OQBTree)
491	self.assertEqual(	6✔
492	BTrees.family64.UU, BTrees.QQBTree)
493	self.assertEqual(	6✔
494	BTrees.family64.UF, BTrees.QFBTree)
495	self.assertEqual(	6✔
496	BTrees.family64.OO, BTrees.OOBTree)
497	self.assertEqual(	6✔
498	BTrees.family64.OU, BTrees.OQBTree)
499	s = LOTreeSet()	6✔
500	s.insert(BTrees.family64.maxint)	6✔
501	self.assertTrue(BTrees.family64.maxint in s)	6✔
502	s = LOTreeSet()	6✔
503	s.insert(BTrees.family64.minint)	6✔
504	self.assertTrue(BTrees.family64.minint in s)	6✔
505	s = LOTreeSet()	6✔
506	# XXX why oh why do we expect ValueError here, but TypeError in test32?
507	self.assertRaises((TypeError, OverflowError), s.insert, BTrees.family64.maxint + 1)	6✔
508	self.assertRaises((TypeError, OverflowError), s.insert, BTrees.family64.minint - 1)	6✔
509	self.check_pickling(BTrees.family64)	6✔
510
511	def check_pickling(self, family):	6✔
512	# The "family" objects are singletons; they can be pickled and
513	# unpickled, and the same instances will always be returned on
514	# unpickling, whether from the same unpickler or different
515	# unpicklers.
516	import pickle	6✔
517	from io import BytesIO	6✔
518
519	s = pickle.dumps((family, family))	6✔
520	(f1, f2) = pickle.loads(s)	6✔
521	self.assertIs(f1, family)	6✔
522	self.assertIs(f2, family)	6✔
523
524	# Using a single memo across multiple pickles:
525	sio = BytesIO()	6✔
526	p = pickle.Pickler(sio)	6✔
527	p.dump(family)	6✔
528	p.dump([family])	6✔
529	u = pickle.Unpickler(BytesIO(sio.getvalue()))	6✔
530	f1 = u.load()	6✔
531	f2, = u.load()	6✔
532	self.assertTrue(f1 is family)	6✔
533	self.assertTrue(f2 is family)	6✔
534
535	# Using separate memos for each pickle:
536	sio = BytesIO()	6✔
537	p = pickle.Pickler(sio)	6✔
538	p.dump(family)	6✔
539	p.clear_memo()	6✔
540	p.dump([family])	6✔
541	u = pickle.Unpickler(BytesIO(sio.getvalue()))	6✔
542	f1 = u.load()	6✔
543	f2, = u.load()	6✔
544	self.assertTrue(f1 is family)	6✔
545	self.assertTrue(f2 is family)	6✔

zopefoundation / BTrees / 3792165026

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous