diff --git a/Lib/test/test_set.py b/Lib/test/test_set.py
index bb1081f03..0d9ac1fc0 100644
--- a/Lib/test/test_set.py
+++ b/Lib/test/test_set.py
@@ -1,6 +1,6 @@
 import unittest
 from test import support
-import gc
+# import gc
 import weakref
 import operator
 import copy
@@ -47,6 +47,7 @@ class TestJointOps:
         self.s = self.thetype(word)
         self.d = dict.fromkeys(word)
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_new_or_init(self):
         self.assertRaises(TypeError, self.thetype, [], 2)
         self.assertRaises(TypeError, set().__init__, a=1)
@@ -61,6 +62,7 @@ class TestJointOps:
     def test_len(self):
         self.assertEqual(len(self.s), len(self.d))
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_contains(self):
         for c in self.letters:
             self.assertEqual(c in self.s, c in self.d)
@@ -170,6 +172,7 @@ class TestJointOps:
         else:
             self.fail("s-t did not screen-out general iterables")
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_symmetric_difference(self):
         i = self.s.symmetric_difference(self.otherword)
         for c in self.letters:
@@ -184,6 +187,7 @@ class TestJointOps:
             self.assertEqual(self.thetype('abcba').symmetric_difference(C('ccb')), set('a'))
             self.assertEqual(self.thetype('abcba').symmetric_difference(C('ef')), set('abcef'))
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_xor(self):
         i = self.s.symmetric_difference(self.otherword)
         self.assertEqual(self.s ^ set(self.otherword), i)
@@ -203,6 +207,7 @@ class TestJointOps:
         self.assertNotEqual(self.s, frozenset(self.otherword))
         self.assertEqual(self.s != self.word, True)
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_setOfFrozensets(self):
         t = map(frozenset, ['abcdef', 'bcd', 'bdcb', 'fed', 'fedccba'])
         s = self.thetype(t)
@@ -224,6 +229,7 @@ class TestJointOps:
         self.assertFalse(set('a').issubset('cbs'))
         self.assertFalse(set('cbs').issuperset('a'))
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_pickling(self):
         for i in range(pickle.HIGHEST_PROTOCOL + 1):
             p = pickle.dumps(self.s, i)
@@ -235,6 +241,7 @@ class TestJointOps:
                 dup = pickle.loads(p)
                 self.assertEqual(self.s.x, dup.x)
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_iterator_pickling(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             itorg = iter(self.s)
@@ -256,6 +263,7 @@ class TestJointOps:
             it = pickle.loads(d)
             self.assertEqual(self.thetype(it), data - self.thetype((drop,)))
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_deepcopy(self):
         class Tracer:
             def __init__(self, value):
@@ -273,6 +281,7 @@ class TestJointOps:
         self.assertNotEqual(id(t), id(newt))
         self.assertEqual(t.value + 1, newt.value)
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_gc(self):
         # Create a nest of cycles to exercise overall ref count check
         class A:
@@ -331,6 +340,7 @@ class TestJointOps:
             fo.close()
             support.unlink(support.TESTFN)
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_do_not_rehash_dict_keys(self):
         n = 10
         d = dict.fromkeys(map(HashCountingInt, range(n)))
@@ -350,6 +360,7 @@ class TestJointOps:
         self.assertEqual(sum(elem.hash_count for elem in d), n)
         self.assertEqual(d3, dict.fromkeys(d, 123))
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_container_iterator(self):
         # Bug #3680: tp_traverse was not implemented for set iterator object
         class C(object):
@@ -362,6 +373,7 @@ class TestJointOps:
         gc.collect()
         self.assertTrue(ref() is None, "Cycle was not collected")
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_free_after_iterating(self):
         support.check_free_after_iterating(self, iter, self.thetype)
 
@@ -369,6 +381,7 @@ class TestSet(TestJointOps, unittest.TestCase):
     thetype = set
     basetype = set
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_init(self):
         s = self.thetype()
         s.__init__(self.word)
@@ -425,6 +438,7 @@ class TestSet(TestJointOps, unittest.TestCase):
         self.assertEqual(self.s, dup)
         self.assertRaises(TypeError, self.s.add, [])
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_remove(self):
         self.s.remove('a')
         self.assertNotIn('a', self.s)
@@ -447,6 +461,7 @@ class TestSet(TestJointOps, unittest.TestCase):
             else:
                 self.fail()
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_remove_keyerror_set(self):
         key = self.thetype([3, 4])
         try:
@@ -458,6 +473,7 @@ class TestSet(TestJointOps, unittest.TestCase):
         else:
             self.fail()
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_discard(self):
         self.s.discard('a')
         self.assertNotIn('a', self.s)
@@ -499,6 +515,7 @@ class TestSet(TestJointOps, unittest.TestCase):
         for c in (self.word + self.otherword):
             self.assertIn(c, self.s)
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_intersection_update(self):
         retval = self.s.intersection_update(self.otherword)
         self.assertEqual(retval, None)
@@ -565,6 +582,7 @@ class TestSet(TestJointOps, unittest.TestCase):
             else:
                 self.assertNotIn(c, self.s)
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_symmetric_difference_update(self):
         retval = self.s.symmetric_difference_update(self.otherword)
         self.assertEqual(retval, None)
@@ -589,6 +607,7 @@ class TestSet(TestJointOps, unittest.TestCase):
             else:
                 self.assertNotIn(c, self.s)
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_inplace_on_self(self):
         t = self.s.copy()
         t |= t
@@ -601,6 +620,7 @@ class TestSet(TestJointOps, unittest.TestCase):
         t ^= t
         self.assertEqual(t, self.thetype())
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_weakref(self):
         s = self.thetype('gallahad')
         p = weakref.proxy(s)
@@ -652,6 +672,7 @@ class TestSet(TestJointOps, unittest.TestCase):
 class SetSubclass(set):
     pass
 
+@unittest.skip("TODO: RUSTPYTHON")
 class TestSetSubclass(TestSet):
     thetype = SetSubclass
     basetype = set
@@ -660,6 +681,7 @@ class SetSubclassWithKeywordArgs(set):
     def __init__(self, iterable=[], newarg=None):
         set.__init__(self, iterable)
 
+@unittest.skip("TODO: RUSTPYTHON")
 class TestSetSubclassWithKeywordArgs(TestSet):
 
     def test_keywords_in_subclass(self):
@@ -675,6 +697,7 @@ class TestFrozenSet(TestJointOps, unittest.TestCase):
         s.__init__(self.otherword)
         self.assertEqual(s, set(self.word))
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_singleton_empty_frozenset(self):
         f = frozenset()
         efs = [frozenset(), frozenset([]), frozenset(()), frozenset(''),
@@ -684,11 +707,13 @@ class TestFrozenSet(TestJointOps, unittest.TestCase):
         # All of the empty frozensets should have just one id()
         self.assertEqual(len(set(map(id, efs))), 1)
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_constructor_identity(self):
         s = self.thetype(range(3))
         t = self.thetype(s)
         self.assertEqual(id(s), id(t))
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_hash(self):
         self.assertEqual(hash(self.thetype('abcdeb')),
                          hash(self.thetype('ebecda')))
@@ -702,10 +727,12 @@ class TestFrozenSet(TestJointOps, unittest.TestCase):
             results.add(hash(self.thetype(seq)))
         self.assertEqual(len(results), 1)
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_copy(self):
         dup = self.s.copy()
         self.assertEqual(id(self.s), id(dup))
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_frozen_as_dictkey(self):
         seq = list(range(10)) + list('abcdefg') + ['apple']
         key1 = self.thetype(seq)
@@ -720,6 +747,7 @@ class TestFrozenSet(TestJointOps, unittest.TestCase):
         f = self.thetype('abcdcda')
         self.assertEqual(hash(f), hash(f))
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_hash_effectiveness(self):
         n = 13
         hashvalues = set()
@@ -769,6 +797,7 @@ class TestFrozenSetSubclass(TestFrozenSet):
         t = self.thetype(s)
         self.assertEqual(s, t)
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_singleton_empty_frozenset(self):
         Frozenset = self.thetype
         f = frozenset()
@@ -888,6 +917,7 @@ class TestBasicOps:
         setiter = iter(self.set)
         self.assertEqual(setiter.__length_hint__(), len(self.set))
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_pickling(self):
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
             p = pickle.dumps(self.set, proto)
@@ -1020,6 +1050,7 @@ class TestExceptionPropagation(unittest.TestCase):
         set('abc')
         set(gooditer())
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_changingSizeWhileIterating(self):
         s = set([1,2,3])
         try:
@@ -1533,6 +1564,7 @@ class TestCopying:
         for i in range(len(dup_list)):
             self.assertTrue(dup_list[i] is set_list[i])
 
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_deep_copy(self):
         dup = copy.deepcopy(self.set)
         ##print type(dup), repr(dup)
@@ -1753,6 +1785,7 @@ class bad_dict_clear:
         return 0
 
 class TestWeirdBugs(unittest.TestCase):
+    @unittest.skip("TODO: RUSTPYTHON")
     def test_8420_set_merge(self):
         # This used to segfault
         global be_bad, set2, dict2
@@ -1849,6 +1882,7 @@ def faces(G):
     return f
 
 
+@unittest.skip("TODO: RUSTPYTHON")
 class TestGraphs(unittest.TestCase):
 
     def test_cube(self):