Add task composer taskflow unit tests

tesseract_task_composer/core/CMakeLists.txt

@@ -2,7 +2,6 @@ add_library(
   ${PROJECT_NAME}
   src/task_composer_data_storage.cpp
   src/task_composer_executor.cpp
-  src/task_composer_future.cpp
   src/task_composer_graph.cpp
   src/task_composer_input.cpp
   src/task_composer_node.cpp

tesseract_task_composer/core/include/tesseract_task_composer/core/task_composer_executor.h

@@ -55,36 +55,11 @@ class TaskComposerExecutor
 
   /**
    * @brief Execute the provided node
-   * @details It will call one of the pure virtual methods below based on the node type
    * @param node The node to execute
    * @param task_input The task input provided to every task
    * @return The future associated with execution
    */
-  virtual TaskComposerFuture::UPtr run(const TaskComposerNode& node, TaskComposerInput& task_input);
-
-  /**
-   * @brief Execute the provided task graph
-   * @param task_graph The task graph to execute
-   * @param task_input The task input provided to every task
-   * @return The future associated with execution
-   */
-  virtual TaskComposerFuture::UPtr run(const TaskComposerGraph& task_graph, TaskComposerInput& task_input) = 0;
-
-  /**
-   * @brief Execute the provided task pipeline
-   * @param task_pipeline The task pipeline to execute
-   * @param task_input The task input provided to every task
-   * @return The future associated with execution
-   */
-  virtual TaskComposerFuture::UPtr run(const TaskComposerPipeline& task_pipeline, TaskComposerInput& task_input) = 0;
-
-  /**
-   * @brief Execute the provided task
-   * @param task_graph The task to execute
-   * @param task_input The task input provided to task
-   * @return The future associated with execution
-   */
-  virtual TaskComposerFuture::UPtr run(const TaskComposerTask& task, TaskComposerInput& task_input) = 0;
+  virtual TaskComposerFuture::UPtr run(const TaskComposerNode& node, TaskComposerInput& task_input) = 0;
 
   /** @brief Queries the number of workers (example: number of threads) */
   virtual long getWorkerCount() const = 0;

tesseract_task_composer/core/include/tesseract_task_composer/core/task_composer_future.h

@@ -33,8 +33,6 @@ TESSERACT_COMMON_IGNORE_WARNINGS_PUSH
 #include <memory>
 TESSERACT_COMMON_IGNORE_WARNINGS_POP
 
-#include <tesseract_common/serialization.h>
-
 namespace tesseract_planning
 {
 /**
@@ -87,18 +85,7 @@ class TaskComposerFuture
    * @return A copy, for example to allow access from multiple thread
    */
   virtual TaskComposerFuture::UPtr copy() const = 0;
-
-  bool operator==(const TaskComposerFuture& rhs) const;
-  bool operator!=(const TaskComposerFuture& rhs) const;
-
-private:
-  friend struct tesseract_common::Serialization;
-  friend class boost::serialization::access;
-  template <class Archive>
-  void serialize(Archive& ar, const unsigned int version);  // NOLINT
 };
 }  // namespace tesseract_planning
 
-#include <boost/serialization/export.hpp>
-BOOST_CLASS_EXPORT_KEY2(tesseract_planning::TaskComposerFuture, "TaskComposerFuture")
 #endif  // TESSERACT_TASK_COMPOSER_TASK_COMPOSER_FUTURE_H

tesseract_task_composer/core/include/tesseract_task_composer/core/task_composer_node.h

@@ -40,6 +40,7 @@ namespace tesseract_planning
 {
 enum class TaskComposerNodeType
 {
+  NODE,
   TASK,
   PIPELINE,
   GRAPH
@@ -55,7 +56,7 @@ class TaskComposerNode
   using ConstUPtr = std::unique_ptr<const TaskComposerNode>;
 
   TaskComposerNode(std::string name = "TaskComposerNode",
-                   TaskComposerNodeType type = TaskComposerNodeType::TASK,
+                   TaskComposerNodeType type = TaskComposerNodeType::NODE,
                    bool conditional = false);
   explicit TaskComposerNode(std::string name, TaskComposerNodeType type, const YAML::Node& config);
   virtual ~TaskComposerNode() = default;

tesseract_task_composer/core/include/tesseract_task_composer/core/test_suite/task_composer_serialization_utils.hpp

@@ -7,6 +7,7 @@ TESSERACT_COMMON_IGNORE_WARNINGS_PUSH
 #include <boost/archive/xml_oarchive.hpp>
 #include <boost/archive/xml_iarchive.hpp>
 #include <boost/serialization/unique_ptr.hpp>
+#include <boost/serialization/shared_ptr.hpp>
 #include <fstream>
 TESSERACT_COMMON_IGNORE_WARNINGS_POP
 

tesseract_task_composer/core/src/task_composer_executor.cpp

@@ -37,20 +37,6 @@ TaskComposerExecutor::TaskComposerExecutor(std::string name) : name_(std::move(n
 
 const std::string& TaskComposerExecutor::getName() const { return name_; }
 
-TaskComposerFuture::UPtr TaskComposerExecutor::run(const TaskComposerNode& node, TaskComposerInput& task_input)
-{
-  if (node.getType() == TaskComposerNodeType::TASK)
-    return run(static_cast<const TaskComposerTask&>(node), task_input);
-
-  if (node.getType() == TaskComposerNodeType::PIPELINE)
-    return run(static_cast<const TaskComposerPipeline&>(node), task_input);
-
-  if (node.getType() == TaskComposerNodeType::GRAPH)
-    return run(static_cast<const TaskComposerGraph&>(node), task_input);
-
-  throw std::runtime_error("TaskComposerExecutor, unsupported node type!");
-}
-
 bool TaskComposerExecutor::operator==(const TaskComposerExecutor& rhs) const { return (name_ == rhs.name_); }
 
 bool TaskComposerExecutor::operator!=(const TaskComposerExecutor& rhs) const { return !operator==(rhs); }

tesseract_task_composer/taskflow/include/tesseract_task_composer/taskflow/taskflow_task_composer_executor.h

@@ -59,11 +59,7 @@ class TaskflowTaskComposerExecutor : public TaskComposerExecutor
   TaskflowTaskComposerExecutor(TaskflowTaskComposerExecutor&&) = delete;
   TaskflowTaskComposerExecutor& operator=(TaskflowTaskComposerExecutor&&) = delete;
 
-  TaskComposerFuture::UPtr run(const TaskComposerGraph& task_graph, TaskComposerInput& task_input) override final;
-
-  TaskComposerFuture::UPtr run(const TaskComposerPipeline& task_pipeline, TaskComposerInput& task_input) override final;
-
-  TaskComposerFuture::UPtr run(const TaskComposerTask& task, TaskComposerInput& task_input) override final;
+  TaskComposerFuture::UPtr run(const TaskComposerNode& node, TaskComposerInput& task_input) override final;
 
   long getWorkerCount() const override final;
 

tesseract_task_composer/taskflow/include/tesseract_task_composer/taskflow/taskflow_task_composer_future.h

@@ -26,6 +26,12 @@
 #ifndef TESSERACT_TASK_COMPOSER_TASKFLOW_TASK_COMPOSER_FUTURE_H
 #define TESSERACT_TASK_COMPOSER_TASKFLOW_TASK_COMPOSER_FUTURE_H
 
+#include <tesseract_common/macros.h>
+TESSERACT_COMMON_IGNORE_WARNINGS_PUSH
+#include <memory>
+#include <vector>
+TESSERACT_COMMON_IGNORE_WARNINGS_POP
+
 #include <tesseract_task_composer/core/task_composer_future.h>
 
 namespace tf
@@ -63,15 +69,7 @@ class TaskflowTaskComposerFuture : public TaskComposerFuture
 
   TaskComposerFuture::UPtr copy() const override final;
 
-  bool operator==(const TaskflowTaskComposerFuture& rhs) const;
-  bool operator!=(const TaskflowTaskComposerFuture& rhs) const;
-
 private:
-  friend struct tesseract_common::Serialization;
-  friend class boost::serialization::access;
-  template <class Archive>
-  void serialize(Archive& ar, const unsigned int version);  // NOLINT
-
   /** @brief This is the future return from taskflow executor.run */
   std::shared_future<void> future_;
 
@@ -80,7 +78,4 @@ class TaskflowTaskComposerFuture : public TaskComposerFuture
 };
 }  // namespace tesseract_planning
 
-#include <boost/serialization/export.hpp>
-#include <boost/serialization/tracking.hpp>
-BOOST_CLASS_EXPORT_KEY2(tesseract_planning::TaskflowTaskComposerFuture, "TaskflowTaskComposerFuture")
 #endif  // TESSERACT_TASK_COMPOSER_TASKFLOW_TASK_COMPOSER_FUTURE_H

tesseract_task_composer/taskflow/src/taskflow_task_composer_executor.cpp

@@ -68,44 +68,24 @@ TaskflowTaskComposerExecutor::TaskflowTaskComposerExecutor(std::string name, con
 
 TaskflowTaskComposerExecutor::~TaskflowTaskComposerExecutor() = default;
 
-TaskComposerFuture::UPtr TaskflowTaskComposerExecutor::run(const TaskComposerGraph& task_graph,
-                                                           TaskComposerInput& task_input)
+TaskComposerFuture::UPtr TaskflowTaskComposerExecutor::run(const TaskComposerNode& node, TaskComposerInput& task_input)
 {
-  auto taskflow = convertToTaskflow(task_graph, task_input, *this);
-  std::shared_future<void> f = executor_->run(*(taskflow->front()));
-
-  //  std::ofstream out_data;
-  //  out_data.open(tesseract_common::getTempPath() + "task_composer_example.dot");
-  //  taskflow.top->dump(out_data);  // dump the graph including dynamic tasks
-  //  out_data.close();
-
-  return std::make_unique<TaskflowTaskComposerFuture>(f, std::move(taskflow));
-}
-
-TaskComposerFuture::UPtr TaskflowTaskComposerExecutor::run(const TaskComposerPipeline& task_pipeline,
-                                                           TaskComposerInput& task_input)
-{
-  auto taskflow = convertToTaskflow(task_pipeline, task_input, *this);
-  std::shared_future<void> f = executor_->run(*(taskflow->front()));
+  std::shared_ptr<std::vector<std::unique_ptr<tf::Taskflow>>> taskflow;
+  if (node.getType() == TaskComposerNodeType::TASK)
+    taskflow = convertToTaskflow(static_cast<const TaskComposerTask&>(node), task_input, *this);
+  else if (node.getType() == TaskComposerNodeType::PIPELINE)
+    taskflow = convertToTaskflow(static_cast<const TaskComposerPipeline&>(node), task_input, *this);
+  else if (node.getType() == TaskComposerNodeType::GRAPH)
+    taskflow = convertToTaskflow(static_cast<const TaskComposerGraph&>(node), task_input, *this);
+  else
+    throw std::runtime_error("TaskComposerExecutor, unsupported node type!");
 
   //  std::ofstream out_data;
   //  out_data.open(tesseract_common::getTempPath() + "task_composer_example.dot");
   //  taskflow.top->dump(out_data);  // dump the graph including dynamic tasks
   //  out_data.close();
 
-  return std::make_unique<TaskflowTaskComposerFuture>(f, std::move(taskflow));
-}
-
-TaskComposerFuture::UPtr TaskflowTaskComposerExecutor::run(const TaskComposerTask& task, TaskComposerInput& task_input)
-{
-  auto taskflow = convertToTaskflow(task, task_input, *this);
   std::shared_future<void> f = executor_->run(*(taskflow->front()));
-
-  //  std::ofstream out_data;
-  //  out_data.open(tesseract_common::getTempPath() + "task_composer_example.dot");
-  //  taskflow.top->dump(out_data);  // dump the graph including dynamic tasks
-  //  out_data.close();
-
   return std::make_unique<TaskflowTaskComposerFuture>(f, std::move(taskflow));
 }
 
@@ -117,7 +97,6 @@ bool TaskflowTaskComposerExecutor::operator==(const TaskflowTaskComposerExecutor
 {
   bool equal = true;
   equal &= (num_threads_ == rhs.num_threads_);
-  equal &= (executor_ == rhs.executor_);
   equal &= TaskComposerExecutor::operator==(rhs);
   return equal;
 }
@@ -176,7 +155,7 @@ TaskflowTaskComposerExecutor::convertToTaskflow(const TaskComposerGraph& task_gr
                                 ->emplace([task, &task_input, &task_executor] { task->run(task_input, task_executor); })
                                 .name(pair.second->getName());
     }
-    if (pair.second->getType() == TaskComposerNodeType::PIPELINE)
+    else if (pair.second->getType() == TaskComposerNodeType::PIPELINE)
     {
       auto pipeline = std::static_pointer_cast<const TaskComposerPipeline>(pair.second);
       if (edges.size() > 1 && pipeline->isConditional())

tesseract_task_composer/taskflow/src/taskflow_task_composer_future.cpp

@@ -24,18 +24,6 @@
  * limitations under the License.
  */
 
-#include <tesseract_common/macros.h>
-TESSERACT_COMMON_IGNORE_WARNINGS_PUSH
-#include <boost/serialization/nvp.hpp>
-#if (BOOST_VERSION >= 107400) && (BOOST_VERSION < 107500)
-#include <boost/serialization/library_version_type.hpp>
-#endif
-#include <boost/serialization/unordered_map.hpp>
-#include <boost/serialization/vector.hpp>
-#include <boost/serialization/unique_ptr.hpp>
-#include <boost/serialization/shared_ptr.hpp>
-TESSERACT_COMMON_IGNORE_WARNINGS_POP
-
 #include <tesseract_task_composer/taskflow/taskflow_task_composer_future.h>
 
 namespace tesseract_planning
@@ -83,25 +71,4 @@ TaskComposerFuture::UPtr TaskflowTaskComposerFuture::copy() const
   return clone;
 }
 
-bool TaskflowTaskComposerFuture::operator==(const tesseract_planning::TaskflowTaskComposerFuture& rhs) const
-{
-  bool equal = true;
-  equal &= future_.valid() == rhs.future_.valid();
-  return equal;
-}
-
-bool TaskflowTaskComposerFuture::operator!=(const tesseract_planning::TaskflowTaskComposerFuture& rhs) const
-{
-  return !operator==(rhs);
-}
-
-template <class Archive>
-void TaskflowTaskComposerFuture::serialize(Archive& ar, const unsigned int /*version*/)
-{
-  ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(TaskComposerFuture);
-}
-
 }  // namespace tesseract_planning
-#include <tesseract_common/serialization.h>
-TESSERACT_SERIALIZE_ARCHIVES_INSTANTIATE(tesseract_planning::TaskflowTaskComposerFuture)
-BOOST_CLASS_EXPORT_IMPLEMENT(tesseract_planning::TaskflowTaskComposerFuture)

tesseract_task_composer/test/CMakeLists.txt

@@ -118,3 +118,27 @@ target_code_coverage(
 add_gtest_discover_tests(${PROJECT_NAME}_core_unit)
 add_dependencies(run_tests ${PROJECT_NAME}_core_unit)
 add_dependencies(${PROJECT_NAME}_core_unit ${PROJECT_NAME})
+
+# Taskflow Tests
+add_executable(${PROJECT_NAME}_taskflow_unit ${PROJECT_NAME}_taskflow_unit.cpp)
+target_link_libraries(
+  ${PROJECT_NAME}_taskflow_unit
+  PRIVATE GTest::GTest
+          GTest::Main
+          ${PROJECT_NAME}
+          ${PROJECT_NAME}_nodes
+          ${PROJECT_NAME}_taskflow)
+target_include_directories(${PROJECT_NAME}_taskflow_unit PUBLIC "$<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/examples>")
+target_compile_options(${PROJECT_NAME}_taskflow_unit PRIVATE ${TESSERACT_COMPILE_OPTIONS_PRIVATE}
+                                                             ${TESSERACT_COMPILE_OPTIONS_PUBLIC})
+target_clang_tidy(${PROJECT_NAME}_taskflow_unit ENABLE ${TESSERACT_ENABLE_CLANG_TIDY})
+target_cxx_version(${PROJECT_NAME}_taskflow_unit PRIVATE VERSION ${TESSERACT_CXX_VERSION})
+target_code_coverage(
+  ${PROJECT_NAME}_taskflow_unit
+  PRIVATE
+  ALL
+  EXCLUDE ${COVERAGE_EXCLUDE}
+  ENABLE ${TESSERACT_ENABLE_CODE_COVERAGE})
+add_gtest_discover_tests(${PROJECT_NAME}_taskflow_unit)
+add_dependencies(run_tests ${PROJECT_NAME}_taskflow_unit)
+add_dependencies(${PROJECT_NAME}_taskflow_unit ${PROJECT_NAME})

tesseract_task_composer/test/tesseract_task_composer_core_unit.cpp

@@ -146,7 +146,7 @@ TEST(TesseractTaskComposerCoreUnit, TaskComposerNodeTests)  // NOLINT
   auto node = std::make_unique<TaskComposerNode>();
   // Default
   EXPECT_EQ(node->getName(), "TaskComposerNode");
-  EXPECT_EQ(node->getType(), TaskComposerNodeType::TASK);
+  EXPECT_EQ(node->getType(), TaskComposerNodeType::NODE);
   EXPECT_FALSE(node->getUUID().is_nil());
   EXPECT_FALSE(node->getUUIDString().empty());
   EXPECT_TRUE(node->getParentUUID().is_nil());