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/test_python-syntax_error.py

+# flake8: noqa
+hello world