Mark failed and error tests for dict

Lib/test/mapping_tests.py

@@ -170,6 +170,7 @@ class BasicTestMappingProtocol(unittest.TestCase):
 
         self.assertRaises(TypeError, d.__getitem__)
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_update(self):
         # mapping argument
         d = self._empty_mapping()

Lib/test/test_dict.py

@@ -1,6 +1,6 @@
 import collections
 import collections.abc
-import gc
+# import gc // XXX RustPython
 import pickle
 import random
 import string
@@ -12,6 +12,7 @@ from test import support
 
 class DictTest(unittest.TestCase):
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_invalid_keyword_arguments(self):
         class Custom(dict):
             pass
@@ -26,6 +27,7 @@ class DictTest(unittest.TestCase):
         self.assertEqual(dict(), {})
         self.assertIsNot(dict(), {})
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_literal_constructor(self):
         # check literal constructor for different sized dicts
         # (to exercise the BUILD_MAP oparg).
@@ -43,6 +45,7 @@ class DictTest(unittest.TestCase):
         self.assertIs(bool({}), False)
         self.assertIs(bool({1: 2}), True)
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_keys(self):
         d = {}
         self.assertEqual(set(d.keys()), set())
@@ -56,6 +59,7 @@ class DictTest(unittest.TestCase):
         self.assertRaises(TypeError, d.keys, None)
         self.assertEqual(repr(dict(a=1).keys()), "dict_keys(['a'])")
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_values(self):
         d = {}
         self.assertEqual(set(d.values()), set())
@@ -64,6 +68,7 @@ class DictTest(unittest.TestCase):
         self.assertRaises(TypeError, d.values, None)
         self.assertEqual(repr(dict(a=1).values()), "dict_values([1])")
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_items(self):
         d = {}
         self.assertEqual(set(d.items()), set())
@@ -136,6 +141,7 @@ class DictTest(unittest.TestCase):
 
         self.assertRaises(TypeError, d.clear, None)
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_update(self):
         d = {}
         d.update({1:100})
@@ -212,6 +218,8 @@ class DictTest(unittest.TestCase):
 
         self.assertRaises(ValueError, {}.update, [(1, 2, 3)])
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_fromkeys(self):
         self.assertEqual(dict.fromkeys('abc'), {'a':None, 'b':None, 'c':None})
         d = {}
@@ -283,6 +291,7 @@ class DictTest(unittest.TestCase):
         self.assertEqual({}.copy(), {})
         self.assertRaises(TypeError, d.copy, None)
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_copy_fuzz(self):
         for dict_size in [10, 100, 1000, 10000, 100000]:
             dict_size = random.randrange(
@@ -299,6 +308,7 @@ class DictTest(unittest.TestCase):
                 self.assertNotEqual(d, d2)
                 self.assertEqual(len(d2), len(d) + 1)
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_copy_maintains_tracking(self):
         class A:
             pass
@@ -361,6 +371,8 @@ class DictTest(unittest.TestCase):
         x.fail = True
         self.assertRaises(Exc, d.setdefault, x, [])
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_setdefault_atomic(self):
         # Issue #13521: setdefault() calls __hash__ and __eq__ only once.
         class Hashed(object):
@@ -470,6 +482,8 @@ class DictTest(unittest.TestCase):
             for i in d:
                 d[i+1] = 1
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_mutating_iteration_delete(self):
         # change dict content during iteration
         d = {}
@@ -479,6 +493,8 @@ class DictTest(unittest.TestCase):
                 del d[0]
                 d[0] = 0
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_mutating_iteration_delete_over_values(self):
         # change dict content during iteration
         d = {}
@@ -488,6 +504,8 @@ class DictTest(unittest.TestCase):
                 del d[0]
                 d[0] = 0
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_mutating_iteration_delete_over_items(self):
         # change dict content during iteration
         d = {}
@@ -497,6 +515,7 @@ class DictTest(unittest.TestCase):
                 del d[0]
                 d[0] = 0
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_mutating_lookup(self):
         # changing dict during a lookup (issue #14417)
         class NastyKey:
@@ -541,6 +560,8 @@ class DictTest(unittest.TestCase):
         d = {1: BadRepr()}
         self.assertRaises(Exc, repr, d)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_repr_deep(self):
         d = {}
         for i in range(sys.getrecursionlimit() + 100):
@@ -565,6 +586,7 @@ class DictTest(unittest.TestCase):
         with self.assertRaises(Exc):
             d1 == d2
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_keys_contained(self):
         self.helper_keys_contained(lambda x: x.keys())
         self.helper_keys_contained(lambda x: x.items())
@@ -613,6 +635,8 @@ class DictTest(unittest.TestCase):
         self.assertTrue(larger != larger3)
         self.assertFalse(larger == larger3)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_errors_in_view_containment_check(self):
         class C:
             def __eq__(self, other):
@@ -635,6 +659,7 @@ class DictTest(unittest.TestCase):
         with self.assertRaises(RuntimeError):
             d3.items() > d2.items()
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_dictview_set_operations_on_keys(self):
         k1 = {1:1, 2:2}.keys()
         k2 = {1:1, 2:2, 3:3}.keys()
@@ -650,6 +675,7 @@ class DictTest(unittest.TestCase):
         self.assertEqual(k1 ^ k2, {3})
         self.assertEqual(k1 ^ k3, {1,2,4})
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_dictview_set_operations_on_items(self):
         k1 = {1:1, 2:2}.items()
         k2 = {1:1, 2:2, 3:3}.items()
@@ -665,6 +691,8 @@ class DictTest(unittest.TestCase):
         self.assertEqual(k1 ^ k2, {(3,3)})
         self.assertEqual(k1 ^ k3, {(1,1), (2,2), (4,4)})
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_dictview_mixed_set_operations(self):
         # Just a few for .keys()
         self.assertTrue({1:1}.keys() == {1})
@@ -801,6 +829,7 @@ class DictTest(unittest.TestCase):
                  'f': None, 'g': None, 'h': None}
         d = {}
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_container_iterator(self):
         # Bug #3680: tp_traverse was not implemented for dictiter and
         # dictview objects.
@@ -1042,6 +1071,7 @@ class DictTest(unittest.TestCase):
         a.a = 3
         self.assertFalse(_testcapi.dict_hassplittable(a.__dict__))
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_iterator_pickling(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             data = {1:"a", 2:"b", 3:"c"}
@@ -1060,6 +1090,7 @@ class DictTest(unittest.TestCase):
             del data[drop]
             self.assertEqual(list(it), list(data))
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_itemiterator_pickling(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             data = {1:"a", 2:"b", 3:"c"}
@@ -1082,6 +1113,7 @@ class DictTest(unittest.TestCase):
             del data[drop[0]]
             self.assertEqual(dict(it), data)
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_valuesiterator_pickling(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             data = {1:"a", 2:"b", 3:"c"}
@@ -1098,6 +1130,7 @@ class DictTest(unittest.TestCase):
             values = list(it) + [drop]
             self.assertEqual(sorted(values), sorted(list(data.values())))
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_reverseiterator_pickling(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             data = {1:"a", 2:"b", 3:"c"}
@@ -1116,6 +1149,7 @@ class DictTest(unittest.TestCase):
             del data[drop]
             self.assertEqual(list(it), list(reversed(data)))
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_reverseitemiterator_pickling(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             data = {1:"a", 2:"b", 3:"c"}
@@ -1138,6 +1172,7 @@ class DictTest(unittest.TestCase):
             del data[drop[0]]
             self.assertEqual(dict(it), data)
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_reversevaluesiterator_pickling(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             data = {1:"a", 2:"b", 3:"c"}
@@ -1199,6 +1234,7 @@ class DictTest(unittest.TestCase):
                 d.popitem()
         self.check_reentrant_insertion(mutate)
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_merge_and_mutate(self):
         class X:
             def __hash__(self):
@@ -1214,12 +1250,14 @@ class DictTest(unittest.TestCase):
         d = {X(): 0, 1: 1}
         self.assertRaises(RuntimeError, d.update, other)
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_free_after_iterating(self):
         support.check_free_after_iterating(self, iter, dict)
         support.check_free_after_iterating(self, lambda d: iter(d.keys()), dict)
         support.check_free_after_iterating(self, lambda d: iter(d.values()), dict)
         support.check_free_after_iterating(self, lambda d: iter(d.items()), dict)
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_equal_operator_modifying_operand(self):
         # test fix for seg fault reported in issue 27945 part 3.
         class X():
@@ -1273,6 +1311,7 @@ class DictTest(unittest.TestCase):
         except RuntimeError:  # implementation defined
             pass
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_dictitems_contains_use_after_free(self):
         class X:
             def __eq__(self, other):
@@ -1291,6 +1330,8 @@ class DictTest(unittest.TestCase):
         pair = [X(), 123]
         dict([pair])
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_oob_indexing_dictiter_iternextitem(self):
         class X(int):
             def __del__(self):
@@ -1305,6 +1346,7 @@ class DictTest(unittest.TestCase):
 
         self.assertRaises(RuntimeError, iter_and_mutate)
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_reversed(self):
         d = {"a": 1, "b": 2, "foo": 0, "c": 3, "d": 4}
         del d["foo"]
@@ -1312,6 +1354,7 @@ class DictTest(unittest.TestCase):
         self.assertEqual(list(r), list('dcba'))
         self.assertRaises(StopIteration, next, r)
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_dict_copy_order(self):
         # bpo-34320
         od = collections.OrderedDict([('a', 1), ('b', 2)])