Added tests for Concatenate with ellipsis

Author: Daraan

src/test_typing_extensions.py

@@ -1683,6 +1683,8 @@ class C(Generic[T]): pass
         self.assertIn(get_args(Callable[P, int]), [(P, int), ([P], int)])
         self.assertEqual(get_args(Callable[Concatenate[int, P], int]),
                          (Concatenate[int, P], int))
+        self.assertEqual(get_args(Callable[Concatenate[int, ...], int]),
+                    (Concatenate[int, ...], int))
         self.assertEqual(get_args(Required[int]), (int,))
         self.assertEqual(get_args(NotRequired[int]), (int,))
         self.assertEqual(get_args(Unpack[Ts]), (Ts,))
@@ -5322,6 +5324,11 @@ class MyClass: ...
 
         c = Concatenate[MyClass, P]
         self.assertNotEqual(c, Concatenate)
+        
+        # Test Ellipsis Concatenation
+        d = Concatenate[MyClass, ...]
+        self.assertNotEqual(d, c)
+        self.assertNotEqual(d, Concatenate)
 
     def test_valid_uses(self):
         P = ParamSpec('P')
@@ -5338,6 +5345,18 @@ def test_valid_uses(self):
             C4 = collections.abc.Callable[Concatenate[int, T, P], T]
             self.assertEqual(C3.__origin__, C4.__origin__)
             self.assertNotEqual(C3, C4)
+            
+        C5 = Callable[Concatenate[int, ...], int]
+        C6 = Callable[Concatenate[int, T, ...], T]
+        self.assertEqual(C5.__origin__, C6.__origin__)
+        self.assertNotEqual(C5, C6)
+
+        # Test collections.abc.Callable too.
+        if sys.version_info[:2] >= (3, 9):
+            C7 = collections.abc.Callable[Concatenate[int, ...], int]
+            C8 = collections.abc.Callable[Concatenate[int, T, ...], T]
+            self.assertEqual(C7.__origin__, C8.__origin__)
+            self.assertNotEqual(C7, C8)
 
     def test_invalid_uses(self):
         P = ParamSpec('P')
@@ -5351,7 +5370,7 @@ def test_invalid_uses(self):
 
         with self.assertRaisesRegex(
             TypeError,
-            'The last parameter to Concatenate should be a ParamSpec variable',
+            'The last parameter to Concatenate should be a ParamSpec variable or ellipsis',
         ):
             Concatenate[P, T]
 
@@ -5361,15 +5380,27 @@ def test_invalid_uses(self):
                 'each arg must be a type',
             ):
                 Concatenate[1, P]
+                
+            with self.assertRaisesRegex(
+                TypeError,
+                'each arg must be a type.',
+            ):
+                Concatenate[1, ..., P]
 
     def test_basic_introspection(self):
         P = ParamSpec('P')
         C1 = Concatenate[int, P]
         C2 = Concatenate[int, T, P]
+        C3 = Concatenate[int, ...]
+        C4 = Concatenate[int, T, ...]
         self.assertEqual(C1.__origin__, Concatenate)
         self.assertEqual(C1.__args__, (int, P))
         self.assertEqual(C2.__origin__, Concatenate)
         self.assertEqual(C2.__args__, (int, T, P))
+        self.assertEqual(C3.__origin__, Concatenate)
+        self.assertEqual(C3.__args__, (int, Ellipsis))
+        self.assertEqual(C4.__origin__, Concatenate)
+        self.assertEqual(C4.__args__, (int, T, Ellipsis))
 
     def test_eq(self):
         P = ParamSpec('P')
@@ -5379,6 +5410,13 @@ def test_eq(self):
         self.assertEqual(C1, C2)
         self.assertEqual(hash(C1), hash(C2))
         self.assertNotEqual(C1, C3)
+        
+        C4 = Concatenate[int, ...]
+        C5 = Concatenate[int, ...]
+        C6 = Concatenate[int, T, ...]
+        self.assertEqual(C4, C5)
+        self.assertEqual(hash(C4), hash(C5))
+        self.assertNotEqual(C4, C6)
 
 
 class TypeGuardTests(BaseTestCase):
@@ -6050,7 +6088,7 @@ def test_typing_extensions_defers_when_possible(self):
         if sys.version_info < (3, 10, 1):
             exclude |= {"Literal"}
         if sys.version_info < (3, 11):
-            exclude |= {'final', 'Any', 'NewType', 'overload'}
+            exclude |= {'final', 'Any', 'NewType', 'overload', 'Concatenate'}
         if sys.version_info < (3, 12):
             exclude |= {
                 'SupportsAbs', 'SupportsBytes',