[Checkins] SVN: BTrees/branches/pure_python/ Move II-related set-op tests into II test module.
Tres Seaver
cvs-admin at zope.org
Sun Nov 11 18:55:48 UTC 2012
Log message for revision 128221:
Move II-related set-op tests into II test module.
Changed:
_U BTrees/branches/pure_python/
U BTrees/branches/pure_python/BTrees/tests/common.py
U BTrees/branches/pure_python/BTrees/tests/testSetOps.py
U BTrees/branches/pure_python/BTrees/tests/test_IIBTree.py
-=-
Modified: BTrees/branches/pure_python/BTrees/tests/common.py
===================================================================
--- BTrees/branches/pure_python/BTrees/tests/common.py 2012-11-09 21:26:19 UTC (rev 128220)
+++ BTrees/branches/pure_python/BTrees/tests/common.py 2012-11-11 18:55:46 UTC (rev 128221)
@@ -1496,7 +1496,363 @@
ValueError,
self._set_value, k1, LARGEST_NEGATIVE_65_BITS)
+# 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
+# Subclasses have to set up:
+# builders() - function returning functions to build inputs,
+# each returned callable tkes an optional keys arg
+# intersection, union, difference - set to the type-correct versions
+class SetResult(object):
+ 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)
+ for e in y:
+ if e not in result:
+ result.append(e)
+ result.sort()
+ return result
+
+ def _intersection(self, x, y):
+ result = []
+ for e in x:
+ if e in y:
+ result.append(e)
+ return result
+
+ def _difference(self, x, y):
+ result = list(x)
+ for e in y:
+ 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 == 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), [])
+
+ 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 BTrees.IIBTree import IISet
+ 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), want,
+ (A, B, Akeys, Bkeys, list(got), want))
+
+# 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(object):
+
+ 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, [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')
+
+# Subclasses must set up (as class variables):
+# multiunion, union
+# mkset, mktreeset
+# mkbucket, mkbtree
+class MultiUnion(object):
+
+ 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), list(fast))
+ self.assertEqual(list(fast), range(N))
+
+
## utility functions
def lsubtract(l1, l2):
Modified: BTrees/branches/pure_python/BTrees/tests/testSetOps.py
===================================================================
--- BTrees/branches/pure_python/BTrees/tests/testSetOps.py 2012-11-09 21:26:19 UTC (rev 128220)
+++ BTrees/branches/pure_python/BTrees/tests/testSetOps.py 2012-11-11 18:55:46 UTC (rev 128221)
@@ -13,159 +13,12 @@
##############################################################################
import unittest
-# Subclasses have to set up:
-# builders() - function returning functions to build inputs,
-# each returned callable tkes an optional keys arg
-# intersection, union, difference - set to the type-correct versions
-class SetResult(object):
- 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()]
+from .common import MultiUnion
+from .common import SetResult
+from .common import Weighted
+from .common import itemsToSet
+from .common import makeBuilder
- # Slow but obviously correct Python implementations of basic ops.
- def _union(self, x, y):
- result = list(x)
- for e in y:
- if e not in result:
- result.append(e)
- result.sort()
- return result
-
- def _intersection(self, x, y):
- result = []
- for e in x:
- if e in y:
- result.append(e)
- return result
-
- def _difference(self, x, y):
- result = list(x)
- for e in y:
- 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 == 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), [])
-
- 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 BTrees.IIBTree import IISet
- 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), want,
- (A, B, Akeys, Bkeys, list(got), 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 PureOO(SetResult, unittest.TestCase):
def union(self, *args):
from BTrees.OOBTree import union
@@ -183,23 +36,6 @@
from BTrees.OOBTree import OOSet
return OOSet, OOTreeSet, makeBuilder(OOBTree), makeBuilder(OOBucket)
-class PureII(SetResult, unittest.TestCase):
- def union(self, *args):
- from BTrees.IIBTree import union
- return union(*args)
- def intersection(self, *args):
- from BTrees.IIBTree import intersection
- return intersection(*args)
- def difference(self, *args):
- from BTrees.IIBTree import difference
- return difference(*args)
- def builders(self):
- from BTrees.IIBTree import IIBTree
- from BTrees.IIBTree import IIBucket
- from BTrees.IIBTree import IITreeSet
- from BTrees.IIBTree import IISet
- return IISet, IITreeSet, makeBuilder(IIBTree), makeBuilder(IIBucket)
-
class PureIO(SetResult, unittest.TestCase):
def union(self, *args):
from BTrees.IOBTree import union
@@ -319,92 +155,6 @@
from BTrees.OLBTree import OLSet
return OLSet, OLTreeSet, makeBuilder(OLBTree), makeBuilder(OLBucket)
-# Subclasses must set up (as class variables):
-# multiunion, union
-# mkset, mktreeset
-# mkbucket, mkbtree
-class MultiUnion(object):
-
- 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), list(fast))
- self.assertEqual(list(fast), range(N))
-
-class TestIIMultiUnion(MultiUnion, unittest.TestCase):
- def multiunion(self, *args):
- from BTrees.IIBTree import multiunion
- return multiunion(*args)
- def union(self, *args):
- from BTrees.IIBTree import union
- return union(*args)
- def mkset(self, *args):
- from BTrees.IIBTree import IISet as mkset
- return mkset(*args)
- def mktreeset(self, *args):
- from BTrees.IIBTree import IITreeSet as mktreeset
- return mktreeset(*args)
- def mkbucket(self, *args):
- from BTrees.IIBTree import IIBucket as mkbucket
- return mkbucket(*args)
- def mkbtree(self, *args):
- from BTrees.IIBTree import IIBTree as mkbtree
- return mkbtree(*args)
-
class TestIOMultiUnion(MultiUnion, unittest.TestCase):
def multiunion(self, *args):
from BTrees.IOBTree import multiunion
@@ -592,161 +342,6 @@
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(object):
-
- 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, [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
-
-class TestWeightedII(Weighted, unittest.TestCase):
- def weightedUnion(self):
- from BTrees.IIBTree import weightedUnion
- return weightedUnion
- def weightedIntersection(self):
- from BTrees.IIBTree import weightedIntersection
- return weightedIntersection
- def union(self):
- from BTrees.IIBTree import union
- return union
- def intersection(self):
- from BTrees.IIBTree import intersection
- return intersection
- def mkbucket(self, *args):
- from BTrees.IIBTree import IIBucket as mkbucket
- return mkbucket(*args)
- def builders(self):
- from BTrees.IIBTree import IIBTree
- from BTrees.IIBTree import IIBucket
- from BTrees.IIBTree import IITreeSet
- from BTrees.IIBTree import IISet
- return IIBucket, IIBTree, itemsToSet(IISet), itemsToSet(IITreeSet)
-
class TestWeightedOI(Weighted, unittest.TestCase):
def weightedUnion(self):
from BTrees.OIBTree import weightedUnion
@@ -817,32 +412,32 @@
return OLBucket, OLBTree, itemsToSet(OLSet), itemsToSet(OLTreeSet)
-# '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')
-
-
def test_suite():
return unittest.TestSuite((
- unittest.makeSuite(TestIIMultiUnion),
+
unittest.makeSuite(TestIOMultiUnion),
+ unittest.makeSuite(PureIO),
+
unittest.makeSuite(TestIFMultiUnion),
+ unittest.makeSuite(PureIF),
+
unittest.makeSuite(TestLLMultiUnion),
+ unittest.makeSuite(PureLL),
+ unittest.makeSuite(TestWeightedLL),
+
unittest.makeSuite(TestLOMultiUnion),
+ unittest.makeSuite(PureLO),
+
unittest.makeSuite(TestLFMultiUnion),
- unittest.makeSuite(TestImports),
+ unittest.makeSuite(PureLF),
+
unittest.makeSuite(PureOO),
- unittest.makeSuite(PureII),
- unittest.makeSuite(PureIO),
- unittest.makeSuite(PureIF),
+
unittest.makeSuite(PureOI),
- unittest.makeSuite(PureLL),
- unittest.makeSuite(PureLO),
- unittest.makeSuite(PureLF),
- unittest.makeSuite(PureOL),
- unittest.makeSuite(TestWeightedII),
unittest.makeSuite(TestWeightedOI),
- unittest.makeSuite(TestWeightedLL),
+
+ unittest.makeSuite(PureOL),
unittest.makeSuite(TestWeightedOL),
+
+ unittest.makeSuite(TestImports),
))
Modified: BTrees/branches/pure_python/BTrees/tests/test_IIBTree.py
===================================================================
--- BTrees/branches/pure_python/BTrees/tests/test_IIBTree.py 2012-11-09 21:26:19 UTC (rev 128220)
+++ BTrees/branches/pure_python/BTrees/tests/test_IIBTree.py 2012-11-11 18:55:46 UTC (rev 128221)
@@ -13,16 +13,21 @@
##############################################################################
import unittest
-from BTrees.tests.common import BTreeTests
-from BTrees.tests.common import ExtendedSetTests
-from BTrees.tests.common import I_SetsBase
-from BTrees.tests.common import InternalKeysMappingTest
-from BTrees.tests.common import InternalKeysSetTest
-from BTrees.tests.common import MappingBase
-from BTrees.tests.common import ModuleTest
-from BTrees.tests.common import NormalSetTests
-from BTrees.tests.common import TestLongIntKeys
-from BTrees.tests.common import TestLongIntValues
+from .common import BTreeTests
+from .common import ExtendedSetTests
+from .common import I_SetsBase
+from .common import InternalKeysMappingTest
+from .common import InternalKeysSetTest
+from .common import MappingBase
+from .common import ModuleTest
+from .common import MultiUnion
+from .common import NormalSetTests
+from .common import SetResult
+from .common import TestLongIntKeys
+from .common import TestLongIntValues
+from .common import Weighted
+from .common import itemsToSet
+from .common import makeBuilder
from BTrees.IIBTree import using64bits #XXX Ugly, but unavoidable
@@ -162,7 +167,69 @@
return IITreeSet()
+class PureII(SetResult, unittest.TestCase):
+ def union(self, *args):
+ from BTrees.IIBTree import union
+ return union(*args)
+ def intersection(self, *args):
+ from BTrees.IIBTree import intersection
+ return intersection(*args)
+ def difference(self, *args):
+ from BTrees.IIBTree import difference
+ return difference(*args)
+ def builders(self):
+ from BTrees.IIBTree import IIBTree
+ from BTrees.IIBTree import IIBucket
+ from BTrees.IIBTree import IITreeSet
+ from BTrees.IIBTree import IISet
+ return IISet, IITreeSet, makeBuilder(IIBTree), makeBuilder(IIBucket)
+
+class TestIIMultiUnion(MultiUnion, unittest.TestCase):
+ def multiunion(self, *args):
+ from BTrees.IIBTree import multiunion
+ return multiunion(*args)
+ def union(self, *args):
+ from BTrees.IIBTree import union
+ return union(*args)
+ def mkset(self, *args):
+ from BTrees.IIBTree import IISet as mkset
+ return mkset(*args)
+ def mktreeset(self, *args):
+ from BTrees.IIBTree import IITreeSet as mktreeset
+ return mktreeset(*args)
+ def mkbucket(self, *args):
+ from BTrees.IIBTree import IIBucket as mkbucket
+ return mkbucket(*args)
+ def mkbtree(self, *args):
+ from BTrees.IIBTree import IIBTree as mkbtree
+ return mkbtree(*args)
+
+class TestWeightedII(Weighted, unittest.TestCase):
+ def weightedUnion(self):
+ from BTrees.IIBTree import weightedUnion
+ return weightedUnion
+ def weightedIntersection(self):
+ from BTrees.IIBTree import weightedIntersection
+ return weightedIntersection
+ def union(self):
+ from BTrees.IIBTree import union
+ return union
+ def intersection(self):
+ from BTrees.IIBTree import intersection
+ return intersection
+ def mkbucket(self, *args):
+ from BTrees.IIBTree import IIBucket as mkbucket
+ return mkbucket(*args)
+ def builders(self):
+ from BTrees.IIBTree import IIBTree
+ from BTrees.IIBTree import IIBucket
+ from BTrees.IIBTree import IITreeSet
+ from BTrees.IIBTree import IISet
+ return IIBucket, IIBTree, itemsToSet(IISet), itemsToSet(IITreeSet)
+
+
+
def test_suite():
return unittest.TestSuite((
unittest.makeSuite(IIBTreeInternalKeyTest),
@@ -175,4 +242,7 @@
unittest.makeSuite(TestIIBTrees),
unittest.makeSuite(TestIISets),
unittest.makeSuite(TestIITreeSets),
+ unittest.makeSuite(TestIIMultiUnion),
+ unittest.makeSuite(PureII),
+ unittest.makeSuite(TestWeightedII),
))
More information about the checkins
mailing list