tests/bundle_unittests/src/test_bundle.cc

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <gtest/gtest.h>
  18 #include <gmock/gmock.h>
  19 #include <iostream>
  20 #include <stdexcept>
  21
  22 #include "include/bundle.h"
  23 #include "include/bundle_internal.h"
  24
  25 class BundleTest : public ::testing::Test {
  26  public:
  27   virtual void SetUp() {
  28     b_ = bundle_create();
  29   }
  30   virtual void TearDown() {
  31     if (b_)
  32       bundle_free(b_);
  33   }
  34
  35   bundle* GetHandle() {
  36     return b_;
  37   }
  38
  39   void SetHandle(bundle* b) {
  40     b_ = b;
  41   }
  42
  43  private:
  44   bundle* b_ = nullptr;
  45 };
  46
  47 TEST_F(BundleTest, bundle_create_P) {
  48   bundle* b = bundle_create();
  49   std::unique_ptr<bundle, decltype(bundle_free)*> b_ptr(b, bundle_free);
  50   ASSERT_NE(b, nullptr);
  51   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
  52 }
  53
  54 TEST_F(BundleTest, bundle_free_P) {
  55   bundle* b = GetHandle();
  56   int ret = bundle_free(b);
  57   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
  58   SetHandle(nullptr);
  59 }
  60
  61 TEST_F(BundleTest, bundle_free_N) {
  62   int ret = bundle_free(nullptr);
  63   ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
  64 }
  65
  66 TEST_F(BundleTest, bundle_add_str_P) {
  67   bundle* b = GetHandle();
  68   int ret = bundle_add_str(b, "KEY1", "VALUE1");
  69   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
  70
  71   ret = bundle_add_str(b, "KEY2", "VALUE2");
  72   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
  73
  74   char* str = nullptr;
  75   ret = bundle_get_str(b, "KEY1", &str);
  76   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
  77   ASSERT_EQ(std::string(str), "VALUE1");
  78
  79   str = nullptr;
  80   ret = bundle_get_str(b, "KEY2", &str);
  81   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
  82   ASSERT_EQ(std::string(str), "VALUE2");
  83 }
  84
  85 TEST_F(BundleTest, bundle_add_str_N) {
  86   bundle* b = GetHandle();
  87   int ret = bundle_add_str(b, nullptr, nullptr);
  88   ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
  89
  90   ret = bundle_add_str(b, "KEY1", "VALUE1");
  91   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
  92   ret = bundle_add_str(b, "KEY1", "VALUE2");
  93   ASSERT_EQ(ret, BUNDLE_ERROR_KEY_EXISTS);
  94 }
  95
  96 TEST_F(BundleTest, bundle_get_str_P) {
  97   bundle* b = GetHandle();
  98   int ret = bundle_add_str(b, "KEY", "VALUE");
  99   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 100
 101   char* str = nullptr;
 102   ret = bundle_get_str(b, "KEY", &str);
 103   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 104   ASSERT_EQ(std::string(str), "VALUE");
 105 }
 106
 107 TEST_F(BundleTest, bundle_get_str_N) {
 108   bundle* b = GetHandle();
 109   int ret = bundle_get_str(nullptr, nullptr, nullptr);
 110   ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
 111
 112   char* str = nullptr;
 113   ret = bundle_get_str(b, "KEY", &str);
 114   ASSERT_EQ(ret, BUNDLE_ERROR_KEY_NOT_AVAILABLE);
 115 }
 116
 117 TEST_F(BundleTest, bundle_add_P) {
 118   bundle* b = GetHandle();
 119   int ret = bundle_add(b, "KEY1", "VALUE1");
 120   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 121   ret = bundle_add(b, "KEY2", "VALUE2");
 122   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 123
 124   char* str = nullptr;
 125   ret = bundle_get_str(b, "KEY1", &str);
 126   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 127   ASSERT_EQ(std::string(str), "VALUE1");
 128
 129   str = nullptr;
 130   ret = bundle_get_str(b, "KEY2", &str);
 131   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 132   ASSERT_EQ(std::string(str), "VALUE2");
 133 }
 134
 135 TEST_F(BundleTest, bundle_add_N) {
 136   bundle* b = GetHandle();
 137   int ret = bundle_add(b, nullptr, nullptr);
 138   ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
 139
 140   ret = bundle_add(b, "KEY1", "VALUE1");
 141   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 142   ret = bundle_add(b, "KEY1", "VALUE2");
 143   ASSERT_EQ(ret, BUNDLE_ERROR_KEY_EXISTS);
 144 }
 145
 146 TEST_F(BundleTest, bundle_get_val_P) {
 147   bundle* b = GetHandle();
 148   int ret = bundle_add_str(b, "KEY", "VALUE");
 149   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 150
 151   const char* val = bundle_get_val(b, "KEY");
 152   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 153   ASSERT_NE(val, nullptr);
 154   ASSERT_EQ(std::string(val), "VALUE");
 155 }
 156
 157 TEST_F(BundleTest, bundle_get_val_N) {
 158   bundle* b = GetHandle();
 159   const char* val = bundle_get_val(nullptr, nullptr);
 160   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_INVALID_PARAMETER);
 161   ASSERT_EQ(val, nullptr);
 162
 163   val = bundle_get_val(b, "KEY");
 164   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_KEY_NOT_AVAILABLE);
 165   ASSERT_EQ(val, nullptr);
 166 }
 167
 168 TEST_F(BundleTest, bundle_del_P) {
 169   bundle* b = GetHandle();
 170   int ret = bundle_add_str(b, "KEY", "VALUE");
 171   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 172
 173   int count = bundle_get_count(b);
 174   ASSERT_EQ(count, 1);
 175
 176   ret = bundle_del(b, "KEY");
 177   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 178
 179   count = bundle_get_count(b);
 180   ASSERT_EQ(count, 0);
 181 }
 182
 183 TEST_F(BundleTest, bundle_del_N) {
 184   bundle* b = GetHandle();
 185   int ret = bundle_del(nullptr, nullptr);
 186   ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
 187
 188   ret = bundle_del(b, "KEY");
 189   ASSERT_EQ(ret, BUNDLE_ERROR_KEY_NOT_AVAILABLE);
 190 }
 191
 192 TEST_F(BundleTest, bundle_get_count_P) {
 193   bundle* b = GetHandle();
 194   int ret = bundle_add_str(b, "KEY1", "VALUE1");
 195   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 196   int count = bundle_get_count(b);
 197   ASSERT_EQ(count, 1);
 198
 199   ret = bundle_add_str(b, "KEY2", "VALUE2");
 200   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 201   count = bundle_get_count(b);
 202   ASSERT_EQ(count, 2);
 203
 204   ret = bundle_del(b, "KEY2");
 205   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 206   count = bundle_get_count(b);
 207   ASSERT_EQ(count, 1);
 208 }
 209
 210 TEST_F(BundleTest, bundle_get_count_N) {
 211   bundle* b = GetHandle();
 212   int count = bundle_get_count(b);
 213   ASSERT_EQ(count, 0);
 214
 215   count = bundle_get_count(nullptr);
 216   ASSERT_EQ(count, 0);
 217 }
 218
 219 TEST_F(BundleTest, bundle_iterate_P) {
 220   bundle* b = GetHandle();
 221   int ret = bundle_add_str(b, "KEY1", "VALUE1");
 222   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 223   ret = bundle_add_str(b, "KEY2", "VALUE2");
 224   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 225
 226   int count = 0;
 227   bundle_iterate(b,
 228       [](const char* key, const char* val, void* data) {
 229         int* count = reinterpret_cast<int*>(data);
 230         if (std::string(key) == "KEY1") {
 231           if (std::string(val) == "VALUE1")
 232             (*count)++;
 233         } else if (std::string(key) == "KEY2") {
 234           if (std::string(val) == "VALUE2")
 235             (*count)++;
 236         }
 237       }, reinterpret_cast<void*>(&count));
 238   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 239   ASSERT_EQ(count, 2);
 240 }
 241
 242 TEST_F(BundleTest, bundle_iterate_N) {
 243   bundle* b = GetHandle();
 244   bundle_iterate(b, nullptr, nullptr);
 245   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_INVALID_PARAMETER);
 246   bundle_iterate(nullptr,
 247       [](const char* key, const char* val, void* data) {
 248       }, nullptr);
 249   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_INVALID_PARAMETER);
 250 }
 251
 252 TEST_F(BundleTest, bundle_foreach_P) {
 253   bundle* b = GetHandle();
 254   int ret = bundle_add_str(b, "KEY1", "VALUE1");
 255   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 256   ret = bundle_add_str(b, "KEY2", "VALUE2");
 257   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 258   ret = bundle_add_str(b, "KEY3", "VALUE3");
 259   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 260
 261   int count = 0;
 262   bundle_foreach(b,
 263       [](const char* key, const int type, const bundle_keyval_t* kv,
 264          void* user_data) {
 265         int* count = reinterpret_cast<int*>(user_data);
 266         if (type == BUNDLE_TYPE_STR) {
 267           void* val = nullptr;
 268           size_t size = 0;
 269           int ret = bundle_keyval_get_basic_val(
 270               const_cast<bundle_keyval_t*>(kv), &val, &size);
 271           if (ret != BUNDLE_ERROR_NONE)
 272             return;
 273
 274           std::string value(reinterpret_cast<char*>(val));
 275           if (std::string(key) == "KEY1") {
 276             if (value == "VALUE1")
 277               (*count)++;
 278           } else if (std::string(key) == "KEY2") {
 279             if (value == "VALUE2")
 280               (*count)++;
 281           } else if (std::string(key) == "KEY3") {
 282             if (value == "VALUE3")
 283               (*count)++;
 284           }
 285         }
 286       }, reinterpret_cast<void*>(&count));
 287   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 288   ASSERT_EQ(count, 3);
 289 }
 290
 291 TEST_F(BundleTest, bundle_foreach_N) {
 292   bundle* b = GetHandle();
 293   bundle_foreach(b, nullptr, nullptr);
 294   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_INVALID_PARAMETER);
 295   bundle_foreach(nullptr,
 296       [](const char* key, const int type, const bundle_keyval_t* kv,
 297          void* user_data) {
 298       }, nullptr);
 299   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_INVALID_PARAMETER);
 300 }
 301
 302 TEST_F(BundleTest, bundle_keyval_get_type_P) {
 303   bundle* b = GetHandle();
 304   int ret = bundle_add_str(b, "KEY1", "VALUE1");
 305   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 306
 307   bool matched = false;
 308   bundle_foreach(b,
 309       [](const char* key, const int type, const bundle_keyval_t* kv,
 310          void* user_data) {
 311         bool* matched = reinterpret_cast<bool*>(user_data);
 312         if (type == BUNDLE_TYPE_STR) {
 313           int keyval_type = bundle_keyval_get_type(
 314               const_cast<bundle_keyval_t*>(kv));
 315           ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 316           ASSERT_EQ(keyval_type, type);
 317           *matched = true;
 318         }
 319       }, reinterpret_cast<void*>(&matched));
 320   ASSERT_EQ(matched, true);
 321 }
 322
 323 TEST_F(BundleTest, bundle_keyval_get_type_N) {
 324   int type = bundle_keyval_get_type(nullptr);
 325   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_INVALID_PARAMETER);
 326   ASSERT_EQ(type, -1);
 327 }
 328
 329 TEST_F(BundleTest, bundle_keyval_type_is_array_P) {
 330   bundle* b = GetHandle();
 331   const char* str_array[] = {
 332     "VALUE1",
 333     "VALUE2",
 334   };
 335
 336   int ret = bundle_add_str_array(b, "KEY", str_array, 2);
 337   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 338
 339   bool is_array = false;
 340   bundle_foreach(b,
 341       [](const char* key, const int type, const bundle_keyval_t* kv,
 342          void* user_data) {
 343         bool* is_array = reinterpret_cast<bool*>(user_data);
 344         if (type == BUNDLE_TYPE_STR_ARRAY) {
 345           int ret = bundle_keyval_type_is_array(
 346               const_cast<bundle_keyval_t*>(kv));
 347           ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 348           ASSERT_EQ(ret, 1);
 349           *is_array = true;
 350         }
 351       }, reinterpret_cast<void*>(&is_array));
 352   ASSERT_EQ(is_array, true);
 353 }
 354
 355 TEST_F(BundleTest, bundle_keyval_type_is_array_N) {
 356   int ret = bundle_keyval_type_is_array(nullptr);
 357   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_INVALID_PARAMETER);
 358   ASSERT_EQ(ret, -1);
 359
 360   bundle* b = GetHandle();
 361   ret = bundle_add_str(b, "KEY", "VALUE");
 362   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 363
 364   bool is_array = false;
 365   bundle_foreach(b,
 366       [](const char* key, const int type, const bundle_keyval_t* kv,
 367         void* user_data) {
 368         bool* is_array = reinterpret_cast<bool*>(user_data);
 369         if (std::string(key) == "KEY") {
 370           int ret = bundle_keyval_type_is_array(
 371               const_cast<bundle_keyval_t*>(kv));
 372           ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 373           ASSERT_EQ(ret, 0);
 374           if (ret == 1)
 375             *is_array = true;
 376         }
 377       }, reinterpret_cast<void*>(&is_array));
 378   ASSERT_NE(is_array, true);
 379 }
 380
 381 TEST_F(BundleTest, bundle_keyval_type_is_measurable_P) {
 382   bundle* b = GetHandle();
 383   const char* str_array[] = {
 384     "VALUE1",
 385     "VALUE2",
 386   };
 387
 388   int ret = bundle_add_str_array(b, "KEY", str_array, 2);
 389   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 390
 391   bool is_measurable = false;
 392   bundle_foreach(b,
 393       [](const char* key, const int type, const bundle_keyval_t* kv,
 394          void* user_data) {
 395         bool* is_measurable = reinterpret_cast<bool*>(user_data);
 396         int ret = bundle_keyval_type_is_measurable(
 397               const_cast<bundle_keyval_t*>(kv));
 398         ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 399         ASSERT_EQ(ret, 1);
 400         *is_measurable = true;
 401       }, reinterpret_cast<void*>(&is_measurable));
 402   ASSERT_EQ(is_measurable, true);
 403 }
 404
 405 TEST_F(BundleTest, bundle_keyval_type_is_measurable_N) {
 406   int ret = bundle_keyval_type_is_measurable(nullptr);
 407   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_INVALID_PARAMETER);
 408   ASSERT_EQ(ret, -1);
 409
 410   bundle* b = GetHandle();
 411   ret = bundle_add_byte(b, "KEY", "VALUE", sizeof("VALUE"));
 412   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 413
 414   bool is_measurable = false;
 415   bundle_foreach(b,
 416       [](const char* key, const int type, const bundle_keyval_t* kv,
 417         void* user_data) {
 418         bool* is_measurable = reinterpret_cast<bool*>(user_data);
 419         if (std::string(key) == "KEY") {
 420           int ret = bundle_keyval_type_is_measurable(
 421               const_cast<bundle_keyval_t*>(kv));
 422           ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 423           ASSERT_EQ(ret, 0);
 424           if (ret == 1)
 425             *is_measurable = true;
 426         }
 427       }, reinterpret_cast<void*>(&is_measurable));
 428   ASSERT_NE(is_measurable, true);
 429 }
 430
 431 TEST_F(BundleTest, bundle_keyval_get_basic_val_P) {
 432   bundle* b = GetHandle();
 433   int ret = bundle_add_str(b, "KEY", "VALUE");
 434   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 435
 436   char* val = nullptr;
 437   bundle_foreach(b,
 438       [](const char* key, const int type, const bundle_keyval_t* kv,
 439          void* user_data) {
 440         char** val = reinterpret_cast<char**>(user_data);
 441         if (std::string(key) == "KEY") {
 442           size_t size = 0;
 443           int ret = bundle_keyval_get_basic_val(
 444               const_cast<bundle_keyval_t*>(kv),
 445               reinterpret_cast<void**>(val),
 446               &size);
 447           ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 448         }
 449       }, reinterpret_cast<void*>(&val));
 450   ASSERT_EQ(std::string(val), "VALUE");
 451 }
 452
 453 TEST_F(BundleTest, bundle_keyval_get_basic_val_N) {
 454   int ret = bundle_keyval_get_basic_val(nullptr, nullptr, nullptr);
 455   ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
 456 }
 457
 458 TEST_F(BundleTest, bundle_keyval_get_array_val_P) {
 459   bundle* b = GetHandle();
 460   const char* str_array[] = {
 461     "VALUE1",
 462     "VALUE2",
 463   };
 464   int ret = bundle_add_str_array(b, "KEY", str_array, 2);
 465   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 466
 467   char** array_val = nullptr;
 468   bundle_foreach(b,
 469       [](const char* key, const int type, const bundle_keyval_t* kv,
 470          void* user_data) {
 471         char*** array_val = reinterpret_cast<char***>(user_data);
 472         if (std::string(key) == "KEY") {
 473           unsigned int array_len = 0;
 474           size_t* array_item_size = nullptr;
 475           int ret = bundle_keyval_get_array_val(
 476               const_cast<bundle_keyval_t*>(kv),
 477               reinterpret_cast<void***>(array_val),
 478               &array_len,
 479               &array_item_size);
 480           ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 481           ASSERT_EQ(array_len, 2);
 482           ASSERT_EQ(array_item_size[0], sizeof("VALUE1"));
 483           ASSERT_EQ(array_item_size[1], sizeof("VALUE2"));
 484         }
 485       }, reinterpret_cast<void*>(&array_val));
 486   ASSERT_EQ(std::string(array_val[0]), "VALUE1");
 487   ASSERT_EQ(std::string(array_val[1]), "VALUE2");
 488 }
 489
 490 TEST_F(BundleTest, bundle_keyval_get_array_val_N) {
 491   int ret = bundle_keyval_get_array_val(nullptr, nullptr, nullptr, nullptr);
 492   ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
 493 }
 494
 495 TEST_F(BundleTest, bundle_keyval_dup_P) {
 496   bundle* b = GetHandle();
 497   int ret = bundle_add_str(b, "KEY", "VALUE");
 498   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 499
 500   bundle_keyval_t* kv = nullptr;
 501   bundle_foreach(b,
 502       [](const char* key, const int type, const bundle_keyval_t* kv,
 503          void* user_data) {
 504         bundle_keyval_t** kv_dup = reinterpret_cast<bundle_keyval_t**>(
 505             user_data);
 506         *kv_dup = bundle_keyval_dup(const_cast<bundle_keyval_t*>(kv));
 507         ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 508       }, reinterpret_cast<void*>(&kv));
 509   std::unique_ptr<bundle_keyval_t, decltype(bundle_keyval_free)*> keyval_ptr(
 510       kv, bundle_keyval_free);
 511   ASSERT_NE(kv, nullptr);
 512
 513   size_t size = 0;
 514   char* val = nullptr;
 515   ret = bundle_keyval_get_basic_val(kv, reinterpret_cast<void**>(&val), &size);
 516   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 517   ASSERT_EQ(std::string(val), "VALUE");
 518   ASSERT_EQ(size, sizeof("VALUE"));
 519 }
 520
 521 TEST_F(BundleTest, bundle_keyval_dup_N) {
 522   bundle_keyval_t* kv = bundle_keyval_dup(nullptr);
 523   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_INVALID_PARAMETER);
 524   ASSERT_EQ(kv, nullptr);
 525 }
 526
 527 TEST_F(BundleTest, bundle_keyval_free_P) {
 528   bundle* b = GetHandle();
 529   int ret = bundle_add_str(b, "KEY", "VALUE");
 530   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 531
 532   bundle_keyval_t* kv = nullptr;
 533   bundle_foreach(b,
 534       [](const char* key, const int type, const bundle_keyval_t* kv,
 535          void* user_data) {
 536         bundle_keyval_t** kv_dup = reinterpret_cast<bundle_keyval_t**>(
 537             user_data);
 538         *kv_dup = bundle_keyval_dup(const_cast<bundle_keyval_t*>(kv));
 539         ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 540       }, reinterpret_cast<void*>(&kv));
 541   ASSERT_NE(kv, nullptr);
 542
 543   ret = bundle_keyval_free(kv);
 544   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 545 }
 546
 547 TEST_F(BundleTest, bundle_keyval_free_N) {
 548   int ret = bundle_keyval_free(nullptr);
 549   ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
 550 }
 551
 552 TEST_F(BundleTest, bundle_dup_P) {
 553   bundle* b = GetHandle();
 554   int ret = bundle_add_str(b, "KEY", "VALUE");
 555   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 556
 557   bundle* b_dup = bundle_dup(b);
 558   std::unique_ptr<bundle, decltype(bundle_free)*> b_ptr(b_dup, bundle_free);
 559   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 560   ASSERT_NE(b_dup, nullptr);
 561
 562   const char* val = bundle_get_val(b_dup, "KEY");
 563   ASSERT_EQ(std::string(val), "VALUE");
 564 }
 565
 566 TEST_F(BundleTest, bundle_dup_N) {
 567   bundle* b_dup = bundle_dup(nullptr);
 568   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_INVALID_PARAMETER);
 569   ASSERT_EQ(b_dup, nullptr);
 570 }
 571
 572 TEST_F(BundleTest, bundle_encode_P) {
 573   bundle* b = GetHandle();
 574   int ret = bundle_add_str(b, "KEY", "VALUE");
 575   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 576
 577   bundle_raw* raw = nullptr;
 578   int len = 0;
 579   ret = bundle_encode(b, &raw, &len);
 580   std::unique_ptr<bundle_raw*, decltype(bundle_free_encoded_rawdata)*> raw_ptr(
 581       &raw, bundle_free_encoded_rawdata);
 582   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 583   ASSERT_NE(raw, nullptr);
 584   ASSERT_NE(len, 0);
 585
 586   bundle* decoded_b = bundle_decode(raw, len);
 587   std::unique_ptr<bundle, decltype(bundle_free)*> b_ptr(decoded_b, bundle_free);
 588   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 589   ASSERT_NE(decoded_b, nullptr);
 590
 591   const char* val = bundle_get_val(decoded_b, "KEY");
 592   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 593   ASSERT_NE(val, nullptr);
 594   ASSERT_EQ(std::string(val), "VALUE");
 595 }
 596
 597 TEST_F(BundleTest, bundle_encode_N) {
 598   int ret = bundle_encode(nullptr, nullptr, nullptr);
 599   ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
 600 }
 601
 602 TEST_F(BundleTest, bundle_free_encoded_rawdata_P) {
 603   bundle* b = GetHandle();
 604   bundle_raw* raw = nullptr;
 605   int len = 0;
 606   int ret = bundle_encode(b, &raw, &len);
 607   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 608
 609   ret = bundle_free_encoded_rawdata(&raw);
 610   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 611 }
 612
 613 TEST_F(BundleTest, bundle_free_encoded_rawdata_N) {
 614   int ret = bundle_free_encoded_rawdata(nullptr);
 615   ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
 616 }
 617
 618 TEST_F(BundleTest, bundle_decode_P) {
 619   bundle* b = GetHandle();
 620   int ret = bundle_add_str(b, "KEY", "VALUE");
 621   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 622
 623   bundle_raw* raw = nullptr;
 624   int len = 0;
 625   ret = bundle_encode(b, &raw, &len);
 626   std::unique_ptr<bundle_raw*, decltype(bundle_free_encoded_rawdata)*> raw_ptr(
 627       &raw, bundle_free_encoded_rawdata);
 628   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 629   ASSERT_NE(raw, nullptr);
 630   ASSERT_NE(len, 0);
 631
 632   bundle* decoded_b = bundle_decode(raw, len);
 633   std::unique_ptr<bundle, decltype(bundle_free)*> b_ptr(decoded_b, bundle_free);
 634   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 635   ASSERT_NE(decoded_b, nullptr);
 636
 637   const char* val = bundle_get_val(decoded_b, "KEY");
 638   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 639   ASSERT_NE(val, nullptr);
 640   ASSERT_EQ(std::string(val), "VALUE");
 641 }
 642
 643 TEST_F(BundleTest, bundle_decode_N) {
 644   bundle* b = bundle_decode(nullptr, 0);
 645   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_INVALID_PARAMETER);
 646   ASSERT_EQ(b, nullptr);
 647 }
 648
 649 TEST_F(BundleTest, bundle_encode_raw_P) {
 650   bundle* b = GetHandle();
 651   int ret = bundle_add_str(b, "KEY", "VALUE1");
 652   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 653
 654   bundle_raw* raw = nullptr;
 655   int len = 0;
 656   ret = bundle_encode_raw(b, &raw, &len);
 657   std::unique_ptr<bundle_raw*, decltype(bundle_free_encoded_rawdata)*> raw_ptr(
 658       &raw, bundle_free_encoded_rawdata);
 659   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 660   ASSERT_NE(raw, nullptr);
 661   ASSERT_NE(len, 0);
 662
 663   bundle* decoded_b = bundle_decode_raw(raw, len);
 664   std::unique_ptr<bundle, decltype(bundle_free)*> b_ptr(decoded_b, bundle_free);
 665   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 666   ASSERT_NE(decoded_b, nullptr);
 667
 668   const char* val = bundle_get_val(decoded_b, "KEY");
 669   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 670   ASSERT_NE(val, nullptr);
 671   ASSERT_EQ(std::string(val), "VALUE1");
 672 }
 673
 674 TEST_F(BundleTest, bundle_encode_raw_N) {
 675   int ret = bundle_encode_raw(nullptr, nullptr, nullptr);
 676   ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
 677 }
 678
 679 TEST_F(BundleTest, bundle_decode_raw_P) {
 680   bundle* b = GetHandle();
 681   int ret = bundle_add_str(b, "KEY", "VALUE2");
 682   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 683
 684   bundle_raw* raw = nullptr;
 685   int len = 0;
 686   ret = bundle_encode_raw(b, &raw, &len);
 687   std::unique_ptr<bundle_raw*, decltype(bundle_free_encoded_rawdata)*> raw_ptr(
 688       &raw, bundle_free_encoded_rawdata);
 689   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 690   ASSERT_NE(raw, nullptr);
 691   ASSERT_NE(len, 0);
 692
 693   bundle* decoded_b = bundle_decode_raw(raw, len);
 694   std::unique_ptr<bundle, decltype(bundle_free)*> b_ptr(decoded_b, bundle_free);
 695   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 696   ASSERT_NE(decoded_b, nullptr);
 697
 698   const char* val = bundle_get_val(decoded_b, "KEY");
 699   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 700   ASSERT_NE(val, nullptr);
 701   ASSERT_EQ(std::string(val), "VALUE2");
 702 }
 703
 704 TEST_F(BundleTest, bundle_decode_raw_N) {
 705   bundle* b = bundle_decode_raw(nullptr, 0);
 706   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_INVALID_PARAMETER);
 707   ASSERT_EQ(b, nullptr);
 708 }
 709
 710 TEST_F(BundleTest, bundle_get_type_P) {
 711   bundle* b = GetHandle();
 712   int ret = bundle_add_str(b, "KEY1", "VALUE1");
 713   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 714   const char* str_array[] = {
 715     "VALUE2",
 716     "VALUE3",
 717   };
 718   ret = bundle_add_str_array(b, "KEY2", str_array, 2);
 719   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 720   ret = bundle_add_byte(b, "KEY3", "VALUE3", sizeof("VALUE4"));
 721   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 722   ret = bundle_add_byte_array(b, "KEY4", 2);
 723   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 724   ret = bundle_set_byte_array_element(b, "KEY4", 0,
 725       "VALUE5", sizeof("VALUE5"));
 726   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 727   ret = bundle_set_byte_array_element(b, "KEY4", 1,
 728       "VALUE6", sizeof("VALUE6"));
 729   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 730
 731   int type = bundle_get_type(b, "KEY1");
 732   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 733   ASSERT_EQ(type, BUNDLE_TYPE_STR);
 734
 735   type = bundle_get_type(b, "KEY2");
 736   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 737   ASSERT_EQ(type, BUNDLE_TYPE_STR_ARRAY);
 738
 739   type = bundle_get_type(b, "KEY3");
 740   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 741   ASSERT_EQ(type, BUNDLE_TYPE_BYTE);
 742
 743   type = bundle_get_type(b, "KEY4");
 744   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 745   ASSERT_EQ(type, BUNDLE_TYPE_BYTE_ARRAY);
 746 }
 747
 748 TEST_F(BundleTest, bundle_get_type_N) {
 749   int type = bundle_get_type(nullptr, nullptr);
 750   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_KEY_NOT_AVAILABLE);
 751   ASSERT_EQ(type, BUNDLE_TYPE_NONE);
 752
 753   bundle* b = GetHandle();
 754   type = bundle_get_type(b, "KEY");
 755   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_KEY_NOT_AVAILABLE);
 756   ASSERT_EQ(type, BUNDLE_TYPE_NONE);
 757 }
 758
 759 TEST_F(BundleTest, bundle_add_str_array_P) {
 760   bundle* b = GetHandle();
 761   const char* str_array[] = {
 762     "VALUE1",
 763     "VALUE2",
 764   };
 765   int ret = bundle_add_str_array(b, "KEY", str_array, 2);
 766   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 767
 768   int len = 0;
 769   const char** val_array = bundle_get_str_array(b, "KEY", &len);
 770   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 771   ASSERT_NE(val_array, nullptr);
 772   ASSERT_EQ(std::string(val_array[0]), "VALUE1");
 773   ASSERT_EQ(std::string(val_array[1]), "VALUE2");
 774   ASSERT_EQ(len, 2);
 775 }
 776
 777 TEST_F(BundleTest, bundle_add_str_array_N) {
 778   int ret = bundle_add_str_array(nullptr, nullptr, nullptr, 0);
 779   ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
 780
 781   bundle* b = GetHandle();
 782   const char* str_array[] = {
 783     "VALUE1",
 784     "VALUE2",
 785   };
 786   ret = bundle_add_str_array(b, "KEY", str_array, 2);
 787   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 788
 789   ret = bundle_add_str_array(b, "KEY", str_array, 2);
 790   ASSERT_EQ(ret, BUNDLE_ERROR_KEY_EXISTS);
 791 }
 792
 793 TEST_F(BundleTest, bundle_get_str_array_P) {
 794   bundle* b = GetHandle();
 795   const char* str_array[] = {
 796     "VALUE1",
 797     "VALUE2",
 798   };
 799   int ret = bundle_add_str_array(b, "KEY", str_array, 2);
 800   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 801
 802   int len = 0;
 803   const char** val_array = bundle_get_str_array(b, "KEY", &len);
 804   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 805   ASSERT_NE(val_array, nullptr);
 806   ASSERT_EQ(std::string(val_array[0]), "VALUE1");
 807   ASSERT_EQ(std::string(val_array[1]), "VALUE2");
 808   ASSERT_EQ(len, 2);
 809 }
 810
 811 TEST_F(BundleTest, bundle_get_str_array_N) {
 812   const char** val_array = bundle_get_str_array(nullptr, nullptr, nullptr);
 813   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_INVALID_PARAMETER);
 814   ASSERT_EQ(val_array, nullptr);
 815
 816   bundle* b = GetHandle();
 817   int len = 0;
 818   val_array = bundle_get_str_array(b, "KEY", &len);
 819   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_KEY_NOT_AVAILABLE);
 820   ASSERT_EQ(val_array, nullptr);
 821 }
 822
 823 TEST_F(BundleTest, bundle_add_byte_P) {
 824   bundle* b = GetHandle();
 825   int ret = bundle_add_byte(b, "KEY", "VALUE", sizeof("VALUE"));
 826   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 827
 828   void* bytes = nullptr;
 829   size_t size = 0;
 830   ret = bundle_get_byte(b, "KEY", &bytes, &size);
 831   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 832   ASSERT_NE(bytes, nullptr);
 833   ASSERT_NE(size, 0);
 834   ASSERT_EQ(std::string(reinterpret_cast<char*>(bytes)), "VALUE");
 835 }
 836
 837 TEST_F(BundleTest, bundle_add_byte_N) {
 838   int ret = bundle_add_byte(nullptr, nullptr, nullptr, 0);
 839   ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
 840
 841   bundle* b = GetHandle();
 842   ret = bundle_add_byte(b, "KEY", "VALUE", sizeof("VALUE"));
 843   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 844
 845   ret = bundle_add_byte(b, "KEY", "VALUE1", sizeof("VALUE1"));
 846   ASSERT_EQ(ret, BUNDLE_ERROR_KEY_EXISTS);
 847 }
 848
 849 TEST_F(BundleTest, bundle_get_byte_P) {
 850   bundle* b = GetHandle();
 851   int ret = bundle_add_byte(b, "KEY", "VALUE", sizeof("VALUE"));
 852   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 853
 854   void* bytes = nullptr;
 855   size_t size = 0;
 856   ret = bundle_get_byte(b, "KEY", &bytes, &size);
 857   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 858   ASSERT_NE(bytes, nullptr);
 859   ASSERT_NE(size, 0);
 860   ASSERT_EQ(std::string(reinterpret_cast<char*>(bytes)), "VALUE");
 861 }
 862
 863 TEST_F(BundleTest, bundle_get_byte_N) {
 864   int ret = bundle_get_byte(nullptr, nullptr, nullptr, nullptr);
 865   ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
 866
 867   bundle* b = GetHandle();
 868   void* bytes = nullptr;
 869   size_t size = 0;
 870   ret = bundle_get_byte(b, "KEY", &bytes, &size);
 871   ASSERT_EQ(ret, BUNDLE_ERROR_KEY_NOT_AVAILABLE);
 872 }
 873
 874 TEST_F(BundleTest, bundle_export_to_argv_P) {
 875   bundle* b = GetHandle();
 876   int ret = bundle_add_str(b, "KEY", "VALUE");
 877   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 878
 879   char** argv = nullptr;
 880   int argc = bundle_export_to_argv(b, &argv);
 881   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 882   ASSERT_NE(argv, nullptr);
 883   ASSERT_NE(argc, 0);
 884
 885   bundle* imported_b = bundle_import_from_argv(argc, argv);
 886   bundle_free_exported_argv(argc, &argv);
 887   std::unique_ptr<bundle, decltype(bundle_free)*> b_ptr(imported_b,
 888       bundle_free);
 889   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 890   ASSERT_NE(imported_b, nullptr);
 891
 892   const char* val = bundle_get_val(imported_b, "KEY");
 893   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 894   ASSERT_NE(val, nullptr);
 895   ASSERT_EQ(std::string(val), "VALUE");
 896 }
 897
 898 TEST_F(BundleTest, bundle_export_to_argv_N) {
 899   int argc = bundle_export_to_argv(nullptr, nullptr);
 900   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_INVALID_PARAMETER);
 901   ASSERT_EQ(argc, -1);
 902 }
 903
 904 TEST_F(BundleTest, bundle_free_exported_argv_P) {
 905   bundle* b = GetHandle();
 906   int ret = bundle_add_str(b, "KEY", "VALUE");
 907   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 908
 909   char** argv = nullptr;
 910   int argc = bundle_export_to_argv(b, &argv);
 911   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 912   ASSERT_NE(argv, nullptr);
 913   ASSERT_NE(argc, 0);
 914
 915   ret = bundle_free_exported_argv(argc, &argv);
 916   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 917 }
 918
 919 TEST_F(BundleTest, bundle_free_exported_argv_N) {
 920   int ret = bundle_free_exported_argv(0, nullptr);
 921   ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
 922 }
 923
 924 TEST_F(BundleTest, bundle_import_from_argv_P) {
 925   bundle* b = GetHandle();
 926   int ret = bundle_add_str(b, "KEY", "VALUE");
 927   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 928
 929   char** argv = nullptr;
 930   int argc = bundle_export_to_argv(b, &argv);
 931   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 932   ASSERT_NE(argv, nullptr);
 933   ASSERT_NE(argc, 0);
 934
 935   bundle* imported_b = bundle_import_from_argv(argc, argv);
 936   bundle_free_exported_argv(argc, &argv);
 937   std::unique_ptr<bundle, decltype(bundle_free)*> b_ptr(imported_b,
 938       bundle_free);
 939   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 940   ASSERT_NE(imported_b, nullptr);
 941
 942   const char* val = bundle_get_val(imported_b, "KEY");
 943   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 944   ASSERT_NE(val, nullptr);
 945   ASSERT_EQ(std::string(val), "VALUE");
 946 }
 947
 948 TEST_F(BundleTest, bundle_import_from_argv_N) {
 949   bundle* b = bundle_import_from_argv(0, nullptr);
 950   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_INVALID_PARAMETER);
 951   ASSERT_EQ(b, nullptr);
 952 }
 953
 954 TEST_F(BundleTest, bundle_compare_P) {
 955   bundle* b = GetHandle();
 956   int ret = bundle_add_str(b, "KEY", "VALUE");
 957   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 958
 959   bundle* b_dup = bundle_dup(b);
 960   std::unique_ptr<bundle, decltype(bundle_free)*> b_ptr(b_dup, bundle_free);
 961   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 962   ASSERT_NE(b_dup, nullptr);
 963
 964   ret = bundle_compare(b, b_dup);
 965   ASSERT_EQ(ret, 0);
 966 }
 967
 968 TEST_F(BundleTest, bundle_compare_N) {
 969   int ret = bundle_compare(nullptr, nullptr);
 970   ASSERT_EQ(ret, -1);
 971
 972   bundle* b = GetHandle();
 973   ret = bundle_add_str(b, "KEY", "VALUE");
 974   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 975
 976   bundle* b_dup = bundle_dup(b);
 977   std::unique_ptr<bundle, decltype(bundle_free)*> b_ptr(b_dup, bundle_free);
 978   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
 979   ASSERT_NE(b_dup, nullptr);
 980
 981   ret = bundle_del(b, "KEY");
 982   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 983
 984   ret = bundle_compare(b, b_dup);
 985   ASSERT_EQ(ret, 1);
 986 }
 987
 988 TEST_F(BundleTest, bundle_set_str_array_element_P) {
 989   bundle* b = GetHandle();
 990   const char* str_array[] = {
 991     "VALUE1",
 992     "VALUE2",
 993   };
 994   int ret = bundle_add_str_array(b, "KEY", str_array, 2);
 995   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 996
 997   ret = bundle_set_str_array_element(b, "KEY", 1, "VALUE3");
 998   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
 999
1000   int len = 0;
1001   const char** val_array = bundle_get_str_array(b, "KEY", &len);
1002   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
1003   ASSERT_NE(val_array, nullptr);
1004   ASSERT_NE(len, 0);
1005   ASSERT_EQ(std::string(val_array[0]), "VALUE1");
1006   ASSERT_EQ(std::string(val_array[1]), "VALUE3");
1007 }
1008
1009 TEST_F(BundleTest, bundle_set_str_array_element_N) {
1010   int ret = bundle_set_str_array_element(nullptr, nullptr, 0, nullptr);
1011   ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
1012
1013   bundle* b = GetHandle();
1014   ret = bundle_set_str_array_element(b, "KEY", 0, "VALUE");
1015   ASSERT_EQ(ret, BUNDLE_ERROR_KEY_NOT_AVAILABLE);
1016 }
1017
1018 TEST_F(BundleTest, bundle_add_byte_array_P) {
1019   bundle* b = GetHandle();
1020   int ret = bundle_add_byte_array(b, "KEY", 2);
1021   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
1022 }
1023
1024 TEST_F(BundleTest, bundle_add_byte_array_N) {
1025   int ret = bundle_add_byte_array(nullptr, nullptr, 0);
1026   ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
1027
1028   bundle* b = GetHandle();
1029   ret = bundle_add_byte_array(b, "KEY", 2);
1030   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
1031
1032   ret = bundle_add_byte_array(b, "KEY", 3);
1033   ASSERT_EQ(ret, BUNDLE_ERROR_KEY_EXISTS);
1034 }
1035
1036 TEST_F(BundleTest, bundle_init_byte_array_P) {
1037   bundle* b = GetHandle();
1038   int ret = bundle_init_byte_array(b, "KEY", 2);
1039   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
1040 }
1041
1042 TEST_F(BundleTest, bundle_init_byte_array_N) {
1043   int ret = bundle_init_byte_array(nullptr, nullptr, 0);
1044   ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
1045
1046   bundle* b = GetHandle();
1047   ret = bundle_init_byte_array(b, "KEY", 2);
1048   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
1049
1050   ret = bundle_init_byte_array(b, "KEY", 3);
1051   ASSERT_EQ(ret, BUNDLE_ERROR_KEY_EXISTS);
1052 }
1053
1054 TEST_F(BundleTest, bundle_get_byte_array_P) {
1055   bundle* b = GetHandle();
1056   int ret = bundle_add_byte_array(b, "KEY", 2);
1057   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
1058   ret = bundle_set_byte_array_element(b, "KEY", 0, "VALUE1", sizeof("VALUE1"));
1059   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
1060   ret = bundle_set_byte_array_element(b, "KEY", 1, "VALUE2", sizeof("VALUE2"));
1061   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
1062
1063   void** bytes_array = nullptr;
1064   unsigned int len = 0;
1065   unsigned int* array_element_size = nullptr;
1066   ret = bundle_get_byte_array(b, "KEY", &bytes_array, &len,
1067       &array_element_size);
1068   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
1069   ASSERT_NE(bytes_array, nullptr);
1070   ASSERT_NE(len, 0);
1071   ASSERT_NE(array_element_size, nullptr);
1072   ASSERT_EQ(std::string(reinterpret_cast<char*>(bytes_array[0])), "VALUE1");
1073   ASSERT_EQ(std::string(reinterpret_cast<char*>(bytes_array[1])), "VALUE2");
1074   ASSERT_EQ(array_element_size[0], sizeof("VALUE1"));
1075   ASSERT_EQ(array_element_size[1], sizeof("VALUE2"));
1076 }
1077
1078 TEST_F(BundleTest, bundle_get_byte_array_N) {
1079   int ret = bundle_get_byte_array(nullptr, nullptr, nullptr, nullptr, nullptr);
1080   ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
1081
1082   void** bytes_array = nullptr;
1083   unsigned int len = 0;
1084   unsigned int* array_element_size = nullptr;
1085   bundle* b = GetHandle();
1086   ret = bundle_get_byte_array(b, "KEY", &bytes_array, &len,
1087       &array_element_size);
1088   ASSERT_EQ(ret, BUNDLE_ERROR_KEY_NOT_AVAILABLE);
1089 }
1090
1091 TEST_F(BundleTest, bundle_set_byte_array_element_P) {
1092   bundle* b = GetHandle();
1093   int ret = bundle_add_byte_array(b, "KEY", 2);
1094   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
1095   ret = bundle_set_byte_array_element(b, "KEY", 0, "VALUE1", sizeof("VALUE1"));
1096   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
1097   ret = bundle_set_byte_array_element(b, "KEY", 1, "VALUE2", sizeof("VALUE2"));
1098   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
1099
1100   void** bytes_array = nullptr;
1101   unsigned int len = 0;
1102   unsigned int* array_element_size = nullptr;
1103   ret = bundle_get_byte_array(b, "KEY", &bytes_array, &len,
1104       &array_element_size);
1105   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
1106   ASSERT_NE(bytes_array, nullptr);
1107   ASSERT_NE(len, 0);
1108   ASSERT_NE(array_element_size, nullptr);
1109   ASSERT_EQ(std::string(reinterpret_cast<char*>(bytes_array[0])), "VALUE1");
1110   ASSERT_EQ(std::string(reinterpret_cast<char*>(bytes_array[1])), "VALUE2");
1111   ASSERT_EQ(array_element_size[0], sizeof("VALUE1"));
1112   ASSERT_EQ(array_element_size[1], sizeof("VALUE2"));
1113 }
1114
1115 TEST_F(BundleTest, bundle_set_byte_array_element_N) {
1116   int ret = bundle_set_byte_array_element(nullptr, nullptr, 0, nullptr, 0);
1117   ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
1118
1119   bundle* b = GetHandle();
1120   ret = bundle_set_byte_array_element(b, "KEY", 0, "VALUE", sizeof("VALUE"));
1121   ASSERT_EQ(ret, BUNDLE_ERROR_KEY_NOT_AVAILABLE);
1122 }
1123
1124 TEST_F(BundleTest, bundle_to_json_P) {
1125   bundle* b = GetHandle();
1126   int ret = bundle_add_str(b, "KEY1", "VALUE1");
1127   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
1128
1129   const char* str_array[] = {
1130     "VALUE1",
1131     "VALUE2",
1132   };
1133   ret = bundle_add_str_array(b, "KEY2", str_array, 2);
1134   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
1135
1136   char* json = nullptr;
1137   ret = bundle_to_json(b, &json);
1138   std::unique_ptr<char, decltype(std::free)*> json_ptr(json, std::free);
1139   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
1140   ASSERT_NE(json, nullptr);
1141
1142   bundle* json_b = nullptr;
1143   ret = bundle_from_json(json, &json_b);
1144   std::unique_ptr<bundle, decltype(bundle_free)*> b_ptr(json_b, bundle_free);
1145   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
1146
1147   const char* val = bundle_get_val(json_b, "KEY1");
1148   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
1149   ASSERT_NE(val, nullptr);
1150   ASSERT_EQ(std::string(val), "VALUE1");
1151
1152   int len = 0;
1153   const char** val_array = bundle_get_str_array(json_b, "KEY2", &len);
1154   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
1155   ASSERT_NE(val_array, nullptr);
1156   ASSERT_NE(len, 0);
1157   ASSERT_EQ(std::string(val_array[0]), "VALUE1");
1158   ASSERT_EQ(std::string(val_array[1]), "VALUE2");
1159 }
1160
1161 TEST_F(BundleTest, bundle_to_json_N) {
1162   int ret = bundle_to_json(nullptr, nullptr);
1163   ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
1164 }
1165
1166 TEST_F(BundleTest, bundle_from_json_P) {
1167   const char json[] = "{\"KEY1\":\"VALUE1\",\"KEY2\":[\"VALUE0\",\"VALUE1\"]}";
1168   bundle* json_b = nullptr;
1169   int ret = bundle_from_json(json, &json_b);
1170   std::unique_ptr<bundle, decltype(bundle_free)*> b_ptr(json_b, bundle_free);
1171   ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
1172
1173   const char* val = bundle_get_val(json_b, "KEY1");
1174   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
1175   ASSERT_NE(val, nullptr);
1176   ASSERT_EQ(std::string(val), "VALUE1");
1177
1178   int len = 0;
1179   const char** val_array = bundle_get_str_array(json_b, "KEY2", &len);
1180   ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
1181   ASSERT_NE(val_array, nullptr);
1182   ASSERT_NE(len, 0);
1183   ASSERT_EQ(std::string(val_array[0]), "VALUE0");
1184   ASSERT_EQ(std::string(val_array[1]), "VALUE1");
1185 }
1186
1187 TEST_F(BundleTest, bundle_from_json_N) {
1188   int ret = bundle_from_json(nullptr, nullptr);
1189   ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
1190 }