test: use runtime pipeline configuration feature

Change-Id: I76d313d1b809ad909f7c8eb29ac3d7fb827c095c
Signed-off-by: Inki Dae <inki.dae@samsung.com>

diff --git a/test/services/test_task_manager.cpp b/test/services/test_task_manager.cpp
index 0f9ecd3aba4c59fc03c5d3f4c52a90f66606d543..14d22408dfd6d06c0a4d5c5dc6280822d6b0e444 100644 (file)
--- a/test/services/test_task_manager.cpp
+++ b/test/services/test_task_manager.cpp
@@ -85,23 +85,28 @@ TEST(SingloTaskManager, MultipleNodesBasedGraphAShouldWork)
        auto taskManager = make_unique<TaskManager>();
        const unsigned int maxIteration = 10;
 
-       for (unsigned int cnt = 0; cnt < maxIteration; ++cnt) {
-               taskManager->addInput(image_data);
+       taskManager->requestNewNode(NodeType::STARTPOINT, "startpoint");
 
-               auto face_detection_node = taskManager->requestNewNode(NodeType::INFERENCE, "face_detection");
-               dynamic_cast<InferenceNode *>(face_detection_node)->setInferenceTask(factory->createFaceDetection());
+       auto face_detection_node = taskManager->requestNewNode(NodeType::INFERENCE, "face_detection");
+       dynamic_cast<InferenceNode *>(face_detection_node)->setInferenceTask(factory->createFaceDetection());
 
-               auto bridge_node = taskManager->requestNewNode(NodeType::BRIDGE, "bridge");
-               dynamic_cast<BridgeNode *>(bridge_node)->setCb(BridgeNodeCallbackFD);
-               bridge_node->addDependency(face_detection_node);
+       auto bridge_node = taskManager->requestNewNode(NodeType::BRIDGE, "bridge");
+       dynamic_cast<BridgeNode *>(bridge_node)->setCb(BridgeNodeCallbackFD);
 
-               auto face_landmark_node = taskManager->requestNewNode(NodeType::INFERENCE, "face_landmark");
-               dynamic_cast<InferenceNode *>(face_landmark_node)->setInferenceTask(factory->createFaceLandmarkDetection());
-               face_landmark_node->addDependency(bridge_node);
+       auto face_landmark_node = taskManager->requestNewNode(NodeType::INFERENCE, "face_landmark");
+       dynamic_cast<InferenceNode *>(face_landmark_node)->setInferenceTask(factory->createFaceLandmarkDetection());
 
-               auto endpoint_node = taskManager->requestNewNode(NodeType::ENDPOINT, "endpoint");
-               endpoint_node->addDependency(face_landmark_node);
+       taskManager->requestNewNode(NodeType::ENDPOINT, "endpoint");
+
+       taskManager->resetPipeline();
+
+       taskManager->addEdge("startpoint", "face_detection");
+       taskManager->addEdge("face_detection", "bridge");
+       taskManager->addEdge("bridge", "face_landmark");
+       taskManager->addEdge("face_landmark", "endpoint");
 
+       for (unsigned int cnt = 0; cnt < maxIteration; ++cnt) {
+               taskManager->addInput(image_data);
                taskManager->run();
 
                for (auto &result : taskManager->output()) {
@@ -113,9 +118,9 @@ TEST(SingloTaskManager, MultipleNodesBasedGraphAShouldWork)
                        for (auto &point : fld_result->_points)
                                ASSERT_EQ(point, answer[idx++]);
                }
-
-               taskManager->clear();
        }
+
+       taskManager->clear();
 }
 
 // GraphB:
@@ -142,27 +147,33 @@ TEST(SingloTaskManager, MultipleNodesBasedGraphBShouldWork)
        auto taskManager = make_unique<TaskManager>();
        const unsigned int maxIteration = 10;
 
-       for (unsigned int cnt = 0; cnt < maxIteration; ++cnt) {
-               taskManager->addInput(image_data);
+       taskManager->requestNewNode(NodeType::STARTPOINT, "startpoint");
 
-               auto face_detection_node_a = taskManager->requestNewNode(NodeType::INFERENCE, "face_detectionA");
-               dynamic_cast<InferenceNode *>(face_detection_node_a)->setInferenceTask(factory->createFaceDetection());
+       auto face_detection_node_a = taskManager->requestNewNode(NodeType::INFERENCE, "face_detectionA");
+       dynamic_cast<InferenceNode *>(face_detection_node_a)->setInferenceTask(factory->createFaceDetection());
 
-               auto face_detection_node_b = taskManager->requestNewNode(NodeType::INFERENCE, "face_detectionB");
-               dynamic_cast<InferenceNode *>(face_detection_node_b)->setInferenceTask(factory->createFaceDetection());
+       auto face_detection_node_b = taskManager->requestNewNode(NodeType::INFERENCE, "face_detectionB");
+       dynamic_cast<InferenceNode *>(face_detection_node_b)->setInferenceTask(factory->createFaceDetection());
 
-               auto bridge_node = taskManager->requestNewNode(NodeType::BRIDGE, "bridge");
-               dynamic_cast<BridgeNode *>(bridge_node)->setCb(BridgeNodeCallbackFD);
-               bridge_node->addDependency(face_detection_node_a);
-               bridge_node->addDependency(face_detection_node_b);
+       auto bridge_node = taskManager->requestNewNode(NodeType::BRIDGE, "bridge");
+       dynamic_cast<BridgeNode *>(bridge_node)->setCb(BridgeNodeCallbackFD);
 
-               auto face_landmark_node = taskManager->requestNewNode(NodeType::INFERENCE, "face_landmark");
-               dynamic_cast<InferenceNode *>(face_landmark_node)->setInferenceTask(factory->createFaceLandmarkDetection());
-               face_landmark_node->addDependency(bridge_node);
+       auto face_landmark_node = taskManager->requestNewNode(NodeType::INFERENCE, "face_landmark");
+       dynamic_cast<InferenceNode *>(face_landmark_node)->setInferenceTask(factory->createFaceLandmarkDetection());
 
-               auto endpoint_node = taskManager->requestNewNode(NodeType::ENDPOINT, "endpoint");
-               dynamic_cast<EndpointNode *>(endpoint_node)->addDependency(face_landmark_node);
+       taskManager->requestNewNode(NodeType::ENDPOINT, "endpoint");
+
+       taskManager->resetPipeline();
+
+       taskManager->addEdge("startpoint", "face_detectionA");
+       taskManager->addEdge("startpoint", "face_detectionB");
+       taskManager->addEdge("face_detectionA", "bridge");
+       taskManager->addEdge("face_detectionB", "bridge");
+       taskManager->addEdge("bridge", "face_landmark");
+       taskManager->addEdge("face_landmark", "endpoint");
 
+       for (unsigned int cnt = 0; cnt < maxIteration; ++cnt) {
+               taskManager->addInput(image_data);
                taskManager->run();
 
                for (auto &result : taskManager->output()) {
@@ -174,9 +185,9 @@ TEST(SingloTaskManager, MultipleNodesBasedGraphBShouldWork)
                        for (auto &point : fld_result->_points)
                                ASSERT_EQ(point, answer[idx++]);
                }
-
-               taskManager->clear();
        }
+
+       taskManager->clear();
 }
 
 void LastNodeCallback(INode *node)
@@ -215,25 +226,30 @@ TEST(SingloTaskManager, MultipleNodesBasedGraphCShouldWork)
        auto taskManager = make_unique<TaskManager>();
        const unsigned int maxIteration = 10;
 
-       for (unsigned int cnt = 0; cnt < maxIteration; ++cnt) {
-               taskManager->addInput(image_data);
+       taskManager->requestNewNode(NodeType::STARTPOINT, "startpoint");
 
-               auto face_detection_node = taskManager->requestNewNode(NodeType::INFERENCE, "face_detection");
-               dynamic_cast<InferenceNode *>(face_detection_node)->setInferenceTask(factory->createFaceDetection());
+       auto face_detection_node = taskManager->requestNewNode(NodeType::INFERENCE, "face_detection");
+       dynamic_cast<InferenceNode *>(face_detection_node)->setInferenceTask(factory->createFaceDetection());
 
-               auto bridge_node = taskManager->requestNewNode(NodeType::BRIDGE, "bridge");
-               dynamic_cast<BridgeNode *>(bridge_node)->setCb(BridgeNodeCallbackFD);
-               bridge_node->addDependency(face_detection_node);
+       auto bridge_node = taskManager->requestNewNode(NodeType::BRIDGE, "bridge");
+       dynamic_cast<BridgeNode *>(bridge_node)->setCb(BridgeNodeCallbackFD);
 
-               auto face_landmark_node = taskManager->requestNewNode(NodeType::INFERENCE, "face_landmark");
-               dynamic_cast<InferenceNode *>(face_landmark_node)->setInferenceTask(factory->createFaceLandmarkDetection());
-               face_landmark_node->addDependency(bridge_node);
+       auto face_landmark_node = taskManager->requestNewNode(NodeType::INFERENCE, "face_landmark");
+       dynamic_cast<InferenceNode *>(face_landmark_node)->setInferenceTask(factory->createFaceLandmarkDetection());
 
-               auto endpoint_node = taskManager->requestNewNode(NodeType::ENDPOINT, "endpoint");
-               dynamic_cast<EndpointNode *>(endpoint_node)->setCb(LastNodeCallback);
-               endpoint_node->addDependency(face_detection_node);
-               endpoint_node->addDependency(face_landmark_node);
+       auto endpoint_node = taskManager->requestNewNode(NodeType::ENDPOINT, "endpoint");
+       dynamic_cast<EndpointNode *>(endpoint_node)->setCb(LastNodeCallback);
+
+       taskManager->resetPipeline();
 
+       taskManager->addEdge("startpoint", "face_detection");
+       taskManager->addEdge("face_detection", "bridge");
+       taskManager->addEdge("bridge", "face_landmark");
+       taskManager->addEdge("face_detection", "endpoint");
+       taskManager->addEdge("face_landmark", "endpoint");
+
+       for (unsigned int cnt = 0; cnt < maxIteration; ++cnt) {
+               taskManager->addInput(image_data);
                taskManager->run();
 
                for (auto &result : taskManager->output()) {
@@ -255,9 +271,9 @@ TEST(SingloTaskManager, MultipleNodesBasedGraphCShouldWork)
                                        ASSERT_EQ(point, fld_answer[idx++]);
                        }
                }
-
-               taskManager->clear();
        }
+
+       taskManager->clear();
 }
 
 // GraphD:
@@ -281,33 +297,37 @@ TEST(SingloTaskManager, MultipleNodesBasedGraphDShouldWork)
        image_data.ptr = cv_image.data;
 
        auto factory = InferenceTaskFactory::instance().create("MvInferenceTaskFactory");
-
        auto taskManager = make_unique<TaskManager>();
        const unsigned int maxIteration = 10;
 
-       for (unsigned int cnt = 0; cnt < maxIteration; ++cnt) {
-               taskManager->addInput(image_data);
+       taskManager->requestNewNode(NodeType::STARTPOINT, "startpoint");
 
-               auto face_detection_node_a = taskManager->requestNewNode(NodeType::INFERENCE, "face_detection_a");
-               dynamic_cast<InferenceNode *>(face_detection_node_a)->setInferenceTask(factory->createFaceDetection());
+       auto face_detection_node_a = taskManager->requestNewNode(NodeType::INFERENCE, "face_detection_a");
+       dynamic_cast<InferenceNode *>(face_detection_node_a)->setInferenceTask(factory->createFaceDetection());
 
-               auto bridge_node = taskManager->requestNewNode(NodeType::BRIDGE, "bridge");
-               dynamic_cast<BridgeNode *>(bridge_node)->setCb(BridgeNodeCallbackFD);
-               bridge_node->addDependency(face_detection_node_a);
+       auto bridge_node = taskManager->requestNewNode(NodeType::BRIDGE, "bridge");
+       dynamic_cast<BridgeNode *>(bridge_node)->setCb(BridgeNodeCallbackFD);
 
-               auto face_landmark_node = taskManager->requestNewNode(NodeType::INFERENCE, "face_landmark");
-               dynamic_cast<InferenceNode *>(face_landmark_node)->setInferenceTask(factory->createFaceLandmarkDetection());
-               face_landmark_node->addDependency(bridge_node);
+       auto face_landmark_node = taskManager->requestNewNode(NodeType::INFERENCE, "face_landmark");
+       dynamic_cast<InferenceNode *>(face_landmark_node)->setInferenceTask(factory->createFaceLandmarkDetection());
 
-               auto face_detection_node_b = taskManager->requestNewNode(NodeType::INFERENCE, "face_detection_b");
-               dynamic_cast<InferenceNode *>(face_detection_node_b)->setInferenceTask(factory->createFaceDetection());
-               face_detection_node_b->addDependency(bridge_node);
+       auto face_detection_node_b = taskManager->requestNewNode(NodeType::INFERENCE, "face_detection_b");
+       dynamic_cast<InferenceNode *>(face_detection_node_b)->setInferenceTask(factory->createFaceDetection());
 
-               auto endpoint_node = taskManager->requestNewNode(NodeType::ENDPOINT, "endpoint");
-               dynamic_cast<EndpointNode *>(endpoint_node)->setCb(LastNodeCallback);
-               endpoint_node->addDependency(face_detection_node_b);
-               endpoint_node->addDependency(face_landmark_node);
+       auto endpoint_node = taskManager->requestNewNode(NodeType::ENDPOINT, "endpoint");
+       dynamic_cast<EndpointNode *>(endpoint_node)->setCb(LastNodeCallback);
+
+       taskManager->resetPipeline();
+
+       taskManager->addEdge("startpoint", "face_detection_a");
+       taskManager->addEdge("face_detection_a", "bridge");
+       taskManager->addEdge("bridge", "face_landmark");
+       taskManager->addEdge("bridge", "face_detection_b");
+       taskManager->addEdge("face_detection_b", "endpoint");
+       taskManager->addEdge("face_landmark", "endpoint");
 
+       for (unsigned int cnt = 0; cnt < maxIteration; ++cnt) {
+               taskManager->addInput(image_data);
                taskManager->run();
 
                for (auto &result : taskManager->output()) {
@@ -329,9 +349,9 @@ TEST(SingloTaskManager, MultipleNodesBasedGraphDShouldWork)
                                        ASSERT_EQ(point, fld_answer[idx++]);
                        }
                }
-
-               taskManager->clear();
        }
+
+       taskManager->clear();
 }
 
 void BridgeNodeCallbackOD(INode *node)
@@ -415,42 +435,47 @@ TEST(SingloTaskManager, MultipleNodesBasedGraphEShouldWork)
        auto taskManager = make_unique<TaskManager>();
        const unsigned int maxIteration = 10;
 
-       for (unsigned int cnt = 0; cnt < maxIteration; ++cnt) {
-               taskManager->addInput(image_data);
+       taskManager->requestNewNode(NodeType::STARTPOINT, "startpoint");
 
-               auto object_detection_node = taskManager->requestNewNode(NodeType::INFERENCE, "object_detection");
-               dynamic_cast<InferenceNode *>(object_detection_node)->setInferenceTask(factory->createObjectDetection());
+       auto object_detection_node = taskManager->requestNewNode(NodeType::INFERENCE, "object_detection");
+       dynamic_cast<InferenceNode *>(object_detection_node)->setInferenceTask(factory->createObjectDetection());
 
-               auto bridge_node_1 = taskManager->requestNewNode(NodeType::BRIDGE, "bridge_1");
-               dynamic_cast<BridgeNode *>(bridge_node_1)->setCb(BridgeNodeCallbackOD);
-               bridge_node_1->addDependency(object_detection_node);
+       auto bridge_node_1 = taskManager->requestNewNode(NodeType::BRIDGE, "bridge_1");
+       dynamic_cast<BridgeNode *>(bridge_node_1)->setCb(BridgeNodeCallbackOD);
 
-               auto image_classification_node_1 = taskManager->requestNewNode(NodeType::INFERENCE, "image_classification_1");
-               dynamic_cast<InferenceNode *>(image_classification_node_1)
-                               ->setInferenceTask(factory->createImageClassification());
-               image_classification_node_1->addDependency(bridge_node_1);
+       auto image_classification_node_1 = taskManager->requestNewNode(NodeType::INFERENCE, "image_classification_1");
+       dynamic_cast<InferenceNode *>(image_classification_node_1)
+                       ->setInferenceTask(factory->createImageClassification());
 
-               auto bridge_node_2 = taskManager->requestNewNode(NodeType::BRIDGE, "bridge_2");
-               dynamic_cast<BridgeNode *>(bridge_node_2)->setCb(BridgeNodeCallbackIC);
-               bridge_node_2->addDependency(image_classification_node_1);
+       auto bridge_node_2 = taskManager->requestNewNode(NodeType::BRIDGE, "bridge_2");
+       dynamic_cast<BridgeNode *>(bridge_node_2)->setCb(BridgeNodeCallbackIC);
 
-               auto image_classification_node_2 = taskManager->requestNewNode(NodeType::INFERENCE, "image_classification_2");
-               dynamic_cast<InferenceNode *>(image_classification_node_2)
-                               ->setInferenceTask(factory->createImageClassification());
-               image_classification_node_2->addDependency(bridge_node_2);
+       auto image_classification_node_2 = taskManager->requestNewNode(NodeType::INFERENCE, "image_classification_2");
+       dynamic_cast<InferenceNode *>(image_classification_node_2)
+                       ->setInferenceTask(factory->createImageClassification());
 
-               int endpoint_node_run = 0;
-               auto endpoint_node = taskManager->requestNewNode(NodeType::ENDPOINT, "endpoint");
-               endpoint_node->addDependency(object_detection_node);
-               endpoint_node->addDependency(image_classification_node_2);
-               dynamic_cast<EndpointNode *>(endpoint_node)->setCb([&](INode *node) { endpoint_node_run += 1; });
+       int endpoint_node_run = 0;
+       auto endpoint_node = taskManager->requestNewNode(NodeType::ENDPOINT, "endpoint");
+       dynamic_cast<EndpointNode *>(endpoint_node)->setCb([&](INode *node) { endpoint_node_run += 1; });
 
+       taskManager->resetPipeline();
+
+       taskManager->addEdge("startpoint", "object_detection");
+       taskManager->addEdge("object_detection", "bridge_1");
+       taskManager->addEdge("bridge_1", "image_classification_1");
+       taskManager->addEdge("image_classification_1", "bridge_2");
+       taskManager->addEdge("bridge_2", "image_classification_2");
+       taskManager->addEdge("object_detection", "endpoint");
+       taskManager->addEdge("image_classification_2", "endpoint");
+
+       for (unsigned int cnt = 0; cnt < maxIteration; ++cnt) {
+               taskManager->addInput(image_data);
                taskManager->run();
 
                ASSERT_EQ(endpoint_node_run, 0); // Since OD node fails, endpoint node should not be run.
-
-               taskManager->clear();
        }
+
+       taskManager->clear();
 }
 
 void BranchNodeCallback(INode *node)
@@ -509,53 +534,61 @@ TEST(SingloTaskManager, MultipleNodesBasedGraphFShouldWork)
                auto taskManager = make_unique<TaskManager>();
                const unsigned int maxIteration = 5;
 
-               for (unsigned int cnt = 0; cnt < maxIteration; ++cnt) {
-                       taskManager->addInput(image_data);
+               taskManager->requestNewNode(NodeType::STARTPOINT, "startpoint");
+
+               auto face_detection_node = taskManager->requestNewNode(NodeType::INFERENCE, "face_detection");
+               dynamic_cast<InferenceNode *>(face_detection_node)->setInferenceTask(factory->createFaceDetection());
+
+               auto object_detection_node = taskManager->requestNewNode(NodeType::INFERENCE, "object_detection");
+               dynamic_cast<InferenceNode *>(object_detection_node)->setInferenceTask(factory->createObjectDetection());
+
+               auto branch_node = taskManager->requestNewNode(NodeType::BRANCH, "branch");
+               dynamic_cast<BranchNode *>(branch_node)->setCb(BranchNodeCallback);
+
+               auto face_landmark_node = taskManager->requestNewNode(NodeType::INFERENCE, "face_landmark");
+               dynamic_cast<InferenceNode *>(face_landmark_node)->setInferenceTask(factory->createFaceLandmarkDetection());
 
-                       auto face_detection_node = taskManager->requestNewNode(NodeType::INFERENCE, "face_detection");
-                       dynamic_cast<InferenceNode *>(face_detection_node)->setInferenceTask(factory->createFaceDetection());
-
-                       auto object_detection_node = taskManager->requestNewNode(NodeType::INFERENCE, "object_detection");
-                       dynamic_cast<InferenceNode *>(object_detection_node)->setInferenceTask(factory->createObjectDetection());
-
-                       auto branch_node = taskManager->requestNewNode(NodeType::BRANCH, "branch");
-                       dynamic_cast<BranchNode *>(branch_node)->setCb(BranchNodeCallback);
-                       branch_node->addDependency(face_detection_node);
-                       branch_node->addDependency(object_detection_node);
-
-                       auto face_landmark_node = taskManager->requestNewNode(NodeType::INFERENCE, "face_landmark");
-                       dynamic_cast<InferenceNode *>(face_landmark_node)->setInferenceTask(factory->createFaceLandmarkDetection());
-                       face_landmark_node->addDependency(branch_node);
-
-                       auto image_classification_node = taskManager->requestNewNode(NodeType::INFERENCE, "image_classification");
-                       dynamic_cast<InferenceNode *>(image_classification_node)
-                                       ->setInferenceTask(factory->createImageClassification());
-                       image_classification_node->addDependency(branch_node);
-
-                       auto endpoint_node = taskManager->requestNewNode(NodeType::ENDPOINT, "endpoint");
-                       endpoint_node->addDependency(face_landmark_node);
-                       endpoint_node->addDependency(image_classification_node);
-                       dynamic_cast<EndpointNode *>(endpoint_node)->setCb([&](INode *node) {
-                               auto results = node->results();
-
-                               for (auto &result : results) {
-                                       if (result->_type == ResultType::FACE_LANDMARK) {
-                                               SINGLEO_LOGD("FLD result received at endpoint");
-                                               auto fld_result = dynamic_pointer_cast<FldResultType>(result);
-                                               unsigned int idx = 0;
-
-                                               for (auto &point : fld_result->_points)
-                                                       ASSERT_EQ(point, fld_answer[idx++]);
-                                       } else if (result->_type == ResultType::IMAGE_CLASSIFICATION) {
-                                               SINGLEO_LOGD("IC result received at endpoint");
-                                               auto ic_result = dynamic_pointer_cast<IcResultType>(result);
-                                               ASSERT_EQ(ic_result->_labels[0], ic_answer);
-                                       }
+               auto image_classification_node = taskManager->requestNewNode(NodeType::INFERENCE, "image_classification");
+               dynamic_cast<InferenceNode *>(image_classification_node)
+                               ->setInferenceTask(factory->createImageClassification());
+
+               auto endpoint_node = taskManager->requestNewNode(NodeType::ENDPOINT, "endpoint");
+               dynamic_cast<EndpointNode *>(endpoint_node)->setCb([&](INode *node) {
+                       auto results = node->results();
+
+                       for (auto &result : results) {
+                               if (result->_type == ResultType::FACE_LANDMARK) {
+                                       SINGLEO_LOGD("FLD result received at endpoint");
+                                       auto fld_result = dynamic_pointer_cast<FldResultType>(result);
+                                       unsigned int idx = 0;
+
+                                       for (auto &point : fld_result->_points)
+                                               ASSERT_EQ(point, fld_answer[idx++]);
+                               } else if (result->_type == ResultType::IMAGE_CLASSIFICATION) {
+                                       SINGLEO_LOGD("IC result received at endpoint");
+                                       auto ic_result = dynamic_pointer_cast<IcResultType>(result);
+                                       ASSERT_EQ(ic_result->_labels[0], ic_answer);
                                }
-                       });
+                       }
+               });
+
+
+               taskManager->resetPipeline();
 
+               taskManager->addEdge("startpoint", "face_detection");
+               taskManager->addEdge("startpoint", "object_detection");
+               taskManager->addEdge("face_detection", "branch");
+               taskManager->addEdge("object_detection", "branch");
+               taskManager->addEdge("branch", "face_landmark");
+               taskManager->addEdge("branch", "image_classification");
+               taskManager->addEdge("face_landmark", "endpoint");
+               taskManager->addEdge("image_classification", "endpoint");
+
+               for (unsigned int cnt = 0; cnt < maxIteration; ++cnt) {
+                       taskManager->addInput(image_data);
                        taskManager->run();
-                       taskManager->clear();
                }
+
+               taskManager->clear();
        }
 }
\ No newline at end of file