tests/CMakeLists.txt

+# Copyright 2010-2020, Florent Lamiraux, Thomas Moulard, Olivier Stasse, Guilhem
+# Saurel, JRL, CNRS/AIST, LAAS-CNRS
+
+# Test the interpreter
+add_unit_test(interpreter-test interpreter-test.cc)
+target_link_libraries(interpreter-test PRIVATE ${PROJECT_NAME})
+
+# Test runfile
+add_unit_test(interpreter-test-runfile interpreter-test-runfile.cc)
+target_link_libraries(interpreter-test-runfile PRIVATE ${PROJECT_NAME})
+target_include_directories(interpreter-test-runfile
+                           PRIVATE Boost::unit_test_framework)
+target_compile_definitions(interpreter-test-runfile
+                           PRIVATE PATH="${CMAKE_CURRENT_LIST_DIR}/")
+
+# Test the module generation Create an entity
+
+set(LIBRARY_NAME "custom_entity")
+add_library(${LIBRARY_NAME} SHARED "${LIBRARY_NAME}.cpp")
+if(SUFFIX_SO_VERSION)
+  set_target_properties(${LIBRARY_NAME} PROPERTIES SOVERSION ${PROJECT_VERSION})
+endif(SUFFIX_SO_VERSION)
+
+target_link_libraries(${LIBRARY_NAME} PRIVATE dynamic-graph::dynamic-graph)
+
+# Create its bindings This mimics DYNAMIC_GRAPH_PYTHON_MODULE(${LIBRARY_NAME}
+# ${LIBRARY_NAME} "${LIBRARY_NAME}-wrap")
+
+configure_file(
+  ${PROJECT_SOURCE_DIR}/cmake/dynamic_graph/submodule/__init__.py.cmake
+  ${CMAKE_CURRENT_BINARY_DIR}/${LIBRARY_NAME}/__init__.py)
+set(PYTHON_MODULE "${LIBRARY_NAME}-wrap")
+set(DYNAMICGRAPH_MODULE_HEADER
+    "${CMAKE_SOURCE_DIR}/tests/custom_entity_module.h")
+configure_file(${PROJECT_SOURCE_DIR}/cmake/dynamic_graph/python-module-py.cc.in
+               ${CMAKE_CURRENT_BINARY_DIR}/python-module-py.cc @ONLY)
+add_library(${PYTHON_MODULE} MODULE
+            ${CMAKE_CURRENT_BINARY_DIR}/python-module-py.cc)
+set_target_properties(${PYTHON_MODULE}
+                      PROPERTIES PREFIX "" OUTPUT_NAME ${LIBRARY_NAME}/wrap)
+
+if(UNIX AND NOT APPLE)
+  target_link_libraries(${PYTHON_MODULE} PRIVATE "-Wl,--no-as-needed")
+endif(UNIX AND NOT APPLE)
+
+target_link_libraries(${PYTHON_MODULE} PRIVATE ${LIBRARY_NAME} ${PROJECT_NAME})
+
+# Test it
+add_python_unit_test("test-custom-entity" "tests/test_custom_entity.py" src
+                     tests)
+
+# also test other bindings, using this custom entity
+add_python_unit_test("test-bindings" "tests/test_bindings.py" src tests)

tests/custom_entity.cpp

+/* Copyright 2010-2019 LAAS, CNRS
+ * Thomas Moulard.
+ *
+ */
+
+#define ENABLE_RT_LOG
+
+#include "custom_entity.h"
+
+#include <dynamic-graph/command-bind.h>
+#include <dynamic-graph/entity.h>
+#include <dynamic-graph/exception-factory.h>
+#include <dynamic-graph/factory.h>
+#include <dynamic-graph/pool.h>
+#include <dynamic-graph/real-time-logger.h>
+#include <dynamic-graph/signal-ptr.h>
+#include <dynamic-graph/signal-time-dependent.h>
+
+#include <boost/bind.hpp>
+
+namespace dynamicgraph {
+
+CustomEntity::CustomEntity(const std::string n)
+    : Entity(n),
+      m_sigdSIN(NULL, "CustomEntity(" + name + ")::input(double)::in_double"),
+      m_sigdTimeDepSOUT(boost::bind(&CustomEntity::update, this, _1, _2),
+                        m_sigdSIN,
+                        "CustomEntity(" + name + ")::input(double)::out_double")
+
+{
+  addSignal();
+
+  using namespace dynamicgraph::command;
+
+  this->addCommand("act",
+                   makeCommandVoid0(*this, &CustomEntity::act,
+                                    docCommandVoid0("act on input signal")));
+}
+
+void CustomEntity::addSignal() {
+  signalRegistration(m_sigdSIN << m_sigdTimeDepSOUT);
+}
+
+void CustomEntity::rmValidSignal() {
+  signalDeregistration("in_double");
+  signalDeregistration("out_double");
+}
+
+double &CustomEntity::update(double &res, const int &inTime) {
+  const double &aDouble = m_sigdSIN(inTime);
+  res = aDouble;
+  logger().stream(MSG_TYPE_ERROR) << "start update " << res << '\n';
+  DYNAMIC_GRAPH_ENTITY_DEBUG(*this)
+      << "This is a message of level MSG_TYPE_DEBUG\n";
+  DYNAMIC_GRAPH_ENTITY_INFO(*this)
+      << "This is a message of level MSG_TYPE_INFO\n";
+  DYNAMIC_GRAPH_ENTITY_WARNING(*this)
+      << "This is a message of level MSG_TYPE_WARNING\n";
+  DYNAMIC_GRAPH_ENTITY_ERROR(*this)
+      << "This is a message of level MSG_TYPE_ERROR\n";
+  DYNAMIC_GRAPH_ENTITY_DEBUG_STREAM(*this)
+      << "This is a message of level MSG_TYPE_DEBUG_STREAM\n";
+  DYNAMIC_GRAPH_ENTITY_INFO_STREAM(*this)
+      << "This is a message of level MSG_TYPE_INFO_STREAM\n";
+  DYNAMIC_GRAPH_ENTITY_WARNING_STREAM(*this)
+      << "This is a message of level MSG_TYPE_WARNING_STREAM\n";
+  DYNAMIC_GRAPH_ENTITY_ERROR_STREAM(*this)
+      << "This is a message of level MSG_TYPE_ERROR_STREAM\n";
+  logger().stream(MSG_TYPE_ERROR) << "end update\n";
+  return res;
+}
+
+void CustomEntity::act() { m_sigdSIN.accessCopy(); }
+
+DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN(CustomEntity, "CustomEntity");
+}  // namespace dynamicgraph

tests/custom_entity.h

+/* Copyright 2020 LAAS, CNRS
+ * Joseph Mirabel
+ *
+ */
+
+#define ENABLE_RT_LOG
+
+#include <dynamic-graph/entity.h>
+#include <dynamic-graph/signal-ptr.h>
+#include <dynamic-graph/signal-time-dependent.h>
+
+#include <sstream>
+
+namespace dynamicgraph {
+class CustomEntity : public Entity {
+ public:
+  dynamicgraph::SignalPtr<double, int> m_sigdSIN;
+  dynamicgraph::SignalTimeDependent<double, int> m_sigdTimeDepSOUT;
+
+  DYNAMIC_GRAPH_ENTITY_DECL();
+  CustomEntity(const std::string n);
+
+  void addSignal();
+
+  void rmValidSignal();
+
+  double &update(double &res, const int &inTime);
+
+  void act();
+};
+}  // namespace dynamicgraph

tests/custom_entity_module.h

+#include "custom_entity.h"
+
+typedef boost::mpl::vector<dynamicgraph::CustomEntity> entities_t;

unitTesting/dynamic-graph-python-test.cc → tests/dynamic-graph-python-test.cc

@@ -2,10 +2,10 @@
  *  Copyright
  */
 
+#include "dynamic-graph-python-test.hh"
+
 #include <iostream>
-#include "dynamic-graph-python-test.hh" 
 
-GraphTest::GraphTest()
-{
+GraphTest::GraphTest() {
   std::cout << "Constructor of unitTesting object of class Graph." << std::endl;
 }

tests/dynamic-graph-python-test.cpp

+/*
+ *  Copyright
+ */
+
+#include "dynamic-graph-python-test.hh"
+
+#include <iostream>
+
+GraphTest::GraphTest() {
+  std::cout << "Constructor of unitTesting object of class Graph." << std::endl;
+}

unitTesting/dynamic-graph-python-test.hh → tests/dynamic-graph-python-test.hh

@@ -5,19 +5,19 @@
 #ifndef DYNAMIC_GRAPH_PYTHON_HH
 #define DYNAMIC_GRAPH_PYTHON_HH
 
-#include "dynamic-graph-python/dynamic-graph-python.hh" 
+#include "dynamic-graph-python/dynamic-graph-python.hh"
 
 /**
  \brief UnitTesting class of class Graph
 */
-class GraphTest
-{
-public:
+class GraphTest {
+ public:
   /**
    \brief Constructor
   */
   GraphTest();
-private:
+
+ private:
   dynamic::Graph graph_;
 };
 

tests/interpreter-test-runfile.cc

+// The purpose of this unit test is to check the interpreter::runPythonFile
+// method
+#include <cstring>
+#include <iostream>
+
+#include "dynamic-graph/python/interpreter.hh"
+
+bool testFile(const std::string& filename, const std::string& expectedOutput,
+              int numTest) {
+  std::string err = "";
+  dynamicgraph::python::Interpreter interp;
+  for (int i = 0; i < numTest; ++i) {
+    interp.runPythonFile(filename, err);
+    if (err != expectedOutput) {
+      std::cerr << "At iteration " << i
+                << ", the output was not the one expected:" << std::endl;
+      std::cerr << " expected: " << expectedOutput << std::endl;
+      std::cerr << " err:      " << err << std::endl;
+      return false;
+    }
+  }
+  return true;
+}
+
+bool testInterpreterDestructor(const std::string& filename,
+                               const std::string& expectedOutput) {
+  std::string err = "";
+  {
+    dynamicgraph::python::Interpreter interp;
+    interp.runPythonFile(filename, err);
+  }
+  {
+    dynamicgraph::python::Interpreter interp;
+    interp.runPythonFile(filename, err);
+    if (err != expectedOutput) {
+      std::cerr << "The output was not the one expected:" << std::endl;
+      std::cerr << " expected: " << expectedOutput << std::endl;
+      std::cerr << " err:      " << err << std::endl;
+      return false;
+    }
+  }
+  return true;
+}
+
+int main(int argc, char** argv) {
+  // execute numerous time the same file.
+  // While running 1025, we can notice a change in the error.
+  // unfortunately, it can not be shown using a redirection of the streams
+  int numTest = 1025;
+  if (argc > 1) numTest = atoi(argv[1]);
+
+  bool res = true;
+  // This test succeeds only because it is launched before "test_python-ok.py"
+  // because re as been imported in a previous test and it is not
+  // safe to delete imported module...
+  res = testFile(PATH "test_python-name_error.py",
+                 std::string(
+                     "Traceback (most recent call last):\n"
+                     "  File \"" PATH
+                     "test_python-name_error.py\", line 7, in <module>\n"
+                     "    pathList = re.split(\":\", pkgConfigPath)  # noqa\n"
+                     "NameError: name 're' is not defined\n"),
+                 numTest) &&
+        res;
+
+  res = testFile(PATH "test_python-ok.py", "", numTest) && res;
+  res = testFile(PATH "unexistant_file.py",
+                 PATH "unexistant_file.py cannot be open", numTest) &&
+        res;
+  res = testFile(PATH "test_python-syntax_error.py",
+                 std::string("  File \"" PATH
+                             "test_python-syntax_error.py\", line 2\n"
+                             "    hello world\n"
+#if PY_MINOR_VERSION >= 10
+                             "          ^^^^^\n"
+#elif PY_MINOR_VERSION >= 8
+                             "          ^\n"
+#else
+                             "              ^\n"
+#endif
+                             "SyntaxError: invalid syntax\n"),
+                 numTest) &&
+        res;
+  res = testInterpreterDestructor(PATH "test_python-restart_interpreter.py",
+                                  "") &&
+        res;
+  return (res ? 0 : 1);
+}

tests/test_python-syntax_error.py

+# flake8: noqa
+hello world