separate cpp and python tests, and generate variants

configure_file will overrite boost_optional.cpp only if the content changes. This allow to a quick check on the actual code, and simplifies the cmake

Author: ahoarau

unittest/cpp/.clang-format-ignore

@@ -0,0 +1,4 @@
+boost_optional.cpp
+boost_variant.cpp
+std_variant.cpp
+std_optional.cpp

unittest/cpp/boost_optional.cpp

@@ -0,0 +1,81 @@
+///
+/// Copyright (c) 2023 CNRS INRIA
+///
+
+#include "eigenpy/eigenpy.hpp"
+#include "eigenpy/optional.hpp"
+#ifdef EIGENPY_WITH_CXX17_SUPPORT
+#include <optional>
+#endif
+
+#define TEST_TYPE boost::optional
+#define OPTIONAL TEST_TYPE
+
+typedef eigenpy::detail::nullopt_helper<OPTIONAL> none_helper;
+static auto OPT_NONE = none_helper::value();
+typedef OPTIONAL<double> opt_dbl;
+
+struct mystruct {
+  OPTIONAL<int> a;
+  opt_dbl b;
+  OPTIONAL<std::string> msg{"i am struct"};
+  mystruct() : a(OPT_NONE), b(OPT_NONE) {}
+  mystruct(int a, const opt_dbl &b = OPT_NONE) : a(a), b(b) {}
+};
+
+OPTIONAL<int> none_if_zero(int i) {
+  if (i == 0)
+    return OPT_NONE;
+  else
+    return i;
+}
+
+OPTIONAL<mystruct> create_if_true(bool flag, opt_dbl b = OPT_NONE) {
+  if (flag) {
+    return mystruct(0, b);
+  } else {
+    return OPT_NONE;
+  }
+}
+
+OPTIONAL<Eigen::MatrixXd> random_mat_if_true(bool flag) {
+  if (flag)
+    return Eigen::MatrixXd(Eigen::MatrixXd::Random(4, 4));
+  else
+    return OPT_NONE;
+}
+
+BOOST_PYTHON_MODULE(boost_optional) {
+  using namespace eigenpy;
+  OptionalConverter<int, OPTIONAL>::registration();
+  OptionalConverter<double, OPTIONAL>::registration();
+  OptionalConverter<std::string, OPTIONAL>::registration();
+  OptionalConverter<mystruct, OPTIONAL>::registration();
+  OptionalConverter<Eigen::MatrixXd, OPTIONAL>::registration();
+  enableEigenPy();
+
+  bp::class_<mystruct>("mystruct", bp::no_init)
+      .def(bp::init<>(bp::args("self")))
+      .def(bp::init<int, bp::optional<const opt_dbl &> >(
+          bp::args("self", "a", "b")))
+      .add_property(
+          "a",
+          bp::make_getter(&mystruct::a,
+                          bp::return_value_policy<bp::return_by_value>()),
+          bp::make_setter(&mystruct::a))
+      .add_property(
+          "b",
+          bp::make_getter(&mystruct::b,
+                          bp::return_value_policy<bp::return_by_value>()),
+          bp::make_setter(&mystruct::b))
+      .add_property(
+          "msg",
+          bp::make_getter(&mystruct::msg,
+                          bp::return_value_policy<bp::return_by_value>()),
+          bp::make_setter(&mystruct::msg));
+
+  bp::def("none_if_zero", none_if_zero, bp::args("i"));
+  bp::def("create_if_true", create_if_true,
+          (bp::arg("flag"), bp::arg("b") = OPT_NONE));
+  bp::def("random_mat_if_true", random_mat_if_true, bp::args("flag"));
+}

unittest/cpp/boost_variant.cpp

@@ -0,0 +1,92 @@
+/// @file
+/// @copyright Copyright 2024 CNRS INRIA
+
+#include <eigenpy/eigenpy.hpp>
+#include <eigenpy/variant.hpp>
+
+#include <string>
+#include <complex>
+
+#define TEST_TYPE boost::variant
+#define VARIANT TEST_TYPE
+
+namespace bp = boost::python;
+
+struct V1 {
+  int v;
+};
+struct V2 {
+  char v;
+};
+typedef VARIANT<V1, V2> MyVariant;
+
+template <typename Variant>
+struct MyVariantNoneHelper {};
+
+template <typename... Alternatives>
+struct MyVariantNoneHelper<boost::variant<Alternatives...> > {
+  typedef VARIANT<boost::blank, Alternatives...> type;
+};
+
+#ifdef EIGENPY_WITH_CXX17_SUPPORT
+template <typename... Alternatives>
+struct MyVariantNoneHelper<std::variant<Alternatives...> > {
+  typedef VARIANT<std::monostate, Alternatives...> type;
+};
+#endif
+
+typedef typename MyVariantNoneHelper<
+    VARIANT<V1, bool, int, double, std::string, std::complex<double> > >::type
+    MyVariantFull;
+
+MyVariant make_variant() { return V1(); }
+
+MyVariantFull make_variant_full_none() { return MyVariantFull(); }
+MyVariantFull make_variant_full_float() { return 3.14; }
+MyVariantFull make_variant_full_int() { return 3; }
+MyVariantFull make_variant_full_bool() { return false; }
+MyVariantFull make_variant_full_str() { return std::string("str"); }
+MyVariantFull make_variant_full_complex() { return std::complex<double>(1., 0.); }
+
+struct VariantHolder {
+  MyVariant variant;
+};
+
+struct VariantFullHolder {
+  MyVariantFull variant;
+};
+
+BOOST_PYTHON_MODULE(boost_variant) {
+  using namespace eigenpy;
+
+  enableEigenPy();
+
+  bp::class_<V1>("V1", bp::init<>()).def_readwrite("v", &V1::v);
+  bp::class_<V2>("V2", bp::init<>()).def_readwrite("v", &V2::v);
+
+  typedef eigenpy::VariantConverter<MyVariant> Converter;
+  Converter::registration();
+
+  bp::def("make_variant", make_variant);
+
+  boost::python::class_<VariantHolder>("VariantHolder", bp::init<>())
+      .add_property("variant",
+                    bp::make_getter(&VariantHolder::variant,
+                                    Converter::return_internal_reference()),
+                    bp::make_setter(&VariantHolder::variant));
+
+  typedef eigenpy::VariantConverter<MyVariantFull> ConverterFull;
+  ConverterFull::registration();
+  bp::def("make_variant_full_none", make_variant_full_none);
+  bp::def("make_variant_full_float", make_variant_full_float);
+  bp::def("make_variant_full_int", make_variant_full_int);
+  bp::def("make_variant_full_bool", make_variant_full_bool);
+  bp::def("make_variant_full_str", make_variant_full_str);
+  bp::def("make_variant_full_complex", make_variant_full_complex);
+
+  boost::python::class_<VariantFullHolder>("VariantFullHolder", bp::init<>())
+      .add_property("variant",
+                    bp::make_getter(&VariantFullHolder::variant,
+                                    ConverterFull::return_internal_reference()),
+                    bp::make_setter(&VariantFullHolder::variant));
+}