[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()
-