Added tests for Set, Iterable, Iterator, Union, and Optional

Author: timohl

tests/test_pytypes.cpp

@@ -1037,12 +1037,14 @@ TEST_SUBMODULE(pytypes, m) {
     m.attr("defined_PYBIND11_TEST_PYTYPES_HAS_RANGES") = false;
 #endif
     m.def("half_of_number", [](const RealNumber &x) { return RealNumber{x.value / 2}; });
+    // Tuple<T, T>
     m.def("half_of_number_tuple", [](const py::typing::Tuple<RealNumber, RealNumber> &x) {
         py::typing::Tuple<RealNumber, RealNumber> result
             = py::make_tuple(RealNumber{x[0].cast<RealNumber>().value / 2},
                              RealNumber{x[1].cast<RealNumber>().value / 2});
         return result;
     });
+    // Tuple<T, ...>
     m.def("half_of_number_tuple_ellipsis",
           [](const py::typing::Tuple<RealNumber, py::ellipsis> &x) {
               py::typing::Tuple<RealNumber, py::ellipsis> result(x.size());
@@ -1051,13 +1053,23 @@ TEST_SUBMODULE(pytypes, m) {
               }
               return result;
           });
+    // Dict<K, V>
+    m.def("half_of_number_dict", [](const py::typing::Dict<std::string, RealNumber> &x) {
+        py::typing::Dict<std::string, RealNumber> result;
+        for (auto it : x) {
+            result[it.first] = RealNumber{it.second.cast<RealNumber>().value / 2};
+        }
+        return result;
+    });
+    // List<T>
     m.def("half_of_number_list", [](const py::typing::List<RealNumber> &x) {
         py::typing::List<RealNumber> result;
         for (auto num : x) {
             result.append(RealNumber{num.cast<RealNumber>().value / 2});
         }
         return result;
     });
+    // List<List<T>>
     m.def("half_of_number_nested_list",
           [](const py::typing::List<py::typing::List<RealNumber>> &x) {
               py::typing::List<py::typing::List<RealNumber>> result_lists;
@@ -1070,11 +1082,25 @@ TEST_SUBMODULE(pytypes, m) {
               }
               return result_lists;
           });
-    m.def("half_of_number_dict", [](const py::typing::Dict<std::string, RealNumber> &x) {
-        py::typing::Dict<std::string, RealNumber> result;
-        for (auto it : x) {
-            result[it.first] = RealNumber{it.second.cast<RealNumber>().value / 2};
-        }
-        return result;
-    });
+    // Set<T>
+    m.def("identity_set", [](const py::typing::Set<RealNumber> &x) { return x; });
+    // Iterable<T>
+    m.def("identity_iterable", [](const py::typing::Iterable<RealNumber> &x) { return x; });
+    // Iterator<T>
+    m.def("identity_iterator", [](const py::typing::Iterator<RealNumber> &x) { return x; });
+    // Callable<R(A)>
+    // m.def("get_identity_callable", []() -> py::typing::Callable<RealNumber(const RealNumber &)>
+    // { return [](const RealNumber &x) { return x; };
+    // });
+    // Callable<R(...)>
+    // m.def("get_identity_callable_only_return",
+    //   []() -> py::typing::Callable<RealNumber(py::ellipsis)> {
+    //   return [](const RealNumber &x) { return x; };
+    //   });
+    // Union<T1, T2>
+    m.def("identity_union", [](const py::typing::Union<RealNumber, std::string> &x) { return x; });
+    // Optional<T>
+    m.def("identity_optional", [](const py::typing::Optional<RealNumber> &x) { return x; });
+    // TypeGuard<T>
+    // TypeIs<T>
 }

tests/test_pytypes.py

@@ -1110,23 +1110,57 @@ def test_arg_return_type_hints(doc):
     assert m.half_of_number(0) == 0
     assert isinstance(m.half_of_number(0), float)
     assert not isinstance(m.half_of_number(0), int)
+    # Tuple<T, T>
     assert (
         doc(m.half_of_number_tuple)
         == "half_of_number_tuple(arg0: tuple[Union[float, int], Union[float, int]]) -> tuple[float, float]"
     )
+    # Tuple<T, ...>
     assert (
         doc(m.half_of_number_tuple_ellipsis)
         == "half_of_number_tuple_ellipsis(arg0: tuple[Union[float, int], ...]) -> tuple[float, ...]"
     )
+    # Dict<K, V>
+    assert (
+        doc(m.half_of_number_dict)
+        == "half_of_number_dict(arg0: dict[str, Union[float, int]]) -> dict[str, float]"
+    )
+    # List<T>
     assert (
         doc(m.half_of_number_list)
         == "half_of_number_list(arg0: list[Union[float, int]]) -> list[float]"
     )
+    # List<List<T>>
     assert (
         doc(m.half_of_number_nested_list)
         == "half_of_number_nested_list(arg0: list[list[Union[float, int]]]) -> list[list[float]]"
     )
+    # Set<T>
     assert (
-        doc(m.half_of_number_dict)
-        == "half_of_number_dict(arg0: dict[str, Union[float, int]]) -> dict[str, float]"
+        doc(m.identity_set)
+        == "identity_set(arg0: set[Union[float, int]]) -> set[float]"
+    )
+    # Iterable<T>
+    assert (
+        doc(m.identity_iterable)
+        == "identity_iterable(arg0: Iterable[Union[float, int]]) -> Iterable[float]"
+    )
+    # Iterator<T>
+    assert (
+        doc(m.identity_iterator)
+        == "identity_iterator(arg0: Iterator[Union[float, int]]) -> Iterator[float]"
+    )
+    # Callable<R(A)>
+    # Callable<R(...)>
+    # Union<T1, T2>
+    assert (
+        doc(m.identity_union)
+        == "identity_union(arg0: Union[Union[float, int], str]) -> Union[float, str]"
+    )
+    # Optional<T>
+    assert (
+        doc(m.identity_optional)
+        == "identity_optional(arg0: Optional[Union[float, int]]) -> Optional[float]"
     )
+    # TypeGuard<T>
+    # TypeIs<T>