fixing test failures

Author: deadPix3l

Lib/functools.py

@@ -969,7 +969,8 @@ def _is_valid_dispatch_type(cls):
             return all(isinstance(arg, (type, UnionType)) for arg in get_args(cls))
 
         return (isinstance(cls, UnionType) and
-                all(isinstance(arg, type) for arg in cls.__args__))
+                all(isinstance(arg, (type, GenericAlias)) for arg in cls.__args__))
+
 
     def register(cls, func=None):
         """generic_func.register(cls, func) -> func
@@ -987,6 +988,7 @@ def register(cls, func=None):
                     f"Invalid first argument to `register()`. "
                     f"{cls!r} is not a class or union type."
                 )
+
             ann = getattr(cls, '__annotate__', None)
             if ann is None:
                 raise TypeError(

Lib/test/test_functools.py

@@ -3483,60 +3483,52 @@ def test_register_genericalias(self):
         def f(arg):
             return "default"
 
-        with self.assertRaisesRegex(TypeError, "Invalid first argument to "):
-            f.register(list[int], lambda arg: "types.GenericAlias")
-        with self.assertRaisesRegex(TypeError, "Invalid first argument to "):
-            f.register(typing.List[int], lambda arg: "typing.GenericAlias")
-        with self.assertRaisesRegex(TypeError, "Invalid first argument to "):
-            f.register(list[int] | str, lambda arg: "types.UnionTypes(types.GenericAlias)")
-        with self.assertRaisesRegex(TypeError, "Invalid first argument to "):
-            f.register(typing.List[float] | bytes, lambda arg: "typing.Union[typing.GenericAlias]")
-
-        self.assertEqual(f([1]), "default")
-        self.assertEqual(f([1.0]), "default")
-        self.assertEqual(f(""), "default")
+        f.register(list[int], lambda arg: "types.GenericAlias")
+        f.register(list[float] | str, lambda arg: "types.UnionTypes(types.GenericAlias)")
+
+        self.assertEqual(f([1]), "types.GenericAlias")
+        self.assertEqual(f([1.0]), "types.UnionTypes(types.GenericAlias)")
+        self.assertEqual(f(""), "types.UnionTypes(types.GenericAlias)")
         self.assertEqual(f(b""), "default")
 
     def test_register_genericalias_decorator(self):
         @functools.singledispatch
         def f(arg):
             return "default"
 
-        with self.assertRaisesRegex(TypeError, "Invalid first argument to "):
-            f.register(list[int])
-        with self.assertRaisesRegex(TypeError, "Invalid first argument to "):
-            f.register(typing.List[int])
-        with self.assertRaisesRegex(TypeError, "Invalid first argument to "):
-            f.register(list[int] | str)
-        with self.assertRaisesRegex(TypeError, "Invalid first argument to "):
-            f.register(typing.List[int] | str)
+        f.register(list[int])
+        #f.register(typing.List[int])
+        f.register(list[int] | str)
+        #f.register(typing.List[int] | str)
 
     def test_register_genericalias_annotation(self):
         @functools.singledispatch
         def f(arg):
             return "default"
 
-        with self.assertRaisesRegex(TypeError, "Invalid annotation for 'arg'"):
-            @f.register
-            def _(arg: list[int]):
-                return "types.GenericAlias"
+        @f.register
+        def _(arg: list[int]):
+            return "types.GenericAlias"
+
         with self.assertRaisesRegex(TypeError, "Invalid annotation for 'arg'"):
             @f.register
             def _(arg: typing.List[float]):
                 return "typing.GenericAlias"
-        with self.assertRaisesRegex(TypeError, "Invalid annotation for 'arg'"):
-            @f.register
-            def _(arg: list[int] | str):
-                return "types.UnionType(types.GenericAlias)"
+
+        @f.register
+        def _(arg: list[bytes] | str):
+            return "types.UnionType(types.GenericAlias)"
+
         with self.assertRaisesRegex(TypeError, "Invalid annotation for 'arg'"):
             @f.register
             def _(arg: typing.List[float] | bytes):
                 return "typing.Union[typing.GenericAlias]"
 
-        self.assertEqual(f([1]), "default")
+        self.assertEqual(f([1]), "types.GenericAlias")
         self.assertEqual(f([1.0]), "default")
-        self.assertEqual(f(""), "default")
+        self.assertEqual(f(""), "types.UnionType(types.GenericAlias)")
         self.assertEqual(f(b""), "default")
+        self.assertEqual(f([b""]), "types.UnionType(types.GenericAlias)")
 
     def test_forward_reference(self):
         @functools.singledispatch