RustPython · moreal · Jan 19, 2025 · Jan 19, 2025 · Jan 26, 2025 · Jan 19, 2025
diff --git a/Lib/test/test_dataclasses.py b/Lib/test/test_dataclasses.py
@@ -1906,6 +1906,8 @@ def new_method(self):
         c = Alias(10, 1.0)
         self.assertEqual(c.new_method(), 1.0)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_generic_dynamic(self):
         T = TypeVar('T')
 
@@ -3250,6 +3252,8 @@ def test_classvar_module_level_import(self):
                     # won't exist on the instance.
                     self.assertNotIn('not_iv4', c.__dict__)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_text_annotations(self):
         from test import dataclass_textanno
 

diff --git a/Lib/test/test_fractions.py b/Lib/test/test_fractions.py
@@ -617,13 +617,17 @@ def testConversions(self):
 
         self.assertTypedEquals(0.1+0j, complex(F(1,10)))
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def testSupportsInt(self):
         # See bpo-44547.
         f = F(3, 2)
         self.assertIsInstance(f, typing.SupportsInt)
         self.assertEqual(int(f), 1)
         self.assertEqual(type(int(f)), int)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def testIntGuaranteesIntReturn(self):
         # Check that int(some_fraction) gives a result of exact type `int`
         # even if the fraction is using some other Integral type for its

diff --git a/Lib/test/test_genericalias.py b/Lib/test/test_genericalias.py
@@ -173,6 +173,8 @@ def test_exposed_type(self):
         self.assertEqual(a.__args__, (int,))
         self.assertEqual(a.__parameters__, ())
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_parameters(self):
         from typing import List, Dict, Callable
         D0 = dict[str, int]
@@ -212,6 +214,8 @@ def test_parameters(self):
         self.assertEqual(L5.__args__, (Callable[[K, V], K],))
         self.assertEqual(L5.__parameters__, (K, V))
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_parameter_chaining(self):
         from typing import List, Dict, Union, Callable
         self.assertEqual(list[T][int], list[int])
@@ -271,6 +275,8 @@ class MyType(type):
         with self.assertRaises(TypeError):
             MyType[int]
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_pickle(self):
         alias = GenericAlias(list, T)
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
@@ -280,6 +286,8 @@ def test_pickle(self):
             self.assertEqual(loaded.__args__, alias.__args__)
             self.assertEqual(loaded.__parameters__, alias.__parameters__)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_copy(self):
         class X(list):
             def __copy__(self):
@@ -303,6 +311,8 @@ def test_union(self):
         self.assertEqual(a.__args__, (list[int], list[str]))
         self.assertEqual(a.__parameters__, ())
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_union_generic(self):
         a = typing.Union[list[T], tuple[T, ...]]
         self.assertEqual(a.__args__, (list[T], tuple[T, ...]))

diff --git a/Lib/test/test_types.py b/Lib/test/test_types.py
@@ -392,7 +392,6 @@ def test(i, format_spec, result):
         test(123456, "1=20", '11111111111111123456')
         test(123456, "*=20", '**************123456')
 
-    @unittest.expectedFailure
     @run_with_locale('LC_NUMERIC', 'en_US.UTF8')
     def test_float__format__locale(self):
         # test locale support for __format__ code 'n'
@@ -742,6 +741,8 @@ def test_instancecheck_and_subclasscheck(self):
                 self.assertTrue(issubclass(dict, x))
                 self.assertFalse(issubclass(list, x))
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_instancecheck_and_subclasscheck_order(self):
         T = typing.TypeVar('T')
 
@@ -788,13 +789,17 @@ def __subclasscheck__(cls, sub):
         self.assertTrue(issubclass(int, x))
         self.assertRaises(ZeroDivisionError, issubclass, list, x)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_or_type_operator_with_TypeVar(self):
         TV = typing.TypeVar('T')
         assert TV | str == typing.Union[TV, str]
         assert str | TV == typing.Union[str, TV]
         self.assertIs((int | TV)[int], int)
         self.assertIs((TV | int)[int], int)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_union_args(self):
         def check(arg, expected):
             clear_typing_caches()
@@ -825,6 +830,8 @@ def check(arg, expected):
                 check(x | None, (x, type(None)))
                 check(None | x, (type(None), x))
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_union_parameter_chaining(self):
         T = typing.TypeVar("T")
         S = typing.TypeVar("S")
@@ -869,6 +876,8 @@ def eq(actual, expected, typed=True):
         eq(x[NT], int | NT | bytes)
         eq(x[S], int | S | bytes)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_union_pickle(self):
         orig = list[T] | int
         for proto in range(pickle.HIGHEST_PROTOCOL + 1):
@@ -878,19 +887,25 @@ def test_union_pickle(self):
             self.assertEqual(loaded.__args__, orig.__args__)
             self.assertEqual(loaded.__parameters__, orig.__parameters__)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_union_copy(self):
         orig = list[T] | int
         for copied in (copy.copy(orig), copy.deepcopy(orig)):
             self.assertEqual(copied, orig)
             self.assertEqual(copied.__args__, orig.__args__)
             self.assertEqual(copied.__parameters__, orig.__parameters__)
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_union_parameter_substitution_errors(self):
         T = typing.TypeVar("T")
         x = int | T
         with self.assertRaises(TypeError):
             x[int, str]
 
+    # TODO: RUSTPYTHON
+    @unittest.expectedFailure
     def test_or_type_operator_with_forward(self):
         T = typing.TypeVar('T')
         ForwardAfter = T | 'Forward'