Add node creation tests

amlip_cpp/test/unittest/node/CMakeLists.txt

@@ -26,13 +26,19 @@ all_library_sources(${TEST_SOURCES})
 set(TEST_LIST
         create_client
         create_server
-        create_turn
+        create_repeater
         create_parent
         create_status
         create_main
         create_computing
         create_model_sender
         create_model_receiver
+        create_async_main
+        create_async_computing
+        create_edge
+        create_inference
+        create_async_edge
+        create_async_inference
     )
 
 set(TEST_EXTRA_LIBRARIES

amlip_cpp/test/unittest/node/nodeCreationTest.cpp

@@ -29,6 +29,14 @@
 #include <amlip_cpp/node/workload_distribution/ComputingNode.hpp>
 #include <amlip_cpp/node/collaborative_learning/ModelManagerSenderNode.hpp>
 #include <amlip_cpp/node/collaborative_learning/ModelManagerReceiverNode.hpp>
+#include <amlip_cpp/node/workload_distribution/AsyncMainNode.hpp>
+#include <amlip_cpp/node/workload_distribution/AsyncComputingNode.hpp>
+#include <amlip_cpp/node/EdgeNode.hpp>
+#include <amlip_cpp/node/InferenceNode.hpp>
+#include <amlip_cpp/node/AsyncEdgeNode.hpp>
+#include <amlip_cpp/node/AsyncInferenceNode.hpp>
+
+
 
 #include <dds/Participant.hpp>
 
@@ -50,6 +58,79 @@ class DummyNode : public eprosima::amlip::node::ParentNode
 
 };
 
+class DummyListener : public node::SolutionListener,
+    public node::InferenceSolutionListener
+{
+public:
+
+    DummyListener()
+    {
+    }
+
+    virtual void solution_received(
+            const types::JobSolutionDataType& solution,
+            const types::TaskId& task_id,
+            const types::AmlipIdDataType& server_id) override
+    {
+        logUser(
+            AMLIPCPP_MANUAL_TEST,
+            "Solution received for task : " << task_id
+                                            << " answered from server : " << server_id
+                                            << " . Solution : " << solution << " .");
+    }
+
+    virtual void inference_received(
+            const types::InferenceSolutionDataType& solution,
+            const types::TaskId& task_id,
+            const types::AmlipIdDataType& server_id) override
+    {
+        logUser(
+            AMLIPCPP_MANUAL_TEST,
+            "Inference received for task : " << task_id
+                                             << " answered from server : " << server_id
+                                             << " . Inference : " << solution << " .");
+    }
+
+};
+
+class DummyReplier : public node::JobReplier, public node::InferenceReplier
+{
+public:
+
+    DummyReplier()
+    {
+    }
+
+    virtual types::JobSolutionDataType process_job(
+            const types::JobDataType& task,
+            const types::TaskId& task_id,
+            const types::AmlipIdDataType& client_id) override
+    {
+        types::JobSolutionDataType solution;
+        logUser(
+            AMLIPCPP_MANUAL_TEST,
+            "Job: " << task_id
+                    << " received from client : " << client_id
+                    << " .");
+        return solution;
+    }
+
+    virtual types::InferenceSolutionDataType process_inference(
+            const types::InferenceDataType& task,
+            const types::TaskId& task_id,
+            const types::AmlipIdDataType& client_id) override
+    {
+        types::InferenceSolutionDataType solution;
+        logUser(
+            AMLIPCPP_MANUAL_TEST,
+            "Info: " << task_id
+                     << " received from client : " << client_id
+                     << " .");
+        return solution;
+    }
+
+};
+
 } /* namespace test */
 } /* namespace node */
 } /* namespace amlip */
@@ -181,6 +262,96 @@ TEST(NodeCreationTest, create_model_receiver)
     ASSERT_EQ(types::NodeKind::model_receiver, node.node_kind());
 }
 
+/**
+ * Create AsyncMain Node
+ */
+TEST(NodeCreationTest, create_async_main)
+{
+    {
+        // Create listener
+        std::shared_ptr<node::test::DummyListener> listener =
+                std::make_shared<node::test::DummyListener>();
+
+        // Create AsyncMain Node
+        node::AsyncMainNode node("TestNode", listener);
+
+        ASSERT_EQ(types::StateKind::running, node.current_state());
+        ASSERT_EQ(types::NodeKind::main, node.node_kind());
+    }
+}
+
+/**
+ * Create AsyncComputing Node
+ */
+TEST(NodeCreationTest, create_async_computing)
+{
+    // Create listener
+    std::shared_ptr<node::test::DummyReplier> listener =
+            std::make_shared<node::test::DummyReplier>();
+
+    // Create AsyncComputing Node
+    node::AsyncComputingNode node("TestNode", listener);
+
+    ASSERT_EQ(types::StateKind::stopped, node.current_state());
+    ASSERT_EQ(types::NodeKind::computing, node.node_kind());
+}
+
+/**
+ * Create Edge Node
+ */
+TEST(NodeCreationTest, create_edge)
+{
+    node::EdgeNode node("TestNode");
+
+    ASSERT_EQ(types::StateKind::stopped, node.current_state());
+    ASSERT_EQ(types::NodeKind::edge, node.node_kind());
+}
+
+/**
+ * Create Inference Node
+ */
+TEST(NodeCreationTest, create_inference)
+{
+    node::InferenceNode node("TestNode");
+
+    ASSERT_EQ(types::StateKind::stopped, node.current_state());
+    ASSERT_EQ(types::NodeKind::inference, node.node_kind());
+}
+
+/**
+ * Create AsyncEdge Node
+ */
+TEST(NodeCreationTest, create_async_edge)
+{
+    {
+        // Create listener
+        std::shared_ptr<node::test::DummyListener> listener =
+                std::make_shared<node::test::DummyListener>();
+
+        // Create AsyncEdge Node
+        node::AsyncEdgeNode node("TestNode", listener);
+
+        ASSERT_EQ(types::StateKind::running, node.current_state());
+        ASSERT_EQ(types::NodeKind::edge, node.node_kind());
+    }
+}
+
+/**
+ * Create AsyncInference Node
+ */
+TEST(NodeCreationTest, create_async_inference)
+{
+    // Create listener
+    std::shared_ptr<node::test::DummyReplier> listener =
+            std::make_shared<node::test::DummyReplier>();
+
+    // Create AsyncInference Node
+    node::AsyncInferenceNode node("TestNode", listener);
+
+    ASSERT_EQ(types::StateKind::stopped, node.current_state());
+    ASSERT_EQ(types::NodeKind::inference, node.node_kind());
+}
+
 int main(
         int argc,
         char** argv)