Merge branch 'master' into ticket_1068

1 files changed, 79 insertions, 80 deletions

diff --git a/test/base/test_utils.py b/test/base/test_utils.py
index b28d26e71..194ef1222 100644
--- a/test/base/test_utils.py
+++ b/test/base/test_utils.py
@@ -16,7 +16,7 @@ class KeyedTupleTest():
         eq_(len(keyed_tuple), 0)
 
         eq_(keyed_tuple.__dict__, {'_labels': []})
-        eq_(keyed_tuple.keys(), [])
+        eq_(list(keyed_tuple.keys()), [])
         eq_(keyed_tuple._fields, ())
         eq_(keyed_tuple._asdict(), {})
 
@@ -27,7 +27,7 @@ class KeyedTupleTest():
         eq_(len(keyed_tuple), 2)
 
         eq_(keyed_tuple.__dict__, {'_labels': []})
-        eq_(keyed_tuple.keys(), [])
+        eq_(list(keyed_tuple.keys()), [])
         eq_(keyed_tuple._fields, ())
         eq_(keyed_tuple._asdict(), {})
 
@@ -37,7 +37,7 @@ class KeyedTupleTest():
     def test_basic_creation(self):
         keyed_tuple = util.KeyedTuple([1, 2], ['a', 'b'])
         eq_(str(keyed_tuple), '(1, 2)')
-        eq_(keyed_tuple.keys(), ['a', 'b'])
+        eq_(list(keyed_tuple.keys()), ['a', 'b'])
         eq_(keyed_tuple._fields, ('a', 'b'))
         eq_(keyed_tuple._asdict(), {'a': 1, 'b': 2})
 
@@ -66,7 +66,7 @@ class KeyedTupleTest():
         # TODO: consider not allowing None labels
         expected = {'a': 1, None: 2, 'b': 3, '_labels': ['a', None, 'b']}
         eq_(keyed_tuple.__dict__, expected)
-        eq_(keyed_tuple.keys(), ['a', 'b'])
+        eq_(list(keyed_tuple.keys()), ['a', 'b'])
         eq_(keyed_tuple._fields, ('a', 'b'))
         eq_(keyed_tuple._asdict(), {'a': 1, 'b': 3})
 
@@ -86,7 +86,7 @@ class KeyedTupleTest():
         # TODO: consider not allowing duplicate labels
         expected = {'a': 1, 'b': 3, '_labels': ['a', 'b', 'b']}
         eq_(keyed_tuple.__dict__, expected)
-        eq_(keyed_tuple.keys(), ['a', 'b', 'b'])
+        eq_(list(keyed_tuple.keys()), ['a', 'b', 'b'])
         eq_(keyed_tuple._fields, ('a', 'b', 'b'))
         eq_(keyed_tuple._asdict(), {'a': 1, 'b': 3})
 
@@ -125,12 +125,12 @@ class OrderedDictTest(fixtures.TestBase):
         o['snack'] = 'attack'
         o['c'] = 3
 
-        eq_(o.keys(), ['a', 'b', 'snack', 'c'])
-        eq_(o.values(), [1, 2, 'attack', 3])
+        eq_(list(o.keys()), ['a', 'b', 'snack', 'c'])
+        eq_(list(o.values()), [1, 2, 'attack', 3])
 
         o.pop('snack')
-        eq_(o.keys(), ['a', 'b', 'c'])
-        eq_(o.values(), [1, 2, 3])
+        eq_(list(o.keys()), ['a', 'b', 'c'])
+        eq_(list(o.values()), [1, 2, 3])
 
         try:
             o.pop('eep')
@@ -146,40 +146,40 @@ class OrderedDictTest(fixtures.TestBase):
         except TypeError:
             pass
 
-        eq_(o.keys(), ['a', 'b', 'c'])
-        eq_(o.values(), [1, 2, 3])
+        eq_(list(o.keys()), ['a', 'b', 'c'])
+        eq_(list(o.values()), [1, 2, 3])
 
         o2 = util.OrderedDict(d=4)
         o2['e'] = 5
 
-        eq_(o2.keys(), ['d', 'e'])
-        eq_(o2.values(), [4, 5])
+        eq_(list(o2.keys()), ['d', 'e'])
+        eq_(list(o2.values()), [4, 5])
 
         o.update(o2)
-        eq_(o.keys(), ['a', 'b', 'c', 'd', 'e'])
-        eq_(o.values(), [1, 2, 3, 4, 5])
+        eq_(list(o.keys()), ['a', 'b', 'c', 'd', 'e'])
+        eq_(list(o.values()), [1, 2, 3, 4, 5])
 
         o.setdefault('c', 'zzz')
         o.setdefault('f', 6)
-        eq_(o.keys(), ['a', 'b', 'c', 'd', 'e', 'f'])
-        eq_(o.values(), [1, 2, 3, 4, 5, 6])
+        eq_(list(o.keys()), ['a', 'b', 'c', 'd', 'e', 'f'])
+        eq_(list(o.values()), [1, 2, 3, 4, 5, 6])
 
     def test_odict_constructor(self):
         o = util.OrderedDict([('name', 'jbe'), ('fullname', 'jonathan'
                              ), ('password', '')])
-        eq_(o.keys(), ['name', 'fullname', 'password'])
+        eq_(list(o.keys()), ['name', 'fullname', 'password'])
 
     def test_odict_copy(self):
         o = util.OrderedDict()
         o["zzz"] = 1
         o["aaa"] = 2
-        eq_(o.keys(), ['zzz', 'aaa'])
+        eq_(list(o.keys()), ['zzz', 'aaa'])
 
         o2 = o.copy()
-        eq_(o2.keys(), o.keys())
+        eq_(list(o2.keys()), list(o.keys()))
 
         o3 = copy.copy(o)
-        eq_(o3.keys(), o.keys())
+        eq_(list(o3.keys()), list(o.keys()))
 
 
 class OrderedSetTest(fixtures.TestBase):
@@ -198,7 +198,7 @@ class FrozenDictTest(fixtures.TestBase):
     def test_serialize(self):
         d = util.immutabledict({1: 2, 3: 4})
         for loads, dumps in picklers():
-            print loads(dumps(d))
+            print(loads(dumps(d)))
 
 
 class MemoizedAttrTest(fixtures.TestBase):
@@ -252,7 +252,7 @@ class ColumnCollectionTest(fixtures.TestBase):
         try:
             cc['col1'] in cc
             assert False
-        except exc.ArgumentError, e:
+        except exc.ArgumentError as e:
             eq_(str(e), "__contains__ requires a string argument")
 
     def test_compare(self):
@@ -414,14 +414,14 @@ class IdentitySetTest(fixtures.TestBase):
         for type_ in (object, ImmutableSubclass):
             data = [type_(), type_()]
             ids = util.IdentitySet()
-            for i in range(2) + range(2):
+            for i in list(range(2)) + list(range(2)):
                 ids.add(data[i])
             self.assert_eq(ids, data)
 
         for type_ in (EqOverride, HashOverride, HashEqOverride):
             data = [type_(1), type_(1), type_(2)]
             ids = util.IdentitySet()
-            for i in range(3) + range(3):
+            for i in list(range(3)) + list(range(3)):
                 ids.add(data[i])
             self.assert_eq(ids, data)
 
@@ -843,13 +843,12 @@ class IdentitySetTest(fixtures.TestBase):
         return super_, sub_, twin1, twin2, unique1, unique2
 
     def _assert_unorderable_types(self, callable_):
-        # Py3K
-        #assert_raises_message(
-        #    TypeError, 'unorderable types', callable_)
-        # Py2K
-        assert_raises_message(
-            TypeError, 'cannot compare sets using cmp()', callable_)
-        # end Py2K
+        if util.py3k:
+            assert_raises_message(
+                TypeError, 'unorderable types', callable_)
+        else:
+            assert_raises_message(
+                TypeError, 'cannot compare sets using cmp()', callable_)
 
     def test_basic_sanity(self):
         IdentitySet = util.IdentitySet
@@ -969,23 +968,23 @@ class DictlikeIteritemsTest(fixtures.TestBase):
         d = subdict(a=1, b=2, c=3)
         self._ok(d)
 
-    # Py2K
-    def test_UserDict(self):
-        import UserDict
-        d = UserDict.UserDict(a=1, b=2, c=3)
-        self._ok(d)
-    # end Py2K
+# start Py2K
+#    def test_UserDict(self):
+#        import UserDict
+#        d = UserDict.UserDict(a=1, b=2, c=3)
+#        self._ok(d)
+# end Py2K
 
     def test_object(self):
         self._notok(object())
 
-    # Py2K
-    def test_duck_1(self):
-        class duck1(object):
-            def iteritems(duck):
-                return iter(self.baseline)
-        self._ok(duck1())
-    # end Py2K
+# start Py2K
+#    def test_duck_1(self):
+#        class duck1(object):
+#            def iteritems(duck):
+#                return iter(self.baseline)
+#        self._ok(duck1())
+# end Py2K
 
     def test_duck_2(self):
         class duck2(object):
@@ -993,16 +992,16 @@ class DictlikeIteritemsTest(fixtures.TestBase):
                 return list(self.baseline)
         self._ok(duck2())
 
-    # Py2K
-    def test_duck_3(self):
-        class duck3(object):
-            def iterkeys(duck):
-                return iter(['a', 'b', 'c'])
-
-            def __getitem__(duck, key):
-                return dict(a=1, b=2, c=3).get(key)
-        self._ok(duck3())
-    # end Py2K
+# start Py2K
+#    def test_duck_3(self):
+#        class duck3(object):
+#            def iterkeys(duck):
+#                return iter(['a', 'b', 'c'])
+#
+#            def __getitem__(duck, key):
+#                return dict(a=1, b=2, c=3).get(key)
+#        self._ok(duck3())
+# end Py2K
 
     def test_duck_4(self):
         class duck4(object):
@@ -1029,9 +1028,9 @@ class DictlikeIteritemsTest(fixtures.TestBase):
 class DuckTypeCollectionTest(fixtures.TestBase):
 
     def test_sets(self):
-        # Py2K
-        import sets
-        # end Py2K
+# start Py2K
+#        import sets
+# end Py2K
 
         class SetLike(object):
             def add(self):
@@ -1041,9 +1040,9 @@ class DuckTypeCollectionTest(fixtures.TestBase):
             __emulates__ = set
 
         for type_ in (set,
-                      # Py2K
-                      sets.Set,
-                      # end Py2K
+# start Py2K
+#                      sets.Set,
+# end Py2K
                       SetLike,
                       ForcedSet):
             eq_(util.duck_type_collection(type_), set)
@@ -1051,9 +1050,9 @@ class DuckTypeCollectionTest(fixtures.TestBase):
             eq_(util.duck_type_collection(instance), set)
 
         for type_ in (frozenset,
-                      # Py2K
-                      sets.ImmutableSet
-                      # end Py2K
+# start Py2K
+#                      sets.ImmutableSet
+# end Py2K
                       ):
             is_(util.duck_type_collection(type_), None)
             instance = type_()
@@ -1195,7 +1194,7 @@ class SymbolTest(fixtures.TestBase):
         sym3 = util.pickle.loads(s)
 
         for protocol in 0, 1, 2:
-            print protocol
+            print(protocol)
             serial = util.pickle.dumps(sym1)
             rt = util.pickle.loads(serial)
             assert rt is sym1
@@ -1570,21 +1569,21 @@ class TestClassHierarchy(fixtures.TestBase):
         eq_(set(util.class_hierarchy(A)), set((A, B, C, object)))
         eq_(set(util.class_hierarchy(B)), set((A, B, C, object)))
 
-    # Py2K
-    def test_oldstyle_mixin(self):
-        class A(object):
-            pass
-
-        class Mixin:
-            pass
-
-        class B(A, Mixin):
-            pass
-
-        eq_(set(util.class_hierarchy(B)), set((A, B, object)))
-        eq_(set(util.class_hierarchy(Mixin)), set())
-        eq_(set(util.class_hierarchy(A)), set((A, B, object)))
-    # end Py2K
+# start Py2K
+#    def test_oldstyle_mixin(self):
+#        class A(object):
+#            pass
+#
+#        class Mixin:
+#            pass
+#
+#        class B(A, Mixin):
+#            pass
+#
+#        eq_(set(util.class_hierarchy(B)), set((A, B, object)))
+#        eq_(set(util.class_hierarchy(Mixin)), set())
+#        eq_(set(util.class_hierarchy(A)), set((A, B, object)))
+# end Py2K
 
 
 class TestClassProperty(fixtures.TestBase):