Fix the damage to UserDict and its tests.

Clearly this is not the right way to fix this; UserDict and MixinDict
ought to be redesigned with the new dict API in mind.  But I'm not
claiming to be in charge of library redesign, I only want zero failing
tests.

Lib/UserDict.py

@@ -42,9 +42,6 @@ class UserDict:
         return c
     def keys(self): return self.data.keys()
     def items(self): return self.data.items()
-    def iteritems(self): return self.data.items()
-    def iterkeys(self): return self.data.keys()
-    def itervalues(self): return self.data.values()
     def values(self): return self.data.values()
     def update(self, dict=None, **kwargs):
         if dict is None:
@@ -91,6 +88,8 @@ class DictMixin:
     # methods, progressively more efficiency comes with defining
     # __contains__(), __iter__(), and iteritems().
 
+    # XXX It would make more sense to expect __iter__ to be primitive.
+
     # second level definitions support higher levels
     def __iter__(self):
         for k in self.keys():
@@ -103,20 +102,20 @@ class DictMixin:
         return True
 
     # third level takes advantage of second level definitions
+    def iterkeys(self):
+        return self.__iter__()
     def iteritems(self):
         for k in self:
             yield (k, self[k])
-    def iterkeys(self):
-        return self.__iter__()
 
     # fourth level uses definitions from lower levels
     def itervalues(self):
-        for _, v in self.items():
+        for _, v in self.iteritems():
             yield v
     def values(self):
-        return [v for _, v in self.items()]
+        return [v for _, v in self.iteritems()]
     def items(self):
-        return list(self.items())
+        return list(self.iteritems())
     def clear(self):
         for key in self.keys():
             del self[key]
@@ -140,7 +139,7 @@ class DictMixin:
         return value
     def popitem(self):
         try:
-            k, v = self.items().next()
+            k, v = self.iteritems().next()
         except StopIteration:
             raise KeyError, 'container is empty'
         del self[k]
@@ -169,14 +168,14 @@ class DictMixin:
         except KeyError:
             return default
     def __repr__(self):
-        return repr(dict(self.items()))
+        return repr(dict(self.iteritems()))
     def __eq__(self, other):
         if isinstance(other, DictMixin):
-            other = dict(other.items())
-        return dict(self.items()) == other
+            other = dict(other.iteritems())
+        return dict(self.iteritems()) == other
     def __ne__(self, other):
         if isinstance(other, DictMixin):
-            other = dict(other.items())
-        return dict(self.items()) != other
+            other = dict(other.iteritems())
+        return dict(self.iteritems()) != other
     def __len__(self):
         return len(self.keys())

Lib/test/mapping_tests.py

@@ -317,7 +317,7 @@ class TestMappingProtocol(BasicTestMappingProtocol):
     def test_keys(self):
         BasicTestMappingProtocol.test_keys(self)
         d = self._empty_mapping()
-        self.assertEqual(d.keys(), [])
+        self.assertEqual(list(d.keys()), [])
         d = self._full_mapping({'a': 1, 'b': 2})
         k = d.keys()
         self.assert_('a' in k)
@@ -327,13 +327,13 @@ class TestMappingProtocol(BasicTestMappingProtocol):
     def test_values(self):
         BasicTestMappingProtocol.test_values(self)
         d = self._full_mapping({1:2})
-        self.assertEqual(d.values(), [2])
+        self.assertEqual(list(d.values()), [2])
 
     def test_items(self):
         BasicTestMappingProtocol.test_items(self)
 
         d = self._full_mapping({1:2})
-        self.assertEqual(d.items(), [(1, 2)])
+        self.assertEqual(list(d.items()), [(1, 2)])
 
     def test_contains(self):
         d = self._empty_mapping()

Lib/test/test_userdict.py

@@ -92,7 +92,7 @@ class UserDictTest(mapping_tests.TestHashMappingProtocol):
         # Test keys, items, values
         self.assertEqual(u2.keys(), d2.keys())
         self.assertEqual(u2.items(), d2.items())
-        self.assertEqual(u2.values(), d2.values())
+        self.assertEqual(list(u2.values()), list(d2.values()))
 
         # Test "in".
         for i in u2.keys():