[Zodb-checkins] CVS: Zope/lib/python/BTrees/tests - testSetOps.py:1.13.12.1 testBTrees.py:1.25.10.2 testBTreesUnicode.py:1.5.18.2 testConflict.py:1.10.18.2
Matthew T. Kromer
matt@zope.com
Tue, 10 Sep 2002 17:48:25 -0400
Update of /cvs-repository/Zope/lib/python/BTrees/tests
In directory cvs.zope.org:/tmp/cvs-serv17953/tests
Modified Files:
Tag: Zope-2_5-branch
testBTrees.py testBTreesUnicode.py testConflict.py
Added Files:
Tag: Zope-2_5-branch
testSetOps.py
Log Message:
Backport 2.6 BTrees to 2.5 for a Zope 2.5.2 maintenance release
=== Added File Zope/lib/python/BTrees/tests/testSetOps.py ===
##############################################################################
#
# Copyright (c) 2002 Zope Corporation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.0 (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 random
from unittest import TestCase, TestSuite, TextTestRunner, makeSuite
from BTrees.OOBTree import OOBTree, OOBucket, OOSet, OOTreeSet
from BTrees.IOBTree import IOBTree, IOBucket, IOSet, IOTreeSet
from BTrees.IIBTree import IIBTree, IIBucket, IISet, IITreeSet
from BTrees.OIBTree import OIBTree, OIBucket, OISet, OITreeSet
# Subclasses have to set up:
# builders - functions to build inputs, taking an optional keys arg
# intersection, union, difference - set to the type-correct versions
class SetResult(TestCase):
def setUp(self):
self.Akeys = [1, 3, 5, 6 ]
self.Bkeys = [ 2, 3, 4, 6, 7]
self.As = [makeset(self.Akeys) for makeset in self.builders]
self.Bs = [makeset(self.Bkeys) for makeset in self.builders]
self.emptys = [makeset() for makeset in self.builders]
# Slow but obviously correct Python implementations of basic ops.
def _union(self, x, y):
result = list(x.keys())
for e in y.keys():
if e not in result:
result.append(e)
result.sort()
return result
def _intersection(self, x, y):
result = []
ykeys = y.keys()
for e in x.keys():
if e in ykeys:
result.append(e)
return result
def _difference(self, x, y):
result = list(x.keys())
for e in y.keys():
if e in result:
result.remove(e)
# Difference preserves LHS values.
if hasattr(x, "values"):
result = [(k, x[k]) for k in result]
return result
def testNone(self):
for op in self.union, self.intersection, self.difference:
C = op(None, None)
self.assert_(C is None)
for op in self.union, self.intersection, self.difference:
for A in self.As:
C = op(A, None)
self.assert_(C is A)
C = op(None, A)
if op is self.difference:
self.assert_(C is None)
else:
self.assert_(C is A)
def testEmptyUnion(self):
for A in self.As:
for E in self.emptys:
C = self.union(A, E)
self.assert_(not hasattr(C, "values"))
self.assertEqual(list(C), self.Akeys)
C = self.union(E, A)
self.assert_(not hasattr(C, "values"))
self.assertEqual(list(C), self.Akeys)
def testEmptyIntersection(self):
for A in self.As:
for E in self.emptys:
C = self.intersection(A, E)
self.assert_(not hasattr(C, "values"))
self.assertEqual(list(C), [])
C = self.intersection(E, A)
self.assert_(not hasattr(C, "values"))
self.assertEqual(list(C), [])
def testEmptyDifference(self):
for A in self.As:
for E in self.emptys:
C = self.difference(A, E)
# Difference preserves LHS values.
self.assertEqual(hasattr(C, "values"), hasattr(A, "values"))
if hasattr(A, "values"):
self.assertEqual(list(C.items()), list(A.items()))
else:
self.assertEqual(list(C), self.Akeys)
C = self.difference(E, A)
self.assertEqual(hasattr(C, "values"), hasattr(E, "values"))
self.assertEqual(list(C.keys()), [])
def testUnion(self):
inputs = self.As + self.Bs
for A in inputs:
for B in inputs:
C = self.union(A, B)
self.assert_(not hasattr(C, "values"))
self.assertEqual(list(C), self._union(A, B))
def testIntersection(self):
inputs = self.As + self.Bs
for A in inputs:
for B in inputs:
C = self.intersection(A, B)
self.assert_(not hasattr(C, "values"))
self.assertEqual(list(C), self._intersection(A, B))
def testDifference(self):
inputs = self.As + self.Bs
for A in inputs:
for B in inputs:
C = self.difference(A, B)
# Difference preserves LHS values.
self.assertEqual(hasattr(C, "values"), hasattr(A, "values"))
want = self._difference(A, B)
if hasattr(A, "values"):
self.assertEqual(list(C.items()), want)
else:
self.assertEqual(list(C), want)
def testLargerInputs(self):
from random import randint
MAXSIZE = 200
MAXVAL = 400
for i in range(3):
n = randint(0, MAXSIZE)
Akeys = [randint(1, MAXVAL) for j in range(n)]
As = [makeset(Akeys) for makeset in self.builders]
Akeys = IISet(Akeys)
n = randint(0, MAXSIZE)
Bkeys = [randint(1, MAXVAL) for j in range(n)]
Bs = [makeset(Bkeys) for makeset in self.builders]
Bkeys = IISet(Bkeys)
for op, simulator in ((self.union, self._union),
(self.intersection, self._intersection),
(self.difference, self._difference)):
for A in As:
for B in Bs:
got = op(A, B)
want = simulator(Akeys, Bkeys)
self.assertEqual(list(got.keys()), want,
(A, B,
Akeys, Bkeys,
list(got.keys()), want))
# Given a mapping builder (IIBTree, OOBucket, etc), return a function
# that builds an object of that type given only a list of keys.
def makeBuilder(mapbuilder):
def result(keys=[], mapbuilder=mapbuilder):
return mapbuilder(zip(keys, keys))
return result
class PureII(SetResult):
from BTrees.IIBTree import union, intersection, difference
builders = IISet, IITreeSet, makeBuilder(IIBTree), makeBuilder(IIBucket)
class PureIO(SetResult):
from BTrees.IOBTree import union, intersection, difference
builders = IOSet, IOTreeSet, makeBuilder(IOBTree), makeBuilder(IOBucket)
class PureOO(SetResult):
from BTrees.OOBTree import union, intersection, difference
builders = OOSet, OOTreeSet, makeBuilder(OOBTree), makeBuilder(OOBucket)
class PureOI(SetResult):
from BTrees.OIBTree import union, intersection, difference
builders = OISet, OITreeSet, makeBuilder(OIBTree), makeBuilder(OIBucket)
# Subclasses must set up (as class variables):
# multiunion, union
# mkset, mktreeset
# mkbucket, mkbtree
class MultiUnion(TestCase):
def testEmpty(self):
self.assertEqual(len(self.multiunion([])), 0)
def testOne(self):
for sequence in [3], range(20), range(-10, 0, 2) + range(1, 10, 2):
seq1 = sequence[:]
seq2 = sequence[:]
seq2.reverse()
seqsorted = sequence[:]
seqsorted.sort()
for seq in seq1, seq2, seqsorted:
for builder in self.mkset, self.mktreeset:
input = builder(seq)
output = self.multiunion([input])
self.assertEqual(len(seq), len(output))
self.assertEqual(seqsorted, list(output))
def testValuesIgnored(self):
for builder in self.mkbucket, self.mkbtree:
input = builder([(1, 2), (3, 4), (5, 6)])
output = self.multiunion([input])
self.assertEqual([1, 3, 5], list(output))
def testBigInput(self):
N = 100000
input = self.mkset(range(N))
output = self.multiunion([input] * 10)
self.assertEqual(len(output), N)
self.assertEqual(output.minKey(), 0)
self.assertEqual(output.maxKey(), N-1)
self.assertEqual(list(output), range(N))
def testLotsOfLittleOnes(self):
from random import shuffle
N = 5000
inputs = []
mkset, mktreeset = self.mkset, self.mktreeset
for i in range(N):
base = i * 4 - N
inputs.append(mkset([base, base+1]))
inputs.append(mktreeset([base+2, base+3]))
shuffle(inputs)
output = self.multiunion(inputs)
self.assertEqual(len(output), N*4)
self.assertEqual(list(output), range(-N, 3*N))
def testFunkyKeyIteration(self):
# The internal set iteration protocol allows "iterating over" a
# a single key as if it were a set.
N = 100
union, mkset = self.union, self.mkset
slow = mkset()
for i in range(N):
slow = union(slow, mkset([i]))
fast = self.multiunion(range(N)) # acts like N distinct singleton sets
self.assertEqual(len(slow), N)
self.assertEqual(len(fast), N)
self.assertEqual(list(slow.keys()), list(fast.keys()))
self.assertEqual(list(fast.keys()), range(N))
class TestIIMultiUnion(MultiUnion):
from BTrees.IIBTree import multiunion, union
from BTrees.IIBTree import IISet as mkset, IITreeSet as mktreeset
from BTrees.IIBTree import IIBucket as mkbucket, IIBTree as mkbtree
class TestIOMultiUnion(MultiUnion):
from BTrees.IOBTree import multiunion, union
from BTrees.IOBTree import IOSet as mkset, IOTreeSet as mktreeset
from BTrees.IOBTree import IOBucket as mkbucket, IOBTree as mkbtree
# Check that various special module functions are and aren't imported from
# the expected BTree modules.
class TestImports(TestCase):
def testWeightedUnion(self):
from BTrees.IIBTree import weightedUnion
from BTrees.OIBTree import weightedUnion
try:
from BTrees.IOBTree import weightedUnion
except ImportError:
pass
else:
self.fail("IOBTree shouldn't have weightedUnion")
try:
from BTrees.OOBTree import weightedUnion
except ImportError:
pass
else:
self.fail("OOBTree shouldn't have weightedUnion")
def testWeightedIntersection(self):
from BTrees.IIBTree import weightedIntersection
from BTrees.OIBTree import weightedIntersection
try:
from BTrees.IOBTree import weightedIntersection
except ImportError:
pass
else:
self.fail("IOBTree shouldn't have weightedIntersection")
try:
from BTrees.OOBTree import weightedIntersection
except ImportError:
pass
else:
self.fail("OOBTree shouldn't have weightedIntersection")
def testMultiunion(self):
from BTrees.IIBTree import multiunion
from BTrees.IOBTree import multiunion
try:
from BTrees.OIBTree import multiunion
except ImportError:
pass
else:
self.fail("OIBTree shouldn't have multiunion")
try:
from BTrees.OOBTree import multiunion
except ImportError:
pass
else:
self.fail("OOBTree shouldn't have multiunion")
# Subclasses must set up (as class variables):
# weightedUnion, weightedIntersection
# builders -- sequence of constructors, taking items
# union, intersection -- the module routines of those names
# mkbucket -- the module bucket builder
class Weighted(TestCase):
def setUp(self):
self.Aitems = [(1, 10), (3, 30), (5, 50), (6, 60)]
self.Bitems = [(2, 21), (3, 31), (4, 41), (6, 61), (7, 71)]
self.As = [make(self.Aitems) for make in self.builders]
self.Bs = [make(self.Bitems) for make in self.builders]
self.emptys = [make([]) for make in self.builders]
weights = []
for w1 in -3, -1, 0, 1, 7:
for w2 in -3, -1, 0, 1, 7:
weights.append((w1, w2))
self.weights = weights
def testBothNone(self):
for op in self.weightedUnion, self.weightedIntersection:
w, C = op(None, None)
self.assert_(C is None)
self.assertEqual(w, 0)
w, C = op(None, None, 42, 666)
self.assert_(C is None)
self.assertEqual(w, 0)
def testLeftNone(self):
for op in self.weightedUnion, self.weightedIntersection:
for A in self.As + self.emptys:
w, C = op(None, A)
self.assert_(C is A)
self.assertEqual(w, 1)
w, C = op(None, A, 42, 666)
self.assert_(C is A)
self.assertEqual(w, 666)
def testRightNone(self):
for op in self.weightedUnion, self.weightedIntersection:
for A in self.As + self.emptys:
w, C = op(A, None)
self.assert_(C is A)
self.assertEqual(w, 1)
w, C = op(A, None, 42, 666)
self.assert_(C is A)
self.assertEqual(w, 42)
# If obj is a set, return a bucket with values all 1; else return obj.
def _normalize(self, obj):
if isaset(obj):
obj = self.mkbucket(zip(obj.keys(), [1] * len(obj)))
return obj
# Python simulation of weightedUnion.
def _wunion(self, A, B, w1=1, w2=1):
if isaset(A) and isaset(B):
return 1, self.union(A, B).keys()
A = self._normalize(A)
B = self._normalize(B)
result = []
for key in self.union(A, B):
v1 = A.get(key, 0)
v2 = B.get(key, 0)
result.append((key, v1*w1 + v2*w2))
return 1, result
def testUnion(self):
inputs = self.As + self.Bs + self.emptys
for A in inputs:
for B in inputs:
want_w, want_s = self._wunion(A, B)
got_w, got_s = self.weightedUnion(A, B)
self.assertEqual(got_w, want_w)
if isaset(got_s):
self.assertEqual(got_s.keys(), want_s)
else:
self.assertEqual(got_s.items(), want_s)
for w1, w2 in self.weights:
want_w, want_s = self._wunion(A, B, w1, w2)
got_w, got_s = self.weightedUnion(A, B, w1, w2)
self.assertEqual(got_w, want_w)
if isaset(got_s):
self.assertEqual(got_s.keys(), want_s)
else:
self.assertEqual(got_s.items(), want_s)
# Python simulation weightedIntersection.
def _wintersection(self, A, B, w1=1, w2=1):
if isaset(A) and isaset(B):
return w1 + w2, self.intersection(A, B).keys()
A = self._normalize(A)
B = self._normalize(B)
result = []
for key in self.intersection(A, B):
result.append((key, A[key]*w1 + B[key]*w2))
return 1, result
def testIntersection(self):
inputs = self.As + self.Bs + self.emptys
for A in inputs:
for B in inputs:
want_w, want_s = self._wintersection(A, B)
got_w, got_s = self.weightedIntersection(A, B)
self.assertEqual(got_w, want_w)
if isaset(got_s):
self.assertEqual(got_s.keys(), want_s)
else:
self.assertEqual(got_s.items(), want_s)
for w1, w2 in self.weights:
want_w, want_s = self._wintersection(A, B, w1, w2)
got_w, got_s = self.weightedIntersection(A, B, w1, w2)
self.assertEqual(got_w, want_w)
if isaset(got_s):
self.assertEqual(got_s.keys(), want_s)
else:
self.assertEqual(got_s.items(), want_s)
# Given a set builder (like OITreeSet or OISet), return a function that
# takes a list of (key, value) pairs and builds a set out of the keys.
def itemsToSet(setbuilder):
def result(items, setbuilder=setbuilder):
return setbuilder([key for key, value in items])
return result
# 'thing' is a bucket, btree, set or treeset. Return true iff it's one of the
# latter two.
def isaset(thing):
return not hasattr(thing, 'values')
class TestWeightedII(Weighted):
from BTrees.IIBTree import weightedUnion, weightedIntersection
from BTrees.IIBTree import union, intersection
from BTrees.IIBTree import IIBucket as mkbucket
builders = IIBucket, IIBTree, itemsToSet(IISet), itemsToSet(IITreeSet)
class TestWeightedOI(Weighted):
from BTrees.OIBTree import weightedUnion, weightedIntersection
from BTrees.OIBTree import union, intersection
from BTrees.OIBTree import OIBucket as mkbucket
builders = OIBucket, OIBTree, itemsToSet(OISet), itemsToSet(OITreeSet)
def test_suite():
s = TestSuite()
for klass in (TestIIMultiUnion, TestIOMultiUnion,
TestImports,
PureII, PureIO, PureOI, PureOO,
TestWeightedII, TestWeightedOI):
s.addTest(makeSuite(klass))
return s
def main():
TextTestRunner().run(test_suite())
if __name__ == '__main__':
main()
=== Zope/lib/python/BTrees/tests/testBTrees.py 1.25.10.1 => 1.25.10.2 === (649/749 lines abridged)
--- Zope/lib/python/BTrees/tests/testBTrees.py:1.25.10.1 Wed Feb 13 11:37:02 2002
+++ Zope/lib/python/BTrees/tests/testBTrees.py Tue Sep 10 17:48:24 2002
@@ -2,14 +2,14 @@
#
# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
# All Rights Reserved.
-#
+#
# This software is subject to the provisions of the Zope Public License,
# Version 2.0 (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 sys, os, time, random
import os, sys
@@ -22,6 +22,21 @@
from glob import glob
+try:
+ from ZODB.tests.StorageTestBase import removefs
+except ImportError:
+ # This method is present in Zope 2.6+, so for 2.5 include here
+ import errno
+ def removefs(base):
+ """Remove all files created by FileStorage with path base."""
+ for ext in '', '.old', '.tmp', '.lock', '.index', '.pack':
+ path = base + ext
+ try:
+ os.remove(path)
+ except os.error, err:
+ if err[0] != errno.ENOENT:
+ raise
+
class Base:
""" Tests common to all types: sets, buckets, and BTrees """
def tearDown(self):
@@ -31,24 +46,24 @@
def _getRoot(self):
from ZODB.FileStorage import FileStorage
from ZODB.DB import DB
- n = 'fs_tmp__%s' % os.getpid()
- s = FileStorage(n)
+ self._fsname = 'fs_tmp__%s' % os.getpid()
+ s = FileStorage(self._fsname)
db = DB(s)
[-=- -=- -=- 649 lines omitted -=- -=- -=-]
+
alltests = TestSuite((TIOSet, TOOSet, TOISet, TIISet,
TIOTreeSet, TOOTreeSet, TOITreeSet, TIITreeSet,
TIOBucket, TOOBucket, TOIBucket, TIIBucket,
- TOOBTree, TIOBTree, TOIBTree, TIIBTree))
+ TIOBTree, TOOBTree, TOIBTree, TIIBTree,
+ makeSuite(TestCmpError),
+ ))
return alltests
@@ -756,19 +1139,32 @@
## utility functions
def lsubtract(l1, l2):
- l1=list(l1)
- l2=list(l2)
- l = filter(lambda x, l1=l1: x not in l1, l2)
- l = l + filter(lambda x, l2=l2: x not in l2, l1)
- return l
+ l1=list(l1)
+ l2=list(l2)
+ l = filter(lambda x, l1=l1: x not in l1, l2)
+ l = l + filter(lambda x, l2=l2: x not in l2, l1)
+ return l
def realseq(itemsob):
return map(lambda x: x, itemsob)
+def permutations(x):
+ # Return a list of all permutations of list x.
+ n = len(x)
+ if n <= 1:
+ return [x]
+ result = []
+ x0 = x[0]
+ for i in range(n):
+ # Build the (n-1)! permutations with x[i] in the first position.
+ xcopy = x[:]
+ first, xcopy[i] = xcopy[i], x0
+ result.extend([[first] + p for p in permutations(xcopy[1:])])
+ return result
+
def main():
TextTestRunner().run(test_suite())
if __name__ == '__main__':
main()
-
=== Zope/lib/python/BTrees/tests/testBTreesUnicode.py 1.5.18.1 => 1.5.18.2 ===
--- Zope/lib/python/BTrees/tests/testBTreesUnicode.py:1.5.18.1 Wed Feb 13 11:37:02 2002
+++ Zope/lib/python/BTrees/tests/testBTreesUnicode.py Tue Sep 10 17:48:24 2002
@@ -2,14 +2,14 @@
#
# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
# All Rights Reserved.
-#
+#
# This software is subject to the provisions of the Zope Public License,
# Version 2.0 (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
-#
+#
##############################################################################
__version__ = '$Id$'
@@ -17,61 +17,56 @@
import unittest,types
from BTrees.OOBTree import OOBTree
-
-# When a OOBtree contains unicode strings as keys,
+# When an OOBtree contains unicode strings as keys,
# it is neccessary accessing non-unicode strings are
# either ascii strings or encoded as unicoded using the
# corresponding encoding
-
encoding = 'ISO-8859-1'
class TestBTreesUnicode(unittest.TestCase):
""" test unicode"""
def setUp(self):
- """ setup an OOBTree with some unicode strings """
+ """setup an OOBTree with some unicode strings"""
- self.s = unicode('dreit\xe4gigen','latin1')
+ self.s = unicode('dreit\xe4gigen', 'latin1')
- self.data = [('alien', 284708388),
- ('k\xf6nnten', 284708389),
- ('fox', 284708387),
- ('future', 284708388),
- ('quick', 284708387),
- ('zerst\xf6rt', 284708389),
- (unicode('dreit\xe4gigen','latin1'), 284708391)
- ]
+ self.data = [('alien', 1),
+ ('k\xf6nnten', 2),
+ ('fox', 3),
+ ('future', 4),
+ ('quick', 5),
+ ('zerst\xf6rt', 6),
+ (unicode('dreit\xe4gigen','latin1'), 7),
+ ]
self.tree = OOBTree()
- for k,v in self.data:
- if isinstance(k,types.StringType):
- self.tree[unicode(k,'latin1')]=v
- else:
- self.tree[k]=v
-
-
-
- def test1(self):
- """ check every item of the tree """
-
for k, v in self.data:
- if isinstance(k,types.StringType):
- key = unicode(k,encoding)
- else:
- key = k
-
- if self.tree[key]!=v:
- print "fehler"
-
-
- def test2(self):
- """ try to access unicode keys in tree"""
-
- assert self.data[-1][0]== self.s
- assert self.tree[self.data[-1][0]]== self.data[-1][1]
- assert self.tree[self.s]== self.data[-1][1],''
+ if isinstance(k, types.StringType):
+ k = unicode(k, 'latin1')
+ self.tree[k] = v
+ def testAllKeys(self):
+ # check every item of the tree
+ for k, v in self.data:
+ if isinstance(k, types.StringType):
+ k = unicode(k, encoding)
+ self.assert_(self.tree.has_key(k))
+ self.assertEqual(self.tree[k], v)
+
+ def testUnicodeKeys(self):
+ # try to access unicode keys in tree
+ k, v = self.data[-1]
+ self.assertEqual(k, self.s)
+ self.assertEqual(self.tree[k], v)
+ self.assertEqual(self.tree[self.s], v)
+
+ def testAsciiKeys(self):
+ # try to access some "plain ASCII" keys in the tree
+ for k, v in self.data[0], self.data[2]:
+ self.assert_(isinstance(k, types.StringType))
+ self.assertEqual(self.tree[k], v)
def test_suite():
return unittest.makeSuite(TestBTreesUnicode)
@@ -81,4 +76,3 @@
if __name__ == '__main__':
main()
-
=== Zope/lib/python/BTrees/tests/testConflict.py 1.10.18.1 => 1.10.18.2 ===
--- Zope/lib/python/BTrees/tests/testConflict.py:1.10.18.1 Wed Feb 13 11:37:02 2002
+++ Zope/lib/python/BTrees/tests/testConflict.py Tue Sep 10 17:48:24 2002
@@ -2,16 +2,16 @@
#
# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
# All Rights Reserved.
-#
+#
# This software is subject to the provisions of the Zope Public License,
# Version 2.0 (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 sys, os, time, random
+import os
from BTrees.OOBTree import OOBTree, OOBucket, OOSet, OOTreeSet
from BTrees.IOBTree import IOBTree, IOBucket, IOSet, IOTreeSet
@@ -50,26 +50,18 @@
del self.t[1]
def _setupConflict(self):
- base=self.t
- d={}
- for i in range(20):
- d[random.randrange(-10000, 10001)]=i*100000
-
- e1={}
- while len(e1) < 5:
- k=random.randrange(-10000, 10001)
- if not d.has_key(k):
- e1[k]=len(e1)
- e1=e1.items()
-
- e2={}
- while len(e2) < 5:
- k=random.randrange(-10000, 10001)
- if not d.has_key(k) and not e2.has_key(k):
- e2[k]=len(e2)
- e2=e2.items()
- base.update(d)
+ l=[ -5124, -7377, 2274, 8801, -9901, 7327, 1565, 17, -679,
+ 3686, -3607, 14, 6419, -5637, 6040, -4556, -8622, 3847, 7191,
+ -4067]
+
+
+ e1=[(-1704, 0), (5420, 1), (-239, 2), (4024, 3), (-6984, 4)]
+ e2=[(7745, 0), (4868, 1), (-2548, 2), (-2711, 3), (-3154, 4)]
+
+
+ base=self.t
+ base.update([(i, i*i) for i in l[:20]])
b1=base.__class__(base)
b2=base.__class__(base)
bm=base.__class__(base)
@@ -134,7 +126,7 @@
b2[items[0][0]]=-9
test_merge(base, b1, b2, bm, 'merge conflicting update and delete',
should_fail=1)
-
+
def testMergeInserts(self):
base, b1, b2, bm, e1, e2, items = self._setupConflict()
@@ -148,7 +140,7 @@
bm[99999]=99999
bm[e1[2][0]]=e1[2][1]
test_merge(base, b1, b2, bm, 'merge insert')
-
+
def testMergeInsertsFromEmpty(self):
base, b1, b2, bm, e1, e2, items = self._setupConflict()
@@ -163,7 +155,7 @@
bm.update(e2)
test_merge(base, b1, b2, bm, 'merge insert from empty')
-
+
def testMergeEmptyAndFill(self):
base, b1, b2, bm, e1, e2, items = self._setupConflict()
@@ -173,7 +165,7 @@
bm.update(e2)
test_merge(base, b1, b2, bm, 'merge insert from empty')
-
+
def testMergeEmpty(self):
base, b1, b2, bm, e1, e2, items = self._setupConflict()
@@ -190,7 +182,7 @@
b2[e1[0][0]]=e1[0][1]
test_merge(base, b1, b2, bm, 'merge conflicting inserts',
should_fail=1)
-
+
class NormalSetTests(Base):
""" Test common to all set types """
@@ -201,26 +193,16 @@
"Set (as opposed to TreeSet) specific tests."
def _setupConflict(self):
- base=self.t
- d={}
- for i in range(20):
- d[random.randrange(-10000, 10001)]=i*100000
-
- e1={}
- while len(e1) < 5:
- k=random.randrange(-10000, 10001)
- if not d.has_key(k):
- e1[k]=len(e1)
- e1=e1.keys()
-
- e2={}
- while len(e2) < 5:
- k=random.randrange(-10000, 10001)
- if not d.has_key(k) and not e2.has_key(k):
- e2[k]=len(e2)
- e2=e2.keys()
+ l=[ -5124, -7377, 2274, 8801, -9901, 7327, 1565, 17, -679,
+ 3686, -3607, 14, 6419, -5637, 6040, -4556, -8622, 3847, 7191,
+ -4067]
+
+ e1=[-1704, 5420, -239, 4024, -6984]
+ e2=[7745, 4868, -2548, -2711, -3154]
- base.update(d.keys())
+
+ base=self.t
+ base.update(l)
b1=base.__class__(base)
b2=base.__class__(base)
bm=base.__class__(base)
@@ -247,7 +229,7 @@
b2.remove(items[0])
test_merge(base, b1, b2, bm, 'merge conflicting delete',
should_fail=1)
-
+
def testMergeInserts(self):
base, b1, b2, bm, e1, e2, items = self._setupConflict()
@@ -261,7 +243,7 @@
bm.insert(99999)
bm.insert(e1[2])
test_merge(base, b1, b2, bm, 'merge insert')
-
+
def testMergeInsertsFromEmpty(self):
base, b1, b2, bm, e1, e2, items = self._setupConflict()
@@ -276,7 +258,7 @@
bm.update(e2)
test_merge(base, b1, b2, bm, 'merge insert from empty')
-
+
def testMergeEmptyAndFill(self):
base, b1, b2, bm, e1, e2, items = self._setupConflict()
@@ -286,7 +268,7 @@
bm.update(e2)
test_merge(base, b1, b2, bm, 'merge insert from empty')
-
+
def testMergeEmpty(self):
base, b1, b2, bm, e1, e2, items = self._setupConflict()
@@ -303,7 +285,7 @@
b2.insert(e1[0])
test_merge(base, b1, b2, bm, 'merge conflicting inserts',
should_fail=1)
-
+
def test_merge(o1, o2, o3, expect, message='failed to merge', should_fail=0):
s1=o1.__getstate__()
@@ -322,10 +304,10 @@
else:
merged=o1._p_resolveConflict(s1, s2, s3)
assert merged==expected, message
-
+
class BucketTests(MappingBase):
""" Tests common to all buckets """
-
+
class BTreeTests(MappingBase):
""" Tests common to all BTrees """
@@ -369,7 +351,7 @@
class TestIOTreeSets(NormalSetTests, TestCase):
def setUp(self):
self.t = IOTreeSet()
-
+
class TestOOTreeSets(NormalSetTests, TestCase):
def setUp(self):
self.t = OOTreeSet()
@@ -381,7 +363,7 @@
class TestOITreeSets(NormalSetTests, TestCase):
def setUp(self):
self.t = OITreeSet()
-
+
## Bucket tests
class TestIOBuckets(BucketTests, TestCase):
@@ -400,6 +382,7 @@
def setUp(self):
self.t = OIBucket()
+# XXX disable tests for now
def test_suite():
TIOBTree = makeSuite(TestIOBTrees, 'test')
TOOBTree = makeSuite(TestOOBTrees, 'test')
@@ -420,7 +403,7 @@
TOOBucket = makeSuite(TestOOBuckets, 'test')
TOIBucket = makeSuite(TestOIBuckets, 'test')
TIIBucket = makeSuite(TestIIBuckets, 'test')
-
+
alltests = TestSuite((TIOSet, TOOSet, TOISet, TIISet,
TIOTreeSet, TOOTreeSet, TOITreeSet, TIITreeSet,
TIOBucket, TOOBucket, TOIBucket, TIIBucket,
@@ -431,11 +414,11 @@
## utility functions
def lsubtract(l1, l2):
- l1=list(l1)
- l2=list(l2)
- l = filter(lambda x, l1=l1: x not in l1, l2)
- l = l + filter(lambda x, l2=l2: x not in l2, l1)
- return l
+ l1=list(l1)
+ l2=list(l2)
+ l = filter(lambda x, l1=l1: x not in l1, l2)
+ l = l + filter(lambda x, l2=l2: x not in l2, l1)
+ return l
def realseq(itemsob):
return map(lambda x: x, itemsob)
@@ -445,4 +428,3 @@
if __name__ == '__main__':
main()
-