WIP towards unsigned keys and values.

test__UUBTree.py is complete and passing on Python 3

BTrees/BTreeModuleTemplate.c

@@ -78,11 +78,40 @@ static void PyVar_Assign(PyObject **v, PyObject *e) { Py_XDECREF(*v); *v=e;}
 #endif
 
 #ifdef NEED_LONG_LONG_KEYS
+#if defined(ZODB_UNSIGNED_VALUE_INTS) || defined(ZODB_UNSIGNED_KEY_INTS)
+static int
+ulonglong_check(PyObject *ob)
+{
+#ifndef PY3K
+    if (PyInt_Check(ob))
+    {
+	long tmp;
+	tmp = PyInt_AS_LONG(ob);
+	if (tmp < 0) {
+	    PyErr_SetString(PyExc_OverflowError, "unsigned value less than 0");
+	    return 0;
+	}
+	return 1;
+    }
+#endif
+
+    if (!PyLong_Check(ob))
+	return 0;
+
+    if (PyLong_AsUnsignedLongLong(ob) == (unsigned long long)-1 && PyErr_Occurred())
+	return 0;
+    return 1;
+}
+#endif /* defined(ZODB_UNSIGNED_VALUE_INTS) || defined(ZODB_UNSIGNED_KEY_INTS) */
+
 static int
 longlong_check(PyObject *ob)
 {
-    if (INT_CHECK(ob))
+#ifndef PY3K
+    /* Python's small integers can always fit into a long long. */
+    if (PyInt_Check(ob))
         return 1;
+#endif
 
     if (PyLong_Check(ob)) {
         int overflow;
@@ -97,8 +126,50 @@ overflow:
                     "longlong_check: long integer out of range");
     return 0;
 }
+
 #endif
 
+#if defined(ZODB_UNSIGNED_VALUE_INTS) || defined(ZODB_UNSIGNED_KEY_INTS)
+static PyObject *
+ulonglong_as_object(unsigned PY_LONG_LONG val)
+{
+    if ((val > LONG_MAX))
+        return PyLong_FromUnsignedLongLong(val);
+    return UINT_FROM_LONG((unsigned long)val);
+}
+
+static int
+ulonglong_convert(PyObject *ob, unsigned PY_LONG_LONG *value)
+{
+#ifndef PY3K
+    if (PyInt_Check(ob))
+    {
+	long tmp;
+	tmp = PyInt_AS_LONG(ob);
+	if (tmp < 0) {
+	    PyErr_SetString(PyExc_OverflowError, "unsigned value less than 0");
+	    return 0;
+	}
+        (*value) = (unsigned PY_LONG_LONG)tmp;
+        return 1;
+    }
+#endif
+
+    if (!PyLong_Check(ob))
+    {
+        PyErr_SetString(PyExc_TypeError, "expected integer key");
+        return 0;
+    }
+
+    unsigned PY_LONG_LONG val;
+    val = PyLong_AsUnsignedLongLong(ob);
+    if (val == (unsigned long long)-1 && PyErr_Occurred())
+	return 0;
+    (*value) = val;
+    return 1;
+}
+#endif /* defined(ZODB_UNSIGNED_VALUE_INTS) || defined(ZODB_UNSIGNED_KEY_INTS) */
+
 static PyObject *
 longlong_as_object(PY_LONG_LONG val)
 {
@@ -107,7 +178,6 @@ longlong_as_object(PY_LONG_LONG val)
     return INT_FROM_LONG((long)val);
 }
 
-
 static int
 longlong_convert(PyObject *ob, PY_LONG_LONG *value)
 {
@@ -138,6 +208,7 @@ overflow:
     PyErr_SetString(PyExc_ValueError, "long integer out of range");
     return 0;
 }
+
 #endif  /* NEED_LONG_LONG_SUPPORT */
 
 

BTrees/IUBTree.py

+##############################################################################
+#
+# Copyright (c) 2001-2012 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
+#
+##############################################################################
+
+__all__ = ('Bucket', 'Set', 'BTree', 'TreeSet',
+           'IUBucket', 'IUSet', 'IUBTree', 'IUTreeSet',
+           'union', 'intersection', 'difference',
+           'weightedUnion', 'weightedIntersection', 'multiunion',
+          )
+
+from zope.interface import moduleProvides
+
+from .Interfaces import IIntegerUnsignedBTreeModule
+from ._base import Bucket
+from ._base import MERGE
+from ._base import MERGE_WEIGHT_numeric
+from ._base import MERGE_DEFAULT_int
+from ._base import Set
+from ._base import Tree as BTree
+from ._base import TreeSet
+from ._base import _TreeIterator
+from ._base import difference as _difference
+from ._base import intersection as _intersection
+from ._base import multiunion as _multiunion
+from ._base import set_operation as _set_operation
+from ._base import to_int as _to_key
+from ._base import to_uint as _to_value
+from ._base import union as _union
+from ._base import weightedIntersection as _weightedIntersection
+from ._base import weightedUnion as _weightedUnion
+from ._base import _fix_pickle
+from ._compat import import_c_extension
+
+_BUCKET_SIZE = 120
+_TREE_SIZE = 500
+using64bits = False
+
+
+class IUBucketPy(Bucket):
+    _to_key = _to_key
+    _to_value = _to_value
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class IUSetPy(Set):
+    _to_key = _to_key
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class IUBTreePy(BTree):
+    max_leaf_size = _BUCKET_SIZE
+    max_internal_size = _TREE_SIZE
+    _to_key = _to_key
+    _to_value = _to_value
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class IUTreeSetPy(TreeSet):
+    max_leaf_size = _BUCKET_SIZE
+    max_internal_size = _TREE_SIZE
+    _to_key = _to_key
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class IUTreeIteratorPy(_TreeIterator):
+    pass
+
+
+# Can't declare forward refs, so fix up afterwards:
+
+IUBucketPy._mapping_type = IUBucketPy._bucket_type = IUBucketPy
+IUBucketPy._set_type = IUSetPy
+
+IUSetPy._mapping_type = IUBucketPy
+IUSetPy._set_type = IUSetPy._bucket_type = IUSetPy
+
+IUBTreePy._mapping_type = IUBTreePy._bucket_type = IUBucketPy
+IUBTreePy._set_type = IUSetPy
+
+IUTreeSetPy._mapping_type = IUBucketPy
+IUTreeSetPy._set_type = IUTreeSetPy._bucket_type = IUSetPy
+
+
+differencePy = _set_operation(_difference, IUSetPy)
+unionPy = _set_operation(_union, IUSetPy)
+intersectionPy = _set_operation(_intersection, IUSetPy)
+multiunionPy = _set_operation(_multiunion, IUSetPy)
+weightedUnionPy = _set_operation(_weightedUnion, IUSetPy)
+weightedIntersectionPy = _set_operation(_weightedIntersection, IUSetPy)
+
+import_c_extension(globals())
+
+_fix_pickle(globals(), __name__)
+
+moduleProvides(IIntegerUnsignedBTreeModule)

BTrees/Interfaces.py

@@ -451,40 +451,78 @@ class IMergeIntegerKey(IMerge):
 
 class IBTreeFamily(Interface):
     """the 64-bit or 32-bit family"""
+    IF = Attribute('The IIntegerFloatBTreeModule for this family')
+    II = Attribute('The IIntegerIntegerBTreeModule for this family')
     IO = Attribute('The IIntegerObjectBTreeModule for this family')
+    IU = Attribute('The IIntegerUnsignedBTreeModule for this family')
+
+    UF = Attribute('The IUnsignedFloatBTreeModule for this family')
+    UI = Attribute('The IUnsignedIntegerBTreeModule for this family')
+    UO = Attribute('The IUnsignedObjectBTreeModule for this family')
+    UU = Attribute('The IUnsignedUnsignedBTreeModule for this family')
+
     OI = Attribute('The IObjectIntegerBTreeModule for this family')
-    II = Attribute('The IIntegerIntegerBTreeModule for this family')
-    IF = Attribute('The IIntegerFloatBTreeModule for this family')
     OO = Attribute('The IObjectObjectBTreeModule for this family')
-    maxint = Attribute('The maximum integer storable in this family')
-    minint = Attribute('The minimum integer storable in this family')
+    OU = Attribute('The IObjectUnsignedBTreeModule for this family')
+
+    maxint = Attribute('The maximum signed integer storable in this family')
+    maxuint = Attribute('The maximum unsigned integer storable in this family')
+    minint = Attribute('The minimum signed integer storable in this family')
 
 
-class IIntegerObjectBTreeModule(IBTreeModule, IMerge):
-    """keys, or set values, are integers; values are objects.
+class _IMergeBTreeModule(IBTreeModule, IMerge):
+    family = Attribute('The IBTreeFamily of this module')
+
+
+class IIntegerObjectBTreeModule(_IMergeBTreeModule):
+    """keys, or set values, are signed integers; values are objects.
 
     describes IOBTree and LOBTree"""
 
-    family = Attribute('The IBTreeFamily of this module')
+
+class IUnsignedObjectBTreeModule(_IMergeBTreeModule):
+    """
+    As for `IIntegerObjectBTreeModule` with unsigned integers.
+    """
 
 
-class IObjectIntegerBTreeModule(IBTreeModule, IIMerge):
-    """keys, or set values, are objects; values are integers.
+class IObjectIntegerBTreeModule(_IMergeBTreeModule):
+    """keys, or set values, are objects; values are signed integers.
 
     Object keys (and set values) must sort reliably (for instance, *not* on
     object id)!  Homogenous key types recommended.
 
     describes OIBTree and LOBTree"""
 
-    family = Attribute('The IBTreeFamily of this module')
 
+class IObjectUnsignedBTreeModule(_IMergeBTreeModule):
+    """
+    As for `IObjectIntegerBTreeModule` with unsigned integers.
+    """
 
-class IIntegerIntegerBTreeModule(IBTreeModule, IIMerge, IMergeIntegerKey):
-    """keys, or set values, are integers; values are also integers.
+
+class IIntegerIntegerBTreeModule(_IMergeBTreeModule, IMergeIntegerKey):
+    """keys, or set values, are signed integers; values are also signed integers.
 
     describes IIBTree and LLBTree"""
 
-    family = Attribute('The IBTreeFamily of this module')
+
+class IUnsignedUnsignedBTreeModule(_IMergeBTreeModule, IMergeIntegerKey):
+    """
+    As for `IIntegerIntegerBTreeModule` with unsigned integers.
+    """
+
+
+class IUnsignedIntegerBTreeModule(_IMergeBTreeModule, IMergeIntegerKey):
+    """
+    As for `IIntegerIntegerBTreeModule` with unsigned integers for keys only.
+    """
+
+
+class IIntegerUnsignedBTreeModule(_IMergeBTreeModule, IMergeIntegerKey):
+    """
+    As for `IIntegerIntegerBTreeModule` with unsigned integers for values only.
+    """
 
 
 class IObjectObjectBTreeModule(IBTreeModule, IMerge):
@@ -499,12 +537,15 @@ class IObjectObjectBTreeModule(IBTreeModule, IMerge):
     # the OO flavor of BTrees.
 
 
-class IIntegerFloatBTreeModule(IBTreeModule, IMerge):
-    """keys, or set values, are integers; values are floats.
+class IIntegerFloatBTreeModule(_IMergeBTreeModule):
+    """keys, or set values, are signed integers; values are floats.
 
     describes IFBTree and LFBTree"""
 
-    family = Attribute('The IBTreeFamily of this module')
+class IUnsignedFloatBTreeModule(_IMergeBTreeModule):
+    """
+    As for `IIntegerFloatBTreeModule` with unsigned integers.
+    """
 
 
 try:

BTrees/LQBTree.py

+##############################################################################
+#
+# Copyright (c) 2001-2012 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
+#
+##############################################################################
+
+__all__ = ('Bucket', 'Set', 'BTree', 'TreeSet',
+           'LQBucket', 'LQSet', 'LQBTree', 'LQTreeSet',
+           'union', 'intersection', 'difference',
+           'weightedUnion', 'weightedIntersection', 'multiunion',
+          )
+
+from zope.interface import moduleProvides
+
+from .Interfaces import IIntegerUnsignedBTreeModule
+from ._base import Bucket
+from ._base import MERGE
+from ._base import MERGE_WEIGHT_numeric
+from ._base import MERGE_DEFAULT_int
+from ._base import Set
+from ._base import Tree as BTree
+from ._base import TreeSet
+from ._base import _TreeIterator
+from ._base import difference as _difference
+from ._base import intersection as _intersection
+from ._base import multiunion as _multiunion
+from ._base import set_operation as _set_operation
+from ._base import to_long as _to_key
+from ._base import to_ulong as _to_value
+from ._base import union as _union
+from ._base import weightedIntersection as _weightedIntersection
+from ._base import weightedUnion as _weightedUnion
+from ._base import _fix_pickle
+from ._compat import import_c_extension
+
+_BUCKET_SIZE = 120
+_TREE_SIZE = 500
+using64bits = True
+
+
+class LQBucketPy(Bucket):
+    _to_key = _to_key
+    _to_value = _to_value
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class LQSetPy(Set):
+    _to_key = _to_key
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class LQBTreePy(BTree):
+    max_leaf_size = _BUCKET_SIZE
+    max_internal_size = _TREE_SIZE
+    _to_key = _to_key
+    _to_value = _to_value
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class LQTreeSetPy(TreeSet):
+    max_leaf_size = _BUCKET_SIZE
+    max_internal_size = _TREE_SIZE
+    _to_key = _to_key
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class LQTreeIteratorPy(_TreeIterator):
+    pass
+
+
+# Can't declare forward refs, so fix up afterwards:
+
+LQBucketPy._mapping_type = LQBucketPy._bucket_type = LQBucketPy
+LQBucketPy._set_type = LQSetPy
+
+LQSetPy._mapping_type = LQBucketPy
+LQSetPy._set_type = LQSetPy._bucket_type = LQSetPy
+
+LQBTreePy._mapping_type = LQBTreePy._bucket_type = LQBucketPy
+LQBTreePy._set_type = LQSetPy
+
+LQTreeSetPy._mapping_type = LQBucketPy
+LQTreeSetPy._set_type = LQTreeSetPy._bucket_type = LQSetPy
+
+
+differencePy = _set_operation(_difference, LQSetPy)
+unionPy = _set_operation(_union, LQSetPy)
+intersectionPy = _set_operation(_intersection, LQSetPy)
+multiunionPy = _set_operation(_multiunion, LQSetPy)
+weightedUnionPy = _set_operation(_weightedUnion, LQSetPy)
+weightedIntersectionPy = _set_operation(_weightedIntersection, LQSetPy)
+
+import_c_extension(globals())
+
+_fix_pickle(globals(), __name__)
+
+moduleProvides(IIntegerUnsignedBTreeModule)

BTrees/OQBTree.py

+##############################################################################
+#
+# Copyright (c) 2001-2012 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
+#
+##############################################################################
+
+__all__ = ('Bucket', 'Set', 'BTree', 'TreeSet',
+           'OQBucket', 'OQSet', 'OQBTree', 'OQTreeSet',
+           'union', 'intersection', 'difference',
+           'weightedUnion', 'weightedIntersection',
+          )
+
+from zope.interface import moduleProvides
+
+from .Interfaces import IObjectUnsignedBTreeModule
+from ._base import Bucket
+from ._base import MERGE
+from ._base import MERGE_WEIGHT_numeric
+from ._base import MERGE_DEFAULT_int
+from ._base import Set
+from ._base import Tree as BTree
+from ._base import TreeSet
+from ._base import _TreeIterator
+from ._base import difference as _difference
+from ._base import intersection as _intersection
+from ._base import set_operation as _set_operation
+from ._base import to_ob as _to_key
+from ._base import to_ulong as _to_value
+from ._base import union as _union
+from ._base import weightedIntersection as _weightedIntersection
+from ._base import weightedUnion as _weightedUnion
+from ._base import _fix_pickle
+from ._compat import import_c_extension
+
+_BUCKET_SIZE = 60
+_TREE_SIZE = 250
+using64bits = True
+
+
+class OQBucketPy(Bucket):
+    _to_key = _to_key
+    _to_value = _to_value
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class OQSetPy(Set):
+    _to_key = _to_key
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class OQBTreePy(BTree):
+    max_leaf_size = _BUCKET_SIZE
+    max_internal_size = _TREE_SIZE
+    _to_key = _to_key
+    _to_value = _to_value
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class OQTreeSetPy(TreeSet):
+    max_leaf_size = _BUCKET_SIZE
+    max_internal_size = _TREE_SIZE
+    _to_key = _to_key
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class OQTreeIteratorPy(_TreeIterator):
+    pass
+
+
+# Can't declare forward refs, so fix up afterwards:
+
+OQBucketPy._mapping_type = OQBucketPy._bucket_type = OQBucketPy
+OQBucketPy._set_type = OQSetPy
+
+OQSetPy._mapping_type = OQBucketPy
+OQSetPy._set_type = OQSetPy._bucket_type = OQSetPy
+
+OQBTreePy._mapping_type = OQBTreePy._bucket_type = OQBucketPy
+OQBTreePy._set_type = OQSetPy
+
+OQTreeSetPy._mapping_type = OQBucketPy
+OQTreeSetPy._set_type = OQTreeSetPy._bucket_type = OQSetPy
+
+
+differencePy = _set_operation(_difference, OQSetPy)
+unionPy = _set_operation(_union, OQSetPy)
+intersectionPy = _set_operation(_intersection, OQSetPy)
+weightedUnionPy = _set_operation(_weightedUnion, OQSetPy)
+weightedIntersectionPy = _set_operation(_weightedIntersection, OQSetPy)
+
+import_c_extension(globals())
+
+_fix_pickle(globals(), __name__)
+
+moduleProvides(IObjectUnsignedBTreeModule)

BTrees/OUBTree.py

+##############################################################################
+#
+# Copyright (c) 2001-2012 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
+#
+##############################################################################
+
+__all__ = ('Bucket', 'Set', 'BTree', 'TreeSet',
+           'OUBucket', 'OUSet', 'OUBTree', 'OUTreeSet',
+           'union', 'intersection', 'difference',
+           'weightedUnion', 'weightedIntersection',
+          )
+
+from zope.interface import moduleProvides
+
+from .Interfaces import IObjectUnsignedBTreeModule
+from ._base import Bucket
+from ._base import MERGE
+from ._base import MERGE_WEIGHT_numeric
+from ._base import MERGE_DEFAULT_float
+from ._base import Set
+from ._base import Tree as BTree
+from ._base import TreeSet
+from ._base import _TreeIterator
+from ._base import difference as _difference
+from ._base import intersection as _intersection
+from ._base import set_operation as _set_operation
+from ._base import to_ob as _to_key
+from ._base import to_uint as _to_value
+from ._base import union as _union
+from ._base import weightedIntersection as _weightedIntersection
+from ._base import weightedUnion as _weightedUnion
+from ._base import _fix_pickle
+from ._compat import import_c_extension
+
+_BUCKET_SIZE = 60
+_TREE_SIZE = 250
+using64bits = True
+
+class OUBucketPy(Bucket):
+    _to_key = _to_key
+    _to_value = _to_value
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_float
+
+
+class OUSetPy(Set):
+    _to_key = _to_key
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_float
+
+
+class OUBTreePy(BTree):
+    max_leaf_size = _BUCKET_SIZE
+    max_internal_size = _TREE_SIZE
+    _to_key = _to_key
+    _to_value = _to_value
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_float
+
+
+class OUTreeSetPy(TreeSet):
+    max_leaf_size = _BUCKET_SIZE
+    max_internal_size = _TREE_SIZE
+    _to_key = _to_key
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_float
+
+
+class OUTreeIteratorPy(_TreeIterator):
+    pass
+
+
+# Can't declare forward refs, so fix up afterwards:
+
+OUBucketPy._mapping_type = OUBucketPy._bucket_type = OUBucketPy
+OUBucketPy._set_type = OUSetPy
+
+OUSetPy._mapping_type = OUBucketPy
+OUSetPy._set_type = OUSetPy._bucket_type = OUSetPy
+
+OUBTreePy._mapping_type = OUBTreePy._bucket_type = OUBucketPy
+OUBTreePy._set_type = OUSetPy
+
+OUTreeSetPy._mapping_type = OUBucketPy
+OUTreeSetPy._set_type = OUTreeSetPy._bucket_type = OUSetPy
+
+
+differencePy = _set_operation(_difference, OUSetPy)
+unionPy = _set_operation(_union, OUSetPy)
+intersectionPy = _set_operation(_intersection, OUSetPy)
+weightedUnionPy = _set_operation(_weightedUnion, OUSetPy)
+weightedIntersectionPy = _set_operation(_weightedIntersection, OUSetPy)
+
+import_c_extension(globals())
+
+_fix_pickle(globals(), __name__)
+
+moduleProvides(IObjectUnsignedBTreeModule)

BTrees/QFBTree.py

+##############################################################################
+#
+# Copyright (c) 2001-2012 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
+#
+##############################################################################
+
+__all__ = ('Bucket', 'Set', 'BTree', 'TreeSet',
+           'QFBucket', 'QFSet', 'QFBTree', 'QFTreeSet',
+           'union', 'intersection', 'difference',
+           'weightedUnion', 'weightedIntersection', 'multiunion',
+          )
+
+from zope.interface import moduleProvides
+
+from .Interfaces import IUnsignedFloatBTreeModule
+from ._base import Bucket
+from ._base import MERGE
+from ._base import MERGE_WEIGHT_numeric
+from ._base import MERGE_DEFAULT_float
+from ._base import Set
+from ._base import Tree as BTree
+from ._base import TreeSet
+from ._base import _TreeIterator
+from ._base import difference as _difference
+from ._base import intersection as _intersection
+from ._base import multiunion as _multiunion
+from ._base import set_operation as _set_operation
+from ._base import to_ulong as _to_key
+from ._base import to_float as _to_value
+from ._base import union as _union
+from ._base import weightedIntersection as _weightedIntersection
+from ._base import weightedUnion as _weightedUnion
+from ._base import _fix_pickle
+from ._compat import import_c_extension
+
+_BUCKET_SIZE = 120
+_TREE_SIZE = 500
+using64bits = True
+
+
+class QFBucketPy(Bucket):
+    _to_key = _to_key
+    _to_value = _to_value
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_float
+
+
+class QFSetPy(Set):
+    _to_key = _to_key
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_float
+
+
+class QFBTreePy(BTree):
+    max_leaf_size = _BUCKET_SIZE
+    max_internal_size = _TREE_SIZE
+    _to_key = _to_key
+    _to_value = _to_value
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_float
+
+
+class QFTreeSetPy(TreeSet):
+    max_leaf_size = _BUCKET_SIZE
+    max_internal_size = _TREE_SIZE
+    _to_key = _to_key
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_float
+
+
+class QFTreeIteratorPy(_TreeIterator):
+    pass
+
+
+# Can't declare forward refs, so fix up afterwards:
+
+QFBucketPy._mapping_type = QFBucketPy._bucket_type = QFBucketPy
+QFBucketPy._set_type = QFSetPy
+
+QFSetPy._mapping_type = QFBucketPy
+QFSetPy._set_type = QFSetPy._bucket_type = QFSetPy
+
+QFBTreePy._mapping_type = QFBTreePy._bucket_type = QFBucketPy
+QFBTreePy._set_type = QFSetPy
+
+QFTreeSetPy._mapping_type = QFBucketPy
+QFTreeSetPy._set_type = QFTreeSetPy._bucket_type = QFSetPy
+
+
+differencePy = _set_operation(_difference, QFSetPy)
+unionPy = _set_operation(_union, QFSetPy)
+intersectionPy = _set_operation(_intersection, QFSetPy)
+multiunionPy = _set_operation(_multiunion, QFSetPy)
+weightedUnionPy = _set_operation(_weightedUnion, QFSetPy)
+weightedIntersectionPy = _set_operation(_weightedIntersection, QFSetPy)
+
+import_c_extension(globals())
+
+_fix_pickle(globals(), __name__)
+
+moduleProvides(IUnsignedFloatBTreeModule)

BTrees/QLBTree.py

+##############################################################################
+#
+# Copyright (c) 2001-2012 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
+#
+##############################################################################
+
+__all__ = ('Bucket', 'Set', 'BTree', 'TreeSet',
+           'QLBucket', 'QLSet', 'QLBTree', 'QLTreeSet',
+           'union', 'intersection', 'difference',
+           'weightedUnion', 'weightedIntersection', 'multiunion',
+          )
+
+from zope.interface import moduleProvides
+
+from .Interfaces import IUnsignedIntegerBTreeModule
+from ._base import Bucket
+from ._base import MERGE
+from ._base import MERGE_WEIGHT_numeric
+from ._base import MERGE_DEFAULT_int
+from ._base import Set
+from ._base import Tree as BTree
+from ._base import TreeSet
+from ._base import _TreeIterator
+from ._base import difference as _difference
+from ._base import intersection as _intersection
+from ._base import multiunion as _multiunion
+from ._base import set_operation as _set_operation
+from ._base import to_ulong as _to_key
+from ._base import to_long as _to_value
+from ._base import union as _union
+from ._base import weightedIntersection as _weightedIntersection
+from ._base import weightedUnion as _weightedUnion
+from ._base import _fix_pickle
+from ._compat import import_c_extension
+
+_BUCKET_SIZE = 120
+_TREE_SIZE = 500
+using64bits = True
+
+
+class QLBucketPy(Bucket):
+    _to_key = _to_key
+    _to_value = _to_value
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class QLSetPy(Set):
+    _to_key = _to_key
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class QLBTreePy(BTree):
+    max_leaf_size = _BUCKET_SIZE
+    max_internal_size = _TREE_SIZE
+    _to_key = _to_key
+    _to_value = _to_value
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class QLTreeSetPy(TreeSet):
+    max_leaf_size = _BUCKET_SIZE
+    max_internal_size = _TREE_SIZE
+    _to_key = _to_key
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class QLTreeIteratorPy(_TreeIterator):
+    pass
+
+
+# Can't declare forward refs, so fix up afterwards:
+
+QLBucketPy._mapping_type = QLBucketPy._bucket_type = QLBucketPy
+QLBucketPy._set_type = QLSetPy
+
+QLSetPy._mapping_type = QLBucketPy
+QLSetPy._set_type = QLSetPy._bucket_type = QLSetPy
+
+QLBTreePy._mapping_type = QLBTreePy._bucket_type = QLBucketPy
+QLBTreePy._set_type = QLSetPy
+
+QLTreeSetPy._mapping_type = QLBucketPy
+QLTreeSetPy._set_type = QLTreeSetPy._bucket_type = QLSetPy
+
+
+differencePy = _set_operation(_difference, QLSetPy)
+unionPy = _set_operation(_union, QLSetPy)
+intersectionPy = _set_operation(_intersection, QLSetPy)
+multiunionPy = _set_operation(_multiunion, QLSetPy)
+weightedUnionPy = _set_operation(_weightedUnion, QLSetPy)
+weightedIntersectionPy = _set_operation(_weightedIntersection, QLSetPy)
+
+import_c_extension(globals())
+
+_fix_pickle(globals(), __name__)
+
+moduleProvides(IUnsignedIntegerBTreeModule)

BTrees/QOBTree.py

+##############################################################################
+#
+# Copyright (c) 2001-2012 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
+#
+##############################################################################
+
+__all__ = ('Bucket', 'Set', 'BTree', 'TreeSet',
+           'QOBucket', 'QOSet', 'QOBTree', 'QOTreeSet',
+           'union', 'intersection', 'difference', 'multiunion',
+          )
+
+from zope.interface import moduleProvides
+
+from .Interfaces import IUnsignedObjectBTreeModule
+from ._base import Bucket
+from ._base import MERGE_WEIGHT_default
+from ._base import Set
+from ._base import Tree as BTree
+from ._base import TreeSet
+from ._base import _TreeIterator
+from ._base import difference as _difference
+from ._base import intersection as _intersection
+from ._base import multiunion as _multiunion
+from ._base import set_operation as _set_operation
+from ._base import to_ulong as _to_key
+from ._base import to_ob as _to_value
+from ._base import union as _union
+from ._base import _fix_pickle
+from ._compat import import_c_extension
+
+_BUCKET_SIZE = 60
+_TREE_SIZE = 500
+using64bits = True
+
+
+class QOBucketPy(Bucket):
+    _to_key = _to_key
+    _to_value = _to_value
+    MERGE_WEIGHT = MERGE_WEIGHT_default
+
+
+class QOSetPy(Set):
+    _to_key = _to_key
+
+
+class QOBTreePy(BTree):
+    max_leaf_size = _BUCKET_SIZE
+    max_internal_size = _TREE_SIZE
+    _to_key = _to_key
+    _to_value = _to_value
+    MERGE_WEIGHT = MERGE_WEIGHT_default
+
+
+class QOTreeSetPy(TreeSet):
+    max_leaf_size = _BUCKET_SIZE
+    max_internal_size = _TREE_SIZE
+    _to_key = _to_key
+
+
+class QOTreeIteratorPy(_TreeIterator):
+    pass
+
+
+# Can't declare forward refs, so fix up afterwards:
+
+QOBucketPy._mapping_type = QOBucketPy._bucket_type = QOBucketPy
+QOBucketPy._set_type = QOSetPy
+
+QOSetPy._mapping_type = QOBucketPy
+QOSetPy._set_type = QOSetPy._bucket_type = QOSetPy
+
+QOBTreePy._mapping_type = QOBTreePy._bucket_type = QOBucketPy
+QOBTreePy._set_type = QOSetPy
+
+QOTreeSetPy._mapping_type = QOBucketPy
+QOTreeSetPy._set_type = QOTreeSetPy._bucket_type = QOSetPy
+
+
+differencePy = _set_operation(_difference, QOSetPy)
+unionPy = _set_operation(_union, QOSetPy)
+intersectionPy = _set_operation(_intersection, QOSetPy)
+multiunionPy = _set_operation(_multiunion, QOSetPy)
+
+import_c_extension(globals())
+
+_fix_pickle(globals(), __name__)
+
+moduleProvides(IUnsignedObjectBTreeModule)

BTrees/QQBTree.py

+##############################################################################
+#
+# Copyright (c) 2001-2012 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
+#
+##############################################################################
+
+__all__ = ('Bucket', 'Set', 'BTree', 'TreeSet',
+           'QQBucket', 'QQSet', 'QQBTree', 'QQTreeSet',
+           'union', 'intersection', 'difference',
+           'weightedUnion', 'weightedIntersection', 'multiunion',
+          )
+
+from zope.interface import moduleProvides
+
+from .Interfaces import IUnsignedUnsignedBTreeModule
+from ._base import Bucket
+from ._base import MERGE
+from ._base import MERGE_WEIGHT_numeric
+from ._base import MERGE_DEFAULT_int
+from ._base import Set
+from ._base import Tree as BTree
+from ._base import TreeSet
+from ._base import _TreeIterator
+from ._base import difference as _difference
+from ._base import intersection as _intersection
+from ._base import multiunion as _multiunion
+from ._base import set_operation as _set_operation
+from ._base import to_ulong as _to_key
+_to_value = _to_key
+from ._base import union as _union
+from ._base import weightedIntersection as _weightedIntersection
+from ._base import weightedUnion as _weightedUnion
+from ._base import _fix_pickle
+from ._compat import import_c_extension
+
+_BUCKET_SIZE = 120
+_TREE_SIZE = 500
+using64bits = True
+
+
+class QQBucketPy(Bucket):
+    _to_key = _to_key
+    _to_value = _to_value
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class QQSetPy(Set):
+    _to_key = _to_key
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class QQBTreePy(BTree):
+    max_leaf_size = _BUCKET_SIZE
+    max_internal_size = _TREE_SIZE
+    _to_key = _to_key
+    _to_value = _to_value
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class QQTreeSetPy(TreeSet):
+    max_leaf_size = _BUCKET_SIZE
+    max_internal_size = _TREE_SIZE
+    _to_key = _to_key
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class QQTreeIteratorPy(_TreeIterator):
+    pass
+
+
+# Can't declare forward refs, so fix up afterwards:
+
+QQBucketPy._mapping_type = QQBucketPy._bucket_type = QQBucketPy
+QQBucketPy._set_type = QQSetPy
+
+QQSetPy._mapping_type = QQBucketPy
+QQSetPy._set_type = QQSetPy._bucket_type = QQSetPy
+
+QQBTreePy._mapping_type = QQBTreePy._bucket_type = QQBucketPy
+QQBTreePy._set_type = QQSetPy
+
+QQTreeSetPy._mapping_type = QQBucketPy
+QQTreeSetPy._set_type = QQTreeSetPy._bucket_type = QQSetPy
+
+
+differencePy = _set_operation(_difference, QQSetPy)
+unionPy = _set_operation(_union, QQSetPy)
+intersectionPy = _set_operation(_intersection, QQSetPy)
+multiunionPy = _set_operation(_multiunion, QQSetPy)
+weightedUnionPy = _set_operation(_weightedUnion, QQSetPy)
+weightedIntersectionPy = _set_operation(_weightedIntersection, QQSetPy)
+
+import_c_extension(globals())
+
+_fix_pickle(globals(), __name__)
+
+moduleProvides(IUnsignedUnsignedBTreeModule)

BTrees/UFBTree.py

+##############################################################################
+#
+# Copyright (c) 2001-2012 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
+#
+##############################################################################
+
+__all__ = ('Bucket', 'Set', 'BTree', 'TreeSet',
+           'UFBucket', 'UFSet', 'UFBTree', 'UFTreeSet',
+           'union', 'intersection', 'difference',
+           'weightedUnion', 'weightedIntersection', 'multiunion',
+          )
+
+from zope.interface import moduleProvides
+
+from .Interfaces import IUnsignedFloatBTreeModule
+from ._base import Bucket
+from ._base import MERGE
+from ._base import MERGE_WEIGHT_numeric
+from ._base import MERGE_DEFAULT_float
+from ._base import Set
+from ._base import Tree as BTree
+from ._base import TreeSet
+from ._base import _TreeIterator
+from ._base import difference as _difference
+from ._base import intersection as _intersection
+from ._base import multiunion as _multiunion
+from ._base import set_operation as _set_operation
+from ._base import to_uint as _to_key
+from ._base import to_float as _to_value
+from ._base import union as _union
+from ._base import weightedIntersection as _weightedIntersection
+from ._base import weightedUnion as _weightedUnion
+from ._base import _fix_pickle
+from ._compat import import_c_extension
+
+_BUCKET_SIZE = 120
+_TREE_SIZE = 500
+using64bits = False
+
+class UFBucketPy(Bucket):
+    _to_key = _to_key
+    _to_value = _to_value
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_float
+
+
+class UFSetPy(Set):
+    _to_key = _to_key
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_float
+
+
+class UFBTreePy(BTree):
+    max_leaf_size = _BUCKET_SIZE
+    max_internal_size = _TREE_SIZE
+    _to_key = _to_key
+    _to_value = _to_value
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_float
+
+
+class UFTreeSetPy(TreeSet):
+    max_leaf_size = _BUCKET_SIZE
+    max_internal_size = _TREE_SIZE
+    _to_key = _to_key
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_float
+
+
+class UFTreeIteratorPy(_TreeIterator):
+    pass
+
+
+# Can't declare forward refs, so fix up afterwards:
+
+UFBucketPy._mapping_type = UFBucketPy._bucket_type = UFBucketPy
+UFBucketPy._set_type = UFSetPy
+
+UFSetPy._mapping_type = UFBucketPy
+UFSetPy._set_type = UFSetPy._bucket_type = UFSetPy
+
+UFBTreePy._mapping_type = UFBTreePy._bucket_type = UFBucketPy
+UFBTreePy._set_type = UFSetPy
+
+UFTreeSetPy._mapping_type = UFBucketPy
+UFTreeSetPy._set_type = UFTreeSetPy._bucket_type = UFSetPy
+
+
+differencePy = _set_operation(_difference, UFSetPy)
+unionPy = _set_operation(_union, UFSetPy)
+intersectionPy = _set_operation(_intersection, UFSetPy)
+multiunionPy = _set_operation(_multiunion, UFSetPy)
+weightedUnionPy = _set_operation(_weightedUnion, UFSetPy)
+weightedIntersectionPy = _set_operation(_weightedIntersection, UFSetPy)
+
+import_c_extension(globals())
+
+_fix_pickle(globals(), __name__)
+
+moduleProvides(IUnsignedFloatBTreeModule)

BTrees/UIBTree.py

+##############################################################################
+#
+# Copyright (c) 2001-2012 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
+#
+##############################################################################
+
+__all__ = ('Bucket', 'Set', 'BTree', 'TreeSet',
+           'UIBucket', 'UISet', 'UIBTree', 'UITreeSet',
+           'union', 'intersection', 'difference',
+           'weightedUnion', 'weightedIntersection', 'multiunion',
+          )
+
+from zope.interface import moduleProvides
+
+from .Interfaces import IUnsignedIntegerBTreeModule
+from ._base import Bucket
+from ._base import MERGE
+from ._base import MERGE_WEIGHT_numeric
+from ._base import MERGE_DEFAULT_int
+from ._base import Set
+from ._base import Tree as BTree
+from ._base import TreeSet
+from ._base import _TreeIterator
+from ._base import difference as _difference
+from ._base import intersection as _intersection
+from ._base import multiunion as _multiunion
+from ._base import set_operation as _set_operation
+from ._base import to_uint as _to_key
+from ._base import to_int as _to_value
+from ._base import union as _union
+from ._base import weightedIntersection as _weightedIntersection
+from ._base import weightedUnion as _weightedUnion
+from ._base import _fix_pickle
+from ._compat import import_c_extension
+
+_BUCKET_SIZE = 120
+_TREE_SIZE = 500
+using64bits = False
+
+
+class UIBucketPy(Bucket):
+    _to_key = _to_key
+    _to_value = _to_value
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class UISetPy(Set):
+    _to_key = _to_key
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class UIBTreePy(BTree):
+    max_leaf_size = _BUCKET_SIZE
+    max_internal_size = _TREE_SIZE
+    _to_key = _to_key
+    _to_value = _to_value
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class UITreeSetPy(TreeSet):
+    max_leaf_size = _BUCKET_SIZE
+    max_internal_size = _TREE_SIZE
+    _to_key = _to_key
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class UITreeIteratorPy(_TreeIterator):
+    pass
+
+
+# Can't declare forward refs, so fix up afterwards:
+
+UIBucketPy._mapping_type = UIBucketPy._bucket_type = UIBucketPy
+UIBucketPy._set_type = UISetPy
+
+UISetPy._mapping_type = UIBucketPy
+UISetPy._set_type = UISetPy._bucket_type = UISetPy
+
+UIBTreePy._mapping_type = UIBTreePy._bucket_type = UIBucketPy
+UIBTreePy._set_type = UISetPy
+
+UITreeSetPy._mapping_type = UIBucketPy
+UITreeSetPy._set_type = UITreeSetPy._bucket_type = UISetPy
+
+
+differencePy = _set_operation(_difference, UISetPy)
+unionPy = _set_operation(_union, UISetPy)
+intersectionPy = _set_operation(_intersection, UISetPy)
+multiunionPy = _set_operation(_multiunion, UISetPy)
+weightedUnionPy = _set_operation(_weightedUnion, UISetPy)
+weightedIntersectionPy = _set_operation(_weightedIntersection, UISetPy)
+
+import_c_extension(globals())
+
+_fix_pickle(globals(), __name__)
+
+moduleProvides(IUnsignedIntegerBTreeModule)

BTrees/UOBTree.py

+##############################################################################
+#
+# Copyright (c) 2001-2012 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
+#
+##############################################################################
+
+__all__ = ('Bucket', 'Set', 'BTree', 'TreeSet',
+           'UOBucket', 'UOSet', 'UOBTree', 'UOTreeSet',
+           'union', 'intersection', 'difference', 'multiunion',
+          )
+
+from zope.interface import moduleProvides
+
+from .Interfaces import IUnsignedObjectBTreeModule
+from ._base import Bucket
+from ._base import MERGE_WEIGHT_default
+from ._base import Set
+from ._base import Tree as BTree
+from ._base import TreeSet
+from ._base import _TreeIterator
+from ._base import difference as _difference
+from ._base import intersection as _intersection
+from ._base import multiunion as _multiunion
+from ._base import set_operation as _set_operation
+from ._base import to_uint as _to_key
+from ._base import to_ob as _to_value
+from ._base import union as _union
+from ._base import _fix_pickle
+from ._compat import import_c_extension
+
+_BUCKET_SIZE = 60
+_TREE_SIZE = 500
+using64bits = False
+
+
+class UOBucketPy(Bucket):
+    _to_key = _to_key
+    _to_value = _to_value
+    MERGE_WEIGHT = MERGE_WEIGHT_default
+
+
+class UOSetPy(Set):
+    _to_key = _to_key
+
+
+class UOBTreePy(BTree):
+    max_leaf_size = _BUCKET_SIZE
+    max_internal_size = _TREE_SIZE
+    _to_key = _to_key
+    _to_value = _to_value
+    MERGE_WEIGHT = MERGE_WEIGHT_default
+
+
+class UOTreeSetPy(TreeSet):
+    max_leaf_size = _BUCKET_SIZE
+    max_internal_size = _TREE_SIZE
+    _to_key = _to_key
+
+class UOTreeIteratorPy(_TreeIterator):
+    pass
+
+
+# Can't declare forward refs, so fix up afterwards:
+
+UOBucketPy._mapping_type = UOBucketPy._bucket_type = UOBucketPy
+UOBucketPy._set_type = UOSetPy
+
+UOSetPy._mapping_type = UOBucketPy
+UOSetPy._set_type = UOSetPy._bucket_type = UOSetPy
+
+UOBTreePy._mapping_type = UOBTreePy._bucket_type = UOBucketPy
+UOBTreePy._set_type = UOSetPy
+
+UOTreeSetPy._mapping_type = UOBucketPy
+UOTreeSetPy._set_type = UOTreeSetPy._bucket_type = UOSetPy
+
+
+differencePy = _set_operation(_difference, UOSetPy)
+unionPy = _set_operation(_union, UOSetPy)
+intersectionPy = _set_operation(_intersection, UOSetPy)
+multiunionPy = _set_operation(_multiunion, UOSetPy)
+
+import_c_extension(globals())
+
+_fix_pickle(globals(), __name__)
+
+moduleProvides(IUnsignedObjectBTreeModule)

BTrees/UUBTree.py

+##############################################################################
+#
+# Copyright (c) 2001-2012 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
+#
+##############################################################################
+
+__all__ = ('Bucket', 'Set', 'BTree', 'TreeSet',
+           'UUBucket', 'UUSet', 'UUBTree', 'UUTreeSet',
+           'union', 'intersection', 'difference',
+           'weightedUnion', 'weightedIntersection', 'multiunion',
+          )
+
+from zope.interface import moduleProvides
+
+from .Interfaces import IUnsignedUnsignedBTreeModule
+from ._base import Bucket
+from ._base import MERGE
+from ._base import MERGE_WEIGHT_numeric
+from ._base import MERGE_DEFAULT_int
+from ._base import Set
+from ._base import Tree as BTree
+from ._base import TreeSet
+from ._base import _TreeIterator
+from ._base import difference as _difference
+from ._base import intersection as _intersection
+from ._base import multiunion as _multiunion
+from ._base import set_operation as _set_operation
+from ._base import to_uint as _to_key
+_to_value = _to_key
+from ._base import union as _union
+from ._base import weightedIntersection as _weightedIntersection
+from ._base import weightedUnion as _weightedUnion
+from ._base import _fix_pickle
+from ._compat import import_c_extension
+
+_BUCKET_SIZE = 120
+_TREE_SIZE = 500
+using64bits = False
+
+
+class UUBucketPy(Bucket):
+    _to_key = _to_key
+    _to_value = _to_value
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class UUSetPy(Set):
+    _to_key = _to_key
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class UUBTreePy(BTree):
+    max_leaf_size = _BUCKET_SIZE
+    max_internal_size = _TREE_SIZE
+    _to_key = _to_key
+    _to_value = _to_value
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class UUTreeSetPy(TreeSet):
+    max_leaf_size = _BUCKET_SIZE
+    max_internal_size = _TREE_SIZE
+    _to_key = _to_key
+    MERGE = MERGE
+    MERGE_WEIGHT = MERGE_WEIGHT_numeric
+    MERGE_DEFAULT = MERGE_DEFAULT_int
+
+
+class UUTreeIteratorPy(_TreeIterator):
+    pass
+
+
+# Can't declare forward refs, so fix up afterwards:
+
+UUBucketPy._mapping_type = UUBucketPy._bucket_type = UUBucketPy
+UUBucketPy._set_type = UUSetPy
+
+UUSetPy._mapping_type = UUBucketPy
+UUSetPy._set_type = UUSetPy._bucket_type = UUSetPy
+
+UUBTreePy._mapping_type = UUBTreePy._bucket_type = UUBucketPy
+UUBTreePy._set_type = UUSetPy
+
+UUTreeSetPy._mapping_type = UUBucketPy
+UUTreeSetPy._set_type = UUTreeSetPy._bucket_type = UUSetPy
+
+
+differencePy = _set_operation(_difference, UUSetPy)
+unionPy = _set_operation(_union, UUSetPy)
+intersectionPy = _set_operation(_intersection, UUSetPy)
+multiunionPy = _set_operation(_multiunion, UUSetPy)
+weightedUnionPy = _set_operation(_weightedUnion, UUSetPy)
+weightedIntersectionPy = _set_operation(_weightedIntersection, UUSetPy)
+
+import_c_extension(globals())
+
+_fix_pickle(globals(), __name__)
+
+moduleProvides(IUnsignedUnsignedBTreeModule)

BTrees/_IUBTree.c

+/*############################################################################
+#
+# Copyright (c) 2004 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.
+#
+############################################################################*/
+
+#define MASTER_ID "$Id$\n"
+
+/* IIBTree - int32_t key, uint32_t value BTree
+
+   Implements a collection using int type keys
+   and int type values
+*/
+
+/* Setup template macros */
+
+#define PERSISTENT
+
+#define MOD_NAME_PREFIX "IU"
+
+#define DEFAULT_MAX_BUCKET_SIZE 120
+#define DEFAULT_MAX_BTREE_SIZE 500
+
+#define ZODB_UNSIGNED_VALUE_INTS
+
+#include "_compat.h"
+#include "intkeymacros.h"
+#include "intvaluemacros.h"
+
+#ifdef PY3K
+#define INITMODULE PyInit__IUBTree
+#else
+#define INITMODULE init_IUBTree
+#endif
+#include "BTreeModuleTemplate.c"

BTrees/_LQBTree.c

+/*############################################################################
+#
+# Copyright (c) 2004 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.
+#
+############################################################################*/
+
+#define MASTER_ID "$Id: _IIBTree.c 25186 2004-06-02 15:07:33Z jim $\n"
+
+/* IIBTree - int64_t key, uint64_t value BTree
+
+   Implements a collection using int type keys
+   and int type values
+*/
+
+/* Setup template macros */
+
+#define PERSISTENT
+
+#define MOD_NAME_PREFIX "LQ"
+
+#define DEFAULT_MAX_BUCKET_SIZE 120
+#define DEFAULT_MAX_BTREE_SIZE 500
+
+#define ZODB_64BIT_INTS
+#define ZODB_UNSIGNED_VALUE_INTS
+
+#include "_compat.h"
+#include "intkeymacros.h"
+#include "intvaluemacros.h"
+
+#ifdef PY3K
+#define INITMODULE PyInit__LQBTree
+#else
+#define INITMODULE init_LQBTree
+#endif
+#include "BTreeModuleTemplate.c"

BTrees/_OQBTree.c

+/*############################################################################
+#
+# Copyright (c) 2004 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.
+#
+############################################################################*/
+
+#define MASTER_ID "$Id: _OIBTree.c 25186 2004-06-02 15:07:33Z jim $\n"
+
+/* OQBTree - object key, uint64_t value BTree
+
+   Implements a collection using object type keys
+   and int type values
+*/
+
+#define PERSISTENT
+
+#define MOD_NAME_PREFIX "OQ"
+
+#define DEFAULT_MAX_BUCKET_SIZE 60
+#define DEFAULT_MAX_BTREE_SIZE 250
+
+#define ZODB_64BIT_INTS
+#define ZODB_UNSIGNED_VALUE_INTS
+
+#include "_compat.h"
+#include "objectkeymacros.h"
+#include "intvaluemacros.h"
+
+#ifdef PY3K
+#define INITMODULE PyInit__OQBTree
+#else
+#define INITMODULE init_OQBTree
+#endif
+#include "BTreeModuleTemplate.c"

BTrees/_OUBTree.c

+/*############################################################################
+#
+# Copyright (c) 2004 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.
+#
+############################################################################*/
+
+#define MASTER_ID "$Id$\n"
+
+/* OUBTree - object key, uint32_t value BTree
+
+   Implements a collection using object type keys
+   and int type values
+*/
+
+#define PERSISTENT
+
+#define MOD_NAME_PREFIX "OU"
+
+#define DEFAULT_MAX_BUCKET_SIZE 60
+#define DEFAULT_MAX_BTREE_SIZE 250
+
+#define ZODB_UNSIGNED_VALUE_INTS
+
+#include "_compat.h"
+#include "objectkeymacros.h"
+#include "intvaluemacros.h"
+
+#ifdef PY3K
+#define INITMODULE PyInit__OUBTree
+#else
+#define INITMODULE init_OUBTree
+#endif
+#include "BTreeModuleTemplate.c"

BTrees/_QFBTree.c

+/*############################################################################
+#
+# Copyright (c) 2004 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.
+#
+############################################################################*/
+
+#define MASTER_ID "$Id: _IFBTree.c 67074 2006-04-17 19:13:39Z fdrake $\n"
+
+/* QFBTree - uint64_t key, float value BTree
+
+   Implements a collection using int type keys
+   and float type values
+*/
+
+/* Setup template macros */
+
+#define PERSISTENT
+
+#define MOD_NAME_PREFIX "QF"
+
+#define DEFAULT_MAX_BUCKET_SIZE 120
+#define DEFAULT_MAX_BTREE_SIZE 500
+
+#define ZODB_64BIT_INTS
+#define ZODB_UNSIGNED_KEY_INTS
+
+#include "_compat.h"
+#include "intkeymacros.h"
+#include "floatvaluemacros.h"
+
+#ifdef PY3K
+#define INITMODULE PyInit__QFBTree
+#else
+#define INITMODULE init_QFBTree
+#endif
+#include "BTreeModuleTemplate.c"

BTrees/_QLBTree.c

+/*############################################################################
+#
+# Copyright (c) 2004 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.
+#
+############################################################################*/
+
+#define MASTER_ID "$Id: _IIBTree.c 25186 2004-06-02 15:07:33Z jim $\n"
+
+/* QLBTree - uint64_t key, int64_t value BTree
+
+   Implements a collection using int type keys
+   and int type values
+*/
+
+/* Setup template macros */
+
+#define PERSISTENT
+
+#define MOD_NAME_PREFIX "QL"
+
+#define DEFAULT_MAX_BUCKET_SIZE 120
+#define DEFAULT_MAX_BTREE_SIZE 500
+
+#define ZODB_64BIT_INTS
+#define ZODB_UNSIGNED_KEY_INTS
+
+#include "_compat.h"
+#include "intkeymacros.h"
+#include "intvaluemacros.h"
+
+#ifdef PY3K
+#define INITMODULE PyInit__QLBTree
+#else
+#define INITMODULE init_QLBTree
+#endif
+#include "BTreeModuleTemplate.c"

BTrees/_QOBTree.c

+/*############################################################################
+#
+# Copyright (c) 2004 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.
+#
+############################################################################*/
+
+#define MASTER_ID "$Id: _IOBTree.c 25186 2004-06-02 15:07:33Z jim $\n"
+
+/* QOBTree - uint64_t key, object value BTree
+
+   Implements a collection using int type keys
+   and object type values
+*/
+
+#define PERSISTENT
+
+#define MOD_NAME_PREFIX "QO"
+
+#define DEFAULT_MAX_BUCKET_SIZE 60
+#define DEFAULT_MAX_BTREE_SIZE 500
+
+#define ZODB_64BIT_INTS
+#define ZODB_UNSIGNED_KEY_INTS
+
+#include "_compat.h"
+#include "intkeymacros.h"
+#include "objectvaluemacros.h"
+
+#ifdef PY3K
+#define INITMODULE PyInit__QOBTree
+#else
+#define INITMODULE init_QOBTree
+#endif
+#include "BTreeModuleTemplate.c"

BTrees/_QQBTree.c

+/*############################################################################
+#
+# Copyright (c) 2004 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.
+#
+############################################################################*/
+
+#define MASTER_ID "$Id: _IIBTree.c 25186 2004-06-02 15:07:33Z jim $\n"
+
+/* QQBTree - uint64_t key, uint64_t value BTree
+
+   Implements a collection using int type keys
+   and int type values
+*/
+
+/* Setup template macros */
+
+#define PERSISTENT
+
+#define MOD_NAME_PREFIX "QQ"
+
+#define DEFAULT_MAX_BUCKET_SIZE 120
+#define DEFAULT_MAX_BTREE_SIZE 500
+
+#define ZODB_64BIT_INTS
+#define ZODB_UNSIGNED_KEY_INTS
+#define ZODB_UNSIGNED_VALUE_INTS
+
+#include "_compat.h"
+#include "intkeymacros.h"
+#include "intvaluemacros.h"
+
+#ifdef PY3K
+#define INITMODULE PyInit__QQBTree
+#else
+#define INITMODULE init_QQBTree
+#endif
+#include "BTreeModuleTemplate.c"

BTrees/_UFBTree.c

+/*############################################################################
+#
+# Copyright (c) 2004 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.
+#
+############################################################################*/
+
+#define MASTER_ID "$Id$\n"
+
+/* IFBTree - unsigned int key, float value BTree
+
+   Implements a collection using int type keys
+   and float type values
+*/
+
+/* Setup template macros */
+
+#define PERSISTENT
+
+#define MOD_NAME_PREFIX "UF"
+
+#define DEFAULT_MAX_BUCKET_SIZE 120
+#define DEFAULT_MAX_BTREE_SIZE 500
+#define ZODB_UNSIGNED_KEY_INTS
+
+#include "_compat.h"
+#include "intkeymacros.h"
+#include "floatvaluemacros.h"
+
+#ifdef PY3K
+#define INITMODULE PyInit__UFBTree
+#else
+#define INITMODULE init_UFBTree
+#endif
+#include "BTreeModuleTemplate.c"

BTrees/_UIBTree.c

+/*############################################################################
+#
+# Copyright (c) 2004 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.
+#
+############################################################################*/
+
+#define MASTER_ID "$Id$\n"
+
+/* IIBTree - unsigned int key, int value BTree
+
+   Implements a collection using int type keys
+   and int type values
+*/
+
+/* Setup template macros */
+
+#define PERSISTENT
+
+#define MOD_NAME_PREFIX "UI"
+
+#define DEFAULT_MAX_BUCKET_SIZE 120
+#define DEFAULT_MAX_BTREE_SIZE 500
+#define ZODB_UNSIGNED_KEY_INTS
+
+#include "_compat.h"
+#include "intkeymacros.h"
+#include "intvaluemacros.h"
+
+#ifdef PY3K
+#define INITMODULE PyInit__UIBTree
+#else
+#define INITMODULE init_UIBTree
+#endif
+#include "BTreeModuleTemplate.c"

BTrees/_UOBTree.c

+/*############################################################################
+#
+# Copyright (c) 2004 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.
+#
+############################################################################*/
+
+#define MASTER_ID "$Id$\n"
+
+/* UOBTree - unsigned int key, object value BTree
+
+   Implements a collection using unsigned int type keys
+   and object type values
+*/
+
+#define PERSISTENT
+
+#define MOD_NAME_PREFIX "UO"
+
+#define DEFAULT_MAX_BUCKET_SIZE 60
+#define DEFAULT_MAX_BTREE_SIZE 500
+#define ZODB_UNSIGNED_KEY_INTS
+#include "_compat.h"
+#include "intkeymacros.h"
+#include "objectvaluemacros.h"
+
+#ifdef PY3K
+#define INITMODULE PyInit__UOBTree
+#else
+#define INITMODULE init_UOBTree
+#endif
+#include "BTreeModuleTemplate.c"

BTrees/_UUBTree.c

+/*############################################################################
+#
+# Copyright (c) 2004 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.
+#
+############################################################################*/
+
+#define MASTER_ID "$Id$\n"
+
+/* IIBTree - unsigned int key, unsigned int value BTree
+
+   Implements a collection using int type keys
+   and int type values
+*/
+
+/* Setup template macros */
+
+#define PERSISTENT
+
+#define MOD_NAME_PREFIX "UU"
+
+#define DEFAULT_MAX_BUCKET_SIZE 120
+#define DEFAULT_MAX_BTREE_SIZE 500
+#define ZODB_UNSIGNED_KEY_INTS
+#define ZODB_UNSIGNED_VALUE_INTS
+
+#include "_compat.h"
+#include "intkeymacros.h"
+#include "intvaluemacros.h"
+
+#ifdef PY3K
+#define INITMODULE PyInit__UUBTree
+#else
+#define INITMODULE init_UUBTree
+#endif
+#include "BTreeModuleTemplate.c"

BTrees/__init__.py

@@ -18,15 +18,23 @@ import BTrees.Interfaces
 
 @zope.interface.implementer(BTrees.Interfaces.IBTreeFamily)
 class _Family(object):
-
     from BTrees import OOBTree as OO
 
 class _Family32(_Family):
     from BTrees import OIBTree as OI
+    from BTrees import OUBTree as OU
+
+    from BTrees import IFBTree as IF
     from BTrees import IIBTree as II
     from BTrees import IOBTree as IO
-    from BTrees import IFBTree as IF
+    from BTrees import IUBTree as IU
+
+    from BTrees import UFBTree as UF
+    from BTrees import UIBTree as UI
+    from BTrees import UOBTree as UO
+    from BTrees import UUBTree as UU
 
+    maxuint = int(2**32)
     maxint = int(2**31-1)
     minint = -maxint - 1
 
@@ -35,10 +43,19 @@ class _Family32(_Family):
 
 class _Family64(_Family):
     from BTrees import OLBTree as OI
+    from BTrees import OQBTree as OU
+
+    from BTrees import LFBTree as IF
     from BTrees import LLBTree as II
     from BTrees import LOBTree as IO
-    from BTrees import LFBTree as IF
+    from BTrees import LQBTree as IU
+
+    from BTrees import QFBTree as UF
+    from BTrees import QLBTree as UI
+    from BTrees import QOBTree as UO
+    from BTrees import QQBTree as UU
 
+    maxuint = 2**64
     maxint = 2**63-1
     minint = -maxint - 1
 
@@ -57,13 +74,10 @@ _family64.__safe_for_unpickling__ = True
 family32 = _Family32()
 family64 = _Family64()
 
-
-BTrees.family64.IO.family = family64
-BTrees.family64.OI.family = family64
-BTrees.family64.IF.family = family64
-BTrees.family64.II.family = family64
-
-BTrees.family32.IO.family = family32
-BTrees.family32.OI.family = family32
-BTrees.family32.IF.family = family32
-BTrees.family32.II.family = family32
+for _family in family32, family64:
+    for _mod_name in (
+            "OI", "OU",
+            'IO', "II", "IF", "IU",
+            "UO", "UU", "UF", "UI",
+    ):
+        getattr(_family, _mod_name).family = _family

BTrees/_base.py

@@ -1509,6 +1509,18 @@ def to_int(self, v):
 
     return int(v)
 
+uint_pack, uint_unpack = _packer_unpacker('I')
+
+def to_uint(self, v):
+    try:
+        uint_pack(index(v))
+    except (struct_error, TypeError):
+        if isinstance(v, int_types):
+            raise OverflowError("Value out of range", v)
+        raise TypeError('non-negative 32-bit integer expected')
+
+    return int(v)
+
 float_pack = _packer_unpacker('f')[0]
 
 def to_float(self, v):
@@ -1526,11 +1538,24 @@ def to_long(self, v):
         long_pack(index(v))
     except (struct_error, TypeError):
         if isinstance(v, int_types):
-            raise ValueError("Value out of range", v)
+            raise OverflowError("Value out of range", v)
         raise TypeError('64-bit integer expected')
 
     return int(v)
 
+ulong_pack, ulong_unpack = _packer_unpacker('Q')
+
+def to_ulong(self, v):
+    try:
+        ulong_pack(index(v))
+    except (struct_error, TypeError):
+        if isinstance(v, int_types):
+            raise OverflowError("Value out of range", v)
+        raise TypeError('non-negative 64-bit integer expected')
+
+    return int(v)
+
+
 def to_bytes(l):
     def to(self, v):
         if not (isinstance(v, bytes) and len(v) == l):
@@ -1538,7 +1563,7 @@ def to_bytes(l):
         return v
     return to
 
-tos = dict(I=to_int, L=to_long, F=to_float, O=to_ob)
+tos = dict(I=to_int, L=to_long, F=to_float, O=to_ob, U=to_uint, Q=to_ulong)
 
 MERGE_DEFAULT_int = 1
 MERGE_DEFAULT_float = 1.0

BTrees/_compat.h

@@ -23,7 +23,15 @@
 #define INTERN PyUnicode_InternFromString
 #define INT_FROM_LONG(x) PyLong_FromLong(x)
 #define INT_CHECK(x) PyLong_Check(x)
+/* PyLong_AS_LONG isn't a documnted API function. But because of
+ * an issue in persistent/_compat.h, if we define it to be
+ * the documented function, PyLong_AsLong, we get
+ * warnings about macro redefinition. See
+ * https://github.com/zopefoundation/persistent/issues/125
+*/
 #define INT_AS_LONG(x) PyLong_AS_LONG(x)
+#define UINT_FROM_LONG(x) PyLong_FromUnsignedLong(x)
+#define UINT_AS_LONG(x) PyLong_AsUnsignedLong(x)
 #define TEXT_FROM_STRING PyUnicode_FromString
 #define TEXT_FORMAT PyUnicode_Format
 
@@ -43,6 +51,8 @@
 #define INT_FROM_LONG(x) PyInt_FromLong(x)
 #define INT_CHECK(x) PyInt_Check(x)
 #define INT_AS_LONG(x) PyInt_AS_LONG(x)
+#define UINT_FROM_LONG(x) PyInt_FromSize_t(x)
+#define UINT_AS_LONG(x) PyInt_AsUnsignedLongMask(x)
 #define TEXT_FROM_STRING PyString_FromString
 #define TEXT_FORMAT PyString_Format
 

BTrees/check.py

@@ -32,24 +32,57 @@ addresses and/or object identity (the synthesized bucket has an address
 that doesn't exist in the actual BTree).
 """
 
+# 32-bit signed int
 from BTrees.IFBTree import IFBTree, IFBucket, IFSet, IFTreeSet
 from BTrees.IFBTree import IFBTreePy, IFBucketPy, IFSetPy, IFTreeSetPy
 from BTrees.IIBTree import IIBTree, IIBucket, IISet, IITreeSet
 from BTrees.IIBTree import IIBTreePy, IIBucketPy, IISetPy, IITreeSetPy
 from BTrees.IOBTree import IOBTree, IOBucket, IOSet, IOTreeSet
 from BTrees.IOBTree import IOBTreePy, IOBucketPy, IOSetPy, IOTreeSetPy
+from BTrees.IUBTree import IUBTree, IUBucket, IUSet, IUTreeSet
+from BTrees.IUBTree import IUBTreePy, IUBucketPy, IUSetPy, IUTreeSetPy
+
+# 32-bit unsigned int
+from BTrees.UFBTree import UFBTree, UFBucket, UFSet, UFTreeSet
+from BTrees.UFBTree import UFBTreePy, UFBucketPy, UFSetPy, UFTreeSetPy
+from BTrees.UIBTree import UIBTree, UIBucket, UISet, UITreeSet
+from BTrees.UIBTree import UIBTreePy, UIBucketPy, UISetPy, UITreeSetPy
+from BTrees.UOBTree import UOBTree, UOBucket, UOSet, UOTreeSet
+from BTrees.UOBTree import UOBTreePy, UOBucketPy, UOSetPy, UOTreeSetPy
+from BTrees.UUBTree import UUBTree, UUBucket, UUSet, UUTreeSet
+from BTrees.UUBTree import UUBTreePy, UUBucketPy, UUSetPy, UUTreeSetPy
+
+# 64-bit signed int
 from BTrees.LFBTree import LFBTree, LFBucket, LFSet, LFTreeSet
 from BTrees.LFBTree import LFBTreePy, LFBucketPy, LFSetPy, LFTreeSetPy
 from BTrees.LLBTree import LLBTree, LLBucket, LLSet, LLTreeSet
 from BTrees.LLBTree import LLBTreePy, LLBucketPy, LLSetPy, LLTreeSetPy
 from BTrees.LOBTree import LOBTree, LOBucket, LOSet, LOTreeSet
 from BTrees.LOBTree import LOBTreePy, LOBucketPy, LOSetPy, LOTreeSetPy
+from BTrees.LQBTree import LQBTree, LQBucket, LQSet, LQTreeSet
+from BTrees.LQBTree import LQBTreePy, LQBucketPy, LQSetPy, LQTreeSetPy
+
+# 64-bit unsigned int
+from BTrees.QFBTree import QFBTree, QFBucket, QFSet, QFTreeSet
+from BTrees.QFBTree import QFBTreePy, QFBucketPy, QFSetPy, QFTreeSetPy
+from BTrees.QLBTree import QLBTree, QLBucket, QLSet, QLTreeSet
+from BTrees.QLBTree import QLBTreePy, QLBucketPy, QLSetPy, QLTreeSetPy
+from BTrees.QOBTree import QOBTree, QOBucket, QOSet, QOTreeSet
+from BTrees.QOBTree import QOBTreePy, QOBucketPy, QOSetPy, QOTreeSetPy
+from BTrees.QQBTree import QQBTree, QQBucket, QQSet, QQTreeSet
+from BTrees.QQBTree import QQBTreePy, QQBucketPy, QQSetPy, QQTreeSetPy
+
+
 from BTrees.OIBTree import OIBTree, OIBucket, OISet, OITreeSet
 from BTrees.OIBTree import OIBTreePy, OIBucketPy, OISetPy, OITreeSetPy
 from BTrees.OLBTree import OLBTree, OLBucket, OLSet, OLTreeSet
 from BTrees.OLBTree import OLBTreePy, OLBucketPy, OLSetPy, OLTreeSetPy
 from BTrees.OOBTree import OOBTree, OOBucket, OOSet, OOTreeSet
 from BTrees.OOBTree import OOBTreePy, OOBucketPy, OOSetPy, OOTreeSetPy
+from BTrees.OUBTree import OUBTree, OUBucket, OUSet, OUTreeSet
+from BTrees.OUBTree import OUBTreePy, OUBucketPy, OUSetPy, OUTreeSetPy
+from BTrees.OQBTree import OQBTree, OQBucket, OQSet, OQTreeSet
+from BTrees.OQBTree import OQBTreePy, OQBucketPy, OQSetPy, OQTreeSetPy
 
 from BTrees.utils import positive_id
 from BTrees.utils import oid_repr
@@ -59,17 +92,22 @@ TYPE_UNKNOWN, TYPE_BTREE, TYPE_BUCKET = range(3)
 from ._compat import compare
 
 _type2kind = {}
-for kv in ('OO',
-           'II', 'IO', 'OI', 'IF',
-           'LL', 'LO', 'OL', 'LF',
-           ):
+_FAMILIES = (
+    'OO', 'OI', 'OU', 'OL', 'OQ',
+    'II', 'IO', 'IF', 'IU',
+    'LL', 'LO', 'LF', 'LQ',
+    'UU', 'UO', 'UF', 'UI',
+    'QQ', 'QO', 'QF', 'QL',
+    # Note that fs is missing from this list.
+)
+for kv in _FAMILIES:
     for name, kind in (
-        ('BTree', (TYPE_BTREE, True)),
-        ('Bucket', (TYPE_BUCKET, True)),
-        ('TreeSet', (TYPE_BTREE, False)),
-        ('Set', (TYPE_BUCKET, False)),
-        ):
-        _type2kind[globals()[kv+name]] = kind
+            ('BTree', (TYPE_BTREE, True)),
+            ('Bucket', (TYPE_BUCKET, True)),
+            ('TreeSet', (TYPE_BTREE, False)),
+            ('Set', (TYPE_BUCKET, False)),
+    ):
+        _type2kind[globals()[kv + name]] = kind
         py = kv + name + 'Py'
         _type2kind[globals()[py]] = kind
 
@@ -122,10 +160,7 @@ BTREE_EMPTY, BTREE_ONE, BTREE_NORMAL = range(3)
 #     )
 
 _btree2bucket = {}
-for kv in ('OO',
-           'II', 'IO', 'OI', 'IF',
-           'LL', 'LO', 'OL', 'LF',
-           ):
+for kv in _FAMILIES:
     _btree2bucket[globals()[kv+'BTree']] = globals()[kv+'Bucket']
     py = kv + 'BTreePy'
     _btree2bucket[globals()[py]] = globals()[kv+'BucketPy']

BTrees/intkeymacros.h

 
 #define KEYMACROS_H "$Id$\n"
 
+#ifndef ZODB_UNSIGNED_KEY_INTS
+/* signed keys */
 #ifdef ZODB_64BIT_INTS
 /* PY_LONG_LONG as key */
 #define NEED_LONG_LONG_SUPPORT
@@ -12,7 +14,7 @@
     if (!longlong_convert((ARG), &TARGET)) \
     { \
         (STATUS)=0; (TARGET)=0; \
-    } 
+    }
 #else
 /* C int as key */
 #define KEY_TYPE int
@@ -31,6 +33,43 @@
       PyErr_SetString(PyExc_TypeError, "expected integer key");   \
       (STATUS)=0; (TARGET)=0; }
 #endif
+#else
+/* Unsigned keys */
+#ifdef ZODB_64BIT_INTS
+/* PY_LONG_LONG as key */
+#define NEED_LONG_LONG_SUPPORT
+#define NEED_LONG_LONG_KEYS
+#define KEY_TYPE unsigned PY_LONG_LONG
+#define KEY_CHECK ulonglong_check
+#define COPY_KEY_TO_OBJECT(O, K) O=ulonglong_as_object(K)
+#define COPY_KEY_FROM_ARG(TARGET, ARG, STATUS) \
+    if (!ulonglong_convert((ARG), &TARGET)) \
+    { \
+        (STATUS)=0; (TARGET)=0; \
+    }
+#else
+/* C int as key */
+#define KEY_TYPE unsigned int
+#define KEY_CHECK INT_CHECK
+#define COPY_KEY_TO_OBJECT(O, K) O=UINT_FROM_LONG(K)
+#define COPY_KEY_FROM_ARG(TARGET, ARG, STATUS)                    \
+  if (INT_CHECK(ARG)) {                                           \
+      long vcopy = INT_AS_LONG(ARG);                     \
+      if (PyErr_Occurred()) { (STATUS)=0; (TARGET)=0; }           \
+      else if (vcopy < 0) {                                       \
+        PyErr_SetString(PyExc_OverflowError, "can't convert negative value to unsigned int"); \
+        (STATUS)=0; (TARGET)=0;                                   \
+      }                                                           \
+      else if ((unsigned int)vcopy != vcopy) {                     \
+        PyErr_SetString(PyExc_TypeError, "integer out of range"); \
+        (STATUS)=0; (TARGET)=0;                                   \
+      }                                                           \
+      else TARGET = vcopy;                                        \
+  } else {                                                        \
+      PyErr_SetString(PyExc_TypeError, "expected integer key");   \
+      (STATUS)=0; (TARGET)=0; }
+#endif
+#endif /* ZODB_SIGNED_KEY_INTS */
 
 #undef KEY_TYPE_IS_PYOBJECT
 #define TEST_KEY_SET_OR(V, K, T) if ( ( (V) = (((K) < (T)) ? -1 : (((K) > (T)) ? 1: 0)) ) , 0 )

BTrees/intvaluemacros.h

 
 #define VALUEMACROS_H "$Id$\n"
 
+/*
+  VALUE_PARSE is used exclusively in SetOpTemplate.c to accept the weight
+  values for merging. The PyArg_ParseTuple function it uses has no trivial way
+  to express "unsigned with check", so in the unsigned case, passing negative
+  values as weights will produce weird output no matter what VALUE_PARSE we
+  use (because it will immediately get cast to an unsigned).
+*/
+
+#ifndef ZODB_UNSIGNED_VALUE_INTS
+/*signed values */
 #ifdef ZODB_64BIT_INTS
 #define NEED_LONG_LONG_SUPPORT
 #define VALUE_TYPE PY_LONG_LONG
@@ -10,7 +20,7 @@
     if (!longlong_convert((ARG), &TARGET)) \
     { \
         (STATUS)=0; (TARGET)=0; \
-    } 
+    }
 #else
 #define VALUE_TYPE int
 #define VALUE_PARSE "i"
@@ -30,9 +40,47 @@
       (STATUS)=0; (TARGET)=0; }
 
 #endif
+#else
+/* unsigned values */
+#ifdef ZODB_64BIT_INTS
+/* unsigned, 64-bit values */
+#define NEED_LONG_LONG_SUPPORT
+#define VALUE_TYPE unsigned PY_LONG_LONG
+#define VALUE_PARSE "K"
+#define COPY_VALUE_TO_OBJECT(O, K) O=ulonglong_as_object(K)
+#define COPY_VALUE_FROM_ARG(TARGET, ARG, STATUS) \
+    if (!ulonglong_convert((ARG), &TARGET)) \
+    { \
+        (STATUS)=0; (TARGET)=0; \
+    }
+#else
+/* unsigned, 32-bit values */
+#define VALUE_TYPE unsigned int
+#define VALUE_PARSE "I"
+#define COPY_VALUE_TO_OBJECT(O, K) O=UINT_FROM_LONG(K)
+
+#define COPY_VALUE_FROM_ARG(TARGET, ARG, STATUS)                  \
+  if (INT_CHECK(ARG)) {                                           \
+      long vcopy = INT_AS_LONG(ARG);                              \
+      if (PyErr_Occurred()) { (STATUS)=0; (TARGET)=0; }           \
+      else if (vcopy < 0) {                                       \
+        PyErr_SetString(PyExc_OverflowError, "can't convert negative value to unsigned int"); \
+        (STATUS)=0; (TARGET)=0;                                   \
+      }								  \
+      else if ((unsigned int)vcopy != vcopy) {                    \
+        PyErr_SetString(PyExc_TypeError, "integer out of range"); \
+        (STATUS)=0; (TARGET)=0;                                   \
+      }                                                           \
+      else TARGET = vcopy;                                        \
+  } else {                                                        \
+      PyErr_SetString(PyExc_TypeError, "expected integer key");   \
+      (STATUS)=0; (TARGET)=0; }
+
+#endif
+#endif
 
 #undef VALUE_TYPE_IS_PYOBJECT
-#define TEST_VALUE(K, T) (((K) < (T)) ? -1 : (((K) > (T)) ? 1: 0)) 
+#define TEST_VALUE(K, T) (((K) < (T)) ? -1 : (((K) > (T)) ? 1: 0))
 #define VALUE_SAME(VALUE, TARGET) ( (VALUE) == (TARGET) )
 #define DECLARE_VALUE(NAME) VALUE_TYPE NAME
 #define DECREF_VALUE(k)

BTrees/tests/common.py

@@ -13,7 +13,6 @@
 ##############################################################################
 from __future__ import division
 
-import sys
 import functools
 import unittest
 import platform
@@ -56,7 +55,52 @@ def _skip_if_pure_py_and_py_test(self):
         # one normal/C and one with Py in the name for the Py test.
         raise unittest.SkipTest("Redundant with the C test")
 
-class Base(object):
+# pylint:disable=too-many-lines
+# pylint:disable=no-member,protected-access,unused-variable,import-error
+# pylint:disable=line-too-long,unidiomatic-typecheck,abstract-method
+# pylint:disable=redefined-builtin
+
+#: The exceptions that can be raised by failed
+#: unsigned conversions. The OverflowError is raised
+#: by the interpreter and is nicer than the manual error.
+UnsignedError = (TypeError, OverflowError)
+
+def uses_negative_keys_and_values(func):
+    """
+    Apply this decorator to tests that use negative keys and values.
+
+    If the underlying mapping doesn't support that, it will
+    be expected to raise a TypeError or OverflowError.
+    """
+    @functools.wraps(func)
+    def test(self):
+        if not (self.SUPPORTS_NEGATIVE_KEYS and self.SUPPORTS_NEGATIVE_VALUES):
+            with self.assertRaises(UnsignedError):
+                func(self)
+        else:
+            func(self)
+    return test
+
+class SignedMixin(object):
+    SUPPORTS_NEGATIVE_KEYS = True
+    SUPPORTS_NEGATIVE_VALUES = True
+    #: The values to pass to ``random.randrange()`` to generate
+    #: valid keys.
+    KEY_RANDRANGE_ARGS = (-2000, 2001)
+
+
+class UnsignedMixin(object):
+    SUPPORTS_NEGATIVE_KEYS = False
+    SUPPORTS_NEGATIVE_VALUES = False
+    KEY_RANDRANGE_ARGS = (0, 4002)
+
+class UnsignedValuesMixin(SignedMixin):
+    SUPPORTS_NEGATIVE_VALUES = False
+
+class UnsignedKeysMixin(UnsignedMixin):
+    SUPPORTS_NEGATIVE_VALUES = True
+
+class Base(SignedMixin):
     # Tests common to all types: sets, buckets, and BTrees
 
     db = None
@@ -141,9 +185,9 @@ class Base(object):
 
             root2 = self._getRoot()
             if hasattr(t, 'items'):
-                self.assertEqual(list(root2[i].items()) , list(t.items()))
+                self.assertEqual(list(root2[i].items()), list(t.items()))
             else:
-                self.assertEqual(list(root2[i].keys()) , list(t.keys()))
+                self.assertEqual(list(root2[i].keys()), list(t.keys()))
 
             self._closeRoot(root)
             self._closeRoot(root2)
@@ -170,9 +214,9 @@ class Base(object):
             root2[i]._p_deactivate()
             transaction.commit()
             if hasattr(t, 'items'):
-                self.assertEqual(list(root2[i].items()) , list(t.items()))
+                self.assertEqual(list(root2[i].items()), list(t.items()))
             else:
-                self.assertEqual(list(root2[i].keys()) , list(t.keys()))
+                self.assertEqual(list(root2[i].keys()), list(t.keys()))
 
             self._closeRoot(root)
             self._closeRoot(root2)
@@ -204,12 +248,16 @@ class Base(object):
         self.assertEqual(list(t.keys(excludemax=True)), [0, 1])
         self.assertEqual(list(t.keys(excludemin=True, excludemax=True)), [1])
 
-        self.assertEqual(list(t.keys(-1, 3, excludemin=True, excludemax=True)),
-                         [0, 1, 2])
+        for low, high, expected in ((-1, 3, [0, 1, 2]), (-1, 2, [0, 1])):
+            if self.SUPPORTS_NEGATIVE_KEYS:
+                self.assertEqual(list(t.keys(low, high, excludemin=True, excludemax=True)),
+                                 expected)
+            else:
+                with self.assertRaises(UnsignedError):
+                    t.keys(low, high, excludemin=True, excludemax=True)
+
         self.assertEqual(list(t.keys(0, 3, excludemin=True, excludemax=True)),
                          [1, 2])
-        self.assertEqual(list(t.keys(-1, 2, excludemin=True, excludemax=True)),
-                         [0, 1])
         self.assertEqual(list(t.keys(0, 2, excludemin=True, excludemax=True)),
                          [1])
 
@@ -354,11 +402,12 @@ class Base(object):
 
 class MappingBase(Base):
     # Tests common to mappings (buckets, btrees)
+    SUPPORTS_NEGATIVE_VALUES = True
 
     def _populate(self, t, l):
         # Make some data
         for i in range(l):
-            t[i]=i
+            t[i] = i
 
     def testShortRepr(self):
         # test the repr because buckets have a complex repr implementation
@@ -407,21 +456,21 @@ class MappingBase(Base):
         return self._makeOne()[1]
 
     def testGetReturnsDefault(self):
-        self.assertEqual(self._makeOne().get(1) , None)
-        self.assertEqual(self._makeOne().get(1, 'foo') , 'foo')
+        self.assertEqual(self._makeOne().get(1), None)
+        self.assertEqual(self._makeOne().get(1, 'foo'), 'foo')
 
     def testSetItemGetItemWorks(self):
         t = self._makeOne()
         t[1] = 1
         a = t[1]
-        self.assertEqual(a , 1, repr(a))
+        self.assertEqual(a, 1, repr(a))
 
     def testReplaceWorks(self):
         t = self._makeOne()
         t[1] = 1
-        self.assertEqual(t[1] , 1, t[1])
+        self.assertEqual(t[1], 1, t[1])
         t[1] = 2
-        self.assertEqual(t[1] , 2, t[1])
+        self.assertEqual(t[1], 2, t[1])
 
     def testLen(self):
         import random
@@ -433,7 +482,7 @@ class MappingBase(Base):
             t[k] = x
             added[k] = x
         addl = added.keys()
-        self.assertEqual(len(t) , len(addl), len(t))
+        self.assertEqual(len(t), len(addl), len(t))
 
     def testHasKeyWorks(self):
         from .._compat import PY2
@@ -464,12 +513,13 @@ class MappingBase(Base):
             t[99-x] = x
 
         for x in range(40):
-            lst = sorted(t.values(0+x,99-x))
-            self.assertEqual(lst, list(range(0+x,99-x+1)))
+            lst = sorted(t.values(0 + x, 99 - x))
+            self.assertEqual(lst, list(range(0 + x, 99 - x + 1)))
 
-            lst = sorted(t.values(max=99-x, min=0+x))
-            self.assertEqual(lst, list(range(0+x,99-x+1)))
+            lst = sorted(t.values(max=99 - x, min=0 + x))
+            self.assertEqual(lst, list(range(0 + x, 99 - x + 1)))
 
+    @uses_negative_keys_and_values
     def testValuesNegativeIndex(self):
         t = self._makeOne()
         L = [-3, 6, -11, 4]
@@ -488,19 +538,20 @@ class MappingBase(Base):
         v = t.keys()
         i = 0
         for x in v:
-            self.assertEqual(x,i)
+            self.assertEqual(x, i)
             i = i + 1
         self.assertRaises(IndexError, lambda: v[i])
 
         for x in range(40):
-            lst = t.keys(0+x,99-x)
-            self.assertEqual(list(lst), list(range(0+x, 99-x+1)))
+            lst = t.keys(0 + x, 99 - x)
+            self.assertEqual(list(lst), list(range(0 + x, 99 - x + 1)))
 
             lst = t.keys(max=99-x, min=0+x)
             self.assertEqual(list(lst), list(range(0+x, 99-x+1)))
 
         self.assertEqual(len(v), 100)
 
+    @uses_negative_keys_and_values
     def testKeysNegativeIndex(self):
         t = self._makeOne()
         L = [-3, 6, -11, 4]
@@ -536,6 +587,8 @@ class MappingBase(Base):
         self.assertEqual(items, list(zip(range(12, 21), range(24, 43, 2))))
 
     def testItemsNegativeIndex(self):
+        if not (self.SUPPORTS_NEGATIVE_KEYS and self.SUPPORTS_NEGATIVE_VALUES):
+            self.skipTest("Needs negative keys and values")
         t = self._makeOne()
         L = [-3, 6, -11, 4]
         for i in L:
@@ -601,14 +654,14 @@ class MappingBase(Base):
     def testUpdate(self):
         import random
         t = self._makeOne()
-        d={}
-        l=[]
+        d = {}
+        l = []
         for i in range(10000):
-            k=random.randrange(-2000, 2001)
-            d[k]=i
+            k = random.randrange(*self.KEY_RANDRANGE_ARGS)
+            d[k] = i
             l.append((k, i))
 
-        items= sorted(d.items())
+        items = sorted(d.items())
 
         t.update(d)
         self.assertEqual(list(t.items()), items)
@@ -633,12 +686,14 @@ class MappingBase(Base):
 
     def testEmptyRangeSearches(self):
         t = self._makeOne()
-        t.update([(1,1), (5,5), (9,9)])
-        self.assertEqual(list(t.keys(-6,-4)), [], list(t.keys(-6,-4)))
-        self.assertEqual(list(t.keys(2,4)), [], list(t.keys(2,4)))
-        self.assertEqual(list(t.keys(6,8)), [], list(t.keys(6,8)))
-        self.assertEqual(list(t.keys(10,12)), [], list(t.keys(10,12)))
-        self.assertEqual(list(t.keys(9, 1)), [], list(t.keys(9, 1)))
+        t.update([(1, 1), (5, 5), (9, 9)])
+        if self.SUPPORTS_NEGATIVE_KEYS:
+            self.assertEqual(list(t.keys(-6, -4)), [])
+
+        self.assertEqual(list(t.keys(2, 4)), [])
+        self.assertEqual(list(t.keys(6, 8)), [])
+        self.assertEqual(list(t.keys(10, 12)), [])
+        self.assertEqual(list(t.keys(9, 1)), [])
 
         # For IITreeSets, this one was returning 31 for len(keys), and
         # list(keys) produced a list with 100 elements.
@@ -662,6 +717,7 @@ class MappingBase(Base):
         # "BTreeItems slice contains 1 too many elements".
         from .._compat import xrange
         t = self._makeOne()
+        val_multiplier = -2 if self.SUPPORTS_NEGATIVE_VALUES else 2
         for n in range(10):
             t.clear()
             self.assertEqual(len(t), 0)
@@ -669,8 +725,9 @@ class MappingBase(Base):
             keys = []
             values = []
             items = []
+
             for key in range(n):
-                value = -2 * key
+                value = key * val_multiplier
                 t[key] = value
                 keys.append(key)
                 values.append(value)
@@ -730,13 +787,15 @@ class MappingBase(Base):
         self.assertEqual(len(tslice), 60)
         self.assertEqual(list(tslice), list(zip(range(20, 80), [1]*60)))
 
+    @uses_negative_keys_and_values
     def testIterators(self):
         t = self._makeOne()
 
         for keys in [], [-2], [1, 4], list(range(-170, 2000, 6)):
             t.clear()
             for k in keys:
-                t[k] = -3 * k
+                val = -3 * k
+                t[k] = val
 
             self.assertEqual(list(t), keys)
 
@@ -759,6 +818,7 @@ class MappingBase(Base):
             self.assertEqual(list(t.itervalues()), list(t.values()))
             self.assertEqual(list(t.iteritems()), list(t.items()))
 
+    @uses_negative_keys_and_values
     def testRangedIterators(self):
         t = self._makeOne()
 
@@ -838,6 +898,10 @@ class MappingBase(Base):
             if meth is None:
                 continue
 
+            __traceback_info__ = meth
+
+            supports_negative = self.SUPPORTS_NEGATIVE_KEYS
+
             self.assertEqual(list(meth()), [])
             self.assertEqual(list(meth(excludemin=True)), [])
             self.assertEqual(list(meth(excludemax=True)), [])
@@ -862,16 +926,19 @@ class MappingBase(Base):
             self.assertEqual(list(meth(excludemin=True)), f([1, 2]))
             self.assertEqual(list(meth(excludemax=True)), f([0, 1]))
             self.assertEqual(list(meth(excludemin=True, excludemax=True)),
-                            f([1]))
-            self.assertEqual(list(meth(-1, 3, excludemin=True,
-                                       excludemax=True)),
-                             f([0, 1, 2]))
+                             f([1]))
+            if supports_negative:
+                self.assertEqual(list(meth(-1, 2, excludemin=True,
+                                           excludemax=True)),
+                                 f([0, 1]))
+
+                self.assertEqual(list(meth(-1, 3, excludemin=True,
+                                           excludemax=True)),
+                                 f([0, 1, 2]))
+
             self.assertEqual(list(meth(0, 3, excludemin=True,
                                        excludemax=True)),
                              f([1, 2]))
-            self.assertEqual(list(meth(-1, 2, excludemin=True,
-                                       excludemax=True)),
-                             f([0, 1]))
             self.assertEqual(list(meth(0, 2, excludemin=True,
                                        excludemax=True)),
                              f([1]))
@@ -930,6 +997,16 @@ class MappingBase(Base):
         # Too many arguments.
         self.assertRaises(TypeError, t.pop, 1, 2, 3)
 
+class UnsignedMappingBase(UnsignedMixin, MappingBase):
+    pass
+
+class UnsignedValuesMappingBase(UnsignedValuesMixin, MappingBase):
+    pass
+
+class UnsignedKeysMappingBase(UnsignedKeysMixin, MappingBase):
+    pass
+
+
 class BTreeTests(MappingBase):
     # Tests common to all BTrees
 
@@ -943,7 +1020,7 @@ class BTreeTests(MappingBase):
             return type(self._makeOne())
         raise NotImplementedError()
 
-    def _makeOne(self, *args):
+    def _makeOne(self, *args): # pylint:disable=arguments-differ
         return self._getTargetClass()(*args)
 
     def _checkIt(self, t):
@@ -961,8 +1038,8 @@ class BTreeTests(MappingBase):
         t[10] = 500
         t[4] = 99
         del t[4]
-        diff = lsubtract(t.keys(), [1,2,3,5,6,10])
-        self.assertEqual(diff , [], diff)
+        diff = lsubtract(t.keys(), [1, 2, 3, 5, 6, 10])
+        self.assertEqual(diff, [], diff)
         self._checkIt(t)
 
     def testDeleteOneChildWorks(self):
@@ -975,8 +1052,8 @@ class BTreeTests(MappingBase):
         t[10] = 500
         t[4] = 99
         del t[3]
-        diff = lsubtract(t.keys(), [1,2,4,5,6,10])
-        self.assertEqual(diff , [], diff)
+        diff = lsubtract(t.keys(), [1, 2, 4, 5, 6, 10])
+        self.assertEqual(diff, [], diff)
         self._checkIt(t)
 
     def testDeleteTwoChildrenNoInorderSuccessorWorks(self):
@@ -989,8 +1066,8 @@ class BTreeTests(MappingBase):
         t[10] = 500
         t[4] = 99
         del t[2]
-        diff = lsubtract(t.keys(), [1,3,4,5,6,10])
-        self.assertEqual(diff , [], diff)
+        diff = lsubtract(t.keys(), [1, 3, 4, 5, 6, 10])
+        self.assertEqual(diff, [], diff)
         self._checkIt(t)
 
     def testDeleteTwoChildrenInorderSuccessorWorks(self):
@@ -1005,8 +1082,8 @@ class BTreeTests(MappingBase):
         t[6] = 99
         t[4] = 150
         del t[3]
-        diff = lsubtract(t.keys(), [1,4,5,6,7,8,10])
-        self.assertEqual(diff , [], diff)
+        diff = lsubtract(t.keys(), [1, 4, 5, 6, 7, 8, 10])
+        self.assertEqual(diff, [], diff)
         self._checkIt(t)
 
     def testDeleteRootWorks(self):
@@ -1021,8 +1098,8 @@ class BTreeTests(MappingBase):
         t[6] = 99
         t[4] = 150
         del t[7]
-        diff = lsubtract(t.keys(), [1,3,4,5,6,8,10])
-        self.assertEqual(diff , [], diff)
+        diff = lsubtract(t.keys(), [1, 3, 4, 5, 6, 8, 10])
+        self.assertEqual(diff, [], diff)
         self._checkIt(t)
 
     def testRandomNonOverlappingInserts(self):
@@ -1037,7 +1114,7 @@ class BTreeTests(MappingBase):
                 added[k] = 1
         addl = sorted(added.keys())
         diff = lsubtract(list(t.keys()), addl)
-        self.assertEqual(diff , [], (diff, addl, list(t.keys())))
+        self.assertEqual(diff, [], (diff, addl, list(t.keys())))
         self._checkIt(t)
 
     def testRandomOverlappingInserts(self):
@@ -1051,7 +1128,7 @@ class BTreeTests(MappingBase):
             added[k] = 1
         addl = sorted(added.keys())
         diff = lsubtract(t.keys(), addl)
-        self.assertEqual(diff , [], diff)
+        self.assertEqual(diff, [], diff)
         self._checkIt(t)
 
     def testRandomDeletes(self):
@@ -1071,12 +1148,12 @@ class BTreeTests(MappingBase):
                 del t[k]
                 deleted.append(k)
                 if k in t:
-                    self.fail( "had problems deleting %s" % k )
+                    self.fail("had problems deleting %s" % k)
         badones = []
         for x in deleted:
             if x in t:
                 badones.append(x)
-        self.assertEqual(badones , [], (badones, added, deleted))
+        self.assertEqual(badones, [], (badones, added, deleted))
         self._checkIt(t)
 
     def testTargetedDeletes(self):
@@ -1091,7 +1168,7 @@ class BTreeTests(MappingBase):
                 del t[x]
             except KeyError:
                 pass
-        self.assertEqual(realseq(t.keys()) , [], realseq(t.keys()))
+        self.assertEqual(realseq(t.keys()), [], realseq(t.keys()))
         self._checkIt(t)
 
     def testPathologicalRightBranching(self):
@@ -1099,10 +1176,10 @@ class BTreeTests(MappingBase):
         r = list(range(1000))
         for x in r:
             t[x] = 1
-        self.assertEqual(realseq(t.keys()) , r, realseq(t.keys()))
+        self.assertEqual(realseq(t.keys()), r, realseq(t.keys()))
         for x in r:
             del t[x]
-        self.assertEqual(realseq(t.keys()) , [], realseq(t.keys()))
+        self.assertEqual(realseq(t.keys()), [], realseq(t.keys()))
         self._checkIt(t)
 
     def testPathologicalLeftBranching(self):
@@ -1111,11 +1188,11 @@ class BTreeTests(MappingBase):
         revr = list(reversed(r[:]))
         for x in revr:
             t[x] = 1
-        self.assertEqual(realseq(t.keys()) , r, realseq(t.keys()))
+        self.assertEqual(realseq(t.keys()), r, realseq(t.keys()))
 
         for x in revr:
             del t[x]
-        self.assertEqual(realseq(t.keys()) , [], realseq(t.keys()))
+        self.assertEqual(realseq(t.keys()), [], realseq(t.keys()))
         self._checkIt(t)
 
     def testSuccessorChildParentRewriteExerciseCase(self):
@@ -1165,7 +1242,7 @@ class BTreeTests(MappingBase):
                 del t[x]
             except KeyError:
                 if x in t:
-                    self.assertEqual(1,2,"failed to delete %s" % x)
+                    self.assertEqual(1, 2, "failed to delete %s" % x)
         self._checkIt(t)
 
     def testRangeSearchAfterSequentialInsert(self):
@@ -1174,16 +1251,16 @@ class BTreeTests(MappingBase):
         for x in r:
             t[x] = 0
         diff = lsubtract(list(t.keys(0, 100)), r)
-        self.assertEqual(diff , [], diff)
+        self.assertEqual(diff, [], diff)
         # The same thing with no bounds
         diff = lsubtract(list(t.keys(None, None)), r)
-        self.assertEqual(diff , [], diff)
+        self.assertEqual(diff, [], diff)
         # The same thing with each bound set and the other
         # explicitly None
         diff = lsubtract(list(t.keys(0, None)), r)
-        self.assertEqual(diff , [], diff)
-        diff = lsubtract(list(t.keys(None,100)), r)
-        self.assertEqual(diff , [], diff)
+        self.assertEqual(diff, [], diff)
+        diff = lsubtract(list(t.keys(None, 100)), r)
+        self.assertEqual(diff, [], diff)
         self._checkIt(t)
 
     def testRangeSearchAfterRandomInsert(self):
@@ -1202,7 +1279,15 @@ class BTreeTests(MappingBase):
     def testPathologicalRangeSearch(self):
         t = self._makeOne()
         # Build a 2-level tree with at least two buckets.
-        for i in range(200):
+        if self.SUPPORTS_NEGATIVE_KEYS:
+            range_begin = 0
+            firstkey_offset = 1
+        else:
+            range_begin = 1
+            firstkey_offset = 0
+
+        before_range_begin = range_begin - 1
+        for i in range(range_begin, 200 + range_begin):
             t[i] = i
         items, dummy = t.__getstate__()
         self.assertTrue(len(items) > 2)   # at least two buckets and a key
@@ -1210,9 +1295,9 @@ class BTreeTests(MappingBase):
         # second bucket are >= firstkey, and firstkey is the first key in
         # the second bucket.
         firstkey = items[1]
-        therange = t.keys(-1, firstkey)
-        self.assertEqual(len(therange), firstkey + 1)
-        self.assertEqual(list(therange), list(range(firstkey + 1)))
+        therange = t.keys(before_range_begin, firstkey)
+        self.assertEqual(len(therange), firstkey + firstkey_offset)
+        self.assertEqual(list(therange), list(range(range_begin, firstkey + 1)))
         # Now for the tricky part.  If we delete firstkey, the second bucket
         # loses its smallest key, but firstkey remains in the BTree node.
         # If we then do a high-end range search on firstkey, the BTree node
@@ -1222,17 +1307,17 @@ class BTreeTests(MappingBase):
         # to "go backwards" in the BTree then; if it doesn't, it will
         # erroneously claim that the range is empty.
         del t[firstkey]
-        therange = t.keys(min=-1, max=firstkey)
-        self.assertEqual(len(therange), firstkey)
-        self.assertEqual(list(therange), list(range(firstkey)))
+        therange = t.keys(min=before_range_begin, max=firstkey)
+        self.assertEqual(len(therange), firstkey - range_begin)
+        self.assertEqual(list(therange), list(range(range_begin, firstkey)))
         self._checkIt(t)
 
     def testInsertMethod(self):
         t = self._makeOne()
         t[0] = 1
-        self.assertEqual(t.insert(0, 1) , 0)
-        self.assertEqual(t.insert(1, 1) , 1)
-        self.assertEqual(lsubtract(list(t.keys()), [0,1]) , [])
+        self.assertEqual(t.insert(0, 1), 0)
+        self.assertEqual(t.insert(1, 1), 1)
+        self.assertEqual(lsubtract(list(t.keys()), [0, 1]), [])
         self._checkIt(t)
 
     def testDamagedIterator(self):
@@ -1376,6 +1461,15 @@ class BTreeTests(MappingBase):
             self.assertEqual(s2, s)
 
 
+class UnsignedBTreeTests(UnsignedMixin, BTreeTests):
+    pass
+
+class UnsignedValuesBTreeTests(UnsignedValuesMixin, BTreeTests):
+    pass
+
+class UnsignedKeysBTreeTests(UnsignedKeysMixin, BTreeTests):
+    pass
+
 class NormalSetTests(Base):
     # Test common to all set types
 
@@ -1408,14 +1502,14 @@ class NormalSetTests(Base):
 
     def testInsertReturnsValue(self):
         t = self._makeOne()
-        self.assertEqual(t.insert(5) , 1)
-        self.assertEqual(t.add(4) , 1)
+        self.assertEqual(t.insert(5), 1)
+        self.assertEqual(t.add(4), 1)
 
     def testDuplicateInsert(self):
         t = self._makeOne()
         t.insert(5)
-        self.assertEqual(t.insert(5) , 0)
-        self.assertEqual(t.add(5) , 0)
+        self.assertEqual(t.insert(5), 0)
+        self.assertEqual(t.add(5), 0)
 
     def testInsert(self):
         from .._compat import PY2
@@ -1442,8 +1536,10 @@ class NormalSetTests(Base):
         from .._compat import xrange
         t = self._makeOne()
         r = xrange(10000)
-        for x in r: t.insert(x)
-        for x in r: t.remove(x)
+        for x in r:
+            t.insert(x)
+        for x in r:
+            t.remove(x)
 
     def testRemoveFails(self):
         self.assertRaises(KeyError, self._removenonexistent)
@@ -1466,7 +1562,7 @@ class NormalSetTests(Base):
             t.insert(x)
         diff = lsubtract(t.keys(), r)
         self.assertEqual(diff, [])
-        diff = lsubtract(t.keys(None,None), r)
+        diff = lsubtract(t.keys(None, None), r)
         self.assertEqual(diff, [])
 
 
@@ -1474,10 +1570,11 @@ class NormalSetTests(Base):
         from .._compat import xrange
         t = self._makeOne()
         r = xrange(1000)
-        for x in r: t.insert(x)
+        for x in r:
+            t.insert(x)
         t.clear()
         diff = lsubtract(t.keys(), [])
-        self.assertEqual(diff , [], diff)
+        self.assertEqual(diff, [], diff)
 
     def testMaxKeyMinKey(self):
         t = self._makeOne()
@@ -1489,14 +1586,14 @@ class NormalSetTests(Base):
         t.insert(10)
         t.insert(6)
         t.insert(4)
-        self.assertEqual(t.maxKey() , 10)
-        self.assertEqual(t.maxKey(None) , 10)
-        self.assertEqual(t.maxKey(6) , 6)
-        self.assertEqual(t.maxKey(9) , 8)
-        self.assertEqual(t.minKey() , 1)
-        self.assertEqual(t.minKey(None) , 1)
-        self.assertEqual(t.minKey(3) , 3)
-        self.assertEqual(t.minKey(9) , 10)
+        self.assertEqual(t.maxKey(), 10)
+        self.assertEqual(t.maxKey(None), 10)
+        self.assertEqual(t.maxKey(6), 6)
+        self.assertEqual(t.maxKey(9), 8)
+        self.assertEqual(t.minKey(), 1)
+        self.assertEqual(t.minKey(None), 1)
+        self.assertEqual(t.minKey(3), 3)
+        self.assertEqual(t.minKey(9), 10)
         self.assertTrue(t.minKey() in t)
         self.assertTrue(t.minKey()-1 not in t)
         self.assertTrue(t.maxKey() in t)
@@ -1519,11 +1616,11 @@ class NormalSetTests(Base):
     def testUpdate(self):
         import random
         t = self._makeOne()
-        d={}
-        l=[]
+        d = {}
+        l = []
         for i in range(10000):
-            k=random.randrange(-2000, 2001)
-            d[k]=i
+            k = random.randrange(*self.KEY_RANDRANGE_ARGS)
+            d[k] = i
             l.append(k)
 
         items = sorted(d.keys())
@@ -1534,11 +1631,13 @@ class NormalSetTests(Base):
     def testEmptyRangeSearches(self):
         t = self._makeOne()
         t.update([1, 5, 9])
-        self.assertEqual(list(t.keys(-6,-4)), [], list(t.keys(-6,-4)))
-        self.assertEqual(list(t.keys(2,4)), [], list(t.keys(2,4)))
-        self.assertEqual(list(t.keys(6,8)), [], list(t.keys(6,8)))
-        self.assertEqual(list(t.keys(10,12)), [], list(t.keys(10,12)))
-        self.assertEqual(list(t.keys(9,1)), [], list(t.keys(9,1)))
+        if self.SUPPORTS_NEGATIVE_KEYS:
+            self.assertEqual(list(t.keys(-6, -4)), [])
+
+        self.assertEqual(list(t.keys(2, 4)), [])
+        self.assertEqual(list(t.keys(6, 8)), [])
+        self.assertEqual(list(t.keys(10, 12)), [])
+        self.assertEqual(list(t.keys(9, 1)), [])
 
         # For IITreeSets, this one was returning 31 for len(keys), and
         # list(keys) produced a list with 100 elements.
@@ -1588,6 +1687,11 @@ class NormalSetTests(Base):
 
         for keys in [], [-2], [1, 4], list(range(-170, 2000, 6)):
             t.clear()
+            if keys and keys[0] < 0 and not self.SUPPORTS_NEGATIVE_KEYS:
+                with self.assertRaises(UnsignedError):
+                    t.update(keys)
+                continue
+
             t.update(keys)
 
             self.assertEqual(list(t), keys)
@@ -1667,22 +1771,33 @@ class NormalSetTests(Base):
         # Whether or not doing `t.add(0)` again would result in
         # _p_changed being set depends on whether this is a TreeSet or a plain Set
 
+
+class UnsignedNormalSetTests(UnsignedMixin, NormalSetTests):
+    pass
+
+
 class ExtendedSetTests(NormalSetTests):
 
     def testLen(self):
         from .._compat import xrange
         t = self._makeOne()
         r = xrange(10000)
-        for x in r: t.insert(x)
-        self.assertEqual(len(t) , 10000, len(t))
+        for x in r:
+            t.insert(x)
+        self.assertEqual(len(t), 10000, len(t))
 
     def testGetItem(self):
         from .._compat import xrange
         t = self._makeOne()
         r = xrange(10000)
-        for x in r: t.insert(x)
         for x in r:
-            self.assertEqual(t[x] , x)
+            t.insert(x)
+        for x in r:
+            self.assertEqual(t[x], x)
+
+
+class UnsignedExtendedSetTests(UnsignedMixin, ExtendedSetTests):
+    pass
 
 
 class InternalKeysMappingTest(object):
@@ -1801,9 +1916,9 @@ class I_SetsBase(object):
         self.assertRaises(TypeError, t.update, [1, ''])
 
     def testNonIntegerInsertRaises(self):
-        self.assertRaises(TypeError,self._insertstringraises)
-        self.assertRaises(TypeError,self._insertfloatraises)
-        self.assertRaises(TypeError,self._insertnoneraises)
+        self.assertRaises(TypeError, self._insertstringraises)
+        self.assertRaises(TypeError, self._insertfloatraises)
+        self.assertRaises(TypeError, self._insertnoneraises)
 
     def _insertstringraises(self):
         self._makeOne().insert('a')
@@ -1821,7 +1936,7 @@ SMALLEST_32_BITS = -LARGEST_32_BITS - 1
 SMALLEST_POSITIVE_33_BITS = LARGEST_32_BITS + 1
 LARGEST_NEGATIVE_33_BITS = SMALLEST_32_BITS - 1
 
-LARGEST_64_BITS = 0x7fffffffffffffff
+LARGEST_64_BITS = 0x7fffffffffffffff # Signed. 2**63 - 1
 SMALLEST_64_BITS = -LARGEST_64_BITS - 1
 
 SMALLEST_POSITIVE_65_BITS = LARGEST_64_BITS + 1
@@ -1869,7 +1984,7 @@ class TestLongIntKeys(TestLongIntSupport):
         t[0] = o2
         self.assertEqual(t[zero_long], o2)
         self.assertEqual(list(t.keys()), [0])
-        self.assertEqual(list(t.keys(None,None)), [0])
+        self.assertEqual(list(t.keys(None, None)), [0])
 
         # Test some large key values too:
         k1 = SMALLEST_POSITIVE_33_BITS
@@ -1882,8 +1997,8 @@ class TestLongIntKeys(TestLongIntSupport):
         self.assertEqual(t[k2], o2)
         self.assertEqual(t[k3], o1)
         self.assertEqual(list(t.keys()), [k3, 0, k1, k2])
-        self.assertEqual(list(t.keys(k3,None)), [k3, 0, k1, k2])
-        self.assertEqual(list(t.keys(None,k2)), [k3, 0, k1, k2])
+        self.assertEqual(list(t.keys(k3, None)), [k3, 0, k1, k2])
+        self.assertEqual(list(t.keys(None, k2)), [k3, 0, k1, k2])
 
     def testLongIntKeysOutOfRange(self):
         self._skip_if_not_64bit()
@@ -1916,7 +2031,7 @@ class TestLongIntValues(TestLongIntSupport):
         self.assertEqual(t[k1], v1)
         self.assertEqual(t[k2], v2)
         self.assertEqual(list(t.values()), [v1, v2])
-        self.assertEqual(list(t.values(None,None)), [v1, v2])
+        self.assertEqual(list(t.values(None, None)), [v1, v2])
 
     def testLongIntValuesOutOfRange(self):
         self._skip_if_not_64bit()
@@ -1934,7 +2049,7 @@ class TestLongIntValues(TestLongIntSupport):
 # 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):
+    def result(keys=(), mapbuilder=mapbuilder):
         return mapbuilder(list(zip(keys, keys)))
     return result
 
@@ -1947,7 +2062,7 @@ class SetResult(object):
         super(SetResult, self).setUp()
         _skip_if_pure_py_and_py_test(self)
 
-        self.Akeys = [1,    3,    5, 6   ]
+        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()]
@@ -2061,7 +2176,7 @@ class SetResult(object):
                     self.assertEqual(list(C), want)
 
     def testLargerInputs(self):
-        from BTrees.IIBTree import IISet
+        from BTrees.IIBTree import IISet # pylint:disable=no-name-in-module
         from random import randint
         MAXSIZE = 200
         MAXVAL = 400
@@ -2091,11 +2206,11 @@ class SetResult(object):
 #     builders -- sequence of constructors, taking items
 #     union, intersection -- the module routines of those names
 #     mkbucket -- the module bucket builder
-class Weighted(object):
+class Weighted(SignedMixin):
 
     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.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()]
@@ -2171,6 +2286,8 @@ class Weighted(object):
                     self.assertEqual(got_s.items(), want_s)
 
                 for w1, w2 in self.weights:
+                    if (w1 < 0 or w2 < 0) and not self.SUPPORTS_NEGATIVE_VALUES:
+                        continue
                     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)
@@ -2203,6 +2320,8 @@ class Weighted(object):
                     self.assertEqual(got_s.items(), want_s)
 
                 for w1, w2 in self.weights:
+                    if (w1 < 0 or w2 < 0) and not self.SUPPORTS_NEGATIVE_VALUES:
+                        continue
                     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)
@@ -2227,7 +2346,7 @@ def isaset(thing):
 #     multiunion, union
 #     mkset, mktreeset
 #     mkbucket, mkbtree
-class MultiUnion(object):
+class MultiUnion(SignedMixin):
 
     def setUp(self):
         super(MultiUnion, self).setUp()
@@ -2237,10 +2356,13 @@ class MultiUnion(object):
         self.assertEqual(len(self.multiunion([])), 0)
 
     def testOne(self):
-        for sequence in ([3],
-                         list(range(20)),
-                         list(range(-10, 0, 2)) + list(range(1, 10, 2)),
-                        ):
+        for sequence in (
+                [3],
+                list(range(20)),
+                list(range(-10, 0, 2)) + list(range(1, 10, 2)),
+        ):
+            if min(sequence) < 0 and not self.SUPPORTS_NEGATIVE_KEYS:
+                continue
             seq1 = sequence[:]
             seq2 = list(reversed(sequence[:]))
             seqsorted = sorted(sequence[:])
@@ -2276,13 +2398,19 @@ class MultiUnion(object):
         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]))
+            if self.SUPPORTS_NEGATIVE_KEYS:
+                base = i * 4 - N
+            else:
+                base = i * 4
+            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), list(range(-N, 3*N)))
+        self.assertEqual(len(output), N * 4)
+        if self.SUPPORTS_NEGATIVE_KEYS:
+            self.assertEqual(list(output), list(range(-N, 3 * N)))
+        else:
+            self.assertEqual(list(output), list(range(N * 4)))
 
     def testFunkyKeyIteration(self):
         # The internal set iteration protocol allows "iterating over" a
@@ -2299,7 +2427,7 @@ class MultiUnion(object):
         self.assertEqual(list(fast), list(range(N)))
 
 
-class ConflictTestBase(object):
+class ConflictTestBase(SignedMixin, object):
     # Tests common to all types: sets, buckets, and BTrees
 
     storage = None
@@ -2307,6 +2435,10 @@ class ConflictTestBase(object):
     def setUp(self):
         super(ConflictTestBase, self).setUp()
         _skip_if_pure_py_and_py_test(self)
+        def identity(x):
+            return x
+        self.key_tx = abs if not self.SUPPORTS_NEGATIVE_KEYS else identity
+        self.val_tx = abs if not self.SUPPORTS_NEGATIVE_VALUES else identity
 
     def tearDown(self):
         import transaction
@@ -2328,44 +2460,45 @@ class ConflictTestBase(object):
         return self.db
 
 
-def _test_merge(o1, o2, o3, expect, message='failed to merge', should_fail=0):
-    from BTrees.Interfaces import BTreesConflictError
-    s1 = o1.__getstate__()
-    s2 = o2.__getstate__()
-    s3 = o3.__getstate__()
-    expected = expect.__getstate__()
-    if expected is None:
-        expected = ((((),),),)
+    def _test_merge(self, o1, o2, o3, expect, message='failed to merge', should_fail=False):
+        from BTrees.Interfaces import BTreesConflictError
+        s1 = o1.__getstate__()
+        s2 = o2.__getstate__()
+        s3 = o3.__getstate__()
+        expected = expect.__getstate__()
+        if expected is None:
+            expected = ((((),),),)
 
-    if should_fail:
-        try:
-            merged = o1._p_resolveConflict(s1, s2, s3)
-        except BTreesConflictError as err:
-            pass
+        if should_fail:
+            with self.assertRaises(BTreesConflictError):
+                __traceback_info__ = message
+                o1._p_resolveConflict(s1, s2, s3)
         else:
-            assert 0, message
-    else:
-        merged = o1._p_resolveConflict(s1, s2, s3)
-        assert merged == expected, message
+            merged = o1._p_resolveConflict(s1, s2, s3)
+            self.assertEqual(merged, expected, message)
 
 
 class MappingConflictTestBase(ConflictTestBase):
     # Tests common to mappings (buckets, btrees).
 
+
     def _deletefail(self):
         t = self._makeOne()
         del t[1]
 
     def _setupConflict(self):
-
-        l=[ -5124, -7377, 2274, 8801, -9901, 7327, 1565, 17, -679,
+        key_tx = self.key_tx
+        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)]
+            -4067
+        ]
+        l = [key_tx(v) for v in l]
 
+        e1 = [(-1704, 0), (5420, 1), (-239, 2), (4024, 3), (-6984, 4)]
+        e1 = [(key_tx(k), v) for k, v in e1]
+        e2 = [(7745, 0), (4868, 1), (-2548, 2), (-2711, 3), (-3154, 4)]
+        e2 = [(key_tx(k), v) for k, v in e2]
 
         base = self._makeOne()
         base.update([(i, i*i) for i in l[:20]])
@@ -2373,7 +2506,7 @@ class MappingConflictTestBase(ConflictTestBase):
         b2 = type(base)(base)
         bm = type(base)(base)
 
-        items=base.items()
+        items = base.items()
 
         return  base, b1, b2, bm, e1, e2, items
 
@@ -2387,66 +2520,67 @@ class MappingConflictTestBase(ConflictTestBase):
         del bm[items[5][0]]
         del bm[items[-1][0]]
         del bm[items[-2][0]]
-        _test_merge(base, b1, b2, bm, 'merge  delete')
+        self._test_merge(base, b1, b2, bm, 'merge  delete')
 
     def testMergeDeleteAndUpdate(self):
         base, b1, b2, bm, e1, e2, items = self._setupConflict()
         del b1[items[1][0]]
-        b2[items[5][0]]=1
+        b2[items[5][0]] = 1
         del b1[items[-1][0]]
-        b2[items[-2][0]]=2
+        b2[items[-2][0]] = 2
         del bm[items[1][0]]
-        bm[items[5][0]]=1
+        bm[items[5][0]] = 1
         del bm[items[-1][0]]
-        bm[items[-2][0]]=2
-        _test_merge(base, b1, b2, bm, 'merge update and delete')
+        bm[items[-2][0]] = 2
+        self._test_merge(base, b1, b2, bm, 'merge update and delete')
 
     def testMergeUpdate(self):
         base, b1, b2, bm, e1, e2, items = self._setupConflict()
-        b1[items[0][0]]=1
-        b2[items[5][0]]=2
-        b1[items[-1][0]]=3
-        b2[items[-2][0]]=4
-        bm[items[0][0]]=1
-        bm[items[5][0]]=2
-        bm[items[-1][0]]=3
-        bm[items[-2][0]]=4
-        _test_merge(base, b1, b2, bm, 'merge update')
+        b1[items[0][0]] = 1
+        b2[items[5][0]] = 2
+        b1[items[-1][0]] = 3
+        b2[items[-2][0]] = 4
+        bm[items[0][0]] = 1
+        bm[items[5][0]] = 2
+        bm[items[-1][0]] = 3
+        bm[items[-2][0]] = 4
+        self._test_merge(base, b1, b2, bm, 'merge update')
 
     def testFailMergeDelete(self):
         base, b1, b2, bm, e1, e2, items = self._setupConflict()
         del b1[items[0][0]]
         del b2[items[0][0]]
-        _test_merge(base, b1, b2, bm, 'merge conflicting delete',
-                   should_fail=1)
+        self._test_merge(base, b1, b2, bm, 'merge conflicting delete',
+                         should_fail=1)
 
     def testFailMergeUpdate(self):
         base, b1, b2, bm, e1, e2, items = self._setupConflict()
-        b1[items[0][0]]=1
-        b2[items[0][0]]=2
-        _test_merge(base, b1, b2, bm, 'merge conflicting update',
-                   should_fail=1)
+        b1[items[0][0]] = 1
+        b2[items[0][0]] = 2
+        self._test_merge(base, b1, b2, bm, 'merge conflicting update',
+                         should_fail=1)
 
     def testFailMergeDeleteAndUpdate(self):
         base, b1, b2, bm, e1, e2, items = self._setupConflict()
         del b1[items[0][0]]
-        b2[items[0][0]]=-9
-        _test_merge(base, b1, b2, bm, 'merge conflicting update and delete',
-                   should_fail=1)
+        b2[items[0][0]] = self.val_tx(-9)
+        self._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()
 
-        b1[-99999]=-99999
-        b1[e1[0][0]]=e1[0][1]
-        b2[99999]=99999
-        b2[e1[2][0]]=e1[2][1]
+        b1[self.key_tx(-99999)] = self.val_tx(-99999)
+        b1[e1[0][0]] = e1[0][1]
+        b2[99999] = 99999
+        b2[e1[2][0]] = e1[2][1]
 
-        bm[-99999]=-99999
-        bm[e1[0][0]]=e1[0][1]
-        bm[99999]=99999
-        bm[e1[2][0]]=e1[2][1]
-        _test_merge(base, b1, b2, bm, 'merge insert')
+        bm[self.key_tx(-99999)] = self.val_tx(-99999)
+        bm[e1[0][0]] = e1[0][1]
+        bm[99999] = 99999
+        bm[e1[2][0]] = e1[2][1]
+        self._test_merge(base, b1, b2, bm, 'merge insert',
+                         should_fail=not self.SUPPORTS_NEGATIVE_KEYS)
 
     def testMergeInsertsFromEmpty(self):
         base, b1, b2, bm, e1, e2, items = self._setupConflict()
@@ -2461,7 +2595,7 @@ class MappingConflictTestBase(ConflictTestBase):
         b2.update(e2)
         bm.update(e2)
 
-        _test_merge(base, b1, b2, bm, 'merge insert from empty')
+        self._test_merge(base, b1, b2, bm, 'merge insert from empty')
 
     def testFailMergeEmptyAndFill(self):
         base, b1, b2, bm, e1, e2, items = self._setupConflict()
@@ -2471,7 +2605,7 @@ class MappingConflictTestBase(ConflictTestBase):
         b2.update(e2)
         bm.update(e2)
 
-        _test_merge(base, b1, b2, bm, 'merge insert from empty', should_fail=1)
+        self._test_merge(base, b1, b2, bm, 'merge insert from empty', should_fail=1)
 
     def testMergeEmpty(self):
         base, b1, b2, bm, e1, e2, items = self._setupConflict()
@@ -2479,36 +2613,49 @@ class MappingConflictTestBase(ConflictTestBase):
         b1.clear()
         bm.clear()
 
-        _test_merge(base, b1, b2, bm, 'empty one and not other', should_fail=1)
+        self._test_merge(base, b1, b2, bm, 'empty one and not other', should_fail=1)
 
     def testFailMergeInsert(self):
         base, b1, b2, bm, e1, e2, items = self._setupConflict()
-        b1[-99999]=-99999
-        b1[e1[0][0]]=e1[0][1]
-        b2[99999]=99999
-        b2[e1[0][0]]=e1[0][1]
-        _test_merge(base, b1, b2, bm, 'merge conflicting inserts',
-                   should_fail=1)
+        b1[self.key_tx(-99999)] = self.val_tx(-99999)
+        b1[e1[0][0]] = e1[0][1]
+        b2[99999] = 99999
+        b2[e1[0][0]] = e1[0][1]
+        self._test_merge(base, b1, b2, bm, 'merge conflicting inserts',
+                         should_fail=1)
+
+class UnsignedMappingConflictTestBase(UnsignedMixin, MappingConflictTestBase):
+    pass
+
+class UnsignedValuesMappingConflictTestBase(UnsignedValuesMixin, MappingConflictTestBase):
+    pass
+
+class UnsignedKeysMappingConflictTestBase(UnsignedKeysMixin, MappingConflictTestBase):
+    pass
+
 
 class SetConflictTestBase(ConflictTestBase):
     "Set (as opposed to TreeSet) specific tests."
 
     def _setupConflict(self):
-        l=[ -5124, -7377, 2274, 8801, -9901, 7327, 1565, 17, -679,
+        l = [self.key_tx(x) for x in [
+            -5124, -7377, 2274, 8801, -9901, 7327, 1565, 17, -679,
             3686, -3607, 14, 6419, -5637, 6040, -4556, -8622, 3847, 7191,
-            -4067]
+            -4067]]
 
-        e1=[-1704, 5420, -239, 4024, -6984]
-        e2=[7745, 4868, -2548, -2711, -3154]
+        e1 = [self.key_tx(x) for x in
+              [-1704, 5420, -239, 4024, -6984]]
+        e2 = [self.key_tx(x) for x in
+              [7745, 4868, -2548, -2711, -3154]]
 
 
         base = self._makeOne()
         base.update(l)
-        b1=base.__class__(base)
-        b2=base.__class__(base)
-        bm=base.__class__(base)
+        b1 = base.__class__(base)
+        b2 = base.__class__(base)
+        bm = base.__class__(base)
 
-        items=base.keys()
+        items = base.keys()
 
         return  base, b1, b2, bm, e1, e2, items
 
@@ -2522,28 +2669,29 @@ class SetConflictTestBase(ConflictTestBase):
         bm.remove(items[5])
         bm.remove(items[-1])
         bm.remove(items[-2])
-        _test_merge(base, b1, b2, bm, 'merge  delete')
+        self._test_merge(base, b1, b2, bm, 'merge  delete')
 
     def testFailMergeDelete(self):
         base, b1, b2, bm, e1, e2, items = self._setupConflict()
         b1.remove(items[0])
         b2.remove(items[0])
-        _test_merge(base, b1, b2, bm, 'merge conflicting delete',
-                   should_fail=1)
+        self._test_merge(base, b1, b2, bm, 'merge conflicting delete',
+                         should_fail=1)
 
     def testMergeInserts(self):
         base, b1, b2, bm, e1, e2, items = self._setupConflict()
 
-        b1.insert(-99999)
+        b1.insert(self.key_tx(-99999))
         b1.insert(e1[0])
         b2.insert(99999)
         b2.insert(e1[2])
 
-        bm.insert(-99999)
+        bm.insert(self.key_tx(-99999))
         bm.insert(e1[0])
         bm.insert(99999)
         bm.insert(e1[2])
-        _test_merge(base, b1, b2, bm, 'merge insert')
+        self._test_merge(base, b1, b2, bm, 'merge insert',
+                         should_fail=not self.SUPPORTS_NEGATIVE_KEYS)
 
     def testMergeInsertsFromEmpty(self):
         base, b1, b2, bm, e1, e2, items = self._setupConflict()
@@ -2558,7 +2706,7 @@ class SetConflictTestBase(ConflictTestBase):
         b2.update(e2)
         bm.update(e2)
 
-        _test_merge(base, b1, b2, bm, 'merge insert from empty')
+        self._test_merge(base, b1, b2, bm, 'merge insert from empty')
 
     def testFailMergeEmptyAndFill(self):
         base, b1, b2, bm, e1, e2, items = self._setupConflict()
@@ -2568,7 +2716,7 @@ class SetConflictTestBase(ConflictTestBase):
         b2.update(e2)
         bm.update(e2)
 
-        _test_merge(base, b1, b2, bm, 'merge insert from empty', should_fail=1)
+        self._test_merge(base, b1, b2, bm, 'merge insert from empty', should_fail=1)
 
     def testMergeEmpty(self):
         base, b1, b2, bm, e1, e2, items = self._setupConflict()
@@ -2576,17 +2724,19 @@ class SetConflictTestBase(ConflictTestBase):
         b1.clear()
         bm.clear()
 
-        _test_merge(base, b1, b2, bm, 'empty one and not other', should_fail=1)
+        self._test_merge(base, b1, b2, bm, 'empty one and not other', should_fail=1)
 
     def testFailMergeInsert(self):
         base, b1, b2, bm, e1, e2, items = self._setupConflict()
-        b1.insert(-99999)
+        b1.insert(self.key_tx(-99999))
         b1.insert(e1[0])
         b2.insert(99999)
         b2.insert(e1[0])
-        _test_merge(base, b1, b2, bm, 'merge conflicting inserts',
-                   should_fail=1)
+        self._test_merge(base, b1, b2, bm, 'merge conflicting inserts',
+                         should_fail=1)
 
+class UnsignedSetConflictTestBase(UnsignedMixin, SetConflictTestBase):
+    pass
 
 ## utility functions
 
@@ -2597,7 +2747,7 @@ def lsubtract(l1, l2):
             list(filter(lambda x, l2=l2: x not in l2, l1)))
 
 def realseq(itemsob):
-    return [x for x in itemsob]
+    return list(itemsob)
 
 def permutations(x):
     # Return a list of all permutations of list x.

BTrees/tests/testBTrees.py

@@ -484,8 +484,8 @@ class FamilyTest(unittest.TestCase):
         self.assertTrue(BTrees.family64.minint in s)
         s = LOTreeSet()
         # XXX why oh why do we expect ValueError here, but TypeError in test32?
-        self.assertRaises(ValueError, s.insert, BTrees.family64.maxint + 1)
-        self.assertRaises(ValueError, s.insert, BTrees.family64.minint - 1)
+        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):

BTrees/tests/test_IUBTree.py

+##############################################################################
+#
+# Copyright (c) 2001-2012 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 .common import UnsignedValuesBTreeTests as BTreeTests
+from .common import ExtendedSetTests
+from .common import I_SetsBase
+from .common import InternalKeysMappingTest
+from .common import InternalKeysSetTest
+from .common import UnsignedValuesMappingBase as MappingBase
+from .common import UnsignedValuesMappingConflictTestBase as MappingConflictTestBase
+from .common import ModuleTest
+from .common import MultiUnion
+from .common import NormalSetTests
+from .common import SetConflictTestBase
+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 .common import UnsignedValuesMixin
+from .common import UnsignedError
+from BTrees.IUBTree import using64bits # XXX Ugly, but unavoidable
+
+# pylint:disable=no-name-in-module,arguments-differ
+
+class IUBTreeInternalKeyTest(InternalKeysMappingTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.IUBTree import IUBTree
+        return IUBTree
+
+
+class IUBTreePyInternalKeyTest(InternalKeysMappingTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.IUBTree import IUBTreePy
+        return IUBTreePy
+
+
+class IUTreeSetInternalKeyTest(InternalKeysSetTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.IUBTree import IUTreeSet
+        return IUTreeSet
+
+
+class IUTreeSetPyInternalKeyTest(InternalKeysSetTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.IUBTree import IUTreeSetPy
+        return IUTreeSetPy
+
+
+class IUBucketTest(MappingBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.IUBTree import IUBucket
+        return IUBucket
+
+
+class IUBucketPyTest(MappingBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.IUBTree import IUBucketPy
+        return IUBucketPy
+
+
+class IUTreeSetTest(NormalSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.IUBTree import IUTreeSet
+        return IUTreeSet
+
+
+class IUTreeSetPyTest(NormalSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.IUBTree import IUTreeSetPy
+        return IUTreeSetPy
+
+
+class IUSetTest(ExtendedSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.IUBTree import IUSet
+        return IUSet
+
+
+class IUSetPyTest(ExtendedSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.IUBTree import IUSetPy
+        return IUSetPy
+
+
+class _IUBTreeTestBase(BTreeTests):
+
+    def testIUBTreeOverflow(self):
+        good = set()
+        b = self._makeOne()
+
+        def trial(i):
+            i = int(i)
+            try:
+                b[i] = i
+            except UnsignedError:
+                pass
+            else:
+                good.add(i)
+                b[0] = i
+                self.assertEqual(b[0], i)
+
+        for i in range((1<<31) - 3, (1<<31) + 3):
+            trial(i)
+            trial(-i)
+
+        del b[0]
+        self.assertEqual(sorted(good), sorted(b))
+
+
+class IUBTreeTest(_IUBTreeTestBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.IUBTree import IUBTree
+        return IUBTree()
+
+
+class IUBTreeTestPy(_IUBTreeTestBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.IUBTree import IUBTreePy
+        return IUBTreePy()
+
+
+if using64bits:
+
+    class IUBTreeTest(BTreeTests, TestLongIntKeys, TestLongIntValues,
+                      unittest.TestCase):
+
+        def _makeOne(self):
+            from BTrees.IUBTree import IUBTree
+            return IUBTree()
+
+        def getTwoValues(self):
+            return 1, 2
+
+    class IUBTreeTest(BTreeTests, TestLongIntKeys, TestLongIntValues,
+                      unittest.TestCase):
+
+        def _makeOne(self):
+            from BTrees.IUBTree import IUBTreePy
+            return IUBTreePy()
+
+        def getTwoValues(self):
+            return 1, 2
+
+
+class _TestIUBTreesBase(object):
+
+    def testNonIntegerKeyRaises(self):
+        self.assertRaises(TypeError, self._stringraiseskey)
+        self.assertRaises(TypeError, self._floatraiseskey)
+        self.assertRaises(TypeError, self._noneraiseskey)
+
+    def testNonIntegerValueRaises(self):
+        self.assertRaises(TypeError, self._stringraisesvalue)
+        self.assertRaises(TypeError, self._floatraisesvalue)
+        self.assertRaises(TypeError, self._noneraisesvalue)
+
+    def _stringraiseskey(self):
+        self._makeOne()['c'] = 1
+
+    def _floatraiseskey(self):
+        self._makeOne()[2.5] = 1
+
+    def _noneraiseskey(self):
+        self._makeOne()[None] = 1
+
+    def _stringraisesvalue(self):
+        self._makeOne()[1] = 'c'
+
+    def _floatraisesvalue(self):
+        self._makeOne()[1] = 1.4
+
+    def _noneraisesvalue(self):
+        self._makeOne()[1] = None
+
+
+class TestIUBTrees(_TestIUBTreesBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.IUBTree import IUBTree
+        return IUBTree()
+
+
+class TestIUBTreesPy(_TestIUBTreesBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.IUBTree import IUBTreePy
+        return IUBTreePy()
+
+
+class TestIUSets(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.IUBTree import IUSet
+        return IUSet()
+
+
+class TestIUSetsPy(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.IUBTree import IUSetPy
+        return IUSetPy()
+
+
+class TestIUTreeSets(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.IUBTree import IUTreeSet
+        return IUTreeSet()
+
+
+class TestIUTreeSetsPy(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.IUBTree import IUTreeSetPy
+        return IUTreeSetPy()
+
+
+class PureIU(SetResult, unittest.TestCase):
+
+    def union(self, *args):
+        from BTrees.IUBTree import union
+        return union(*args)
+
+    def intersection(self, *args):
+        from BTrees.IUBTree import intersection
+        return intersection(*args)
+
+    def difference(self, *args):
+        from BTrees.IUBTree import difference
+        return difference(*args)
+
+    def builders(self):
+        from BTrees.IUBTree import IUBTree
+        from BTrees.IUBTree import IUBucket
+        from BTrees.IUBTree import IUTreeSet
+        from BTrees.IUBTree import IUSet
+        return IUSet, IUTreeSet, makeBuilder(IUBTree), makeBuilder(IUBucket)
+
+
+class PureIUPy(SetResult, unittest.TestCase):
+
+    def union(self, *args):
+        from BTrees.IUBTree import unionPy
+        return unionPy(*args)
+
+    def intersection(self, *args):
+        from BTrees.IUBTree import intersectionPy
+        return intersectionPy(*args)
+
+    def difference(self, *args):
+        from BTrees.IUBTree import differencePy
+        return differencePy(*args)
+
+    def builders(self):
+        from BTrees.IUBTree import IUBTreePy
+        from BTrees.IUBTree import IUBucketPy
+        from BTrees.IUBTree import IUTreeSetPy
+        from BTrees.IUBTree import IUSetPy
+        return (IUSetPy, IUTreeSetPy,
+                makeBuilder(IUBTreePy), makeBuilder(IUBucketPy))
+
+
+class TestIUMultiUnion(UnsignedValuesMixin, MultiUnion, unittest.TestCase):
+
+    def multiunion(self, *args):
+        from BTrees.IUBTree import multiunion
+        return multiunion(*args)
+
+    def union(self, *args):
+        from BTrees.IUBTree import union
+        return union(*args)
+
+    def mkset(self, *args):
+        from BTrees.IUBTree import IUSet as mkset
+        return mkset(*args)
+
+    def mktreeset(self, *args):
+        from BTrees.IUBTree import IUTreeSet as mktreeset
+        return mktreeset(*args)
+
+    def mkbucket(self, *args):
+        from BTrees.IUBTree import IUBucket as mkbucket
+        return mkbucket(*args)
+
+    def mkbtree(self, *args):
+        from BTrees.IUBTree import IUBTree as mkbtree
+        return mkbtree(*args)
+
+
+class TestIUMultiUnionPy(UnsignedValuesMixin, MultiUnion, unittest.TestCase):
+
+    def multiunion(self, *args):
+        from BTrees.IUBTree import multiunionPy
+        return multiunionPy(*args)
+
+    def union(self, *args):
+        from BTrees.IUBTree import unionPy
+        return unionPy(*args)
+
+    def mkset(self, *args):
+        from BTrees.IUBTree import IUSetPy as mkset
+        return mkset(*args)
+
+    def mktreeset(self, *args):
+        from BTrees.IUBTree import IUTreeSetPy as mktreeset
+        return mktreeset(*args)
+
+    def mkbucket(self, *args):
+        from BTrees.IUBTree import IUBucketPy as mkbucket
+        return mkbucket(*args)
+
+    def mkbtree(self, *args):
+        from BTrees.IUBTree import IUBTreePy as mkbtree
+        return mkbtree(*args)
+
+
+class TestWeightedIU(UnsignedValuesMixin, Weighted, unittest.TestCase):
+
+    def weightedUnion(self):
+        from BTrees.IUBTree import weightedUnion
+        return weightedUnion
+
+    def weightedIntersection(self):
+        from BTrees.IUBTree import weightedIntersection
+        return weightedIntersection
+
+    def union(self):
+        from BTrees.IUBTree import union
+        return union
+
+    def intersection(self):
+        from BTrees.IUBTree import intersection
+        return intersection
+
+    def mkbucket(self, *args):
+        from BTrees.IUBTree import IUBucket as mkbucket
+        return mkbucket(*args)
+
+    def builders(self):
+        from BTrees.IUBTree import IUBTree
+        from BTrees.IUBTree import IUBucket
+        from BTrees.IUBTree import IUTreeSet
+        from BTrees.IUBTree import IUSet
+        return IUBucket, IUBTree, itemsToSet(IUSet), itemsToSet(IUTreeSet)
+
+
+class TestWeightedIUPy(UnsignedValuesMixin, Weighted, unittest.TestCase):
+
+    def weightedUnion(self):
+        from BTrees.IUBTree import weightedUnionPy
+        return weightedUnionPy
+
+    def weightedIntersection(self):
+        from BTrees.IUBTree import weightedIntersectionPy
+        return weightedIntersectionPy
+
+    def union(self):
+        from BTrees.IUBTree import unionPy
+        return unionPy
+
+    def intersection(self):
+        from BTrees.IUBTree import intersectionPy
+        return intersectionPy
+
+    def mkbucket(self, *args):
+        from BTrees.IUBTree import IUBucketPy as mkbucket
+        return mkbucket(*args)
+
+    def builders(self):
+        from BTrees.IUBTree import IUBTreePy
+        from BTrees.IUBTree import IUBucketPy
+        from BTrees.IUBTree import IUTreeSetPy
+        from BTrees.IUBTree import IUSetPy
+        return (IUBucketPy, IUBTreePy,
+                itemsToSet(IUSetPy), itemsToSet(IUTreeSetPy))
+
+
+class IUBTreeConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.IUBTree import IUBTree
+        return IUBTree
+
+
+class IUBTreeConflictTestsPy(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.IUBTree import IUBTreePy
+        return IUBTreePy
+
+
+class IUBucketConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.IUBTree import IUBucket
+        return IUBucket
+
+
+class IUBucketConflictTestsPy(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.IUBTree import IUBucketPy
+        return IUBucketPy
+
+
+class IUTreeSetConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.IUBTree import IUTreeSet
+        return IUTreeSet
+
+
+class IUTreeSetConflictTestsPy(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.IUBTree import IUTreeSetPy
+        return IUTreeSetPy
+
+
+class IUSetConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.IUBTree import IUSet
+        return IUSet
+
+
+class IUSetConflictTestsPy(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.IUBTree import IUSetPy
+        return IUSetPy
+
+
+class IUModuleTest(ModuleTest, unittest.TestCase):
+
+    prefix = 'IU'
+
+    def _getModule(self):
+        import BTrees
+        return BTrees.IUBTree
+    def _getInterface(self):
+        import BTrees.Interfaces
+        return BTrees.Interfaces.IIntegerUnsignedBTreeModule
+
+
+
+def test_suite():
+    return unittest.TestSuite((
+        unittest.makeSuite(IUBTreeInternalKeyTest),
+        unittest.makeSuite(IUBTreePyInternalKeyTest),
+        unittest.makeSuite(IUTreeSetInternalKeyTest),
+        unittest.makeSuite(IUTreeSetPyInternalKeyTest),
+        unittest.makeSuite(IUBucketTest),
+        unittest.makeSuite(IUBucketPyTest),
+        unittest.makeSuite(IUTreeSetTest),
+        unittest.makeSuite(IUTreeSetPyTest),
+        unittest.makeSuite(IUSetTest),
+        unittest.makeSuite(IUSetPyTest),
+        unittest.makeSuite(IUBTreeTest),
+        unittest.makeSuite(IUBTreeTestPy),
+        unittest.makeSuite(TestIUBTrees),
+        unittest.makeSuite(TestIUBTreesPy),
+        unittest.makeSuite(TestIUSets),
+        unittest.makeSuite(TestIUSetsPy),
+        unittest.makeSuite(TestIUTreeSets),
+        unittest.makeSuite(TestIUTreeSetsPy),
+        unittest.makeSuite(TestIUMultiUnion),
+        unittest.makeSuite(TestIUMultiUnionPy),
+        unittest.makeSuite(PureIU),
+        unittest.makeSuite(PureIUPy),
+        unittest.makeSuite(TestWeightedIU),
+        unittest.makeSuite(TestWeightedIUPy),
+        unittest.makeSuite(IUBTreeConflictTests),
+        unittest.makeSuite(IUBTreeConflictTestsPy),
+        unittest.makeSuite(IUBucketConflictTests),
+        unittest.makeSuite(IUBucketConflictTestsPy),
+        unittest.makeSuite(IUTreeSetConflictTests),
+        unittest.makeSuite(IUTreeSetConflictTestsPy),
+        unittest.makeSuite(IUSetConflictTests),
+        unittest.makeSuite(IUSetConflictTestsPy),
+        unittest.makeSuite(IUModuleTest),
+    ))

BTrees/tests/test_LQBTree.py

+##############################################################################
+#
+# Copyright (c) 2001-2012 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 .common import UnsignedValuesBTreeTests as BTreeTests
+from .common import ExtendedSetTests
+from .common import I_SetsBase
+from .common import InternalKeysMappingTest
+from .common import InternalKeysSetTest
+from .common import UnsignedValuesMappingBase as MappingBase
+from .common import UnsignedValuesMappingConflictTestBase as MappingConflictTestBase
+from .common import ModuleTest
+from .common import MultiUnion
+from .common import NormalSetTests
+from .common import SetConflictTestBase
+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 .common import UnsignedValuesMixin
+
+# pylint:disable=no-name-in-module,arguments-differ
+
+class LQBTreeInternalKeyTest(InternalKeysMappingTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.LQBTree import LQBTree
+        return LQBTree
+
+
+class LQBTreePyInternalKeyTest(InternalKeysMappingTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.LQBTree import LQBTreePy
+        return LQBTreePy
+
+
+class LQTreeSetInternalKeyTest(InternalKeysSetTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.LQBTree import LQTreeSet
+        return LQTreeSet
+
+
+class LQTreeSetPyInternalKeyTest(InternalKeysSetTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.LQBTree import LQTreeSetPy
+        return LQTreeSetPy
+
+
+class LQBucketTest(MappingBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.LQBTree import LQBucket
+        return LQBucket
+
+
+class LQBucketTestPy(MappingBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.LQBTree import LQBucketPy
+        return LQBucketPy
+
+
+class LQTreeSetTest(NormalSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.LQBTree import LQTreeSet
+        return LQTreeSet
+
+
+class LQTreeSetTestPy(NormalSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.LQBTree import LQTreeSetPy
+        return LQTreeSetPy
+
+
+class LQSetTest(ExtendedSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.LQBTree import LQSet
+        return LQSet
+
+
+class LQSetTestPy(ExtendedSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.LQBTree import LQSetPy
+        return LQSetPy
+
+
+class LQBTreeTest(BTreeTests, TestLongIntKeys, TestLongIntValues,
+                  unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.LQBTree import LQBTree
+        return LQBTree()
+    def getTwoValues(self):
+        return 1, 2
+
+
+class LQBTreeTestPy(BTreeTests, TestLongIntKeys, TestLongIntValues,
+                    unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.LQBTree import LQBTreePy
+        return LQBTreePy()
+    def getTwoValues(self):
+        return 1, 2
+
+
+class TestLQSets(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.LQBTree import LQSet
+        return LQSet()
+
+
+class TestLQSetsPy(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.LQBTree import LQSetPy
+        return LQSetPy()
+
+
+class TestLQTreeSets(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.LQBTree import LQTreeSet
+        return LQTreeSet()
+
+
+class TestLQTreeSetsPy(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.LQBTree import LQTreeSetPy
+        return LQTreeSetPy()
+
+
+class PureLQ(SetResult, unittest.TestCase):
+
+    def union(self, *args):
+        from BTrees.LQBTree import union
+        return union(*args)
+
+    def intersection(self, *args):
+        from BTrees.LQBTree import intersection
+        return intersection(*args)
+
+    def difference(self, *args):
+        from BTrees.LQBTree import difference
+        return difference(*args)
+
+    def builders(self):
+        from BTrees.LQBTree import LQBTree
+        from BTrees.LQBTree import LQBucket
+        from BTrees.LQBTree import LQTreeSet
+        from BTrees.LQBTree import LQSet
+        return LQSet, LQTreeSet, makeBuilder(LQBTree), makeBuilder(LQBucket)
+
+
+class PureLQPy(SetResult, unittest.TestCase):
+
+    def union(self, *args):
+        from BTrees.LQBTree import unionPy
+        return unionPy(*args)
+
+    def intersection(self, *args):
+        from BTrees.LQBTree import intersectionPy
+        return intersectionPy(*args)
+
+    def difference(self, *args):
+        from BTrees.LQBTree import differencePy
+        return differencePy(*args)
+
+    def builders(self):
+        from BTrees.LQBTree import LQBTreePy
+        from BTrees.LQBTree import LQBucketPy
+        from BTrees.LQBTree import LQTreeSetPy
+        from BTrees.LQBTree import LQSetPy
+        return (LQSetPy, LQTreeSetPy,
+                makeBuilder(LQBTreePy), makeBuilder(LQBucketPy))
+
+
+class TestLQMultiUnion(MultiUnion, unittest.TestCase):
+
+    def multiunion(self, *args):
+        from BTrees.LQBTree import multiunion
+        return multiunion(*args)
+
+    def union(self, *args):
+        from BTrees.LQBTree import union
+        return union(*args)
+
+    def mkset(self, *args):
+        from BTrees.LQBTree import LQSet as mkset
+        return mkset(*args)
+
+    def mktreeset(self, *args):
+        from BTrees.LQBTree import LQTreeSet as mktreeset
+        return mktreeset(*args)
+
+    def mkbucket(self, *args):
+        from BTrees.LQBTree import LQBucket as mkbucket
+        return mkbucket(*args)
+
+    def mkbtree(self, *args):
+        from BTrees.LQBTree import LQBTree as mkbtree
+        return mkbtree(*args)
+
+
+class TestLQMultiUnionPy(MultiUnion, unittest.TestCase):
+
+    def multiunion(self, *args):
+        from BTrees.LQBTree import multiunionPy
+        return multiunionPy(*args)
+
+    def union(self, *args):
+        from BTrees.LQBTree import unionPy
+        return unionPy(*args)
+
+    def mkset(self, *args):
+        from BTrees.LQBTree import LQSetPy as mkset
+        return mkset(*args)
+
+    def mktreeset(self, *args):
+        from BTrees.LQBTree import LQTreeSetPy as mktreeset
+        return mktreeset(*args)
+
+    def mkbucket(self, *args):
+        from BTrees.LQBTree import LQBucketPy as mkbucket
+        return mkbucket(*args)
+
+    def mkbtree(self, *args):
+        from BTrees.LQBTree import LQBTreePy as mkbtree
+        return mkbtree(*args)
+
+
+class TestWeightedLQ(UnsignedValuesMixin, Weighted, unittest.TestCase):
+
+    def weightedUnion(self):
+        from BTrees.LQBTree import weightedUnion
+        return weightedUnion
+
+    def weightedIntersection(self):
+        from BTrees.LQBTree import weightedIntersection
+        return weightedIntersection
+
+    def union(self):
+        from BTrees.LQBTree import union
+        return union
+
+    def intersection(self):
+        from BTrees.LQBTree import intersection
+        return intersection
+
+    def mkbucket(self, *args):
+        from BTrees.LQBTree import LQBucket as mkbucket
+        return mkbucket(*args)
+
+    def builders(self):
+        from BTrees.LQBTree import LQBTree
+        from BTrees.LQBTree import LQBucket
+        from BTrees.LQBTree import LQTreeSet
+        from BTrees.LQBTree import LQSet
+        return LQBucket, LQBTree, itemsToSet(LQSet), itemsToSet(LQTreeSet)
+
+
+class TestWeightedLQPy(UnsignedValuesMixin, Weighted, unittest.TestCase):
+
+    def weightedUnion(self):
+        from BTrees.LQBTree import weightedUnionPy
+        return weightedUnionPy
+
+    def weightedIntersection(self):
+        from BTrees.LQBTree import weightedIntersectionPy
+        return weightedIntersectionPy
+
+    def union(self):
+        from BTrees.LQBTree import unionPy
+        return unionPy
+
+    def intersection(self):
+        from BTrees.LQBTree import intersectionPy
+        return intersectionPy
+
+    def mkbucket(self, *args):
+        from BTrees.LQBTree import LQBucketPy as mkbucket
+        return mkbucket(*args)
+
+    def builders(self):
+        from BTrees.LQBTree import LQBTreePy
+        from BTrees.LQBTree import LQBucketPy
+        from BTrees.LQBTree import LQTreeSetPy
+        from BTrees.LQBTree import LQSetPy
+        return (LQBucketPy, LQBTreePy,
+                itemsToSet(LQSetPy), itemsToSet(LQTreeSetPy))
+
+
+class LQBTreeConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.LQBTree import LQBTree
+        return LQBTree
+
+
+class LQBTreeConflictTestsPy(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.LQBTree import LQBTreePy
+        return LQBTreePy
+
+
+class LQBucketConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.LQBTree import LQBucket
+        return LQBucket
+
+
+class LQBucketConflictTestsPy(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.LQBTree import LQBucketPy
+        return LQBucketPy
+
+
+class LQTreeSetConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.LQBTree import LQTreeSet
+        return LQTreeSet
+
+
+class LQTreeSetConflictTestsPy(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.LQBTree import LQTreeSetPy
+        return LQTreeSetPy
+
+
+class LQSetConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.LQBTree import LQSet
+        return LQSet
+
+
+class LQSetConflictTestsPy(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.LQBTree import LQSetPy
+        return LQSetPy
+
+
+class LQModuleTest(ModuleTest, unittest.TestCase):
+
+    prefix = 'LQ'
+
+    def _getModule(self):
+        import BTrees
+        return BTrees.LQBTree
+
+    def _getInterface(self):
+        import BTrees.Interfaces
+        return BTrees.Interfaces.IIntegerUnsignedBTreeModule
+
+
+def test_suite():
+    return unittest.TestSuite((
+        unittest.makeSuite(LQBTreeInternalKeyTest),
+        unittest.makeSuite(LQBTreeInternalKeyTest),
+        unittest.makeSuite(LQTreeSetInternalKeyTest),
+        unittest.makeSuite(LQTreeSetInternalKeyTest),
+        unittest.makeSuite(LQBucketTest),
+        unittest.makeSuite(LQBucketTest),
+        unittest.makeSuite(LQTreeSetTest),
+        unittest.makeSuite(LQTreeSetTest),
+        unittest.makeSuite(LQSetTest),
+        unittest.makeSuite(LQSetTest),
+        unittest.makeSuite(LQBTreeTest),
+        unittest.makeSuite(LQBTreeTest),
+        unittest.makeSuite(TestLQSets),
+        unittest.makeSuite(TestLQSets),
+        unittest.makeSuite(TestLQTreeSets),
+        unittest.makeSuite(TestLQTreeSets),
+        unittest.makeSuite(TestLQMultiUnion),
+        unittest.makeSuite(TestLQMultiUnion),
+        unittest.makeSuite(PureLQ),
+        unittest.makeSuite(PureLQ),
+        unittest.makeSuite(TestWeightedLQ),
+        unittest.makeSuite(TestWeightedLQ),
+        unittest.makeSuite(LQBTreeConflictTests),
+        unittest.makeSuite(LQBTreeConflictTests),
+        unittest.makeSuite(LQBucketConflictTests),
+        unittest.makeSuite(LQBucketConflictTests),
+        unittest.makeSuite(LQTreeSetConflictTests),
+        unittest.makeSuite(LQTreeSetConflictTests),
+        unittest.makeSuite(LQSetConflictTests),
+        unittest.makeSuite(LQSetConflictTests),
+        unittest.makeSuite(LQModuleTest),
+    ))

BTrees/tests/test_OQBTree.py

+##############################################################################
+#
+# Copyright (c) 2001-2012 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 .common import UnsignedValuesBTreeTests as BTreeTests
+from .common import ExtendedSetTests
+from .common import InternalKeysMappingTest
+from .common import InternalKeysSetTest
+from .common import UnsignedValuesMappingBase as MappingBase
+from .common import UnsignedValuesMappingConflictTestBase as MappingConflictTestBase
+from .common import ModuleTest
+from .common import NormalSetTests
+from .common import SetConflictTestBase
+from .common import SetResult
+from .common import TestLongIntValues
+from .common import Weighted
+from .common import itemsToSet
+from .common import makeBuilder
+from .common import _skip_on_32_bits
+from .common import UnsignedValuesMixin
+
+# pylint:disable=no-name-in-module,arguments-differ
+
+class OQBTreeInternalKeyTest(InternalKeysMappingTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OQBTree import OQBTree
+        return OQBTree
+
+
+class OQBTreePyInternalKeyTest(InternalKeysMappingTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OQBTree import OQBTreePy
+        return OQBTreePy
+
+
+class OQTreeSetInternalKeyTest(InternalKeysSetTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OQBTree import OQTreeSet
+        return OQTreeSet
+
+
+class OQTreeSetPyInternalKeyTest(InternalKeysSetTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OQBTree import OQTreeSetPy
+        return OQTreeSetPy
+
+
+class OQBucketTest(MappingBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OQBTree import OQBucket
+        return OQBucket
+
+
+class OQBucketPyTest(MappingBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OQBTree import OQBucketPy
+        return OQBucketPy
+
+
+class OQTreeSetTest(NormalSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OQBTree import OQTreeSet
+        return OQTreeSet
+
+
+class OQTreeSetPyTest(NormalSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OQBTree import OQTreeSetPy
+        return OQTreeSetPy
+
+
+class OQSetTest(ExtendedSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OQBTree import OQSet
+        return OQSet
+
+
+class OQSetPyTest(ExtendedSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OQBTree import OQSetPy
+        return OQSetPy
+
+
+class OQBTreeTest(BTreeTests, TestLongIntValues, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.OQBTree import OQBTree
+        return OQBTree()
+
+    def getTwoKeys(self):
+        return "abc", "def"
+
+    @_skip_on_32_bits
+    def test_extremes(self):
+        from BTrees.tests.common import SMALLEST_POSITIVE_65_BITS
+        from BTrees.tests.common import LARGEST_64_BITS
+        from BTrees.tests.common import LARGEST_NEGATIVE_65_BITS
+        btree = self._makeOne()
+        btree['ZERO'] = 0
+        btree['SMALLEST_64_BITS'] = 0
+        btree['LARGEST_64_BITS'] = LARGEST_64_BITS
+        btree['SMALLEST_POSITIVE_65_BITS'] = SMALLEST_POSITIVE_65_BITS
+        with self.assertRaises((ValueError, OverflowError)):
+            btree['TOO_BIG'] = 2**65
+
+        self.assertRaises((ValueError, OverflowError), btree.__setitem__,
+                          'LARGEST_NEGATIVE_65_BITS', LARGEST_NEGATIVE_65_BITS)
+
+
+class OQBTreePyTest(BTreeTests, TestLongIntValues, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.OQBTree import OQBTreePy
+        return OQBTreePy()
+
+    def getTwoKeys(self):
+        return "abc", "def"
+
+
+class PureOQ(SetResult, unittest.TestCase):
+
+    def union(self, *args):
+        from BTrees.OQBTree import union
+        return union(*args)
+
+    def intersection(self, *args):
+        from BTrees.OQBTree import intersection
+        return intersection(*args)
+
+    def difference(self, *args):
+        from BTrees.OQBTree import difference
+        return difference(*args)
+
+    def builders(self):
+        from BTrees.OQBTree import OQBTree
+        from BTrees.OQBTree import OQBucket
+        from BTrees.OQBTree import OQTreeSet
+        from BTrees.OQBTree import OQSet
+        return OQSet, OQTreeSet, makeBuilder(OQBTree), makeBuilder(OQBucket)
+
+
+class PureOQPy(SetResult, unittest.TestCase):
+
+    def union(self, *args):
+        from BTrees.OQBTree import unionPy
+        return unionPy(*args)
+
+    def intersection(self, *args):
+        from BTrees.OQBTree import intersectionPy
+        return intersectionPy(*args)
+
+    def difference(self, *args):
+        from BTrees.OQBTree import differencePy
+        return differencePy(*args)
+
+    def builders(self):
+        from BTrees.OQBTree import OQBTreePy
+        from BTrees.OQBTree import OQBucketPy
+        from BTrees.OQBTree import OQTreeSetPy
+        from BTrees.OQBTree import OQSetPy
+        return (OQSetPy, OQTreeSetPy,
+                makeBuilder(OQBTreePy), makeBuilder(OQBucketPy))
+
+
+class TestWeightedOQ(UnsignedValuesMixin, Weighted, unittest.TestCase):
+
+    def weightedUnion(self):
+        from BTrees.OQBTree import weightedUnion
+        return weightedUnion
+
+    def weightedIntersection(self):
+        from BTrees.OQBTree import weightedIntersection
+        return weightedIntersection
+
+    def union(self):
+        from BTrees.OQBTree import union
+        return union
+
+    def intersection(self):
+        from BTrees.OQBTree import intersection
+        return intersection
+
+    def mkbucket(self, *args):
+        from BTrees.OQBTree import OQBucket as mkbucket
+        return mkbucket(*args)
+
+    def builders(self):
+        from BTrees.OQBTree import OQBTree
+        from BTrees.OQBTree import OQBucket
+        from BTrees.OQBTree import OQTreeSet
+        from BTrees.OQBTree import OQSet
+        return OQBucket, OQBTree, itemsToSet(OQSet), itemsToSet(OQTreeSet)
+
+
+class TestWeightedOQPy(Weighted, unittest.TestCase):
+
+    def weightedUnion(self):
+        from BTrees.OQBTree import weightedUnionPy
+        return weightedUnionPy
+
+    def weightedIntersection(self):
+        from BTrees.OQBTree import weightedIntersectionPy
+        return weightedIntersectionPy
+
+    def union(self):
+        from BTrees.OQBTree import unionPy
+        return unionPy
+
+    def intersection(self):
+        from BTrees.OQBTree import intersectionPy
+        return intersectionPy
+
+    def mkbucket(self, *args):
+        from BTrees.OQBTree import OQBucketPy as mkbucket
+        return mkbucket(*args)
+
+    def builders(self):
+        from BTrees.OQBTree import OQBTreePy
+        from BTrees.OQBTree import OQBucketPy
+        from BTrees.OQBTree import OQTreeSetPy
+        from BTrees.OQBTree import OQSetPy
+        return (OQBucketPy, OQBTreePy,
+                itemsToSet(OQSetPy), itemsToSet(OQTreeSetPy))
+
+
+class OQBucketConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OQBTree import OQBucket
+        return OQBucket
+
+
+class OQBucketPyConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OQBTree import OQBucketPy
+        return OQBucketPy
+
+
+class OQSetConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OQBTree import OQSet
+        return OQSet
+
+
+class OQSetPyConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OQBTree import OQSetPy
+        return OQSetPy
+
+
+class OQBTreeConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OQBTree import OQBTree
+        return OQBTree
+
+
+class OQBTreePyConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OQBTree import OQBTreePy
+        return OQBTreePy
+
+
+class OQTreeSetConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OQBTree import OQTreeSet
+        return OQTreeSet
+
+
+class OQTreeSetPyConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OQBTree import OQTreeSetPy
+        return OQTreeSetPy
+
+
+class OQModuleTest(ModuleTest, unittest.TestCase):
+
+    prefix = 'OQ'
+
+    def _getModule(self):
+        import BTrees
+        return BTrees.OQBTree
+
+    def _getInterface(self):
+        import BTrees.Interfaces
+        return BTrees.Interfaces.IObjectUnsignedBTreeModule
+
+    def test_multiunion_not_present(self):
+        try:
+            from BTrees.OQBTree import multiunion
+        except ImportError:
+            pass
+        else:
+            self.fail("OQBTree shouldn't have multiunion")
+
+
+def test_suite():
+    return unittest.TestSuite((
+        unittest.makeSuite(OQBTreeInternalKeyTest),
+        unittest.makeSuite(OQBTreePyInternalKeyTest),
+        unittest.makeSuite(OQTreeSetInternalKeyTest),
+        unittest.makeSuite(OQTreeSetPyInternalKeyTest),
+        unittest.makeSuite(OQBucketTest),
+        unittest.makeSuite(OQBucketPyTest),
+        unittest.makeSuite(OQTreeSetTest),
+        unittest.makeSuite(OQTreeSetPyTest),
+        unittest.makeSuite(OQSetTest),
+        unittest.makeSuite(OQSetPyTest),
+        unittest.makeSuite(OQBTreeTest),
+        unittest.makeSuite(OQBTreePyTest),
+        unittest.makeSuite(PureOQ),
+        unittest.makeSuite(PureOQPy),
+        unittest.makeSuite(TestWeightedOQ),
+        unittest.makeSuite(TestWeightedOQPy),
+        unittest.makeSuite(OQBucketConflictTests),
+        unittest.makeSuite(OQBucketPyConflictTests),
+        unittest.makeSuite(OQSetConflictTests),
+        unittest.makeSuite(OQSetPyConflictTests),
+        unittest.makeSuite(OQBTreeConflictTests),
+        unittest.makeSuite(OQBTreePyConflictTests),
+        unittest.makeSuite(OQTreeSetConflictTests),
+        unittest.makeSuite(OQTreeSetPyConflictTests),
+        unittest.makeSuite(OQModuleTest),
+    ))

BTrees/tests/test_OUBTree.py

+##############################################################################
+#
+# Copyright (c) 2001-2012 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 .common import UnsignedValuesBTreeTests as BTreeTests
+from .common import ExtendedSetTests
+from .common import InternalKeysMappingTest
+from .common import InternalKeysSetTest
+from .common import UnsignedValuesMappingBase as MappingBase
+from .common import UnsignedValuesMappingConflictTestBase as MappingConflictTestBase
+from .common import ModuleTest
+from .common import NormalSetTests
+from .common import SetConflictTestBase
+from .common import SetResult
+from .common import TestLongIntValues
+from .common import TypeTest
+from .common import Weighted
+from .common import itemsToSet
+from .common import makeBuilder
+from .common import UnsignedValuesMixin
+from BTrees.IIBTree import using64bits #XXX Ugly, but necessary
+
+
+class OUBTreeInternalKeyTest(InternalKeysMappingTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OUBTree import OUBTree
+        return OUBTree
+
+
+class OUBTreePyInternalKeyTest(InternalKeysMappingTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OUBTree import OUBTreePy
+        return OUBTreePy
+
+
+class OUTreeSetInternalKeyTest(InternalKeysSetTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OUBTree import OUTreeSet
+        return OUTreeSet
+
+
+class OUTreeSetPyInternalKeyTest(InternalKeysSetTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OUBTree import OUTreeSetPy
+        return OUTreeSetPy
+
+
+class OUBucketTest(MappingBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OUBTree import OUBucket
+        return OUBucket
+
+
+class OUBucketPyTest(MappingBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OUBTree import OUBucketPy
+        return OUBucketPy
+
+
+class OUTreeSetTest(NormalSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OUBTree import OUTreeSet
+        return OUTreeSet
+
+
+class OUTreeSetPyTest(NormalSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OUBTree import OUTreeSetPy
+        return OUTreeSetPy
+
+
+class OUSetTest(ExtendedSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OUBTree import OUSet
+        return OUSet
+
+
+class OUSetPyTest(ExtendedSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OUBTree import OUSetPy
+        return OUSetPy
+
+
+class OUBTreeTest(BTreeTests, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.OUBTree import OUBTree
+        return OUBTree()
+
+
+class OUBTreePyTest(BTreeTests, unittest.TestCase):
+    def _makeOne(self):
+        from BTrees.OUBTree import OUBTreePy
+        return OUBTreePy()
+
+
+if using64bits:
+
+    class OUBTreeTest(BTreeTests, TestLongIntValues, unittest.TestCase):
+        def _makeOne(self):
+            from BTrees.OUBTree import OUBTree
+            return OUBTree()
+        def getTwoKeys(self):
+            return object(), object()
+
+    class OUBTreePyTest(BTreeTests, TestLongIntValues, unittest.TestCase):
+        def _makeOne(self):
+            from BTrees.OUBTree import OUBTreePy
+            return OUBTreePy()
+        def getTwoKeys(self):
+            return object(), object()
+
+
+class _TestOUBTreesBase(TypeTest):
+
+    def _stringraises(self):
+        self._makeOne()[1] = 'c'
+
+    def _floatraises(self):
+        self._makeOne()[1] = 1.4
+
+    def _noneraises(self):
+        self._makeOne()[1] = None
+
+    def testEmptyFirstBucketReportedByGuido(self):
+        from .._compat import xrange
+        b = self._makeOne()
+        for i in xrange(29972): # reduce to 29971 and it works
+            b[i] = i
+        for i in xrange(30): # reduce to 29 and it works
+            del b[i]
+            b[i+40000] = i
+
+        self.assertEqual(b.keys()[0], 30)
+
+
+class TestOUBTrees(_TestOUBTreesBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.OUBTree import OUBTree
+        return OUBTree()
+
+
+class TestOUBTreesPy(_TestOUBTreesBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.OUBTree import OUBTreePy
+        return OUBTreePy()
+
+
+class PureOU(SetResult, unittest.TestCase):
+
+    def union(self, *args):
+        from BTrees.OUBTree import union
+        return union(*args)
+
+    def intersection(self, *args):
+        from BTrees.OUBTree import intersection
+        return intersection(*args)
+
+    def difference(self, *args):
+        from BTrees.OUBTree import difference
+        return difference(*args)
+
+    def builders(self):
+        from BTrees.OUBTree import OUBTree
+        from BTrees.OUBTree import OUBucket
+        from BTrees.OUBTree import OUTreeSet
+        from BTrees.OUBTree import OUSet
+        return OUSet, OUTreeSet, makeBuilder(OUBTree), makeBuilder(OUBucket)
+
+
+class PureOUPy(SetResult, unittest.TestCase):
+
+    def union(self, *args):
+        from BTrees.OUBTree import unionPy
+        return unionPy(*args)
+
+    def intersection(self, *args):
+        from BTrees.OUBTree import intersectionPy
+        return intersectionPy(*args)
+
+    def difference(self, *args):
+        from BTrees.OUBTree import differencePy
+        return differencePy(*args)
+
+    def builders(self):
+        from BTrees.OUBTree import OUBTreePy
+        from BTrees.OUBTree import OUBucketPy
+        from BTrees.OUBTree import OUTreeSetPy
+        from BTrees.OUBTree import OUSetPy
+        return (OUSetPy, OUTreeSetPy,
+                makeBuilder(OUBTreePy), makeBuilder(OUBucketPy))
+
+
+class TestWeightedOU(UnsignedValuesMixin, Weighted, unittest.TestCase):
+
+    def weightedUnion(self):
+        from BTrees.OUBTree import weightedUnion
+        return weightedUnion
+
+    def weightedIntersection(self):
+        from BTrees.OUBTree import weightedIntersection
+        return weightedIntersection
+
+    def union(self):
+        from BTrees.OUBTree import union
+        return union
+
+    def intersection(self):
+        from BTrees.OUBTree import intersection
+        return intersection
+
+    def mkbucket(self, *args):
+        from BTrees.OUBTree import OUBucket as mkbucket
+        return mkbucket(*args)
+
+    def builders(self):
+        from BTrees.OUBTree import OUBTree
+        from BTrees.OUBTree import OUBucket
+        from BTrees.OUBTree import OUTreeSet
+        from BTrees.OUBTree import OUSet
+        return OUBucket, OUBTree, itemsToSet(OUSet), itemsToSet(OUTreeSet)
+
+
+class TestWeightedOUPy(Weighted, unittest.TestCase):
+
+    def weightedUnion(self):
+        from BTrees.OUBTree import weightedUnionPy
+        return weightedUnionPy
+
+    def weightedIntersection(self):
+        from BTrees.OUBTree import weightedIntersectionPy
+        return weightedIntersectionPy
+
+    def union(self):
+        from BTrees.OUBTree import unionPy
+        return unionPy
+
+    def intersection(self):
+        from BTrees.OUBTree import intersectionPy
+        return intersectionPy
+
+    def mkbucket(self, *args):
+        from BTrees.OUBTree import OUBucketPy as mkbucket
+        return mkbucket(*args)
+
+    def builders(self):
+        from BTrees.OUBTree import OUBTreePy
+        from BTrees.OUBTree import OUBucketPy
+        from BTrees.OUBTree import OUTreeSetPy
+        from BTrees.OUBTree import OUSetPy
+        return (OUBucketPy, OUBTreePy,
+                itemsToSet(OUSetPy), itemsToSet(OUTreeSetPy))
+
+
+class OUBucketConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OUBTree import OUBucket
+        return OUBucket
+
+
+class OUBucketConflictTestsPy(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OUBTree import OUBucketPy
+        return OUBucketPy
+
+
+class OUSetConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OUBTree import OUSet
+        return OUSet
+
+
+class OUSetConflictTestsPy(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OUBTree import OUSetPy
+        return OUSetPy
+
+
+class OUBTreeConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OUBTree import OUBTree
+        return OUBTree
+
+
+class OUBTreeConflictTestsPy(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OUBTree import OUBTreePy
+        return OUBTreePy
+
+
+class OUTreeSetConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OUBTree import OUTreeSet
+        return OUTreeSet
+
+
+class OUTreeSetConflictTestsPy(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.OUBTree import OUTreeSetPy
+        return OUTreeSetPy
+
+
+class OUModuleTest(ModuleTest, unittest.TestCase):
+
+    prefix = 'OU'
+
+    def _getModule(self):
+        import BTrees
+        return BTrees.OUBTree
+
+    def _getInterface(self):
+        import BTrees.Interfaces
+        return BTrees.Interfaces.IObjectUnsignedBTreeModule
+
+    def test_multiunion_not_present(self):
+        try:
+            from BTrees.OUBTree import multiunion
+        except ImportError:
+            pass
+        else:
+            self.fail("OUBTree shouldn't have multiunion")
+
+
+def test_suite():
+    return unittest.TestSuite((
+        unittest.makeSuite(OUBTreeInternalKeyTest),
+        unittest.makeSuite(OUBTreePyInternalKeyTest),
+        unittest.makeSuite(OUTreeSetInternalKeyTest),
+        unittest.makeSuite(OUTreeSetPyInternalKeyTest),
+        unittest.makeSuite(OUBucketTest),
+        unittest.makeSuite(OUBucketPyTest),
+        unittest.makeSuite(OUTreeSetTest),
+        unittest.makeSuite(OUTreeSetPyTest),
+        unittest.makeSuite(OUSetTest),
+        unittest.makeSuite(OUSetPyTest),
+        unittest.makeSuite(OUBTreeTest),
+        unittest.makeSuite(OUBTreePyTest),
+        unittest.makeSuite(TestOUBTrees),
+        unittest.makeSuite(TestOUBTreesPy),
+        unittest.makeSuite(PureOU),
+        unittest.makeSuite(PureOUPy),
+        unittest.makeSuite(TestWeightedOU),
+        unittest.makeSuite(TestWeightedOUPy),
+        unittest.makeSuite(OUBucketConflictTests),
+        unittest.makeSuite(OUBucketConflictTestsPy),
+        unittest.makeSuite(OUSetConflictTests),
+        unittest.makeSuite(OUSetConflictTestsPy),
+        unittest.makeSuite(OUBTreeConflictTests),
+        unittest.makeSuite(OUBTreeConflictTestsPy),
+        unittest.makeSuite(OUTreeSetConflictTests),
+        unittest.makeSuite(OUTreeSetConflictTestsPy),
+        unittest.makeSuite(OUModuleTest),
+    ))

BTrees/tests/test_QFBTree.py

+##############################################################################
+#
+# Copyright (c) 2001-2012 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 .common import UnsignedKeysBTreeTests as BTreeTests
+from .common import UnsignedExtendedSetTests as ExtendedSetTests
+from .common import InternalKeysMappingTest
+from .common import InternalKeysSetTest
+from .common import UnsignedKeysMappingBase as MappingBase
+from .common import UnsignedKeysMappingConflictTestBase as MappingConflictTestBase
+from .common import ModuleTest
+from .common import MultiUnion
+from .common import UnsignedNormalSetTests as NormalSetTests
+from .common import UnsignedSetConflictTestBase as SetConflictTestBase
+from .common import SetResult
+from .common import TestLongIntKeys
+from .common import makeBuilder
+from .common import UnsignedKeysMixin
+
+# pylint: disable=no-name-in-module,arguments-differ
+
+class QFBTreeInternalKeyTest(InternalKeysMappingTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QFBTree import QFBTree
+        return QFBTree
+
+
+class QFBTreePyInternalKeyTest(InternalKeysMappingTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QFBTree import QFBTreePy
+        return QFBTreePy
+
+
+class QFTreeSetInternalKeyTest(InternalKeysSetTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QFBTree import QFTreeSet
+        return QFTreeSet
+
+
+class QFTreeSetPyInternalKeyTest(InternalKeysSetTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QFBTree import QFTreeSetPy
+        return QFTreeSetPy
+
+
+class QFBucketTest(MappingBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QFBTree import QFBucket
+        return QFBucket
+
+
+class QFBucketPyTest(MappingBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QFBTree import QFBucketPy
+        return QFBucketPy
+
+
+class QFTreeSetTest(NormalSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QFBTree import QFTreeSet
+        return QFTreeSet
+
+
+class QFTreeSetPyTest(NormalSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QFBTree import QFTreeSetPy
+        return QFTreeSetPy
+
+
+class QFSetTest(ExtendedSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QFBTree import QFSet
+        return QFSet
+
+
+class QFSetPyTest(ExtendedSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QFBTree import QFSetPy
+        return QFSetPy
+
+
+class QFBTreeTest(BTreeTests, TestLongIntKeys, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.QFBTree import QFBTree
+        return QFBTree()
+
+    def getTwoValues(self):
+        return 0.5, 1.5
+
+
+class QFBTreePyTest(BTreeTests, TestLongIntKeys, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.QFBTree import QFBTreePy
+        return QFBTreePy()
+
+    def getTwoValues(self):
+        return 0.5, 1.5
+
+
+class TestQFMultiUnion(UnsignedKeysMixin, MultiUnion, unittest.TestCase):
+
+    def multiunion(self, *args):
+        from BTrees.QFBTree import multiunionPy
+        return multiunionPy(*args)
+
+    def union(self, *args):
+        from BTrees.QFBTree import unionPy
+        return unionPy(*args)
+
+    def mkset(self, *args):
+        from BTrees.QFBTree import QFSetPy as mkset
+        return mkset(*args)
+
+    def mktreeset(self, *args):
+        from BTrees.QFBTree import QFTreeSetPy as mktreeset
+        return mktreeset(*args)
+
+    def mkbucket(self, *args):
+        from BTrees.QFBTree import QFBucketPy as mkbucket
+        return mkbucket(*args)
+
+    def mkbtree(self, *args):
+        from BTrees.QFBTree import QFBTreePy as mkbtree
+        return mkbtree(*args)
+
+
+class TestQFMultiUnionPy(UnsignedKeysMixin, MultiUnion, unittest.TestCase):
+
+    def multiunion(self, *args):
+        from BTrees.QFBTree import multiunionPy
+        return multiunionPy(*args)
+
+    def union(self, *args):
+        from BTrees.QFBTree import unionPy
+        return unionPy(*args)
+
+    def mkset(self, *args):
+        from BTrees.QFBTree import QFSetPy as mkset
+        return mkset(*args)
+
+    def mktreeset(self, *args):
+        from BTrees.QFBTree import QFTreeSetPy as mktreeset
+        return mktreeset(*args)
+
+    def mkbucket(self, *args):
+        from BTrees.QFBTree import QFBucketPy as mkbucket
+        return mkbucket(*args)
+
+    def mkbtree(self, *args):
+        from BTrees.QFBTree import QFBTreePy as mkbtree
+        return mkbtree(*args)
+
+
+class PureQF(SetResult, unittest.TestCase):
+
+    def union(self, *args):
+        from BTrees.QFBTree import union
+        return union(*args)
+
+    def intersection(self, *args):
+        from BTrees.QFBTree import intersection
+        return intersection(*args)
+
+    def difference(self, *args):
+        from BTrees.QFBTree import difference
+        return difference(*args)
+
+    def builders(self):
+        from BTrees.QFBTree import QFBTree
+        from BTrees.QFBTree import QFBucket
+        from BTrees.QFBTree import QFTreeSet
+        from BTrees.QFBTree import QFSet
+        return QFSet, QFTreeSet, makeBuilder(QFBTree), makeBuilder(QFBucket)
+
+
+class PureQFPy(SetResult, unittest.TestCase):
+
+    def union(self, *args):
+        from BTrees.QFBTree import unionPy
+        return unionPy(*args)
+
+    def intersection(self, *args):
+        from BTrees.QFBTree import intersectionPy
+        return intersectionPy(*args)
+
+    def difference(self, *args):
+        from BTrees.QFBTree import differencePy
+        return differencePy(*args)
+
+    def builders(self):
+        from BTrees.QFBTree import QFBTreePy
+        from BTrees.QFBTree import QFBucketPy
+        from BTrees.QFBTree import QFTreeSetPy
+        from BTrees.QFBTree import QFSetPy
+        return (QFSetPy, QFTreeSetPy,
+                makeBuilder(QFBTreePy), makeBuilder(QFBucketPy))
+
+
+class QFBTreeConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QFBTree import QFBTree
+        return QFBTree
+
+
+class QFBTreeConflictTestsPy(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QFBTree import QFBTreePy
+        return QFBTreePy
+
+
+class QFBucketConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QFBTree import QFBucket
+        return QFBucket
+
+
+class QFBucketConflictTestsPy(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QFBTree import QFBucketPy
+        return QFBucketPy
+
+
+class QFTreeSetConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QFBTree import QFTreeSet
+        return QFTreeSet
+
+
+class QFTreeSetConflictTestsPy(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QFBTree import QFTreeSetPy
+        return QFTreeSetPy
+
+
+class QFSetConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QFBTree import QFSet
+        return QFSet
+
+
+class QFSetConflictTestsPy(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QFBTree import QFSetPy
+        return QFSetPy
+
+
+class QFModuleTest(ModuleTest, unittest.TestCase):
+
+    prefix = 'QF'
+
+    def _getModule(self):
+        import BTrees
+        return BTrees.QFBTree
+
+    def _getInterface(self):
+        import BTrees.Interfaces
+        return BTrees.Interfaces.IUnsignedFloatBTreeModule
+
+
+def test_suite():
+    return unittest.TestSuite((
+        unittest.makeSuite(QFBTreeInternalKeyTest),
+        unittest.makeSuite(QFBTreePyInternalKeyTest),
+        unittest.makeSuite(QFTreeSetInternalKeyTest),
+        unittest.makeSuite(QFTreeSetPyInternalKeyTest),
+        unittest.makeSuite(QFBucketTest),
+        unittest.makeSuite(QFBucketPyTest),
+        unittest.makeSuite(QFTreeSetTest),
+        unittest.makeSuite(QFTreeSetPyTest),
+        unittest.makeSuite(QFSetTest),
+        unittest.makeSuite(QFSetPyTest),
+        unittest.makeSuite(QFBTreeTest),
+        unittest.makeSuite(QFBTreePyTest),
+        unittest.makeSuite(TestQFMultiUnion),
+        unittest.makeSuite(TestQFMultiUnionPy),
+        unittest.makeSuite(PureQF),
+        unittest.makeSuite(PureQFPy),
+        unittest.makeSuite(QFBTreeConflictTests),
+        unittest.makeSuite(QFBTreeConflictTestsPy),
+        unittest.makeSuite(QFBucketConflictTests),
+        unittest.makeSuite(QFBucketConflictTestsPy),
+        unittest.makeSuite(QFTreeSetConflictTests),
+        unittest.makeSuite(QFTreeSetConflictTestsPy),
+        unittest.makeSuite(QFSetConflictTests),
+        unittest.makeSuite(QFSetConflictTestsPy),
+        unittest.makeSuite(QFModuleTest),
+    ))

BTrees/tests/test_QLBTree.py

+##############################################################################
+#
+# Copyright (c) 2001-2012 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 .common import I_SetsBase
+from .common import TestLongIntValues
+from .common import Weighted
+from .common import itemsToSet
+
+from .common import UnsignedKeysBTreeTests as BTreeTests
+from .common import UnsignedExtendedSetTests as ExtendedSetTests
+from .common import InternalKeysMappingTest
+from .common import InternalKeysSetTest
+from .common import UnsignedKeysMappingBase as MappingBase
+from .common import UnsignedKeysMappingConflictTestBase as MappingConflictTestBase
+from .common import ModuleTest
+from .common import MultiUnion
+from .common import UnsignedNormalSetTests as NormalSetTests
+from .common import UnsignedSetConflictTestBase as SetConflictTestBase
+from .common import SetResult
+from .common import TestLongIntKeys
+from .common import makeBuilder
+from .common import UnsignedKeysMixin
+
+# pylint: disable=no-name-in-module,arguments-differ
+
+class QLBTreeInternalKeyTest(InternalKeysMappingTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QLBTree import QLBTree
+        return QLBTree
+
+
+class QLBTreePyInternalKeyTest(InternalKeysMappingTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QLBTree import QLBTreePy
+        return QLBTreePy
+
+
+class QLTreeSetInternalKeyTest(InternalKeysSetTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QLBTree import QLTreeSet
+        return QLTreeSet
+
+
+class QLTreeSetPyInternalKeyTest(InternalKeysSetTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QLBTree import QLTreeSetPy
+        return QLTreeSetPy
+
+
+class QLBucketTest(MappingBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QLBTree import QLBucket
+        return QLBucket
+
+
+class QLBucketTestPy(MappingBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QLBTree import QLBucketPy
+        return QLBucketPy
+
+
+class QLTreeSetTest(NormalSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QLBTree import QLTreeSet
+        return QLTreeSet
+
+
+class QLTreeSetTestPy(NormalSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QLBTree import QLTreeSetPy
+        return QLTreeSetPy
+
+
+class QLSetTest(ExtendedSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QLBTree import QLSet
+        return QLSet
+
+
+class QLSetTestPy(ExtendedSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QLBTree import QLSetPy
+        return QLSetPy
+
+
+class QLBTreeTest(BTreeTests, TestLongIntKeys, TestLongIntValues,
+                  unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.QLBTree import QLBTree
+        return QLBTree()
+    def getTwoValues(self):
+        return 1, 2
+
+
+class QLBTreeTestPy(BTreeTests, TestLongIntKeys, TestLongIntValues,
+                    unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.QLBTree import QLBTreePy
+        return QLBTreePy()
+    def getTwoValues(self):
+        return 1, 2
+
+
+class TestQLSets(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.QLBTree import QLSet
+        return QLSet()
+
+
+class TestQLSetsPy(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.QLBTree import QLSetPy
+        return QLSetPy()
+
+
+class TestQLTreeSets(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.QLBTree import QLTreeSet
+        return QLTreeSet()
+
+
+class TestQLTreeSetsPy(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.QLBTree import QLTreeSetPy
+        return QLTreeSetPy()
+
+
+class PureQL(SetResult, unittest.TestCase):
+
+    def union(self, *args):
+        from BTrees.QLBTree import union
+        return union(*args)
+
+    def intersection(self, *args):
+        from BTrees.QLBTree import intersection
+        return intersection(*args)
+
+    def difference(self, *args):
+        from BTrees.QLBTree import difference
+        return difference(*args)
+
+    def builders(self):
+        from BTrees.QLBTree import QLBTree
+        from BTrees.QLBTree import QLBucket
+        from BTrees.QLBTree import QLTreeSet
+        from BTrees.QLBTree import QLSet
+        return QLSet, QLTreeSet, makeBuilder(QLBTree), makeBuilder(QLBucket)
+
+
+class PureQLPy(SetResult, unittest.TestCase):
+
+    def union(self, *args):
+        from BTrees.QLBTree import unionPy
+        return unionPy(*args)
+
+    def intersection(self, *args):
+        from BTrees.QLBTree import intersectionPy
+        return intersectionPy(*args)
+
+    def difference(self, *args):
+        from BTrees.QLBTree import differencePy
+        return differencePy(*args)
+
+    def builders(self):
+        from BTrees.QLBTree import QLBTreePy
+        from BTrees.QLBTree import QLBucketPy
+        from BTrees.QLBTree import QLTreeSetPy
+        from BTrees.QLBTree import QLSetPy
+        return (QLSetPy, QLTreeSetPy,
+                makeBuilder(QLBTreePy), makeBuilder(QLBucketPy))
+
+
+class TestQLMultiUnion(UnsignedKeysMixin, MultiUnion, unittest.TestCase):
+
+    def multiunion(self, *args):
+        from BTrees.QLBTree import multiunion
+        return multiunion(*args)
+
+    def union(self, *args):
+        from BTrees.QLBTree import union
+        return union(*args)
+
+    def mkset(self, *args):
+        from BTrees.QLBTree import QLSet as mkset
+        return mkset(*args)
+
+    def mktreeset(self, *args):
+        from BTrees.QLBTree import QLTreeSet as mktreeset
+        return mktreeset(*args)
+
+    def mkbucket(self, *args):
+        from BTrees.QLBTree import QLBucket as mkbucket
+        return mkbucket(*args)
+
+    def mkbtree(self, *args):
+        from BTrees.QLBTree import QLBTree as mkbtree
+        return mkbtree(*args)
+
+
+class TestQLMultiUnionPy(UnsignedKeysMixin, MultiUnion, unittest.TestCase):
+
+    def multiunion(self, *args):
+        from BTrees.QLBTree import multiunionPy
+        return multiunionPy(*args)
+
+    def union(self, *args):
+        from BTrees.QLBTree import unionPy
+        return unionPy(*args)
+
+    def mkset(self, *args):
+        from BTrees.QLBTree import QLSetPy as mkset
+        return mkset(*args)
+
+    def mktreeset(self, *args):
+        from BTrees.QLBTree import QLTreeSetPy as mktreeset
+        return mktreeset(*args)
+
+    def mkbucket(self, *args):
+        from BTrees.QLBTree import QLBucketPy as mkbucket
+        return mkbucket(*args)
+
+    def mkbtree(self, *args):
+        from BTrees.QLBTree import QLBTreePy as mkbtree
+        return mkbtree(*args)
+
+
+class TestWeightedQL(UnsignedKeysMixin, Weighted, unittest.TestCase):
+
+    def weightedUnion(self):
+        from BTrees.QLBTree import weightedUnion
+        return weightedUnion
+
+    def weightedIntersection(self):
+        from BTrees.QLBTree import weightedIntersection
+        return weightedIntersection
+
+    def union(self):
+        from BTrees.QLBTree import union
+        return union
+
+    def intersection(self):
+        from BTrees.QLBTree import intersection
+        return intersection
+
+    def mkbucket(self, *args):
+        from BTrees.QLBTree import QLBucket as mkbucket
+        return mkbucket(*args)
+
+    def builders(self):
+        from BTrees.QLBTree import QLBTree
+        from BTrees.QLBTree import QLBucket
+        from BTrees.QLBTree import QLTreeSet
+        from BTrees.QLBTree import QLSet
+        return QLBucket, QLBTree, itemsToSet(QLSet), itemsToSet(QLTreeSet)
+
+
+class TestWeightedQLPy(UnsignedKeysMixin, Weighted, unittest.TestCase):
+
+    def weightedUnion(self):
+        from BTrees.QLBTree import weightedUnionPy
+        return weightedUnionPy
+
+    def weightedIntersection(self):
+        from BTrees.QLBTree import weightedIntersectionPy
+        return weightedIntersectionPy
+
+    def union(self):
+        from BTrees.QLBTree import unionPy
+        return unionPy
+
+    def intersection(self):
+        from BTrees.QLBTree import intersectionPy
+        return intersectionPy
+
+    def mkbucket(self, *args):
+        from BTrees.QLBTree import QLBucketPy as mkbucket
+        return mkbucket(*args)
+
+    def builders(self):
+        from BTrees.QLBTree import QLBTreePy
+        from BTrees.QLBTree import QLBucketPy
+        from BTrees.QLBTree import QLTreeSetPy
+        from BTrees.QLBTree import QLSetPy
+        return (QLBucketPy, QLBTreePy,
+                itemsToSet(QLSetPy), itemsToSet(QLTreeSetPy))
+
+
+class QLBTreeConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QLBTree import QLBTree
+        return QLBTree
+
+
+class QLBTreeConflictTestsPy(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QLBTree import QLBTreePy
+        return QLBTreePy
+
+
+class QLBucketConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QLBTree import QLBucket
+        return QLBucket
+
+
+class QLBucketConflictTestsPy(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QLBTree import QLBucketPy
+        return QLBucketPy
+
+
+class QLTreeSetConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QLBTree import QLTreeSet
+        return QLTreeSet
+
+
+class QLTreeSetConflictTestsPy(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QLBTree import QLTreeSetPy
+        return QLTreeSetPy
+
+
+class QLSetConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QLBTree import QLSet
+        return QLSet
+
+
+class QLSetConflictTestsPy(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QLBTree import QLSetPy
+        return QLSetPy
+
+
+class QLModuleTest(ModuleTest, unittest.TestCase):
+
+    prefix = 'QL'
+
+    def _getModule(self):
+        import BTrees
+        return BTrees.QLBTree
+
+    def _getInterface(self):
+        import BTrees.Interfaces
+        return BTrees.Interfaces.IUnsignedIntegerBTreeModule
+
+
+def test_suite():
+    return unittest.TestSuite((
+        unittest.makeSuite(QLBTreeInternalKeyTest),
+        unittest.makeSuite(QLBTreeInternalKeyTest),
+        unittest.makeSuite(QLTreeSetInternalKeyTest),
+        unittest.makeSuite(QLTreeSetInternalKeyTest),
+        unittest.makeSuite(QLBucketTest),
+        unittest.makeSuite(QLBucketTest),
+        unittest.makeSuite(QLTreeSetTest),
+        unittest.makeSuite(QLTreeSetTest),
+        unittest.makeSuite(QLSetTest),
+        unittest.makeSuite(QLSetTest),
+        unittest.makeSuite(QLBTreeTest),
+        unittest.makeSuite(QLBTreeTest),
+        unittest.makeSuite(TestQLSets),
+        unittest.makeSuite(TestQLSets),
+        unittest.makeSuite(TestQLTreeSets),
+        unittest.makeSuite(TestQLTreeSets),
+        unittest.makeSuite(TestQLMultiUnion),
+        unittest.makeSuite(TestQLMultiUnion),
+        unittest.makeSuite(PureQL),
+        unittest.makeSuite(PureQL),
+        unittest.makeSuite(TestWeightedQL),
+        unittest.makeSuite(TestWeightedQL),
+        unittest.makeSuite(QLBTreeConflictTests),
+        unittest.makeSuite(QLBTreeConflictTests),
+        unittest.makeSuite(QLBucketConflictTests),
+        unittest.makeSuite(QLBucketConflictTests),
+        unittest.makeSuite(QLTreeSetConflictTests),
+        unittest.makeSuite(QLTreeSetConflictTests),
+        unittest.makeSuite(QLSetConflictTests),
+        unittest.makeSuite(QLSetConflictTests),
+        unittest.makeSuite(QLModuleTest),
+    ))

BTrees/tests/test_QOBTree.py

+##############################################################################
+#
+# Copyright (c) 2001-2012 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 .common import UnsignedKeysBTreeTests as BTreeTests
+from .common import UnsignedExtendedSetTests as ExtendedSetTests
+from .common import I_SetsBase
+from .common import InternalKeysMappingTest
+from .common import InternalKeysSetTest
+from .common import UnsignedKeysMappingBase as MappingBase
+from .common import UnsignedKeysMappingConflictTestBase as MappingConflictTestBase
+from .common import ModuleTest
+from .common import MultiUnion
+from .common import UnsignedNormalSetTests as NormalSetTests
+from .common import UnsignedSetConflictTestBase as SetConflictTestBase
+from .common import SetResult
+from .common import TestLongIntKeys
+from .common import makeBuilder
+from .common import UnsignedKeysMixin
+
+# pylint:disable=no-name-in-module,arguments-differ
+
+class QOBTreeInternalKeyTest(InternalKeysMappingTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QOBTree import QOBTree
+        return QOBTree
+
+
+class QOBTreePyInternalKeyTest(InternalKeysMappingTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QOBTree import QOBTreePy
+        return QOBTreePy
+
+
+class QOTreeSetInternalKeyTest(InternalKeysSetTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QOBTree import QOTreeSet
+        return QOTreeSet
+
+
+class QOTreeSetPyInternalKeyTest(InternalKeysSetTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QOBTree import QOTreeSetPy
+        return QOTreeSetPy
+
+
+class QOBucketTest(MappingBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QOBTree import QOBucket
+        return QOBucket
+
+
+class QOBucketPyTest(MappingBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QOBTree import QOBucketPy
+        return QOBucketPy
+
+
+class QOTreeSetTest(NormalSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QOBTree import QOTreeSet
+        return QOTreeSet
+
+
+class QOTreeSetPyTest(NormalSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QOBTree import QOTreeSetPy
+        return QOTreeSetPy
+
+
+class QOSetTest(ExtendedSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QOBTree import QOSet
+        return QOSet
+
+
+class QOSetPyTest(ExtendedSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QOBTree import QOSetPy
+        return QOSetPy
+
+
+class QOBTreeTest(BTreeTests, TestLongIntKeys, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.QOBTree import QOBTree
+        return QOBTree()
+
+
+class QOBTreePyTest(BTreeTests, TestLongIntKeys, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.QOBTree import QOBTreePy
+        return QOBTreePy()
+
+
+class TestQOSets(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.QOBTree import QOSet
+        return QOSet()
+
+
+class TestQOSetsPy(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.QOBTree import QOSetPy
+        return QOSetPy()
+
+
+class TestQOTreeSets(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.QOBTree import QOTreeSet
+        return QOTreeSet()
+
+
+class TestQOTreeSetsPy(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.QOBTree import QOTreeSetPy
+        return QOTreeSetPy()
+
+
+class TestQOMultiUnion(UnsignedKeysMixin, MultiUnion, unittest.TestCase):
+
+    def multiunion(self, *args):
+        from BTrees.QOBTree import multiunion
+        return multiunion(*args)
+
+    def union(self, *args):
+        from BTrees.QOBTree import union
+        return union(*args)
+
+    def mkset(self, *args):
+        from BTrees.QOBTree import QOSet as mkset
+        return mkset(*args)
+
+    def mktreeset(self, *args):
+        from BTrees.QOBTree import QOTreeSet as mktreeset
+        return mktreeset(*args)
+
+    def mkbucket(self, *args):
+        from BTrees.QOBTree import QOBucket as mkbucket
+        return mkbucket(*args)
+
+    def mkbtree(self, *args):
+        from BTrees.QOBTree import QOBTree as mkbtree
+        return mkbtree(*args)
+
+
+class TestQOMultiUnionPy(UnsignedKeysMixin, MultiUnion, unittest.TestCase):
+
+    def multiunion(self, *args):
+        from BTrees.QOBTree import multiunionPy
+        return multiunionPy(*args)
+
+    def union(self, *args):
+        from BTrees.QOBTree import unionPy
+        return unionPy(*args)
+
+    def mkset(self, *args):
+        from BTrees.QOBTree import QOSetPy as mkset
+        return mkset(*args)
+
+    def mktreeset(self, *args):
+        from BTrees.QOBTree import QOTreeSetPy as mktreeset
+        return mktreeset(*args)
+
+    def mkbucket(self, *args):
+        from BTrees.QOBTree import QOBucketPy as mkbucket
+        return mkbucket(*args)
+
+    def mkbtree(self, *args):
+        from BTrees.QOBTree import QOBTreePy as mkbtree
+        return mkbtree(*args)
+
+
+class PureQO(SetResult, unittest.TestCase):
+
+    def union(self, *args):
+        from BTrees.QOBTree import union
+        return union(*args)
+
+    def intersection(self, *args):
+        from BTrees.QOBTree import intersection
+        return intersection(*args)
+
+    def difference(self, *args):
+        from BTrees.QOBTree import difference
+        return difference(*args)
+
+    def builders(self):
+        from BTrees.QOBTree import QOBTree
+        from BTrees.QOBTree import QOBucket
+        from BTrees.QOBTree import QOTreeSet
+        from BTrees.QOBTree import QOSet
+        return QOSet, QOTreeSet, makeBuilder(QOBTree), makeBuilder(QOBucket)
+
+
+class PureQOPy(SetResult, unittest.TestCase):
+
+    def union(self, *args):
+        from BTrees.QOBTree import unionPy
+        return unionPy(*args)
+
+    def intersection(self, *args):
+        from BTrees.QOBTree import intersectionPy
+        return intersectionPy(*args)
+
+    def difference(self, *args):
+        from BTrees.QOBTree import differencePy
+        return differencePy(*args)
+
+    def builders(self):
+        from BTrees.QOBTree import QOBTreePy
+        from BTrees.QOBTree import QOBucketPy
+        from BTrees.QOBTree import QOTreeSetPy
+        from BTrees.QOBTree import QOSetPy
+        return (QOSetPy, QOTreeSetPy,
+                makeBuilder(QOBTreePy), makeBuilder(QOBucketPy))
+
+
+class QOBTreeConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QOBTree import QOBTree
+        return QOBTree
+
+
+class QOBTreeConflictTestsPy(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QOBTree import QOBTreePy
+        return QOBTreePy
+
+
+class QOBucketConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QOBTree import QOBucket
+        return QOBucket
+
+
+class QOBucketConflictTestsPy(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QOBTree import QOBucketPy
+        return QOBucketPy
+
+
+class QOTreeSetConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QOBTree import QOTreeSet
+        return QOTreeSet
+
+
+class QOTreeSetConflictTestsPy(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QOBTree import QOTreeSetPy
+        return QOTreeSetPy
+
+
+class QOSetConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QOBTree import QOSet
+        return QOSet
+
+
+class QOSetConflictTestsPy(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QOBTree import QOSetPy
+        return QOSetPy
+
+
+class QOModuleTest(ModuleTest, unittest.TestCase):
+
+    prefix = 'QO'
+
+    def _getModule(self):
+        import BTrees
+        return BTrees.QOBTree
+
+    def _getInterface(self):
+        import BTrees.Interfaces
+        return BTrees.Interfaces.IUnsignedObjectBTreeModule
+
+    def test_weightedUnion_not_present(self):
+        try:
+            from BTrees.QOBTree import weightedUnion
+        except ImportError:
+            pass
+        else:
+            self.fail("QOBTree shouldn't have weightedUnion")
+
+    def test_weightedIntersection_not_present(self):
+        try:
+            from BTrees.QOBTree import weightedIntersection
+        except ImportError:
+            pass
+        else:
+            self.fail("QOBTree shouldn't have weightedIntersection")
+
+
+def test_suite():
+    return unittest.TestSuite((
+        unittest.makeSuite(QOBTreeInternalKeyTest),
+        unittest.makeSuite(QOBTreePyInternalKeyTest),
+        unittest.makeSuite(QOTreeSetInternalKeyTest),
+        unittest.makeSuite(QOTreeSetPyInternalKeyTest),
+        unittest.makeSuite(QOBucketTest),
+        unittest.makeSuite(QOBucketPyTest),
+        unittest.makeSuite(QOTreeSetTest),
+        unittest.makeSuite(QOTreeSetPyTest),
+        unittest.makeSuite(QOSetTest),
+        unittest.makeSuite(QOSetPyTest),
+        unittest.makeSuite(QOBTreeTest),
+        unittest.makeSuite(QOBTreePyTest),
+        unittest.makeSuite(TestQOSets),
+        unittest.makeSuite(TestQOSetsPy),
+        unittest.makeSuite(TestQOTreeSets),
+        unittest.makeSuite(TestQOTreeSetsPy),
+        unittest.makeSuite(TestQOMultiUnion),
+        unittest.makeSuite(TestQOMultiUnionPy),
+        unittest.makeSuite(PureQO),
+        unittest.makeSuite(PureQOPy),
+        unittest.makeSuite(QOBTreeConflictTests),
+        unittest.makeSuite(QOBTreeConflictTestsPy),
+        unittest.makeSuite(QOBucketConflictTests),
+        unittest.makeSuite(QOBucketConflictTestsPy),
+        unittest.makeSuite(QOTreeSetConflictTests),
+        unittest.makeSuite(QOTreeSetConflictTestsPy),
+        unittest.makeSuite(QOSetConflictTests),
+        unittest.makeSuite(QOSetConflictTestsPy),
+        unittest.makeSuite(QOModuleTest),
+    ))

BTrees/tests/test_QQBTree.py

+##############################################################################
+#
+# Copyright (c) 2001-2012 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 .common import UnsignedBTreeTests as BTreeTests
+from .common import UnsignedExtendedSetTests as ExtendedSetTests
+from .common import I_SetsBase
+from .common import InternalKeysMappingTest
+from .common import InternalKeysSetTest
+from .common import UnsignedMappingBase as MappingBase
+from .common import UnsignedMappingConflictTestBase as MappingConflictTestBase
+from .common import ModuleTest
+from .common import MultiUnion
+from .common import UnsignedNormalSetTests as NormalSetTests
+from .common import UnsignedSetConflictTestBase as SetConflictTestBase
+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 .common import UnsignedMixin
+
+
+# pylint:disable=no-name-in-module,arguments-differ
+
+class QQBTreeInternalKeyTest(InternalKeysMappingTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QQBTree import QQBTree
+        return QQBTree
+
+
+class QQBTreePyInternalKeyTest(InternalKeysMappingTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QQBTree import QQBTreePy
+        return QQBTreePy
+
+
+class QQTreeSetInternalKeyTest(InternalKeysSetTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QQBTree import QQTreeSet
+        return QQTreeSet
+
+
+class QQTreeSetPyInternalKeyTest(InternalKeysSetTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QQBTree import QQTreeSetPy
+        return QQTreeSetPy
+
+
+class QQBucketTest(MappingBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QQBTree import QQBucket
+        return QQBucket
+
+
+class QQBucketTestPy(MappingBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QQBTree import QQBucketPy
+        return QQBucketPy
+
+
+class QQTreeSetTest(NormalSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QQBTree import QQTreeSet
+        return QQTreeSet
+
+
+class QQTreeSetTestPy(NormalSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QQBTree import QQTreeSetPy
+        return QQTreeSetPy
+
+
+class QQSetTest(ExtendedSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QQBTree import QQSet
+        return QQSet
+
+
+class QQSetTestPy(ExtendedSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QQBTree import QQSetPy
+        return QQSetPy
+
+
+class QQBTreeTest(BTreeTests, TestLongIntKeys, TestLongIntValues,
+                  unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.QQBTree import QQBTree
+        return QQBTree()
+    def getTwoValues(self):
+        return 1, 2
+
+
+class QQBTreeTestPy(BTreeTests, TestLongIntKeys, TestLongIntValues,
+                    unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.QQBTree import QQBTreePy
+        return QQBTreePy()
+    def getTwoValues(self):
+        return 1, 2
+
+
+class TestQQSets(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.QQBTree import QQSet
+        return QQSet()
+
+
+class TestQQSetsPy(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.QQBTree import QQSetPy
+        return QQSetPy()
+
+
+class TestQQTreeSets(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.QQBTree import QQTreeSet
+        return QQTreeSet()
+
+
+class TestQQTreeSetsPy(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.QQBTree import QQTreeSetPy
+        return QQTreeSetPy()
+
+
+class PureQQ(SetResult, unittest.TestCase):
+
+    def union(self, *args):
+        from BTrees.QQBTree import union
+        return union(*args)
+
+    def intersection(self, *args):
+        from BTrees.QQBTree import intersection
+        return intersection(*args)
+
+    def difference(self, *args):
+        from BTrees.QQBTree import difference
+        return difference(*args)
+
+    def builders(self):
+        from BTrees.QQBTree import QQBTree
+        from BTrees.QQBTree import QQBucket
+        from BTrees.QQBTree import QQTreeSet
+        from BTrees.QQBTree import QQSet
+        return QQSet, QQTreeSet, makeBuilder(QQBTree), makeBuilder(QQBucket)
+
+
+class PureQQPy(SetResult, unittest.TestCase):
+
+    def union(self, *args):
+        from BTrees.QQBTree import unionPy
+        return unionPy(*args)
+
+    def intersection(self, *args):
+        from BTrees.QQBTree import intersectionPy
+        return intersectionPy(*args)
+
+    def difference(self, *args):
+        from BTrees.QQBTree import differencePy
+        return differencePy(*args)
+
+    def builders(self):
+        from BTrees.QQBTree import QQBTreePy
+        from BTrees.QQBTree import QQBucketPy
+        from BTrees.QQBTree import QQTreeSetPy
+        from BTrees.QQBTree import QQSetPy
+        return (QQSetPy, QQTreeSetPy,
+                makeBuilder(QQBTreePy), makeBuilder(QQBucketPy))
+
+
+class TestQQMultiUnion(UnsignedMixin, MultiUnion, unittest.TestCase):
+
+    def multiunion(self, *args):
+        from BTrees.QQBTree import multiunion
+        return multiunion(*args)
+
+    def union(self, *args):
+        from BTrees.QQBTree import union
+        return union(*args)
+
+    def mkset(self, *args):
+        from BTrees.QQBTree import QQSet as mkset
+        return mkset(*args)
+
+    def mktreeset(self, *args):
+        from BTrees.QQBTree import QQTreeSet as mktreeset
+        return mktreeset(*args)
+
+    def mkbucket(self, *args):
+        from BTrees.QQBTree import QQBucket as mkbucket
+        return mkbucket(*args)
+
+    def mkbtree(self, *args):
+        from BTrees.QQBTree import QQBTree as mkbtree
+        return mkbtree(*args)
+
+
+class TestQQMultiUnionPy(UnsignedMixin, MultiUnion, unittest.TestCase):
+
+    def multiunion(self, *args):
+        from BTrees.QQBTree import multiunionPy
+        return multiunionPy(*args)
+
+    def union(self, *args):
+        from BTrees.QQBTree import unionPy
+        return unionPy(*args)
+
+    def mkset(self, *args):
+        from BTrees.QQBTree import QQSetPy as mkset
+        return mkset(*args)
+
+    def mktreeset(self, *args):
+        from BTrees.QQBTree import QQTreeSetPy as mktreeset
+        return mktreeset(*args)
+
+    def mkbucket(self, *args):
+        from BTrees.QQBTree import QQBucketPy as mkbucket
+        return mkbucket(*args)
+
+    def mkbtree(self, *args):
+        from BTrees.QQBTree import QQBTreePy as mkbtree
+        return mkbtree(*args)
+
+
+class TestWeightedQQ(UnsignedMixin, Weighted, unittest.TestCase):
+
+    def weightedUnion(self):
+        from BTrees.QQBTree import weightedUnion
+        return weightedUnion
+
+    def weightedIntersection(self):
+        from BTrees.QQBTree import weightedIntersection
+        return weightedIntersection
+
+    def union(self):
+        from BTrees.QQBTree import union
+        return union
+
+    def intersection(self):
+        from BTrees.QQBTree import intersection
+        return intersection
+
+    def mkbucket(self, *args):
+        from BTrees.QQBTree import QQBucket as mkbucket
+        return mkbucket(*args)
+
+    def builders(self):
+        from BTrees.QQBTree import QQBTree
+        from BTrees.QQBTree import QQBucket
+        from BTrees.QQBTree import QQTreeSet
+        from BTrees.QQBTree import QQSet
+        return QQBucket, QQBTree, itemsToSet(QQSet), itemsToSet(QQTreeSet)
+
+
+class TestWeightedQQPy(UnsignedMixin, Weighted, unittest.TestCase):
+
+    def weightedUnion(self):
+        from BTrees.QQBTree import weightedUnionPy
+        return weightedUnionPy
+
+    def weightedIntersection(self):
+        from BTrees.QQBTree import weightedIntersectionPy
+        return weightedIntersectionPy
+
+    def union(self):
+        from BTrees.QQBTree import unionPy
+        return unionPy
+
+    def intersection(self):
+        from BTrees.QQBTree import intersectionPy
+        return intersectionPy
+
+    def mkbucket(self, *args):
+        from BTrees.QQBTree import QQBucketPy as mkbucket
+        return mkbucket(*args)
+
+    def builders(self):
+        from BTrees.QQBTree import QQBTreePy
+        from BTrees.QQBTree import QQBucketPy
+        from BTrees.QQBTree import QQTreeSetPy
+        from BTrees.QQBTree import QQSetPy
+        return (QQBucketPy, QQBTreePy,
+                itemsToSet(QQSetPy), itemsToSet(QQTreeSetPy))
+
+
+class QQBTreeConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QQBTree import QQBTree
+        return QQBTree
+
+
+class QQBTreeConflictTestsPy(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QQBTree import QQBTreePy
+        return QQBTreePy
+
+
+class QQBucketConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QQBTree import QQBucket
+        return QQBucket
+
+
+class QQBucketConflictTestsPy(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QQBTree import QQBucketPy
+        return QQBucketPy
+
+
+class QQTreeSetConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QQBTree import QQTreeSet
+        return QQTreeSet
+
+
+class QQTreeSetConflictTestsPy(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QQBTree import QQTreeSetPy
+        return QQTreeSetPy
+
+
+class QQSetConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QQBTree import QQSet
+        return QQSet
+
+
+class QQSetConflictTestsPy(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.QQBTree import QQSetPy
+        return QQSetPy
+
+
+class QQModuleTest(ModuleTest, unittest.TestCase):
+
+    prefix = 'QQ'
+
+    def _getModule(self):
+        import BTrees
+        return BTrees.QQBTree
+
+    def _getInterface(self):
+        import BTrees.Interfaces
+        return BTrees.Interfaces.IUnsignedUnsignedBTreeModule
+
+
+def test_suite():
+    return unittest.TestSuite((
+        unittest.makeSuite(QQBTreeInternalKeyTest),
+        unittest.makeSuite(QQBTreeInternalKeyTest),
+        unittest.makeSuite(QQTreeSetInternalKeyTest),
+        unittest.makeSuite(QQTreeSetInternalKeyTest),
+        unittest.makeSuite(QQBucketTest),
+        unittest.makeSuite(QQBucketTest),
+        unittest.makeSuite(QQTreeSetTest),
+        unittest.makeSuite(QQTreeSetTest),
+        unittest.makeSuite(QQSetTest),
+        unittest.makeSuite(QQSetTest),
+        unittest.makeSuite(QQBTreeTest),
+        unittest.makeSuite(QQBTreeTest),
+        unittest.makeSuite(TestQQSets),
+        unittest.makeSuite(TestQQSets),
+        unittest.makeSuite(TestQQTreeSets),
+        unittest.makeSuite(TestQQTreeSets),
+        unittest.makeSuite(TestQQMultiUnion),
+        unittest.makeSuite(TestQQMultiUnion),
+        unittest.makeSuite(PureQQ),
+        unittest.makeSuite(PureQQ),
+        unittest.makeSuite(TestWeightedQQ),
+        unittest.makeSuite(TestWeightedQQPy),
+        unittest.makeSuite(QQBTreeConflictTests),
+        unittest.makeSuite(QQBTreeConflictTests),
+        unittest.makeSuite(QQBucketConflictTests),
+        unittest.makeSuite(QQBucketConflictTests),
+        unittest.makeSuite(QQTreeSetConflictTests),
+        unittest.makeSuite(QQTreeSetConflictTests),
+        unittest.makeSuite(QQSetConflictTests),
+        unittest.makeSuite(QQSetConflictTests),
+        unittest.makeSuite(QQModuleTest),
+    ))

BTrees/tests/test_UFBTree.py

+##############################################################################
+#
+# Copyright (c) 2001-2012 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 .common import UnsignedKeysBTreeTests as BTreeTests
+from .common import UnsignedExtendedSetTests as ExtendedSetTests
+from .common import InternalKeysMappingTest
+from .common import InternalKeysSetTest
+from .common import UnsignedKeysMappingBase as MappingBase
+from .common import UnsignedKeysMappingConflictTestBase as MappingConflictTestBase
+from .common import ModuleTest
+from .common import MultiUnion
+from .common import UnsignedNormalSetTests as NormalSetTests
+from .common import UnsignedSetConflictTestBase as SetConflictTestBase
+from .common import SetResult
+from .common import TestLongIntKeys
+from .common import makeBuilder
+from .common import UnsignedKeysMixin
+from BTrees.IIBTree import using64bits #XXX Ugly, but unavoidable
+
+# pylint:disable=no-name-in-module,arguments-differ
+
+class UFBTreeInternalKeyTest(InternalKeysMappingTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UFBTree import UFBTree
+        return UFBTree
+
+
+class UFBTreePyInternalKeyTest(InternalKeysMappingTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UFBTree import UFBTreePy
+        return UFBTreePy
+
+
+class UFTreeSetInternalKeyTest(InternalKeysSetTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UFBTree import UFTreeSet
+        return UFTreeSet
+
+
+class UFTreeSetPyInternalKeyTest(InternalKeysSetTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UFBTree import UFTreeSetPy
+        return UFTreeSetPy
+
+
+class UFBucketTest(MappingBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UFBTree import UFBucket
+        return UFBucket
+
+
+class UFBucketPyTest(MappingBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UFBTree import UFBucketPy
+        return UFBucketPy
+
+
+class UFTreeSetTest(NormalSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UFBTree import UFTreeSet
+        return UFTreeSet
+
+
+class UFTreeSetPyTest(NormalSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UFBTree import UFTreeSetPy
+        return UFTreeSetPy
+
+
+class UFSetTest(ExtendedSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UFBTree import UFSet
+        return UFSet
+
+
+class UFSetPyTest(ExtendedSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UFBTree import UFSetPy
+        return UFSetPy
+
+
+class UFBTreeTest(BTreeTests, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UFBTree import UFBTree
+        return UFBTree()
+
+
+class UFBTreePyTest(BTreeTests, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UFBTree import UFBTreePy
+        return UFBTreePy()
+
+if using64bits:
+
+    class UFBTreeTest(BTreeTests, TestLongIntKeys, unittest.TestCase):
+
+        def _makeOne(self):
+            from BTrees.UFBTree import UFBTree
+            return UFBTree()
+
+        def getTwoValues(self):
+            return 0.5, 1.5
+
+    class UFBTreePyTest(BTreeTests, TestLongIntKeys, unittest.TestCase):
+
+        def _makeOne(self):
+            from BTrees.UFBTree import UFBTreePy
+            return UFBTreePy()
+
+        def getTwoValues(self):
+            return 0.5, 1.5
+
+
+class _TestUFBTreesBase(object):
+
+    def testNonIntegerKeyRaises(self):
+        self.assertRaises(TypeError, self._stringraiseskey)
+        self.assertRaises(TypeError, self._floatraiseskey)
+        self.assertRaises(TypeError, self._noneraiseskey)
+
+    def testNonNumericValueRaises(self):
+        self.assertRaises(TypeError, self._stringraisesvalue)
+        self.assertRaises(TypeError, self._noneraisesvalue)
+        self._makeOne()[1] = 1
+        self._makeOne()[1] = 1.0
+
+    def _stringraiseskey(self):
+        self._makeOne()['c'] = 1
+
+    def _floatraiseskey(self):
+        self._makeOne()[2.5] = 1
+
+    def _noneraiseskey(self):
+        self._makeOne()[None] = 1
+
+    def _stringraisesvalue(self):
+        self._makeOne()[1] = 'c'
+
+    def _floatraisesvalue(self):
+        self._makeOne()[1] = 1.4
+
+    def _noneraisesvalue(self):
+        self._makeOne()[1] = None
+
+
+class TestUFBTrees(_TestUFBTreesBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UFBTree import UFBTree
+        return UFBTree()
+
+
+class TestUFBTreesPy(_TestUFBTreesBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UFBTree import UFBTreePy
+        return UFBTreePy()
+
+
+class TestUFMultiUnion(UnsignedKeysMixin, MultiUnion, unittest.TestCase):
+
+    def multiunion(self, *args):
+        from BTrees.UFBTree import multiunion
+        return multiunion(*args)
+
+    def union(self, *args):
+        from BTrees.UFBTree import union
+        return union(*args)
+
+    def mkset(self, *args):
+        from BTrees.UFBTree import UFSet as mkset
+        return mkset(*args)
+
+    def mktreeset(self, *args):
+        from BTrees.UFBTree import UFTreeSet as mktreeset
+        return mktreeset(*args)
+
+    def mkbucket(self, *args):
+        from BTrees.UFBTree import UFBucket as mkbucket
+        return mkbucket(*args)
+
+    def mkbtree(self, *args):
+        from BTrees.UFBTree import UFBTree as mkbtree
+        return mkbtree(*args)
+
+
+class TestUFMultiUnionPy(UnsignedKeysMixin, MultiUnion, unittest.TestCase):
+
+    def multiunion(self, *args):
+        from BTrees.UFBTree import multiunionPy
+        return multiunionPy(*args)
+
+    def union(self, *args):
+        from BTrees.UFBTree import unionPy
+        return unionPy(*args)
+
+    def mkset(self, *args):
+        from BTrees.UFBTree import UFSetPy as mkset
+        return mkset(*args)
+
+    def mktreeset(self, *args):
+        from BTrees.UFBTree import UFTreeSetPy as mktreeset
+        return mktreeset(*args)
+
+    def mkbucket(self, *args):
+        from BTrees.UFBTree import UFBucketPy as mkbucket
+        return mkbucket(*args)
+
+    def mkbtree(self, *args):
+        from BTrees.UFBTree import UFBTreePy as mkbtree
+        return mkbtree(*args)
+
+
+class PureUF(SetResult, unittest.TestCase):
+
+    def union(self, *args):
+        from BTrees.UFBTree import union
+        return union(*args)
+
+    def intersection(self, *args):
+        from BTrees.UFBTree import intersection
+        return intersection(*args)
+
+    def difference(self, *args):
+        from BTrees.UFBTree import difference
+        return difference(*args)
+
+    def builders(self):
+        from BTrees.UFBTree import UFBTree
+        from BTrees.UFBTree import UFBucket
+        from BTrees.UFBTree import UFTreeSet
+        from BTrees.UFBTree import UFSet
+        return UFSet, UFTreeSet, makeBuilder(UFBTree), makeBuilder(UFBucket)
+
+
+class PureUFPy(SetResult, unittest.TestCase):
+
+    def union(self, *args):
+        from BTrees.UFBTree import unionPy
+        return unionPy(*args)
+
+    def intersection(self, *args):
+        from BTrees.UFBTree import intersectionPy
+        return intersectionPy(*args)
+
+    def difference(self, *args):
+        from BTrees.UFBTree import differencePy
+        return differencePy(*args)
+
+    def builders(self):
+        from BTrees.UFBTree import UFBTreePy
+        from BTrees.UFBTree import UFBucketPy
+        from BTrees.UFBTree import UFTreeSetPy
+        from BTrees.UFBTree import UFSetPy
+        return (UFSetPy, UFTreeSetPy,
+                makeBuilder(UFBTreePy), makeBuilder(UFBucketPy))
+
+
+class UFBTreeConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UFBTree import UFBTree
+        return UFBTree
+
+
+class UFBTreePyConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UFBTree import UFBTreePy
+        return UFBTreePy
+
+
+class UFBucketConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UFBTree import UFBucket
+        return UFBucket
+
+
+class UFBucketPyConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UFBTree import UFBucketPy
+        return UFBucketPy
+
+
+class UFTreeSetConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UFBTree import UFTreeSet
+        return UFTreeSet
+
+
+class UFTreeSetPyConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UFBTree import UFTreeSetPy
+        return UFTreeSetPy
+
+
+class UFSetConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UFBTree import UFSet
+        return UFSet
+
+
+class UFSetPyConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UFBTree import UFSetPy
+        return UFSetPy
+
+
+class UFModuleTest(ModuleTest, unittest.TestCase):
+
+    prefix = 'UF'
+
+    def _getModule(self):
+        import BTrees
+        return BTrees.UFBTree
+
+    def _getInterface(self):
+        import BTrees.Interfaces
+        return BTrees.Interfaces.IUnsignedFloatBTreeModule
+
+def test_suite():
+    return unittest.TestSuite((
+        unittest.makeSuite(UFBTreeInternalKeyTest),
+        unittest.makeSuite(UFBTreePyInternalKeyTest),
+        unittest.makeSuite(UFTreeSetInternalKeyTest),
+        unittest.makeSuite(UFTreeSetPyInternalKeyTest),
+        unittest.makeSuite(UFBucketTest),
+        unittest.makeSuite(UFBucketPyTest),
+        unittest.makeSuite(UFTreeSetTest),
+        unittest.makeSuite(UFTreeSetPyTest),
+        unittest.makeSuite(UFSetTest),
+        unittest.makeSuite(UFSetPyTest),
+        unittest.makeSuite(UFBTreeTest),
+        unittest.makeSuite(UFBTreePyTest),
+        unittest.makeSuite(TestUFBTrees),
+        unittest.makeSuite(TestUFBTreesPy),
+        unittest.makeSuite(TestUFMultiUnion),
+        unittest.makeSuite(TestUFMultiUnionPy),
+        unittest.makeSuite(PureUF),
+        unittest.makeSuite(PureUFPy),
+        unittest.makeSuite(UFBTreeConflictTests),
+        unittest.makeSuite(UFBTreePyConflictTests),
+        unittest.makeSuite(UFBucketConflictTests),
+        unittest.makeSuite(UFBucketPyConflictTests),
+        unittest.makeSuite(UFTreeSetConflictTests),
+        unittest.makeSuite(UFTreeSetPyConflictTests),
+        unittest.makeSuite(UFSetConflictTests),
+        unittest.makeSuite(UFSetPyConflictTests),
+        unittest.makeSuite(UFModuleTest),
+    ))

BTrees/tests/test_UIBTree.py

+##############################################################################
+#
+# Copyright (c) 2001-2012 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 .common import UnsignedKeysBTreeTests as BTreeTests
+from .common import UnsignedExtendedSetTests as ExtendedSetTests
+from .common import I_SetsBase
+from .common import InternalKeysMappingTest
+from .common import InternalKeysSetTest
+from .common import UnsignedKeysMappingBase as MappingBase
+from .common import UnsignedKeysMappingConflictTestBase as MappingConflictTestBase
+from .common import ModuleTest
+from .common import MultiUnion
+from .common import UnsignedNormalSetTests as NormalSetTests
+from .common import UnsignedSetConflictTestBase as SetConflictTestBase
+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 .common import UnsignedKeysMixin
+from .common import UnsignedError
+from BTrees.UIBTree import using64bits #XXX Ugly, but unavoidable
+
+
+# pylint:disable=no-name-in-module,arguments-differ
+
+class UIBTreeInternalKeyTest(InternalKeysMappingTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UIBTree import UIBTree
+        return UIBTree
+
+
+class UIBTreePyInternalKeyTest(InternalKeysMappingTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UIBTree import UIBTreePy
+        return UIBTreePy
+
+
+class UITreeSetInternalKeyTest(InternalKeysSetTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UIBTree import UITreeSet
+        return UITreeSet
+
+
+class UITreeSetPyInternalKeyTest(InternalKeysSetTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UIBTree import UITreeSetPy
+        return UITreeSetPy
+
+
+class UIBucketTest(MappingBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UIBTree import UIBucket
+        return UIBucket
+
+
+class UIBucketPyTest(MappingBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UIBTree import UIBucketPy
+        return UIBucketPy
+
+
+class UITreeSetTest(NormalSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UIBTree import UITreeSet
+        return UITreeSet
+
+
+class UITreeSetPyTest(NormalSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UIBTree import UITreeSetPy
+        return UITreeSetPy
+
+
+class UISetTest(ExtendedSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UIBTree import UISet
+        return UISet
+
+
+class UISetPyTest(ExtendedSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UIBTree import UISetPy
+        return UISetPy
+
+
+class _UIBTreeTestBase(BTreeTests):
+
+    def testUIBTreeOverflow(self):
+        good = set()
+        b = self._makeOne()
+
+        def trial(i):
+            i = int(i)
+            try:
+                b[i] = 0
+            except (UnsignedError):
+                __traceback_info__ = i
+                if i > 2 ** 31:
+                    with self.assertRaises(UnsignedError):
+                        b[0] = i
+            else:
+                good.add(i)
+                if i < 2 ** 31:
+                    b[0] = i
+                    self.assertEqual(b[0], i)
+                else:
+                    with self.assertRaises(UnsignedError):
+                        b[0] = i
+
+        for i in range((1<<31) - 3, (1<<31) + 3):
+            trial(i)
+            trial(-i)
+
+        del b[0]
+        self.assertEqual(sorted(good), sorted(b))
+
+
+class UIBTreeTest(_UIBTreeTestBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UIBTree import UIBTree
+        return UIBTree()
+
+
+class UIBTreeTestPy(_UIBTreeTestBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UIBTree import UIBTreePy
+        return UIBTreePy()
+
+
+if using64bits:
+
+    class UIBTreeTest(BTreeTests, TestLongIntKeys, TestLongIntValues,
+                      unittest.TestCase):
+
+        def _makeOne(self):
+            from BTrees.UIBTree import UIBTree
+            return UIBTree()
+
+        def getTwoValues(self):
+            return 1, 2
+
+    class UIBTreeTest(BTreeTests, TestLongIntKeys, TestLongIntValues,
+                      unittest.TestCase):
+
+        def _makeOne(self):
+            from BTrees.UIBTree import UIBTreePy
+            return UIBTreePy()
+
+        def getTwoValues(self):
+            return 1, 2
+
+
+class _TestUIBTreesBase(object):
+
+    def testNonIntegerKeyRaises(self):
+        self.assertRaises(TypeError, self._stringraiseskey)
+        self.assertRaises(TypeError, self._floatraiseskey)
+        self.assertRaises(TypeError, self._noneraiseskey)
+
+    def testNonIntegerValueRaises(self):
+        self.assertRaises(TypeError, self._stringraisesvalue)
+        self.assertRaises(TypeError, self._floatraisesvalue)
+        self.assertRaises(TypeError, self._noneraisesvalue)
+
+    def _stringraiseskey(self):
+        self._makeOne()['c'] = 1
+
+    def _floatraiseskey(self):
+        self._makeOne()[2.5] = 1
+
+    def _noneraiseskey(self):
+        self._makeOne()[None] = 1
+
+    def _stringraisesvalue(self):
+        self._makeOne()[1] = 'c'
+
+    def _floatraisesvalue(self):
+        self._makeOne()[1] = 1.4
+
+    def _noneraisesvalue(self):
+        self._makeOne()[1] = None
+
+
+class TestUIBTrees(_TestUIBTreesBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UIBTree import UIBTree
+        return UIBTree()
+
+
+class TestUIBTreesPy(_TestUIBTreesBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UIBTree import UIBTreePy
+        return UIBTreePy()
+
+
+class TestUISets(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UIBTree import UISet
+        return UISet()
+
+
+class TestUISetsPy(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UIBTree import UISetPy
+        return UISetPy()
+
+
+class TestUITreeSets(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UIBTree import UITreeSet
+        return UITreeSet()
+
+
+class TestUITreeSetsPy(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UIBTree import UITreeSetPy
+        return UITreeSetPy()
+
+
+class PureUI(SetResult, unittest.TestCase):
+
+    def union(self, *args):
+        from BTrees.UIBTree import union
+        return union(*args)
+
+    def intersection(self, *args):
+        from BTrees.UIBTree import intersection
+        return intersection(*args)
+
+    def difference(self, *args):
+        from BTrees.UIBTree import difference
+        return difference(*args)
+
+    def builders(self):
+        from BTrees.UIBTree import UIBTree
+        from BTrees.UIBTree import UIBucket
+        from BTrees.UIBTree import UITreeSet
+        from BTrees.UIBTree import UISet
+        return UISet, UITreeSet, makeBuilder(UIBTree), makeBuilder(UIBucket)
+
+
+class PureUIPy(SetResult, unittest.TestCase):
+
+    def union(self, *args):
+        from BTrees.UIBTree import unionPy
+        return unionPy(*args)
+
+    def intersection(self, *args):
+        from BTrees.UIBTree import intersectionPy
+        return intersectionPy(*args)
+
+    def difference(self, *args):
+        from BTrees.UIBTree import differencePy
+        return differencePy(*args)
+
+    def builders(self):
+        from BTrees.UIBTree import UIBTreePy
+        from BTrees.UIBTree import UIBucketPy
+        from BTrees.UIBTree import UITreeSetPy
+        from BTrees.UIBTree import UISetPy
+        return (UISetPy, UITreeSetPy,
+                makeBuilder(UIBTreePy), makeBuilder(UIBucketPy))
+
+
+class TestUIMultiUnion(UnsignedKeysMixin, MultiUnion, unittest.TestCase):
+
+    def multiunion(self, *args):
+        from BTrees.UIBTree import multiunion
+        return multiunion(*args)
+
+    def union(self, *args):
+        from BTrees.UIBTree import union
+        return union(*args)
+
+    def mkset(self, *args):
+        from BTrees.UIBTree import UISet as mkset
+        return mkset(*args)
+
+    def mktreeset(self, *args):
+        from BTrees.UIBTree import UITreeSet as mktreeset
+        return mktreeset(*args)
+
+    def mkbucket(self, *args):
+        from BTrees.UIBTree import UIBucket as mkbucket
+        return mkbucket(*args)
+
+    def mkbtree(self, *args):
+        from BTrees.UIBTree import UIBTree as mkbtree
+        return mkbtree(*args)
+
+
+class TestUIMultiUnionPy(UnsignedKeysMixin, MultiUnion, unittest.TestCase):
+
+    def multiunion(self, *args):
+        from BTrees.UIBTree import multiunionPy
+        return multiunionPy(*args)
+
+    def union(self, *args):
+        from BTrees.UIBTree import unionPy
+        return unionPy(*args)
+
+    def mkset(self, *args):
+        from BTrees.UIBTree import UISetPy as mkset
+        return mkset(*args)
+
+    def mktreeset(self, *args):
+        from BTrees.UIBTree import UITreeSetPy as mktreeset
+        return mktreeset(*args)
+
+    def mkbucket(self, *args):
+        from BTrees.UIBTree import UIBucketPy as mkbucket
+        return mkbucket(*args)
+
+    def mkbtree(self, *args):
+        from BTrees.UIBTree import UIBTreePy as mkbtree
+        return mkbtree(*args)
+
+
+class TestWeightedUI(UnsignedKeysMixin, Weighted, unittest.TestCase):
+
+    def weightedUnion(self):
+        from BTrees.UIBTree import weightedUnion
+        return weightedUnion
+
+    def weightedIntersection(self):
+        from BTrees.UIBTree import weightedIntersection
+        return weightedIntersection
+
+    def union(self):
+        from BTrees.UIBTree import union
+        return union
+
+    def intersection(self):
+        from BTrees.UIBTree import intersection
+        return intersection
+
+    def mkbucket(self, *args):
+        from BTrees.UIBTree import UIBucket as mkbucket
+        return mkbucket(*args)
+
+    def builders(self):
+        from BTrees.UIBTree import UIBTree
+        from BTrees.UIBTree import UIBucket
+        from BTrees.UIBTree import UITreeSet
+        from BTrees.UIBTree import UISet
+        return UIBucket, UIBTree, itemsToSet(UISet), itemsToSet(UITreeSet)
+
+
+class TestWeightedUIPy(Weighted, unittest.TestCase):
+
+    def weightedUnion(self):
+        from BTrees.UIBTree import weightedUnionPy
+        return weightedUnionPy
+
+    def weightedIntersection(self):
+        from BTrees.UIBTree import weightedIntersectionPy
+        return weightedIntersectionPy
+
+    def union(self):
+        from BTrees.UIBTree import unionPy
+        return unionPy
+
+    def intersection(self):
+        from BTrees.UIBTree import intersectionPy
+        return intersectionPy
+
+    def mkbucket(self, *args):
+        from BTrees.UIBTree import UIBucketPy as mkbucket
+        return mkbucket(*args)
+
+    def builders(self):
+        from BTrees.UIBTree import UIBTreePy
+        from BTrees.UIBTree import UIBucketPy
+        from BTrees.UIBTree import UITreeSetPy
+        from BTrees.UIBTree import UISetPy
+        return (UIBucketPy, UIBTreePy,
+                itemsToSet(UISetPy), itemsToSet(UITreeSetPy))
+
+
+class UIBTreeConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UIBTree import UIBTree
+        return UIBTree
+
+
+class UIBTreeConflictTestsPy(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UIBTree import UIBTreePy
+        return UIBTreePy
+
+
+class UIBucketConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UIBTree import UIBucket
+        return UIBucket
+
+
+class UIBucketConflictTestsPy(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UIBTree import UIBucketPy
+        return UIBucketPy
+
+
+class UITreeSetConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UIBTree import UITreeSet
+        return UITreeSet
+
+
+class UITreeSetConflictTestsPy(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UIBTree import UITreeSetPy
+        return UITreeSetPy
+
+
+class UISetConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UIBTree import UISet
+        return UISet
+
+
+class UISetConflictTestsPy(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UIBTree import UISetPy
+        return UISetPy
+
+
+class UIModuleTest(ModuleTest, unittest.TestCase):
+
+    prefix = 'UI'
+
+    def _getModule(self):
+        import BTrees
+        return BTrees.UIBTree
+    def _getInterface(self):
+        import BTrees.Interfaces
+        return BTrees.Interfaces.IUnsignedIntegerBTreeModule
+
+
+
+def test_suite():
+    return unittest.TestSuite((
+        unittest.makeSuite(UIBTreeInternalKeyTest),
+        unittest.makeSuite(UIBTreePyInternalKeyTest),
+        unittest.makeSuite(UITreeSetInternalKeyTest),
+        unittest.makeSuite(UITreeSetPyInternalKeyTest),
+        unittest.makeSuite(UIBucketTest),
+        unittest.makeSuite(UIBucketPyTest),
+        unittest.makeSuite(UITreeSetTest),
+        unittest.makeSuite(UITreeSetPyTest),
+        unittest.makeSuite(UISetTest),
+        unittest.makeSuite(UISetPyTest),
+        unittest.makeSuite(UIBTreeTest),
+        unittest.makeSuite(UIBTreeTestPy),
+        unittest.makeSuite(TestUIBTrees),
+        unittest.makeSuite(TestUIBTreesPy),
+        unittest.makeSuite(TestUISets),
+        unittest.makeSuite(TestUISetsPy),
+        unittest.makeSuite(TestUITreeSets),
+        unittest.makeSuite(TestUITreeSetsPy),
+        unittest.makeSuite(TestUIMultiUnion),
+        unittest.makeSuite(TestUIMultiUnionPy),
+        unittest.makeSuite(PureUI),
+        unittest.makeSuite(PureUIPy),
+        unittest.makeSuite(TestWeightedUI),
+        unittest.makeSuite(TestWeightedUIPy),
+        unittest.makeSuite(UIBTreeConflictTests),
+        unittest.makeSuite(UIBTreeConflictTestsPy),
+        unittest.makeSuite(UIBucketConflictTests),
+        unittest.makeSuite(UIBucketConflictTestsPy),
+        unittest.makeSuite(UITreeSetConflictTests),
+        unittest.makeSuite(UITreeSetConflictTestsPy),
+        unittest.makeSuite(UISetConflictTests),
+        unittest.makeSuite(UISetConflictTestsPy),
+        unittest.makeSuite(UIModuleTest),
+    ))

BTrees/tests/test_UOBTree.py

+##############################################################################
+#
+# Copyright (c) 2001-2012 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 .common import UnsignedKeysBTreeTests as BTreeTests
+from .common import UnsignedExtendedSetTests as ExtendedSetTests
+from .common import I_SetsBase
+from .common import InternalKeysMappingTest
+from .common import InternalKeysSetTest
+from .common import UnsignedKeysMappingBase as MappingBase
+from .common import UnsignedKeysMappingConflictTestBase as MappingConflictTestBase
+from .common import ModuleTest
+from .common import MultiUnion
+from .common import UnsignedNormalSetTests as NormalSetTests
+from .common import UnsignedSetConflictTestBase as SetConflictTestBase
+from .common import SetResult
+from .common import TypeTest
+from .common import TestLongIntKeys
+from .common import makeBuilder
+from .common import UnsignedKeysMixin
+from .common import UnsignedError
+from BTrees.UOBTree import using64bits #XXX Ugly, but unavoidable
+
+# pylint:disable=no-name-in-module,arguments-differ
+
+class UOBTreeInternalKeyTest(InternalKeysMappingTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UOBTree import UOBTree
+        return UOBTree
+
+
+class UOBTreePyInternalKeyTest(InternalKeysMappingTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UOBTree import UOBTreePy
+        return UOBTreePy
+
+
+class UOTreeSetInternalKeyTest(InternalKeysSetTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UOBTree import UOTreeSet
+        return UOTreeSet
+
+
+class UOTreeSetPyInternalKeyTest(InternalKeysSetTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UOBTree import UOTreeSetPy
+        return UOTreeSetPy
+
+
+class UOBucketTest(MappingBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UOBTree import UOBucket
+        return UOBucket
+
+
+class UOBucketPyTest(MappingBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UOBTree import UOBucketPy
+        return UOBucketPy
+
+
+class UOTreeSetTest(NormalSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UOBTree import UOTreeSet
+        return UOTreeSet
+
+
+class UOTreeSetPyTest(NormalSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UOBTree import UOTreeSetPy
+        return UOTreeSetPy
+
+
+class UOSetTest(ExtendedSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UOBTree import UOSet
+        return UOSet
+
+
+class UOSetPyTest(ExtendedSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UOBTree import UOSetPy
+        return UOSetPy
+
+
+class UOBTreeTest(BTreeTests, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UOBTree import UOBTree
+        return UOBTree()
+
+
+class UOBTreePyTest(BTreeTests, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UOBTree import UOBTreePy
+        return UOBTreePy()
+
+
+if using64bits:
+
+
+    class UOBTreeTest(BTreeTests, TestLongIntKeys, unittest.TestCase):
+
+        def _makeOne(self):
+            from BTrees.UOBTree import UOBTree
+            return UOBTree()
+
+
+    class UOBTreePyTest(BTreeTests, TestLongIntKeys, unittest.TestCase):
+
+        def _makeOne(self):
+            from BTrees.UOBTree import UOBTreePy
+            return UOBTreePy()
+
+
+class _TestUOBTreesBase(TypeTest):
+
+    def _stringraises(self):
+        self._makeOne()['c'] = 1
+
+    def _floatraises(self):
+        self._makeOne()[2.5] = 1
+
+    def _noneraises(self):
+        self._makeOne()[None] = 1
+
+    def testStringAllowedInContains(self):
+        self.assertFalse('key' in self._makeOne())
+
+    def testStringKeyRaisesKeyErrorWhenMissing(self):
+        self.assertRaises(KeyError, self._makeOne().__getitem__, 'key')
+
+    def testStringKeyReturnsDefaultFromGetWhenMissing(self):
+        self.assertEqual(self._makeOne().get('key', 42), 42)
+
+class TestUOBTrees(_TestUOBTreesBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UOBTree import UOBTree
+        return UOBTree()
+
+
+class TestUOBTreesPy(_TestUOBTreesBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UOBTree import UOBTreePy
+        return UOBTreePy()
+
+
+class TestUOSets(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UOBTree import UOSet
+        return UOSet()
+
+
+class TestUOSetsPy(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UOBTree import UOSetPy
+        return UOSetPy()
+
+
+class TestUOTreeSets(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UOBTree import UOTreeSet
+        return UOTreeSet()
+
+
+class TestUOTreeSetsPy(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UOBTree import UOTreeSetPy
+        return UOTreeSetPy()
+
+
+class PureUO(SetResult, unittest.TestCase):
+
+    def union(self, *args):
+        from BTrees.UOBTree import union
+        return union(*args)
+
+    def intersection(self, *args):
+        from BTrees.UOBTree import intersection
+        return intersection(*args)
+
+    def difference(self, *args):
+        from BTrees.UOBTree import difference
+        return difference(*args)
+
+    def builders(self):
+        from BTrees.UOBTree import UOBTree
+        from BTrees.UOBTree import UOBucket
+        from BTrees.UOBTree import UOTreeSet
+        from BTrees.UOBTree import UOSet
+        return UOSet, UOTreeSet, makeBuilder(UOBTree), makeBuilder(UOBucket)
+
+
+class PureUOPy(SetResult, unittest.TestCase):
+
+    def union(self, *args):
+        from BTrees.UOBTree import unionPy
+        return unionPy(*args)
+
+    def intersection(self, *args):
+        from BTrees.UOBTree import intersectionPy
+        return intersectionPy(*args)
+
+    def difference(self, *args):
+        from BTrees.UOBTree import differencePy
+        return differencePy(*args)
+
+    def builders(self):
+        from BTrees.UOBTree import UOBTreePy
+        from BTrees.UOBTree import UOBucketPy
+        from BTrees.UOBTree import UOTreeSetPy
+        from BTrees.UOBTree import UOSetPy
+        return (UOSetPy, UOTreeSetPy,
+                makeBuilder(UOBTreePy), makeBuilder(UOBucketPy))
+
+
+class TestUOMultiUnion(UnsignedKeysMixin, MultiUnion, unittest.TestCase):
+
+    def multiunion(self, *args):
+        from BTrees.UOBTree import multiunion
+        return multiunion(*args)
+
+    def union(self, *args):
+        from BTrees.UOBTree import union
+        return union(*args)
+
+    def mkset(self, *args):
+        from BTrees.UOBTree import UOSet as mkset
+        return mkset(*args)
+
+    def mktreeset(self, *args):
+        from BTrees.UOBTree import UOTreeSet as mktreeset
+        return mktreeset(*args)
+
+    def mkbucket(self, *args):
+        from BTrees.UOBTree import UOBucket as mkbucket
+        return mkbucket(*args)
+
+    def mkbtree(self, *args):
+        from BTrees.UOBTree import UOBTree as mkbtree
+        return mkbtree(*args)
+
+
+class TestUOMultiUnionPy(UnsignedKeysMixin, MultiUnion, unittest.TestCase):
+
+    def multiunion(self, *args):
+        from BTrees.UOBTree import multiunionPy
+        return multiunionPy(*args)
+
+    def union(self, *args):
+        from BTrees.UOBTree import unionPy
+        return unionPy(*args)
+
+    def mkset(self, *args):
+        from BTrees.UOBTree import UOSetPy as mkset
+        return mkset(*args)
+
+    def mktreeset(self, *args):
+        from BTrees.UOBTree import UOTreeSetPy as mktreeset
+        return mktreeset(*args)
+
+    def mkbucket(self, *args):
+        from BTrees.UOBTree import UOBucketPy as mkbucket
+        return mkbucket(*args)
+
+    def mkbtree(self, *args):
+        from BTrees.UOBTree import UOBTreePy as mkbtree
+        return mkbtree(*args)
+
+
+class UOBTreeConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UOBTree import UOBTree
+        return UOBTree
+
+
+class UOBTreeConflictTestsPy(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UOBTree import UOBTreePy
+        return UOBTreePy
+
+
+class UOBucketConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UOBTree import UOBucket
+        return UOBucket
+
+
+class UOBucketConflictTestsPy(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UOBTree import UOBucketPy
+        return UOBucketPy
+
+
+class UOTreeSetConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UOBTree import UOTreeSet
+        return UOTreeSet
+
+
+class UOTreeSetConflictTestsPy(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UOBTree import UOTreeSetPy
+        return UOTreeSetPy
+
+
+class UOSetConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UOBTree import UOSet
+        return UOSet
+
+
+class UOSetConflictTestsPy(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UOBTree import UOSetPy
+        return UOSetPy
+
+
+class UOModuleTest(ModuleTest, unittest.TestCase):
+
+    prefix = 'UO'
+
+    def _getModule(self):
+        import BTrees
+        return BTrees.UOBTree
+
+    def _getInterface(self):
+        import BTrees.Interfaces
+        return BTrees.Interfaces.IUnsignedObjectBTreeModule
+
+    def test_weightedUnion_not_present(self):
+        try:
+            from BTrees.UOBTree import weightedUnion
+        except ImportError:
+            pass
+        else:
+            self.fail("UOBTree shouldn't have weightedUnion")
+
+    def test_weightedIntersection_not_present(self):
+        try:
+            from BTrees.UOBTree import weightedIntersection
+        except ImportError:
+            pass
+        else:
+            self.fail("UOBTree shouldn't have weightedIntersection")
+
+
+def test_suite():
+    return unittest.TestSuite((
+        unittest.makeSuite(UOBTreeInternalKeyTest),
+        unittest.makeSuite(UOBTreePyInternalKeyTest),
+        unittest.makeSuite(UOTreeSetInternalKeyTest),
+        unittest.makeSuite(UOTreeSetPyInternalKeyTest),
+        unittest.makeSuite(UOBucketTest),
+        unittest.makeSuite(UOBucketPyTest),
+        unittest.makeSuite(UOTreeSetTest),
+        unittest.makeSuite(UOTreeSetPyTest),
+        unittest.makeSuite(UOSetTest),
+        unittest.makeSuite(UOSetPyTest),
+        unittest.makeSuite(UOBTreeTest),
+        unittest.makeSuite(UOBTreePyTest),
+        unittest.makeSuite(TestUOBTrees),
+        unittest.makeSuite(TestUOBTreesPy),
+        unittest.makeSuite(TestUOSets),
+        unittest.makeSuite(TestUOSetsPy),
+        unittest.makeSuite(TestUOTreeSets),
+        unittest.makeSuite(TestUOTreeSetsPy),
+        unittest.makeSuite(TestUOMultiUnion),
+        unittest.makeSuite(TestUOMultiUnionPy),
+        unittest.makeSuite(PureUO),
+        unittest.makeSuite(PureUOPy),
+        unittest.makeSuite(UOBTreeConflictTests),
+        unittest.makeSuite(UOBTreeConflictTestsPy),
+        unittest.makeSuite(UOBucketConflictTests),
+        unittest.makeSuite(UOBucketConflictTestsPy),
+        unittest.makeSuite(UOTreeSetConflictTests),
+        unittest.makeSuite(UOTreeSetConflictTestsPy),
+        unittest.makeSuite(UOSetConflictTests),
+        unittest.makeSuite(UOSetConflictTestsPy),
+        unittest.makeSuite(UOModuleTest),
+    ))

BTrees/tests/test_UUBTree.py

+##############################################################################
+#
+# Copyright (c) 2001-2012 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 .common import UnsignedBTreeTests as BTreeTests
+from .common import UnsignedExtendedSetTests as ExtendedSetTests
+from .common import I_SetsBase
+from .common import InternalKeysMappingTest
+from .common import InternalKeysSetTest
+from .common import UnsignedMappingBase as MappingBase
+from .common import UnsignedMappingConflictTestBase as MappingConflictTestBase
+from .common import ModuleTest
+from .common import MultiUnion
+from .common import UnsignedNormalSetTests as NormalSetTests
+from .common import UnsignedSetConflictTestBase as SetConflictTestBase
+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 .common import UnsignedMixin
+from .common import UnsignedError
+from BTrees.UUBTree import using64bits #XXX Ugly, but unavoidable
+
+
+class UUBTreeInternalKeyTest(InternalKeysMappingTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UUBTree import UUBTree
+        return UUBTree
+
+
+class UUBTreePyInternalKeyTest(InternalKeysMappingTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UUBTree import UUBTreePy
+        return UUBTreePy
+
+
+class UUTreeSetInternalKeyTest(InternalKeysSetTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UUBTree import UUTreeSet
+        return UUTreeSet
+
+
+class UUTreeSetPyInternalKeyTest(InternalKeysSetTest, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UUBTree import UUTreeSetPy
+        return UUTreeSetPy
+
+
+class UUBucketTest(MappingBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UUBTree import UUBucket
+        return UUBucket
+
+
+class UUBucketPyTest(MappingBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UUBTree import UUBucketPy
+        return UUBucketPy
+
+
+class UUTreeSetTest(NormalSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UUBTree import UUTreeSet
+        return UUTreeSet
+
+
+class UUTreeSetPyTest(NormalSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UUBTree import UUTreeSetPy
+        return UUTreeSetPy
+
+
+class UUSetTest(ExtendedSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UUBTree import UUSet
+        return UUSet
+
+
+class UUSetPyTest(ExtendedSetTests, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UUBTree import UUSetPy
+        return UUSetPy
+
+
+class _UUBTreeTestBase(BTreeTests):
+
+    def testUUBTreeOverflow(self):
+        good = set()
+        b = self._makeOne()
+
+        def trial(i):
+            i = int(i)
+            try:
+                b[i] = 0
+            except UnsignedError:
+                with self.assertRaises(UnsignedError):
+                    b[0] = i
+            else:
+                good.add(i)
+                b[0] = i
+                self.assertEqual(b[0], i)
+
+        for i in range((1<<31) - 3, (1<<31) + 3):
+            __traceback_info__ = i
+            trial(i)
+            trial(-i)
+
+        del b[0]
+        self.assertEqual(sorted(good), sorted(b))
+
+
+class UUBTreeTest(_UUBTreeTestBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UUBTree import UUBTree
+        return UUBTree()
+
+
+class UUBTreeTestPy(_UUBTreeTestBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UUBTree import UUBTreePy
+        return UUBTreePy()
+
+
+if using64bits:
+
+    class UUBTreeTest(BTreeTests, TestLongIntKeys, TestLongIntValues,
+                      unittest.TestCase):
+
+        def _makeOne(self):
+            from BTrees.UUBTree import UUBTree
+            return UUBTree()
+
+        def getTwoValues(self):
+            return 1, 2
+
+    class UUBTreeTestPy(BTreeTests, TestLongIntKeys, TestLongIntValues,
+                        unittest.TestCase):
+
+        def _makeOne(self):
+            from BTrees.UUBTree import UUBTreePy
+            return UUBTreePy()
+
+        def getTwoValues(self):
+            return 1, 2
+
+
+class _TestUUBTreesBase(object):
+
+    def testNonIntegerKeyRaises(self):
+        self.assertRaises(TypeError, self._stringraiseskey)
+        self.assertRaises(TypeError, self._floatraiseskey)
+        self.assertRaises(TypeError, self._noneraiseskey)
+
+    def testNonIntegerValueRaises(self):
+        self.assertRaises(TypeError, self._stringraisesvalue)
+        self.assertRaises(TypeError, self._floatraisesvalue)
+        self.assertRaises(TypeError, self._noneraisesvalue)
+
+    def _stringraiseskey(self):
+        self._makeOne()['c'] = 1
+
+    def _floatraiseskey(self):
+        self._makeOne()[2.5] = 1
+
+    def _noneraiseskey(self):
+        self._makeOne()[None] = 1
+
+    def _stringraisesvalue(self):
+        self._makeOne()[1] = 'c'
+
+    def _floatraisesvalue(self):
+        self._makeOne()[1] = 1.4
+
+    def _noneraisesvalue(self):
+        self._makeOne()[1] = None
+
+
+class TestUUBTrees(_TestUUBTreesBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UUBTree import UUBTree
+        return UUBTree()
+
+
+class TestUUBTreesPy(_TestUUBTreesBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UUBTree import UUBTreePy
+        return UUBTreePy()
+
+
+class TestUUSets(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UUBTree import UUSet
+        return UUSet()
+
+
+class TestUUSetsPy(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UUBTree import UUSetPy
+        return UUSetPy()
+
+
+class TestUUTreeSets(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UUBTree import UUTreeSet
+        return UUTreeSet()
+
+
+class TestUUTreeSetsPy(I_SetsBase, unittest.TestCase):
+
+    def _makeOne(self):
+        from BTrees.UUBTree import UUTreeSetPy
+        return UUTreeSetPy()
+
+
+class PureUU(SetResult, unittest.TestCase):
+
+    def union(self, *args):
+        from BTrees.UUBTree import union
+        return union(*args)
+
+    def intersection(self, *args):
+        from BTrees.UUBTree import intersection
+        return intersection(*args)
+
+    def difference(self, *args):
+        from BTrees.UUBTree import difference
+        return difference(*args)
+
+    def builders(self):
+        from BTrees.UUBTree import UUBTree
+        from BTrees.UUBTree import UUBucket
+        from BTrees.UUBTree import UUTreeSet
+        from BTrees.UUBTree import UUSet
+        return UUSet, UUTreeSet, makeBuilder(UUBTree), makeBuilder(UUBucket)
+
+
+class PureUUPy(SetResult, unittest.TestCase):
+
+    def union(self, *args):
+        from BTrees.UUBTree import unionPy
+        return unionPy(*args)
+
+    def intersection(self, *args):
+        from BTrees.UUBTree import intersectionPy
+        return intersectionPy(*args)
+
+    def difference(self, *args):
+        from BTrees.UUBTree import differencePy
+        return differencePy(*args)
+
+    def builders(self):
+        from BTrees.UUBTree import UUBTreePy
+        from BTrees.UUBTree import UUBucketPy
+        from BTrees.UUBTree import UUTreeSetPy
+        from BTrees.UUBTree import UUSetPy
+        return (UUSetPy, UUTreeSetPy,
+                makeBuilder(UUBTreePy), makeBuilder(UUBucketPy))
+
+
+class TestUUMultiUnion(UnsignedMixin, MultiUnion, unittest.TestCase):
+
+    def multiunion(self, *args):
+        from BTrees.UUBTree import multiunion
+        return multiunion(*args)
+
+    def union(self, *args):
+        from BTrees.UUBTree import union
+        return union(*args)
+
+    def mkset(self, *args):
+        from BTrees.UUBTree import UUSet as mkset
+        return mkset(*args)
+
+    def mktreeset(self, *args):
+        from BTrees.UUBTree import UUTreeSet as mktreeset
+        return mktreeset(*args)
+
+    def mkbucket(self, *args):
+        from BTrees.UUBTree import UUBucket as mkbucket
+        return mkbucket(*args)
+
+    def mkbtree(self, *args):
+        from BTrees.UUBTree import UUBTree as mkbtree
+        return mkbtree(*args)
+
+
+class TestUUMultiUnionPy(UnsignedMixin, MultiUnion, unittest.TestCase):
+
+    def multiunion(self, *args):
+        from BTrees.UUBTree import multiunionPy
+        return multiunionPy(*args)
+
+    def union(self, *args):
+        from BTrees.UUBTree import unionPy
+        return unionPy(*args)
+
+    def mkset(self, *args):
+        from BTrees.UUBTree import UUSetPy as mkset
+        return mkset(*args)
+
+    def mktreeset(self, *args):
+        from BTrees.UUBTree import UUTreeSetPy as mktreeset
+        return mktreeset(*args)
+
+    def mkbucket(self, *args):
+        from BTrees.UUBTree import UUBucketPy as mkbucket
+        return mkbucket(*args)
+
+    def mkbtree(self, *args):
+        from BTrees.UUBTree import UUBTreePy as mkbtree
+        return mkbtree(*args)
+
+
+class TestWeightedUU(UnsignedMixin, Weighted, unittest.TestCase):
+
+    def weightedUnion(self):
+        from BTrees.UUBTree import weightedUnion
+        return weightedUnion
+
+    def weightedIntersection(self):
+        from BTrees.UUBTree import weightedIntersection
+        return weightedIntersection
+
+    def union(self):
+        from BTrees.UUBTree import union
+        return union
+
+    def intersection(self):
+        from BTrees.UUBTree import intersection
+        return intersection
+
+    def mkbucket(self, *args):
+        from BTrees.UUBTree import UUBucket as mkbucket
+        return mkbucket(*args)
+
+    def builders(self):
+        from BTrees.UUBTree import UUBTree
+        from BTrees.UUBTree import UUBucket
+        from BTrees.UUBTree import UUTreeSet
+        from BTrees.UUBTree import UUSet
+        return UUBucket, UUBTree, itemsToSet(UUSet), itemsToSet(UUTreeSet)
+
+
+class TestWeightedUUPy(UnsignedMixin, Weighted, unittest.TestCase):
+
+    def weightedUnion(self):
+        from BTrees.UUBTree import weightedUnionPy
+        return weightedUnionPy
+
+    def weightedIntersection(self):
+        from BTrees.UUBTree import weightedIntersectionPy
+        return weightedIntersectionPy
+
+    def union(self):
+        from BTrees.UUBTree import unionPy
+        return unionPy
+
+    def intersection(self):
+        from BTrees.UUBTree import intersectionPy
+        return intersectionPy
+
+    def mkbucket(self, *args):
+        from BTrees.UUBTree import UUBucketPy as mkbucket
+        return mkbucket(*args)
+
+    def builders(self):
+        from BTrees.UUBTree import UUBTreePy
+        from BTrees.UUBTree import UUBucketPy
+        from BTrees.UUBTree import UUTreeSetPy
+        from BTrees.UUBTree import UUSetPy
+        return (UUBucketPy, UUBTreePy,
+                itemsToSet(UUSetPy), itemsToSet(UUTreeSetPy))
+
+
+class UUBTreeConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UUBTree import UUBTree
+        return UUBTree
+
+
+class UUBTreeConflictTestsPy(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UUBTree import UUBTreePy
+        return UUBTreePy
+
+
+class UUBucketConflictTests(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UUBTree import UUBucket
+        return UUBucket
+
+
+class UUBucketConflictTestsPy(MappingConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UUBTree import UUBucketPy
+        return UUBucketPy
+
+
+class UUTreeSetConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UUBTree import UUTreeSet
+        return UUTreeSet
+
+
+class UUTreeSetConflictTestsPy(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UUBTree import UUTreeSetPy
+        return UUTreeSetPy
+
+
+class UUSetConflictTests(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UUBTree import UUSet
+        return UUSet
+
+
+class UUSetConflictTestsPy(SetConflictTestBase, unittest.TestCase):
+
+    def _getTargetClass(self):
+        from BTrees.UUBTree import UUSetPy
+        return UUSetPy
+
+
+class UUModuleTest(ModuleTest, unittest.TestCase):
+
+    prefix = 'UU'
+
+    def _getModule(self):
+        import BTrees
+        return BTrees.UUBTree
+    def _getInterface(self):
+        import BTrees.Interfaces
+        return BTrees.Interfaces.IUnsignedUnsignedBTreeModule
+
+
+
+def test_suite():
+    return unittest.TestSuite((
+        unittest.makeSuite(UUBTreeInternalKeyTest),
+        unittest.makeSuite(UUBTreePyInternalKeyTest),
+        unittest.makeSuite(UUTreeSetInternalKeyTest),
+        unittest.makeSuite(UUTreeSetPyInternalKeyTest),
+        unittest.makeSuite(UUBucketTest),
+        unittest.makeSuite(UUBucketPyTest),
+        unittest.makeSuite(UUTreeSetTest),
+        unittest.makeSuite(UUTreeSetPyTest),
+        unittest.makeSuite(UUSetTest),
+        unittest.makeSuite(UUSetPyTest),
+        unittest.makeSuite(UUBTreeTest),
+        unittest.makeSuite(UUBTreeTestPy),
+        unittest.makeSuite(TestUUBTrees),
+        unittest.makeSuite(TestUUBTreesPy),
+        unittest.makeSuite(TestUUSets),
+        unittest.makeSuite(TestUUSetsPy),
+        unittest.makeSuite(TestUUTreeSets),
+        unittest.makeSuite(TestUUTreeSetsPy),
+        unittest.makeSuite(TestUUMultiUnion),
+        unittest.makeSuite(TestUUMultiUnionPy),
+        unittest.makeSuite(PureUU),
+        unittest.makeSuite(PureUUPy),
+        unittest.makeSuite(TestWeightedUU),
+        unittest.makeSuite(TestWeightedUUPy),
+        unittest.makeSuite(UUBTreeConflictTests),
+        unittest.makeSuite(UUBTreeConflictTestsPy),
+        unittest.makeSuite(UUBucketConflictTests),
+        unittest.makeSuite(UUBucketConflictTestsPy),
+        unittest.makeSuite(UUTreeSetConflictTests),
+        unittest.makeSuite(UUTreeSetConflictTestsPy),
+        unittest.makeSuite(UUSetConflictTests),
+        unittest.makeSuite(UUSetConflictTestsPy),
+        unittest.makeSuite(UUModuleTest),
+    ))

BTrees/tests/test__base.py

@@ -2963,7 +2963,7 @@ class Test_helpers(unittest.TestCase):
     def test_to_long_w_overflow(self):
         from BTrees._base import to_long
         faux_self = object()
-        self.assertRaises(ValueError, to_long, faux_self, 2**64)
+        self.assertRaises(OverflowError, to_long, faux_self, 2**64)
 
     def test_to_long_w_invalid(self):
         from BTrees._base import to_long

CHANGES.rst

@@ -2,10 +2,13 @@
  BTrees Changelog
 ==================
 
-4.6.2 (unreleased)
+4.7.0 (unreleased)
 ==================
 
-- Nothing changed yet.
+- Add unsigned variants of the trees. These use the initial "U" for
+  32-bit data and "Q" for 64-bit data (for "quad", which is similar to
+  what the C ``printf`` function uses and the Python struct module
+  uses).
 
 - Fix the value for ``BTrees.OIBTree.using64bits`` when using the pure Python
   implementation (PyPy and when ``PURE_PYTHON`` is in the environment).

setup.py

@@ -104,9 +104,44 @@ base_btrees_depends = [
     "BTrees/sorters.c",
     ]
 
-FLAVORS = {"O": "object", "I": "int", "F": "float", 'L': 'int'}
+FLAVORS = {
+    "O": "object",
+    "F": "float",
+    "I": "int", # Signed 32-bit
+    "L": "int", # Signed 64-bit
+    "U": "int", # Unsigned 32-bit
+    "Q": "int"  # Unsigned 64-bit (from the printf "q" modifier for quad_t)
+}
 # XXX should 'fs' be in ZODB instead?
-FAMILIES = ("OO", "IO", "OI", "II", "IF", "fs", "LO", "OL", "LL", "LF")
+FAMILIES = (
+    # Signed 32-bit keys
+    "IO", # object value
+    "II", # self value
+    "IF", # float value
+    "IU", # opposite sign value
+    # Unsigned 32-bit keys
+    "UO", # object value
+    "UU", # self value
+    "UF", # float value
+    "UI", # opposite sign value
+    # Signed 64-bit keys
+    "LO", # object value
+    "LL", # self value
+    "LF", # float value
+    "LQ", # opposite sign value
+    # Unsigned 64-bit keys
+    "QO", # object value
+    "QQ", # self value
+    "QF", # float value
+    "QL", # opposite sign value
+    # Object keys
+    "OO", # object
+    "OI", # 32-bit signed
+    "OU", # 32-bit unsigned
+    "OL", # 64-bit signed
+    "OQ", # 64-bit unsigned
+    "fs",
+)
 
 KEY_H = "BTrees/%skeymacros.h"
 VALUE_H = "BTrees/%svaluemacros.h"