Add generic float/complex to numpy_scalar<> tests

Author: aldanor

tests/test_numpy_scalars.cpp

@@ -7,6 +7,7 @@
   BSD-style license that can be found in the LICENSE file.
 */
 
+#include <complex>
 #include <cstdint>
 #include <string>
 #include <utility>
@@ -16,29 +17,44 @@
 
 namespace py = pybind11;
 
-template<typename T>
-void register_test(py::module& m, const char *name) {
+template<typename T, typename F>
+void register_test(py::module& m, const char *name, F&& func) {
     m.def("test_numpy_scalars", [=](py::numpy_scalar<T> v) {
-        return std::make_tuple(name, py::make_scalar(static_cast<T>(v.value + 1)));
+        return std::make_tuple(name, py::make_scalar(static_cast<T>(func(v.value))));
     }, py::arg("x"));
     m.def((std::string("test_") + name).c_str(), [=](py::numpy_scalar<T> v) {
-        return std::make_tuple(name, py::make_scalar(static_cast<T>(v.value + 1)));
+        return std::make_tuple(name, py::make_scalar(static_cast<T>(func(v.value))));
     }, py::arg("x"));
 }
 
+template<typename T>
+struct add {
+    T x;
+    add(T x) : x(x) {}
+    T operator()(T y) const { return static_cast<T>(x + y); }
+};
+
 TEST_SUBMODULE(numpy_scalars, m) {
     try { py::module::import("numpy"); }
     catch (...) { return; }
 
-    register_test<bool>(m, "bool");
-    register_test<int8_t>(m, "int8");
-    register_test<int16_t>(m, "int16");
-    register_test<int32_t>(m, "int32");
-    register_test<int64_t>(m, "int64");
-    register_test<uint8_t>(m, "uint8");
-    register_test<uint16_t>(m, "uint16");
-    register_test<uint32_t>(m, "uint32");
-    register_test<uint64_t>(m, "uint64");
-    register_test<float>(m, "float32");
-    register_test<double>(m, "float64");
+    using cfloat = std::complex<float>;
+    using cdouble = std::complex<double>;
+    using clongdouble = std::complex<long double>;
+
+    register_test<bool>(m, "bool", [](bool x) { return !x; });
+    register_test<int8_t>(m, "int8", add<int8_t>(-8));
+    register_test<int16_t>(m, "int16", add<int16_t>(-16));
+    register_test<int32_t>(m, "int32", add<int32_t>(-32));
+    register_test<int64_t>(m, "int64", add<int64_t>(-64));
+    register_test<uint8_t>(m, "uint8", add<uint8_t>(8));
+    register_test<uint16_t>(m, "uint16", add<uint16_t>(16));
+    register_test<uint32_t>(m, "uint32", add<uint32_t>(32));
+    register_test<uint64_t>(m, "uint64", add<uint64_t>(64));
+    register_test<float>(m, "float32", add<float>(0.125f));
+    register_test<double>(m, "float64", add<double>(0.25f));
+    register_test<long double>(m, "longdouble", add<long double>(0.5L));
+    register_test<cfloat>(m, "complex64", add<cfloat>({0, -0.125f}));
+    register_test<cdouble>(m, "complex128", add<cdouble>({0, -0.25}));
+    register_test<clongdouble>(m, "longcomplex", add<clongdouble>({0, -0.5L}));
 }

tests/test_numpy_scalars.py

@@ -4,66 +4,85 @@
 
 pytestmark = pytest.requires_numpy
 
+SCALAR_TYPES = {}
+
 with pytest.suppress(ImportError):
     import numpy as np
 
+    SCALAR_TYPES = dict([
+        (np.bool_, False),
+        (np.int8, -7),
+        (np.int16, -15),
+        (np.int32, -31),
+        (np.int64, -63),
+        (np.uint8, 9),
+        (np.uint16, 17),
+        (np.uint32, 33),
+        (np.uint64, 65),
+        (np.single, 1.125),
+        (np.double, 1.25),
+        (np.longdouble, 1.5),
+        (np.csingle, 1 - 0.125j),
+        (np.cdouble, 1 - 0.25j),
+        (np.clongdouble, 1 - 0.5j),
+    ])
 
-@pytest.fixture(scope='module')
-def scalar_types():
-    return [
-        np.bool_,
-        np.int8,
-        np.int16,
-        np.int32,
-        np.int64,
-        np.uint8,
-        np.uint16,
-        np.uint32,
-        np.uint64,
-        np.float32,
-        np.float64,
-    ]
+ALL_TYPES = [int, bool, float, bytes, str, type(None)] + list(SCALAR_TYPES)
 
 
-@pytest.fixture(scope='module')
-def other_types():
-    return [int, bool, float, bytes, str, np.complex64, type(None)]
+def type_name(tp):
+    try:
+        if tp is np.longdouble:
+            return 'longdouble'
+        elif issubclass(tp, np.floating):
+            return 'float' + str(8 * tp().itemsize)
+        elif tp is np.clongdouble:
+            return 'longcomplex'
+        elif issubclass(tp, np.complexfloating):
+            return 'complex' + str(8 * tp().itemsize)
+        return tp.__name__.rstrip('_')
+    except BaseException:
+        # no numpy
+        return str(tp)
 
 
-def signature(tp):
-    name = tp.__name__.rstrip('_')
-    return 'test_numpy_scalars(x: {tp}) -> Tuple[str, {tp}]'.format(tp=name)
+@pytest.fixture(scope='module', params=list(SCALAR_TYPES), ids=type_name)
+def scalar_type(request):
+    return request.param
 
 
-def test_numpy_scalars_single(scalar_types, other_types):
-    s_tp = 'str' if sys.version_info[0] >= 3 else 'unicode'
-    for scalar_type in scalar_types:
-        name = scalar_type.__name__.rstrip('_')
-        func = getattr(m, 'test_' + name)
-        sig = 'test_{tp}(x: {tp}) -> Tuple[{s_tp}, {tp}]\n'.format(tp=name, s_tp=s_tp)
-        assert func.__doc__ == sig
-        for tp in (scalar_types + other_types):
-            value = None if isinstance(None, tp) else tp()
-            if tp is scalar_type:
-                result = func(value)
-                assert result[0] == name
-                assert isinstance(result[1], tp)
-                assert result[1] == tp(1)
-            else:
-                with pytest.raises(TypeError):
-                    func(value)
+def expected_signature(tp):
+    s = 'str' if sys.version_info[0] >= 3 else 'unicode'
+    t = type_name(tp)
+    return 'test_{t}(x: {t}) -> Tuple[{s}, {t}]\n'.format(s=s, t=t)
 
 
-def test_numpy_scalars_overload(scalar_types, other_types):
-    func = m.test_numpy_scalars
-    for tp in (scalar_types + other_types):
-        value = None if isinstance(None, tp) else tp()
-        if tp in scalar_types:
-            name = tp.__name__.rstrip('_')
+def test_numpy_scalars_single(scalar_type):
+    expected = SCALAR_TYPES[scalar_type]
+    name = type_name(scalar_type)
+    func = getattr(m, 'test_' + name)
+    assert func.__doc__ == expected_signature(scalar_type)
+    for tp in ALL_TYPES:
+        value = None if isinstance(None, tp) else tp(1)
+        if tp is scalar_type:
             result = func(value)
             assert result[0] == name
             assert isinstance(result[1], tp)
-            assert result[1] == tp(1)
+            assert result[1] == tp(expected)
+        else:
+            with pytest.raises(TypeError):
+                func(value)
+
+
+def test_numpy_scalars_overload():
+    func = m.test_numpy_scalars
+    for tp in ALL_TYPES:
+        value = None if isinstance(None, tp) else tp(1)
+        if tp in SCALAR_TYPES:
+            result = func(value)
+            assert result[0] == type_name(tp)
+            assert isinstance(result[1], tp)
+            assert result[1] == tp(SCALAR_TYPES[tp])
         else:
             with pytest.raises(TypeError):
                 func(value)