[CodeClean] separate data utils

Code clean, prepare util functions.
1. separate edge-data utils.
2. remove todo item and extra code clean.

TODO: separate mqtt, edge-event and other util functions.

Signed-off-by: Jaeyun <jy1210.jung@samsung.com>

diff --git a/include/nnstreamer-edge.h b/include/nnstreamer-edge.h
index 0bc9838c7e0ab2c4aa1f2cda128e442465c6eb09..fd6b2ddfae59d5c407fbbd8ee788de8cd98b763f 100644 (file)
--- a/include/nnstreamer-edge.h
+++ b/include/nnstreamer-edge.h
@@ -14,13 +14,8 @@
 #define __NNSTREAMER_EDGE_H__
 
 #include <errno.h>
-#include <limits.h>
-#include <stddef.h>
-#include <stdbool.h>
-#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 
 #ifdef __cplusplus
 extern "C" {

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index ec44ce3d09e6ae13282a32f10beb8c2a77673f8c..0c0727010360f3f09f3f08b62248518f04877106 100644 (file)
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -2,6 +2,7 @@
 SET(NNS_EDGE_LIB_NAME nnstreamer-edge)
 SET(NNS_EDGE_SRCS
     ${NNS_EDGE_SRC_DIR}/nnstreamer-edge-common.c
+    ${NNS_EDGE_SRC_DIR}/nnstreamer-edge-data.c
     ${NNS_EDGE_SRC_DIR}/nnstreamer-edge-internal.c
     ${NNS_EDGE_SRC_DIR}/nnstreamer-edge-util.c
     ${NNS_EDGE_SRC_DIR}/nnstreamer-edge-queue.c

diff --git a/src/libnnstreamer-edge/nnstreamer-edge-aitt.c b/src/libnnstreamer-edge/nnstreamer-edge-aitt.c
index 6cf360f870c338396fcb73a8c728a27929fccb07..00272d468519e3b5282d531dbe32e205f0b72bb2 100644 (file)
--- a/src/libnnstreamer-edge/nnstreamer-edge-aitt.c
+++ b/src/libnnstreamer-edge/nnstreamer-edge-aitt.c
@@ -13,6 +13,8 @@
 
 #include <stdbool.h>
 #include <aitt_c.h>
+
+#include "nnstreamer-edge-data.h"
 #include "nnstreamer-edge-common.h"
 #include "nnstreamer-edge-internal.h"
 #include "nnstreamer-edge-util.h"
@@ -24,7 +26,6 @@ typedef void *nns_edge_aitt_sub_h;
 
 /**
  * @brief Data structure for aitt handle.
- * @todo Update AITT-related handle later. This is internal struct to manage edge-handle with AITT.
  */
 typedef struct
 {
@@ -33,7 +34,6 @@ typedef struct
   nns_edge_aitt_sub_h sub_h;
 } nns_edge_aitt_handle_s;
 
-
 /**
  * @brief Create AITT handle and connect to AITT.
  * @note This is internal function for AITT. You should call this with edge-handle lock.

diff --git a/src/libnnstreamer-edge/nnstreamer-edge-common.c b/src/libnnstreamer-edge/nnstreamer-edge-common.c
index 389f23b7dc2e00692c7794b850b54947d3de90f5..34c5d7a4f726fab20c17689fe5e44d3b0f529059 100644 (file)
--- a/src/libnnstreamer-edge/nnstreamer-edge-common.c
+++ b/src/libnnstreamer-edge/nnstreamer-edge-common.c
@@ -11,6 +11,7 @@
  */
 
 #include "nnstreamer-edge-common.h"
+#include "nnstreamer-edge-data.h"
 #include "nnstreamer-edge-log.h"
 #include "nnstreamer-edge-util.h"
 
@@ -459,543 +460,3 @@ nns_edge_event_parse_capability (nns_edge_event_h event_h, char **capability)
 
   return NNS_EDGE_ERROR_NONE;
 }
-
-/**
- * @brief Create nnstreamer edge data.
- */
-int
-nns_edge_data_create (nns_edge_data_h * data_h)
-{
-  nns_edge_data_s *ed;
-
-  if (!data_h) {
-    nns_edge_loge ("Invalid param, data_h should not be null.");
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  ed = (nns_edge_data_s *) calloc (1, sizeof (nns_edge_data_s));
-  if (!ed) {
-    nns_edge_loge ("Failed to allocate memory for edge data.");
-    return NNS_EDGE_ERROR_OUT_OF_MEMORY;
-  }
-
-  nns_edge_lock_init (ed);
-  ed->magic = NNS_EDGE_MAGIC;
-  nns_edge_metadata_init (&ed->metadata);
-
-  *data_h = ed;
-  return NNS_EDGE_ERROR_NONE;
-}
-
-/**
- * @brief Destroy nnstreamer edge data.
- */
-int
-nns_edge_data_destroy (nns_edge_data_h data_h)
-{
-  nns_edge_data_s *ed;
-  unsigned int i;
-
-  ed = (nns_edge_data_s *) data_h;
-  if (!ed) {
-    nns_edge_loge ("Invalid param, given edge data handle is null.");
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  nns_edge_lock (ed);
-
-  if (!NNS_EDGE_MAGIC_IS_VALID (ed)) {
-    nns_edge_loge ("Invalid param, given edge data is invalid.");
-    nns_edge_unlock (ed);
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  ed->magic = NNS_EDGE_MAGIC_DEAD;
-
-  for (i = 0; i < ed->num; i++) {
-    if (ed->data[i].destroy_cb)
-      ed->data[i].destroy_cb (ed->data[i].data);
-  }
-
-  nns_edge_metadata_free (&ed->metadata);
-
-  nns_edge_unlock (ed);
-  nns_edge_lock_destroy (ed);
-  SAFE_FREE (ed);
-  return NNS_EDGE_ERROR_NONE;
-}
-
-/**
- * @brief Validate edge data handle.
- */
-int
-nns_edge_data_is_valid (nns_edge_data_h data_h)
-{
-  nns_edge_data_s *ed;
-
-  ed = (nns_edge_data_s *) data_h;
-  if (!ed) {
-    nns_edge_loge ("Invalid param, given edge data handle is null.");
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  nns_edge_lock (ed);
-
-  if (!NNS_EDGE_MAGIC_IS_VALID (ed)) {
-    nns_edge_loge ("Invalid param, edge data handle is invalid.");
-    nns_edge_unlock (ed);
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  nns_edge_unlock (ed);
-  return NNS_EDGE_ERROR_NONE;
-}
-
-/**
- * @brief Copy edge data and return new handle.
- */
-int
-nns_edge_data_copy (nns_edge_data_h data_h, nns_edge_data_h * new_data_h)
-{
-  nns_edge_data_s *ed;
-  nns_edge_data_s *copied;
-  unsigned int i;
-  int ret;
-
-  ed = (nns_edge_data_s *) data_h;
-  if (!ed) {
-    nns_edge_loge ("Invalid param, given edge data handle is null.");
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  if (!new_data_h) {
-    nns_edge_loge ("Invalid param, new_data_h should not be null.");
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  nns_edge_lock (ed);
-
-  if (!NNS_EDGE_MAGIC_IS_VALID (ed)) {
-    nns_edge_loge ("Invalid param, edge data handle is invalid.");
-    nns_edge_unlock (ed);
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  ret = nns_edge_data_create (new_data_h);
-  if (ret != NNS_EDGE_ERROR_NONE) {
-    nns_edge_loge ("Failed to create new data handle.");
-    nns_edge_unlock (ed);
-    return ret;
-  }
-
-  copied = (nns_edge_data_s *) (*new_data_h);
-
-  copied->num = ed->num;
-  for (i = 0; i < ed->num; i++) {
-    copied->data[i].data = nns_edge_memdup (ed->data[i].data,
-        ed->data[i].data_len);
-
-    if (!copied->data[i].data) {
-      nns_edge_loge ("Failed to copy data, error while allocating new memory.");
-      copied->num = i;
-      ret = NNS_EDGE_ERROR_OUT_OF_MEMORY;
-      goto done;
-    }
-
-    copied->data[i].data_len = ed->data[i].data_len;
-    copied->data[i].destroy_cb = nns_edge_free;
-  }
-
-  ret = nns_edge_metadata_copy (&copied->metadata, &ed->metadata);
-
-done:
-  if (ret != NNS_EDGE_ERROR_NONE) {
-    nns_edge_data_destroy (*new_data_h);
-    *new_data_h = NULL;
-  }
-
-  nns_edge_unlock (ed);
-  return ret;
-}
-
-/**
- * @brief Add raw data into nnstreamer edge data.
- */
-int
-nns_edge_data_add (nns_edge_data_h data_h, void *data, size_t data_len,
-    nns_edge_data_destroy_cb destroy_cb)
-{
-  nns_edge_data_s *ed;
-
-  ed = (nns_edge_data_s *) data_h;
-  if (!ed) {
-    nns_edge_loge ("Invalid param, given edge data handle is null.");
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  if (!data || data_len <= 0) {
-    nns_edge_loge ("Invalid param, data should not be null.");
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  nns_edge_lock (ed);
-
-  if (!NNS_EDGE_MAGIC_IS_VALID (ed)) {
-    nns_edge_loge ("Invalid param, given edge data is invalid.");
-    nns_edge_unlock (ed);
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  if (ed->num >= NNS_EDGE_DATA_LIMIT) {
-    nns_edge_loge ("Cannot add data, the maximum number of edge data is %d.",
-        NNS_EDGE_DATA_LIMIT);
-    nns_edge_unlock (ed);
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  ed->data[ed->num].data = data;
-  ed->data[ed->num].data_len = data_len;
-  ed->data[ed->num].destroy_cb = destroy_cb;
-  ed->num++;
-
-  nns_edge_unlock (ed);
-  return NNS_EDGE_ERROR_NONE;
-}
-
-/**
- * @brief Get the n'th edge data.
- * @note DO NOT release returned data. You should copy the data to another buffer if the returned data is necessary.
- */
-int
-nns_edge_data_get (nns_edge_data_h data_h, unsigned int index, void **data,
-    size_t *data_len)
-{
-  nns_edge_data_s *ed;
-
-  ed = (nns_edge_data_s *) data_h;
-  if (!ed) {
-    nns_edge_loge ("Invalid param, given edge data handle is null.");
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  if (!data || !data_len) {
-    nns_edge_loge ("Invalid param, data and len should not be null.");
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  nns_edge_lock (ed);
-
-  if (!NNS_EDGE_MAGIC_IS_VALID (ed)) {
-    nns_edge_loge ("Invalid param, given edge data is invalid.");
-    nns_edge_unlock (ed);
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  if (index >= ed->num) {
-    nns_edge_loge
-        ("Invalid param, the number of edge data is %u but requested %uth data.",
-        ed->num, index);
-    nns_edge_unlock (ed);
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  *data = ed->data[index].data;
-  *data_len = ed->data[index].data_len;
-
-  nns_edge_unlock (ed);
-  return NNS_EDGE_ERROR_NONE;
-}
-
-/**
- * @brief Get the number of edge data in handle.
- */
-int
-nns_edge_data_get_count (nns_edge_data_h data_h, unsigned int *count)
-{
-  nns_edge_data_s *ed;
-
-  ed = (nns_edge_data_s *) data_h;
-  if (!ed) {
-    nns_edge_loge ("Invalid param, given edge data handle is null.");
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  if (!count) {
-    nns_edge_loge ("Invalid param, count should not be null.");
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  nns_edge_lock (ed);
-
-  if (!NNS_EDGE_MAGIC_IS_VALID (ed)) {
-    nns_edge_loge ("Invalid param, given edge data is invalid.");
-    nns_edge_unlock (ed);
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  *count = ed->num;
-
-  nns_edge_unlock (ed);
-  return NNS_EDGE_ERROR_NONE;
-}
-
-/**
- * @brief Set the information of edge data.
- */
-int
-nns_edge_data_set_info (nns_edge_data_h data_h, const char *key,
-    const char *value)
-{
-  nns_edge_data_s *ed;
-  int ret;
-
-  ed = (nns_edge_data_s *) data_h;
-  if (!ed) {
-    nns_edge_loge ("Invalid param, given edge data handle is null.");
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  if (!STR_IS_VALID (key)) {
-    nns_edge_loge ("Invalid param, given key is invalid.");
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  nns_edge_lock (ed);
-
-  if (!NNS_EDGE_MAGIC_IS_VALID (ed)) {
-    nns_edge_loge ("Invalid param, given edge data is invalid.");
-    nns_edge_unlock (ed);
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  ret = nns_edge_metadata_set (&ed->metadata, key, value);
-
-  nns_edge_unlock (ed);
-  return ret;
-}
-
-/**
- * @brief Get the information of edge data. Caller should release the returned value using free().
- */
-int
-nns_edge_data_get_info (nns_edge_data_h data_h, const char *key, char **value)
-{
-  nns_edge_data_s *ed;
-  int ret;
-
-  ed = (nns_edge_data_s *) data_h;
-  if (!ed) {
-    nns_edge_loge ("Invalid param, given edge data handle is null.");
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  if (!STR_IS_VALID (key)) {
-    nns_edge_loge ("Invalid param, given key is invalid.");
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  if (!value) {
-    nns_edge_loge ("Invalid param, value should not be null.");
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  nns_edge_lock (ed);
-
-  if (!NNS_EDGE_MAGIC_IS_VALID (ed)) {
-    nns_edge_loge ("Invalid param, given edge data is invalid.");
-    nns_edge_unlock (ed);
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  ret = nns_edge_metadata_get (&ed->metadata, key, value);
-
-  nns_edge_unlock (ed);
-  return ret;
-}
-
-/**
- * @brief Serialize metadata in edge data.
- * @note This is internal function, DO NOT export this. Caller should release the returned value using free().
- */
-int
-nns_edge_data_serialize_meta (nns_edge_data_h data_h, void **data,
-    size_t *data_len)
-{
-  nns_edge_data_s *ed;
-  int ret;
-
-  ed = (nns_edge_data_s *) data_h;
-  if (!ed) {
-    nns_edge_loge ("Invalid param, given edge data handle is null.");
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  nns_edge_lock (ed);
-
-  if (!NNS_EDGE_MAGIC_IS_VALID (ed)) {
-    nns_edge_loge ("Invalid param, given edge data is invalid.");
-    nns_edge_unlock (ed);
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  ret = nns_edge_metadata_serialize (&ed->metadata, data, data_len);
-
-  nns_edge_unlock (ed);
-  return ret;
-}
-
-/**
- * @brief Deserialize metadata in edge data.
- * @note This is internal function, DO NOT export this. Caller should release the returned value using free().
- */
-int
-nns_edge_data_deserialize_meta (nns_edge_data_h data_h, void *data,
-    size_t data_len)
-{
-  nns_edge_data_s *ed;
-  int ret;
-
-  ed = (nns_edge_data_s *) data_h;
-  if (!ed) {
-    nns_edge_loge ("Invalid param, given edge data handle is null.");
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  nns_edge_lock (ed);
-
-  if (!NNS_EDGE_MAGIC_IS_VALID (ed)) {
-    nns_edge_loge ("Invalid param, given edge data is invalid.");
-    nns_edge_unlock (ed);
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  ret = nns_edge_metadata_deserialize (&ed->metadata, data, data_len);
-
-  nns_edge_unlock (ed);
-  return ret;
-}
-
-/**
- * @brief Serialize edge data (meta data + raw data).
- * @note This is internal function, DO NOT export this. Caller should release the returned value using free().
- */
-int
-nns_edge_data_serialize (nns_edge_data_h data_h, void **data, size_t *len)
-{
-  nns_edge_data_s *ed;
-  nns_edge_data_header_s edata_header;
-  void *meta_serialized = NULL;
-  size_t total, header_len, data_len;
-  char *serialized, *ptr;
-  unsigned int n;
-  int ret;
-
-  ed = (nns_edge_data_s *) data_h;
-  if (!ed || !data || !len) {
-    nns_edge_loge ("Invalid param, one of the given param is null.");
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  nns_edge_lock (ed);
-
-  if (!NNS_EDGE_MAGIC_IS_VALID (ed)) {
-    nns_edge_loge ("Invalid param, given edge data is invalid.");
-    nns_edge_unlock (ed);
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  header_len = sizeof (nns_edge_data_header_s);
-
-  data_len = 0;
-  edata_header.num_mem = ed->num;
-  for (n = 0; n < ed->num; n++) {
-    edata_header.data_len[n] = ed->data[n].data_len;
-    data_len += ed->data[n].data_len;
-  }
-
-  ret =
-      nns_edge_metadata_serialize (&ed->metadata, &meta_serialized,
-      &edata_header.meta_len);
-  if (NNS_EDGE_ERROR_NONE != ret) {
-    goto done;
-  }
-
-  total = header_len + data_len + edata_header.meta_len;
-
-  serialized = ptr = (char *) malloc (total);
-  if (!serialized) {
-    ret = NNS_EDGE_ERROR_OUT_OF_MEMORY;
-    goto done;
-  }
-
-  /** Copy serialization header of edge data */
-  memcpy (ptr, &edata_header, header_len);
-  ptr += header_len;
-
-  /** Copy edge data */
-  for (n = 0; n < ed->num; n++) {
-    memcpy (ptr, ed->data[n].data, ed->data[n].data_len);
-    ptr += ed->data[n].data_len;
-  }
-
-  /** Copy edge meta data */
-  memcpy (ptr, meta_serialized, edata_header.meta_len);
-
-  *data = serialized;
-  *len = total;
-
-done:
-  nns_edge_free (meta_serialized);
-  nns_edge_unlock (ed);
-  return ret;
-}
-
-/**
- * @brief Deserialize metadata in edge data.
- * @note This is internal function, DO NOT export this. Caller should release the returned value using free().
- */
-int
-nns_edge_data_deserialize (nns_edge_data_h data_h, void *data)
-{
-  nns_edge_data_s *ed;
-  nns_edge_data_header_s *header;
-  int ret;
-  unsigned int n;
-  size_t meta_len;
-  char *ptr;
-
-  ed = (nns_edge_data_s *) data_h;
-  if (!ed || !data) {
-    nns_edge_loge ("Invalid param, one of the given param is null.");
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  nns_edge_lock (ed);
-
-  if (!NNS_EDGE_MAGIC_IS_VALID (ed)) {
-    nns_edge_loge ("Invalid param, given edge data is invalid.");
-    nns_edge_unlock (ed);
-    return NNS_EDGE_ERROR_INVALID_PARAMETER;
-  }
-
-  ptr = (char *) data;
-  header = (nns_edge_data_header_s *) ptr;
-
-  ed->num = header->num_mem;
-  for (n = 0; n < ed->num; n++) {
-    ed->data[n].data_len = header->data_len[n];
-  }
-  meta_len = header->meta_len;
-
-  ptr += sizeof (nns_edge_data_header_s);
-
-  for (n = 0; n < ed->num; n++) {
-    ed->data[n].data = nns_edge_memdup (ptr, ed->data[n].data_len);
-    ptr += ed->data[n].data_len;
-  }
-
-  ret = nns_edge_metadata_deserialize (&ed->metadata, ptr, meta_len);
-
-  nns_edge_unlock (ed);
-  return ret;
-}

diff --git a/src/libnnstreamer-edge/nnstreamer-edge-common.h b/src/libnnstreamer-edge/nnstreamer-edge-common.h
index 78dd493cdb4d1cf23f7092aa390317ef3e774f1d..010c506d2016c6f367e4a92296e48c77bd6f9508 100644 (file)
--- a/src/libnnstreamer-edge/nnstreamer-edge-common.h
+++ b/src/libnnstreamer-edge/nnstreamer-edge-common.h
@@ -16,73 +16,12 @@
 #define __NNSTREAMER_EDGE_COMMON_H__
 
 #include "nnstreamer-edge.h"
+#include "nnstreamer-edge-internal.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif /* __cplusplus */
 
-typedef void *nns_edge_broker_h;
-
-/**
- * @brief Internal data structure for metadata.
- */
-typedef struct _nns_edge_metadata_node_s nns_edge_metadata_node_s;
-
-/**
- * @brief Internal data structure for metadata.
- */
-struct _nns_edge_metadata_node_s {
-  char *key;
-  char *value;
-  nns_edge_metadata_node_s *next;
-};
-
-/**
- * @brief Internal data structure to handle metadata. This struct should be managed in the handle.
- */
-typedef struct {
-  unsigned int list_len;
-  nns_edge_metadata_node_s *list;
-} nns_edge_metadata_s;
-
-/**
- * @brief Internal data structure for raw data.
- */
-typedef struct {
-  void *data;
-  size_t data_len;
-  nns_edge_data_destroy_cb destroy_cb;
-} nns_edge_raw_data_s;
-
-/**
- * @brief Internal data structure for edge data.
- */
-typedef struct {
-  unsigned int magic;
-  pthread_mutex_t lock;
-  unsigned int num;
-  nns_edge_raw_data_s data[NNS_EDGE_DATA_LIMIT];
-  nns_edge_metadata_s metadata;
-} nns_edge_data_s;
-
-/**
- * @brief Internal data structure for edge event.
- */
-typedef struct {
-  unsigned int magic;
-  nns_edge_event_e event;
-  nns_edge_raw_data_s data;
-} nns_edge_event_s;
-
-/**
- * @brief Internal data structure for the header of the serialzied edge data.
- */
-typedef struct {
-  unsigned int num_mem;
-  size_t data_len[NNS_EDGE_DATA_LIMIT];
-  size_t meta_len;
-} nns_edge_data_header_s;
-
 /**
  * @brief Internal function to initialize metadata structure.
  */
@@ -136,38 +75,6 @@ int nns_edge_event_destroy (nns_edge_event_h event_h);
  */
 int nns_edge_event_set_data (nns_edge_event_h event_h, void *data, size_t data_len, nns_edge_data_destroy_cb destroy_cb);
 
-/**
- * @brief Validate edge data handle.
- * @note This is internal function, DO NOT export this.
- */
-int nns_edge_data_is_valid (nns_edge_data_h data_h);
-
-/**
- * @brief Serialize metadata in edge data.
- * @note This is internal function, DO NOT export this. Caller should release the returned value using free().
- */
-int nns_edge_data_serialize_meta (nns_edge_data_h data_h, void **data, size_t *data_len);
-
-/**
- * @brief Deserialize metadata in edge data.
- * @note This is internal function, DO NOT export this. Caller should release the returned value using free().
- */
-int nns_edge_data_deserialize_meta (nns_edge_data_h data_h, void *data, size_t data_len);
-
-/**
- * @brief Serialize entire edge data (meta data + raw data).
- * @note This is internal function, DO NOT export this. Caller should release the returned value using free().
- */
-int
-nns_edge_data_serialize (nns_edge_data_h data_h, void **data, size_t *data_len);
-
-/**
- * @brief Deserialize entire edge data (meta data + raw data).
- * @note This is internal function, DO NOT export this. Caller should release the returned value using free().
- */
-int
-nns_edge_data_deserialize (nns_edge_data_h data_h, void *data);
-
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */

diff --git a/src/libnnstreamer-edge/nnstreamer-edge-data.c b/src/libnnstreamer-edge/nnstreamer-edge-data.c
new file mode 100644 (file)
index 0000000..66e5113
--- /dev/null
+++ b/src/libnnstreamer-edge/nnstreamer-edge-data.c
@@ -0,0 +1,550 @@
+/* SPDX-License-Identifier: Apache-2.0 */
+/**
+ * Copyright (C) 2022 Samsung Electronics Co., Ltd. All Rights Reserved.
+ *
+ * @file   nnstreamer-edge-data.c
+ * @date   7 Sep 2022
+ * @brief  Util functions for edge data.
+ * @see    https://github.com/nnstreamer/nnstreamer
+ * @author Gichan Jang <gichan2.jang@samsung.com>
+ * @bug    No known bugs except for NYI items
+ */
+
+#include "nnstreamer-edge-data.h"
+#include "nnstreamer-edge-log.h"
+#include "nnstreamer-edge-common.h"
+#include "nnstreamer-edge-util.h"
+
+/**
+ * @brief Create nnstreamer edge data.
+ */
+int
+nns_edge_data_create (nns_edge_data_h * data_h)
+{
+  nns_edge_data_s *ed;
+
+  if (!data_h) {
+    nns_edge_loge ("Invalid param, data_h should not be null.");
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  ed = (nns_edge_data_s *) calloc (1, sizeof (nns_edge_data_s));
+  if (!ed) {
+    nns_edge_loge ("Failed to allocate memory for edge data.");
+    return NNS_EDGE_ERROR_OUT_OF_MEMORY;
+  }
+
+  nns_edge_lock_init (ed);
+  ed->magic = NNS_EDGE_MAGIC;
+  nns_edge_metadata_init (&ed->metadata);
+
+  *data_h = ed;
+  return NNS_EDGE_ERROR_NONE;
+}
+
+/**
+ * @brief Destroy nnstreamer edge data.
+ */
+int
+nns_edge_data_destroy (nns_edge_data_h data_h)
+{
+  nns_edge_data_s *ed;
+  unsigned int i;
+
+  ed = (nns_edge_data_s *) data_h;
+  if (!ed) {
+    nns_edge_loge ("Invalid param, given edge data handle is null.");
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  nns_edge_lock (ed);
+
+  if (!NNS_EDGE_MAGIC_IS_VALID (ed)) {
+    nns_edge_loge ("Invalid param, given edge data is invalid.");
+    nns_edge_unlock (ed);
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  ed->magic = NNS_EDGE_MAGIC_DEAD;
+
+  for (i = 0; i < ed->num; i++) {
+    if (ed->data[i].destroy_cb)
+      ed->data[i].destroy_cb (ed->data[i].data);
+  }
+
+  nns_edge_metadata_free (&ed->metadata);
+
+  nns_edge_unlock (ed);
+  nns_edge_lock_destroy (ed);
+  SAFE_FREE (ed);
+  return NNS_EDGE_ERROR_NONE;
+}
+
+/**
+ * @brief Validate edge data handle.
+ */
+int
+nns_edge_data_is_valid (nns_edge_data_h data_h)
+{
+  nns_edge_data_s *ed;
+
+  ed = (nns_edge_data_s *) data_h;
+  if (!ed) {
+    nns_edge_loge ("Invalid param, given edge data handle is null.");
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  nns_edge_lock (ed);
+
+  if (!NNS_EDGE_MAGIC_IS_VALID (ed)) {
+    nns_edge_loge ("Invalid param, edge data handle is invalid.");
+    nns_edge_unlock (ed);
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  nns_edge_unlock (ed);
+  return NNS_EDGE_ERROR_NONE;
+}
+
+/**
+ * @brief Copy edge data and return new handle.
+ */
+int
+nns_edge_data_copy (nns_edge_data_h data_h, nns_edge_data_h * new_data_h)
+{
+  nns_edge_data_s *ed;
+  nns_edge_data_s *copied;
+  unsigned int i;
+  int ret;
+
+  ed = (nns_edge_data_s *) data_h;
+  if (!ed) {
+    nns_edge_loge ("Invalid param, given edge data handle is null.");
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  if (!new_data_h) {
+    nns_edge_loge ("Invalid param, new_data_h should not be null.");
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  nns_edge_lock (ed);
+
+  if (!NNS_EDGE_MAGIC_IS_VALID (ed)) {
+    nns_edge_loge ("Invalid param, edge data handle is invalid.");
+    nns_edge_unlock (ed);
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  ret = nns_edge_data_create (new_data_h);
+  if (ret != NNS_EDGE_ERROR_NONE) {
+    nns_edge_loge ("Failed to create new data handle.");
+    nns_edge_unlock (ed);
+    return ret;
+  }
+
+  copied = (nns_edge_data_s *) (*new_data_h);
+
+  copied->num = ed->num;
+  for (i = 0; i < ed->num; i++) {
+    copied->data[i].data = nns_edge_memdup (ed->data[i].data,
+        ed->data[i].data_len);
+
+    if (!copied->data[i].data) {
+      nns_edge_loge ("Failed to copy data, error while allocating new memory.");
+      copied->num = i;
+      ret = NNS_EDGE_ERROR_OUT_OF_MEMORY;
+      goto done;
+    }
+
+    copied->data[i].data_len = ed->data[i].data_len;
+    copied->data[i].destroy_cb = nns_edge_free;
+  }
+
+  ret = nns_edge_metadata_copy (&copied->metadata, &ed->metadata);
+
+done:
+  if (ret != NNS_EDGE_ERROR_NONE) {
+    nns_edge_data_destroy (*new_data_h);
+    *new_data_h = NULL;
+  }
+
+  nns_edge_unlock (ed);
+  return ret;
+}
+
+/**
+ * @brief Add raw data into nnstreamer edge data.
+ */
+int
+nns_edge_data_add (nns_edge_data_h data_h, void *data, size_t data_len,
+    nns_edge_data_destroy_cb destroy_cb)
+{
+  nns_edge_data_s *ed;
+
+  ed = (nns_edge_data_s *) data_h;
+  if (!ed) {
+    nns_edge_loge ("Invalid param, given edge data handle is null.");
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  if (!data || data_len <= 0) {
+    nns_edge_loge ("Invalid param, data should not be null.");
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  nns_edge_lock (ed);
+
+  if (!NNS_EDGE_MAGIC_IS_VALID (ed)) {
+    nns_edge_loge ("Invalid param, given edge data is invalid.");
+    nns_edge_unlock (ed);
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  if (ed->num >= NNS_EDGE_DATA_LIMIT) {
+    nns_edge_loge ("Cannot add data, the maximum number of edge data is %d.",
+        NNS_EDGE_DATA_LIMIT);
+    nns_edge_unlock (ed);
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  ed->data[ed->num].data = data;
+  ed->data[ed->num].data_len = data_len;
+  ed->data[ed->num].destroy_cb = destroy_cb;
+  ed->num++;
+
+  nns_edge_unlock (ed);
+  return NNS_EDGE_ERROR_NONE;
+}
+
+/**
+ * @brief Get the n'th edge data.
+ */
+int
+nns_edge_data_get (nns_edge_data_h data_h, unsigned int index, void **data,
+    size_t *data_len)
+{
+  nns_edge_data_s *ed;
+
+  ed = (nns_edge_data_s *) data_h;
+  if (!ed) {
+    nns_edge_loge ("Invalid param, given edge data handle is null.");
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  if (!data || !data_len) {
+    nns_edge_loge ("Invalid param, data and len should not be null.");
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  nns_edge_lock (ed);
+
+  if (!NNS_EDGE_MAGIC_IS_VALID (ed)) {
+    nns_edge_loge ("Invalid param, given edge data is invalid.");
+    nns_edge_unlock (ed);
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  if (index >= ed->num) {
+    nns_edge_loge
+        ("Invalid param, the number of edge data is %u but requested %uth data.",
+        ed->num, index);
+    nns_edge_unlock (ed);
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  *data = ed->data[index].data;
+  *data_len = ed->data[index].data_len;
+
+  nns_edge_unlock (ed);
+  return NNS_EDGE_ERROR_NONE;
+}
+
+/**
+ * @brief Get the number of edge data in handle.
+ */
+int
+nns_edge_data_get_count (nns_edge_data_h data_h, unsigned int *count)
+{
+  nns_edge_data_s *ed;
+
+  ed = (nns_edge_data_s *) data_h;
+  if (!ed) {
+    nns_edge_loge ("Invalid param, given edge data handle is null.");
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  if (!count) {
+    nns_edge_loge ("Invalid param, count should not be null.");
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  nns_edge_lock (ed);
+
+  if (!NNS_EDGE_MAGIC_IS_VALID (ed)) {
+    nns_edge_loge ("Invalid param, given edge data is invalid.");
+    nns_edge_unlock (ed);
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  *count = ed->num;
+
+  nns_edge_unlock (ed);
+  return NNS_EDGE_ERROR_NONE;
+}
+
+/**
+ * @brief Set the information of edge data.
+ */
+int
+nns_edge_data_set_info (nns_edge_data_h data_h, const char *key,
+    const char *value)
+{
+  nns_edge_data_s *ed;
+  int ret;
+
+  ed = (nns_edge_data_s *) data_h;
+  if (!ed) {
+    nns_edge_loge ("Invalid param, given edge data handle is null.");
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  if (!STR_IS_VALID (key)) {
+    nns_edge_loge ("Invalid param, given key is invalid.");
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  nns_edge_lock (ed);
+
+  if (!NNS_EDGE_MAGIC_IS_VALID (ed)) {
+    nns_edge_loge ("Invalid param, given edge data is invalid.");
+    nns_edge_unlock (ed);
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  ret = nns_edge_metadata_set (&ed->metadata, key, value);
+
+  nns_edge_unlock (ed);
+  return ret;
+}
+
+/**
+ * @brief Get the information of edge data. Caller should release the returned value using free().
+ */
+int
+nns_edge_data_get_info (nns_edge_data_h data_h, const char *key, char **value)
+{
+  nns_edge_data_s *ed;
+  int ret;
+
+  ed = (nns_edge_data_s *) data_h;
+  if (!ed) {
+    nns_edge_loge ("Invalid param, given edge data handle is null.");
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  if (!STR_IS_VALID (key)) {
+    nns_edge_loge ("Invalid param, given key is invalid.");
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  if (!value) {
+    nns_edge_loge ("Invalid param, value should not be null.");
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  nns_edge_lock (ed);
+
+  if (!NNS_EDGE_MAGIC_IS_VALID (ed)) {
+    nns_edge_loge ("Invalid param, given edge data is invalid.");
+    nns_edge_unlock (ed);
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  ret = nns_edge_metadata_get (&ed->metadata, key, value);
+
+  nns_edge_unlock (ed);
+  return ret;
+}
+
+/**
+ * @brief Serialize metadata in edge data.
+ */
+int
+nns_edge_data_serialize_meta (nns_edge_data_h data_h, void **data,
+    size_t *data_len)
+{
+  nns_edge_data_s *ed;
+  int ret;
+
+  ed = (nns_edge_data_s *) data_h;
+  if (!ed) {
+    nns_edge_loge ("Invalid param, given edge data handle is null.");
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  nns_edge_lock (ed);
+
+  if (!NNS_EDGE_MAGIC_IS_VALID (ed)) {
+    nns_edge_loge ("Invalid param, given edge data is invalid.");
+    nns_edge_unlock (ed);
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  ret = nns_edge_metadata_serialize (&ed->metadata, data, data_len);
+
+  nns_edge_unlock (ed);
+  return ret;
+}
+
+/**
+ * @brief Deserialize metadata in edge data.
+ */
+int
+nns_edge_data_deserialize_meta (nns_edge_data_h data_h, void *data,
+    size_t data_len)
+{
+  nns_edge_data_s *ed;
+  int ret;
+
+  ed = (nns_edge_data_s *) data_h;
+  if (!ed) {
+    nns_edge_loge ("Invalid param, given edge data handle is null.");
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  nns_edge_lock (ed);
+
+  if (!NNS_EDGE_MAGIC_IS_VALID (ed)) {
+    nns_edge_loge ("Invalid param, given edge data is invalid.");
+    nns_edge_unlock (ed);
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  ret = nns_edge_metadata_deserialize (&ed->metadata, data, data_len);
+
+  nns_edge_unlock (ed);
+  return ret;
+}
+
+/**
+ * @brief Serialize edge data (meta data + raw data).
+ */
+int
+nns_edge_data_serialize (nns_edge_data_h data_h, void **data, size_t *len)
+{
+  nns_edge_data_s *ed;
+  nns_edge_data_header_s edata_header;
+  void *meta_serialized = NULL;
+  size_t total, header_len, data_len;
+  char *serialized, *ptr;
+  unsigned int n;
+  int ret;
+
+  ed = (nns_edge_data_s *) data_h;
+  if (!ed || !data || !len) {
+    nns_edge_loge ("Invalid param, one of the given param is null.");
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  nns_edge_lock (ed);
+
+  if (!NNS_EDGE_MAGIC_IS_VALID (ed)) {
+    nns_edge_loge ("Invalid param, given edge data is invalid.");
+    nns_edge_unlock (ed);
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  header_len = sizeof (nns_edge_data_header_s);
+
+  data_len = 0;
+  edata_header.num_mem = ed->num;
+  for (n = 0; n < ed->num; n++) {
+    edata_header.data_len[n] = ed->data[n].data_len;
+    data_len += ed->data[n].data_len;
+  }
+
+  ret = nns_edge_metadata_serialize (&ed->metadata, &meta_serialized,
+      &edata_header.meta_len);
+  if (NNS_EDGE_ERROR_NONE != ret) {
+    goto done;
+  }
+
+  total = header_len + data_len + edata_header.meta_len;
+
+  serialized = ptr = (char *) malloc (total);
+  if (!serialized) {
+    ret = NNS_EDGE_ERROR_OUT_OF_MEMORY;
+    goto done;
+  }
+
+  /** Copy serialization header of edge data */
+  memcpy (ptr, &edata_header, header_len);
+  ptr += header_len;
+
+  /** Copy edge data */
+  for (n = 0; n < ed->num; n++) {
+    memcpy (ptr, ed->data[n].data, ed->data[n].data_len);
+    ptr += ed->data[n].data_len;
+  }
+
+  /** Copy edge meta data */
+  memcpy (ptr, meta_serialized, edata_header.meta_len);
+
+  *data = serialized;
+  *len = total;
+
+done:
+  nns_edge_free (meta_serialized);
+  nns_edge_unlock (ed);
+  return ret;
+}
+
+/**
+ * @brief Deserialize metadata in edge data.
+ */
+int
+nns_edge_data_deserialize (nns_edge_data_h data_h, void *data)
+{
+  nns_edge_data_s *ed;
+  nns_edge_data_header_s *header;
+  int ret;
+  unsigned int n;
+  size_t meta_len;
+  char *ptr;
+
+  ed = (nns_edge_data_s *) data_h;
+  if (!ed || !data) {
+    nns_edge_loge ("Invalid param, one of the given param is null.");
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  nns_edge_lock (ed);
+
+  if (!NNS_EDGE_MAGIC_IS_VALID (ed)) {
+    nns_edge_loge ("Invalid param, given edge data is invalid.");
+    nns_edge_unlock (ed);
+    return NNS_EDGE_ERROR_INVALID_PARAMETER;
+  }
+
+  ptr = (char *) data;
+  header = (nns_edge_data_header_s *) ptr;
+
+  ed->num = header->num_mem;
+  for (n = 0; n < ed->num; n++) {
+    ed->data[n].data_len = header->data_len[n];
+  }
+  meta_len = header->meta_len;
+
+  ptr += sizeof (nns_edge_data_header_s);
+
+  for (n = 0; n < ed->num; n++) {
+    ed->data[n].data = nns_edge_memdup (ptr, ed->data[n].data_len);
+    ptr += ed->data[n].data_len;
+  }
+
+  ret = nns_edge_metadata_deserialize (&ed->metadata, ptr, meta_len);
+
+  nns_edge_unlock (ed);
+  return ret;
+}

diff --git a/src/libnnstreamer-edge/nnstreamer-edge-data.h b/src/libnnstreamer-edge/nnstreamer-edge-data.h
new file mode 100644 (file)
index 0000000..f87b6bc
--- /dev/null
+++ b/src/libnnstreamer-edge/nnstreamer-edge-data.h
@@ -0,0 +1,77 @@
+/* SPDX-License-Identifier: Apache-2.0 */
+/**
+ * Copyright (C) 2022 Samsung Electronics Co., Ltd. All Rights Reserved.
+ *
+ * @file   nnstreamer-edge-data.h
+ * @date   7 Sep 2022
+ * @brief  Util functions for edge data.
+ * @see    https://github.com/nnstreamer/nnstreamer
+ * @author Gichan Jang <gichan2.jang@samsung.com>
+ * @bug    No known bugs except for NYI items
+ * @note   This file is internal header for nnstreamer edge utils. DO NOT export this file.
+ */
+
+#ifndef __NNSTREAMER_EDGE_DATA_H__
+#define __NNSTREAMER_EDGE_DATA_H__
+
+#include "nnstreamer-edge.h"
+#include "nnstreamer-edge-internal.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/**
+ * @brief Internal data structure for edge data.
+ */
+typedef struct {
+  unsigned int magic;
+  pthread_mutex_t lock;
+  unsigned int num;
+  nns_edge_raw_data_s data[NNS_EDGE_DATA_LIMIT];
+  nns_edge_metadata_s metadata;
+} nns_edge_data_s;
+
+/**
+ * @brief Internal data structure for the header of the serialzied edge data.
+ */
+typedef struct {
+  unsigned int num_mem;
+  size_t data_len[NNS_EDGE_DATA_LIMIT];
+  size_t meta_len;
+} nns_edge_data_header_s;
+
+/**
+ * @brief Validate edge data handle.
+ * @note This is internal function, DO NOT export this.
+ */
+int nns_edge_data_is_valid (nns_edge_data_h data_h);
+
+/**
+ * @brief Serialize metadata in edge data.
+ * @note This is internal function, DO NOT export this. Caller should release the returned value using free().
+ */
+int nns_edge_data_serialize_meta (nns_edge_data_h data_h, void **data, size_t *data_len);
+
+/**
+ * @brief Deserialize metadata in edge data.
+ * @note This is internal function, DO NOT export this. Caller should release the returned value using free().
+ */
+int nns_edge_data_deserialize_meta (nns_edge_data_h data_h, void *data, size_t data_len);
+
+/**
+ * @brief Serialize entire edge data (meta data + raw data).
+ * @note This is internal function, DO NOT export this. Caller should release the returned value using free().
+ */
+int nns_edge_data_serialize (nns_edge_data_h data_h, void **data, size_t *data_len);
+
+/**
+ * @brief Deserialize entire edge data (meta data + raw data).
+ * @note This is internal function, DO NOT export this. Caller should release the returned value using free().
+ */
+int nns_edge_data_deserialize (nns_edge_data_h data_h, void *data);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif /* __NNSTREAMER_EDGE_DATA_H__ */

diff --git a/src/libnnstreamer-edge/nnstreamer-edge-internal.c b/src/libnnstreamer-edge/nnstreamer-edge-internal.c
index 79f23e968943d1ce8c35cfd81f935c5e4c0ceac6..1a7bc208a855ee540b7469ba6160fca0e1b2ec6d 100644 (file)
--- a/src/libnnstreamer-edge/nnstreamer-edge-internal.c
+++ b/src/libnnstreamer-edge/nnstreamer-edge-internal.c
@@ -14,7 +14,9 @@
 #include <netdb.h>
 #include <sys/poll.h>
 
+#include "nnstreamer-edge-data.h"
 #include "nnstreamer-edge-log.h"
+#include "nnstreamer-edge-common.h"
 #include "nnstreamer-edge-util.h"
 #include "nnstreamer-edge-internal.h"
 
@@ -321,7 +323,7 @@ static int
 _nns_edge_cmd_send_aitt (nns_edge_handle_s * eh, nns_edge_data_h * data_h)
 {
   int ret;
-  void *data;
+  void *data = NULL;
   size_t size;
 
   if (!eh) {
@@ -329,9 +331,7 @@ _nns_edge_cmd_send_aitt (nns_edge_handle_s * eh, nns_edge_data_h * data_h)
     return NNS_EDGE_ERROR_INVALID_PARAMETER;
   }
 
-
   ret = nns_edge_data_serialize (data_h, &data, &size);
-
   if (NNS_EDGE_ERROR_NONE != ret) {
     nns_edge_loge ("Failed to serialize the edge data.");
     goto done;

diff --git a/src/libnnstreamer-edge/nnstreamer-edge-internal.h b/src/libnnstreamer-edge/nnstreamer-edge-internal.h
index bec3d9aa27dc05a321e280d9042681e964657dd6..bd72251e2468b2705b7e6172ffd190550c8e0d4f 100644 (file)
--- a/src/libnnstreamer-edge/nnstreamer-edge-internal.h
+++ b/src/libnnstreamer-edge/nnstreamer-edge-internal.h
@@ -19,9 +19,50 @@ extern "C" {
 #endif /* __cplusplus */
 
 #include "nnstreamer-edge.h"
-#include "nnstreamer-edge-common.h"
 #include "nnstreamer-edge-queue.h"
 
+typedef void *nns_edge_broker_h;
+
+/**
+ * @brief Internal data structure for raw data.
+ */
+typedef struct {
+  void *data;
+  size_t data_len;
+  nns_edge_data_destroy_cb destroy_cb;
+} nns_edge_raw_data_s;
+
+/**
+ * @brief Internal data structure for metadata.
+ */
+typedef struct _nns_edge_metadata_node_s nns_edge_metadata_node_s;
+
+/**
+ * @brief Internal data structure for metadata.
+ */
+struct _nns_edge_metadata_node_s {
+  char *key;
+  char *value;
+  nns_edge_metadata_node_s *next;
+};
+
+/**
+ * @brief Internal data structure to handle metadata. This struct should be managed in the handle.
+ */
+typedef struct {
+  unsigned int list_len;
+  nns_edge_metadata_node_s *list;
+} nns_edge_metadata_s;
+
+/**
+ * @brief Internal data structure for edge event.
+ */
+typedef struct {
+  unsigned int magic;
+  nns_edge_event_e event;
+  nns_edge_raw_data_s data;
+} nns_edge_event_s;
+
 /**
  * @brief Data structure for edge handle.
  */

diff --git a/tests/unittest_nnstreamer-edge-aitt.cc b/tests/unittest_nnstreamer-edge-aitt.cc
index 7daac787dcdb5ac4597b870b96fe4be5e7f5cba2..6d8e8bf55e66b15241c951a1fb3e9d9cc7978f0d 100644 (file)
--- a/tests/unittest_nnstreamer-edge-aitt.cc
+++ b/tests/unittest_nnstreamer-edge-aitt.cc
@@ -55,7 +55,6 @@ _free_test_data (ne_test_data_s *_td)
   free (_td);
 }
 
-
 /**
  * @brief Edge event callback for test.
  */
@@ -218,7 +217,7 @@ TEST(edge, connectLocal)
   ret = nns_edge_data_add (data_h, data2, data_len * 2, nns_edge_free);
   EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
 
-  for (i = 0; i < 1U; i++) {
+  for (i = 0; i < 5U; i++) {
     ret = nns_edge_send (server_h, data_h);
     EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
     usleep (10000);

diff --git a/tests/unittest_nnstreamer-edge.cc b/tests/unittest_nnstreamer-edge.cc
index 3f1bcaca7bcc77be2fdba77bc969c55a67007492..a07ef7a9e982b65bdba6cbf3d7c03d8c414dadba 100644 (file)
--- a/tests/unittest_nnstreamer-edge.cc
+++ b/tests/unittest_nnstreamer-edge.cc
@@ -1,3975 +1,3976 @@
-/**\r
- * @file        unittest_nnstreamer-edge.cc\r
- * @date        27 June 2022\r
- * @brief       Unittest for nnstreamer-edge library.\r
- * @see         https://github.com/nnstreamer/nnstreamer-edge\r
- * @author      Jaeyun Jung <jy1210.jung@samsung.com>\r
- * @bug         No known bugs\r
- */\r
-\r
-#include <gtest/gtest.h>\r
-#include "nnstreamer-edge.h"\r
-#include "nnstreamer-edge-common.h"\r
-#include "nnstreamer-edge-internal.h"\r
-#include "nnstreamer-edge-log.h"\r
-#include "nnstreamer-edge-util.h"\r
-#include "nnstreamer-edge-queue.h"\r
-\r
-/**\r
- * @brief Data struct for unittest.\r
- */\r
-typedef struct\r
-{\r
-  nns_edge_h handle;\r
-  bool running;\r
-  bool is_server;\r
-  bool event_cb_released;\r
-  unsigned int received;\r
-} ne_test_data_s;\r
-\r
-/**\r
- * @brief Allocate and initialize test data.\r
- */\r
-static ne_test_data_s *\r
-_get_test_data (bool is_server)\r
-{\r
-  ne_test_data_s *_td;\r
-\r
-  _td = (ne_test_data_s *) calloc (1, sizeof (ne_test_data_s));\r
-\r
-  if (_td) {\r
-    _td->is_server = is_server;\r
-  }\r
-\r
-  return _td;\r
-}\r
-\r
-/**\r
- * @brief Release test data.\r
- */\r
-static void\r
-_free_test_data (ne_test_data_s *_td)\r
-{\r
-  if (!_td)\r
-    return;\r
-\r
-  free (_td);\r
-}\r
-\r
-/**\r
- * @brief Edge event callback for test.\r
- */\r
-static int\r
-_test_edge_event_cb (nns_edge_event_h event_h, void *user_data)\r
-{\r
-  ne_test_data_s *_td = (ne_test_data_s *) user_data;\r
-  nns_edge_event_e event = NNS_EDGE_EVENT_UNKNOWN;\r
-  nns_edge_data_h data_h;\r
-  void *data;\r
-  size_t data_len;\r
-  char *val;\r
-  unsigned int i, count;\r
-  int ret;\r
-\r
-  if (!_td) {\r
-    /* Cannot update event status. */\r
-    return NNS_EDGE_ERROR_NONE;\r
-  }\r
-\r
-  ret = nns_edge_event_get_type (event_h, &event);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  switch (event) {\r
-    case NNS_EDGE_EVENT_CALLBACK_RELEASED:\r
-      _td->event_cb_released = true;\r
-      break;\r
-    case NNS_EDGE_EVENT_NEW_DATA_RECEIVED:\r
-      _td->received++;\r
-\r
-      ret = nns_edge_event_parse_new_data (event_h, &data_h);\r
-      EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-      /* Compare metadata */\r
-      ret = nns_edge_data_get_info (data_h, "test-key1", &val);\r
-      EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-      EXPECT_STREQ (val, "test-value1");\r
-      nns_edge_free (val);\r
-      ret = nns_edge_data_get_info (data_h, "test-key2", &val);\r
-      EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-      EXPECT_STREQ (val, "test-value2");\r
-      nns_edge_free (val);\r
-\r
-      if (_td->is_server) {\r
-        /**\r
-         * @note This is test code, responding to client.\r
-         * Recommend not to call edge API in event callback.\r
-         */\r
-        ret = nns_edge_send (_td->handle, data_h);\r
-        EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-      } else {\r
-        /* Compare received data */\r
-        ret = nns_edge_data_get_count (data_h, &count);\r
-        EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-        ret = nns_edge_data_get (data_h, 0, &data, &data_len);\r
-        EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-        EXPECT_EQ (count, 1U);\r
-        for (i = 0; i < 10U; i++)\r
-          EXPECT_EQ (((unsigned int *) data)[i], i);\r
-      }\r
-\r
-      ret = nns_edge_data_destroy (data_h);\r
-      EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-      break;\r
-    default:\r
-      break;\r
-  }\r
-\r
-  return NNS_EDGE_ERROR_NONE;\r
-}\r
-\r
-/**\r
- * @brief Connect to local host, multiple clients.\r
- */\r
-TEST(edge, connectLocal)\r
-{\r
-  nns_edge_h server_h, client1_h, client2_h;\r
-  ne_test_data_s *_td_server, *_td_client1, *_td_client2;\r
-  nns_edge_data_h data_h;\r
-  size_t data_len;\r
-  void *data;\r
-  unsigned int i, retry;\r
-  int ret, port;\r
-  char *val, *client1_id, *client2_id;\r
-\r
-  _td_server = _get_test_data (true);\r
-  _td_client1 = _get_test_data (false);\r
-  _td_client2 = _get_test_data (false);\r
-  ASSERT_TRUE (_td_server != NULL && _td_client1 != NULL && _td_client2 != NULL);\r
-  port = nns_edge_get_available_port ();\r
-\r
-  /* Prepare server (127.0.0.1:port) */\r
-  val = nns_edge_strdup_printf ("%d", port);\r
-  nns_edge_create_handle ("temp-server", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND | NNS_EDGE_FLAG_SERVER), &server_h);\r
-  nns_edge_set_event_callback (server_h, _test_edge_event_cb, _td_server);\r
-  nns_edge_set_info (server_h, "IP", "127.0.0.1");\r
-  nns_edge_set_info (server_h, "PORT", val);\r
-  nns_edge_set_info (server_h, "CAPS", "test server");\r
-  _td_server->handle = server_h;\r
-  nns_edge_free (val);\r
-\r
-  /* Prepare client */\r
-  nns_edge_create_handle ("temp-client1", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &client1_h);\r
-  nns_edge_set_event_callback (client1_h, _test_edge_event_cb, _td_client1);\r
-  nns_edge_set_info (client1_h, "CAPS", "test client1");\r
-  _td_client1->handle = client1_h;\r
-\r
-  nns_edge_create_handle ("temp-client2", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &client2_h);\r
-  nns_edge_set_event_callback (client2_h, _test_edge_event_cb, _td_client2);\r
-  nns_edge_set_info (client2_h, "CAPS", "test client2");\r
-  _td_client2->handle = client2_h;\r
-\r
-  ret = nns_edge_start (server_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_start (client1_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_start (client2_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  usleep (200000);\r
-\r
-  ret = nns_edge_connect (client1_h, "127.0.0.1", port);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  usleep (10000);\r
-  ret = nns_edge_connect (client2_h, "127.0.0.1", port);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  sleep (2);\r
-\r
-  /* Send request to server */\r
-  data_len = 10U * sizeof (unsigned int);\r
-  data = malloc (data_len);\r
-  ASSERT_TRUE (data != NULL);\r
-\r
-  client1_id = client2_id = NULL;\r
-  ret = nns_edge_get_info (client1_h, "client_id", &client1_id);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_get_info (client2_h, "client_id", &client2_id);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  for (i = 0; i < 10U; i++)\r
-    ((unsigned int *) data)[i] = i;\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_add (data_h, data, data_len, nns_edge_free);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  /* For metadata test */\r
-  ret = nns_edge_data_set_info (data_h, "test-key1", "test-value1");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_data_set_info (data_h, "test-key2", "test-value2");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  for (i = 0; i < 5U; i++) {\r
-    ret = nns_edge_data_set_info (data_h, "client_id", client1_id);\r
-    EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-    ret = nns_edge_send (client1_h, data_h);\r
-    EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-    usleep (10000);\r
-    ret = nns_edge_data_set_info (data_h, "client_id", client2_id);\r
-    EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-    ret = nns_edge_send (client2_h, data_h);\r
-    EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-    usleep (100000);\r
-  }\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  /* Wait for responding data (20 seconds) */\r
-  retry = 0U;\r
-  do {\r
-    usleep (100000);\r
-    if (_td_client1->received > 0 && _td_client2->received > 0)\r
-      break;\r
-  } while (retry++ < 200U);\r
-\r
-  ret = nns_edge_disconnect (server_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_release_handle (server_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_release_handle (client1_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_release_handle (client2_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  EXPECT_TRUE (_td_server->received > 0);\r
-  EXPECT_TRUE (_td_client1->received > 0);\r
-  EXPECT_TRUE (_td_client2->received > 0);\r
-\r
-  nns_edge_free (client1_id);\r
-  nns_edge_free (client2_id);\r
-\r
-  _free_test_data (_td_server);\r
-  _free_test_data (_td_client1);\r
-  _free_test_data (_td_client2);\r
-}\r
-\r
-/**\r
- * @brief Create edge handle - invalid param.\r
- */\r
-TEST(edge, createHandleInvalidParam01_n)\r
-{\r
-  nns_edge_h edge_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle (NULL, NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Create edge handle - invalid param.\r
- */\r
-TEST(edge, createHandleInvalidParam02_n)\r
-{\r
-  nns_edge_h edge_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_UNKNOWN,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Create edge handle - invalid param.\r
- */\r
-TEST(edge, createHandleInvalidParam03_n)\r
-{\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Create edge handle - invalid param.\r
- */\r
-TEST(edge, createHandleInvalidParam04_n)\r
-{\r
-  nns_edge_h edge_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle ("", NNS_EDGE_CONNECT_TYPE_MQTT,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Create edge handle - invalid param.\r
- */\r
-TEST(edge, createHandleInvalidParam05_n)\r
-{\r
-  nns_edge_h edge_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_HYBRID,\r
-      NNS_EDGE_FLAG_NONE, &edge_h);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Start - invalid param.\r
- */\r
-TEST(edge, startInvalidParam01_n)\r
-{\r
-  int ret;\r
-\r
-  ret = nns_edge_start (NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Start - invalid param.\r
- */\r
-TEST(edge, startInvalidParam02_n)\r
-{\r
-  nns_edge_h edge_h;\r
-  nns_edge_handle_s *eh;\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  eh = (nns_edge_handle_s *) edge_h;\r
-  eh->magic = NNS_EDGE_MAGIC_DEAD;\r
-\r
-  ret = nns_edge_start (edge_h);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  eh->magic = NNS_EDGE_MAGIC;\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Release edge handle - invalid param.\r
- */\r
-TEST(edge, releaseHandleInvalidParam01_n)\r
-{\r
-  int ret;\r
-\r
-  ret = nns_edge_release_handle (NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Release edge handle - invalid param.\r
- */\r
-TEST(edge, releaseHandleInvalidParam02_n)\r
-{\r
-  nns_edge_h edge_h;\r
-  nns_edge_handle_s *eh;\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  eh = (nns_edge_handle_s *) edge_h;\r
-  eh->magic = NNS_EDGE_MAGIC_DEAD;\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  eh->magic = NNS_EDGE_MAGIC;\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Set event callback - null param to clear event callback.\r
- */\r
-TEST(edge, setEventCbSetNullCallback)\r
-{\r
-  nns_edge_h edge_h;\r
-  ne_test_data_s *_td;\r
-  int ret;\r
-\r
-  _td = _get_test_data (false);\r
-  ASSERT_TRUE (_td != NULL);\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_set_event_callback (edge_h, _test_edge_event_cb, _td);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  /* Set null param to clear event callback. */\r
-  ret = nns_edge_set_event_callback (edge_h, NULL, NULL);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  EXPECT_TRUE (_td->event_cb_released);\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  _free_test_data (_td);\r
-}\r
-\r
-/**\r
- * @brief Set event callback - invalid param.\r
- */\r
-TEST(edge, setEventCbInvalidParam01_n)\r
-{\r
-  int ret;\r
-\r
-  ret = nns_edge_set_event_callback (NULL, _test_edge_event_cb, NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Set event callback - invalid param.\r
- */\r
-TEST(edge, setEventCbInvalidParam02_n)\r
-{\r
-  nns_edge_h edge_h;\r
-  nns_edge_handle_s *eh;\r
-  ne_test_data_s *_td;\r
-  int ret;\r
-\r
-  _td = _get_test_data (false);\r
-  ASSERT_TRUE (_td != NULL);\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  eh = (nns_edge_handle_s *) edge_h;\r
-  eh->magic = NNS_EDGE_MAGIC_DEAD;\r
-\r
-  ret = nns_edge_set_event_callback (edge_h, _test_edge_event_cb, _td);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  eh->magic = NNS_EDGE_MAGIC;\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  _free_test_data (_td);\r
-}\r
-\r
-/**\r
- * @brief Connect - invalid param.\r
- */\r
-TEST(edge, connectInvalidParam01_n)\r
-{\r
-  int ret;\r
-\r
-  ret = nns_edge_connect (NULL, "127.0.0.1", 80);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Connect - invalid param.\r
- */\r
-TEST(edge, connectInvalidParam02_n)\r
-{\r
-  nns_edge_h edge_h;\r
-  nns_edge_handle_s *eh;\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_set_event_callback (edge_h, _test_edge_event_cb, NULL);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  eh = (nns_edge_handle_s *) edge_h;\r
-  eh->magic = NNS_EDGE_MAGIC_DEAD;\r
-\r
-  ret = nns_edge_connect (edge_h, "127.0.0.1", 80);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  eh->magic = NNS_EDGE_MAGIC;\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Connect - invalid param.\r
- */\r
-TEST(edge, connectInvalidParam03_n)\r
-{\r
-  nns_edge_h edge_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_set_event_callback (edge_h, _test_edge_event_cb, NULL);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_connect (edge_h, NULL, 80);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Connect - invalid param.\r
- */\r
-TEST(edge, connectInvalidParam04_n)\r
-{\r
-  nns_edge_h edge_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_set_event_callback (edge_h, _test_edge_event_cb, NULL);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_connect (edge_h, "", 80);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Connect - invalid param.\r
- */\r
-TEST(edge, connectInvalidParam05_n)\r
-{\r
-  nns_edge_h edge_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_set_event_callback (edge_h, _test_edge_event_cb, NULL);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  /* Invalid port number */\r
-  ret = nns_edge_connect (edge_h, "127.0.0.1", -1);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_connect (edge_h, "127.0.0.1", 0);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_connect (edge_h, "127.0.0.1", 77777);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Disconnect - invalid param.\r
- */\r
-TEST(edge, disconnectInvalidParam01_n)\r
-{\r
-  int ret;\r
-\r
-  ret = nns_edge_disconnect (NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Disconnect - invalid param.\r
- */\r
-TEST(edge, disconnectInvalidParam02_n)\r
-{\r
-  nns_edge_h edge_h;\r
-  nns_edge_handle_s *eh;\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  eh = (nns_edge_handle_s *) edge_h;\r
-  eh->magic = NNS_EDGE_MAGIC_DEAD;\r
-\r
-  ret = nns_edge_disconnect (edge_h);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  eh->magic = NNS_EDGE_MAGIC;\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Send - invalid param.\r
- */\r
-TEST(edge, sendInvalidParam01_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_set_info (data_h, "client_id", "10");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_send (NULL, data_h);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Send - invalid param.\r
- */\r
-TEST(edge, sendInvalidParam02_n)\r
-{\r
-  nns_edge_h edge_h;\r
-  nns_edge_data_h data_h;\r
-  nns_edge_handle_s *eh;\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_set_info (data_h, "client_id", "10");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  eh = (nns_edge_handle_s *) edge_h;\r
-  eh->magic = NNS_EDGE_MAGIC_DEAD;\r
-\r
-  ret = nns_edge_send (edge_h, data_h);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  eh->magic = NNS_EDGE_MAGIC;\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Send - invalid param.\r
- */\r
-TEST(edge, sendInvalidParam03_n)\r
-{\r
-  nns_edge_h edge_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_send (edge_h, NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Set info - invalid param.\r
- */\r
-TEST(edge, setInfoInvalidParam01_n)\r
-{\r
-  int ret;\r
-\r
-  ret = nns_edge_set_info (NULL, "caps", "temp-caps");\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Set info - invalid param.\r
- */\r
-TEST(edge, setInfoInvalidParam02_n)\r
-{\r
-  nns_edge_h edge_h;\r
-  nns_edge_handle_s *eh;\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  eh = (nns_edge_handle_s *) edge_h;\r
-  eh->magic = NNS_EDGE_MAGIC_DEAD;\r
-\r
-  ret = nns_edge_set_info (edge_h, "caps", "temp-caps");\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  eh->magic = NNS_EDGE_MAGIC;\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Set info - invalid param.\r
- */\r
-TEST(edge, setInfoInvalidParam03_n)\r
-{\r
-  nns_edge_h edge_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_set_info (edge_h, NULL, "temp-caps");\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Set info - invalid param.\r
- */\r
-TEST(edge, setInfoInvalidParam04_n)\r
-{\r
-  nns_edge_h edge_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_set_info (edge_h, "", "temp-caps");\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Set info - invalid param.\r
- */\r
-TEST(edge, setInfoInvalidParam05_n)\r
-{\r
-  nns_edge_h edge_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_set_info (edge_h, "caps", NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Set info - invalid param.\r
- */\r
-TEST(edge, setInfoInvalidParam06_n)\r
-{\r
-  nns_edge_h edge_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_set_info (edge_h, "caps", "");\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Set info - invalid param.\r
- */\r
-TEST(edge, setInfoInvalidParam07_n)\r
-{\r
-  nns_edge_h edge_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  /* Not allowed key */\r
-  ret = nns_edge_set_info (edge_h, "id", "temp-id2");\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_set_info (edge_h, "client_id", "temp-cid");\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Set info - invalid param.\r
- */\r
-TEST(edge, setInfoInvalidParam08_n)\r
-{\r
-  nns_edge_h edge_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  /* Invalid port number */\r
-  ret = nns_edge_set_info (edge_h, "port", "-1");\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_set_info (edge_h, "port", "0");\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_set_info (edge_h, "port", "77777");\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Get info.\r
- */\r
-TEST(edge, getInfo)\r
-{\r
-  nns_edge_h edge_h;\r
-  char *value = NULL;\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_set_info (edge_h, "capability", "capa-for-test");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_set_info (edge_h, "topic", "topic-for-test");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_set_info (edge_h, "ip", "165.213.201.100");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_set_info (edge_h, "port", "2000");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_set_info (edge_h, "dest_ip", "165.213.201.101");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_set_info (edge_h, "dest_port", "2001");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_set_info (edge_h, "temp-key1", "temp-value1");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_set_info (edge_h, "temp-key2", "temp-value2");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_get_info (edge_h, "ID", &value);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_STREQ (value, "temp-id");\r
-  nns_edge_free (value);\r
-\r
-  ret = nns_edge_get_info (edge_h, "capability", &value);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_STREQ (value, "capa-for-test");\r
-  nns_edge_free (value);\r
-\r
-  ret = nns_edge_get_info (edge_h, "topic", &value);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_STREQ (value, "topic-for-test");\r
-  nns_edge_free (value);\r
-\r
-  ret = nns_edge_get_info (edge_h, "ip", &value);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_STREQ (value, "165.213.201.100");\r
-  nns_edge_free (value);\r
-\r
-  ret = nns_edge_get_info (edge_h, "port", &value);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_STREQ (value, "2000");\r
-  nns_edge_free (value);\r
-\r
-  ret = nns_edge_get_info (edge_h, "dest_ip", &value);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_STREQ (value, "165.213.201.101");\r
-  nns_edge_free (value);\r
-\r
-  ret = nns_edge_get_info (edge_h, "dest_port", &value);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_STREQ (value, "2001");\r
-  nns_edge_free (value);\r
-\r
-  ret = nns_edge_get_info (edge_h, "temp-key1", &value);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_STREQ (value, "temp-value1");\r
-  nns_edge_free (value);\r
-\r
-  ret = nns_edge_get_info (edge_h, "temp-key2", &value);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_STREQ (value, "temp-value2");\r
-  nns_edge_free (value);\r
-\r
-  /* Replace old value */\r
-  ret = nns_edge_set_info (edge_h, "temp-key2", "temp-value2-replaced");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_get_info (edge_h, "temp-key2", &value);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_STREQ (value, "temp-value2-replaced");\r
-  nns_edge_free (value);\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Get info - invalid param.\r
- */\r
-TEST(edge, getInfoInvalidParam01_n)\r
-{\r
-  char *value = NULL;\r
-  int ret;\r
-\r
-  ret = nns_edge_get_info (NULL, "temp-key", &value);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Get info - invalid param.\r
- */\r
-TEST(edge, getInfoInvalidParam02_n)\r
-{\r
-  nns_edge_h edge_h;\r
-  nns_edge_handle_s *eh;\r
-  char *value;\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  eh = (nns_edge_handle_s *) edge_h;\r
-  eh->magic = NNS_EDGE_MAGIC_DEAD;\r
-\r
-  ret = nns_edge_get_info (edge_h, "temp-key", &value);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  eh->magic = NNS_EDGE_MAGIC;\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Get info - invalid param.\r
- */\r
-TEST(edge, getInfoInvalidParam03_n)\r
-{\r
-  nns_edge_h edge_h;\r
-  char *value = NULL;\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_get_info (edge_h, NULL, &value);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Get info - invalid param.\r
- */\r
-TEST(edge, getInfoInvalidParam04_n)\r
-{\r
-  nns_edge_h edge_h;\r
-  char *value = NULL;\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_get_info (edge_h, "", &value);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Get info - invalid param.\r
- */\r
-TEST(edge, getInfoInvalidParam05_n)\r
-{\r
-  nns_edge_h edge_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_get_info (edge_h, "temp-key", NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Get info - invalid param.\r
- */\r
-TEST(edge, getInfoInvalidParam06_n)\r
-{\r
-  nns_edge_h edge_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,\r
-      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND | NNS_EDGE_FLAG_SERVER), &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  /* Cannot get the client ID if handle is server */\r
-  ret = nns_edge_get_info (edge_h, "client_id", NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Create edge-data - invalid param.\r
- */\r
-TEST(edgeData, createInvalidParam01_n)\r
-{\r
-  int ret;\r
-\r
-  ret = nns_edge_data_create (NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Destroy edge-data - invalid param.\r
- */\r
-TEST(edgeData, destroyInvalidParam01_n)\r
-{\r
-  int ret;\r
-\r
-  ret = nns_edge_data_destroy (NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Destroy edge-data - invalid param.\r
- */\r
-TEST(edgeData, destroyInvalidParam02_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  nns_edge_data_s *ed;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ed = (nns_edge_data_s *) data_h;\r
-  ed->magic = NNS_EDGE_MAGIC_DEAD;\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ed->magic = NNS_EDGE_MAGIC;\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Validate edge-data.\r
- */\r
-TEST(edgeData, validate)\r
-{\r
-  nns_edge_data_h data_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_is_valid (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Validate edge-data - invalid param.\r
- */\r
-TEST(edgeData, validateInvalidParam01_n)\r
-{\r
-  int ret;\r
-\r
-  ret = nns_edge_data_is_valid (NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Validate edge-data - invalid param.\r
- */\r
-TEST(edgeData, validateInvalidParam02_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  nns_edge_data_s *ed;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ed = (nns_edge_data_s *) data_h;\r
-  ed->magic = NNS_EDGE_MAGIC_DEAD;\r
-\r
-  ret = nns_edge_data_is_valid (data_h);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ed->magic = NNS_EDGE_MAGIC;\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Copy edge-data.\r
- */\r
-TEST(edgeData, copy)\r
-{\r
-  nns_edge_data_h src_h, desc_h;\r
-  void *data, *result;\r
-  size_t data_len, result_len;\r
-  char *result_value;\r
-  unsigned int i, result_count;\r
-  int ret;\r
-\r
-  data_len = 10U * sizeof (unsigned int);\r
-  data = malloc (data_len);\r
-  ASSERT_TRUE (data != NULL);\r
-\r
-  for (i = 0; i < 10U; i++)\r
-    ((unsigned int *) data)[i] = i;\r
-\r
-  ret = nns_edge_data_create (&src_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_set_info (src_h, "temp-key1", "temp-data-val1");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_data_set_info (src_h, "temp-key2", "temp-data-val2");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_add (src_h, data, data_len, free);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_copy (src_h, &desc_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (src_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  /* Compare data and info */\r
-  ret = nns_edge_data_get_count (desc_h, &result_count);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_EQ (result_count, 1U);\r
-\r
-  ret = nns_edge_data_get (desc_h, 0, &result, &result_len);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  for (i = 0; i < 10U; i++)\r
-    EXPECT_EQ (((unsigned int *) result)[i], i);\r
-\r
-  ret = nns_edge_data_get_info (desc_h, "temp-key1", &result_value);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_STREQ (result_value, "temp-data-val1");\r
-  free (result_value);\r
-\r
-  ret = nns_edge_data_get_info (desc_h, "temp-key2", &result_value);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_STREQ (result_value, "temp-data-val2");\r
-  free (result_value);\r
-\r
-  ret = nns_edge_data_destroy (desc_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Copy edge-data - invalid param.\r
- */\r
-TEST(edgeData, copyInvalidParam01_n)\r
-{\r
-  nns_edge_data_h desc_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_copy (NULL, &desc_h);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Copy edge-data - invalid param.\r
- */\r
-TEST(edgeData, copyInvalidParam02_n)\r
-{\r
-  nns_edge_data_h src_h, desc_h;\r
-  nns_edge_data_s *ed;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_create (&src_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ed = (nns_edge_data_s *) src_h;\r
-  ed->magic = NNS_EDGE_MAGIC_DEAD;\r
-\r
-  ret = nns_edge_data_copy (src_h, &desc_h);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ed->magic = NNS_EDGE_MAGIC;\r
-\r
-  ret = nns_edge_data_destroy (src_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Copy edge-data - invalid param.\r
- */\r
-TEST(edgeData, copyInvalidParam03_n)\r
-{\r
-  nns_edge_data_h src_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_create (&src_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_copy (src_h, NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (src_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Add edge-data - max data limit.\r
- */\r
-TEST(edgeData, addMaxData_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  void *data;\r
-  size_t data_len;\r
-  int i, ret;\r
-\r
-  data_len = 10U * sizeof (int);\r
-  data = malloc (data_len);\r
-  ASSERT_TRUE (data != NULL);\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  for (i = 0; i < NNS_EDGE_DATA_LIMIT; i++) {\r
-    ret = nns_edge_data_add (data_h, data, data_len, NULL);\r
-    EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  }\r
-\r
-  ret = nns_edge_data_add (data_h, data, data_len, NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  free (data);\r
-}\r
-\r
-/**\r
- * @brief Add edge-data - invalid param.\r
- */\r
-TEST(edgeData, addInvalidParam01_n)\r
-{\r
-  void *data;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  data_len = 10U * sizeof (int);\r
-  data = malloc (data_len);\r
-  ASSERT_TRUE (data != NULL);\r
-\r
-  ret = nns_edge_data_add (NULL, data, data_len, NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  free (data);\r
-}\r
-\r
-/**\r
- * @brief Add edge-data - invalid param.\r
- */\r
-TEST(edgeData, addInvalidParam02_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  nns_edge_data_s *ed;\r
-  void *data;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  data_len = 10U * sizeof (int);\r
-  data = malloc (data_len);\r
-  ASSERT_TRUE (data != NULL);\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ed = (nns_edge_data_s *) data_h;\r
-  ed->magic = NNS_EDGE_MAGIC_DEAD;\r
-\r
-  ret = nns_edge_data_add (data_h, data, data_len, NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ed->magic = NNS_EDGE_MAGIC;\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  free (data);\r
-}\r
-\r
-/**\r
- * @brief Add edge-data - invalid param.\r
- */\r
-TEST(edgeData, addInvalidParam03_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  void *data;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  data_len = 10U * sizeof (int);\r
-  data = malloc (data_len);\r
-  ASSERT_TRUE (data != NULL);\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_add (data_h, NULL, data_len, NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  free (data);\r
-}\r
-\r
-/**\r
- * @brief Add edge-data - invalid param.\r
- */\r
-TEST(edgeData, addInvalidParam04_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  void *data;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  data_len = 10U * sizeof (int);\r
-  data = malloc (data_len);\r
-  ASSERT_TRUE (data != NULL);\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_add (data_h, data, 0, NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  free (data);\r
-}\r
-\r
-/**\r
- * @brief Get edge-data.\r
- */\r
-TEST(edgeData, get)\r
-{\r
-  nns_edge_data_h data_h;\r
-  void *data, *result;\r
-  size_t data_len, result_len;\r
-  unsigned int count;\r
-  int ret;\r
-\r
-  data_len = 10U * sizeof (int);\r
-  data = malloc (data_len);\r
-  ASSERT_TRUE (data != NULL);\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_add (data_h, data, data_len, NULL);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_get_count (data_h, &count);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_EQ (count, 1U);\r
-\r
-  ret = nns_edge_data_get (data_h, 0, &result, &result_len);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_EQ (result, data);\r
-  EXPECT_EQ (result_len, data_len);\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  free (data);\r
-}\r
-\r
-/**\r
- * @brief Get edge-data - invalid param.\r
- */\r
-TEST(edgeData, getInvalidParam01_n)\r
-{\r
-  void *data;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_get (NULL, 0, &data, &data_len);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Get edge-data - invalid param.\r
- */\r
-TEST(edgeData, getInvalidParam02_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  nns_edge_data_s *ed;\r
-  void *data, *result;\r
-  size_t data_len, result_len;\r
-  int ret;\r
-\r
-  data_len = 10U * sizeof (int);\r
-  data = malloc (data_len);\r
-  ASSERT_TRUE (data != NULL);\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_add (data_h, data, data_len, NULL);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ed = (nns_edge_data_s *) data_h;\r
-  ed->magic = NNS_EDGE_MAGIC_DEAD;\r
-\r
-  ret = nns_edge_data_get (data_h, 0, &result, &result_len);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ed->magic = NNS_EDGE_MAGIC;\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  free (data);\r
-}\r
-\r
-/**\r
- * @brief Get edge-data - invalid param.\r
- */\r
-TEST(edgeData, getInvalidParam03_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  void *data, *result;\r
-  size_t data_len, result_len;\r
-  int ret;\r
-\r
-  data_len = 10U * sizeof (int);\r
-  data = malloc (data_len);\r
-  ASSERT_TRUE (data != NULL);\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_add (data_h, data, data_len, NULL);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  /* Invalid index */\r
-  ret = nns_edge_data_get (data_h, 1, &result, &result_len);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  free (data);\r
-}\r
-\r
-/**\r
- * @brief Get edge-data - invalid param.\r
- */\r
-TEST(edgeData, getInvalidParam04_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  void *data;\r
-  size_t data_len, result_len;\r
-  int ret;\r
-\r
-  data_len = 10U * sizeof (int);\r
-  data = malloc (data_len);\r
-  ASSERT_TRUE (data != NULL);\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_add (data_h, data, data_len, NULL);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_get (data_h, 0, NULL, &result_len);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  free (data);\r
-}\r
-\r
-/**\r
- * @brief Get edge-data - invalid param.\r
- */\r
-TEST(edgeData, getInvalidParam05_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  void *data, *result;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  data_len = 10U * sizeof (int);\r
-  data = malloc (data_len);\r
-  ASSERT_TRUE (data != NULL);\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_add (data_h, data, data_len, NULL);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_get (data_h, 0, &result, NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  free (data);\r
-}\r
-\r
-/**\r
- * @brief Get count of edge-data - invalid param.\r
- */\r
-TEST(edgeData, getCountInvalidParam01_n)\r
-{\r
-  unsigned int count;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_get_count (NULL, &count);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Get count of edge-data - invalid param.\r
- */\r
-TEST(edgeData, getCountInvalidParam02_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  nns_edge_data_s *ed;\r
-  void *data;\r
-  size_t data_len;\r
-  unsigned int count;\r
-  int ret;\r
-\r
-  data_len = 10U * sizeof (int);\r
-  data = malloc (data_len);\r
-  ASSERT_TRUE (data != NULL);\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_add (data_h, data, data_len, NULL);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ed = (nns_edge_data_s *) data_h;\r
-  ed->magic = NNS_EDGE_MAGIC_DEAD;\r
-\r
-  ret = nns_edge_data_get_count (data_h, &count);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ed->magic = NNS_EDGE_MAGIC;\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  free (data);\r
-}\r
-\r
-/**\r
- * @brief Get count of edge-data - invalid param.\r
- */\r
-TEST(edgeData, getCountInvalidParam03_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  void *data;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  data_len = 10U * sizeof (int);\r
-  data = malloc (data_len);\r
-  ASSERT_TRUE (data != NULL);\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_add (data_h, data, data_len, NULL);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_get_count (data_h, NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  free (data);\r
-}\r
-\r
-/**\r
- * @brief Set info of edge-data - invalid param.\r
- */\r
-TEST(edgeData, setInfoInvalidParam01_n)\r
-{\r
-  int ret;\r
-\r
-  ret = nns_edge_data_set_info (NULL, "temp-key", "temp-value");\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Set info of edge-data - invalid param.\r
- */\r
-TEST(edgeData, setInfoInvalidParam02_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  nns_edge_data_s *ed;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ed = (nns_edge_data_s *) data_h;\r
-  ed->magic = NNS_EDGE_MAGIC_DEAD;\r
-\r
-  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ed->magic = NNS_EDGE_MAGIC;\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Set info of edge-data - invalid param.\r
- */\r
-TEST(edgeData, setInfoInvalidParam03_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_set_info (data_h, NULL, "temp-value");\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Set info of edge-data - invalid param.\r
- */\r
-TEST(edgeData, setInfoInvalidParam04_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_set_info (data_h, "temp-key", NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Get info of edge-data - invalid param.\r
- */\r
-TEST(edgeData, getInfoInvalidParam01_n)\r
-{\r
-  char *value = NULL;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_get_info (NULL, "temp-key", &value);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Get info of edge-data - invalid param.\r
- */\r
-TEST(edgeData, getInfoInvalidParam02_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  nns_edge_data_s *ed;\r
-  char *value = NULL;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ed = (nns_edge_data_s *) data_h;\r
-  ed->magic = NNS_EDGE_MAGIC_DEAD;\r
-\r
-  ret = nns_edge_data_get_info (data_h, "temp-key", &value);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ed->magic = NNS_EDGE_MAGIC;\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Get info of edge-data - invalid param.\r
- */\r
-TEST(edgeData, getInfoInvalidParam03_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  char *value = NULL;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_get_info (data_h, NULL, &value);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Get info of edge-data - invalid param.\r
- */\r
-TEST(edgeData, getInfoInvalidParam04_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_get_info (data_h, "temp-key", NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Get info of edge-data - invalid param.\r
- */\r
-TEST(edgeData, getInfoInvalidParam05_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_get_info (data_h, "", NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Serialize meta in edge-data - invalid param.\r
- */\r
-TEST(edgeData, serializeInvalidParam01_n)\r
-{\r
-  void *data;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_serialize_meta (NULL, &data, &data_len);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Serialize meta in edge-data - invalid param.\r
- */\r
-TEST(edgeData, serializeInvalidParam02_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  nns_edge_data_s *ed;\r
-  void *data;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ed = (nns_edge_data_s *) data_h;\r
-  ed->magic = NNS_EDGE_MAGIC_DEAD;\r
-\r
-  ret = nns_edge_data_serialize_meta (data_h, &data, &data_len);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ed->magic = NNS_EDGE_MAGIC;\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Serialize meta in edge-data - invalid param.\r
- */\r
-TEST(edgeData, serializeInvalidParam03_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_serialize_meta (data_h, NULL, &data_len);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Serialize meta in edge-data - invalid param.\r
- */\r
-TEST(edgeData, serializeInvalidParam04_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  void *data;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_serialize_meta (data_h, &data, NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Derialize meta to edge-data - invalid param.\r
- */\r
-TEST(edgeData, deserializeInvalidParam01_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  void *data;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_serialize_meta (data_h, &data, &data_len);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_deserialize_meta (NULL, data, data_len);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  nns_edge_free (data);\r
-}\r
-\r
-/**\r
- * @brief Derialize meta to edge-data - invalid param.\r
- */\r
-TEST(edgeData, deserializeInvalidParam02_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  nns_edge_data_s *ed;\r
-  void *data;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_serialize_meta (data_h, &data, &data_len);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ed = (nns_edge_data_s *) data_h;\r
-  ed->magic = NNS_EDGE_MAGIC_DEAD;\r
-\r
-  ret = nns_edge_data_deserialize_meta (data_h, data, data_len);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ed->magic = NNS_EDGE_MAGIC;\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  nns_edge_free (data);\r
-}\r
-\r
-/**\r
- * @brief Derialize meta to edge-data - invalid param.\r
- */\r
-TEST(edgeData, deserializeInvalidParam03_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  void *data;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_serialize_meta (data_h, &data, &data_len);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_deserialize_meta (data_h, NULL, data_len);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  nns_edge_free (data);\r
-}\r
-\r
-/**\r
- * @brief Derialize meta to edge-data - invalid param.\r
- */\r
-TEST(edgeData, deserializeInvalidParam04_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  void *data;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_serialize_meta (data_h, &data, &data_len);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_deserialize_meta (data_h, data, 0);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  nns_edge_free (data);\r
-}\r
-\r
-\r
-/**\r
- * @brief Serialzie and deserialize the edge-data.\r
- */\r
-TEST(edgeDataSerialize, normal)\r
-{\r
-  nns_edge_data_h src_h, dest_h;\r
-  void *data1, *data2, *result, *serialized_data;\r
-  size_t data_len, result_len, serialized_len;\r
-  char *result_value;\r
-  unsigned int i, result_count;\r
-  int ret;\r
-\r
-  data_len = 10U * sizeof (unsigned int);\r
-  data1 = malloc (data_len);\r
-  ASSERT_TRUE (data1 != NULL);\r
-\r
-  for (i = 0; i < 10U; i++)\r
-    ((unsigned int *) data1)[i] = i;\r
-\r
-  data2 = malloc (data_len * 2);\r
-  ASSERT_TRUE (data2 != NULL);\r
-\r
-  for (i = 0; i < 20U; i++)\r
-    ((unsigned int *) data2)[i] = 20 - i;\r
-\r
-  ret = nns_edge_data_create (&src_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_set_info (src_h, "temp-key1", "temp-data-val1");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_data_set_info (src_h, "temp-key2", "temp-data-val2");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_add (src_h, data1, data_len, free);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_data_add (src_h, data2, data_len * 2, free);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_serialize (src_h, &serialized_data, &serialized_len);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (src_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_create (&dest_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_deserialize (dest_h, serialized_data);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  /* Compare data and info */\r
-  ret = nns_edge_data_get_count (dest_h, &result_count);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_EQ (result_count, 2U);\r
-\r
-  ret = nns_edge_data_get (dest_h, 0, &result, &result_len);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  for (i = 0; i < 10U; i++)\r
-    EXPECT_EQ (((unsigned int *) result)[i], i);\r
-\r
-  ret = nns_edge_data_get (dest_h, 1, &result, &result_len);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  for (i = 0; i < 20U; i++)\r
-    EXPECT_EQ (((unsigned int *) result)[i], 20 - i);\r
-\r
-  ret = nns_edge_data_get_info (dest_h, "temp-key1", &result_value);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_STREQ (result_value, "temp-data-val1");\r
-  free (result_value);\r
-\r
-  ret = nns_edge_data_get_info (dest_h, "temp-key2", &result_value);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_STREQ (result_value, "temp-data-val2");\r
-  free (result_value);\r
-\r
-  ret = nns_edge_data_destroy (dest_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-\r
-/**\r
- * @brief Serialize edge-data - invalid param.\r
- */\r
-TEST(edgeDataSerialize, invalidParam01_n)\r
-{\r
-  void *data;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_serialize (NULL, &data, &data_len);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Serialize edge-data - invalid param.\r
- */\r
-TEST(edgeData, invalidParam02_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  nns_edge_data_s *ed;\r
-  void *data;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ed = (nns_edge_data_s *) data_h;\r
-  ed->magic = NNS_EDGE_MAGIC_DEAD;\r
-\r
-  ret = nns_edge_data_serialize (data_h, &data, &data_len);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ed->magic = NNS_EDGE_MAGIC;\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Serialize edge-data - invalid param.\r
- */\r
-TEST(edgeDataSerialize, invalidParam03_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_serialize (data_h, NULL, &data_len);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Serialize edge-data - invalid param.\r
- */\r
-TEST(edgeDataSerialize, invalidParam04_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  void *data;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_serialize_meta (data_h, &data, NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Derialize edge-data - invalid param.\r
- */\r
-TEST(edgeDataDeserialize, invalidParam01_n)\r
-{\r
-  void *data = NULL;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_deserialize (NULL, data);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  nns_edge_free (data);\r
-}\r
-\r
-/**\r
- * @brief Derialize edge-data - invalid param.\r
- */\r
-TEST(edgeDataDeserialize, invalidParam02_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  nns_edge_data_s *ed;\r
-  void *data;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_serialize_meta (data_h, &data, &data_len);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ed = (nns_edge_data_s *) data_h;\r
-  ed->magic = NNS_EDGE_MAGIC_DEAD;\r
-\r
-  ret = nns_edge_data_deserialize (data_h, data);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ed->magic = NNS_EDGE_MAGIC;\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  nns_edge_free (data);\r
-}\r
-\r
-/**\r
- * @brief Derialize edge-data - invalid param.\r
- */\r
-TEST(edgeDataDeserialize, invalidParam03_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_deserialize (data_h, NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Create edge event - invalid param.\r
- */\r
-TEST(edgeEvent, createInvalidParam01_n)\r
-{\r
-  nns_edge_event_h event_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_event_create (NNS_EDGE_EVENT_UNKNOWN, &event_h);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Create edge event - invalid param.\r
- */\r
-TEST(edgeEvent, createInvalidParam02_n)\r
-{\r
-  int ret;\r
-\r
-  ret = nns_edge_event_create (NNS_EDGE_EVENT_CUSTOM, NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Destroy edge event - invalid param.\r
- */\r
-TEST(edgeEvent, destroyInvalidParam01_n)\r
-{\r
-  int ret;\r
-\r
-  ret = nns_edge_event_destroy (NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Destroy edge event - invalid param.\r
- */\r
-TEST(edgeEvent, destroyInvalidParam02_n)\r
-{\r
-  nns_edge_event_h event_h;\r
-  nns_edge_event_s *ee;\r
-  void *data;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  data_len = 10U * sizeof (int);\r
-  data = malloc (data_len);\r
-  ASSERT_TRUE (data != NULL);\r
-\r
-  ret = nns_edge_event_create (NNS_EDGE_EVENT_CUSTOM, &event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_event_set_data (event_h, data, data_len, free);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ee = (nns_edge_event_s *) event_h;\r
-  ee->magic = NNS_EDGE_MAGIC_DEAD;\r
-\r
-  ret = nns_edge_event_destroy (event_h);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ee->magic = NNS_EDGE_MAGIC;\r
-\r
-  ret = nns_edge_event_destroy (event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Set edge event data - invalid param.\r
- */\r
-TEST(edgeEvent, setDataInvalidParam01_n)\r
-{\r
-  void *data;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  data_len = 10U * sizeof (int);\r
-  data = malloc (data_len);\r
-  ASSERT_TRUE (data != NULL);\r
-\r
-  ret = nns_edge_event_set_data (NULL, data, data_len, NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  free (data);\r
-}\r
-\r
-/**\r
- * @brief Set edge event data - invalid param.\r
- */\r
-TEST(edgeEvent, setDataInvalidParam02_n)\r
-{\r
-  nns_edge_event_h event_h;\r
-  void *data;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  data_len = 10U * sizeof (int);\r
-  data = malloc (data_len);\r
-  ASSERT_TRUE (data != NULL);\r
-\r
-  ret = nns_edge_event_create (NNS_EDGE_EVENT_CUSTOM, &event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_event_set_data (event_h, NULL, data_len, NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_event_destroy (event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  free (data);\r
-}\r
-\r
-/**\r
- * @brief Set edge event data - invalid param.\r
- */\r
-TEST(edgeEvent, setDataInvalidParam03_n)\r
-{\r
-  nns_edge_event_h event_h;\r
-  void *data;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  data_len = 10U * sizeof (int);\r
-  data = malloc (data_len);\r
-  ASSERT_TRUE (data != NULL);\r
-\r
-  ret = nns_edge_event_create (NNS_EDGE_EVENT_CUSTOM, &event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_event_set_data (event_h, data, 0, NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_event_destroy (event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  free (data);\r
-}\r
-\r
-/**\r
- * @brief Set edge event data - invalid param.\r
- */\r
-TEST(edgeEvent, setDataInvalidParam04_n)\r
-{\r
-  nns_edge_event_h event_h;\r
-  nns_edge_event_s *ee;\r
-  void *data;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  data_len = 10U * sizeof (int);\r
-  data = malloc (data_len);\r
-  ASSERT_TRUE (data != NULL);\r
-\r
-  ret = nns_edge_event_create (NNS_EDGE_EVENT_CUSTOM, &event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ee = (nns_edge_event_s *) event_h;\r
-  ee->magic = NNS_EDGE_MAGIC_DEAD;\r
-\r
-  ret = nns_edge_event_set_data (event_h, data, data_len, NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ee->magic = NNS_EDGE_MAGIC;\r
-\r
-  ret = nns_edge_event_destroy (event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  free (data);\r
-}\r
-\r
-/**\r
- * @brief Get edge event type.\r
- */\r
-TEST(edgeEvent, getType)\r
-{\r
-  nns_edge_event_h event_h;\r
-  nns_edge_event_e event = NNS_EDGE_EVENT_UNKNOWN;\r
-  int ret;\r
-\r
-  ret = nns_edge_event_create (NNS_EDGE_EVENT_CUSTOM, &event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_event_get_type (event_h, &event);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_EQ (event, NNS_EDGE_EVENT_CUSTOM);\r
-\r
-  ret = nns_edge_event_destroy (event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Get edge event type - invalid param.\r
- */\r
-TEST(edgeEvent, getTypeInvalidParam01_n)\r
-{\r
-  nns_edge_event_e event;\r
-  int ret;\r
-\r
-  ret = nns_edge_event_get_type (NULL, &event);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Get edge event type - invalid param.\r
- */\r
-TEST(edgeEvent, getTypeInvalidParam02_n)\r
-{\r
-  nns_edge_event_h event_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_event_create (NNS_EDGE_EVENT_CUSTOM, &event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_event_get_type (event_h, NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_event_destroy (event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Get edge event type - invalid param.\r
- */\r
-TEST(edgeEvent, getTypeInvalidParam03_n)\r
-{\r
-  nns_edge_event_h event_h;\r
-  nns_edge_event_e event;\r
-  nns_edge_event_s *ee;\r
-  int ret;\r
-\r
-  ret = nns_edge_event_create (NNS_EDGE_EVENT_CUSTOM, &event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ee = (nns_edge_event_s *) event_h;\r
-  ee->magic = NNS_EDGE_MAGIC_DEAD;\r
-\r
-  ret = nns_edge_event_get_type (event_h, &event);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ee->magic = NNS_EDGE_MAGIC;\r
-\r
-  ret = nns_edge_event_destroy (event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Parse new data of edge event.\r
- */\r
-TEST(edgeEvent, parseNewData)\r
-{\r
-  nns_edge_event_h event_h;\r
-  nns_edge_data_h data_h, result_h;\r
-  void *data, *result;\r
-  size_t data_len, result_len;\r
-  char *result_value;\r
-  unsigned int i, count;\r
-  int ret;\r
-\r
-  data_len = 10U * sizeof (unsigned int);\r
-  data = malloc (data_len);\r
-  ASSERT_TRUE (data != NULL);\r
-\r
-  for (i = 0; i < 10U; i++)\r
-    ((unsigned int *) data)[i] = i;\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_add (data_h, data, data_len, free);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_set_info (data_h, "temp-key1", "temp-data-val1");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_data_set_info (data_h, "temp-key2", "temp-data-val2");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_event_create (NNS_EDGE_EVENT_NEW_DATA_RECEIVED, &event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_event_set_data (event_h, data_h, sizeof (nns_edge_data_h), NULL);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_event_parse_new_data (event_h, &result_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  /* Compare data and info */\r
-  ret = nns_edge_data_get_count (result_h, &count);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_EQ (count, 1U);\r
-\r
-  ret = nns_edge_data_get (result_h, 0, &result, &result_len);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  for (i = 0; i < 10U; i++)\r
-    EXPECT_EQ (((unsigned int *) result)[i], i);\r
-\r
-  ret = nns_edge_data_get_info (result_h, "temp-key1", &result_value);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_STREQ (result_value, "temp-data-val1");\r
-  free (result_value);\r
-\r
-  ret = nns_edge_data_get_info (result_h, "temp-key2", &result_value);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_STREQ (result_value, "temp-data-val2");\r
-  free (result_value);\r
-\r
-  ret = nns_edge_event_destroy (event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_destroy (result_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Parse new data of edge event - invalid param.\r
- */\r
-TEST(edgeEvent, parseNewDataInvalidParam01_n)\r
-{\r
-  nns_edge_data_h data_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_event_parse_new_data (NULL, &data_h);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Parse new data of edge event - invalid param.\r
- */\r
-TEST(edgeEvent, parseNewDataInvalidParam02_n)\r
-{\r
-  nns_edge_event_h event_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_event_create (NNS_EDGE_EVENT_NEW_DATA_RECEIVED, &event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_event_parse_new_data (event_h, NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_event_destroy (event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Parse new data of edge event - invalid param.\r
- */\r
-TEST(edgeEvent, parseNewDataInvalidParam03_n)\r
-{\r
-  nns_edge_event_h event_h;\r
-  nns_edge_data_h data_h;\r
-  nns_edge_event_s *ee;\r
-  int ret;\r
-\r
-  ret = nns_edge_event_create (NNS_EDGE_EVENT_NEW_DATA_RECEIVED, &event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ee = (nns_edge_event_s *) event_h;\r
-  ee->magic = NNS_EDGE_MAGIC_DEAD;\r
-\r
-  ret = nns_edge_event_parse_new_data (event_h, &data_h);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ee->magic = NNS_EDGE_MAGIC;\r
-\r
-  ret = nns_edge_event_destroy (event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Parse new data of edge event - invalid param.\r
- */\r
-TEST(edgeEvent, parseNewDataInvalidParam04_n)\r
-{\r
-  nns_edge_event_h event_h;\r
-  nns_edge_data_h data_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_event_create (NNS_EDGE_EVENT_CUSTOM, &event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_event_parse_new_data (event_h, &data_h);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_event_destroy (event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Parse capability of edge event.\r
- */\r
-TEST(edgeEvent, parseCapability)\r
-{\r
-  const char capability[] = "temp-capability";\r
-  nns_edge_event_h event_h;\r
-  char *caps = NULL;\r
-  int ret;\r
-\r
-  ret = nns_edge_event_create (NNS_EDGE_EVENT_CAPABILITY, &event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_event_set_data (event_h, (void *) capability, strlen (capability), NULL);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_event_parse_capability (event_h, &caps);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_STREQ (caps, capability);\r
-  free (caps);\r
-\r
-  ret = nns_edge_event_destroy (event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Parse capability of edge event - invalid param.\r
- */\r
-TEST(edgeEvent, parseCapabilityInvalidParam01_n)\r
-{\r
-  char *caps = NULL;\r
-  int ret;\r
-\r
-  ret = nns_edge_event_parse_capability (NULL, &caps);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Parse capability of edge event - invalid param.\r
- */\r
-TEST(edgeEvent, parseCapabilityInvalidParam02_n)\r
-{\r
-  nns_edge_event_h event_h;\r
-  int ret;\r
-\r
-  ret = nns_edge_event_create (NNS_EDGE_EVENT_CAPABILITY, &event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_event_parse_capability (event_h, NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_event_destroy (event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Parse capability of edge event - invalid param.\r
- */\r
-TEST(edgeEvent, parseCapabilityInvalidParam03_n)\r
-{\r
-  nns_edge_event_h event_h;\r
-  nns_edge_event_s *ee;\r
-  char *caps = NULL;\r
-  int ret;\r
-\r
-  ret = nns_edge_event_create (NNS_EDGE_EVENT_CAPABILITY, &event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ee = (nns_edge_event_s *) event_h;\r
-  ee->magic = NNS_EDGE_MAGIC_DEAD;\r
-\r
-  ret = nns_edge_event_parse_capability (event_h, &caps);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ee->magic = NNS_EDGE_MAGIC;\r
-\r
-  ret = nns_edge_event_destroy (event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Parse capability of edge event - invalid param.\r
- */\r
-TEST(edgeEvent, parseCapabilityInvalidParam04_n)\r
-{\r
-  nns_edge_event_h event_h;\r
-  char *caps = NULL;\r
-  int ret;\r
-\r
-  ret = nns_edge_event_create (NNS_EDGE_EVENT_CUSTOM, &event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_event_parse_capability (event_h, &caps);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_event_destroy (event_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Initialize edge metadata - invalid param.\r
- */\r
-TEST(edgeMeta, initInvalidParam01_n)\r
-{\r
-  int ret;\r
-\r
-  ret = nns_edge_metadata_init (NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Release resources of edge metadata - invalid param.\r
- */\r
-TEST(edgeMeta, freeInvalidParam01_n)\r
-{\r
-  int ret;\r
-\r
-  ret = nns_edge_metadata_free (NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Set edge metadata - invalid param.\r
- */\r
-TEST(edgeMeta, setInvalidParam01_n)\r
-{\r
-  int ret;\r
-\r
-  ret = nns_edge_metadata_set (NULL, "temp-key", "temp-value");\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Set edge metadata - invalid param.\r
- */\r
-TEST(edgeMeta, setInvalidParam02_n)\r
-{\r
-  nns_edge_metadata_s meta;\r
-  int ret;\r
-\r
-  ret = nns_edge_metadata_init (&meta);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_set (&meta, NULL, "temp-value");\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_free (&meta);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Set edge metadata - invalid param.\r
- */\r
-TEST(edgeMeta, setInvalidParam03_n)\r
-{\r
-  nns_edge_metadata_s meta;\r
-  int ret;\r
-\r
-  ret = nns_edge_metadata_init (&meta);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_set (&meta, "", "temp-value");\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_free (&meta);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Set edge metadata - invalid param.\r
- */\r
-TEST(edgeMeta, setInvalidParam04_n)\r
-{\r
-  nns_edge_metadata_s meta;\r
-  int ret;\r
-\r
-  ret = nns_edge_metadata_init (&meta);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_set (&meta, "temp-key", NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_free (&meta);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Set edge metadata - invalid param.\r
- */\r
-TEST(edgeMeta, setInvalidParam05_n)\r
-{\r
-  nns_edge_metadata_s meta;\r
-  int ret;\r
-\r
-  ret = nns_edge_metadata_init (&meta);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_set (&meta, "temp-key", "");\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_free (&meta);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Get edge metadata - invalid param.\r
- */\r
-TEST(edgeMeta, getInvalidParam01_n)\r
-{\r
-  char *value = NULL;\r
-  int ret;\r
-\r
-  ret = nns_edge_metadata_get (NULL, "temp-key", &value);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Get edge metadata - invalid param.\r
- */\r
-TEST(edgeMeta, getInvalidParam02_n)\r
-{\r
-  nns_edge_metadata_s meta;\r
-  char *value = NULL;\r
-  int ret;\r
-\r
-  ret = nns_edge_metadata_init (&meta);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_get (&meta, NULL, &value);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_free (&meta);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Get edge metadata - invalid param.\r
- */\r
-TEST(edgeMeta, getInvalidParam03_n)\r
-{\r
-  nns_edge_metadata_s meta;\r
-  char *value = NULL;\r
-  int ret;\r
-\r
-  ret = nns_edge_metadata_init (&meta);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_get (&meta, "", &value);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_free (&meta);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Get edge metadata - invalid param.\r
- */\r
-TEST(edgeMeta, getInvalidParam04_n)\r
-{\r
-  nns_edge_metadata_s meta;\r
-  int ret;\r
-\r
-  ret = nns_edge_metadata_init (&meta);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_get (&meta, "temp-key", NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_free (&meta);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Copy edge metadata.\r
- */\r
-TEST(edgeMeta, copy)\r
-{\r
-  nns_edge_metadata_s src, desc;\r
-  char *value = NULL;\r
-  int ret;\r
-\r
-  ret = nns_edge_metadata_init (&src);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_metadata_init (&desc);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_set (&src, "temp-key1", "temp-value1");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_metadata_set (&src, "temp-key2", "temp-value2");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  /* Replace old value */\r
-  ret = nns_edge_metadata_set (&src, "temp-key2", "temp-value2-replaced");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_copy (&desc, &src);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_get (&desc, "temp-key1", &value);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_STREQ (value, "temp-value1");\r
-  nns_edge_free (value);\r
-\r
-  ret = nns_edge_metadata_get (&desc, "temp-key2", &value);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_STREQ (value, "temp-value2-replaced");\r
-  nns_edge_free (value);\r
-\r
-  ret = nns_edge_metadata_free (&src);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_metadata_free (&desc);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Copy edge metadata - invalid param.\r
- */\r
-TEST(edgeMeta, copyInvalidParam01_n)\r
-{\r
-  nns_edge_metadata_s src;\r
-  int ret;\r
-\r
-  ret = nns_edge_metadata_init (&src);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_copy (NULL, &src);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_free (&src);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Copy edge metadata - invalid param.\r
- */\r
-TEST(edgeMeta, copyInvalidParam02_n)\r
-{\r
-  nns_edge_metadata_s desc;\r
-  int ret;\r
-\r
-  ret = nns_edge_metadata_init (&desc);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_copy (&desc, NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_free (&desc);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Serialize edge metadata.\r
- */\r
-TEST(edgeMeta, serialize)\r
-{\r
-  nns_edge_metadata_s src, desc;\r
-  char *value;\r
-  void *data;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  ret = nns_edge_metadata_init (&src);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_metadata_init (&desc);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_set (&src, "temp-key1", "temp-value1");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_metadata_set (&src, "temp-key2", "temp-value2");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_metadata_set (&src, "temp-key3", "temp-value3");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  EXPECT_EQ (src.list_len, 3U);\r
-  EXPECT_EQ (desc.list_len, 0U);\r
-\r
-  ret = nns_edge_metadata_serialize (&src, &data, &data_len);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_deserialize (&desc, data, data_len);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_EQ (desc.list_len, 3U);\r
-\r
-  ret = nns_edge_metadata_get (&desc, "temp-key1", &value);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_STREQ (value, "temp-value1");\r
-  nns_edge_free (value);\r
-\r
-  ret = nns_edge_metadata_get (&desc, "temp-key2", &value);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_STREQ (value, "temp-value2");\r
-  nns_edge_free (value);\r
-\r
-  ret = nns_edge_metadata_get (&desc, "temp-key3", &value);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  EXPECT_STREQ (value, "temp-value3");\r
-  nns_edge_free (value);\r
-\r
-  ret = nns_edge_metadata_free (&src);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_metadata_free (&desc);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  free (data);\r
-}\r
-\r
-/**\r
- * @brief Serialize edge metadata - invalid param.\r
- */\r
-TEST(edgeMeta, serializeInvalidParam01_n)\r
-{\r
-  void *data;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  ret = nns_edge_metadata_serialize (NULL, &data, &data_len);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Serialize edge metadata - invalid param.\r
- */\r
-TEST(edgeMeta, serializeInvalidParam02_n)\r
-{\r
-  nns_edge_metadata_s meta;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  ret = nns_edge_metadata_init (&meta);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_serialize (&meta, NULL, &data_len);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_free (&meta);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Serialize edge metadata - invalid param.\r
- */\r
-TEST(edgeMeta, serializeInvalidParam03_n)\r
-{\r
-  nns_edge_metadata_s meta;\r
-  void *data;\r
-  int ret;\r
-\r
-  ret = nns_edge_metadata_init (&meta);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_serialize (&meta, &data, NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_free (&meta);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Deserialize edge metadata - invalid param.\r
- */\r
-TEST(edgeMeta, deserializeInvalidParam01_n)\r
-{\r
-  void *data;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  data_len = 10U + sizeof (unsigned int);\r
-  data = malloc (data_len);\r
-  ASSERT_TRUE (data != NULL);\r
-  ((unsigned int *) data)[0] = 0U;\r
-\r
-  ret = nns_edge_metadata_deserialize (NULL, data, data_len);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  free (data);\r
-}\r
-\r
-/**\r
- * @brief Deserialize edge metadata - invalid param.\r
- */\r
-TEST(edgeMeta, deserializeInvalidParam02_n)\r
-{\r
-  nns_edge_metadata_s meta;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  data_len = 10U + sizeof (unsigned int);\r
-\r
-  ret = nns_edge_metadata_init (&meta);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_deserialize (&meta, NULL, data_len);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_free (&meta);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Deserialize edge metadata - invalid param.\r
- */\r
-TEST(edgeMeta, deserializeInvalidParam03_n)\r
-{\r
-  nns_edge_metadata_s meta;\r
-  void *data;\r
-  size_t data_len;\r
-  int ret;\r
-\r
-  data_len = 10U + sizeof (unsigned int);\r
-  data = malloc (data_len);\r
-  ASSERT_TRUE (data != NULL);\r
-  ((unsigned int *) data)[0] = 0U;\r
-\r
-  ret = nns_edge_metadata_init (&meta);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_deserialize (&meta, data, 0);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_metadata_free (&meta);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  free (data);\r
-}\r
-\r
-/**\r
- * @brief Thread to push new data into queue.\r
- */\r
-static void *\r
-_test_thread_edge_queue_push (void *thread_data)\r
-{\r
-  nns_edge_queue_h queue_h = thread_data;\r
-  unsigned int i, j;\r
-  void *data;\r
-\r
-  for (i = 0; i < 6U; i++) {\r
-    usleep (50000);\r
-\r
-    data = malloc (5 * sizeof (unsigned int));\r
-    if (data) {\r
-      for (j = 0; j < 5U; j++)\r
-        ((unsigned int *) data)[j] = i * 10U + j;\r
-    }\r
-\r
-    EXPECT_TRUE (nns_edge_queue_push (queue_h, data, nns_edge_free));\r
-  }\r
-\r
-  return NULL;\r
-}\r
-\r
-/**\r
- * @brief Push and pop data.\r
- */\r
-TEST(edgeQueue, pushData)\r
-{\r
-  nns_edge_queue_h queue_h;\r
-  void *data1, *data2, *data3, *result;\r
-  unsigned int i, len;\r
-\r
-  data1 = malloc (5 * sizeof (unsigned int));\r
-  ASSERT_TRUE (data1 != NULL);\r
-  for (i = 0; i < 5U; i++)\r
-    ((unsigned int *) data1)[i] = i + 10U;\r
-\r
-  data2 = malloc (5 * sizeof (unsigned int));\r
-  ASSERT_TRUE (data1 != NULL);\r
-  for (i = 0; i < 5U; i++)\r
-    ((unsigned int *) data2)[i] = i + 20U;\r
-\r
-  data3 = malloc (5 * sizeof (unsigned int));\r
-  ASSERT_TRUE (data1 != NULL);\r
-  for (i = 0; i < 5U; i++)\r
-    ((unsigned int *) data3)[i] = i + 30U;\r
-\r
-  EXPECT_TRUE (nns_edge_queue_create (&queue_h));\r
-\r
-  EXPECT_TRUE (nns_edge_queue_push (queue_h, data1, NULL));\r
-  len = nns_edge_queue_get_length (queue_h);\r
-  EXPECT_EQ (len, 1U);\r
-\r
-  EXPECT_TRUE (nns_edge_queue_push (queue_h, data2, NULL));\r
-  len = nns_edge_queue_get_length (queue_h);\r
-  EXPECT_EQ (len, 2U);\r
-\r
-  EXPECT_TRUE (nns_edge_queue_push (queue_h, data3, NULL));\r
-  len = nns_edge_queue_get_length (queue_h);\r
-  EXPECT_EQ (len, 3U);\r
-\r
-  EXPECT_TRUE (nns_edge_queue_pop (queue_h, &result));\r
-  len = nns_edge_queue_get_length (queue_h);\r
-  EXPECT_EQ (len, 2U);\r
-  EXPECT_EQ (result, data1);\r
-  for (i = 0; i < 5U; i++)\r
-    EXPECT_EQ (((unsigned int *) result)[i], i + 10U);\r
-\r
-  EXPECT_TRUE (nns_edge_queue_pop (queue_h, &result));\r
-  len = nns_edge_queue_get_length (queue_h);\r
-  EXPECT_EQ (len, 1U);\r
-  EXPECT_EQ (result, data2);\r
-  for (i = 0; i < 5U; i++)\r
-    EXPECT_EQ (((unsigned int *) result)[i], i + 20U);\r
-\r
-  EXPECT_TRUE (nns_edge_queue_pop (queue_h, &result));\r
-  len = nns_edge_queue_get_length (queue_h);\r
-  EXPECT_EQ (len, 0U);\r
-  EXPECT_EQ (result, data3);\r
-  for (i = 0; i < 5U; i++)\r
-    EXPECT_EQ (((unsigned int *) result)[i], i + 30U);\r
-\r
-  EXPECT_TRUE (nns_edge_queue_push (queue_h, data1, nns_edge_free));\r
-  len = nns_edge_queue_get_length (queue_h);\r
-  EXPECT_EQ (len, 1U);\r
-\r
-  EXPECT_TRUE (nns_edge_queue_push (queue_h, data2, nns_edge_free));\r
-  len = nns_edge_queue_get_length (queue_h);\r
-  EXPECT_EQ (len, 2U);\r
-\r
-  EXPECT_TRUE (nns_edge_queue_push (queue_h, data3, nns_edge_free));\r
-  len = nns_edge_queue_get_length (queue_h);\r
-  EXPECT_EQ (len, 3U);\r
-\r
-  EXPECT_TRUE (nns_edge_queue_destroy (queue_h));\r
-}\r
-\r
-/**\r
- * @brief Wait for pushing data.\r
- */\r
-TEST(edgeQueue, pushDataOnThread)\r
-{\r
-  nns_edge_queue_h queue_h;\r
-  pthread_t push_thread;\r
-  pthread_attr_t attr;\r
-  unsigned int i, j, len, retry;\r
-\r
-  EXPECT_TRUE (nns_edge_queue_create (&queue_h));\r
-\r
-  pthread_attr_init (&attr);\r
-  pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);\r
-  pthread_create (&push_thread, &attr, _test_thread_edge_queue_push, queue_h);\r
-  pthread_attr_destroy (&attr);\r
-\r
-  for (i = 0; i < 3U; i++) {\r
-    void *result = NULL;\r
-\r
-    EXPECT_TRUE (nns_edge_queue_wait_pop (queue_h, 0U, &result));\r
-\r
-    for (j = 0; j < 5U; j++)\r
-      EXPECT_EQ (((unsigned int *) result)[j], i * 10U + j);\r
-\r
-    free (result);\r
-  }\r
-\r
-  retry = 0U;\r
-  do {\r
-    usleep (20000);\r
-    len = nns_edge_queue_get_length (queue_h);\r
-  } while (len < 3U && retry++ < 200U);\r
-\r
-  EXPECT_TRUE (nns_edge_queue_destroy (queue_h));\r
-}\r
-\r
-/**\r
- * @brief Create queue - invalid param.\r
- */\r
-TEST(edgeQueue, createInvalidParam01_n)\r
-{\r
-  EXPECT_FALSE (nns_edge_queue_create (NULL));\r
-}\r
-\r
-/**\r
- * @brief Destroy queue - invalid param.\r
- */\r
-TEST(edgeQueue, destroyInvalidParam01_n)\r
-{\r
-  EXPECT_FALSE (nns_edge_queue_destroy (NULL));\r
-}\r
-\r
-/**\r
- * @brief Get length of queue - invalid param.\r
- */\r
-TEST(edgeQueue, getLengthInvalidParam01_n)\r
-{\r
-  unsigned int len;\r
-\r
-  len = nns_edge_queue_get_length (NULL);\r
-  EXPECT_EQ (len, 0U);\r
-}\r
-\r
-/**\r
- * @brief Push data into queue - invalid param.\r
- */\r
-TEST(edgeQueue, pushInvalidParam01_n)\r
-{\r
-  void *data;\r
-\r
-  data = malloc (5 * sizeof (unsigned int));\r
-  ASSERT_TRUE (data != NULL);\r
-\r
-  EXPECT_FALSE (nns_edge_queue_push (NULL, data, NULL));\r
-\r
-  free (data);\r
-}\r
-\r
-/**\r
- * @brief Push data into queue - invalid param.\r
- */\r
-TEST(edgeQueue, pushInvalidParam02_n)\r
-{\r
-  nns_edge_queue_h queue_h;\r
-\r
-  EXPECT_TRUE (nns_edge_queue_create (&queue_h));\r
-\r
-  EXPECT_FALSE (nns_edge_queue_push (queue_h, NULL, NULL));\r
-\r
-  EXPECT_TRUE (nns_edge_queue_destroy (queue_h));\r
-}\r
-\r
-/**\r
- * @brief Pop data from queue - invalid param.\r
- */\r
-TEST(edgeQueue, popInvalidParam01_n)\r
-{\r
-  void *data;\r
-\r
-  EXPECT_FALSE (nns_edge_queue_pop (NULL, &data));\r
-}\r
-\r
-/**\r
- * @brief Pop data from queue - invalid param.\r
- */\r
-TEST(edgeQueue, popInvalidParam02_n)\r
-{\r
-  nns_edge_queue_h queue_h;\r
-\r
-  EXPECT_TRUE (nns_edge_queue_create (&queue_h));\r
-\r
-  EXPECT_FALSE (nns_edge_queue_pop (queue_h, NULL));\r
-\r
-  EXPECT_TRUE (nns_edge_queue_destroy (queue_h));\r
-}\r
-\r
-/**\r
- * @brief Wait and pop data from queue, timed out.\r
- */\r
-TEST(edgeQueue, waitPopTimedout)\r
-{\r
-  nns_edge_queue_h queue_h;\r
-  void *data;\r
-\r
-  EXPECT_TRUE (nns_edge_queue_create (&queue_h));\r
-\r
-  EXPECT_FALSE (nns_edge_queue_wait_pop (queue_h, 10U, &data));\r
-\r
-  EXPECT_TRUE (nns_edge_queue_destroy (queue_h));\r
-}\r
-\r
-/**\r
- * @brief Wait and pop data from queue - invalid param.\r
- */\r
-TEST(edgeQueue, waitPopInvalidParam01_n)\r
-{\r
-  void *data;\r
-\r
-  EXPECT_FALSE (nns_edge_queue_wait_pop (NULL, 0U, &data));\r
-}\r
-\r
-/**\r
- * @brief Wait and pop data from queue - invalid param.\r
- */\r
-TEST(edgeQueue, waitPopInvalidParam02_n)\r
-{\r
-  nns_edge_queue_h queue_h;\r
-\r
-  EXPECT_TRUE (nns_edge_queue_create (&queue_h));\r
-\r
-  EXPECT_FALSE (nns_edge_queue_wait_pop (queue_h, 0U, NULL));\r
-\r
-  EXPECT_TRUE (nns_edge_queue_destroy (queue_h));\r
-}\r
-\r
-#if defined(ENABLE_MQTT)\r
-/**\r
- * @brief Edge event callback for test.\r
- */\r
-static int\r
-_test_edge_hybrid_event_cb (nns_edge_event_h event_h, void *user_data)\r
-{\r
-  ne_test_data_s *_td = (ne_test_data_s *) user_data;\r
-  nns_edge_event_e event = NNS_EDGE_EVENT_UNKNOWN;\r
-  nns_edge_data_h data_h;\r
-  void *data;\r
-  size_t data_len;\r
-  char *val;\r
-  unsigned int i, count;\r
-  int ret;\r
-\r
-  if (!_td) {\r
-    /* Cannot update event status. */\r
-    return NNS_EDGE_ERROR_NONE;\r
-  }\r
-\r
-  ret = nns_edge_event_get_type (event_h, &event);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  switch (event) {\r
-    case NNS_EDGE_EVENT_NEW_DATA_RECEIVED:\r
-      _td->received++;\r
-\r
-      ret = nns_edge_event_parse_new_data (event_h, &data_h);\r
-      EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-      /* Compare metadata */\r
-      ret = nns_edge_data_get_info (data_h, "test-key", &val);\r
-      EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-      EXPECT_STREQ (val, "test-value");\r
-      nns_edge_free (val);\r
-\r
-      if (_td->is_server) {\r
-        /**\r
-         * @note This is test code, responding to client.\r
-         * Recommend not to call edge API in event callback.\r
-         */\r
-        ret = nns_edge_send (_td->handle, data_h);\r
-        EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-      } else {\r
-        /* Compare received data */\r
-        ret = nns_edge_data_get_count (data_h, &count);\r
-        EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-        ret = nns_edge_data_get (data_h, 0, &data, &data_len);\r
-        EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-        EXPECT_EQ (count, 1U);\r
-        for (i = 0; i < 10U; i++)\r
-          EXPECT_EQ (((unsigned int *) data)[i], i);\r
-      }\r
-\r
-      ret = nns_edge_data_destroy (data_h);\r
-      EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-      break;\r
-    default:\r
-      break;\r
-  }\r
-\r
-  return NNS_EDGE_ERROR_NONE;\r
-}\r
-\r
-/**\r
- * @brief Check whether MQTT broker is running or not.\r
- */\r
-static bool\r
-_check_mqtt_broker ()\r
-{\r
-  int ret = 0;\r
-\r
-  ret = system ("ps aux | grep mosquitto | grep -v grep");\r
-  if (0 != ret) {\r
-    nns_edge_logw ("MQTT broker is not running. Skip query hybrid test.");\r
-    return false;\r
-  }\r
-\r
-  return true;\r
-}\r
-\r
-/**\r
- * @brief Connect to the local host using the information received from mqtt.\r
- */\r
-TEST(edgeMqtt, connectLocal)\r
-{\r
-  nns_edge_h server_h, client_h;\r
-  ne_test_data_s *_td_server, *_td_client;\r
-  nns_edge_data_h data_h;\r
-  size_t data_len;\r
-  void *data;\r
-  unsigned int i, retry;\r
-  int ret = 0;\r
-  char *val;\r
-\r
-  if (!_check_mqtt_broker ())\r
-    return;\r
-\r
-  _td_server = _get_test_data (true);\r
-  _td_client = _get_test_data (false);\r
-  ASSERT_TRUE (_td_server != NULL && _td_client != NULL);\r
-\r
-  /* Prepare server (127.0.0.1:port) */\r
-  nns_edge_create_handle ("temp-server", NNS_EDGE_CONNECT_TYPE_HYBRID,\r
-      NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND | NNS_EDGE_FLAG_SERVER, &server_h);\r
-  nns_edge_set_event_callback (server_h, _test_edge_hybrid_event_cb, _td_server);\r
-  nns_edge_set_info (server_h, "HOST", "localhost");\r
-  nns_edge_set_info (server_h, "PORT", "0");\r
-  nns_edge_set_info (server_h, "DEST_HOST", "tcp://localhost");\r
-  nns_edge_set_info (server_h, "DEST_PORT", "1883");\r
-  nns_edge_set_info (server_h, "TOPIC", "temp-mqtt-topic");\r
-  nns_edge_set_info (server_h, "CAPS", "test server");\r
-  _td_server->handle = server_h;\r
-\r
-  /* Prepare client */\r
-  nns_edge_create_handle ("temp-client", NNS_EDGE_CONNECT_TYPE_HYBRID,\r
-      NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND, &client_h);\r
-  nns_edge_set_event_callback (client_h, _test_edge_hybrid_event_cb, _td_client);\r
-  nns_edge_set_info (client_h, "CAPS", "test client");\r
-  nns_edge_set_info (client_h, "HOST", "localhost");\r
-  nns_edge_set_info (client_h, "port", "0");\r
-  nns_edge_set_info (client_h, "TOPIC", "temp-mqtt-topic");\r
-  _td_client->handle = client_h;\r
-\r
-  ret = nns_edge_start (server_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_start (client_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  usleep (200000);\r
-\r
-  ret = nns_edge_connect (client_h, "tcp://localhost", 1883);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  usleep (10000);\r
-\r
-  sleep (2);\r
-\r
-  /* Send request to server */\r
-  data_len = 10U * sizeof (unsigned int);\r
-  data = malloc (data_len);\r
-  ASSERT_TRUE (data != NULL);\r
-\r
-  for (i = 0; i < 10U; i++)\r
-    ((unsigned int *) data)[i] = i;\r
-\r
-  ret = nns_edge_data_create (&data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_data_add (data_h, data, data_len, nns_edge_free);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  nns_edge_get_info (client_h, "client_id", &val);\r
-  nns_edge_data_set_info (data_h, "client_id", val);\r
-  nns_edge_free (val);\r
-\r
-  ret = nns_edge_data_set_info (data_h, "test-key", "test-value");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  for (i = 0; i < 5U; i++) {\r
-    ret = nns_edge_send (client_h, data_h);\r
-    EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-    usleep (10000);\r
-  }\r
-\r
-  ret = nns_edge_data_destroy (data_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  /* Wait for responding data (20 seconds) */\r
-  retry = 0U;\r
-  do {\r
-    usleep (100000);\r
-    if (_td_client->received > 0)\r
-      break;\r
-  } while (retry++ < 200U);\r
-\r
-  ret = nns_edge_release_handle (server_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  ret = nns_edge_release_handle (client_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  EXPECT_TRUE (_td_server->received > 0);\r
-  EXPECT_TRUE (_td_client->received > 0);\r
-\r
-  _free_test_data (_td_server);\r
-  _free_test_data (_td_client);\r
-}\r
-\r
-/**\r
- * @brief Connect to the mqtt broker with invalid param.\r
- */\r
-TEST(edgeMqtt, connectInvalidParam1_n)\r
-{\r
-  int ret = -1;\r
-\r
-  if (!_check_mqtt_broker ())\r
-    return;\r
-\r
-  ret = nns_edge_mqtt_connect (NULL, "temp-mqtt-topic");\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Connect to the mqtt broker with invalid param.\r
- */\r
-TEST(edgeMqtt, connectInvalidParam2_n)\r
-{\r
-  int ret = -1;\r
-  nns_edge_h edge_h;\r
-\r
-  if (!_check_mqtt_broker ())\r
-    return;\r
-\r
-  ret = nns_edge_create_handle ("temp-server", NNS_EDGE_CONNECT_TYPE_HYBRID,\r
-      NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND | NNS_EDGE_FLAG_SERVER, &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  nns_edge_set_info (edge_h, "DEST_HOST", "tcp://localhost");\r
-  nns_edge_set_info (edge_h, "DEST_PORT", "1883");\r
-\r
-  ret = nns_edge_mqtt_connect (edge_h, NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Connect to the mqtt broker with invalid param.\r
- */\r
-TEST(edgeMqtt, connectInvalidParam3_n)\r
-{\r
-  int ret = -1;\r
-  nns_edge_h edge_h;\r
-\r
-  if (!_check_mqtt_broker ())\r
-    return;\r
-\r
-  ret = nns_edge_create_handle ("temp-server", NNS_EDGE_CONNECT_TYPE_HYBRID,\r
-      NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND | NNS_EDGE_FLAG_SERVER, &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  nns_edge_set_info (edge_h, "DEST_HOST", "tcp://localhost");\r
-  nns_edge_set_info (edge_h, "DEST_PORT", "1883");\r
-\r
-  ret = nns_edge_mqtt_connect (edge_h, "");\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Connect to the mqtt broker with invalid hostaddress.\r
- */\r
-TEST(edgeMqtt, connectInvalidParam4_n)\r
-{\r
-  int ret = -1;\r
-  nns_edge_h edge_h;\r
-\r
-  if (!_check_mqtt_broker ())\r
-    return;\r
-\r
-  ret = nns_edge_create_handle ("temp-server", NNS_EDGE_CONNECT_TYPE_HYBRID,\r
-      NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND | NNS_EDGE_FLAG_SERVER, &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  nns_edge_set_info (edge_h, "DEST_HOST", "tcp://none");\r
-  nns_edge_set_info (edge_h, "DEST_PORT", "1883");\r
-\r
-  ret = nns_edge_mqtt_connect (edge_h, "temp-mqtt-topic");\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Close the mqtt handle with invalid param.\r
- */\r
-TEST(edgeMqtt, closeInvalidParam_n)\r
-{\r
-  int ret = -1;\r
-\r
-  if (!_check_mqtt_broker ())\r
-    return;\r
-\r
-  ret = nns_edge_mqtt_close (NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Close the mqtt handle before the connection.\r
- */\r
-TEST(edgeMqtt, closeInvalidParam2_n)\r
-{\r
-  int ret = -1;\r
-  nns_edge_h edge_h;\r
-\r
-  if (!_check_mqtt_broker ())\r
-    return;\r
-\r
-  ret = nns_edge_create_handle ("temp-server", NNS_EDGE_CONNECT_TYPE_HYBRID,\r
-      NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND | NNS_EDGE_FLAG_SERVER, &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_mqtt_close (edge_h);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Publish with invalid param.\r
- */\r
-TEST(edgeMqtt, publishInvalidParam_n)\r
-{\r
-  int ret = -1;\r
-  const char *msg = "TEMP_MESSAGE";\r
-\r
-  if (!_check_mqtt_broker ())\r
-    return;\r
-\r
-  ret = nns_edge_mqtt_publish (NULL, msg, strlen (msg) + 1);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Publish with invalid param.\r
- */\r
-TEST(edgeMqtt, publishInvalidParam2_n)\r
-{\r
-  int ret = -1;\r
-  nns_edge_h edge_h;\r
-  const char *msg = "TEMP_MESSAGE";\r
-\r
-  if (!_check_mqtt_broker ())\r
-    return;\r
-\r
-  ret = nns_edge_create_handle ("temp-server", NNS_EDGE_CONNECT_TYPE_HYBRID,\r
-      NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND | NNS_EDGE_FLAG_SERVER, &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  nns_edge_set_info (edge_h, "DEST_HOST", "tcp://localhost");\r
-  nns_edge_set_info (edge_h, "DEST_PORT", "1883");\r
-\r
-  ret = nns_edge_start (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  /* data is null */\r
-  ret = nns_edge_mqtt_publish (edge_h, NULL, strlen (msg) + 1);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Publish with invalid param.\r
- */\r
-TEST(edgeMqtt, publishInvalidParam3_n)\r
-{\r
-  int ret = -1;\r
-  nns_edge_h edge_h;\r
-  const char *msg = "TEMP_MESSAGE";\r
-\r
-  if (!_check_mqtt_broker ())\r
-    return;\r
-\r
-  ret = nns_edge_create_handle ("temp-server", NNS_EDGE_CONNECT_TYPE_HYBRID,\r
-      NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND | NNS_EDGE_FLAG_SERVER, &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  nns_edge_set_info (edge_h, "DEST_HOST", "tcp://localhost");\r
-  nns_edge_set_info (edge_h, "DEST_PORT", "1883");\r
-\r
-  ret = nns_edge_start (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  /* data length is 0 */\r
-  ret = nns_edge_mqtt_publish (edge_h, msg, 0);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Publish the message without the connection.\r
- */\r
-TEST(edgeMqtt, publishInvalidParam4_n)\r
-{\r
-  int ret = -1;\r
-  nns_edge_h edge_h;\r
-  const char *msg = "TEMP_MESSAGE";\r
-\r
-  if (!_check_mqtt_broker ())\r
-    return;\r
-\r
-  ret = nns_edge_create_handle ("temp-server", NNS_EDGE_CONNECT_TYPE_HYBRID,\r
-      NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND | NNS_EDGE_FLAG_SERVER, &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  nns_edge_set_info (edge_h, "DEST_HOST", "tcp://localhost");\r
-  nns_edge_set_info (edge_h, "DEST_PORT", "1883");\r
-\r
-  ret = nns_edge_mqtt_publish (edge_h, msg, strlen (msg) + 1);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Subscribe the topic with invalid param.\r
- */\r
-TEST(edgeMqtt, subscribeInvalidParam_n)\r
-{\r
-  int ret = -1;\r
-\r
-  if (!_check_mqtt_broker ())\r
-    return;\r
-\r
-  ret = nns_edge_mqtt_subscribe (NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Subscribe the topic before the connection.\r
- */\r
-TEST(edgeMqtt, subscribeInvalidParam2_n)\r
-{\r
-  int ret = -1;\r
-  nns_edge_h edge_h;\r
-\r
-  if (!_check_mqtt_broker ())\r
-    return;\r
-\r
-  ret = nns_edge_create_handle ("temp-server", NNS_EDGE_CONNECT_TYPE_HYBRID,\r
-      NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND | NNS_EDGE_FLAG_SERVER, &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_mqtt_subscribe (edge_h);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Get message with invalid param.\r
- */\r
-TEST(edgeMqtt, getMessageInvalidParam_n)\r
-{\r
-  int ret = -1;\r
-  char *msg = NULL;\r
-\r
-  if (!_check_mqtt_broker ())\r
-    return;\r
-\r
-  ret = nns_edge_mqtt_get_message (NULL, &msg);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Get message with invalid param.\r
- */\r
-TEST(edgeMqtt, getMessageInvalidParam2_n)\r
-{\r
-  int ret = -1;\r
-  nns_edge_h edge_h;\r
-\r
-  if (!_check_mqtt_broker ())\r
-    return;\r
-\r
-  ret = nns_edge_create_handle ("temp-server", NNS_EDGE_CONNECT_TYPE_HYBRID,\r
-      NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND | NNS_EDGE_FLAG_SERVER, &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  nns_edge_set_info (edge_h, "DEST_HOST", "tcp://localhost");\r
-  nns_edge_set_info (edge_h, "DEST_PORT", "1883");\r
-\r
-  ret = nns_edge_start (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_mqtt_get_message (edge_h, NULL);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-\r
-/**\r
- * @brief Get message from empty message queue.\r
- */\r
-TEST(edgeMqtt, getMessageWithinTimeout_n)\r
-{\r
-  int ret = -1;\r
-  nns_edge_h edge_h;\r
-  char *msg = NULL;\r
-\r
-  if (!_check_mqtt_broker ())\r
-    return;\r
-\r
-  ret = nns_edge_create_handle ("temp-server", NNS_EDGE_CONNECT_TYPE_HYBRID,\r
-      NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND | NNS_EDGE_FLAG_SERVER, &edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-  nns_edge_set_info (edge_h, "DEST_HOST", "tcp://localhost");\r
-  nns_edge_set_info (edge_h, "DEST_PORT", "1883");\r
-\r
-  ret = nns_edge_mqtt_connect (edge_h, "temp-mqtt-topic");\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_mqtt_get_message (edge_h, &msg);\r
-  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_mqtt_close (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-\r
-  ret = nns_edge_release_handle (edge_h);\r
-  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);\r
-}\r
-#endif /* ENABLE_MQTT */\r
-\r
-/**\r
- * @brief Main gtest\r
- */\r
-int\r
-main (int argc, char **argv)\r
-{\r
-  int result = -1;\r
-\r
-  try {\r
-    testing::InitGoogleTest (&argc, argv);\r
-  } catch (...) {\r
-    nns_edge_loge ("Catch exception, failed to init google test.");\r
-  }\r
-\r
-  try {\r
-    result = RUN_ALL_TESTS ();\r
-  } catch (...) {\r
-    nns_edge_loge ("Catch exception, failed to run the unittest.");\r
-  }\r
-\r
-  return result;\r
-}\r
+/**
+ * @file        unittest_nnstreamer-edge.cc
+ * @date        27 June 2022
+ * @brief       Unittest for nnstreamer-edge library.
+ * @see         https://github.com/nnstreamer/nnstreamer-edge
+ * @author      Jaeyun Jung <jy1210.jung@samsung.com>
+ * @bug         No known bugs
+ */
+
+#include <gtest/gtest.h>
+#include "nnstreamer-edge.h"
+#include "nnstreamer-edge-data.h"
+#include "nnstreamer-edge-common.h"
+#include "nnstreamer-edge-internal.h"
+#include "nnstreamer-edge-log.h"
+#include "nnstreamer-edge-util.h"
+#include "nnstreamer-edge-queue.h"
+
+/**
+ * @brief Data struct for unittest.
+ */
+typedef struct
+{
+  nns_edge_h handle;
+  bool running;
+  bool is_server;
+  bool event_cb_released;
+  unsigned int received;
+} ne_test_data_s;
+
+/**
+ * @brief Allocate and initialize test data.
+ */
+static ne_test_data_s *
+_get_test_data (bool is_server)
+{
+  ne_test_data_s *_td;
+
+  _td = (ne_test_data_s *) calloc (1, sizeof (ne_test_data_s));
+
+  if (_td) {
+    _td->is_server = is_server;
+  }
+
+  return _td;
+}
+
+/**
+ * @brief Release test data.
+ */
+static void
+_free_test_data (ne_test_data_s *_td)
+{
+  if (!_td)
+    return;
+
+  free (_td);
+}
+
+/**
+ * @brief Edge event callback for test.
+ */
+static int
+_test_edge_event_cb (nns_edge_event_h event_h, void *user_data)
+{
+  ne_test_data_s *_td = (ne_test_data_s *) user_data;
+  nns_edge_event_e event = NNS_EDGE_EVENT_UNKNOWN;
+  nns_edge_data_h data_h;
+  void *data;
+  size_t data_len;
+  char *val;
+  unsigned int i, count;
+  int ret;
+
+  if (!_td) {
+    /* Cannot update event status. */
+    return NNS_EDGE_ERROR_NONE;
+  }
+
+  ret = nns_edge_event_get_type (event_h, &event);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  switch (event) {
+    case NNS_EDGE_EVENT_CALLBACK_RELEASED:
+      _td->event_cb_released = true;
+      break;
+    case NNS_EDGE_EVENT_NEW_DATA_RECEIVED:
+      _td->received++;
+
+      ret = nns_edge_event_parse_new_data (event_h, &data_h);
+      EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+      /* Compare metadata */
+      ret = nns_edge_data_get_info (data_h, "test-key1", &val);
+      EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+      EXPECT_STREQ (val, "test-value1");
+      nns_edge_free (val);
+      ret = nns_edge_data_get_info (data_h, "test-key2", &val);
+      EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+      EXPECT_STREQ (val, "test-value2");
+      nns_edge_free (val);
+
+      if (_td->is_server) {
+        /**
+         * @note This is test code, responding to client.
+         * Recommend not to call edge API in event callback.
+         */
+        ret = nns_edge_send (_td->handle, data_h);
+        EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+      } else {
+        /* Compare received data */
+        ret = nns_edge_data_get_count (data_h, &count);
+        EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+        ret = nns_edge_data_get (data_h, 0, &data, &data_len);
+        EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+        EXPECT_EQ (count, 1U);
+        for (i = 0; i < 10U; i++)
+          EXPECT_EQ (((unsigned int *) data)[i], i);
+      }
+
+      ret = nns_edge_data_destroy (data_h);
+      EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+      break;
+    default:
+      break;
+  }
+
+  return NNS_EDGE_ERROR_NONE;
+}
+
+/**
+ * @brief Connect to local host, multiple clients.
+ */
+TEST(edge, connectLocal)
+{
+  nns_edge_h server_h, client1_h, client2_h;
+  ne_test_data_s *_td_server, *_td_client1, *_td_client2;
+  nns_edge_data_h data_h;
+  size_t data_len;
+  void *data;
+  unsigned int i, retry;
+  int ret, port;
+  char *val, *client1_id, *client2_id;
+
+  _td_server = _get_test_data (true);
+  _td_client1 = _get_test_data (false);
+  _td_client2 = _get_test_data (false);
+  ASSERT_TRUE (_td_server != NULL && _td_client1 != NULL && _td_client2 != NULL);
+  port = nns_edge_get_available_port ();
+
+  /* Prepare server (127.0.0.1:port) */
+  val = nns_edge_strdup_printf ("%d", port);
+  nns_edge_create_handle ("temp-server", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND | NNS_EDGE_FLAG_SERVER), &server_h);
+  nns_edge_set_event_callback (server_h, _test_edge_event_cb, _td_server);
+  nns_edge_set_info (server_h, "IP", "127.0.0.1");
+  nns_edge_set_info (server_h, "PORT", val);
+  nns_edge_set_info (server_h, "CAPS", "test server");
+  _td_server->handle = server_h;
+  nns_edge_free (val);
+
+  /* Prepare client */
+  nns_edge_create_handle ("temp-client1", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &client1_h);
+  nns_edge_set_event_callback (client1_h, _test_edge_event_cb, _td_client1);
+  nns_edge_set_info (client1_h, "CAPS", "test client1");
+  _td_client1->handle = client1_h;
+
+  nns_edge_create_handle ("temp-client2", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &client2_h);
+  nns_edge_set_event_callback (client2_h, _test_edge_event_cb, _td_client2);
+  nns_edge_set_info (client2_h, "CAPS", "test client2");
+  _td_client2->handle = client2_h;
+
+  ret = nns_edge_start (server_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_start (client1_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_start (client2_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  usleep (200000);
+
+  ret = nns_edge_connect (client1_h, "127.0.0.1", port);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  usleep (10000);
+  ret = nns_edge_connect (client2_h, "127.0.0.1", port);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  sleep (2);
+
+  /* Send request to server */
+  data_len = 10U * sizeof (unsigned int);
+  data = malloc (data_len);
+  ASSERT_TRUE (data != NULL);
+
+  client1_id = client2_id = NULL;
+  ret = nns_edge_get_info (client1_h, "client_id", &client1_id);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_get_info (client2_h, "client_id", &client2_id);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  for (i = 0; i < 10U; i++)
+    ((unsigned int *) data)[i] = i;
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_add (data_h, data, data_len, nns_edge_free);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  /* For metadata test */
+  ret = nns_edge_data_set_info (data_h, "test-key1", "test-value1");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_data_set_info (data_h, "test-key2", "test-value2");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  for (i = 0; i < 5U; i++) {
+    ret = nns_edge_data_set_info (data_h, "client_id", client1_id);
+    EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+    ret = nns_edge_send (client1_h, data_h);
+    EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+    usleep (10000);
+    ret = nns_edge_data_set_info (data_h, "client_id", client2_id);
+    EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+    ret = nns_edge_send (client2_h, data_h);
+    EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+    usleep (100000);
+  }
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  /* Wait for responding data (20 seconds) */
+  retry = 0U;
+  do {
+    usleep (100000);
+    if (_td_client1->received > 0 && _td_client2->received > 0)
+      break;
+  } while (retry++ < 200U);
+
+  ret = nns_edge_disconnect (server_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_release_handle (server_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_release_handle (client1_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_release_handle (client2_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  EXPECT_TRUE (_td_server->received > 0);
+  EXPECT_TRUE (_td_client1->received > 0);
+  EXPECT_TRUE (_td_client2->received > 0);
+
+  nns_edge_free (client1_id);
+  nns_edge_free (client2_id);
+
+  _free_test_data (_td_server);
+  _free_test_data (_td_client1);
+  _free_test_data (_td_client2);
+}
+
+/**
+ * @brief Create edge handle - invalid param.
+ */
+TEST(edge, createHandleInvalidParam01_n)
+{
+  nns_edge_h edge_h;
+  int ret;
+
+  ret = nns_edge_create_handle (NULL, NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Create edge handle - invalid param.
+ */
+TEST(edge, createHandleInvalidParam02_n)
+{
+  nns_edge_h edge_h;
+  int ret;
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_UNKNOWN,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Create edge handle - invalid param.
+ */
+TEST(edge, createHandleInvalidParam03_n)
+{
+  int ret;
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Create edge handle - invalid param.
+ */
+TEST(edge, createHandleInvalidParam04_n)
+{
+  nns_edge_h edge_h;
+  int ret;
+
+  ret = nns_edge_create_handle ("", NNS_EDGE_CONNECT_TYPE_MQTT,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Create edge handle - invalid param.
+ */
+TEST(edge, createHandleInvalidParam05_n)
+{
+  nns_edge_h edge_h;
+  int ret;
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_HYBRID,
+      NNS_EDGE_FLAG_NONE, &edge_h);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Start - invalid param.
+ */
+TEST(edge, startInvalidParam01_n)
+{
+  int ret;
+
+  ret = nns_edge_start (NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Start - invalid param.
+ */
+TEST(edge, startInvalidParam02_n)
+{
+  nns_edge_h edge_h;
+  nns_edge_handle_s *eh;
+  int ret;
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  eh = (nns_edge_handle_s *) edge_h;
+  eh->magic = NNS_EDGE_MAGIC_DEAD;
+
+  ret = nns_edge_start (edge_h);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  eh->magic = NNS_EDGE_MAGIC;
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Release edge handle - invalid param.
+ */
+TEST(edge, releaseHandleInvalidParam01_n)
+{
+  int ret;
+
+  ret = nns_edge_release_handle (NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Release edge handle - invalid param.
+ */
+TEST(edge, releaseHandleInvalidParam02_n)
+{
+  nns_edge_h edge_h;
+  nns_edge_handle_s *eh;
+  int ret;
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  eh = (nns_edge_handle_s *) edge_h;
+  eh->magic = NNS_EDGE_MAGIC_DEAD;
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  eh->magic = NNS_EDGE_MAGIC;
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Set event callback - null param to clear event callback.
+ */
+TEST(edge, setEventCbSetNullCallback)
+{
+  nns_edge_h edge_h;
+  ne_test_data_s *_td;
+  int ret;
+
+  _td = _get_test_data (false);
+  ASSERT_TRUE (_td != NULL);
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_set_event_callback (edge_h, _test_edge_event_cb, _td);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  /* Set null param to clear event callback. */
+  ret = nns_edge_set_event_callback (edge_h, NULL, NULL);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  EXPECT_TRUE (_td->event_cb_released);
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  _free_test_data (_td);
+}
+
+/**
+ * @brief Set event callback - invalid param.
+ */
+TEST(edge, setEventCbInvalidParam01_n)
+{
+  int ret;
+
+  ret = nns_edge_set_event_callback (NULL, _test_edge_event_cb, NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Set event callback - invalid param.
+ */
+TEST(edge, setEventCbInvalidParam02_n)
+{
+  nns_edge_h edge_h;
+  nns_edge_handle_s *eh;
+  ne_test_data_s *_td;
+  int ret;
+
+  _td = _get_test_data (false);
+  ASSERT_TRUE (_td != NULL);
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  eh = (nns_edge_handle_s *) edge_h;
+  eh->magic = NNS_EDGE_MAGIC_DEAD;
+
+  ret = nns_edge_set_event_callback (edge_h, _test_edge_event_cb, _td);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  eh->magic = NNS_EDGE_MAGIC;
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  _free_test_data (_td);
+}
+
+/**
+ * @brief Connect - invalid param.
+ */
+TEST(edge, connectInvalidParam01_n)
+{
+  int ret;
+
+  ret = nns_edge_connect (NULL, "127.0.0.1", 80);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Connect - invalid param.
+ */
+TEST(edge, connectInvalidParam02_n)
+{
+  nns_edge_h edge_h;
+  nns_edge_handle_s *eh;
+  int ret;
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_set_event_callback (edge_h, _test_edge_event_cb, NULL);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  eh = (nns_edge_handle_s *) edge_h;
+  eh->magic = NNS_EDGE_MAGIC_DEAD;
+
+  ret = nns_edge_connect (edge_h, "127.0.0.1", 80);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  eh->magic = NNS_EDGE_MAGIC;
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Connect - invalid param.
+ */
+TEST(edge, connectInvalidParam03_n)
+{
+  nns_edge_h edge_h;
+  int ret;
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_set_event_callback (edge_h, _test_edge_event_cb, NULL);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_connect (edge_h, NULL, 80);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Connect - invalid param.
+ */
+TEST(edge, connectInvalidParam04_n)
+{
+  nns_edge_h edge_h;
+  int ret;
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_set_event_callback (edge_h, _test_edge_event_cb, NULL);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_connect (edge_h, "", 80);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Connect - invalid param.
+ */
+TEST(edge, connectInvalidParam05_n)
+{
+  nns_edge_h edge_h;
+  int ret;
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_set_event_callback (edge_h, _test_edge_event_cb, NULL);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  /* Invalid port number */
+  ret = nns_edge_connect (edge_h, "127.0.0.1", -1);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_connect (edge_h, "127.0.0.1", 0);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_connect (edge_h, "127.0.0.1", 77777);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Disconnect - invalid param.
+ */
+TEST(edge, disconnectInvalidParam01_n)
+{
+  int ret;
+
+  ret = nns_edge_disconnect (NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Disconnect - invalid param.
+ */
+TEST(edge, disconnectInvalidParam02_n)
+{
+  nns_edge_h edge_h;
+  nns_edge_handle_s *eh;
+  int ret;
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  eh = (nns_edge_handle_s *) edge_h;
+  eh->magic = NNS_EDGE_MAGIC_DEAD;
+
+  ret = nns_edge_disconnect (edge_h);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  eh->magic = NNS_EDGE_MAGIC;
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Send - invalid param.
+ */
+TEST(edge, sendInvalidParam01_n)
+{
+  nns_edge_data_h data_h;
+  int ret;
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_set_info (data_h, "client_id", "10");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_send (NULL, data_h);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Send - invalid param.
+ */
+TEST(edge, sendInvalidParam02_n)
+{
+  nns_edge_h edge_h;
+  nns_edge_data_h data_h;
+  nns_edge_handle_s *eh;
+  int ret;
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_set_info (data_h, "client_id", "10");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  eh = (nns_edge_handle_s *) edge_h;
+  eh->magic = NNS_EDGE_MAGIC_DEAD;
+
+  ret = nns_edge_send (edge_h, data_h);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  eh->magic = NNS_EDGE_MAGIC;
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Send - invalid param.
+ */
+TEST(edge, sendInvalidParam03_n)
+{
+  nns_edge_h edge_h;
+  int ret;
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_send (edge_h, NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Set info - invalid param.
+ */
+TEST(edge, setInfoInvalidParam01_n)
+{
+  int ret;
+
+  ret = nns_edge_set_info (NULL, "caps", "temp-caps");
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Set info - invalid param.
+ */
+TEST(edge, setInfoInvalidParam02_n)
+{
+  nns_edge_h edge_h;
+  nns_edge_handle_s *eh;
+  int ret;
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  eh = (nns_edge_handle_s *) edge_h;
+  eh->magic = NNS_EDGE_MAGIC_DEAD;
+
+  ret = nns_edge_set_info (edge_h, "caps", "temp-caps");
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  eh->magic = NNS_EDGE_MAGIC;
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Set info - invalid param.
+ */
+TEST(edge, setInfoInvalidParam03_n)
+{
+  nns_edge_h edge_h;
+  int ret;
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_set_info (edge_h, NULL, "temp-caps");
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Set info - invalid param.
+ */
+TEST(edge, setInfoInvalidParam04_n)
+{
+  nns_edge_h edge_h;
+  int ret;
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_set_info (edge_h, "", "temp-caps");
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Set info - invalid param.
+ */
+TEST(edge, setInfoInvalidParam05_n)
+{
+  nns_edge_h edge_h;
+  int ret;
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_set_info (edge_h, "caps", NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Set info - invalid param.
+ */
+TEST(edge, setInfoInvalidParam06_n)
+{
+  nns_edge_h edge_h;
+  int ret;
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_set_info (edge_h, "caps", "");
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Set info - invalid param.
+ */
+TEST(edge, setInfoInvalidParam07_n)
+{
+  nns_edge_h edge_h;
+  int ret;
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  /* Not allowed key */
+  ret = nns_edge_set_info (edge_h, "id", "temp-id2");
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_set_info (edge_h, "client_id", "temp-cid");
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Set info - invalid param.
+ */
+TEST(edge, setInfoInvalidParam08_n)
+{
+  nns_edge_h edge_h;
+  int ret;
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  /* Invalid port number */
+  ret = nns_edge_set_info (edge_h, "port", "-1");
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_set_info (edge_h, "port", "0");
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_set_info (edge_h, "port", "77777");
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Get info.
+ */
+TEST(edge, getInfo)
+{
+  nns_edge_h edge_h;
+  char *value = NULL;
+  int ret;
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_set_info (edge_h, "capability", "capa-for-test");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_set_info (edge_h, "topic", "topic-for-test");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_set_info (edge_h, "ip", "165.213.201.100");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_set_info (edge_h, "port", "2000");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_set_info (edge_h, "dest_ip", "165.213.201.101");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_set_info (edge_h, "dest_port", "2001");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_set_info (edge_h, "temp-key1", "temp-value1");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_set_info (edge_h, "temp-key2", "temp-value2");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_get_info (edge_h, "ID", &value);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_STREQ (value, "temp-id");
+  nns_edge_free (value);
+
+  ret = nns_edge_get_info (edge_h, "capability", &value);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_STREQ (value, "capa-for-test");
+  nns_edge_free (value);
+
+  ret = nns_edge_get_info (edge_h, "topic", &value);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_STREQ (value, "topic-for-test");
+  nns_edge_free (value);
+
+  ret = nns_edge_get_info (edge_h, "ip", &value);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_STREQ (value, "165.213.201.100");
+  nns_edge_free (value);
+
+  ret = nns_edge_get_info (edge_h, "port", &value);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_STREQ (value, "2000");
+  nns_edge_free (value);
+
+  ret = nns_edge_get_info (edge_h, "dest_ip", &value);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_STREQ (value, "165.213.201.101");
+  nns_edge_free (value);
+
+  ret = nns_edge_get_info (edge_h, "dest_port", &value);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_STREQ (value, "2001");
+  nns_edge_free (value);
+
+  ret = nns_edge_get_info (edge_h, "temp-key1", &value);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_STREQ (value, "temp-value1");
+  nns_edge_free (value);
+
+  ret = nns_edge_get_info (edge_h, "temp-key2", &value);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_STREQ (value, "temp-value2");
+  nns_edge_free (value);
+
+  /* Replace old value */
+  ret = nns_edge_set_info (edge_h, "temp-key2", "temp-value2-replaced");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_get_info (edge_h, "temp-key2", &value);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_STREQ (value, "temp-value2-replaced");
+  nns_edge_free (value);
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Get info - invalid param.
+ */
+TEST(edge, getInfoInvalidParam01_n)
+{
+  char *value = NULL;
+  int ret;
+
+  ret = nns_edge_get_info (NULL, "temp-key", &value);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Get info - invalid param.
+ */
+TEST(edge, getInfoInvalidParam02_n)
+{
+  nns_edge_h edge_h;
+  nns_edge_handle_s *eh;
+  char *value;
+  int ret;
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  eh = (nns_edge_handle_s *) edge_h;
+  eh->magic = NNS_EDGE_MAGIC_DEAD;
+
+  ret = nns_edge_get_info (edge_h, "temp-key", &value);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  eh->magic = NNS_EDGE_MAGIC;
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Get info - invalid param.
+ */
+TEST(edge, getInfoInvalidParam03_n)
+{
+  nns_edge_h edge_h;
+  char *value = NULL;
+  int ret;
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_get_info (edge_h, NULL, &value);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Get info - invalid param.
+ */
+TEST(edge, getInfoInvalidParam04_n)
+{
+  nns_edge_h edge_h;
+  char *value = NULL;
+  int ret;
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_get_info (edge_h, "", &value);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Get info - invalid param.
+ */
+TEST(edge, getInfoInvalidParam05_n)
+{
+  nns_edge_h edge_h;
+  int ret;
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND), &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_get_info (edge_h, "temp-key", NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Get info - invalid param.
+ */
+TEST(edge, getInfoInvalidParam06_n)
+{
+  nns_edge_h edge_h;
+  int ret;
+
+  ret = nns_edge_create_handle ("temp-id", NNS_EDGE_CONNECT_TYPE_TCP,
+      (NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND | NNS_EDGE_FLAG_SERVER), &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  /* Cannot get the client ID if handle is server */
+  ret = nns_edge_get_info (edge_h, "client_id", NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Create edge-data - invalid param.
+ */
+TEST(edgeData, createInvalidParam01_n)
+{
+  int ret;
+
+  ret = nns_edge_data_create (NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Destroy edge-data - invalid param.
+ */
+TEST(edgeData, destroyInvalidParam01_n)
+{
+  int ret;
+
+  ret = nns_edge_data_destroy (NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Destroy edge-data - invalid param.
+ */
+TEST(edgeData, destroyInvalidParam02_n)
+{
+  nns_edge_data_h data_h;
+  nns_edge_data_s *ed;
+  int ret;
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ed = (nns_edge_data_s *) data_h;
+  ed->magic = NNS_EDGE_MAGIC_DEAD;
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ed->magic = NNS_EDGE_MAGIC;
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Validate edge-data.
+ */
+TEST(edgeData, validate)
+{
+  nns_edge_data_h data_h;
+  int ret;
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_is_valid (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Validate edge-data - invalid param.
+ */
+TEST(edgeData, validateInvalidParam01_n)
+{
+  int ret;
+
+  ret = nns_edge_data_is_valid (NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Validate edge-data - invalid param.
+ */
+TEST(edgeData, validateInvalidParam02_n)
+{
+  nns_edge_data_h data_h;
+  nns_edge_data_s *ed;
+  int ret;
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ed = (nns_edge_data_s *) data_h;
+  ed->magic = NNS_EDGE_MAGIC_DEAD;
+
+  ret = nns_edge_data_is_valid (data_h);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ed->magic = NNS_EDGE_MAGIC;
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Copy edge-data.
+ */
+TEST(edgeData, copy)
+{
+  nns_edge_data_h src_h, desc_h;
+  void *data, *result;
+  size_t data_len, result_len;
+  char *result_value;
+  unsigned int i, result_count;
+  int ret;
+
+  data_len = 10U * sizeof (unsigned int);
+  data = malloc (data_len);
+  ASSERT_TRUE (data != NULL);
+
+  for (i = 0; i < 10U; i++)
+    ((unsigned int *) data)[i] = i;
+
+  ret = nns_edge_data_create (&src_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_set_info (src_h, "temp-key1", "temp-data-val1");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_data_set_info (src_h, "temp-key2", "temp-data-val2");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_add (src_h, data, data_len, free);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_copy (src_h, &desc_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (src_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  /* Compare data and info */
+  ret = nns_edge_data_get_count (desc_h, &result_count);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_EQ (result_count, 1U);
+
+  ret = nns_edge_data_get (desc_h, 0, &result, &result_len);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  for (i = 0; i < 10U; i++)
+    EXPECT_EQ (((unsigned int *) result)[i], i);
+
+  ret = nns_edge_data_get_info (desc_h, "temp-key1", &result_value);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_STREQ (result_value, "temp-data-val1");
+  free (result_value);
+
+  ret = nns_edge_data_get_info (desc_h, "temp-key2", &result_value);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_STREQ (result_value, "temp-data-val2");
+  free (result_value);
+
+  ret = nns_edge_data_destroy (desc_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Copy edge-data - invalid param.
+ */
+TEST(edgeData, copyInvalidParam01_n)
+{
+  nns_edge_data_h desc_h;
+  int ret;
+
+  ret = nns_edge_data_copy (NULL, &desc_h);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Copy edge-data - invalid param.
+ */
+TEST(edgeData, copyInvalidParam02_n)
+{
+  nns_edge_data_h src_h, desc_h;
+  nns_edge_data_s *ed;
+  int ret;
+
+  ret = nns_edge_data_create (&src_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ed = (nns_edge_data_s *) src_h;
+  ed->magic = NNS_EDGE_MAGIC_DEAD;
+
+  ret = nns_edge_data_copy (src_h, &desc_h);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ed->magic = NNS_EDGE_MAGIC;
+
+  ret = nns_edge_data_destroy (src_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Copy edge-data - invalid param.
+ */
+TEST(edgeData, copyInvalidParam03_n)
+{
+  nns_edge_data_h src_h;
+  int ret;
+
+  ret = nns_edge_data_create (&src_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_copy (src_h, NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (src_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Add edge-data - max data limit.
+ */
+TEST(edgeData, addMaxData_n)
+{
+  nns_edge_data_h data_h;
+  void *data;
+  size_t data_len;
+  int i, ret;
+
+  data_len = 10U * sizeof (int);
+  data = malloc (data_len);
+  ASSERT_TRUE (data != NULL);
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  for (i = 0; i < NNS_EDGE_DATA_LIMIT; i++) {
+    ret = nns_edge_data_add (data_h, data, data_len, NULL);
+    EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  }
+
+  ret = nns_edge_data_add (data_h, data, data_len, NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  free (data);
+}
+
+/**
+ * @brief Add edge-data - invalid param.
+ */
+TEST(edgeData, addInvalidParam01_n)
+{
+  void *data;
+  size_t data_len;
+  int ret;
+
+  data_len = 10U * sizeof (int);
+  data = malloc (data_len);
+  ASSERT_TRUE (data != NULL);
+
+  ret = nns_edge_data_add (NULL, data, data_len, NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  free (data);
+}
+
+/**
+ * @brief Add edge-data - invalid param.
+ */
+TEST(edgeData, addInvalidParam02_n)
+{
+  nns_edge_data_h data_h;
+  nns_edge_data_s *ed;
+  void *data;
+  size_t data_len;
+  int ret;
+
+  data_len = 10U * sizeof (int);
+  data = malloc (data_len);
+  ASSERT_TRUE (data != NULL);
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ed = (nns_edge_data_s *) data_h;
+  ed->magic = NNS_EDGE_MAGIC_DEAD;
+
+  ret = nns_edge_data_add (data_h, data, data_len, NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ed->magic = NNS_EDGE_MAGIC;
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  free (data);
+}
+
+/**
+ * @brief Add edge-data - invalid param.
+ */
+TEST(edgeData, addInvalidParam03_n)
+{
+  nns_edge_data_h data_h;
+  void *data;
+  size_t data_len;
+  int ret;
+
+  data_len = 10U * sizeof (int);
+  data = malloc (data_len);
+  ASSERT_TRUE (data != NULL);
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_add (data_h, NULL, data_len, NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  free (data);
+}
+
+/**
+ * @brief Add edge-data - invalid param.
+ */
+TEST(edgeData, addInvalidParam04_n)
+{
+  nns_edge_data_h data_h;
+  void *data;
+  size_t data_len;
+  int ret;
+
+  data_len = 10U * sizeof (int);
+  data = malloc (data_len);
+  ASSERT_TRUE (data != NULL);
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_add (data_h, data, 0, NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  free (data);
+}
+
+/**
+ * @brief Get edge-data.
+ */
+TEST(edgeData, get)
+{
+  nns_edge_data_h data_h;
+  void *data, *result;
+  size_t data_len, result_len;
+  unsigned int count;
+  int ret;
+
+  data_len = 10U * sizeof (int);
+  data = malloc (data_len);
+  ASSERT_TRUE (data != NULL);
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_add (data_h, data, data_len, NULL);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_get_count (data_h, &count);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_EQ (count, 1U);
+
+  ret = nns_edge_data_get (data_h, 0, &result, &result_len);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_EQ (result, data);
+  EXPECT_EQ (result_len, data_len);
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  free (data);
+}
+
+/**
+ * @brief Get edge-data - invalid param.
+ */
+TEST(edgeData, getInvalidParam01_n)
+{
+  void *data;
+  size_t data_len;
+  int ret;
+
+  ret = nns_edge_data_get (NULL, 0, &data, &data_len);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Get edge-data - invalid param.
+ */
+TEST(edgeData, getInvalidParam02_n)
+{
+  nns_edge_data_h data_h;
+  nns_edge_data_s *ed;
+  void *data, *result;
+  size_t data_len, result_len;
+  int ret;
+
+  data_len = 10U * sizeof (int);
+  data = malloc (data_len);
+  ASSERT_TRUE (data != NULL);
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_add (data_h, data, data_len, NULL);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ed = (nns_edge_data_s *) data_h;
+  ed->magic = NNS_EDGE_MAGIC_DEAD;
+
+  ret = nns_edge_data_get (data_h, 0, &result, &result_len);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ed->magic = NNS_EDGE_MAGIC;
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  free (data);
+}
+
+/**
+ * @brief Get edge-data - invalid param.
+ */
+TEST(edgeData, getInvalidParam03_n)
+{
+  nns_edge_data_h data_h;
+  void *data, *result;
+  size_t data_len, result_len;
+  int ret;
+
+  data_len = 10U * sizeof (int);
+  data = malloc (data_len);
+  ASSERT_TRUE (data != NULL);
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_add (data_h, data, data_len, NULL);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  /* Invalid index */
+  ret = nns_edge_data_get (data_h, 1, &result, &result_len);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  free (data);
+}
+
+/**
+ * @brief Get edge-data - invalid param.
+ */
+TEST(edgeData, getInvalidParam04_n)
+{
+  nns_edge_data_h data_h;
+  void *data;
+  size_t data_len, result_len;
+  int ret;
+
+  data_len = 10U * sizeof (int);
+  data = malloc (data_len);
+  ASSERT_TRUE (data != NULL);
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_add (data_h, data, data_len, NULL);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_get (data_h, 0, NULL, &result_len);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  free (data);
+}
+
+/**
+ * @brief Get edge-data - invalid param.
+ */
+TEST(edgeData, getInvalidParam05_n)
+{
+  nns_edge_data_h data_h;
+  void *data, *result;
+  size_t data_len;
+  int ret;
+
+  data_len = 10U * sizeof (int);
+  data = malloc (data_len);
+  ASSERT_TRUE (data != NULL);
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_add (data_h, data, data_len, NULL);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_get (data_h, 0, &result, NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  free (data);
+}
+
+/**
+ * @brief Get count of edge-data - invalid param.
+ */
+TEST(edgeData, getCountInvalidParam01_n)
+{
+  unsigned int count;
+  int ret;
+
+  ret = nns_edge_data_get_count (NULL, &count);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Get count of edge-data - invalid param.
+ */
+TEST(edgeData, getCountInvalidParam02_n)
+{
+  nns_edge_data_h data_h;
+  nns_edge_data_s *ed;
+  void *data;
+  size_t data_len;
+  unsigned int count;
+  int ret;
+
+  data_len = 10U * sizeof (int);
+  data = malloc (data_len);
+  ASSERT_TRUE (data != NULL);
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_add (data_h, data, data_len, NULL);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ed = (nns_edge_data_s *) data_h;
+  ed->magic = NNS_EDGE_MAGIC_DEAD;
+
+  ret = nns_edge_data_get_count (data_h, &count);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ed->magic = NNS_EDGE_MAGIC;
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  free (data);
+}
+
+/**
+ * @brief Get count of edge-data - invalid param.
+ */
+TEST(edgeData, getCountInvalidParam03_n)
+{
+  nns_edge_data_h data_h;
+  void *data;
+  size_t data_len;
+  int ret;
+
+  data_len = 10U * sizeof (int);
+  data = malloc (data_len);
+  ASSERT_TRUE (data != NULL);
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_add (data_h, data, data_len, NULL);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_get_count (data_h, NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  free (data);
+}
+
+/**
+ * @brief Set info of edge-data - invalid param.
+ */
+TEST(edgeData, setInfoInvalidParam01_n)
+{
+  int ret;
+
+  ret = nns_edge_data_set_info (NULL, "temp-key", "temp-value");
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Set info of edge-data - invalid param.
+ */
+TEST(edgeData, setInfoInvalidParam02_n)
+{
+  nns_edge_data_h data_h;
+  nns_edge_data_s *ed;
+  int ret;
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ed = (nns_edge_data_s *) data_h;
+  ed->magic = NNS_EDGE_MAGIC_DEAD;
+
+  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ed->magic = NNS_EDGE_MAGIC;
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Set info of edge-data - invalid param.
+ */
+TEST(edgeData, setInfoInvalidParam03_n)
+{
+  nns_edge_data_h data_h;
+  int ret;
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_set_info (data_h, NULL, "temp-value");
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Set info of edge-data - invalid param.
+ */
+TEST(edgeData, setInfoInvalidParam04_n)
+{
+  nns_edge_data_h data_h;
+  int ret;
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_set_info (data_h, "temp-key", NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Get info of edge-data - invalid param.
+ */
+TEST(edgeData, getInfoInvalidParam01_n)
+{
+  char *value = NULL;
+  int ret;
+
+  ret = nns_edge_data_get_info (NULL, "temp-key", &value);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Get info of edge-data - invalid param.
+ */
+TEST(edgeData, getInfoInvalidParam02_n)
+{
+  nns_edge_data_h data_h;
+  nns_edge_data_s *ed;
+  char *value = NULL;
+  int ret;
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ed = (nns_edge_data_s *) data_h;
+  ed->magic = NNS_EDGE_MAGIC_DEAD;
+
+  ret = nns_edge_data_get_info (data_h, "temp-key", &value);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ed->magic = NNS_EDGE_MAGIC;
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Get info of edge-data - invalid param.
+ */
+TEST(edgeData, getInfoInvalidParam03_n)
+{
+  nns_edge_data_h data_h;
+  char *value = NULL;
+  int ret;
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_get_info (data_h, NULL, &value);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Get info of edge-data - invalid param.
+ */
+TEST(edgeData, getInfoInvalidParam04_n)
+{
+  nns_edge_data_h data_h;
+  int ret;
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_get_info (data_h, "temp-key", NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Get info of edge-data - invalid param.
+ */
+TEST(edgeData, getInfoInvalidParam05_n)
+{
+  nns_edge_data_h data_h;
+  int ret;
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_get_info (data_h, "", NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Serialize meta in edge-data - invalid param.
+ */
+TEST(edgeData, serializeInvalidParam01_n)
+{
+  void *data;
+  size_t data_len;
+  int ret;
+
+  ret = nns_edge_data_serialize_meta (NULL, &data, &data_len);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Serialize meta in edge-data - invalid param.
+ */
+TEST(edgeData, serializeInvalidParam02_n)
+{
+  nns_edge_data_h data_h;
+  nns_edge_data_s *ed;
+  void *data;
+  size_t data_len;
+  int ret;
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ed = (nns_edge_data_s *) data_h;
+  ed->magic = NNS_EDGE_MAGIC_DEAD;
+
+  ret = nns_edge_data_serialize_meta (data_h, &data, &data_len);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ed->magic = NNS_EDGE_MAGIC;
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Serialize meta in edge-data - invalid param.
+ */
+TEST(edgeData, serializeInvalidParam03_n)
+{
+  nns_edge_data_h data_h;
+  size_t data_len;
+  int ret;
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_serialize_meta (data_h, NULL, &data_len);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Serialize meta in edge-data - invalid param.
+ */
+TEST(edgeData, serializeInvalidParam04_n)
+{
+  nns_edge_data_h data_h;
+  void *data;
+  int ret;
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_serialize_meta (data_h, &data, NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Derialize meta to edge-data - invalid param.
+ */
+TEST(edgeData, deserializeInvalidParam01_n)
+{
+  nns_edge_data_h data_h;
+  void *data;
+  size_t data_len;
+  int ret;
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_serialize_meta (data_h, &data, &data_len);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_deserialize_meta (NULL, data, data_len);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  nns_edge_free (data);
+}
+
+/**
+ * @brief Derialize meta to edge-data - invalid param.
+ */
+TEST(edgeData, deserializeInvalidParam02_n)
+{
+  nns_edge_data_h data_h;
+  nns_edge_data_s *ed;
+  void *data;
+  size_t data_len;
+  int ret;
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_serialize_meta (data_h, &data, &data_len);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ed = (nns_edge_data_s *) data_h;
+  ed->magic = NNS_EDGE_MAGIC_DEAD;
+
+  ret = nns_edge_data_deserialize_meta (data_h, data, data_len);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ed->magic = NNS_EDGE_MAGIC;
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  nns_edge_free (data);
+}
+
+/**
+ * @brief Derialize meta to edge-data - invalid param.
+ */
+TEST(edgeData, deserializeInvalidParam03_n)
+{
+  nns_edge_data_h data_h;
+  void *data;
+  size_t data_len;
+  int ret;
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_serialize_meta (data_h, &data, &data_len);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_deserialize_meta (data_h, NULL, data_len);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  nns_edge_free (data);
+}
+
+/**
+ * @brief Derialize meta to edge-data - invalid param.
+ */
+TEST(edgeData, deserializeInvalidParam04_n)
+{
+  nns_edge_data_h data_h;
+  void *data;
+  size_t data_len;
+  int ret;
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_serialize_meta (data_h, &data, &data_len);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_deserialize_meta (data_h, data, 0);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  nns_edge_free (data);
+}
+
+
+/**
+ * @brief Serialzie and deserialize the edge-data.
+ */
+TEST(edgeDataSerialize, normal)
+{
+  nns_edge_data_h src_h, dest_h;
+  void *data1, *data2, *result, *serialized_data;
+  size_t data_len, result_len, serialized_len;
+  char *result_value;
+  unsigned int i, result_count;
+  int ret;
+
+  data_len = 10U * sizeof (unsigned int);
+  data1 = malloc (data_len);
+  ASSERT_TRUE (data1 != NULL);
+
+  for (i = 0; i < 10U; i++)
+    ((unsigned int *) data1)[i] = i;
+
+  data2 = malloc (data_len * 2);
+  ASSERT_TRUE (data2 != NULL);
+
+  for (i = 0; i < 20U; i++)
+    ((unsigned int *) data2)[i] = 20 - i;
+
+  ret = nns_edge_data_create (&src_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_set_info (src_h, "temp-key1", "temp-data-val1");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_data_set_info (src_h, "temp-key2", "temp-data-val2");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_add (src_h, data1, data_len, free);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_data_add (src_h, data2, data_len * 2, free);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_serialize (src_h, &serialized_data, &serialized_len);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (src_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_create (&dest_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_deserialize (dest_h, serialized_data);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  /* Compare data and info */
+  ret = nns_edge_data_get_count (dest_h, &result_count);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_EQ (result_count, 2U);
+
+  ret = nns_edge_data_get (dest_h, 0, &result, &result_len);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  for (i = 0; i < 10U; i++)
+    EXPECT_EQ (((unsigned int *) result)[i], i);
+
+  ret = nns_edge_data_get (dest_h, 1, &result, &result_len);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  for (i = 0; i < 20U; i++)
+    EXPECT_EQ (((unsigned int *) result)[i], 20 - i);
+
+  ret = nns_edge_data_get_info (dest_h, "temp-key1", &result_value);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_STREQ (result_value, "temp-data-val1");
+  free (result_value);
+
+  ret = nns_edge_data_get_info (dest_h, "temp-key2", &result_value);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_STREQ (result_value, "temp-data-val2");
+  free (result_value);
+
+  ret = nns_edge_data_destroy (dest_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+
+/**
+ * @brief Serialize edge-data - invalid param.
+ */
+TEST(edgeDataSerialize, invalidParam01_n)
+{
+  void *data;
+  size_t data_len;
+  int ret;
+
+  ret = nns_edge_data_serialize (NULL, &data, &data_len);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Serialize edge-data - invalid param.
+ */
+TEST(edgeData, invalidParam02_n)
+{
+  nns_edge_data_h data_h;
+  nns_edge_data_s *ed;
+  void *data;
+  size_t data_len;
+  int ret;
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ed = (nns_edge_data_s *) data_h;
+  ed->magic = NNS_EDGE_MAGIC_DEAD;
+
+  ret = nns_edge_data_serialize (data_h, &data, &data_len);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ed->magic = NNS_EDGE_MAGIC;
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Serialize edge-data - invalid param.
+ */
+TEST(edgeDataSerialize, invalidParam03_n)
+{
+  nns_edge_data_h data_h;
+  size_t data_len;
+  int ret;
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_serialize (data_h, NULL, &data_len);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Serialize edge-data - invalid param.
+ */
+TEST(edgeDataSerialize, invalidParam04_n)
+{
+  nns_edge_data_h data_h;
+  void *data;
+  int ret;
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_serialize_meta (data_h, &data, NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Derialize edge-data - invalid param.
+ */
+TEST(edgeDataDeserialize, invalidParam01_n)
+{
+  void *data = NULL;
+  size_t data_len;
+  int ret;
+
+  ret = nns_edge_data_deserialize (NULL, data);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  nns_edge_free (data);
+}
+
+/**
+ * @brief Derialize edge-data - invalid param.
+ */
+TEST(edgeDataDeserialize, invalidParam02_n)
+{
+  nns_edge_data_h data_h;
+  nns_edge_data_s *ed;
+  void *data;
+  size_t data_len;
+  int ret;
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_serialize_meta (data_h, &data, &data_len);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ed = (nns_edge_data_s *) data_h;
+  ed->magic = NNS_EDGE_MAGIC_DEAD;
+
+  ret = nns_edge_data_deserialize (data_h, data);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ed->magic = NNS_EDGE_MAGIC;
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  nns_edge_free (data);
+}
+
+/**
+ * @brief Derialize edge-data - invalid param.
+ */
+TEST(edgeDataDeserialize, invalidParam03_n)
+{
+  nns_edge_data_h data_h;
+  int ret;
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_set_info (data_h, "temp-key", "temp-value");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_deserialize (data_h, NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Create edge event - invalid param.
+ */
+TEST(edgeEvent, createInvalidParam01_n)
+{
+  nns_edge_event_h event_h;
+  int ret;
+
+  ret = nns_edge_event_create (NNS_EDGE_EVENT_UNKNOWN, &event_h);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Create edge event - invalid param.
+ */
+TEST(edgeEvent, createInvalidParam02_n)
+{
+  int ret;
+
+  ret = nns_edge_event_create (NNS_EDGE_EVENT_CUSTOM, NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Destroy edge event - invalid param.
+ */
+TEST(edgeEvent, destroyInvalidParam01_n)
+{
+  int ret;
+
+  ret = nns_edge_event_destroy (NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Destroy edge event - invalid param.
+ */
+TEST(edgeEvent, destroyInvalidParam02_n)
+{
+  nns_edge_event_h event_h;
+  nns_edge_event_s *ee;
+  void *data;
+  size_t data_len;
+  int ret;
+
+  data_len = 10U * sizeof (int);
+  data = malloc (data_len);
+  ASSERT_TRUE (data != NULL);
+
+  ret = nns_edge_event_create (NNS_EDGE_EVENT_CUSTOM, &event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_event_set_data (event_h, data, data_len, free);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ee = (nns_edge_event_s *) event_h;
+  ee->magic = NNS_EDGE_MAGIC_DEAD;
+
+  ret = nns_edge_event_destroy (event_h);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ee->magic = NNS_EDGE_MAGIC;
+
+  ret = nns_edge_event_destroy (event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Set edge event data - invalid param.
+ */
+TEST(edgeEvent, setDataInvalidParam01_n)
+{
+  void *data;
+  size_t data_len;
+  int ret;
+
+  data_len = 10U * sizeof (int);
+  data = malloc (data_len);
+  ASSERT_TRUE (data != NULL);
+
+  ret = nns_edge_event_set_data (NULL, data, data_len, NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  free (data);
+}
+
+/**
+ * @brief Set edge event data - invalid param.
+ */
+TEST(edgeEvent, setDataInvalidParam02_n)
+{
+  nns_edge_event_h event_h;
+  void *data;
+  size_t data_len;
+  int ret;
+
+  data_len = 10U * sizeof (int);
+  data = malloc (data_len);
+  ASSERT_TRUE (data != NULL);
+
+  ret = nns_edge_event_create (NNS_EDGE_EVENT_CUSTOM, &event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_event_set_data (event_h, NULL, data_len, NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_event_destroy (event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  free (data);
+}
+
+/**
+ * @brief Set edge event data - invalid param.
+ */
+TEST(edgeEvent, setDataInvalidParam03_n)
+{
+  nns_edge_event_h event_h;
+  void *data;
+  size_t data_len;
+  int ret;
+
+  data_len = 10U * sizeof (int);
+  data = malloc (data_len);
+  ASSERT_TRUE (data != NULL);
+
+  ret = nns_edge_event_create (NNS_EDGE_EVENT_CUSTOM, &event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_event_set_data (event_h, data, 0, NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_event_destroy (event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  free (data);
+}
+
+/**
+ * @brief Set edge event data - invalid param.
+ */
+TEST(edgeEvent, setDataInvalidParam04_n)
+{
+  nns_edge_event_h event_h;
+  nns_edge_event_s *ee;
+  void *data;
+  size_t data_len;
+  int ret;
+
+  data_len = 10U * sizeof (int);
+  data = malloc (data_len);
+  ASSERT_TRUE (data != NULL);
+
+  ret = nns_edge_event_create (NNS_EDGE_EVENT_CUSTOM, &event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ee = (nns_edge_event_s *) event_h;
+  ee->magic = NNS_EDGE_MAGIC_DEAD;
+
+  ret = nns_edge_event_set_data (event_h, data, data_len, NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ee->magic = NNS_EDGE_MAGIC;
+
+  ret = nns_edge_event_destroy (event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  free (data);
+}
+
+/**
+ * @brief Get edge event type.
+ */
+TEST(edgeEvent, getType)
+{
+  nns_edge_event_h event_h;
+  nns_edge_event_e event = NNS_EDGE_EVENT_UNKNOWN;
+  int ret;
+
+  ret = nns_edge_event_create (NNS_EDGE_EVENT_CUSTOM, &event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_event_get_type (event_h, &event);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_EQ (event, NNS_EDGE_EVENT_CUSTOM);
+
+  ret = nns_edge_event_destroy (event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Get edge event type - invalid param.
+ */
+TEST(edgeEvent, getTypeInvalidParam01_n)
+{
+  nns_edge_event_e event;
+  int ret;
+
+  ret = nns_edge_event_get_type (NULL, &event);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Get edge event type - invalid param.
+ */
+TEST(edgeEvent, getTypeInvalidParam02_n)
+{
+  nns_edge_event_h event_h;
+  int ret;
+
+  ret = nns_edge_event_create (NNS_EDGE_EVENT_CUSTOM, &event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_event_get_type (event_h, NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_event_destroy (event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Get edge event type - invalid param.
+ */
+TEST(edgeEvent, getTypeInvalidParam03_n)
+{
+  nns_edge_event_h event_h;
+  nns_edge_event_e event;
+  nns_edge_event_s *ee;
+  int ret;
+
+  ret = nns_edge_event_create (NNS_EDGE_EVENT_CUSTOM, &event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ee = (nns_edge_event_s *) event_h;
+  ee->magic = NNS_EDGE_MAGIC_DEAD;
+
+  ret = nns_edge_event_get_type (event_h, &event);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ee->magic = NNS_EDGE_MAGIC;
+
+  ret = nns_edge_event_destroy (event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Parse new data of edge event.
+ */
+TEST(edgeEvent, parseNewData)
+{
+  nns_edge_event_h event_h;
+  nns_edge_data_h data_h, result_h;
+  void *data, *result;
+  size_t data_len, result_len;
+  char *result_value;
+  unsigned int i, count;
+  int ret;
+
+  data_len = 10U * sizeof (unsigned int);
+  data = malloc (data_len);
+  ASSERT_TRUE (data != NULL);
+
+  for (i = 0; i < 10U; i++)
+    ((unsigned int *) data)[i] = i;
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_add (data_h, data, data_len, free);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_set_info (data_h, "temp-key1", "temp-data-val1");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_data_set_info (data_h, "temp-key2", "temp-data-val2");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_event_create (NNS_EDGE_EVENT_NEW_DATA_RECEIVED, &event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_event_set_data (event_h, data_h, sizeof (nns_edge_data_h), NULL);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_event_parse_new_data (event_h, &result_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  /* Compare data and info */
+  ret = nns_edge_data_get_count (result_h, &count);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_EQ (count, 1U);
+
+  ret = nns_edge_data_get (result_h, 0, &result, &result_len);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  for (i = 0; i < 10U; i++)
+    EXPECT_EQ (((unsigned int *) result)[i], i);
+
+  ret = nns_edge_data_get_info (result_h, "temp-key1", &result_value);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_STREQ (result_value, "temp-data-val1");
+  free (result_value);
+
+  ret = nns_edge_data_get_info (result_h, "temp-key2", &result_value);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_STREQ (result_value, "temp-data-val2");
+  free (result_value);
+
+  ret = nns_edge_event_destroy (event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_destroy (result_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Parse new data of edge event - invalid param.
+ */
+TEST(edgeEvent, parseNewDataInvalidParam01_n)
+{
+  nns_edge_data_h data_h;
+  int ret;
+
+  ret = nns_edge_event_parse_new_data (NULL, &data_h);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Parse new data of edge event - invalid param.
+ */
+TEST(edgeEvent, parseNewDataInvalidParam02_n)
+{
+  nns_edge_event_h event_h;
+  int ret;
+
+  ret = nns_edge_event_create (NNS_EDGE_EVENT_NEW_DATA_RECEIVED, &event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_event_parse_new_data (event_h, NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_event_destroy (event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Parse new data of edge event - invalid param.
+ */
+TEST(edgeEvent, parseNewDataInvalidParam03_n)
+{
+  nns_edge_event_h event_h;
+  nns_edge_data_h data_h;
+  nns_edge_event_s *ee;
+  int ret;
+
+  ret = nns_edge_event_create (NNS_EDGE_EVENT_NEW_DATA_RECEIVED, &event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ee = (nns_edge_event_s *) event_h;
+  ee->magic = NNS_EDGE_MAGIC_DEAD;
+
+  ret = nns_edge_event_parse_new_data (event_h, &data_h);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ee->magic = NNS_EDGE_MAGIC;
+
+  ret = nns_edge_event_destroy (event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Parse new data of edge event - invalid param.
+ */
+TEST(edgeEvent, parseNewDataInvalidParam04_n)
+{
+  nns_edge_event_h event_h;
+  nns_edge_data_h data_h;
+  int ret;
+
+  ret = nns_edge_event_create (NNS_EDGE_EVENT_CUSTOM, &event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_event_parse_new_data (event_h, &data_h);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_event_destroy (event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Parse capability of edge event.
+ */
+TEST(edgeEvent, parseCapability)
+{
+  const char capability[] = "temp-capability";
+  nns_edge_event_h event_h;
+  char *caps = NULL;
+  int ret;
+
+  ret = nns_edge_event_create (NNS_EDGE_EVENT_CAPABILITY, &event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_event_set_data (event_h, (void *) capability, strlen (capability), NULL);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_event_parse_capability (event_h, &caps);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_STREQ (caps, capability);
+  free (caps);
+
+  ret = nns_edge_event_destroy (event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Parse capability of edge event - invalid param.
+ */
+TEST(edgeEvent, parseCapabilityInvalidParam01_n)
+{
+  char *caps = NULL;
+  int ret;
+
+  ret = nns_edge_event_parse_capability (NULL, &caps);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Parse capability of edge event - invalid param.
+ */
+TEST(edgeEvent, parseCapabilityInvalidParam02_n)
+{
+  nns_edge_event_h event_h;
+  int ret;
+
+  ret = nns_edge_event_create (NNS_EDGE_EVENT_CAPABILITY, &event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_event_parse_capability (event_h, NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_event_destroy (event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Parse capability of edge event - invalid param.
+ */
+TEST(edgeEvent, parseCapabilityInvalidParam03_n)
+{
+  nns_edge_event_h event_h;
+  nns_edge_event_s *ee;
+  char *caps = NULL;
+  int ret;
+
+  ret = nns_edge_event_create (NNS_EDGE_EVENT_CAPABILITY, &event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ee = (nns_edge_event_s *) event_h;
+  ee->magic = NNS_EDGE_MAGIC_DEAD;
+
+  ret = nns_edge_event_parse_capability (event_h, &caps);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ee->magic = NNS_EDGE_MAGIC;
+
+  ret = nns_edge_event_destroy (event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Parse capability of edge event - invalid param.
+ */
+TEST(edgeEvent, parseCapabilityInvalidParam04_n)
+{
+  nns_edge_event_h event_h;
+  char *caps = NULL;
+  int ret;
+
+  ret = nns_edge_event_create (NNS_EDGE_EVENT_CUSTOM, &event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_event_parse_capability (event_h, &caps);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_event_destroy (event_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Initialize edge metadata - invalid param.
+ */
+TEST(edgeMeta, initInvalidParam01_n)
+{
+  int ret;
+
+  ret = nns_edge_metadata_init (NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Release resources of edge metadata - invalid param.
+ */
+TEST(edgeMeta, freeInvalidParam01_n)
+{
+  int ret;
+
+  ret = nns_edge_metadata_free (NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Set edge metadata - invalid param.
+ */
+TEST(edgeMeta, setInvalidParam01_n)
+{
+  int ret;
+
+  ret = nns_edge_metadata_set (NULL, "temp-key", "temp-value");
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Set edge metadata - invalid param.
+ */
+TEST(edgeMeta, setInvalidParam02_n)
+{
+  nns_edge_metadata_s meta;
+  int ret;
+
+  ret = nns_edge_metadata_init (&meta);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_set (&meta, NULL, "temp-value");
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_free (&meta);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Set edge metadata - invalid param.
+ */
+TEST(edgeMeta, setInvalidParam03_n)
+{
+  nns_edge_metadata_s meta;
+  int ret;
+
+  ret = nns_edge_metadata_init (&meta);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_set (&meta, "", "temp-value");
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_free (&meta);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Set edge metadata - invalid param.
+ */
+TEST(edgeMeta, setInvalidParam04_n)
+{
+  nns_edge_metadata_s meta;
+  int ret;
+
+  ret = nns_edge_metadata_init (&meta);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_set (&meta, "temp-key", NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_free (&meta);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Set edge metadata - invalid param.
+ */
+TEST(edgeMeta, setInvalidParam05_n)
+{
+  nns_edge_metadata_s meta;
+  int ret;
+
+  ret = nns_edge_metadata_init (&meta);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_set (&meta, "temp-key", "");
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_free (&meta);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Get edge metadata - invalid param.
+ */
+TEST(edgeMeta, getInvalidParam01_n)
+{
+  char *value = NULL;
+  int ret;
+
+  ret = nns_edge_metadata_get (NULL, "temp-key", &value);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Get edge metadata - invalid param.
+ */
+TEST(edgeMeta, getInvalidParam02_n)
+{
+  nns_edge_metadata_s meta;
+  char *value = NULL;
+  int ret;
+
+  ret = nns_edge_metadata_init (&meta);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_get (&meta, NULL, &value);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_free (&meta);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Get edge metadata - invalid param.
+ */
+TEST(edgeMeta, getInvalidParam03_n)
+{
+  nns_edge_metadata_s meta;
+  char *value = NULL;
+  int ret;
+
+  ret = nns_edge_metadata_init (&meta);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_get (&meta, "", &value);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_free (&meta);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Get edge metadata - invalid param.
+ */
+TEST(edgeMeta, getInvalidParam04_n)
+{
+  nns_edge_metadata_s meta;
+  int ret;
+
+  ret = nns_edge_metadata_init (&meta);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_get (&meta, "temp-key", NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_free (&meta);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Copy edge metadata.
+ */
+TEST(edgeMeta, copy)
+{
+  nns_edge_metadata_s src, desc;
+  char *value = NULL;
+  int ret;
+
+  ret = nns_edge_metadata_init (&src);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_metadata_init (&desc);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_set (&src, "temp-key1", "temp-value1");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_metadata_set (&src, "temp-key2", "temp-value2");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  /* Replace old value */
+  ret = nns_edge_metadata_set (&src, "temp-key2", "temp-value2-replaced");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_copy (&desc, &src);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_get (&desc, "temp-key1", &value);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_STREQ (value, "temp-value1");
+  nns_edge_free (value);
+
+  ret = nns_edge_metadata_get (&desc, "temp-key2", &value);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_STREQ (value, "temp-value2-replaced");
+  nns_edge_free (value);
+
+  ret = nns_edge_metadata_free (&src);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_metadata_free (&desc);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Copy edge metadata - invalid param.
+ */
+TEST(edgeMeta, copyInvalidParam01_n)
+{
+  nns_edge_metadata_s src;
+  int ret;
+
+  ret = nns_edge_metadata_init (&src);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_copy (NULL, &src);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_free (&src);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Copy edge metadata - invalid param.
+ */
+TEST(edgeMeta, copyInvalidParam02_n)
+{
+  nns_edge_metadata_s desc;
+  int ret;
+
+  ret = nns_edge_metadata_init (&desc);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_copy (&desc, NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_free (&desc);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Serialize edge metadata.
+ */
+TEST(edgeMeta, serialize)
+{
+  nns_edge_metadata_s src, desc;
+  char *value;
+  void *data;
+  size_t data_len;
+  int ret;
+
+  ret = nns_edge_metadata_init (&src);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_metadata_init (&desc);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_set (&src, "temp-key1", "temp-value1");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_metadata_set (&src, "temp-key2", "temp-value2");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_metadata_set (&src, "temp-key3", "temp-value3");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  EXPECT_EQ (src.list_len, 3U);
+  EXPECT_EQ (desc.list_len, 0U);
+
+  ret = nns_edge_metadata_serialize (&src, &data, &data_len);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_deserialize (&desc, data, data_len);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_EQ (desc.list_len, 3U);
+
+  ret = nns_edge_metadata_get (&desc, "temp-key1", &value);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_STREQ (value, "temp-value1");
+  nns_edge_free (value);
+
+  ret = nns_edge_metadata_get (&desc, "temp-key2", &value);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_STREQ (value, "temp-value2");
+  nns_edge_free (value);
+
+  ret = nns_edge_metadata_get (&desc, "temp-key3", &value);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  EXPECT_STREQ (value, "temp-value3");
+  nns_edge_free (value);
+
+  ret = nns_edge_metadata_free (&src);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_metadata_free (&desc);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  free (data);
+}
+
+/**
+ * @brief Serialize edge metadata - invalid param.
+ */
+TEST(edgeMeta, serializeInvalidParam01_n)
+{
+  void *data;
+  size_t data_len;
+  int ret;
+
+  ret = nns_edge_metadata_serialize (NULL, &data, &data_len);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Serialize edge metadata - invalid param.
+ */
+TEST(edgeMeta, serializeInvalidParam02_n)
+{
+  nns_edge_metadata_s meta;
+  size_t data_len;
+  int ret;
+
+  ret = nns_edge_metadata_init (&meta);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_serialize (&meta, NULL, &data_len);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_free (&meta);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Serialize edge metadata - invalid param.
+ */
+TEST(edgeMeta, serializeInvalidParam03_n)
+{
+  nns_edge_metadata_s meta;
+  void *data;
+  int ret;
+
+  ret = nns_edge_metadata_init (&meta);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_serialize (&meta, &data, NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_free (&meta);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Deserialize edge metadata - invalid param.
+ */
+TEST(edgeMeta, deserializeInvalidParam01_n)
+{
+  void *data;
+  size_t data_len;
+  int ret;
+
+  data_len = 10U + sizeof (unsigned int);
+  data = malloc (data_len);
+  ASSERT_TRUE (data != NULL);
+  ((unsigned int *) data)[0] = 0U;
+
+  ret = nns_edge_metadata_deserialize (NULL, data, data_len);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  free (data);
+}
+
+/**
+ * @brief Deserialize edge metadata - invalid param.
+ */
+TEST(edgeMeta, deserializeInvalidParam02_n)
+{
+  nns_edge_metadata_s meta;
+  size_t data_len;
+  int ret;
+
+  data_len = 10U + sizeof (unsigned int);
+
+  ret = nns_edge_metadata_init (&meta);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_deserialize (&meta, NULL, data_len);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_free (&meta);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Deserialize edge metadata - invalid param.
+ */
+TEST(edgeMeta, deserializeInvalidParam03_n)
+{
+  nns_edge_metadata_s meta;
+  void *data;
+  size_t data_len;
+  int ret;
+
+  data_len = 10U + sizeof (unsigned int);
+  data = malloc (data_len);
+  ASSERT_TRUE (data != NULL);
+  ((unsigned int *) data)[0] = 0U;
+
+  ret = nns_edge_metadata_init (&meta);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_deserialize (&meta, data, 0);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_metadata_free (&meta);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  free (data);
+}
+
+/**
+ * @brief Thread to push new data into queue.
+ */
+static void *
+_test_thread_edge_queue_push (void *thread_data)
+{
+  nns_edge_queue_h queue_h = thread_data;
+  unsigned int i, j;
+  void *data;
+
+  for (i = 0; i < 6U; i++) {
+    usleep (50000);
+
+    data = malloc (5 * sizeof (unsigned int));
+    if (data) {
+      for (j = 0; j < 5U; j++)
+        ((unsigned int *) data)[j] = i * 10U + j;
+    }
+
+    EXPECT_TRUE (nns_edge_queue_push (queue_h, data, nns_edge_free));
+  }
+
+  return NULL;
+}
+
+/**
+ * @brief Push and pop data.
+ */
+TEST(edgeQueue, pushData)
+{
+  nns_edge_queue_h queue_h;
+  void *data1, *data2, *data3, *result;
+  unsigned int i, len;
+
+  data1 = malloc (5 * sizeof (unsigned int));
+  ASSERT_TRUE (data1 != NULL);
+  for (i = 0; i < 5U; i++)
+    ((unsigned int *) data1)[i] = i + 10U;
+
+  data2 = malloc (5 * sizeof (unsigned int));
+  ASSERT_TRUE (data1 != NULL);
+  for (i = 0; i < 5U; i++)
+    ((unsigned int *) data2)[i] = i + 20U;
+
+  data3 = malloc (5 * sizeof (unsigned int));
+  ASSERT_TRUE (data1 != NULL);
+  for (i = 0; i < 5U; i++)
+    ((unsigned int *) data3)[i] = i + 30U;
+
+  EXPECT_TRUE (nns_edge_queue_create (&queue_h));
+
+  EXPECT_TRUE (nns_edge_queue_push (queue_h, data1, NULL));
+  len = nns_edge_queue_get_length (queue_h);
+  EXPECT_EQ (len, 1U);
+
+  EXPECT_TRUE (nns_edge_queue_push (queue_h, data2, NULL));
+  len = nns_edge_queue_get_length (queue_h);
+  EXPECT_EQ (len, 2U);
+
+  EXPECT_TRUE (nns_edge_queue_push (queue_h, data3, NULL));
+  len = nns_edge_queue_get_length (queue_h);
+  EXPECT_EQ (len, 3U);
+
+  EXPECT_TRUE (nns_edge_queue_pop (queue_h, &result));
+  len = nns_edge_queue_get_length (queue_h);
+  EXPECT_EQ (len, 2U);
+  EXPECT_EQ (result, data1);
+  for (i = 0; i < 5U; i++)
+    EXPECT_EQ (((unsigned int *) result)[i], i + 10U);
+
+  EXPECT_TRUE (nns_edge_queue_pop (queue_h, &result));
+  len = nns_edge_queue_get_length (queue_h);
+  EXPECT_EQ (len, 1U);
+  EXPECT_EQ (result, data2);
+  for (i = 0; i < 5U; i++)
+    EXPECT_EQ (((unsigned int *) result)[i], i + 20U);
+
+  EXPECT_TRUE (nns_edge_queue_pop (queue_h, &result));
+  len = nns_edge_queue_get_length (queue_h);
+  EXPECT_EQ (len, 0U);
+  EXPECT_EQ (result, data3);
+  for (i = 0; i < 5U; i++)
+    EXPECT_EQ (((unsigned int *) result)[i], i + 30U);
+
+  EXPECT_TRUE (nns_edge_queue_push (queue_h, data1, nns_edge_free));
+  len = nns_edge_queue_get_length (queue_h);
+  EXPECT_EQ (len, 1U);
+
+  EXPECT_TRUE (nns_edge_queue_push (queue_h, data2, nns_edge_free));
+  len = nns_edge_queue_get_length (queue_h);
+  EXPECT_EQ (len, 2U);
+
+  EXPECT_TRUE (nns_edge_queue_push (queue_h, data3, nns_edge_free));
+  len = nns_edge_queue_get_length (queue_h);
+  EXPECT_EQ (len, 3U);
+
+  EXPECT_TRUE (nns_edge_queue_destroy (queue_h));
+}
+
+/**
+ * @brief Wait for pushing data.
+ */
+TEST(edgeQueue, pushDataOnThread)
+{
+  nns_edge_queue_h queue_h;
+  pthread_t push_thread;
+  pthread_attr_t attr;
+  unsigned int i, j, len, retry;
+
+  EXPECT_TRUE (nns_edge_queue_create (&queue_h));
+
+  pthread_attr_init (&attr);
+  pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
+  pthread_create (&push_thread, &attr, _test_thread_edge_queue_push, queue_h);
+  pthread_attr_destroy (&attr);
+
+  for (i = 0; i < 3U; i++) {
+    void *result = NULL;
+
+    EXPECT_TRUE (nns_edge_queue_wait_pop (queue_h, 0U, &result));
+
+    for (j = 0; j < 5U; j++)
+      EXPECT_EQ (((unsigned int *) result)[j], i * 10U + j);
+
+    free (result);
+  }
+
+  retry = 0U;
+  do {
+    usleep (20000);
+    len = nns_edge_queue_get_length (queue_h);
+  } while (len < 3U && retry++ < 200U);
+
+  EXPECT_TRUE (nns_edge_queue_destroy (queue_h));
+}
+
+/**
+ * @brief Create queue - invalid param.
+ */
+TEST(edgeQueue, createInvalidParam01_n)
+{
+  EXPECT_FALSE (nns_edge_queue_create (NULL));
+}
+
+/**
+ * @brief Destroy queue - invalid param.
+ */
+TEST(edgeQueue, destroyInvalidParam01_n)
+{
+  EXPECT_FALSE (nns_edge_queue_destroy (NULL));
+}
+
+/**
+ * @brief Get length of queue - invalid param.
+ */
+TEST(edgeQueue, getLengthInvalidParam01_n)
+{
+  unsigned int len;
+
+  len = nns_edge_queue_get_length (NULL);
+  EXPECT_EQ (len, 0U);
+}
+
+/**
+ * @brief Push data into queue - invalid param.
+ */
+TEST(edgeQueue, pushInvalidParam01_n)
+{
+  void *data;
+
+  data = malloc (5 * sizeof (unsigned int));
+  ASSERT_TRUE (data != NULL);
+
+  EXPECT_FALSE (nns_edge_queue_push (NULL, data, NULL));
+
+  free (data);
+}
+
+/**
+ * @brief Push data into queue - invalid param.
+ */
+TEST(edgeQueue, pushInvalidParam02_n)
+{
+  nns_edge_queue_h queue_h;
+
+  EXPECT_TRUE (nns_edge_queue_create (&queue_h));
+
+  EXPECT_FALSE (nns_edge_queue_push (queue_h, NULL, NULL));
+
+  EXPECT_TRUE (nns_edge_queue_destroy (queue_h));
+}
+
+/**
+ * @brief Pop data from queue - invalid param.
+ */
+TEST(edgeQueue, popInvalidParam01_n)
+{
+  void *data;
+
+  EXPECT_FALSE (nns_edge_queue_pop (NULL, &data));
+}
+
+/**
+ * @brief Pop data from queue - invalid param.
+ */
+TEST(edgeQueue, popInvalidParam02_n)
+{
+  nns_edge_queue_h queue_h;
+
+  EXPECT_TRUE (nns_edge_queue_create (&queue_h));
+
+  EXPECT_FALSE (nns_edge_queue_pop (queue_h, NULL));
+
+  EXPECT_TRUE (nns_edge_queue_destroy (queue_h));
+}
+
+/**
+ * @brief Wait and pop data from queue, timed out.
+ */
+TEST(edgeQueue, waitPopTimedout)
+{
+  nns_edge_queue_h queue_h;
+  void *data;
+
+  EXPECT_TRUE (nns_edge_queue_create (&queue_h));
+
+  EXPECT_FALSE (nns_edge_queue_wait_pop (queue_h, 10U, &data));
+
+  EXPECT_TRUE (nns_edge_queue_destroy (queue_h));
+}
+
+/**
+ * @brief Wait and pop data from queue - invalid param.
+ */
+TEST(edgeQueue, waitPopInvalidParam01_n)
+{
+  void *data;
+
+  EXPECT_FALSE (nns_edge_queue_wait_pop (NULL, 0U, &data));
+}
+
+/**
+ * @brief Wait and pop data from queue - invalid param.
+ */
+TEST(edgeQueue, waitPopInvalidParam02_n)
+{
+  nns_edge_queue_h queue_h;
+
+  EXPECT_TRUE (nns_edge_queue_create (&queue_h));
+
+  EXPECT_FALSE (nns_edge_queue_wait_pop (queue_h, 0U, NULL));
+
+  EXPECT_TRUE (nns_edge_queue_destroy (queue_h));
+}
+
+#if defined(ENABLE_MQTT)
+/**
+ * @brief Edge event callback for test.
+ */
+static int
+_test_edge_hybrid_event_cb (nns_edge_event_h event_h, void *user_data)
+{
+  ne_test_data_s *_td = (ne_test_data_s *) user_data;
+  nns_edge_event_e event = NNS_EDGE_EVENT_UNKNOWN;
+  nns_edge_data_h data_h;
+  void *data;
+  size_t data_len;
+  char *val;
+  unsigned int i, count;
+  int ret;
+
+  if (!_td) {
+    /* Cannot update event status. */
+    return NNS_EDGE_ERROR_NONE;
+  }
+
+  ret = nns_edge_event_get_type (event_h, &event);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  switch (event) {
+    case NNS_EDGE_EVENT_NEW_DATA_RECEIVED:
+      _td->received++;
+
+      ret = nns_edge_event_parse_new_data (event_h, &data_h);
+      EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+      /* Compare metadata */
+      ret = nns_edge_data_get_info (data_h, "test-key", &val);
+      EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+      EXPECT_STREQ (val, "test-value");
+      nns_edge_free (val);
+
+      if (_td->is_server) {
+        /**
+         * @note This is test code, responding to client.
+         * Recommend not to call edge API in event callback.
+         */
+        ret = nns_edge_send (_td->handle, data_h);
+        EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+      } else {
+        /* Compare received data */
+        ret = nns_edge_data_get_count (data_h, &count);
+        EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+        ret = nns_edge_data_get (data_h, 0, &data, &data_len);
+        EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+        EXPECT_EQ (count, 1U);
+        for (i = 0; i < 10U; i++)
+          EXPECT_EQ (((unsigned int *) data)[i], i);
+      }
+
+      ret = nns_edge_data_destroy (data_h);
+      EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+      break;
+    default:
+      break;
+  }
+
+  return NNS_EDGE_ERROR_NONE;
+}
+
+/**
+ * @brief Check whether MQTT broker is running or not.
+ */
+static bool
+_check_mqtt_broker ()
+{
+  int ret = 0;
+
+  ret = system ("ps aux | grep mosquitto | grep -v grep");
+  if (0 != ret) {
+    nns_edge_logw ("MQTT broker is not running. Skip query hybrid test.");
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * @brief Connect to the local host using the information received from mqtt.
+ */
+TEST(edgeMqtt, connectLocal)
+{
+  nns_edge_h server_h, client_h;
+  ne_test_data_s *_td_server, *_td_client;
+  nns_edge_data_h data_h;
+  size_t data_len;
+  void *data;
+  unsigned int i, retry;
+  int ret = 0;
+  char *val;
+
+  if (!_check_mqtt_broker ())
+    return;
+
+  _td_server = _get_test_data (true);
+  _td_client = _get_test_data (false);
+  ASSERT_TRUE (_td_server != NULL && _td_client != NULL);
+
+  /* Prepare server (127.0.0.1:port) */
+  nns_edge_create_handle ("temp-server", NNS_EDGE_CONNECT_TYPE_HYBRID,
+      NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND | NNS_EDGE_FLAG_SERVER, &server_h);
+  nns_edge_set_event_callback (server_h, _test_edge_hybrid_event_cb, _td_server);
+  nns_edge_set_info (server_h, "HOST", "localhost");
+  nns_edge_set_info (server_h, "PORT", "0");
+  nns_edge_set_info (server_h, "DEST_HOST", "tcp://localhost");
+  nns_edge_set_info (server_h, "DEST_PORT", "1883");
+  nns_edge_set_info (server_h, "TOPIC", "temp-mqtt-topic");
+  nns_edge_set_info (server_h, "CAPS", "test server");
+  _td_server->handle = server_h;
+
+  /* Prepare client */
+  nns_edge_create_handle ("temp-client", NNS_EDGE_CONNECT_TYPE_HYBRID,
+      NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND, &client_h);
+  nns_edge_set_event_callback (client_h, _test_edge_hybrid_event_cb, _td_client);
+  nns_edge_set_info (client_h, "CAPS", "test client");
+  nns_edge_set_info (client_h, "HOST", "localhost");
+  nns_edge_set_info (client_h, "port", "0");
+  nns_edge_set_info (client_h, "TOPIC", "temp-mqtt-topic");
+  _td_client->handle = client_h;
+
+  ret = nns_edge_start (server_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_start (client_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  usleep (200000);
+
+  ret = nns_edge_connect (client_h, "tcp://localhost", 1883);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  usleep (10000);
+
+  sleep (2);
+
+  /* Send request to server */
+  data_len = 10U * sizeof (unsigned int);
+  data = malloc (data_len);
+  ASSERT_TRUE (data != NULL);
+
+  for (i = 0; i < 10U; i++)
+    ((unsigned int *) data)[i] = i;
+
+  ret = nns_edge_data_create (&data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_data_add (data_h, data, data_len, nns_edge_free);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  nns_edge_get_info (client_h, "client_id", &val);
+  nns_edge_data_set_info (data_h, "client_id", val);
+  nns_edge_free (val);
+
+  ret = nns_edge_data_set_info (data_h, "test-key", "test-value");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  for (i = 0; i < 5U; i++) {
+    ret = nns_edge_send (client_h, data_h);
+    EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+    usleep (10000);
+  }
+
+  ret = nns_edge_data_destroy (data_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  /* Wait for responding data (20 seconds) */
+  retry = 0U;
+  do {
+    usleep (100000);
+    if (_td_client->received > 0)
+      break;
+  } while (retry++ < 200U);
+
+  ret = nns_edge_release_handle (server_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  ret = nns_edge_release_handle (client_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  EXPECT_TRUE (_td_server->received > 0);
+  EXPECT_TRUE (_td_client->received > 0);
+
+  _free_test_data (_td_server);
+  _free_test_data (_td_client);
+}
+
+/**
+ * @brief Connect to the mqtt broker with invalid param.
+ */
+TEST(edgeMqtt, connectInvalidParam1_n)
+{
+  int ret = -1;
+
+  if (!_check_mqtt_broker ())
+    return;
+
+  ret = nns_edge_mqtt_connect (NULL, "temp-mqtt-topic");
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Connect to the mqtt broker with invalid param.
+ */
+TEST(edgeMqtt, connectInvalidParam2_n)
+{
+  int ret = -1;
+  nns_edge_h edge_h;
+
+  if (!_check_mqtt_broker ())
+    return;
+
+  ret = nns_edge_create_handle ("temp-server", NNS_EDGE_CONNECT_TYPE_HYBRID,
+      NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND | NNS_EDGE_FLAG_SERVER, &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  nns_edge_set_info (edge_h, "DEST_HOST", "tcp://localhost");
+  nns_edge_set_info (edge_h, "DEST_PORT", "1883");
+
+  ret = nns_edge_mqtt_connect (edge_h, NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Connect to the mqtt broker with invalid param.
+ */
+TEST(edgeMqtt, connectInvalidParam3_n)
+{
+  int ret = -1;
+  nns_edge_h edge_h;
+
+  if (!_check_mqtt_broker ())
+    return;
+
+  ret = nns_edge_create_handle ("temp-server", NNS_EDGE_CONNECT_TYPE_HYBRID,
+      NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND | NNS_EDGE_FLAG_SERVER, &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  nns_edge_set_info (edge_h, "DEST_HOST", "tcp://localhost");
+  nns_edge_set_info (edge_h, "DEST_PORT", "1883");
+
+  ret = nns_edge_mqtt_connect (edge_h, "");
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Connect to the mqtt broker with invalid hostaddress.
+ */
+TEST(edgeMqtt, connectInvalidParam4_n)
+{
+  int ret = -1;
+  nns_edge_h edge_h;
+
+  if (!_check_mqtt_broker ())
+    return;
+
+  ret = nns_edge_create_handle ("temp-server", NNS_EDGE_CONNECT_TYPE_HYBRID,
+      NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND | NNS_EDGE_FLAG_SERVER, &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  nns_edge_set_info (edge_h, "DEST_HOST", "tcp://none");
+  nns_edge_set_info (edge_h, "DEST_PORT", "1883");
+
+  ret = nns_edge_mqtt_connect (edge_h, "temp-mqtt-topic");
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Close the mqtt handle with invalid param.
+ */
+TEST(edgeMqtt, closeInvalidParam_n)
+{
+  int ret = -1;
+
+  if (!_check_mqtt_broker ())
+    return;
+
+  ret = nns_edge_mqtt_close (NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Close the mqtt handle before the connection.
+ */
+TEST(edgeMqtt, closeInvalidParam2_n)
+{
+  int ret = -1;
+  nns_edge_h edge_h;
+
+  if (!_check_mqtt_broker ())
+    return;
+
+  ret = nns_edge_create_handle ("temp-server", NNS_EDGE_CONNECT_TYPE_HYBRID,
+      NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND | NNS_EDGE_FLAG_SERVER, &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_mqtt_close (edge_h);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Publish with invalid param.
+ */
+TEST(edgeMqtt, publishInvalidParam_n)
+{
+  int ret = -1;
+  const char *msg = "TEMP_MESSAGE";
+
+  if (!_check_mqtt_broker ())
+    return;
+
+  ret = nns_edge_mqtt_publish (NULL, msg, strlen (msg) + 1);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Publish with invalid param.
+ */
+TEST(edgeMqtt, publishInvalidParam2_n)
+{
+  int ret = -1;
+  nns_edge_h edge_h;
+  const char *msg = "TEMP_MESSAGE";
+
+  if (!_check_mqtt_broker ())
+    return;
+
+  ret = nns_edge_create_handle ("temp-server", NNS_EDGE_CONNECT_TYPE_HYBRID,
+      NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND | NNS_EDGE_FLAG_SERVER, &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  nns_edge_set_info (edge_h, "DEST_HOST", "tcp://localhost");
+  nns_edge_set_info (edge_h, "DEST_PORT", "1883");
+
+  ret = nns_edge_start (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  /* data is null */
+  ret = nns_edge_mqtt_publish (edge_h, NULL, strlen (msg) + 1);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Publish with invalid param.
+ */
+TEST(edgeMqtt, publishInvalidParam3_n)
+{
+  int ret = -1;
+  nns_edge_h edge_h;
+  const char *msg = "TEMP_MESSAGE";
+
+  if (!_check_mqtt_broker ())
+    return;
+
+  ret = nns_edge_create_handle ("temp-server", NNS_EDGE_CONNECT_TYPE_HYBRID,
+      NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND | NNS_EDGE_FLAG_SERVER, &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  nns_edge_set_info (edge_h, "DEST_HOST", "tcp://localhost");
+  nns_edge_set_info (edge_h, "DEST_PORT", "1883");
+
+  ret = nns_edge_start (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  /* data length is 0 */
+  ret = nns_edge_mqtt_publish (edge_h, msg, 0);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Publish the message without the connection.
+ */
+TEST(edgeMqtt, publishInvalidParam4_n)
+{
+  int ret = -1;
+  nns_edge_h edge_h;
+  const char *msg = "TEMP_MESSAGE";
+
+  if (!_check_mqtt_broker ())
+    return;
+
+  ret = nns_edge_create_handle ("temp-server", NNS_EDGE_CONNECT_TYPE_HYBRID,
+      NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND | NNS_EDGE_FLAG_SERVER, &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  nns_edge_set_info (edge_h, "DEST_HOST", "tcp://localhost");
+  nns_edge_set_info (edge_h, "DEST_PORT", "1883");
+
+  ret = nns_edge_mqtt_publish (edge_h, msg, strlen (msg) + 1);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Subscribe the topic with invalid param.
+ */
+TEST(edgeMqtt, subscribeInvalidParam_n)
+{
+  int ret = -1;
+
+  if (!_check_mqtt_broker ())
+    return;
+
+  ret = nns_edge_mqtt_subscribe (NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Subscribe the topic before the connection.
+ */
+TEST(edgeMqtt, subscribeInvalidParam2_n)
+{
+  int ret = -1;
+  nns_edge_h edge_h;
+
+  if (!_check_mqtt_broker ())
+    return;
+
+  ret = nns_edge_create_handle ("temp-server", NNS_EDGE_CONNECT_TYPE_HYBRID,
+      NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND | NNS_EDGE_FLAG_SERVER, &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_mqtt_subscribe (edge_h);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Get message with invalid param.
+ */
+TEST(edgeMqtt, getMessageInvalidParam_n)
+{
+  int ret = -1;
+  char *msg = NULL;
+
+  if (!_check_mqtt_broker ())
+    return;
+
+  ret = nns_edge_mqtt_get_message (NULL, &msg);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Get message with invalid param.
+ */
+TEST(edgeMqtt, getMessageInvalidParam2_n)
+{
+  int ret = -1;
+  nns_edge_h edge_h;
+
+  if (!_check_mqtt_broker ())
+    return;
+
+  ret = nns_edge_create_handle ("temp-server", NNS_EDGE_CONNECT_TYPE_HYBRID,
+      NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND | NNS_EDGE_FLAG_SERVER, &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  nns_edge_set_info (edge_h, "DEST_HOST", "tcp://localhost");
+  nns_edge_set_info (edge_h, "DEST_PORT", "1883");
+
+  ret = nns_edge_start (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_mqtt_get_message (edge_h, NULL);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+
+/**
+ * @brief Get message from empty message queue.
+ */
+TEST(edgeMqtt, getMessageWithinTimeout_n)
+{
+  int ret = -1;
+  nns_edge_h edge_h;
+  char *msg = NULL;
+
+  if (!_check_mqtt_broker ())
+    return;
+
+  ret = nns_edge_create_handle ("temp-server", NNS_EDGE_CONNECT_TYPE_HYBRID,
+      NNS_EDGE_FLAG_RECV | NNS_EDGE_FLAG_SEND | NNS_EDGE_FLAG_SERVER, &edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+  nns_edge_set_info (edge_h, "DEST_HOST", "tcp://localhost");
+  nns_edge_set_info (edge_h, "DEST_PORT", "1883");
+
+  ret = nns_edge_mqtt_connect (edge_h, "temp-mqtt-topic");
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_mqtt_get_message (edge_h, &msg);
+  EXPECT_NE (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_mqtt_close (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+
+  ret = nns_edge_release_handle (edge_h);
+  EXPECT_EQ (ret, NNS_EDGE_ERROR_NONE);
+}
+#endif /* ENABLE_MQTT */
+
+/**
+ * @brief Main gtest
+ */
+int
+main (int argc, char **argv)
+{
+  int result = -1;
+
+  try {
+    testing::InitGoogleTest (&argc, argv);
+  } catch (...) {
+    nns_edge_loge ("Catch exception, failed to init google test.");
+  }
+
+  try {
+    result = RUN_ALL_TESTS ();
+  } catch (...) {
+    nns_edge_loge ("Catch exception, failed to run the unittest.");
+  }
+
+  return result;
+}