[Coverage/Handler] Increase test coverage for host handler

This patch increases test coverage for host handler.

Signed-off-by: Dongju Chae <dongju.chae@samsung.com>

diff --git a/src/core/ne-handler.cc b/src/core/ne-handler.cc
index 775c60e..a10a985 100644 (file)
--- a/src/core/ne-handler.cc
+++ b/src/core/ne-handler.cc
@@ -970,7 +970,7 @@ Device::deallocMemory (int dmabuf_fd)
 Buffer *
 TrinityVision::prepareInputBuffers (const Metadata *meta, const input_buffers *input)
 {
-  if (meta == nullptr ||
+  if (meta == nullptr || input == nullptr ||
       meta->getInputNum() != input->num_buffers) {
     logerr (TAG, "Invalid metadata info provided\n");
     return nullptr;

diff --git a/tests/unittests/ne_core_handler_test.cc b/tests/unittests/ne_core_handler_test.cc
index c190be0..6398e70 100644 (file)
--- a/tests/unittests/ne_core_handler_test.cc
+++ b/tests/unittests/ne_core_handler_test.cc
@@ -89,20 +89,37 @@ TEST (ne_core_handler_test, device_instance_uninitilized_n)
   EXPECT_GT (num_devices, 0);
 
   /** directly creating a device instance but not initialized */
-  std::unique_ptr<Device> device (new TrinityVision (0));
-  EXPECT_EQ (device->initialized (), false);
+  std::unique_ptr<Device> triv (new TrinityVision (0));
+  EXPECT_EQ (triv->initialized (), false);
 
   HWmem * hwmem;
-  EXPECT_EQ (device->allocMemory (4096, &hwmem), -EPERM);
-  EXPECT_EQ (device->deallocMemory (0), -EPERM);
-  EXPECT_EQ (device->stop (true), -EPERM);
-
-  generic_buffer model_buf;
   Model *model;
-  EXPECT_EQ (device->setModel (&model_buf, &model), -EPERM);
-
+  generic_buffer model_buf;
   input_buffers input;
-  EXPECT_EQ (device->run (NPUINPUT_HOST, model, &input, nullptr, nullptr, nullptr), -EPERM);
+
+  EXPECT_EQ (triv->allocMemory (4096, &hwmem), -EPERM);
+  EXPECT_EQ (triv->deallocMemory (0), -EPERM);
+  EXPECT_EQ (triv->stop (true), -EPERM);
+  EXPECT_EQ (triv->setModel (&model_buf, &model), -EPERM);
+  EXPECT_EQ (triv->run (NPUINPUT_HOST, model, &input, nullptr, nullptr, nullptr), -EPERM);
+
+  std::unique_ptr<Device> triv2 (new TrinityVision2 (0));
+  EXPECT_EQ (triv2->initialized (), false);
+
+  EXPECT_EQ (triv2->allocMemory (4096, &hwmem), -EPERM);
+  EXPECT_EQ (triv2->deallocMemory (0), -EPERM);
+  EXPECT_EQ (triv2->stop (true), -EPERM);
+  EXPECT_EQ (triv2->setModel (&model_buf, &model), -EPERM);
+  EXPECT_EQ (triv2->run (NPUINPUT_HOST, model, &input, nullptr, nullptr, nullptr), -EPERM);
+
+  std::unique_ptr<Device> tria (new TrinityAsr (0));
+  EXPECT_EQ (tria->initialized (), false);
+
+  EXPECT_EQ (tria->allocMemory (4096, &hwmem), -EPERM);
+  EXPECT_EQ (tria->deallocMemory (0), -EPERM);
+  EXPECT_EQ (tria->stop (true), -EPERM);
+  EXPECT_EQ (tria->setModel (&model_buf, &model), -EPERM);
+  EXPECT_EQ (tria->run (NPUINPUT_HOST, model, &input, nullptr, nullptr, nullptr), -EPERM);
 }
 
 /**
@@ -446,6 +463,82 @@ TEST (ne_core_handler_test, triv_run_invalid_opmode_n)
 }
 
 /**
+ * @brief test TRIV's prepareInputBuffers () with error handling
+ */
+TEST (ne_core_handler_test, triv_prepare_input_buffers_n)
+{
+  std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV_CONN_SOCIP, 0));
+  EXPECT_NE (device.get (), nullptr);
+
+  /** prepare model */
+  generic_buffer model_buf;
+  create_model_buffer_v2 (model_buf);
+
+  Model *model = nullptr;
+  EXPECT_EQ (device->setModel (&model_buf, &model), 0);
+
+  /** prepare input buffers */
+  input_buffers input_buf;
+  create_input_buffers (input_buf);
+
+  TrinityVision * triv = dynamic_cast<TrinityVision *> (device.get ());
+
+  EXPECT_EQ (triv->prepareInputBuffers (nullptr, nullptr), nullptr);
+  EXPECT_EQ (triv->prepareInputBuffers (model->getMetadata (), nullptr), nullptr);
+  EXPECT_EQ (triv->prepareInputBuffers (nullptr, &input_buf), nullptr);
+  /** unmatched metadata */
+  input_buf.num_buffers = 2;
+  EXPECT_EQ (triv->prepareInputBuffers (model->getMetadata (), &input_buf), nullptr);
+
+  destroy_input_buffers (input_buf);
+  destroy_model_buffer (model_buf);
+}
+
+/**
+ * @brief test Device's stop ()
+ */
+TEST (ne_core_handler_test, triv_stop)
+{
+  std::unique_ptr<Device> device (Device::createInstance (NPUCOND_TRIV_CONN_SOCIP, 0));
+  EXPECT_NE (device.get (), nullptr);
+
+  /** prepare model */
+  generic_buffer model_buf;
+  create_model_buffer_v2 (model_buf);
+
+  Model *model = nullptr;
+  EXPECT_EQ (device->setModel (&model_buf, &model), 0);
+
+  /** prepare input buffers */
+  input_buffers input_buf;
+  create_input_buffers (input_buf);
+
+  npu_input_opmode opmode = NPUINPUT_HOST;
+
+  EXPECT_EQ (device->run (opmode, model, &input_buf), 0);
+  EXPECT_EQ (device->run (opmode, model, &input_buf), 0);
+  EXPECT_EQ (device->run (opmode, model, &input_buf), 0);
+
+  EXPECT_EQ (device->stop (true), 0);
+  sleep (1);  /** TODO remote this when stop() is implemented */
+
+  /** with callback */
+  int max_called = 3;
+  user_cb_data data;
+  data.num_called = 0;
+
+  EXPECT_EQ (device->run (opmode, model, &input_buf, user_cb, &data), 0);
+  EXPECT_EQ (device->run (opmode, model, &input_buf, user_cb, &data), 0);
+  EXPECT_EQ (device->run (opmode, model, &input_buf, user_cb, &data), 0);
+  EXPECT_EQ (device->stop (false), 0);  /* wait until all requests are resolved */
+  sleep (1);  /** TODO remote this when stop() is implemented */
+  EXPECT_EQ (data.num_called, max_called);  /** callbacks are called successfully */
+
+  destroy_input_buffers (input_buf);
+  destroy_model_buffer (model_buf);
+}
+
+/**
  * @brief testing TRIV's data manipulation
  */
 TEST (ne_core_handler_test, triv_data_manipulation)
@@ -526,7 +619,6 @@ TEST (ne_core_handler_test, triv_data_manipulation)
   { /* compare output manipulated */
     std::unique_ptr<uint8_t []> output_data (new uint8_t [meta->buffer_size]);
 
-    output_data.reset (new uint8_t [meta->buffer_size]);
     for (uint32_t i = 0; i < num_tensors; i++) {
       EXPECT_EQ (TrinityVision::manipulateData (model, i, true,
             output_data.get (), input_buf.bufs[i].addr, size_tensor), size_tensor);
@@ -556,7 +648,6 @@ TEST (ne_core_handler_test, triv_data_manipulation)
   { /* compare output manipulated */
     std::unique_ptr<uint8_t []> output_data (new uint8_t [meta->buffer_size]);
 
-    output_data.reset (new uint8_t [meta->buffer_size]);
     for (uint32_t i = 0; i < num_tensors; i++) {
       EXPECT_EQ (TrinityVision::manipulateData (model, i, true,
             output_data.get (), input_buf.bufs[i].addr, size_tensor), size_tensor);
@@ -659,28 +750,30 @@ TEST (ne_core_handler_test, triv_quantization)
   EXPECT_EQ (device->setModel (&model_buf, &model), 0);
   EXPECT_EQ (model->setDataInfo (&info, &info), 0);
 
-  std::unique_ptr<uint8_t []> output_data (new uint8_t [meta->buffer_size]);
+  {
+    std::unique_ptr<uint8_t []> output_data (new uint8_t [meta->buffer_size]);
 
-  for (uint32_t i = 0; i < num_tensors; i++) {
-    EXPECT_EQ (TrinityVision::manipulateData (model, i, true,
-          output_data.get (), input_buf.bufs[i].addr, size_tensor), size_tensor);
+    for (uint32_t i = 0; i < num_tensors; i++) {
+      EXPECT_EQ (TrinityVision::manipulateData (model, i, true,
+            output_data.get (), input_buf.bufs[i].addr, size_tensor), size_tensor);
 
-    double zero_point = (double) meta->input_quant_z[i];
-    double scale = (double) meta->input_quant_s[i];
-    void *each_data_ptr = (char *) output_data.get ();
+      double zero_point = (double) meta->input_quant_z[i];
+      double scale = (double) meta->input_quant_s[i];
+      void *each_data_ptr = (char *) output_data.get ();
 
-    for (uint32_t j = 0; j < size_tensor / sizeof(float); j++) {
-      double val = (double)((int32_t *) input_buf.bufs[i].addr)[j];
+      for (uint32_t j = 0; j < size_tensor / sizeof(float); j++) {
+        double val = (double)((int32_t *) input_buf.bufs[i].addr)[j];
 
-      val = val / scale;
-      val = val + zero_point;
+        val = val / scale;
+        val = val + zero_point;
 
-      if (val > 255.0)
-        val = 255.0;
-      else
-        val = 0.0;
+        if (val > 255.0)
+          val = 255.0;
+        else
+          val = 0.0;
 
-      EXPECT_EQ ((uint8_t) val, ((uint8_t *) each_data_ptr)[j]);
+        EXPECT_DOUBLE_EQ (val, (double)((uint8_t *) each_data_ptr)[j]);
+      }
     }
   }
 
@@ -702,28 +795,30 @@ TEST (ne_core_handler_test, triv_quantization)
   EXPECT_EQ (device->setModel (&model_buf, &model), 0);
   EXPECT_EQ (model->setDataInfo (&info, &info), 0);
 
-  output_data.reset (new uint8_t [meta->buffer_size]);
+  {
+    std::unique_ptr<uint8_t []> output_data (new uint8_t [meta->buffer_size]);
 
-  for (uint32_t i = 0; i < num_tensors; i++) {
-    EXPECT_EQ (TrinityVision::manipulateData (model, i, true,
-          output_data.get (), input_buf.bufs[i].addr, size_tensor), size_tensor);
+    for (uint32_t i = 0; i < num_tensors; i++) {
+      EXPECT_EQ (TrinityVision::manipulateData (model, i, true,
+            output_data.get (), input_buf.bufs[i].addr, size_tensor), size_tensor);
 
-    double zero_point = (double) meta->input_quant_z[i];
-    double scale = (double) meta->input_quant_s[i];
-    void *each_data_ptr = (char *) output_data.get ();
+      double zero_point = (double) meta->input_quant_z[i];
+      double scale = (double) meta->input_quant_s[i];
+      void *each_data_ptr = (char *) output_data.get ();
 
-    for (uint32_t j = 0; j < size_tensor / sizeof(float); j++) {
-      double val = (double)((int32_t *) input_buf.bufs[i].addr)[j];
+      for (uint32_t j = 0; j < size_tensor / sizeof(float); j++) {
+        double val = (double)((int32_t *) input_buf.bufs[i].addr)[j];
 
-      val = val / scale;
-      val = val + zero_point;
+        val = val / scale;
+        val = val + zero_point;
 
-      if (val > 255.0)
-        val = 255.0;
-      else
-        val = 0.0;
+        if (val > 255.0)
+          val = 255.0;
+        else
+          val = 0.0;
 
-      EXPECT_EQ ((uint8_t) val, ((uint8_t *) each_data_ptr)[j % 32 + 64 * (j / 32)]);
+        EXPECT_DOUBLE_EQ (val, (double)((uint8_t *) each_data_ptr)[j % 32 + 64 * (j / 32)]);
+      }
     }
   }