[Checkins] SVN: BTrees/branches/pure_python/ Remove mixins which obscured purpose.
Tres Seaver
cvs-admin at zope.org
Wed Nov 14 23:13:06 UTC 2012
Log message for revision 128294:
Remove mixins which obscured purpose.
Changed:
_U BTrees/branches/pure_python/
U BTrees/branches/pure_python/BTrees/_base.py
U BTrees/branches/pure_python/BTrees/tests/test__base.py
U BTrees/branches/pure_python/setup.cfg
-=-
Modified: BTrees/branches/pure_python/BTrees/_base.py
===================================================================
--- BTrees/branches/pure_python/BTrees/_base.py 2012-11-14 23:13:04 UTC (rev 128293)
+++ BTrees/branches/pure_python/BTrees/_base.py 2012-11-14 23:13:06 UTC (rev 128294)
@@ -18,14 +18,15 @@
from struct import unpack
from struct import error as struct_error
-import persistent
+from persistent import Persistent
-from BTrees.Interfaces import BTreesConflictError
+from .Interfaces import BTreesConflictError
+
_marker = object()
-class _Base(persistent.Persistent):
+class _Base(Persistent):
_key_type = list
@@ -183,24 +184,156 @@
return self
-class _SetBase(_Base):
+class Bucket(_BucketBase):
- #_next = None
- def add(self, key):
- return self._set(self._to_key(key))[0]
+ _value_type = list
+ _to_value = lambda x: x
+ VALUE_SAME_CHECK = False
- insert = add
+ def setdefault(self, key, value):
+ return self._set(self._to_key(key), self._to_value(value), True)[1]
- def remove(self, key):
- self._del(self._to_key(key))
+ def pop(self, key, default=_marker):
+ try:
+ return self._del(self._to_key(key))[1]
+ except KeyError:
+ if default is _marker:
+ raise
+ return default
def update(self, items):
- add = self.add
+ if hasattr(items, 'iteritems'):
+ items = items.iteritems()
+ elif hasattr(items, 'items'):
+ items = items.items()
+
+ set = self.__setitem__
for i in items:
- add(i)
+ set(*i)
+ def __setitem__(self, key, value):
+ # Enforce test that key has non-default comparison.
+ if ( getattr(key, '__lt__', None) is None and
+ getattr(key, '__cmp__', None) is None):
+ raise TypeError("Can't use default __cmp__")
+ self._set(self._to_key(key), self._to_value(value))
+
+ def __delitem__(self, key):
+ self._del(self._to_key(key))
+
+ def clear(self):
+ _BucketBase.clear(self)
+ self._values = self._value_type()
+
+ def get(self, key, default=None):
+ index = self._search(self._to_key(key))
+ if index < 0:
+ return default
+ return self._values[index]
+
+ def __getitem__(self, key):
+ index = self._search(self._to_key(key))
+ if index < 0:
+ raise KeyError(key)
+ return self._values[index]
+
+ def _set(self, key, value, ifunset=False):
+ """Set a value
+
+ Return: status, value
+
+ Status is:
+ None if no change
+ 0 if change, but not size change
+ 1 if change and size change
+ """
+ index = self._search(key)
+ if index >= 0:
+ if (ifunset or
+ self.VALUE_SAME_CHECK and value == self._values[index]
+ ):
+ return None, self._values[index]
+ self._p_changed = True
+ self._values[index] = value
+ return 0, value
+ else:
+ self._p_changed = True
+ index = -index - 1
+ self._keys.insert(index, key)
+ self._values.insert(index, value)
+ return 1, value
+
+ def _del(self, key):
+ index = self._search(key)
+ if index >= 0:
+ self._p_changed = True
+ del self._keys[index]
+ return 0, self._values.pop(index)
+ raise KeyError(key)
+
+ def _split(self, index=-1):
+ if index < 0 or index >= len(self._keys):
+ index = len(self._keys) / 2
+ new_instance = self.__class__()
+ new_instance._keys = self._keys[index:]
+ new_instance._values = self._values[index:]
+ del self._keys[index:]
+ del self._values[index:]
+ new_instance._next = self._next
+ self._next = new_instance
+ return new_instance
+
+ def values(self, *args, **kw):
+ start, end = self._range(*args, **kw)
+ return self._values[start:end]
+
+ def itervalues(self, *args, **kw):
+ values = self._values
+ return (values[i] for i in xrange(*self._range(*args, **kw)))
+
+ def items(self, *args, **kw):
+ keys = self._keys
+ values = self._values
+ return [(keys[i], values[i])
+ for i in xrange(*self._range(*args, **kw))]
+
+ def iteritems(self, *args, **kw):
+ keys = self._keys
+ values = self._values
+ return ((keys[i], values[i])
+ for i in xrange(*self._range(*args, **kw)))
+
+ def __getstate__(self):
+ keys = self._keys
+ values = self._values
+ data = []
+ for i in range(len(keys)):
+ data.append(keys[i])
+ data.append(values[i])
+ data = tuple(data)
+
+ if self._next:
+ return data, self._next
+ return (data, )
+
+ def __setstate__(self, state):
+ if not isinstance(state[0], tuple):
+ raise TypeError("tuple required for first state element")
+
+ self.clear()
+ if len(state) == 2:
+ state, self._next = state
+ else:
+ self._next = None
+ state = state[0]
+
+ keys = self._keys
+ values = self._values
+ for i in range(0, len(state), 2):
+ keys.append(state[i])
+ values.append(state[i+1])
+
def _p_resolveConflict(self, s_old, s_com, s_new):
-
b_old = self.__class__()
if s_old is not None:
b_old.__setstate__(s_old)
@@ -210,12 +343,11 @@
b_new = self.__class__()
if s_new is not None:
b_new.__setstate__(s_new)
-
if (b_com._next != b_old._next or
- b_new._next != b_old._next): # conflict: com or new changed _next
+ b_new._next != b_old._next):
raise BTreesConflictError(-1, -1, -1, 0)
- if not b_com or not b_new: # conflict: com or new empty
+ if not b_com or not b_new:
raise BTreesConflictError(-1, -1, -1, 12)
i_old = _SetIteration(b_old, True)
@@ -230,19 +362,26 @@
def merge_output(it):
result._keys.append(it.key)
+ result._values.append(it.value)
it.advance()
while i_old.active and i_com.active and i_new.active:
cmpOC = cmp(i_old.key, i_com.key)
cmpON = cmp(i_old.key, i_new.key)
- if cmpOC == 0:
- if cmpON == 0: # all match
- merge_output(i_old)
+ if cmpOC==0:
+ if cmpON==0:
+ if i_com.value == i_old.value:
+ result[i_old.key] = i_new.value
+ elif i_new.value == i_old.value:
+ result[i_old.key] = i_com.value
+ else:
+ raise merge_error(1)
+ i_old.advance()
i_com.advance()
i_new.advance()
- elif cmpON > 0: # insert in new
+ elif (cmpON > 0): # insert in new
merge_output(i_new)
- else: # deleted new
+ elif i_old.value == i_com.value: # deleted new
if i_new.position == 1:
# Deleted the first item. This will modify the
# parent node, so we don't know if merging will be
@@ -250,10 +389,12 @@
raise merge_error(13)
i_old.advance()
i_com.advance()
+ else:
+ raise merge_error(2)
elif cmpON == 0:
if cmpOC > 0: # insert committed
merge_output(i_com)
- else: # delete committed
+ elif i_old.value == i_new.value: # delete committed
if i_com.position == 1:
# Deleted the first item. This will modify the
# parent node, so we don't know if merging will be
@@ -261,9 +402,11 @@
raise merge_error(13)
i_old.advance()
i_new.advance()
- else: # both com and new keys changed
+ else:
+ raise merge_error(3)
+ else: # both keys changed
cmpCN = cmp(i_com.key, i_new.key)
- if cmpCN == 0: # both inserted same key
+ if cmpCN == 0:
raise merge_error(4)
if cmpOC > 0: # insert committed
if cmpCN > 0: # insert i_new first
@@ -272,13 +415,13 @@
merge_output(i_com)
elif cmpON > 0: # insert i_new
merge_output(i_new)
- else: # both com and new deleted same key
- raise merge_error(5)
+ else:
+ raise merge_error(5) # both deleted same key
while i_com.active and i_new.active: # new inserts
cmpCN = cmp(i_com.key, i_new.key)
- if cmpCN == 0: # dueling insert
- raise merge_error(6)
+ if cmpCN == 0:
+ raise merge_error(6) # dueling insert
if cmpCN > 0: # insert new
merge_output(i_new)
else: # insert committed
@@ -288,7 +431,7 @@
cmpOC = cmp(i_old.key, i_com.key)
if cmpOC > 0: # insert committed
merge_output(i_com)
- elif cmpOC == 0: # del in new
+ elif cmpOC == 0 and (i_old.value == i_com.value): # del in new
i_old.advance()
i_com.advance()
else: # dueling deletes or delete and change
@@ -299,7 +442,8 @@
cmpON = cmp(i_old.key, i_new.key)
if cmpON > 0: # insert new
merge_output(i_new)
- elif cmpON == 0: # deleted in committed
+ elif cmpON == 0 and (i_old.value == i_new.value):
+ # deleted in committed
i_old.advance()
i_new.advance()
else: # dueling deletes or delete and change
@@ -317,47 +461,78 @@
if len(result._keys) == 0:
# If the output bucket is empty, conflict resolution doesn't have
# enough info to unlink it from its containing BTree correctly.
- assert 0, "CAN'T GET HERE"
raise merge_error(10)
result._next = b_old._next
return result.__getstate__()
-class _MappingBase(_Base):
+class Set(_BucketBase):
- def setdefault(self, key, value):
- return self._set(self._to_key(key), self._to_value(value), True)[1]
+ def add(self, key):
+ return self._set(self._to_key(key))[0]
- def pop(self, key, default=_marker):
- try:
- return self._del(self._to_key(key))[1]
- except KeyError:
- if default is _marker:
- raise
- return default
+ insert = add
+ def remove(self, key):
+ self._del(self._to_key(key))
+
def update(self, items):
- if hasattr(items, 'iteritems'):
- items = items.iteritems()
- elif hasattr(items, 'items'):
- items = items.items()
-
- set = self.__setitem__
+ add = self.add
for i in items:
- set(*i)
+ add(i)
- def __setitem__(self, key, value):
- # Enforce test that key has non-default comparison.
- if ( getattr(key, '__lt__', None) is None and
- getattr(key, '__cmp__', None) is None):
- raise TypeError("Can't use default __cmp__")
- self._set(self._to_key(key), self._to_value(value))
+ def __getstate__(self):
+ data = tuple(self._keys)
+ if self._next:
+ return data, self._next
+ return (data, )
- def __delitem__(self, key):
- self._del(self._to_key(key))
+ def __setstate__(self, state):
+ if not isinstance(state[0], tuple):
+ raise TypeError('tuple required for first state element')
+ self.clear()
+ if len(state) == 2:
+ state, self._next = state
+ else:
+ self._next = None
+ state = state[0]
+
+ self._keys.extend(state)
+
+
+ def _set(self, key, value=None, ifunset=False):
+ index = self._search(key)
+ if index < 0:
+ index = -index - 1
+ self._keys.insert(index, key)
+ return True, None
+ return False, None
+
+ def _del(self, key):
+ index = self._search(key)
+ if index >= 0:
+ self._p_changed = True
+ del self._keys[index]
+ return 0, 0
+ raise KeyError(key)
+
+ def __getitem__(self, i):
+ return self._keys[i]
+
+ def _split(self, index=-1):
+ if index < 0 or index >= len(self._keys):
+ index = len(self._keys) / 2
+ new_instance = self.__class__()
+ new_instance._keys = self._keys[index:]
+ del self._keys[index:]
+ new_instance._next = self._next
+ self._next = new_instance
+ return new_instance
+
def _p_resolveConflict(self, s_old, s_com, s_new):
+
b_old = self.__class__()
if s_old is not None:
b_old.__setstate__(s_old)
@@ -367,11 +542,12 @@
b_new = self.__class__()
if s_new is not None:
b_new.__setstate__(s_new)
+
if (b_com._next != b_old._next or
- b_new._next != b_old._next):
+ b_new._next != b_old._next): # conflict: com or new changed _next
raise BTreesConflictError(-1, -1, -1, 0)
- if not b_com or not b_new:
+ if not b_com or not b_new: # conflict: com or new empty
raise BTreesConflictError(-1, -1, -1, 12)
i_old = _SetIteration(b_old, True)
@@ -386,26 +562,19 @@
def merge_output(it):
result._keys.append(it.key)
- result._values.append(it.value)
it.advance()
while i_old.active and i_com.active and i_new.active:
cmpOC = cmp(i_old.key, i_com.key)
cmpON = cmp(i_old.key, i_new.key)
- if cmpOC==0:
- if cmpON==0:
- if i_com.value == i_old.value:
- result[i_old.key] = i_new.value
- elif i_new.value == i_old.value:
- result[i_old.key] = i_com.value
- else:
- raise merge_error(1)
- i_old.advance()
+ if cmpOC == 0:
+ if cmpON == 0: # all match
+ merge_output(i_old)
i_com.advance()
i_new.advance()
- elif (cmpON > 0): # insert in new
+ elif cmpON > 0: # insert in new
merge_output(i_new)
- elif i_old.value == i_com.value: # deleted new
+ else: # deleted new
if i_new.position == 1:
# Deleted the first item. This will modify the
# parent node, so we don't know if merging will be
@@ -413,12 +582,10 @@
raise merge_error(13)
i_old.advance()
i_com.advance()
- else:
- raise merge_error(2)
elif cmpON == 0:
if cmpOC > 0: # insert committed
merge_output(i_com)
- elif i_old.value == i_new.value: # delete committed
+ else: # delete committed
if i_com.position == 1:
# Deleted the first item. This will modify the
# parent node, so we don't know if merging will be
@@ -426,11 +593,9 @@
raise merge_error(13)
i_old.advance()
i_new.advance()
- else:
- raise merge_error(3)
- else: # both keys changed
+ else: # both com and new keys changed
cmpCN = cmp(i_com.key, i_new.key)
- if cmpCN == 0:
+ if cmpCN == 0: # both inserted same key
raise merge_error(4)
if cmpOC > 0: # insert committed
if cmpCN > 0: # insert i_new first
@@ -439,13 +604,13 @@
merge_output(i_com)
elif cmpON > 0: # insert i_new
merge_output(i_new)
- else:
- raise merge_error(5) # both deleted same key
+ else: # both com and new deleted same key
+ raise merge_error(5)
while i_com.active and i_new.active: # new inserts
cmpCN = cmp(i_com.key, i_new.key)
- if cmpCN == 0:
- raise merge_error(6) # dueling insert
+ if cmpCN == 0: # dueling insert
+ raise merge_error(6)
if cmpCN > 0: # insert new
merge_output(i_new)
else: # insert committed
@@ -455,7 +620,7 @@
cmpOC = cmp(i_old.key, i_com.key)
if cmpOC > 0: # insert committed
merge_output(i_com)
- elif cmpOC == 0 and (i_old.value == i_com.value): # del in new
+ elif cmpOC == 0: # del in new
i_old.advance()
i_com.advance()
else: # dueling deletes or delete and change
@@ -466,8 +631,7 @@
cmpON = cmp(i_old.key, i_new.key)
if cmpON > 0: # insert new
merge_output(i_new)
- elif cmpON == 0 and (i_old.value == i_new.value):
- # deleted in committed
+ elif cmpON == 0: # deleted in committed
i_old.advance()
i_new.advance()
else: # dueling deletes or delete and change
@@ -485,194 +649,55 @@
if len(result._keys) == 0:
# If the output bucket is empty, conflict resolution doesn't have
# enough info to unlink it from its containing BTree correctly.
+ assert 0, "CAN'T GET HERE"
raise merge_error(10)
result._next = b_old._next
return result.__getstate__()
-class Bucket(_MappingBase, _BucketBase):
+class _TreeItem(object):
- _value_type = list
- _to_value = lambda x: x
- VALUE_SAME_CHECK = False
+ __slots__ = 'key', 'child'
- def clear(self):
- _BucketBase.clear(self)
- self._values = self._value_type()
+ def __init__(self, key, child):
+ self.key = key
+ self.child = child
- def get(self, key, default=None):
- index = self._search(self._to_key(key))
- if index < 0:
- return default
- return self._values[index]
- def __getitem__(self, key):
- index = self._search(self._to_key(key))
- if index < 0:
- raise KeyError(key)
- return self._values[index]
+class _Tree(_Base):
- def _set(self, key, value, ifunset=False):
- """Set a value
+ def setdefault(self, key, value):
+ return self._set(self._to_key(key), self._to_value(value), True)[1]
- Return: status, value
+ def pop(self, key, default=_marker):
+ try:
+ return self._del(self._to_key(key))[1]
+ except KeyError:
+ if default is _marker:
+ raise
+ return default
- Status is:
- None if no change
- 0 if change, but not size change
- 1 if change and size change
- """
- index = self._search(key)
- if index >= 0:
- if (ifunset or
- self.VALUE_SAME_CHECK and value == self._values[index]
- ):
- return None, self._values[index]
- self._p_changed = True
- self._values[index] = value
- return 0, value
- else:
- self._p_changed = True
- index = -index - 1
- self._keys.insert(index, key)
- self._values.insert(index, value)
- return 1, value
+ def update(self, items):
+ if hasattr(items, 'iteritems'):
+ items = items.iteritems()
+ elif hasattr(items, 'items'):
+ items = items.items()
- def _del(self, key):
- index = self._search(key)
- if index >= 0:
- self._p_changed = True
- del self._keys[index]
- return 0, self._values.pop(index)
- raise KeyError(key)
+ set = self.__setitem__
+ for i in items:
+ set(*i)
- def _split(self, index=-1):
- if index < 0 or index >= len(self._keys):
- index = len(self._keys) / 2
- new_instance = self.__class__()
- new_instance._keys = self._keys[index:]
- new_instance._values = self._values[index:]
- del self._keys[index:]
- del self._values[index:]
- new_instance._next = self._next
- self._next = new_instance
- return new_instance
+ def __setitem__(self, key, value):
+ # Enforce test that key has non-default comparison.
+ if ( getattr(key, '__lt__', None) is None and
+ getattr(key, '__cmp__', None) is None):
+ raise TypeError("Can't use default __cmp__")
+ self._set(self._to_key(key), self._to_value(value))
- def values(self, *args, **kw):
- start, end = self._range(*args, **kw)
- return self._values[start:end]
+ def __delitem__(self, key):
+ self._del(self._to_key(key))
- def itervalues(self, *args, **kw):
- values = self._values
- return (values[i] for i in xrange(*self._range(*args, **kw)))
-
- def items(self, *args, **kw):
- keys = self._keys
- values = self._values
- return [(keys[i], values[i])
- for i in xrange(*self._range(*args, **kw))]
-
- def iteritems(self, *args, **kw):
- keys = self._keys
- values = self._values
- return ((keys[i], values[i])
- for i in xrange(*self._range(*args, **kw)))
-
- def __getstate__(self):
- keys = self._keys
- values = self._values
- data = []
- for i in range(len(keys)):
- data.append(keys[i])
- data.append(values[i])
- data = tuple(data)
-
- if self._next:
- return data, self._next
- return (data, )
-
- def __setstate__(self, state):
- if not isinstance(state[0], tuple):
- raise TypeError("tuple required for first state element")
-
- self.clear()
- if len(state) == 2:
- state, self._next = state
- else:
- self._next = None
- state = state[0]
-
- keys = self._keys
- values = self._values
- for i in range(0, len(state), 2):
- keys.append(state[i])
- values.append(state[i+1])
-
-
-class Set(_SetBase, _BucketBase):
-
- def __getstate__(self):
- data = tuple(self._keys)
- if self._next:
- return data, self._next
- return (data, )
-
- def __setstate__(self, state):
- if not isinstance(state[0], tuple):
- raise TypeError('tuple required for first state element')
-
- self.clear()
- if len(state) == 2:
- state, self._next = state
- else:
- self._next = None
- state = state[0]
-
- self._keys.extend(state)
-
-
- def _set(self, key, value=None, ifunset=False):
- index = self._search(key)
- if index < 0:
- index = -index - 1
- self._keys.insert(index, key)
- return True, None
- return False, None
-
- def _del(self, key):
- index = self._search(key)
- if index >= 0:
- self._p_changed = True
- del self._keys[index]
- return 0, 0
- raise KeyError(key)
-
- def __getitem__(self, i):
- return self._keys[i]
-
- def _split(self, index=-1):
- if index < 0 or index >= len(self._keys):
- index = len(self._keys) / 2
- new_instance = self.__class__()
- new_instance._keys = self._keys[index:]
- del self._keys[index:]
- new_instance._next = self._next
- self._next = new_instance
- return new_instance
-
-
-class _TreeItem(object):
-
- __slots__ = 'key', 'child'
-
- def __init__(self, key, child):
- self.key = key
- self.child = child
-
-
-class _Tree(_MappingBase):
-
def clear(self):
self._data = []
self._firstbucket = None
@@ -1075,7 +1100,22 @@
return bool(self._set(key, value, True)[0])
-class TreeSet(_SetBase, _Tree):
+class TreeSet(_Tree):
+
+ #_next = None
+ def add(self, key):
+ return self._set(self._to_key(key))[0]
+
+ insert = add
+
+ def remove(self, key):
+ self._del(self._to_key(key))
+
+ def update(self, items):
+ add = self.add
+ for i in items:
+ add(i)
+
_p_resolveConflict = _Tree._p_resolveConflict
Modified: BTrees/branches/pure_python/BTrees/tests/test__base.py
===================================================================
--- BTrees/branches/pure_python/BTrees/tests/test__base.py 2012-11-14 23:13:04 UTC (rev 128293)
+++ BTrees/branches/pure_python/BTrees/tests/test__base.py 2012-11-14 23:13:06 UTC (rev 128294)
@@ -386,7 +386,7 @@
self.assertTrue(key in bucket)
-class Test__SetIteration(unittest.TestCase):
+class Test_SetIteration(unittest.TestCase):
assertRaises = _assertRaises
@@ -414,15 +414,60 @@
self.assertEqual(si.position, 1)
-class Test__SetBase(unittest.TestCase):
+class BucketTests(unittest.TestCase):
assertRaises = _assertRaises
def _getTargetClass(self):
- from .._base import _SetBase
- return _SetBase
+ from .._base import Bucket
+ return Bucket
def _makeOne(self):
+ class _TestMapping(self._getTargetClass()):
+ _values = None
+ def __setstate__(self, state):
+ state, self._next = state
+ self._keys = []
+ self._values = []
+ for i in range(len(state) // 2):
+ self._keys.append(state[i])
+ self._values.append(state[i+1])
+ def clear(self):
+ self._keys, self._values, self._next = [], [], None
+ def iteritems(self):
+ return iter(zip(self._keys, self._values))
+ return _TestMapping()
+
+ def test__p_resolveConflict_delete_first_new(self):
+ from ..Interfaces import BTreesConflictError
+ _mapping = self._makeOne()
+ s_old = (['a', 0, 'b', 1], None)
+ s_com = (['a', 1, 'b', 2, 'c', 3], None)
+ s_new = (['b', 4], None)
+ e = self.assertRaises(BTreesConflictError,
+ _mapping._p_resolveConflict, s_old, s_com, s_new)
+ self.assertEqual(e.reason, 2)
+
+ def test__p_resolveConflict_delete_first_committed(self):
+ from ..Interfaces import BTreesConflictError
+ _mapping = self._makeOne()
+ s_old = (['a', 0, 'b', 1], None)
+ s_com = (['b', 4], None)
+ s_new = (['a', 1, 'b', 2, 'c', 3], None)
+ e = self.assertRaises(BTreesConflictError,
+ _mapping._p_resolveConflict, s_old, s_com, s_new)
+ self.assertEqual(e.reason, 3)
+
+
+class SetTests(unittest.TestCase):
+
+ assertRaises = _assertRaises
+
+ def _getTargetClass(self):
+ from .._base import Set
+ return Set
+
+ def _makeOneXXX(self):
class _TestSet(self._getTargetClass()):
def __setstate__(self, state):
self._keys, self._next = state
@@ -434,13 +479,16 @@
return iter(self._keys)
return _TestSet()
+ def _makeOne(self):
+ return self._getTargetClass()()
+
def test__p_resolveConflict_x_on_com_next(self):
from ..Interfaces import BTreesConflictError
_set = self._makeOne()
N_NEW = object()
- s_old = ([], None)
- s_com = ([], N_NEW)
- s_new = ([], None)
+ s_old = ((), None)
+ s_com = ((), N_NEW)
+ s_new = ((), None)
e = self.assertRaises(BTreesConflictError,
_set._p_resolveConflict, s_old, s_com, s_new)
self.assertEqual(e.reason, 0)
@@ -449,9 +497,9 @@
from ..Interfaces import BTreesConflictError
_set = self._makeOne()
N_NEW = object()
- s_old = ([], None)
- s_com = ([], None)
- s_new = ([], N_NEW)
+ s_old = ((), None)
+ s_com = ((), None)
+ s_new = ((), N_NEW)
e = self.assertRaises(BTreesConflictError,
_set._p_resolveConflict, s_old, s_com, s_new)
self.assertEqual(e.reason, 0)
@@ -459,9 +507,9 @@
def test__p_resolveConflict_x_on_com_empty(self):
from ..Interfaces import BTreesConflictError
_set = self._makeOne()
- s_old = (['a', 'b'], None)
- s_com = ([], None)
- s_new = (['a'], None)
+ s_old = (('a', 'b'), None)
+ s_com = ((), None)
+ s_new = (('a',), None)
e = self.assertRaises(BTreesConflictError,
_set._p_resolveConflict, s_old, s_com, s_new)
self.assertEqual(e.reason, 12)
@@ -469,9 +517,9 @@
def test__p_resolveConflict_x_on_new_empty(self):
from ..Interfaces import BTreesConflictError
_set = self._makeOne()
- s_old = (['a', 'b'], None)
- s_com = (['a'], None)
- s_new = ([], None)
+ s_old = (('a', 'b'), None)
+ s_com = (('a',), None)
+ s_new = ((), None)
e = self.assertRaises(BTreesConflictError,
_set._p_resolveConflict, s_old, s_com, s_new)
self.assertEqual(e.reason, 12)
@@ -479,9 +527,9 @@
def test__p_resolveConflict_x_on_del_first_com(self):
from ..Interfaces import BTreesConflictError
_set = self._makeOne()
- s_old = (['a','b'], None)
- s_com = (['b'], None)
- s_new = (['a', 'b', 'c'], None)
+ s_old = (('a','b'), None)
+ s_com = (('b',), None)
+ s_new = (('a', 'b', 'c'), None)
e = self.assertRaises(BTreesConflictError,
_set._p_resolveConflict, s_old, s_com, s_new)
self.assertEqual(e.reason, 13)
@@ -489,9 +537,9 @@
def test__p_resolveConflict_x_on_del_first_new(self):
from ..Interfaces import BTreesConflictError
_set = self._makeOne()
- s_old = (['a', 'b'], None)
- s_com = (['a', 'b', 'c'], None)
- s_new = (['b'], None)
+ s_old = (('a', 'b'), None)
+ s_com = (('a', 'b', 'c'), None)
+ s_new = (('b',), None)
e = self.assertRaises(BTreesConflictError,
_set._p_resolveConflict, s_old, s_com, s_new)
self.assertEqual(e.reason, 13)
@@ -499,9 +547,9 @@
def test__p_resolveConflict_x_on_ins_same_after_del(self):
from ..Interfaces import BTreesConflictError
_set = self._makeOne()
- s_old = (['a', 'b'], None)
- s_com = (['a', 'c'], None)
- s_new = (['a', 'c', 'd'], None)
+ s_old = (('a', 'b'), None)
+ s_com = (('a', 'c'), None)
+ s_new = (('a', 'c', 'd'), None)
e = self.assertRaises(BTreesConflictError,
_set._p_resolveConflict, s_old, s_com, s_new)
self.assertEqual(e.reason, 4)
@@ -509,9 +557,9 @@
def test__p_resolveConflict_x_on_del_same(self):
from ..Interfaces import BTreesConflictError
_set = self._makeOne()
- s_old = (['a', 'b', 'c'], None)
- s_com = (['a', 'c'], None)
- s_new = (['a', 'd', 'e'], None)
+ s_old = (('a', 'b', 'c'), None)
+ s_com = (('a', 'c'), None)
+ s_new = (('a', 'd', 'e'), None)
e = self.assertRaises(BTreesConflictError,
_set._p_resolveConflict, s_old, s_com, s_new)
self.assertEqual(e.reason, 5)
@@ -519,9 +567,9 @@
def test__p_resolveConflict_x_on_append_same(self):
from ..Interfaces import BTreesConflictError
_set = self._makeOne()
- s_old = (['a'], None)
- s_com = (['a', 'b'], None)
- s_new = (['a', 'b', 'c'], None)
+ s_old = (('a',), None)
+ s_com = (('a', 'b'), None)
+ s_new = (('a', 'b', 'c'), None)
e = self.assertRaises(BTreesConflictError,
_set._p_resolveConflict, s_old, s_com, s_new)
self.assertEqual(e.reason, 6)
@@ -529,9 +577,9 @@
def test__p_resolveConflict_x_on_new_deletes_all_com_adds(self):
from ..Interfaces import BTreesConflictError
_set = self._makeOne()
- s_old = (['a', 'b', 'c'], None)
- s_com = (['a', 'd', 'e', 'f'], None)
- s_new = (['a'], None)
+ s_old = (('a', 'b', 'c'), None)
+ s_com = (('a', 'd', 'e', 'f'), None)
+ s_new = (('a',), None)
e = self.assertRaises(BTreesConflictError,
_set._p_resolveConflict, s_old, s_com, s_new)
self.assertEqual(e.reason, 7)
@@ -539,9 +587,9 @@
def test__p_resolveConflict_x_on_com_deletes_all_new_adds(self):
from ..Interfaces import BTreesConflictError
_set = self._makeOne()
- s_old = (['a', 'b', 'c'], None)
- s_com = (['a'], None)
- s_new = (['a', 'd', 'e', 'f'], None)
+ s_old = (('a', 'b', 'c'), None)
+ s_com = (('a',), None)
+ s_new = (('a', 'd', 'e', 'f'), None)
e = self.assertRaises(BTreesConflictError,
_set._p_resolveConflict, s_old, s_com, s_new)
self.assertEqual(e.reason, 8)
@@ -549,80 +597,36 @@
def test__p_resolveConflict_x_on_com_deletes_all_new_deletes(self):
from ..Interfaces import BTreesConflictError
_set = self._makeOne()
- s_old = (['a', 'b', 'c'], None)
- s_com = (['a'], None)
- s_new = (['a', 'b'], None)
+ s_old = (('a', 'b', 'c'), None)
+ s_com = (('a',), None)
+ s_new = (('a', 'b'), None)
e = self.assertRaises(BTreesConflictError,
_set._p_resolveConflict, s_old, s_com, s_new)
self.assertEqual(e.reason, 9)
def test__p_resolveConflict_ok_both_add_new_max(self):
_set = self._makeOne()
- s_old = (['a'], None)
- s_com = (['a', 'b', 'c'], None)
- s_new = (['a', 'd'], None)
+ s_old = (('a',), None)
+ s_com = (('a', 'b', 'c'), None)
+ s_new = (('a', 'd'), None)
result = _set._p_resolveConflict(s_old, s_com, s_new)
# Note that _SetBase uses default __getstate__
- self.assertEqual(result['_keys'], ['a', 'b', 'c', 'd'])
- self.assertEqual(result['_next'], None)
+ self.assertEqual(result, (('a', 'b', 'c', 'd'),))
def test__p_resolveConflict_add_new_gt_old_com_lt_old(self):
_set = self._makeOne()
- s_old = (['a', 'b', 'c'], None)
- s_com = (['a', 'b', 'bb', 'c'], None)
- s_new = (['a', 'b', 'c', 'd'], None)
+ s_old = (('a', 'b', 'c'), None)
+ s_com = (('a', 'b', 'bb', 'c'), None)
+ s_new = (('a', 'b', 'c', 'd'), None)
result = _set._p_resolveConflict(s_old, s_com, s_new)
- # Note that _SetBase uses default __getstate__
- self.assertEqual(result['_keys'], ['a', 'b', 'bb', 'c', 'd'])
- self.assertEqual(result['_next'], None)
+ self.assertEqual(result, (('a', 'b', 'bb', 'c', 'd'),))
-class Test__MappingBase(unittest.TestCase):
-
- assertRaises = _assertRaises
-
- def _getTargetClass(self):
- from .._base import _MappingBase
- return _MappingBase
-
- def _makeOne(self):
- class _TestMapping(self._getTargetClass()):
- _values = None
- def __setstate__(self, state):
- state, self._next = state
- self._keys = []
- self._values = []
- for i in range(len(state) // 2):
- self._keys.append(state[i])
- self._values.append(state[i+1])
- def clear(self):
- self._keys, self._values, self._next = [], [], None
- def iteritems(self):
- return iter(zip(self._keys, self._values))
- return _TestMapping()
-
- def test__p_resolveConflict_delete_first_new(self):
- from ..Interfaces import BTreesConflictError
- _mapping = self._makeOne()
- s_old = (['a', 0, 'b', 1], None)
- s_com = (['a', 1, 'b', 2, 'c', 3], None)
- s_new = (['b', 4], None)
- e = self.assertRaises(BTreesConflictError,
- _mapping._p_resolveConflict, s_old, s_com, s_new)
- self.assertEqual(e.reason, 2)
-
- def test__p_resolveConflict_delete_first_committed(self):
- from ..Interfaces import BTreesConflictError
- _mapping = self._makeOne()
- s_old = (['a', 0, 'b', 1], None)
- s_com = (['b', 4], None)
- s_new = (['a', 1, 'b', 2, 'c', 3], None)
- e = self.assertRaises(BTreesConflictError,
- _mapping._p_resolveConflict, s_old, s_com, s_new)
- self.assertEqual(e.reason, 3)
-
-
def test_suite():
return unittest.TestSuite((
+ unittest.makeSuite(Test_Base),
unittest.makeSuite(Test_BucketBase),
+ unittest.makeSuite(Test_SetIteration),
+ unittest.makeSuite(BucketTests),
+ unittest.makeSuite(SetTests),
))
Modified: BTrees/branches/pure_python/setup.cfg
===================================================================
--- BTrees/branches/pure_python/setup.cfg 2012-11-14 23:13:04 UTC (rev 128293)
+++ BTrees/branches/pure_python/setup.cfg 2012-11-14 23:13:06 UTC (rev 128294)
@@ -1,6 +1,6 @@
[nosetests]
nocapture=1
-cover-package=BTrees
+;cover-package=BTrees
cover-erase=1
with-doctest=0
where=BTrees
More information about the checkins
mailing list