*** Python-2.3a1/Lib/UserDict.py	Wed Nov 27 09:29:10 2002
--- pweak/Lib/UserDict.py	Sun Jan 12 12:16:06 2003
***************
*** 1,103 ****
  """A more or less complete user-defined wrapper around dictionary objects."""
  
- class UserDict:
-     def __init__(self, dict=None, **kwargs):
-         self.data = {}
-         if dict is not None:
-             if not hasattr(dict,'keys'):
-                 dict = type({})(dict)   # make mapping from a sequence
-             self.update(dict)
-         if len(kwargs):
-             self.update(kwargs)
-     def __repr__(self): return repr(self.data)
-     def __cmp__(self, dict):
-         if isinstance(dict, UserDict):
-             return cmp(self.data, dict.data)
-         else:
-             return cmp(self.data, dict)
-     def __len__(self): return len(self.data)
-     def __getitem__(self, key): return self.data[key]
-     def __setitem__(self, key, item): self.data[key] = item
-     def __delitem__(self, key): del self.data[key]
-     def clear(self): self.data.clear()
-     def copy(self):
-         if self.__class__ is UserDict:
-             return UserDict(self.data)
-         import copy
-         data = self.data
-         try:
-             self.data = {}
-             c = copy.copy(self)
-         finally:
-             self.data = data
-         c.update(self)
-         return c
-     def keys(self): return self.data.keys()
-     def items(self): return self.data.items()
-     def iteritems(self): return self.data.iteritems()
-     def iterkeys(self): return self.data.iterkeys()
-     def itervalues(self): return self.data.itervalues()
-     def values(self): return self.data.values()
-     def has_key(self, key): return self.data.has_key(key)
-     def update(self, dict):
-         if isinstance(dict, UserDict):
-             self.data.update(dict.data)
-         elif isinstance(dict, type(self.data)):
-             self.data.update(dict)
-         else:
-             for k, v in dict.items():
-                 self[k] = v
-     def get(self, key, failobj=None):
-         if not self.has_key(key):
-             return failobj
-         return self[key]
-     def setdefault(self, key, failobj=None):
-         if not self.has_key(key):
-             self[key] = failobj
-         return self[key]
-     def pop(self, key):
-         return self.data.pop(key)
-     def popitem(self):
-         return self.data.popitem()
-     def __contains__(self, key):
-         return key in self.data
-     def fromkeys(cls, iterable, value=None):
-         d = cls()
-         for key in iterable:
-             d[key] = value
-         return d
-     fromkeys = classmethod(fromkeys)
  
! class IterableUserDict(UserDict):
!     def __iter__(self):
!         return iter(self.data)
! 
! class DictMixin:
      # Mixin defining all dictionary methods for classes that already have
      # a minimum dictionary interface including getitem, setitem, delitem,
!     # and keys. Without knowledge of the subclass constructor, the mixin
!     # does not define __init__() or copy().  In addition to the four base
!     # methods, progessively more efficiency comes with defining
!     # __contains__(), __iter__(), and iteritems().
! 
      # second level definitions support higher levels
      def __iter__(self):
          for k in self.keys():
              yield k
!     def has_key(self, key):
          try:
              value = self[key]
          except KeyError:
              return False
          return True
-     __contains__ = has_key
  
      # third level takes advantage of second level definitions
      def iteritems(self):
          for k in self:
              yield (k, self[k])
!     iterkeys = __iter__
! 
      # fourth level uses definitions from lower levels
      def itervalues(self):
          for _, v in self.iteritems():
--- 1,33 ----
  """A more or less complete user-defined wrapper around dictionary objects."""
  
  
! class DictMixin(object):
      # Mixin defining all dictionary methods for classes that already have
      # a minimum dictionary interface including getitem, setitem, delitem,
!     # and keys. In addition to the four base methods, progessively more
!     # efficiency comes with defining __contains__(), __iter__(), and
!     # iteritems().
!     
      # second level definitions support higher levels
      def __iter__(self):
          for k in self.keys():
              yield k
!     def __contains__(self, key):
          try:
              value = self[key]
          except KeyError:
              return False
          return True
  
      # third level takes advantage of second level definitions
      def iteritems(self):
          for k in self:
              yield (k, self[k])
!     def iterkeys(self):
!         return self.__iter__()
!     def has_key(self, key):
!         return self.__contains__(key)
!     
      # fourth level uses definitions from lower levels
      def itervalues(self):
          for _, v in self.iteritems():
***************
*** 142,152 ****
              return self[key]
          except KeyError:
              return default
-     def __repr__(self):
-         return repr(dict(self.iteritems()))
      def __cmp__(self, other):
          if isinstance(other, DictMixin):
              other = dict(other.iteritems())
          return cmp(dict(self.iteritems()), other)
      def __len__(self):
          return len(self.keys())
--- 72,159 ----
              return self[key]
          except KeyError:
              return default
      def __cmp__(self, other):
          if isinstance(other, DictMixin):
              other = dict(other.iteritems())
          return cmp(dict(self.iteritems()), other)
      def __len__(self):
          return len(self.keys())
+     def __nonzero__(self):
+         x = iter(self)
+         try:
+             x.next()
+         except StopIteration:
+             return False
+         else:
+             return True
+     def __repr__(self):
+         data = ", ".join([repr(k)+": "+repr(v) for k,v in self.iteritems()])
+         return "%s({%s})"%(type(self).__name__, data)
+     __str__ = __repr__
+     
+     # theses 3 methods needs an empty constructor 
+     def __init__(self, _newdict=None, **kwargs):
+         super(DictMixin, self).__init__()
+         if _newdict is not None:
+             if not hasattr(_newdict,'keys'):
+                 _newdict = dict(_newdict)   # make mapping from a sequence
+             self.update(_newdict)
+         if len(kwargs):
+             self.update(kwargs)
+     def fromkeys(cls, iterable, value=None):
+         d = cls()
+         for key in iterable:
+             d[key] = value
+         return d
+     fromkeys = classmethod(fromkeys)
+     def copy(self):
+         x = type(self)()
+         x.update(self)
+         return x
+ 
+ class UserDict(DictMixin):
+     def __init__(self, _newdict=None, **kwargs):
+         self.data = {}
+         super(UserDict, self).__init__(_newdict, **kwargs)
+ 
+     def __getitem__(self, key): return self.data[key]
+     def __setitem__(self, key, item): self.data[key] = item
+     def __delitem__(self, key): del self.data[key]
+     def keys(self): return self.data.keys()
+ 
+     def __contains__(self, key):
+         return key in self.data
+     def __iter__(self): return self.data.iterkeys()
+     def iteritems(self): return self.data.iteritems()
+ 
+     def copy(self):
+         if self.__class__ is UserDict:
+             return UserDict(self.data)
+         import copy
+         data = self.data
+         try:
+             self.data = {}
+             c = copy.copy(self)
+         finally:
+             self.data = data
+         c.update(self)
+         return c
+     def __cmp__(self, dict):
+         if isinstance(dict, UserDict):
+             return cmp(self.data, dict.data)
+         else:
+             return cmp(self.data, dict)
+     def __len__(self): return len(self.data)
+     def __repr__(self): return repr(self.data)
+     __str__ = __repr__
+ 
+ 
+ class IterableUserDict(UserDict):
+     def __iter__(self):
+         return iter(self.data)
+ 
+ 
+ 
+ 
+ 
+ 
*** Python-2.3a1/Lib/weakref.py	Tue Jul 16 23:35:23 2002
--- pweak/Lib/weakref.py	Sun Jan 12 16:48:56 2003
***************
*** 30,137 ****
             "CallableProxyType", "ProxyTypes", "WeakValueDictionary"]
  
  
! class WeakValueDictionary(UserDict.UserDict):
      """Mapping class that references values weakly.
  
      Entries in the dictionary will be discarded when no strong
      reference to the value exists anymore
      """
!     # We inherit the constructor without worrying about the input
!     # dictionary; since it uses our .update() method, we get the right
!     # checks (if the other dictionary is a WeakValueDictionary,
!     # objects are unwrapped on the way out, and we always wrap on the
!     # way in).
! 
      def __getitem__(self, key):
!         o = self.data[key]()
!         if o is None:
              raise KeyError, key
          else:
!             return o
! 
!     def __repr__(self):
!         return "<WeakValueDictionary at %s>" % id(self)
! 
      def __setitem__(self, key, value):
!         self.data[key] = ref(value, self.__makeremove(key))
! 
!     def copy(self):
!         new = WeakValueDictionary()
!         for key, wr in self.data.items():
!             o = wr()
!             if o is not None:
!                 new[key] = o
!         return new
! 
!     def get(self, key, default=None):
!         try:
!             wr = self.data[key]
!         except KeyError:
!             return default
!         else:
!             o = wr()
!             if o is None:
!                 # This should only happen
!                 return default
!             else:
!                 return o
! 
!     def items(self):
!         L = []
!         for key, wr in self.data.items():
!             o = wr()
!             if o is not None:
!                 L.append((key, o))
!         return L
  
      def iteritems(self):
!         return WeakValuedItemIterator(self)
! 
!     def iterkeys(self):
!         return self.data.iterkeys()
!     __iter__ = iterkeys
! 
!     def itervalues(self):
!         return WeakValuedValueIterator(self)
! 
!     def popitem(self):
!         while 1:
!             key, wr = self.data.popitem()
!             o = wr()
!             if o is not None:
!                 return key, o
! 
!     def setdefault(self, key, default):
!         try:
!             wr = self.data[key]
!         except KeyError:
!             self.data[key] = ref(default, self.__makeremove(key))
!             return default
!         else:
!             return wr()
! 
!     def update(self, dict):
!         d = self.data
!         for key, o in dict.items():
!             d[key] = ref(o, self.__makeremove(key))
! 
!     def values(self):
!         L = []
!         for wr in self.data.values():
!             o = wr()
!             if o is not None:
!                 L.append(o)
!         return L
! 
!     def __makeremove(self, key):
!         def remove(o, selfref=ref(self), key=key):
!             self = selfref()
!             if self is not None:
!                 del self.data[key]
!         return remove
  
  
! class WeakKeyDictionary(UserDict.UserDict):
      """ Mapping class that references keys weakly.
  
      Entries in the dictionary will be discarded when there is no
--- 30,74 ----
             "CallableProxyType", "ProxyTypes", "WeakValueDictionary"]
  
  
! class WeakValueDictionary(UserDict.DictMixin):
      """Mapping class that references values weakly.
  
      Entries in the dictionary will be discarded when no strong
      reference to the value exists anymore
      """
!     def __init__(self, _newdict=None, **kwargs):
!         self.data = {}
!         super(WeakValueDictionary, self).__init__(_newdict, **kwargs)
      def __getitem__(self, key):
!         value = self.data[key]()
!         if value is None:
              raise KeyError, key
          else:
!             return value        
      def __setitem__(self, key, value):
!         selfref = ref(self)
!         def remove(v):
!             container = selfref()
!             if container is not None:
!                 del container.data[key]
!         self.data[key] = ref(value, remove)
!     def __delitem__(self, key):
!         del self.data[key]
!     def keys(self):
!         return self.data.keys()
  
+     def __contains__(self, key):
+         return key in self.data
+     def __iter__(self):
+         return iter(self.data)
      def iteritems(self):
!         for key, wr in self.data.iteritems():
!             value = wr()
!             if value is not None:
!                 yield key, value
  
  
! class WeakKeyDictionary(UserDict.DictMixin):
      """ Mapping class that references keys weakly.
  
      Entries in the dictionary will be discarded when there is no
***************
*** 141,291 ****
      can be especially useful with objects that override attribute
      accesses.
      """
! 
!     def __init__(self, dict=None):
          self.data = {}
!         def remove(k, selfref=ref(self)):
!             self = selfref()
!             if self is not None:
!                 del self.data[k]
!         self._remove = remove
!         if dict is not None: self.update(dict)
! 
!     def __delitem__(self, key):
!         for ref in self.data.iterkeys():
!             o = ref()
!             if o == key:
!                 del self.data[ref]
!                 return
! 
      def __getitem__(self, key):
          return self.data[ref(key)]
- 
-     def __repr__(self):
-         return "<WeakKeyDictionary at %s>" % id(self)
- 
      def __setitem__(self, key, value):
!         self.data[ref(key, self._remove)] = value
! 
!     def copy(self):
!         new = WeakKeyDictionary()
!         for key, value in self.data.items():
!             o = key()
!             if o is not None:
!                 new[o] = value
!         return new
! 
!     def get(self, key, default=None):
!         return self.data.get(ref(key),default)
! 
!     def has_key(self, key):
!         try:
!             wr = ref(key)
!         except TypeError:
!             return 0
!         return wr in self.data
! 
      def __contains__(self, key):
          try:
              wr = ref(key)
          except TypeError:
!             return 0
          return wr in self.data
- 
-     def items(self):
-         L = []
-         for key, value in self.data.items():
-             o = key()
-             if o is not None:
-                 L.append((o, value))
-         return L
- 
-     def iteritems(self):
-         return WeakKeyedItemIterator(self)
- 
-     def iterkeys(self):
-         return WeakKeyedKeyIterator(self)
-     __iter__ = iterkeys
- 
-     def itervalues(self):
-         return self.data.itervalues()
- 
-     def keys(self):
-         L = []
-         for wr in self.data.keys():
-             o = wr()
-             if o is not None:
-                 L.append(o)
-         return L
- 
-     def popitem(self):
-         while 1:
-             key, value = self.data.popitem()
-             o = key()
-             if o is not None:
-                 return o, value
- 
-     def setdefault(self, key, default):
-         return self.data.setdefault(ref(key, self._remove),default)
- 
-     def update(self, dict):
-         d = self.data
-         for key, value in dict.items():
-             d[ref(key, self._remove)] = value
- 
- 
- class BaseIter:
      def __iter__(self):
!         return self
! 
! 
! class WeakKeyedKeyIterator(BaseIter):
!     def __init__(self, weakdict):
!         self._next = weakdict.data.iterkeys().next
! 
!     def next(self):
!         while 1:
!             wr = self._next()
!             obj = wr()
!             if obj is not None:
!                 return obj
! 
! 
! class WeakKeyedItemIterator(BaseIter):
!     def __init__(self, weakdict):
!         self._next = weakdict.data.iteritems().next
! 
!     def next(self):
!         while 1:
!             wr, value = self._next()
              key = wr()
              if key is not None:
!                 return key, value
! 
! 
! class WeakValuedValueIterator(BaseIter):
!     def __init__(self, weakdict):
!         self._next = weakdict.data.itervalues().next
! 
!     def next(self):
!         while 1:
!             wr = self._next()
!             obj = wr()
!             if obj is not None:
!                 return obj
! 
  
- class WeakValuedItemIterator(BaseIter):
-     def __init__(self, weakdict):
-         self._next = weakdict.data.iteritems().next
  
-     def next(self):
-         while 1:
-             key, wr = self._next()
-             value = wr()
-             if value is not None:
-                 return key, value
  
  
- # no longer needed
- del UserDict
--- 78,120 ----
      can be especially useful with objects that override attribute
      accesses.
      """
!     def __init__(self, _newdict=None, **kwargs):
          self.data = {}
!         super(WeakKeyDictionary, self).__init__(_newdict, **kwargs)
      def __getitem__(self, key):
          return self.data[ref(key)]
      def __setitem__(self, key, value):
!         selfref = ref(self)
!         def remove(k):
!             container = selfref()
!             if container is not None:
!                 del container.data[k]
!         self.data[ref(key, remove)] = value
!     def __delitem__(self, key):
!         del self.data[ref(key)]
!     def keys(self):
!         return list(self.iterkeys())
!     
      def __contains__(self, key):
          try:
              wr = ref(key)
          except TypeError:
!             return False
          return wr in self.data
      def __iter__(self):
!         for wr in self.data:
              key = wr()
              if key is not None:
!                 yield key
!     def iteritems(self):
!         for wr, value in self.data.iteritems():
!             key = wr()
!             if key is not None:
!                 yield key, value
!        
! # no longer needed
! del UserDict
  
  
  
  
*** Python-2.3a1/Lib/shelve.py	Sun Dec  8 22:25:00 2002
--- pweak/Lib/shelve.py	Sun Jan 12 09:09:42 2003
***************
*** 99,104 ****
--- 99,111 ----
          if hasattr(self.dict, 'sync'):
              self.dict.sync()
  
+     def copy(self):
+         """Return a dictionnary with the same keys and values as the
+         database"""
+         x = {}
+         x.update(self)
+         return x
+ 
  
  class BsdDbShelf(Shelf):
      """Shelf implementation using the "BSD" db interface.
*** Python-2.3a1/Lib/test/test_userdict.py	Wed Dec 11 08:16:06 2002
--- pweak/Lib/test/test_userdict.py	Sun Jan 12 21:22:28 2003
***************
*** 1,153 ****
  # Check every path through every method of UserDict
  
! from test.test_support import verify, verbose
  from UserDict import UserDict, IterableUserDict
  
- d0 = {}
- d1 = {"one": 1}
- d2 = {"one": 1, "two": 2}
- d3 = {"one": 1, "two": 3, "three": 5}
- d4 = {"one": None, "two": None}
- d5 = {"one": 1, "two": 1}
- 
- # Test constructors
- 
- u = UserDict()
- u0 = UserDict(d0)
- u1 = UserDict(d1)
- u2 = IterableUserDict(d2)
- 
- uu = UserDict(u)
- uu0 = UserDict(u0)
- uu1 = UserDict(u1)
- uu2 = UserDict(u2)
- 
- verify(UserDict(one=1, two=2) == d2)            # keyword arg constructor
- verify(UserDict([('one',1), ('two',2)]) == d2)  # item sequence constructor
- verify(UserDict(dict=[('one',1), ('two',2)]) == d2)
- verify(UserDict([('one',1), ('two',2)], two=3, three=5) == d3) # both together
- 
- verify(UserDict.fromkeys('one two'.split()) == d4)  # alternate constructor
- verify(UserDict().fromkeys('one two'.split()) == d4)
- verify(UserDict.fromkeys('one two'.split(), 1) == d5)
- verify(UserDict().fromkeys('one two'.split(), 1) == d5)
- verify(u1.fromkeys('one two'.split()) is not u1)
- verify(isinstance(u1.fromkeys('one two'.split()), UserDict))
- verify(isinstance(u2.fromkeys('one two'.split()), IterableUserDict))
- 
- # Test __repr__
- 
- verify(str(u0) == str(d0))
- verify(repr(u1) == repr(d1))
- verify(`u2` == `d2`)
- 
- # Test __cmp__ and __len__
- 
- all = [d0, d1, d2, u, u0, u1, u2, uu, uu0, uu1, uu2]
- for a in all:
-     for b in all:
-         verify(cmp(a, b) == cmp(len(a), len(b)))
- 
- # Test __getitem__
- 
- verify(u2["one"] == 1)
- try:
-     u1["two"]
- except KeyError:
-     pass
- else:
-     verify(0, "u1['two'] shouldn't exist")
- 
- # Test __setitem__
- 
- u3 = UserDict(u2)
- u3["two"] = 2
- u3["three"] = 3
- 
- # Test __delitem__
- 
- del u3["three"]
- try:
-     del u3["three"]
- except KeyError:
-     pass
- else:
-     verify(0, "u3['three'] shouldn't exist")
- 
- # Test clear
- 
- u3.clear()
- verify(u3 == {})
- 
- # Test copy()
- 
- u2a = u2.copy()
- verify(u2a == u2)
- 
- class MyUserDict(UserDict):
-     def display(self): print self
- 
- m2 = MyUserDict(u2)
- m2a = m2.copy()
- verify(m2a == m2)
- 
- # SF bug #476616 -- copy() of UserDict subclass shared data
- m2['foo'] = 'bar'
- verify(m2a != m2)
- 
- # Test keys, items, values
- 
- verify(u2.keys() == d2.keys())
- verify(u2.items() == d2.items())
- verify(u2.values() == d2.values())
- 
- # Test has_key and "in".
- 
- for i in u2.keys():
-     verify(u2.has_key(i) == 1)
-     verify((i in u2) == 1)
-     verify(u1.has_key(i) == d1.has_key(i))
-     verify((i in u1) == (i in d1))
-     verify(u0.has_key(i) == d0.has_key(i))
-     verify((i in u0) == (i in d0))
- 
- # Test update
- 
- t = UserDict()
- t.update(u2)
- verify(t == u2)
- 
- # Test get
- 
- for i in u2.keys():
-     verify(u2.get(i) == u2[i])
-     verify(u1.get(i) == d1.get(i))
-     verify(u0.get(i) == d0.get(i))
- 
- # Test "in" iteration.
- for i in xrange(20):
-     u2[i] = str(i)
- ikeys = []
- for k in u2:
-     ikeys.append(k)
- ikeys.sort()
- keys = u2.keys()
- keys.sort()
- verify(ikeys == keys)
  
  ##########################
! # Test Dict Mixin
  
  from UserDict import DictMixin
  
  class SeqDict(DictMixin):
      """Dictionary lookalike implemented with lists.
! 
!     Used to test and demonstrate DictMixin
!     """
!     def __init__(self):
          self.keylist = []
          self.valuelist = []
      def __getitem__(self, key):
          try:
              i = self.keylist.index(key)
--- 1,249 ----
  # Check every path through every method of UserDict
  
! from test.test_support import verify, verbose, run_unittest
  from UserDict import UserDict, IterableUserDict
+ import unittest
+ 
+ 
+ class TestMapping(unittest.TestCase):
+     """Base class for mapping protocol checks"""
+     
+     # values that will be used in dictionary
+     # theses values are intended to be invariant by dictionary
+     # storage
+     reference = { 1:2, "key1": "value1", "Key2": (1,2,3,4)}
+ 
+     # the class to test
+     class_ = dict
+ 
+     def __init__(self, *args, **kw):
+         unittest.TestCase.__init__(self, *args, **kw)
+         self.reference = self.reference.copy() #put in object scope
+         key, value = self.reference.popitem()
+         self.other = {key:value}
+     
+     def _createEmptyDict(self):
+         return self.class_()
+     def _removeDict(self, X):
+         pass
+     def _createFullDict(self, data):
+         X = self._createEmptyDict()
+         for key, value in data.items():
+             X[key] = value
+         return X
+ 
+     def test_indexing(self):
+         X = self._createEmptyDict()
+         nonkey = self.other.keys()[0]
+         for key,value in self.reference.items():
+             X[key] = value
+             self.assertEqual(X[key], value)
+         try:
+             x = X[nonkey]
+         except KeyError:
+             pass
+         else:
+             self.fail("KeyError exception not raised")
+         try:
+             del X[nonkey]
+         except KeyError:
+             pass
+         else:
+             self.fail("KeyError exception not raised")
+         for key in self.reference:
+             del X[key]
+             try:
+                 x = X[key]
+             except KeyError:
+                 pass
+             else:
+                 self.fail("KeyError exception not raised")
+         self.assertEqual(len(X), 0)
+         self._removeDict(X)
+ 
+     def test_cmp_len(self):
+         X = self._createEmptyDict()
+         X1 = X.copy()
+         Y = self._createFullDict(self.reference)
+         if Y is X:  #ensure the test work with singleton objects
+             X = X1
+         # cmp
+         self.assertEqual(cmp(X,X), 0)
+         self.assertEqual(cmp(Y,Y), 0)
+         self.assertEqual(cmp(X,Y), -1)
+         self.assertEqual(cmp(Y,X), 1)
+         #len
+         self.assertEqual(len(X), 0)
+         self.assert_(len(Y)>0)
+         #__non__zero__
+         if X:
+             self.fail("Empty dictionary should compare to False")
+         if not Y:
+             self.fail("Full dictionary should compare to True")
+         self._removeDict(X)
+         self._removeDict(Y)
+ 
+     def test_update(self):
+         X = self._createFullDict(self.reference)
+ 
+         Y = X.copy()
+         self.assertEqual(X, Y)
+ 
+         self.assert_(len(X)>0)
+         X.clear()
+         self.assertEqual(len(X), 0)
+         X.update(self.reference)
+         self.assert_(len(X)>0)
+         self.assertEqual(X, Y)
+         self._removeDict(Y)
+ 
+         Y = X.copy()
+         Y[self.other.keys()[0]] = self.other.values()[0]
+         self.assertNotEqual(X, Y)
+         self._removeDict(Y)
+         self._removeDict(X)        
+ 
+     def test_key_value(self):
+         def is_iter(obj):
+             return hasattr(obj, 'next') and hasattr(obj, '__iter__')
+         def cmp_list(x, y):
+             x = list(x); y = list(y)
+             x.sort(); y.sort()
+             return cmp(x,y)
+         X = self._createFullDict(self.reference)
+         # keys
+         keys = X.keys()
+         iterkeys = X.iterkeys()
+         itr = iter(X)
+         self.assert_(is_iter(iterkeys))
+         self.assert_(is_iter(itr))
+         self.assert_(cmp_list(keys, iterkeys)==0)
+         self.assert_(cmp_list(keys, itr)==0)
+         for k in self.reference.keys():
+             self.assert_(k in X)
+             self.assert_(X.has_key(k))
+         self.assert_(self.other.keys()[0] not in X)
+         self.assert_(not X.has_key(self.other.keys()[0]))
+         # values
+         values = X.values()
+         itervalues = X.itervalues()
+         self.assert_(is_iter(itervalues))
+         self.assert_(cmp_list(values, itervalues)==0)
+         # items
+         items = X.items()
+         iteritems = X.iteritems()
+         self.assert_(is_iter(iteritems))
+         self.assert_(cmp_list(items, iteritems)==0)
+         # both
+         self.assert_(len(keys)==len(values)==len(items))
+         items_k = [k for k,v in items]
+         items_v = [v for k,v in items]
+         self.assert_(cmp_list(keys, items_k)==0)
+         self.assert_(cmp_list(values, items_v)==0)
+         self._removeDict(X)
+         
+     def test_get_setdefault(self):
+         X = self._createFullDict(self.reference)
+         key, value = self.reference.iteritems().next()
+         nonkey, nonvalue = self.other.iteritems().next()
+         self.assertEqual(X.get(key, nonvalue), value)
+         self.assertEqual(X.get(nonkey, nonvalue), nonvalue)
+         self.assert_(nonkey not in X)
+         self.assertEqual(X.setdefault(key, nonvalue), value)
+         self.assertEqual(X[key], value)
+         self.assertEqual(X.setdefault(nonkey, nonvalue), nonvalue)
+         self.assertEqual(X[nonkey], nonvalue)
+         self._removeDict(X)
+ 
+     def test_popitem(self):
+         X = self._createFullDict(self.reference)
+         key, value = self.reference.iteritems().next()
+         nonkey, nonvalue = self.other.iteritems().next()
+         self.assertEqual(X.pop(key), value)
+         self.assert_(not X.has_key(key))
+         self.assertRaises(KeyError, X.pop, nonkey)
+         key, value = X.popitem()
+         self.assertEqual(value, self.reference[key])
+         self._removeDict(X)
+         X = self._createEmptyDict()
+         self.assertRaises(KeyError, X.popitem)
+         self._removeDict(X)
+ 
+ class TestDictionary(TestMapping):
+     """Base class for dictionary like protocol checks.
+     This is the same checks as TestMapping with the constructors
+     appended."""
+     def test_constructor(self):
+         #empty
+         X = self.class_()
+         self.assertEqual(len(X), 0)
+         self._removeDict(X)
+         #copy
+         X = self.class_(self.reference)
+         self.assertEqual(dict(X), self.reference)
+         self._removeDict(X)
+         #from sequence
+         X = self.class_(self.reference.iteritems())
+         self.assertEqual(dict(X), self.reference)
+         self._removeDict(X)
+         
+     def test_kw_constructor(self):
+         #from keywords
+         g = dict([(str(key),value) for key,value in self.reference.items()])
+         X = self.class_(**g)
+         self.assertEqual(dict(X), g)
+         self._removeDict(X)
+         #both from sequence and keywords
+         g = dict([(str(key),value) for key,value in self.other.items()])
+         X = self.class_(self.reference.iteritems(), **g)
+         g.update(self.reference)
+         self.assertEqual(dict(X), g)
+         self._removeDict(X)
+         
+     def test_fromkeys(self):
+         keys = self.reference.keys()
+         Y = self.class_.fromkeys(keys)
+         for k in keys:
+             self.assertEqual(Y[k], None)
+         self.assertEqual(len(Y), len(keys))
+         self._removeDict(Y)
  
  
  ##########################
! # Test UserDict
! class TestUserDict(TestDictionary):
!     class_ = UserDict
! 
!     def test_repr(self):
!         d = self.reference
!         X = self._createFullDict(d)
!         self.assert_(eval(str(X)) == d)
!         self.assert_(eval(repr(X)) == d)
!         self.assert_(eval(`X`) == d)
!         self._removeDict(X)
!     def test_subclass(self):
!         """ SF bug #476616 -- copy() of UserDict subclass shared data"""
!         class MyUserDict(UserDict):
!             def display(self): print self
!         X = self._createFullDict(self.reference)
!         m = MyUserDict(X)
!         ma = m.copy()
!         self.assert_(ma == m)
!         ma['foo'] = 'bar'
!         self.assert_(ma != m)
!         self._removeDict(X)
  
+ ##########################
+ # Test Dict Mixin
  from UserDict import DictMixin
  
  class SeqDict(DictMixin):
      """Dictionary lookalike implemented with lists.
!     Used to test and demonstrate DictMixin"""
!     def __init__(self, _newdict=None, **kwargs):
          self.keylist = []
          self.valuelist = []
+         super(SeqDict,self).__init__(_newdict, **kwargs)
      def __getitem__(self, key):
          try:
              i = self.keylist.index(key)
***************
*** 171,237 ****
      def keys(self):
          return list(self.keylist)
  
! ## Setup test and verify working of the test class
! s = SeqDict()                   # check init
! s[10] = 'ten'                   # exercise setitem
! s[20] = 'twenty'
! s[30] = 'thirty'
! del s[20]                       # exercise delitem
! verify(s[10] == 'ten')          # check getitem and setitem
! verify(s.keys() == [10, 30])    # check keys() and delitem
! 
! ## Now, test the DictMixin methods one by one
! verify(s.has_key(10))                                       # has_key
! verify(not s.has_key(20))
! 
! verify(10 in s)                                             # __contains__
! verify(20 not in s)
! 
! verify([k for k in s] == [10, 30])                          # __iter__
! 
! verify(len(s) == 2)                                         # __len__
! 
! verify(list(s.iteritems()) == [(10,'ten'), (30, 'thirty')]) # iteritems
! 
! verify(list(s.iterkeys()) == [10, 30])                      # iterkeys
! 
! verify(list(s.itervalues()) == ['ten', 'thirty'])           # itervalues
! 
! verify(s.values() == ['ten', 'thirty'])                     # values
! 
! verify(s.items() == [(10,'ten'), (30, 'thirty')])           # items
! 
! verify(s.get(10) == 'ten')                                  # get
! verify(s.get(15,'fifteen') == 'fifteen')
! verify(s.get(15) == None)
! 
! verify(s.setdefault(40, 'forty') == 'forty')                # setdefault
! verify(s.setdefault(10, 'null') == 'ten')
! del s[40]
! 
! verify(s.pop(10) == 'ten')                                  # pop
! verify(10 not in s)
! s[10] = 'ten'
! 
! k, v = s.popitem()                                          # popitem
! verify(k not in s)
! s[k] = v
! 
! s.clear()                                                   # clear
! verify(len(s) == 0)
  
! try:                                                        # empty popitem
!     s.popitem()
! except KeyError:
!     pass
! else:
!     verify(0, "popitem from an empty list should raise KeyError")
  
! s.update({10: 'ten', 20:'twenty'})                          # update
! verify(s[10]=='ten' and s[20]=='twenty')
  
- verify(s == {10: 'ten', 20:'twenty'})                       # cmp
- t = SeqDict()
- t[20] = 'twenty'
- t[10] = 'ten'
- verify(s == t)
--- 267,282 ----
      def keys(self):
          return list(self.keylist)
  
! class TestDictMixin(TestDictionary):
!     class_ = SeqDict
  
!     
! def test_main():
!     run_unittest(TestDictionary)
!     run_unittest(TestUserDict)
!     run_unittest(TestDictMixin)
!     
  
! if __name__ == "__main__":
!     test_main()    
  
*** Python-2.3a1/Lib/test/test_weakref.py	Thu Aug 22 22:21:30 2002
--- pweak/Lib/test/test_weakref.py	Sun Jan 12 21:21:38 2003
***************
*** 286,527 ****
              self.fail("exception not properly restored")
  
  
  class Object:
      def __init__(self, arg):
          self.arg = arg
      def __repr__(self):
!         return "<Object %r>" % self.arg
  
  
! class MappingTestCase(TestBase):
  
!     COUNT = 10
! 
!     def test_weak_values(self):
!         #
!         #  This exercises d.copy(), d.items(), d[], del d[], len(d).
!         #
!         dict, objects = self.make_weak_valued_dict()
          for o in objects:
              self.assert_(weakref.getweakrefcount(o) == 1,
                           "wrong number of weak references to %r!" % o)
!             self.assert_(o is dict[o.arg],
                           "wrong object returned by weak dict!")
!         items1 = dict.items()
!         items2 = dict.copy().items()
!         items1.sort()
!         items2.sort()
!         self.assert_(items1 == items2,
!                      "cloning of weak-valued dictionary did not work!")
!         del items1, items2
!         self.assert_(len(dict) == self.COUNT)
!         del objects[0]
!         self.assert_(len(dict) == (self.COUNT - 1),
!                      "deleting object did not cause dictionary update")
!         del objects, o
!         self.assert_(len(dict) == 0,
!                      "deleting the values did not clear the dictionary")
!         # regression on SF bug #447152:
!         dict = weakref.WeakValueDictionary()
!         self.assertRaises(KeyError, dict.__getitem__, 1)
!         dict[2] = C()
!         self.assertRaises(KeyError, dict.__getitem__, 2)
  
!     def test_weak_keys(self):
!         #
!         #  This exercises d.copy(), d.items(), d[] = v, d[], del d[],
!         #  len(d), d.has_key().
!         #
!         dict, objects = self.make_weak_keyed_dict()
          for o in objects:
              self.assert_(weakref.getweakrefcount(o) == 1,
                           "wrong number of weak references to %r!" % o)
!             self.assert_(o.arg is dict[o],
                           "wrong object returned by weak dict!")
!         items1 = dict.items()
!         items2 = dict.copy().items()
!         items1.sort()
!         items2.sort()
!         self.assert_(items1 == items2,
!                      "cloning of weak-keyed dictionary did not work!")
!         del items1, items2
!         self.assert_(len(dict) == self.COUNT)
!         del objects[0]
!         self.assert_(len(dict) == (self.COUNT - 1),
!                      "deleting object did not cause dictionary update")
!         del objects, o
!         self.assert_(len(dict) == 0,
!                      "deleting the keys did not clear the dictionary")
!         o = Object(42)
!         dict[o] = "What is the meaning of the universe?"
!         self.assert_(dict.has_key(o))
!         self.assert_(not dict.has_key(34))
! 
!     def test_weak_keyed_iters(self):
!         dict, objects = self.make_weak_keyed_dict()
!         self.check_iters(dict)
! 
!     def test_weak_valued_iters(self):
!         dict, objects = self.make_weak_valued_dict()
!         self.check_iters(dict)
! 
!     def check_iters(self, dict):
!         # item iterator:
!         items = dict.items()
!         for item in dict.iteritems():
!             items.remove(item)
!         self.assert_(len(items) == 0, "iteritems() did not touch all items")
! 
!         # key iterator, via __iter__():
!         keys = dict.keys()
!         for k in dict:
!             keys.remove(k)
!         self.assert_(len(keys) == 0, "__iter__() did not touch all keys")
! 
!         # key iterator, via iterkeys():
!         keys = dict.keys()
!         for k in dict.iterkeys():
!             keys.remove(k)
!         self.assert_(len(keys) == 0, "iterkeys() did not touch all keys")
! 
!         # value iterator:
!         values = dict.values()
!         for v in dict.itervalues():
!             values.remove(v)
!         self.assert_(len(values) == 0, "itervalues() did not touch all values")
! 
!     def test_make_weak_keyed_dict_from_dict(self):
!         o = Object(3)
!         dict = weakref.WeakKeyDictionary({o:364})
!         self.assert_(dict[o] == 364)
! 
!     def test_make_weak_keyed_dict_from_weak_keyed_dict(self):
!         o = Object(3)
!         dict = weakref.WeakKeyDictionary({o:364})
!         dict2 = weakref.WeakKeyDictionary(dict)
!         self.assert_(dict[o] == 364)
! 
!     def make_weak_keyed_dict(self):
!         dict = weakref.WeakKeyDictionary()
!         objects = map(Object, range(self.COUNT))
!         for o in objects:
!             dict[o] = o.arg
!         return dict, objects
! 
!     def make_weak_valued_dict(self):
!         dict = weakref.WeakValueDictionary()
!         objects = map(Object, range(self.COUNT))
!         for o in objects:
!             dict[o.arg] = o
!         return dict, objects
  
-     def check_popitem(self, klass, key1, value1, key2, value2):
-         weakdict = klass()
-         weakdict[key1] = value1
-         weakdict[key2] = value2
-         self.assert_(len(weakdict) == 2)
-         k, v = weakdict.popitem()
-         self.assert_(len(weakdict) == 1)
-         if k is key1:
-             self.assert_(v is value1)
-         else:
-             self.assert_(v is value2)
-         k, v = weakdict.popitem()
-         self.assert_(len(weakdict) == 0)
-         if k is key1:
-             self.assert_(v is value1)
-         else:
-             self.assert_(v is value2)
- 
-     def test_weak_valued_dict_popitem(self):
-         self.check_popitem(weakref.WeakValueDictionary,
-                            "key1", C(), "key2", C())
- 
-     def test_weak_keyed_dict_popitem(self):
-         self.check_popitem(weakref.WeakKeyDictionary,
-                            C(), "value 1", C(), "value 2")
- 
-     def check_setdefault(self, klass, key, value1, value2):
-         self.assert_(value1 is not value2,
-                      "invalid test"
-                      " -- value parameters must be distinct objects")
-         weakdict = klass()
-         o = weakdict.setdefault(key, value1)
-         self.assert_(o is value1)
-         self.assert_(weakdict.has_key(key))
-         self.assert_(weakdict.get(key) is value1)
-         self.assert_(weakdict[key] is value1)
- 
-         o = weakdict.setdefault(key, value2)
-         self.assert_(o is value1)
-         self.assert_(weakdict.has_key(key))
-         self.assert_(weakdict.get(key) is value1)
-         self.assert_(weakdict[key] is value1)
- 
-     def test_weak_valued_dict_setdefault(self):
-         self.check_setdefault(weakref.WeakValueDictionary,
-                               "key", C(), C())
- 
-     def test_weak_keyed_dict_setdefault(self):
-         self.check_setdefault(weakref.WeakKeyDictionary,
-                               C(), "value 1", "value 2")
- 
-     def check_update(self, klass, dict):
-         #
-         #  This exercises d.update(), len(d), d.keys(), d.has_key(),
-         #  d.get(), d[].
-         #
-         weakdict = klass()
-         weakdict.update(dict)
-         self.assert_(len(weakdict) == len(dict))
-         for k in weakdict.keys():
-             self.assert_(dict.has_key(k),
-                          "mysterious new key appeared in weak dict")
-             v = dict.get(k)
-             self.assert_(v is weakdict[k])
-             self.assert_(v is weakdict.get(k))
-         for k in dict.keys():
-             self.assert_(weakdict.has_key(k),
-                          "original key disappeared in weak dict")
-             v = dict[k]
-             self.assert_(v is weakdict[k])
-             self.assert_(v is weakdict.get(k))
- 
-     def test_weak_valued_dict_update(self):
-         self.check_update(weakref.WeakValueDictionary,
-                           {1: C(), 'a': C(), C(): C()})
- 
-     def test_weak_keyed_dict_update(self):
-         self.check_update(weakref.WeakKeyDictionary,
-                           {C(): 1, C(): 2, C(): 3})
- 
-     def test_weak_keyed_delitem(self):
-         d = weakref.WeakKeyDictionary()
-         o1 = Object('1')
-         o2 = Object('2')
-         d[o1] = 'something'
-         d[o2] = 'something'
-         self.assert_(len(d) == 2)
-         del d[o1]
-         self.assert_(len(d) == 1)
-         self.assert_(d.keys() == [o2])
- 
-     def test_weak_valued_delitem(self):
-         d = weakref.WeakValueDictionary()
-         o1 = Object('1')
-         o2 = Object('2')
-         d['something'] = o1
-         d['something else'] = o2
-         self.assert_(len(d) == 2)
-         del d['something']
-         self.assert_(len(d) == 1)
-         self.assert_(d.items() == [('something else', o2)])
  
  
  def test_main():
      suite = unittest.TestSuite()
      suite.addTest(unittest.makeSuite(ReferencesTestCase))
!     suite.addTest(unittest.makeSuite(MappingTestCase))
      test_support.run_suite(suite)
  
  
--- 286,376 ----
              self.fail("exception not properly restored")
  
  
+ ##########################
+ # Test WeakKeyDictionary
  class Object:
      def __init__(self, arg):
          self.arg = arg
      def __repr__(self):
!         return "<Object %s>" % repr(self.arg)
! from test_userdict import TestDictionary
  
+ class TestWeakKeyDict(TestDictionary):
  
!     # make sure we can create a weak ref on keys
!     reference = dict([(Object(k),v) for k,v in TestDictionary.reference.items()])
!     class_ = weakref.WeakKeyDictionary
! 
!     def test_kw_constructor(self):
!         """test_kw_constructor skiped in TestWeakKeyDict
!         Since strings can't be used as keys, the object doesn't support
!         keywords arguments"""
!         pass
  
!     def test_weak_keys(self):
!         objects = [Object(x) for x in range(10)]
!         X = weakref.WeakKeyDictionary()
!         for o in objects:
!             X[o] = o.arg
          for o in objects:
              self.assert_(weakref.getweakrefcount(o) == 1,
                           "wrong number of weak references to %r!" % o)
!             self.assert_(o.arg is X[o],
                           "wrong object returned by weak dict!")
!         del o
!         while objects:
!             objects.pop()
!             values = X.values()
!             values.sort()
!             self.assert_(values == range(len(objects)))
! 
! 
! ##########################
! # Test WeakValueDictionary
! class TestWeakValueDict(TestDictionary):
! 
!     # make sure we can create a weak ref on values
!     reference = dict([(k,Object(v)) for k,v in TestDictionary.reference.items()])
!     class_ = weakref.WeakValueDictionary
! 
!     def test_fromkeys(self):
!         N = Object(None)  #None can't be used as value
!         X = weakref.WeakValueDictionary.fromkeys(range(4), N)
!         for i in range(4):
!             self.assertEqual(X[i], N)
!         del N
!         self.assertEqual(len(X), 0)
  
!     def test_weak_values(self):
!         objects = [Object(x) for x in range(10)]
!         X = weakref.WeakValueDictionary()
!         for o in objects:
!             X[o.arg] = o
          for o in objects:
              self.assert_(weakref.getweakrefcount(o) == 1,
                           "wrong number of weak references to %r!" % o)
!             self.assert_(o is X[o.arg],
                           "wrong object returned by weak dict!")
!         del o
!         while objects:
!             objects.pop()
!             keys = X.keys()
!             keys.sort()
!             self.assert_(keys == range(len(objects)))
  
  
+         # regression on SF bug #447152:
+         dict = weakref.WeakValueDictionary()
+         self.assertRaises(KeyError, dict.__getitem__, 1)
+         dict[2] = C()
+         self.assertRaises(KeyError, dict.__getitem__, 2)
+         
  
  def test_main():
      suite = unittest.TestSuite()
      suite.addTest(unittest.makeSuite(ReferencesTestCase))
!     suite.addTest(unittest.makeSuite(TestWeakKeyDict))
!     suite.addTest(unittest.makeSuite(TestWeakValueDict))
      test_support.run_suite(suite)
  
  
*** Python-2.3a1/Lib/test/test_shelve.py	Tue Dec 24 19:31:27 2002
--- pweak/Lib/test/test_shelve.py	Sun Jan 12 21:16:42 2003
***************
*** 3,51 ****
  import shelve
  import glob
  from test import test_support
  
! class TestCase(unittest.TestCase):
! 
      fn = "shelftemp.db"
  
!     def test_ascii_file_shelf(self):
          try:
!             s = shelve.open(self.fn, binary=False)
!             s['key1'] = (1,2,3,4)
!             self.assertEqual(s['key1'], (1,2,3,4))
!             s.close()
!         finally:
!             for f in glob.glob(self.fn+"*"):
!                 os.unlink(f)
! 
!     def test_binary_file_shelf(self):
          try:
!             s = shelve.open(self.fn, binary=True)
!             s['key1'] = (1,2,3,4)
!             self.assertEqual(s['key1'], (1,2,3,4))
!             s.close()
!         finally:
!             for f in glob.glob(self.fn+"*"):
!                 os.unlink(f)
! 
!     def test_in_memory_shelf(self):
!         d1 = {}
!         s = shelve.Shelf(d1, binary=False)
!         s['key1'] = (1,2,3,4)
!         self.assertEqual(s['key1'], (1,2,3,4))
!         s.close()
!         d2 = {}
!         s = shelve.Shelf(d2, binary=True)
!         s['key1'] = (1,2,3,4)
!         self.assertEqual(s['key1'], (1,2,3,4))
!         s.close()
  
-         self.assertEqual(len(d1), 1)
-         self.assertNotEqual(d1, d2)
  
  def test_main():
!     test_support.run_unittest(TestCase)
! 
  
  if __name__ == "__main__":
      test_main()
--- 3,60 ----
  import shelve
  import glob
  from test import test_support
+ from test_userdict import TestMapping
  
! class TestShelveBase(TestMapping):
!     class_ = shelve.Shelf
      fn = "shelftemp.db"
+     counter = 0
  
!     # only string keys
!     reference = { "1":2, "key1": "value1", "Key2": (1,2,3,4)}
!     
!             
! class TestAsciiFileShelve(TestShelveBase):
!     def tearDown(self):
!         for f in glob.glob(self.fn+"*"):
!             os.unlink(f)
!     def _createEmptyDict(self):
!         self.counter += 1
!         return shelve.open(self.fn+str(self.counter), binary=False)
!     def _removeDict(self, X):
          try:
!             X.close()
!         except AttributeError:
!             pass
! 
! class TestBinaryFileShelve(TestShelveBase):
!     def tearDown(self):
!         for f in glob.glob(self.fn+"*"):
!             os.unlink(f)
!     def _createEmptyDict(self):
!         self.counter += 1
!         return shelve.open(self.fn+str(self.counter), binary=True)
!     def _removeDict(self, X):
          try:
!             X.close()
!         except AttributeError:
!             pass
! 
! class TestAsciiMemoryShelve(TestShelveBase):
!     def _createEmptyDict(self):
!         return shelve.Shelf({}, binary=False)
! class TestBinaryMemoryShelve(TestShelveBase):
!     def _createEmptyDict(self):
!         return shelve.Shelf({}, binary=True)
  
  
  def test_main():
!     suite = unittest.makeSuite(TestAsciiFileShelve)
!     suite.addTest(unittest.makeSuite(TestBinaryFileShelve))
!     suite.addTest(unittest.makeSuite(TestAsciiMemoryShelve))
!     suite.addTest(unittest.makeSuite(TestBinaryMemoryShelve))
!     test_support.run_suite(suite)
  
  if __name__ == "__main__":
      test_main()
+ 
*** Python-2.3a1/Lib/test/test_os.py	Thu Aug 22 21:40:33 2002
--- pweak/Lib/test/test_os.py	Mon Jan 13 08:04:30 2003
***************
*** 185,194 ****
--- 185,214 ----
          except TypeError:
              pass
  
+ 
+ # check that os.environ object conforms to dict protocol
+ from test_userdict import TestMapping
+ 
+ class EnvironTests(TestMapping):
+     class_ = None
+     # only string for keys and values
+     # (all in uppercase because MS-Windows seems to need it)
+     reference = { "KEY1":"VALUE1", "KEY2": "VALUE2", "KEY3": "VALUE3"}
+ 
+     def setUp(self):
+         self.save_environ = dict(os.environ)
+         os.environ.clear()
+     def tearDown(self):
+         os.environ.clear()
+         os.environ.update(self.save_environ)
+     def _createEmptyDict(self):
+         return os.environ
+     
  def test_main():
      suite = unittest.TestSuite()
      suite.addTest(unittest.makeSuite(TemporaryFileTests))
      suite.addTest(unittest.makeSuite(StatAttributeTests))
+     suite.addTest(unittest.makeSuite(EnvironTests))
      run_suite(suite)
  
  if __name__ == "__main__":