update tests

Author: AlexWaygood

crates/ty_python_semantic/resources/mdtest/generics/pep695/variables.md

@@ -431,7 +431,7 @@ def constrained_non_singletons[T: (int, str)](t: T) -> None:
 def constrained_singletons[T: (Literal[True], Literal[False])](t: T) -> None:
     static_assert(is_singleton(T))
 
-def constrained_single_valued[T: (Literal[True], tuple[()])](t: T) -> None:
+def constrained_single_valued[T: (Literal[True], Literal[42])](t: T) -> None:
     static_assert(is_single_valued(T))
 ```
 

crates/ty_python_semantic/resources/mdtest/type_properties/is_single_valued.md

@@ -13,9 +13,6 @@ static_assert(is_single_valued(Literal[1]))
 static_assert(is_single_valued(Literal["abc"]))
 static_assert(is_single_valued(Literal[b"abc"]))
 
-static_assert(is_single_valued(tuple[()]))
-static_assert(is_single_valued(tuple[Literal[True], Literal[1]]))
-
 static_assert(not is_single_valued(str))
 static_assert(not is_single_valued(Never))
 static_assert(not is_single_valued(Any))
@@ -35,6 +32,43 @@ static_assert(is_single_valued(TypeOf[types.FunctionType.__get__]))
 static_assert(is_single_valued(TypeOf[A.method.__get__]))
 ```
 
+Tuple types are not single-valued, because the type `tuple[int, str]` means "any two-element
+instance of `tuple` where the first element is `int` and the second is `str`, *or* any instance of a
+subclass of `tuple[int, str]`". It's easy to create a subclass of `tuple[int, str]` that is
+Liskov-compliant but not single-valued, which therefore means that `tuple[int, str]` cannot be
+single-valued, as it is a supertype of its subclass, so can only be single-valued if all its
+subtypes are single-valued:
+
+```py
+from ty_extensions import is_single_valued, static_assert
+
+class EmptyTupleSubclass(tuple[()]):
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, EmptyTupleSubclass) and len(other) == 0
+
+static_assert(not is_single_valued(tuple[()]))
+static_assert(not is_single_valued(EmptyTupleSubclass))
+
+class SingleElementTupleSubclass(tuple[int]):
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, SingleElementTupleSubclass) and len(other) == 1 and isinstance(other[0], int)
+
+static_assert(not is_single_valued(tuple[int]))
+static_assert(not is_single_valued(SingleElementTupleSubclass))
+
+class TwoElementTupleSubclass(tuple[str, bytes]):
+    def __eq__(self, other: object) -> bool:
+        return (
+            isinstance(other, TwoElementTupleSubclass)
+            and len(other) == 2
+            and isinstance(other[0], str)
+            and isinstance(other[1], bytes)
+        )
+
+static_assert(not is_single_valued(tuple[str, bytes]))
+static_assert(not is_single_valued(TwoElementTupleSubclass))
+```
+
 An enum literal is only considered single-valued if it has no custom `__eq__`/`__ne__` method, or if
 these methods always return `True`/`False`, respectively. Otherwise, the single member of the enum
 literal type might not compare equal to itself.