test updated

Author: JohanMabille

tests/test_numpy_array.cpp

@@ -15,7 +15,7 @@
 #include <cstdint>
 #include <vector>
 
-using arr = py::array;
+using arr = py::array<>;
 using arr_t = py::array_t<uint16_t, 0>;
 
 template<typename... Ix> arr data(const arr& a, Ix... index) {
@@ -100,8 +100,8 @@ test_initializer numpy_array([](py::module &m) {
         return py::array_t<float>({ 2, 2 }, { 8, 4 });
     });
 
-    sm.def("wrap", [](py::array a) {
-        return py::array(
+    sm.def("wrap", [](py::array<> a) {
+        return py::array<>(
             a.dtype(),
             std::vector<size_t>(a.shape(), a.shape() + a.ndim()),
             std::vector<size_t>(a.strides(), a.strides() + a.ndim()),
@@ -128,7 +128,7 @@ test_initializer numpy_array([](py::module &m) {
     sm.def("function_taking_uint64", [](uint64_t) { });
 
     sm.def("isinstance_untyped", [](py::object yes, py::object no) {
-        return py::isinstance<py::array>(yes) && !py::isinstance<py::array>(no);
+        return py::isinstance<py::array<>>(yes) && !py::isinstance<py::array<>>(no);
     });
 
     sm.def("isinstance_typed", [](py::object o) {
@@ -137,15 +137,15 @@ test_initializer numpy_array([](py::module &m) {
 
     sm.def("default_constructors", []() {
         return py::dict(
-            "array"_a=py::array(),
+            "array"_a=py::array<>(),
             "array_t<int32>"_a=py::array_t<std::int32_t>(),
             "array_t<double>"_a=py::array_t<double>()
         );
     });
 
     sm.def("converting_constructors", [](py::object o) {
         return py::dict(
-            "array"_a=py::array(o),
+            "array"_a=py::array<>(o),
             "array_t<int32>"_a=py::array_t<std::int32_t>(o),
             "array_t<double>"_a=py::array_t<double>(o)
         );

tests/test_numpy_dtypes.cpp

@@ -93,10 +93,10 @@ std::ostream& operator<<(std::ostream& os, const EnumStruct& v) {
 }
 
 template <typename T>
-py::array mkarray_via_buffer(size_t n) {
-    return py::array(py::buffer_info(nullptr, sizeof(T),
-                                     py::format_descriptor<T>::format(),
-                                     1, { n }, { sizeof(T) }));
+py::array<> mkarray_via_buffer(size_t n) {
+    return py::array<>(py::buffer_info(nullptr, sizeof(T),
+                                       py::format_descriptor<T>::format(),
+                                       1, { n }, { sizeof(T) }));
 }
 
 template <typename S>
@@ -228,7 +228,7 @@ py::array_t<int32_t, 0> test_array_ctors(int i) {
     py::buffer_info buf_ndim2(vptr, 4, "i", 2, shape, strides);
     py::buffer_info buf_ndim2_null(nullptr, 4, "i", 2, shape, strides);
 
-    auto fill = [](py::array arr) {
+    auto fill = [](py::array<> arr) {
         auto req = arr.request();
         for (int i = 0; i < 6; i++) ((int32_t *) req.ptr)[i] = i + 1;
         return arr;
@@ -237,34 +237,34 @@ py::array_t<int32_t, 0> test_array_ctors(int i) {
     switch (i) {
     // shape: (3, 2)
     case 10: return arr_t(shape, strides, ptr);
-    case 11: return py::array(shape, strides, ptr);
-    case 12: return py::array(dtype, shape, strides, vptr);
+    case 11: return py::array<>(shape, strides, ptr);
+    case 12: return py::array<>(dtype, shape, strides, vptr);
     case 13: return arr_t(shape, ptr);
-    case 14: return py::array(shape, ptr);
-    case 15: return py::array(dtype, shape, vptr);
+    case 14: return py::array<>(shape, ptr);
+    case 15: return py::array<>(dtype, shape, vptr);
     case 16: return arr_t(buf_ndim2);
-    case 17: return py::array(buf_ndim2);
+    case 17: return py::array<>(buf_ndim2);
     // shape: (3, 2) - post-fill
     case 20: return fill(arr_t(shape, strides));
-    case 21: return py::array(shape, strides, ptr); // can't have nullptr due to templated ctor
-    case 22: return fill(py::array(dtype, shape, strides));
+    case 21: return py::array<>(shape, strides, ptr); // can't have nullptr due to templated ctor
+    case 22: return fill(py::array<>(dtype, shape, strides));
     case 23: return fill(arr_t(shape));
-    case 24: return py::array(shape, ptr); // can't have nullptr due to templated ctor
-    case 25: return fill(py::array(dtype, shape));
+    case 24: return py::array<>(shape, ptr); // can't have nullptr due to templated ctor
+    case 25: return fill(py::array<>(dtype, shape));
     case 26: return fill(arr_t(buf_ndim2_null));
-    case 27: return fill(py::array(buf_ndim2_null));
+    case 27: return fill(py::array<>(buf_ndim2_null));
     // shape: (6, )
     case 30: return arr_t(6, ptr);
-    case 31: return py::array(6, ptr);
-    case 32: return py::array(dtype, 6, vptr);
+    case 31: return py::array<>(6, ptr);
+    case 32: return py::array<>(dtype, 6, vptr);
     case 33: return arr_t(buf_ndim1);
-    case 34: return py::array(buf_ndim1);
+    case 34: return py::array<>(buf_ndim1);
     // shape: (6, )
     case 40: return fill(arr_t(6));
-    case 41: return py::array(6, ptr);  // can't have nullptr due to templated ctor
-    case 42: return fill(py::array(dtype, 6));
+    case 41: return py::array<>(6, ptr);  // can't have nullptr due to templated ctor
+    case 42: return fill(py::array<>(dtype, 6));
     case 43: return fill(arr_t(buf_ndim1_null));
-    case 44: return fill(py::array(buf_ndim1_null));
+    case 44: return fill(py::array<>(buf_ndim1_null));
     }
     return arr_t();
 }

tests/test_numpy_vectorize.cpp

@@ -35,7 +35,7 @@ test_initializer numpy_vectorize([](py::module &m) {
     m.def("vectorized_func3", py::vectorize(my_func3));
 
     /// Numpy function which only accepts specific data types
-    m.def("selective_func", [](py::array_t<int, py::array::c_style>) { return "Int branch taken."; });
-    m.def("selective_func", [](py::array_t<float, py::array::c_style>) { return "Float branch taken."; });
-    m.def("selective_func", [](py::array_t<std::complex<float>, py::array::c_style>) { return "Complex float branch taken."; });
+    m.def("selective_func", [](py::array_t<int, py::array<>::c_style>) { return "Int branch taken."; });
+    m.def("selective_func", [](py::array_t<float, py::array<>::c_style>) { return "Float branch taken."; });
+    m.def("selective_func", [](py::array_t<std::complex<float>, py::array<>::c_style>) { return "Complex float branch taken."; });
 });