diff --git a/include/cfl/cfl_kvlist.h b/include/cfl/cfl_kvlist.h
index 3f41bef..6c223de 100644
--- a/include/cfl/cfl_kvlist.h
+++ b/include/cfl/cfl_kvlist.h
@@ -76,8 +76,55 @@ int cfl_kvlist_count(struct cfl_kvlist *list);
 struct cfl_variant *cfl_kvlist_fetch(struct cfl_kvlist *list, char *key);
 int cfl_kvlist_print(FILE *fp, struct cfl_kvlist *list);
 
+int cfl_kvlist_insert_string_s(struct cfl_kvlist *list,
+                               char *key, size_t key_size,
+                               char *value, size_t value_size);
+
+int cfl_kvlist_insert_bytes_s(struct cfl_kvlist *list,
+                              char *key, size_t key_size,
+                              char *value,
+                              size_t value_length);
+
+int cfl_kvlist_insert_reference_s(struct cfl_kvlist *list,
+                                  char *key, size_t key_size,
+                                  void *value);
+
+int cfl_kvlist_insert_bool_s(struct cfl_kvlist *list,
+                             char *key, size_t key_size, int value);
+
+int cfl_kvlist_insert_int64_s(struct cfl_kvlist *list,
+                              char *key, size_t key_size,
+                              int64_t value);
+
+int cfl_kvlist_insert_uint64_s(struct cfl_kvlist *list,
+                               char *key, size_t key_size,
+                               uint64_t value);
+
+int cfl_kvlist_insert_double_s(struct cfl_kvlist *list,
+                               char *key, size_t key_size,
+                               double value);
+
+int cfl_kvlist_insert_array_s(struct cfl_kvlist *list,
+                              char *key, size_t key_size,
+                              struct cfl_array *value);
+
+int cfl_kvlist_insert_new_array_s(struct cfl_kvlist *list,
+                                  char *key, size_t key_size,
+                                  size_t size);
+
+int cfl_kvlist_insert_kvlist_s(struct cfl_kvlist *list,
+                               char *key, size_t key_size,
+                               struct cfl_kvlist *value);
+
+int cfl_kvlist_insert_s(struct cfl_kvlist *list,
+                        char *key, size_t key_size,
+                        struct cfl_variant *value);
+
+struct cfl_variant *cfl_kvlist_fetch_s(struct cfl_kvlist *list, char *key, size_t key_size);
+
 int cfl_kvlist_contains(struct cfl_kvlist *kvlist, char *name);
 int cfl_kvlist_remove(struct cfl_kvlist *kvlist, char *name);
 void cfl_kvpair_destroy(struct cfl_kvpair *pair);
 
+
 #endif
diff --git a/include/cfl/cfl_variant.h b/include/cfl/cfl_variant.h
index 893d1cd..e7135c9 100644
--- a/include/cfl/cfl_variant.h
+++ b/include/cfl/cfl_variant.h
@@ -54,9 +54,10 @@ struct cfl_variant {
         struct cfl_kvlist *as_kvlist;
     } data;
 };
+
 int cfl_variant_print(FILE *fp, struct cfl_variant *val);
 struct cfl_variant *cfl_variant_create_from_string(char *value);
-struct cfl_variant *cfl_variant_create_from_string_n(char *value, int len);
+struct cfl_variant *cfl_variant_create_from_string_s(char *value, size_t value_length);
 struct cfl_variant *cfl_variant_create_from_bytes(char *value, size_t length);
 struct cfl_variant *cfl_variant_create_from_bool(int value);
 struct cfl_variant *cfl_variant_create_from_int64(int64_t value);
diff --git a/src/cfl_kvlist.c b/src/cfl_kvlist.c
index 8f5f442..c07b659 100644
--- a/src/cfl_kvlist.c
+++ b/src/cfl_kvlist.c
@@ -99,18 +99,18 @@ int cfl_kvlist_insert(struct cfl_kvlist *list,
 }
 */
 
-int cfl_kvlist_insert_string(struct cfl_kvlist *list,
-                             char *key, char *value)
+int cfl_kvlist_insert_string_s(struct cfl_kvlist *list,
+                               char *key, size_t key_size, char *value, size_t value_size)
 {
     struct cfl_variant *value_instance;
     int                 result;
 
-    value_instance = cfl_variant_create_from_string(value);
+    value_instance = cfl_variant_create_from_string_s(value, value_size);
     if (value_instance == NULL) {
         return -1;
     }
 
-    result = cfl_kvlist_insert(list, key, value_instance);
+    result = cfl_kvlist_insert_s(list, key, key_size, value_instance);
     if (result) {
         cfl_variant_destroy(value_instance);
 
@@ -120,9 +120,10 @@ int cfl_kvlist_insert_string(struct cfl_kvlist *list,
     return 0;
 }
 
-int cfl_kvlist_insert_bytes(struct cfl_kvlist *list,
-                             char *key, char *value,
-                             size_t length)
+int cfl_kvlist_insert_bytes_s(struct cfl_kvlist *list,
+                              char *key, size_t key_size,
+                              char *value,
+                              size_t length)
 {
     struct cfl_variant *value_instance;
     int                 result;
@@ -133,7 +134,7 @@ int cfl_kvlist_insert_bytes(struct cfl_kvlist *list,
         return -1;
     }
 
-    result = cfl_kvlist_insert(list, key, value_instance);
+    result = cfl_kvlist_insert_s(list, key, key_size, value_instance);
 
     if (result) {
         cfl_variant_destroy(value_instance);
@@ -144,8 +145,8 @@ int cfl_kvlist_insert_bytes(struct cfl_kvlist *list,
     return 0;
 }
 
-int cfl_kvlist_insert_reference(struct cfl_kvlist *list,
-                                char *key, void *value)
+int cfl_kvlist_insert_reference_s(struct cfl_kvlist *list,
+                                  char *key, size_t key_size, void *value)
 {
     struct cfl_variant *value_instance;
     int                 result;
@@ -156,7 +157,7 @@ int cfl_kvlist_insert_reference(struct cfl_kvlist *list,
         return -1;
     }
 
-    result = cfl_kvlist_insert(list, key, value_instance);
+    result = cfl_kvlist_insert_s(list, key, key_size, value_instance);
 
     if (result) {
         cfl_variant_destroy(value_instance);
@@ -167,8 +168,8 @@ int cfl_kvlist_insert_reference(struct cfl_kvlist *list,
     return 0;
 }
 
-int cfl_kvlist_insert_bool(struct cfl_kvlist *list,
-                           char *key, int value)
+int cfl_kvlist_insert_bool_s(struct cfl_kvlist *list,
+                             char *key, size_t key_size, int value)
 {
     struct cfl_variant *value_instance;
     int                 result;
@@ -179,7 +180,7 @@ int cfl_kvlist_insert_bool(struct cfl_kvlist *list,
         return -1;
     }
 
-    result = cfl_kvlist_insert(list, key, value_instance);
+    result = cfl_kvlist_insert_s(list, key, key_size, value_instance);
 
     if (result) {
         cfl_variant_destroy(value_instance);
@@ -190,8 +191,8 @@ int cfl_kvlist_insert_bool(struct cfl_kvlist *list,
     return 0;
 }
 
-int cfl_kvlist_insert_int64(struct cfl_kvlist *list,
-                            char *key, int64_t value)
+int cfl_kvlist_insert_int64_s(struct cfl_kvlist *list,
+                              char *key, size_t key_size, int64_t value)
 {
     struct cfl_variant *value_instance;
     int                 result;
@@ -202,7 +203,7 @@ int cfl_kvlist_insert_int64(struct cfl_kvlist *list,
         return -1;
     }
 
-    result = cfl_kvlist_insert(list, key, value_instance);
+    result = cfl_kvlist_insert_s(list, key, key_size, value_instance);
 
     if (result) {
         cfl_variant_destroy(value_instance);
@@ -213,8 +214,8 @@ int cfl_kvlist_insert_int64(struct cfl_kvlist *list,
     return 0;
 }
 
-int cfl_kvlist_insert_uint64(struct cfl_kvlist *list,
-                            char *key, uint64_t value)
+int cfl_kvlist_insert_uint64_s(struct cfl_kvlist *list,
+                               char *key, size_t key_size, uint64_t value)
 {
     struct cfl_variant *value_instance;
     int                 result;
@@ -225,7 +226,7 @@ int cfl_kvlist_insert_uint64(struct cfl_kvlist *list,
         return -1;
     }
 
-    result = cfl_kvlist_insert(list, key, value_instance);
+    result = cfl_kvlist_insert_s(list, key, key_size, value_instance);
 
     if (result) {
         cfl_variant_destroy(value_instance);
@@ -236,8 +237,8 @@ int cfl_kvlist_insert_uint64(struct cfl_kvlist *list,
     return 0;
 }
 
-int cfl_kvlist_insert_double(struct cfl_kvlist *list,
-                             char *key, double value)
+int cfl_kvlist_insert_double_s(struct cfl_kvlist *list,
+                               char *key, size_t key_size, double value)
 {
     struct cfl_variant *value_instance;
     int                 result;
@@ -248,7 +249,7 @@ int cfl_kvlist_insert_double(struct cfl_kvlist *list,
         return -1;
     }
 
-    result = cfl_kvlist_insert(list, key, value_instance);
+    result = cfl_kvlist_insert_s(list, key, key_size, value_instance);
 
     if (result) {
         cfl_variant_destroy(value_instance);
@@ -259,8 +260,8 @@ int cfl_kvlist_insert_double(struct cfl_kvlist *list,
     return 0;
 }
 
-int cfl_kvlist_insert_array(struct cfl_kvlist *list,
-                            char *key, struct cfl_array *value)
+int cfl_kvlist_insert_array_s(struct cfl_kvlist *list,
+                              char *key, size_t key_size, struct cfl_array *value)
 {
     struct cfl_variant *value_instance;
     int                 result;
@@ -271,7 +272,7 @@ int cfl_kvlist_insert_array(struct cfl_kvlist *list,
         return -1;
     }
 
-    result = cfl_kvlist_insert(list, key, value_instance);
+    result = cfl_kvlist_insert_s(list, key, key_size, value_instance);
 
     if (result) {
         cfl_variant_destroy(value_instance);
@@ -282,8 +283,9 @@ int cfl_kvlist_insert_array(struct cfl_kvlist *list,
     return 0;
 }
 
-int cfl_kvlist_insert_new_array(struct cfl_kvlist *list,
-                                char *key, size_t size)
+
+int cfl_kvlist_insert_new_array_s(struct cfl_kvlist *list,
+                                  char *key, size_t key_size, size_t size)
 {
     int               result;
     struct cfl_array *value;
@@ -294,7 +296,7 @@ int cfl_kvlist_insert_new_array(struct cfl_kvlist *list,
         return -1;
     }
 
-    result = cfl_kvlist_insert_array(list, key, value);
+    result = cfl_kvlist_insert_array_s(list, key, key_size, value);
 
     if (result) {
         cfl_array_destroy(value);
@@ -303,8 +305,8 @@ int cfl_kvlist_insert_new_array(struct cfl_kvlist *list,
     return result;
 }
 
-int cfl_kvlist_insert_kvlist(struct cfl_kvlist *list,
-                             char *key, struct cfl_kvlist *value)
+int cfl_kvlist_insert_kvlist_s(struct cfl_kvlist *list,
+                               char *key, size_t key_size, struct cfl_kvlist *value)
 {
     struct cfl_variant *value_instance;
     int                 result;
@@ -314,7 +316,7 @@ int cfl_kvlist_insert_kvlist(struct cfl_kvlist *list,
         return -1;
     }
 
-    result = cfl_kvlist_insert(list, key, value_instance);
+    result = cfl_kvlist_insert_s(list, key, key_size, value_instance);
 
     if (result) {
         cfl_variant_destroy(value_instance);
@@ -325,12 +327,13 @@ int cfl_kvlist_insert_kvlist(struct cfl_kvlist *list,
     return 0;
 }
 
-int cfl_kvlist_insert(struct cfl_kvlist *list,
-                      char *key, struct cfl_variant *value)
+int cfl_kvlist_insert_s(struct cfl_kvlist *list,
+                        char *key, size_t key_size,
+                        struct cfl_variant *value)
 {
     struct cfl_kvpair *pair;
 
-    if (!key) {
+    if (list == NULL || key == NULL || value == NULL) {
         return -1;
     }
 
@@ -340,7 +343,7 @@ int cfl_kvlist_insert(struct cfl_kvlist *list,
         return -1;
     }
 
-    pair->key = cfl_sds_create(key);
+    pair->key = cfl_sds_create_len(key, key_size);
     if (pair->key == NULL) {
         free(pair);
 
@@ -353,27 +356,19 @@ int cfl_kvlist_insert(struct cfl_kvlist *list,
     return 0;
 }
 
-int cfl_kvlist_count(struct cfl_kvlist *list)
-{
-    return cfl_list_size(&list->list);
-}
-
-struct cfl_variant *cfl_kvlist_fetch(struct cfl_kvlist *list, char *key)
+struct cfl_variant *cfl_kvlist_fetch_s(struct cfl_kvlist *list, char *key, size_t key_size)
 {
-    int len;
     struct cfl_list *head;
     struct cfl_kvpair *pair;
 
-    len = strlen(key);
-
     cfl_list_foreach(head, &list->list) {
         pair = cfl_list_entry(head, struct cfl_kvpair, _head);
 
-        if (cfl_sds_len(pair->key) != len) {
+        if (cfl_sds_len(pair->key) != key_size) {
             continue;
         }
 
-        if (strcmp(pair->key, key) == 0) {
+        if (strncmp(pair->key, key, key_size) == 0) {
             return pair->val;
         }
     }
@@ -381,6 +376,84 @@ struct cfl_variant *cfl_kvlist_fetch(struct cfl_kvlist *list, char *key)
     return NULL;
 }
 
+
+int cfl_kvlist_insert_string(struct cfl_kvlist *list,
+                             char *key, char *value)
+{
+    return cfl_kvlist_insert_string_s(list, key, strlen(key), value, strlen(value));
+}
+
+int cfl_kvlist_insert_bytes(struct cfl_kvlist *list,
+                             char *key, char *value,
+                             size_t length)
+{
+    return cfl_kvlist_insert_bytes_s(list, key, strlen(key), value, length);
+}
+
+int cfl_kvlist_insert_reference(struct cfl_kvlist *list,
+                                char *key, void *value)
+{
+    return cfl_kvlist_insert_reference_s(list, key, strlen(key), value);
+}
+
+int cfl_kvlist_insert_bool(struct cfl_kvlist *list,
+                           char *key, int value)
+{
+    return cfl_kvlist_insert_bool_s(list, key, strlen(key), value);
+}
+
+int cfl_kvlist_insert_int64(struct cfl_kvlist *list,
+                            char *key, int64_t value)
+{
+    return cfl_kvlist_insert_int64_s(list, key, strlen(key), value);
+}
+
+int cfl_kvlist_insert_uint64(struct cfl_kvlist *list,
+                            char *key, uint64_t value)
+{
+    return cfl_kvlist_insert_uint64_s(list, key, strlen(key), value);
+}
+
+int cfl_kvlist_insert_double(struct cfl_kvlist *list,
+                             char *key, double value)
+{
+    return cfl_kvlist_insert_double_s(list, key, strlen(key), value);
+}
+
+int cfl_kvlist_insert_array(struct cfl_kvlist *list,
+                            char *key, struct cfl_array *value)
+{
+    return cfl_kvlist_insert_array_s(list, key, strlen(key), value);
+}
+
+int cfl_kvlist_insert_new_array(struct cfl_kvlist *list,
+                                char *key, size_t size)
+{
+    return cfl_kvlist_insert_new_array_s(list, key, strlen(key), size);
+}
+
+int cfl_kvlist_insert_kvlist(struct cfl_kvlist *list,
+                             char *key, struct cfl_kvlist *value)
+{
+    return cfl_kvlist_insert_kvlist_s(list, key, strlen(key), value);
+}
+
+int cfl_kvlist_insert(struct cfl_kvlist *list,
+                      char *key, struct cfl_variant *value)
+{
+    return cfl_kvlist_insert_s(list, key, strlen(key), value);
+}
+
+struct cfl_variant *cfl_kvlist_fetch(struct cfl_kvlist *list, char *key)
+{
+    return cfl_kvlist_fetch_s(list, key, strlen(key));
+}
+
+int cfl_kvlist_count(struct cfl_kvlist *list)
+{
+    return cfl_list_size(&list->list);
+}
+
 int cfl_kvlist_print(FILE *fp, struct cfl_kvlist *list)
 {
     size_t size;
diff --git a/src/cfl_variant.c b/src/cfl_variant.c
index f38ae1f..5f6748c 100644
--- a/src/cfl_variant.c
+++ b/src/cfl_variant.c
@@ -87,14 +87,14 @@ int cfl_variant_print(FILE *fp, struct cfl_variant *val)
     return ret;
 }
 
-struct cfl_variant *cfl_variant_create_from_string_n(char *value, int len)
+struct cfl_variant *cfl_variant_create_from_string_s(char *value, size_t value_size)
 {
     struct cfl_variant *instance;
 
     instance = cfl_variant_create();
 
     if (instance != NULL) {
-        instance->data.as_string = cfl_sds_create_len(value, len);
+        instance->data.as_string = cfl_sds_create_len(value, value_size);
         if (instance->data.as_string == NULL) {
             free(instance);
             instance = NULL;
@@ -109,10 +109,7 @@ struct cfl_variant *cfl_variant_create_from_string_n(char *value, int len)
 
 struct cfl_variant *cfl_variant_create_from_string(char *value)
 {
-    int len;
-
-    len = strlen(value);
-    return cfl_variant_create_from_string_n(value, len);
+    return cfl_variant_create_from_string_s(value, strlen(value));
 }
 
 struct cfl_variant *cfl_variant_create_from_bytes(char *value, size_t length)
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index b1ec14c..6691cac 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -2,6 +2,7 @@ include_directories(lib/acutest)
 
 set(UNIT_TESTS_FILES
   kv.c
+  kvlist.c
   sds.c
   hash.c
   list.c
diff --git a/tests/kvlist.c b/tests/kvlist.c
index 117ccd1..621f596 100644
--- a/tests/kvlist.c
+++ b/tests/kvlist.c
@@ -18,8 +18,1036 @@
  */
 
 #include <cfl/cfl.h>
+
+#include <float.h>
+#include <math.h>
+
 #include "cfl_tests_internal.h"
 
+static void create_destroy()
+{
+    struct cfl_kvlist *list = NULL;
+
+    list = cfl_kvlist_create();
+    if (!TEST_CHECK(list != NULL)) {
+        TEST_MSG("cfl_kvlist_create failed");
+        return;
+    }
+    cfl_kvlist_destroy(list);
+}
+
+static void count()
+{
+    struct cfl_kvlist *list = NULL;
+    int i;
+    int count = 12;
+    int ret;
+    char buf[128] = {0};
+
+    list = cfl_kvlist_create();
+    if (!TEST_CHECK(list != NULL)) {
+        TEST_MSG("cfl_kvlist_create failed");
+        return;
+    }
+
+    for (i=0; i<count; i++) {
+        memset(&buf[0], 0, sizeof(buf));
+        snprintf(&buf[0], sizeof(buf), "%d", i);
+        ret = cfl_kvlist_insert_int64(list, &buf[0], i);
+        if (!TEST_CHECK(ret == 0)) {
+            TEST_MSG("%d: cfl_kvlist_insert_int64 failed", i);
+            cfl_kvlist_destroy(list);
+            return;
+        }
+    }
+
+    ret = cfl_kvlist_count(list);
+    if (!TEST_CHECK(ret == count)) {
+        TEST_MSG("cfl_list_size failed. got=%d expect=%d", i, count);
+    }
+
+    cfl_kvlist_destroy(list);
+}
+
+static void fetch()
+{
+    int ret;
+    struct cfl_variant *var = NULL;
+    struct cfl_kvlist *list = NULL;
+
+    list = cfl_kvlist_create();
+    if (!TEST_CHECK(list != NULL)) {
+        TEST_MSG("cfl_kvlist_create failed");
+        return;
+    }
+
+    ret = cfl_kvlist_insert_int64(list, "key", 128);
+    if (!TEST_CHECK(ret == 0)) {
+        TEST_MSG("cfl_kvlist_insert_int64 failed");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    /* invalid key name 'k' */
+    var = cfl_kvlist_fetch(list, "k");
+    if (!TEST_CHECK(var == NULL)) {
+        TEST_MSG("cfl_kvlist_fetch returned invalid pointer");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    /* invalid key name 'key_is_invalid' */
+    var = cfl_kvlist_fetch(list, "key_is_invalid");
+    if (!TEST_CHECK(var == NULL)) {
+        TEST_MSG("cfl_kvlist_fetch returned invalid pointer");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    var = cfl_kvlist_fetch(list, "key");
+    if (!TEST_CHECK(var != NULL)) {
+        TEST_MSG("cfl_kvlist_fetch returned NULL");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->type == CFL_VARIANT_INT)) {
+        TEST_MSG("variant type is not int. ret=%d", var->type);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->data.as_int64 == 128)) {
+        TEST_MSG("variant value error.got=%"PRId64" expect=128", var->data.as_int64);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    cfl_kvlist_destroy(list);
+}
+
+static void fetch_s()
+{
+    int ret;
+    struct cfl_variant *var = NULL;
+    struct cfl_kvlist *list = NULL;
+
+    list = cfl_kvlist_create();
+    if (!TEST_CHECK(list != NULL)) {
+        TEST_MSG("cfl_kvlist_create failed");
+        return;
+    }
+
+    ret = cfl_kvlist_insert_int64(list, "key", 128);
+    if (!TEST_CHECK(ret == 0)) {
+        TEST_MSG("cfl_kvlist_insert_int64 failed");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    /* invalid key name 'k' */
+    var = cfl_kvlist_fetch(list, "k");
+    if (!TEST_CHECK(var == NULL)) {
+        TEST_MSG("cfl_kvlist_fetch returned invalid pointer");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    /* invalid key name 'key_is_invalid' */
+    var = cfl_kvlist_fetch(list, "key_is_invalid");
+    if (!TEST_CHECK(var == NULL)) {
+        TEST_MSG("cfl_kvlist_fetch returned invalid pointer");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    var = cfl_kvlist_fetch_s(list, "key_is_long_name", 3);
+    if (!TEST_CHECK(var != NULL)) {
+        TEST_MSG("cfl_kvlist_fetch returned NULL");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->type == CFL_VARIANT_INT)) {
+        TEST_MSG("variant type is not int. ret=%d", var->type);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->data.as_int64 == 128)) {
+        TEST_MSG("variant value error.got=%"PRId64" expect=128", var->data.as_int64);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    cfl_kvlist_destroy(list);
+}
+
+static void insert_string()
+{
+    int ret;
+    int expect_type = CFL_VARIANT_STRING;
+    struct cfl_variant *var = NULL;
+    struct cfl_kvlist *list = NULL;
+
+    list = cfl_kvlist_create();
+    if (!TEST_CHECK(list != NULL)) {
+        TEST_MSG("cfl_kvlist_create failed");
+        return;
+    }
+
+    ret = cfl_kvlist_insert_string(list, "key", "value");
+    if (!TEST_CHECK(ret == 0)) {
+        TEST_MSG("cfl_kvlist_insert_string failed");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    var = cfl_kvlist_fetch(list, "key");
+    if (!TEST_CHECK(var != NULL)) {
+        TEST_MSG("cfl_kvlist_fetch returned NULL");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->type == expect_type)) {
+        TEST_MSG("variant type error. got=%d expect=%d", var->type, expect_type);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(strncmp("value", var->data.as_string,5) == 0)) {
+        TEST_MSG("variant value error.got=%s expect=value", var->data.as_string);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    cfl_kvlist_destroy(list);
+}
+
+static void insert_bytes()
+{
+    int ret;
+    int expect_type = CFL_VARIANT_BYTES;
+    struct cfl_variant *var = NULL;
+    struct cfl_kvlist *list = NULL;
+
+    list = cfl_kvlist_create();
+    if (!TEST_CHECK(list != NULL)) {
+        TEST_MSG("cfl_kvlist_create failed");
+        return;
+    }
+
+    ret = cfl_kvlist_insert_bytes(list, "key", "value", 5);
+    if (!TEST_CHECK(ret == 0)) {
+        TEST_MSG("cfl_kvlist_insert_bytes failed");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    var = cfl_kvlist_fetch(list, "key");
+    if (!TEST_CHECK(var != NULL)) {
+        TEST_MSG("cfl_kvlist_fetch returned NULL");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->type == expect_type)) {
+        TEST_MSG("variant type error. got=%d expect=%d", var->type, expect_type);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(memcmp("value", var->data.as_bytes,5) == 0)) {
+        TEST_MSG("variant value error.got=%s expect=value", var->data.as_bytes);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    cfl_kvlist_destroy(list);
+}
+
+static void insert_reference()
+{
+    int ret;
+    int expect_type = CFL_VARIANT_REFERENCE;
+    struct cfl_variant *var = NULL;
+    struct cfl_kvlist *list = NULL;
+
+    list = cfl_kvlist_create();
+    if (!TEST_CHECK(list != NULL)) {
+        TEST_MSG("cfl_kvlist_create failed");
+        return;
+    }
+
+    ret = cfl_kvlist_insert_reference(list, "key", &expect_type);
+    if (!TEST_CHECK(ret == 0)) {
+        TEST_MSG("cfl_kvlist_insert_reference failed");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    var = cfl_kvlist_fetch(list, "key");
+    if (!TEST_CHECK(var != NULL)) {
+        TEST_MSG("cfl_kvlist_fetch returned NULL");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->type == expect_type)) {
+        TEST_MSG("variant type error. got=%d expect=%d", var->type, expect_type);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->data.as_reference == &expect_type) == 0) {
+        TEST_MSG("variant value error.got=%p expect=%p", var->data.as_reference, &expect_type);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    cfl_kvlist_destroy(list);
+}
+
+static void insert_bool()
+{
+    int ret;
+    int expect_type = CFL_VARIANT_BOOL;
+    struct cfl_variant *var = NULL;
+    struct cfl_kvlist *list = NULL;
+
+    list = cfl_kvlist_create();
+    if (!TEST_CHECK(list != NULL)) {
+        TEST_MSG("cfl_kvlist_create failed");
+        return;
+    }
+
+    ret = cfl_kvlist_insert_bool(list, "key", CFL_TRUE);
+    if (!TEST_CHECK(ret == 0)) {
+        TEST_MSG("cfl_kvlist_insert_bool failed");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    var = cfl_kvlist_fetch(list, "key");
+    if (!TEST_CHECK(var != NULL)) {
+        TEST_MSG("cfl_kvlist_fetch returned NULL");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->type == expect_type)) {
+        TEST_MSG("variant type error. got=%d expect=%d", var->type, expect_type);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->data.as_bool == CFL_TRUE)) {
+        TEST_MSG("variant value error.got=%d expect=%d", var->data.as_bool, CFL_TRUE);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    cfl_kvlist_destroy(list);
+}
+
+static void insert_int64()
+{
+    int ret;
+    int expect_type = CFL_VARIANT_INT;
+    struct cfl_variant *var = NULL;
+    struct cfl_kvlist *list = NULL;
+
+    list = cfl_kvlist_create();
+    if (!TEST_CHECK(list != NULL)) {
+        TEST_MSG("cfl_kvlist_create failed");
+        return;
+    }
+
+    ret = cfl_kvlist_insert_int64(list, "key", -123456);
+    if (!TEST_CHECK(ret == 0)) {
+        TEST_MSG("cfl_kvlist_insert_int64 failed");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    var = cfl_kvlist_fetch(list, "key");
+    if (!TEST_CHECK(var != NULL)) {
+        TEST_MSG("cfl_kvlist_fetch returned NULL");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->type == expect_type)) {
+        TEST_MSG("variant type error. got=%d expect=%d", var->type, expect_type);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->data.as_int64 == -123456)) {
+        TEST_MSG("variant value error.got=%"PRId64" expect=-123456", var->data.as_int64);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    cfl_kvlist_destroy(list);
+}
+
+static void insert_uint64()
+{
+    int ret;
+    int expect_type = CFL_VARIANT_UINT;
+    struct cfl_variant *var = NULL;
+    struct cfl_kvlist *list = NULL;
+
+    list = cfl_kvlist_create();
+    if (!TEST_CHECK(list != NULL)) {
+        TEST_MSG("cfl_kvlist_create failed");
+        return;
+    }
+
+    ret = cfl_kvlist_insert_uint64(list, "key", 123456);
+    if (!TEST_CHECK(ret == 0)) {
+        TEST_MSG("cfl_kvlist_insert_uint64 failed");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    var = cfl_kvlist_fetch(list, "key");
+    if (!TEST_CHECK(var != NULL)) {
+        TEST_MSG("cfl_kvlist_fetch returned NULL");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->type == expect_type)) {
+        TEST_MSG("variant type error. got=%d expect=%d", var->type, expect_type);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->data.as_uint64 == 123456)) {
+        TEST_MSG("variant value error.got=%"PRIu64" expect=123456", var->data.as_uint64);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    cfl_kvlist_destroy(list);
+}
+
+static void insert_double()
+{
+    int ret;
+    double input = 123456.789;
+    int expect_type = CFL_VARIANT_DOUBLE;
+    struct cfl_variant *var = NULL;
+    struct cfl_kvlist *list = NULL;
+
+    list = cfl_kvlist_create();
+    if (!TEST_CHECK(list != NULL)) {
+        TEST_MSG("cfl_kvlist_create failed");
+        return;
+    }
+
+    ret = cfl_kvlist_insert_double(list, "key", input);
+    if (!TEST_CHECK(ret == 0)) {
+        TEST_MSG("cfl_kvlist_insert_double failed");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    var = cfl_kvlist_fetch(list, "key");
+    if (!TEST_CHECK(var != NULL)) {
+        TEST_MSG("cfl_kvlist_fetch returned NULL");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->type == expect_type)) {
+        TEST_MSG("variant type error. got=%d expect=%d", var->type, expect_type);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(fabs(var->data.as_double - input) < DBL_EPSILON)) {
+        TEST_MSG("variant value error.got=%lf expect=%lf", var->data.as_double, input);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    cfl_kvlist_destroy(list);
+}
+
+static void insert_new_array()
+{
+    int ret;
+    int expect_type = CFL_VARIANT_ARRAY;
+    struct cfl_variant *var = NULL;
+    struct cfl_kvlist *list = NULL;
+
+    list = cfl_kvlist_create();
+    if (!TEST_CHECK(list != NULL)) {
+        TEST_MSG("cfl_kvlist_create failed");
+        return;
+    }
+
+    ret = cfl_kvlist_insert_new_array(list, "key", 123);
+    if (!TEST_CHECK(ret == 0)) {
+        TEST_MSG("cfl_kvlist_insert_new_array failed");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    var = cfl_kvlist_fetch(list, "key");
+    if (!TEST_CHECK(var != NULL)) {
+        TEST_MSG("cfl_kvlist_fetch returned NULL");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->type == expect_type)) {
+        TEST_MSG("variant type error. got=%d expect=%d", var->type, expect_type);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->data.as_array->slot_count == 123)) {
+        TEST_MSG("variant value error.got=%d expect=123", var->data.as_array->slot_count);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    cfl_kvlist_destroy(list);
+}
+
+static void insert_empty_array()
+{
+    int ret;
+    int expect_type = CFL_VARIANT_ARRAY;
+    struct cfl_array *input = NULL;
+    struct cfl_variant *var = NULL;
+    struct cfl_kvlist *list = NULL;
+
+    list = cfl_kvlist_create();
+    if (!TEST_CHECK(list != NULL)) {
+        TEST_MSG("cfl_kvlist_create failed");
+        return;
+    }
+
+    input = cfl_array_create(123);
+    if (!TEST_CHECK(input != NULL)) {
+        TEST_MSG("cfl_array_create failed");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    ret = cfl_kvlist_insert_array(list, "key", input);
+    if (!TEST_CHECK(ret == 0)) {
+        TEST_MSG("cfl_kvlist_insert_array failed");
+        cfl_kvlist_destroy(list);
+        cfl_array_destroy(input);
+        return;
+    }
+
+    var = cfl_kvlist_fetch(list, "key");
+    if (!TEST_CHECK(var != NULL)) {
+        TEST_MSG("cfl_kvlist_fetch returned NULL");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->type == expect_type)) {
+        TEST_MSG("variant type error. got=%d expect=%d", var->type, expect_type);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->data.as_array->slot_count == 123)) {
+        TEST_MSG("variant value error.got=%d expect=123", var->data.as_array->slot_count);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    cfl_kvlist_destroy(list);
+}
+
+static void insert_empty_kvlist()
+{
+    int ret;
+    int expect_type = CFL_VARIANT_KVLIST;
+    struct cfl_kvlist *input = NULL;
+    struct cfl_variant *var = NULL;
+    struct cfl_kvlist *list = NULL;
+
+    list = cfl_kvlist_create();
+    if (!TEST_CHECK(list != NULL)) {
+        TEST_MSG("cfl_kvlist_create failed");
+        return;
+    }
+
+    input = cfl_kvlist_create();
+    if (!TEST_CHECK(input != NULL)) {
+        TEST_MSG("cfl_kvlist_create failed");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    ret = cfl_kvlist_insert_kvlist(list, "key", input);
+    if (!TEST_CHECK(ret == 0)) {
+        TEST_MSG("cfl_kvlist_insert_kvlist failed");
+        cfl_kvlist_destroy(list);
+        cfl_kvlist_destroy(input);
+        return;
+    }
+
+    var = cfl_kvlist_fetch(list, "key");
+    if (!TEST_CHECK(var != NULL)) {
+        TEST_MSG("cfl_kvlist_fetch returned NULL");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->type == expect_type)) {
+        TEST_MSG("variant type error. got=%d expect=%d", var->type, expect_type);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    cfl_kvlist_destroy(list);
+}
+
+static void insert_string_s()
+{
+    int ret;
+    int expect_type = CFL_VARIANT_STRING;
+    struct cfl_variant *var = NULL;
+    struct cfl_kvlist *list = NULL;
+
+    list = cfl_kvlist_create();
+    if (!TEST_CHECK(list != NULL)) {
+        TEST_MSG("cfl_kvlist_create failed");
+        return;
+    }
+
+    ret = cfl_kvlist_insert_string_s(list, "key!!!!!", 3, "value", 5);
+    if (!TEST_CHECK(ret == 0)) {
+        TEST_MSG("cfl_kvlist_insert_string_s failed");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    var = cfl_kvlist_fetch_s(list, "key?????", 3);
+    if (!TEST_CHECK(var != NULL)) {
+        TEST_MSG("cfl_kvlist_fetch returned NULL");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->type == expect_type)) {
+        TEST_MSG("variant type error. got=%d expect=%d", var->type, expect_type);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(strncmp("value", var->data.as_string,5) == 0)) {
+        TEST_MSG("variant value error.got=%s expect=value", var->data.as_string);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    cfl_kvlist_destroy(list);
+}
+
+static void insert_bytes_s()
+{
+    int ret;
+    int expect_type = CFL_VARIANT_BYTES;
+    struct cfl_variant *var = NULL;
+    struct cfl_kvlist *list = NULL;
+
+    list = cfl_kvlist_create();
+    if (!TEST_CHECK(list != NULL)) {
+        TEST_MSG("cfl_kvlist_create failed");
+        return;
+    }
+
+    ret = cfl_kvlist_insert_bytes_s(list, "key!!!!!", 3, "value", 5);
+    if (!TEST_CHECK(ret == 0)) {
+        TEST_MSG("cfl_kvlist_insert_bytes_s failed");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    var = cfl_kvlist_fetch_s(list, "key??????????????", 3);
+    if (!TEST_CHECK(var != NULL)) {
+        TEST_MSG("cfl_kvlist_fetch returned NULL");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->type == expect_type)) {
+        TEST_MSG("variant type error. got=%d expect=%d", var->type, expect_type);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(memcmp("value", var->data.as_bytes,5) == 0)) {
+        TEST_MSG("variant value error.got=%s expect=value", var->data.as_bytes);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    cfl_kvlist_destroy(list);
+}
+
+static void insert_reference_s()
+{
+    int ret;
+    int expect_type = CFL_VARIANT_REFERENCE;
+    struct cfl_variant *var = NULL;
+    struct cfl_kvlist *list = NULL;
+
+    list = cfl_kvlist_create();
+    if (!TEST_CHECK(list != NULL)) {
+        TEST_MSG("cfl_kvlist_create failed");
+        return;
+    }
+
+    ret = cfl_kvlist_insert_reference_s(list, "key!!!", 3, &expect_type);
+    if (!TEST_CHECK(ret == 0)) {
+        TEST_MSG("cfl_kvlist_insert_reference_s failed");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    var = cfl_kvlist_fetch_s(list, "key????", 3);
+    if (!TEST_CHECK(var != NULL)) {
+        TEST_MSG("cfl_kvlist_fetch returned NULL");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->type == expect_type)) {
+        TEST_MSG("variant type error. got=%d expect=%d", var->type, expect_type);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->data.as_reference == &expect_type) == 0) {
+        TEST_MSG("variant value error.got=%p expect=%p", var->data.as_reference, &expect_type);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    cfl_kvlist_destroy(list);
+}
+
+static void insert_bool_s()
+{
+    int ret;
+    int expect_type = CFL_VARIANT_BOOL;
+    struct cfl_variant *var = NULL;
+    struct cfl_kvlist *list = NULL;
+
+    list = cfl_kvlist_create();
+    if (!TEST_CHECK(list != NULL)) {
+        TEST_MSG("cfl_kvlist_create failed");
+        return;
+    }
+
+    ret = cfl_kvlist_insert_bool_s(list, "key!!!!", 3, CFL_TRUE);
+    if (!TEST_CHECK(ret == 0)) {
+        TEST_MSG("cfl_kvlist_insert_bool_s failed");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    var = cfl_kvlist_fetch_s(list, "key???", 3);
+    if (!TEST_CHECK(var != NULL)) {
+        TEST_MSG("cfl_kvlist_fetch returned NULL");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->type == expect_type)) {
+        TEST_MSG("variant type error. got=%d expect=%d", var->type, expect_type);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->data.as_bool == CFL_TRUE)) {
+        TEST_MSG("variant value error.got=%d expect=%d", var->data.as_bool, CFL_TRUE);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    cfl_kvlist_destroy(list);
+}
+
+static void insert_int64_s()
+{
+    int ret;
+    int expect_type = CFL_VARIANT_INT;
+    struct cfl_variant *var = NULL;
+    struct cfl_kvlist *list = NULL;
+
+    list = cfl_kvlist_create();
+    if (!TEST_CHECK(list != NULL)) {
+        TEST_MSG("cfl_kvlist_create failed");
+        return;
+    }
+
+    ret = cfl_kvlist_insert_int64_s(list, "key!!!!", 3, -123456);
+    if (!TEST_CHECK(ret == 0)) {
+        TEST_MSG("cfl_kvlist_insert_int64_s failed");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    var = cfl_kvlist_fetch_s(list, "key??", 3);
+    if (!TEST_CHECK(var != NULL)) {
+        TEST_MSG("cfl_kvlist_fetch returned NULL");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->type == expect_type)) {
+        TEST_MSG("variant type error. got=%d expect=%d", var->type, expect_type);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->data.as_int64 == -123456)) {
+        TEST_MSG("variant value error.got=%"PRId64" expect=-123456", var->data.as_int64);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    cfl_kvlist_destroy(list);
+}
+
+static void insert_uint64_s()
+{
+    int ret;
+    int expect_type = CFL_VARIANT_UINT;
+    struct cfl_variant *var = NULL;
+    struct cfl_kvlist *list = NULL;
+
+    list = cfl_kvlist_create();
+    if (!TEST_CHECK(list != NULL)) {
+        TEST_MSG("cfl_kvlist_create failed");
+        return;
+    }
+
+    ret = cfl_kvlist_insert_uint64_s(list, "key???", 3, 123456);
+    if (!TEST_CHECK(ret == 0)) {
+        TEST_MSG("cfl_kvlist_insert_uint64_s failed");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    var = cfl_kvlist_fetch_s(list, "key!!!", 3);
+    if (!TEST_CHECK(var != NULL)) {
+        TEST_MSG("cfl_kvlist_fetch returned NULL");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->type == expect_type)) {
+        TEST_MSG("variant type error. got=%d expect=%d", var->type, expect_type);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->data.as_uint64 == 123456)) {
+        TEST_MSG("variant value error.got=%"PRIu64" expect=123456", var->data.as_uint64);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    cfl_kvlist_destroy(list);
+}
+
+static void insert_double_s()
+{
+    int ret;
+    double input = 123456.789;
+    int expect_type = CFL_VARIANT_DOUBLE;
+    struct cfl_variant *var = NULL;
+    struct cfl_kvlist *list = NULL;
+
+    list = cfl_kvlist_create();
+    if (!TEST_CHECK(list != NULL)) {
+        TEST_MSG("cfl_kvlist_create failed");
+        return;
+    }
+
+    ret = cfl_kvlist_insert_double_s(list, "key????", 3, input);
+    if (!TEST_CHECK(ret == 0)) {
+        TEST_MSG("cfl_kvlist_insert_double_s failed");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    var = cfl_kvlist_fetch_s(list, "key!!!", 3);
+    if (!TEST_CHECK(var != NULL)) {
+        TEST_MSG("cfl_kvlist_fetch returned NULL");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->type == expect_type)) {
+        TEST_MSG("variant type error. got=%d expect=%d", var->type, expect_type);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(fabs(var->data.as_double - input) < DBL_EPSILON)) {
+        TEST_MSG("variant value error.got=%lf expect=%lf", var->data.as_double, input);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    cfl_kvlist_destroy(list);
+}
+
+static void insert_new_array_s()
+{
+    int ret;
+    int expect_type = CFL_VARIANT_ARRAY;
+    struct cfl_variant *var = NULL;
+    struct cfl_kvlist *list = NULL;
+
+    list = cfl_kvlist_create();
+    if (!TEST_CHECK(list != NULL)) {
+        TEST_MSG("cfl_kvlist_create failed");
+        return;
+    }
+
+    ret = cfl_kvlist_insert_new_array_s(list, "key???", 3, 123);
+    if (!TEST_CHECK(ret == 0)) {
+        TEST_MSG("cfl_kvlist_insert_new_array_s failed");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    var = cfl_kvlist_fetch_s(list, "key!!!!!", 3);
+    if (!TEST_CHECK(var != NULL)) {
+        TEST_MSG("cfl_kvlist_fetch returned NULL");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->type == expect_type)) {
+        TEST_MSG("variant type error. got=%d expect=%d", var->type, expect_type);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->data.as_array->slot_count == 123)) {
+        TEST_MSG("variant value error.got=%d expect=123", var->data.as_array->slot_count);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    cfl_kvlist_destroy(list);
+}
+
+static void insert_empty_array_s()
+{
+    int ret;
+    int expect_type = CFL_VARIANT_ARRAY;
+    struct cfl_array *input = NULL;
+    struct cfl_variant *var = NULL;
+    struct cfl_kvlist *list = NULL;
+
+    list = cfl_kvlist_create();
+    if (!TEST_CHECK(list != NULL)) {
+        TEST_MSG("cfl_kvlist_create failed");
+        return;
+    }
+
+    input = cfl_array_create(123);
+    if (!TEST_CHECK(input != NULL)) {
+        TEST_MSG("cfl_array_create failed");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    ret = cfl_kvlist_insert_array_s(list, "key!!!", 3, input);
+    if (!TEST_CHECK(ret == 0)) {
+        TEST_MSG("cfl_kvlist_insert_array_s failed");
+        cfl_kvlist_destroy(list);
+        cfl_array_destroy(input);
+        return;
+    }
+
+    var = cfl_kvlist_fetch_s(list, "key??????", 3);
+    if (!TEST_CHECK(var != NULL)) {
+        TEST_MSG("cfl_kvlist_fetch returned NULL");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->type == expect_type)) {
+        TEST_MSG("variant type error. got=%d expect=%d", var->type, expect_type);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->data.as_array->slot_count == 123)) {
+        TEST_MSG("variant value error.got=%d expect=123", var->data.as_array->slot_count);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    cfl_kvlist_destroy(list);
+}
+
+static void insert_empty_kvlist_s()
+{
+    int ret;
+    int expect_type = CFL_VARIANT_KVLIST;
+    struct cfl_kvlist *input = NULL;
+    struct cfl_variant *var = NULL;
+    struct cfl_kvlist *list = NULL;
+
+    list = cfl_kvlist_create();
+    if (!TEST_CHECK(list != NULL)) {
+        TEST_MSG("cfl_kvlist_create failed");
+        return;
+    }
+
+    input = cfl_kvlist_create();
+    if (!TEST_CHECK(input != NULL)) {
+        TEST_MSG("cfl_kvlist_create failed");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    ret = cfl_kvlist_insert_kvlist_s(list, "key????", 3, input);
+    if (!TEST_CHECK(ret == 0)) {
+        TEST_MSG("cfl_kvlist_insert_kvlist_s failed");
+        cfl_kvlist_destroy(list);
+        cfl_kvlist_destroy(input);
+        return;
+    }
+
+    var = cfl_kvlist_fetch_s(list, "key!", 3);
+    if (!TEST_CHECK(var != NULL)) {
+        TEST_MSG("cfl_kvlist_fetch returned NULL");
+        cfl_kvlist_destroy(list);
+        return;
+    }
+
+    if (!TEST_CHECK(var->type == expect_type)) {
+        TEST_MSG("variant type error. got=%d expect=%d", var->type, expect_type);
+        cfl_kvlist_destroy(list);
+        return;
+    }
+    cfl_kvlist_destroy(list);
+}
+
 static void test_basics()
 {
     int ret;
@@ -139,6 +1167,31 @@ static void test_basics()
 }
 
 TEST_LIST = {
+    {"create_destroy",  create_destroy},
+    {"count", count},
+    {"fetch", fetch},
+    {"insert_string", insert_string},
+    {"insert_bytes", insert_bytes},
+    {"insert_reference", insert_reference},
+    {"insert_bool", insert_bool},
+    {"insert_int64", insert_int64},
+    {"insert_uint64", insert_uint64},
+    {"insert_double", insert_double},
+    {"insert_new_array", insert_new_array},
+    {"insert_empty_array", insert_empty_array},
+    {"insert_empty_kvlist", insert_empty_kvlist},
+
+    {"fetch_s", fetch_s},
+    {"insert_string_s", insert_string_s},
+    {"insert_bytes_s", insert_bytes_s},
+    {"insert_reference_s", insert_reference_s},
+    {"insert_bool_s", insert_bool_s},
+    {"insert_int64_s", insert_int64_s},
+    {"insert_uint64_s", insert_uint64_s},
+    {"insert_double_s", insert_double_s},
+    {"insert_new_array_s", insert_new_array_s},
+    {"insert_empty_array_s", insert_empty_array_s},
+    {"insert_empty_kvlist_s", insert_empty_kvlist_s},
     {"basics", test_basics},
     { 0 }
 };
diff --git a/tests/variant.c b/tests/variant.c
index 3f25dec..0af2841 100644
--- a/tests/variant.c
+++ b/tests/variant.c
@@ -423,6 +423,55 @@ static void test_variant_print_string()
     }
 }
 
+struct str_and_len {
+    char *str;
+    size_t str_size;
+};
+
+static void test_variant_print_string_s()
+{
+    int ret;
+    int i;
+    struct str_and_len inputs[] = {
+        {.str = "hoge", .str_size = 4},
+        {.str = "aaa", .str_size = 3},
+    };
+
+    char *expects[] = {"\"hoge\"", "\"aaa\""};
+
+    FILE *fp = NULL;
+    struct cfl_variant *val = NULL;
+
+    for (i=0; i<sizeof(inputs)/sizeof(struct str_and_len); i++) {
+        fp = tmpfile();
+        if (!TEST_CHECK(fp != NULL)) {
+            TEST_MSG("%d: fp is NULL", i);
+            continue;
+        }
+
+        val = cfl_variant_create_from_string_s(inputs[i].str, inputs[i].str_size);
+        if (!TEST_CHECK(val != NULL)) {
+            TEST_MSG("%d: cfl_variant_create_from_string failed", i);
+            fclose(fp);
+            continue;
+        }
+
+        ret = cfl_variant_print(fp, val);
+        if (!TEST_CHECK(ret > 0)) {
+            TEST_MSG("%d:cfl_variant_print failed", i);
+            cfl_variant_destroy(val);
+            fclose(fp);
+            continue;
+        }
+        ret = compare(fp, expects[i], 0);
+        if (!TEST_CHECK(ret == 0)) {
+            TEST_MSG("%d:compare failed", i);
+        }
+        cfl_variant_destroy(val);
+        fclose(fp);
+    }
+}
+
 static void test_variant_print_bytes()
 {
     int ret;
@@ -541,6 +590,7 @@ TEST_LIST = {
     {"variant_print_uint64", test_variant_print_uint64},
     {"variant_print_double", test_variant_print_double},
     {"variant_print_string", test_variant_print_string},
+    {"variant_print_string_s", test_variant_print_string_s},
     {"variant_print_bytes", test_variant_print_bytes},
     {"variant_print_array", test_variant_print_array},
     {"variant_print_kvlist", test_variant_print_kvlist},