Modified tests

Author: Daraan

src/test_typing_extensions.py

@@ -5305,49 +5305,72 @@ class ProtoZ(Protocol[P]):
         for klass in Z, ProtoZ:
             with self.subTest(klass=klass.__name__):
                 # Note: For 3.10+ __args__ are nested tuples here ((int, ),) instead of (int, )
-                G6 = klass[int, str, bool]
+                G6 = klass[int, str, T]
                 G6args = G6.__args__[0] if sys.version_info >= (3, 10) else G6.__args__
-                self.assertEqual(G6args, (int, str, bool))
-                self.assertEqual(G6.__parameters__, ())
+                self.assertEqual(G6args, (int, str, T))
 
                 # P = [int]
                 G7 = klass[int]
                 G7args = G7.__args__[0] if sys.version_info >= (3, 10) else G7.__args__
                 self.assertEqual(G7args, (int,))
                 self.assertEqual(G7.__parameters__, ())
 
-                # P = [int, int, ...]
-                G8 = klass[T, Concatenate[int, ...]]
-                G8args = G8.__args__[0] if sys.version_info >= (3, 10) else G8.__args__
-                self.assertEqual(G8args, (T, Concatenate[int, ...]))
+                G8 = klass[Concatenate[T, ...]]
+                self.assertEqual(G8.__args__, (Concatenate[T, ...], ))
 
-                # P = [int, int, P_2]
-                G9 = klass[int, Concatenate[T, P_2]]
-                G9args = G9.__args__[0] if sys.version_info >= (3, 10) else G9.__args__
-                self.assertEqual(G9args, (int, Concatenate[T, P_2]))
+                G9 = klass[Concatenate[T, P_2]]
+                self.assertEqual(G9.__args__, (Concatenate[T, P_2], ))
 
-                with self.subTest("Recursive ParamSpec Test A"):
+                # This is an invalid form but useful for testing correct subsitution
+                G10 = klass[int, Concatenate[str, P]]
+                G10args = G10.__args__[0] if sys.version_info >= (3, 10) else G10.__args__
+                self.assertEqual(G10args, (int, Concatenate[str, P], ))
+
+                with self.subTest("Check generic substitution", klass=klass.__name__):
+                    if sys.version_info < (3, 10):
+                        self.skipTest("_ConcatenateGenericAlias not subscriptable")
+                    with self.assertRaisesRegex(TypeError, "Expected a list of types, an ellipsis, ParamSpec, or Concatenate"):
+                        G9[int, int]
+
+                with self.subTest("Check list as parameter expression", klass=klass.__name__):
+                    if sys.version_info < (3, 10):
+                        self.skipTest("Cannot pass non-types")
+                    G5 = klass[[int, str, T]]
+                    self.assertEqual(G5.__args__, ((int, str, T),))
+                    H9 = G9[int, [T]]
+
+                with self.subTest("Check parametrization", klass=klass.__name__):
                     if sys.version_info[:2] == (3, 10):
                         self.skipTest("Parameter detection fails in 3.10")
                     with self.assertRaisesRegex(TypeError, f"Too few {things}"):
                         G9[int]  # for python 3.10 this has no parameters
+                    self.assertEqual(G6.__parameters__, (T,))
                     self.assertEqual(G8.__parameters__, (T,))
                     self.assertEqual(G9.__parameters__, (T, P_2))
+                    if sys.version_info >= (3, 10):  # skipped above
+                        self.assertEqual(G5.__parameters__, (T,))
+                        self.assertEqual(H9.__parameters__, (T,))
 
-                with self.subTest("Recursive ParamSpec Test B"):
+                with self.subTest("Check further substitution", klass=klass.__name__):
+                    if sys.version_info < (3, 10):
+                        self.skipTest("_ConcatenateGenericAlias not subscriptable")
                     if sys.version_info[:2] == (3, 10):
                         self.skipTest("Parameter detection fails in 3.10")
                     if (3, 11, 0) <= sys.version_info[:3] < (3, 11, 3):
                         self.skipTest("Wrong recursive substitution")
                     H1 = G8[int]
-                    H2 = G8[T][int]
-                    self.assertEqual(H2.__parameters__, ())
                     self.assertEqual(H1.__parameters__, ())
                     with self.assertRaisesRegex(TypeError, "not a generic class"):
                         H1[str]  # for python 3.11.0-3 this still has a parameter
+
+                    H2 = G8[T][int]
+                    self.assertEqual(H2.__parameters__, ())
                     with self.assertRaisesRegex(TypeError, "not a generic class"):
                         H2[str]  # for python 3.11.0-3 this still has a parameter
 
+                    H3 = G10[int]
+                    self.assertEqual(H3.__args__, ((int, (str, int)),))
+
     def test_pickle(self):
         global P, P_co, P_contra, P_default
         P = ParamSpec('P')