2 * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 #include <gtest/gtest.h>
18 #include <gmock/gmock.h>
22 #include "include/bundle.h"
23 #include "include/bundle_internal.h"
25 class BundleTest : public ::testing::Test {
27 virtual void SetUp() {
30 virtual void TearDown() {
39 void SetHandle(bundle* b) {
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);
54 TEST_F(BundleTest, bundle_free_P) {
55 bundle* b = GetHandle();
56 int ret = bundle_free(b);
57 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
61 TEST_F(BundleTest, bundle_free_N) {
62 int ret = bundle_free(nullptr);
63 ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
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);
71 ret = bundle_add_str(b, "KEY2", "VALUE2");
72 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
75 ret = bundle_get_str(b, "KEY1", &str);
76 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
77 ASSERT_EQ(std::string(str), "VALUE1");
80 ret = bundle_get_str(b, "KEY2", &str);
81 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
82 ASSERT_EQ(std::string(str), "VALUE2");
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);
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);
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);
102 ret = bundle_get_str(b, "KEY", &str);
103 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
104 ASSERT_EQ(std::string(str), "VALUE");
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);
113 ret = bundle_get_str(b, "KEY", &str);
114 ASSERT_EQ(ret, BUNDLE_ERROR_KEY_NOT_AVAILABLE);
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);
125 ret = bundle_get_str(b, "KEY1", &str);
126 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
127 ASSERT_EQ(std::string(str), "VALUE1");
130 ret = bundle_get_str(b, "KEY2", &str);
131 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
132 ASSERT_EQ(std::string(str), "VALUE2");
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);
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);
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);
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");
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);
163 val = bundle_get_val(b, "KEY");
164 ASSERT_EQ(get_last_result(), BUNDLE_ERROR_KEY_NOT_AVAILABLE);
165 ASSERT_EQ(val, nullptr);
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);
173 int count = bundle_get_count(b);
176 ret = bundle_del(b, "KEY");
177 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
179 count = bundle_get_count(b);
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);
188 ret = bundle_del(b, "KEY");
189 ASSERT_EQ(ret, BUNDLE_ERROR_KEY_NOT_AVAILABLE);
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);
199 ret = bundle_add_str(b, "KEY2", "VALUE2");
200 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
201 count = bundle_get_count(b);
204 ret = bundle_del(b, "KEY2");
205 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
206 count = bundle_get_count(b);
210 TEST_F(BundleTest, bundle_get_count_N) {
211 bundle* b = GetHandle();
212 int count = bundle_get_count(b);
215 count = bundle_get_count(nullptr);
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);
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")
233 } else if (std::string(key) == "KEY2") {
234 if (std::string(val) == "VALUE2")
237 }, reinterpret_cast<void*>(&count));
238 ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
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) {
249 ASSERT_EQ(get_last_result(), BUNDLE_ERROR_INVALID_PARAMETER);
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);
263 [](const char* key, const int type, const bundle_keyval_t* kv,
265 int* count = reinterpret_cast<int*>(user_data);
266 if (type == BUNDLE_TYPE_STR) {
269 int ret = bundle_keyval_get_basic_val(
270 const_cast<bundle_keyval_t*>(kv), &val, &size);
271 if (ret != BUNDLE_ERROR_NONE)
274 std::string value(reinterpret_cast<char*>(val));
275 if (std::string(key) == "KEY1") {
276 if (value == "VALUE1")
278 } else if (std::string(key) == "KEY2") {
279 if (value == "VALUE2")
281 } else if (std::string(key) == "KEY3") {
282 if (value == "VALUE3")
286 }, reinterpret_cast<void*>(&count));
287 ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
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,
299 ASSERT_EQ(get_last_result(), BUNDLE_ERROR_INVALID_PARAMETER);
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);
307 bool matched = false;
309 [](const char* key, const int type, const bundle_keyval_t* kv,
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);
319 }, reinterpret_cast<void*>(&matched));
320 ASSERT_EQ(matched, true);
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);
329 TEST_F(BundleTest, bundle_keyval_type_is_array_P) {
330 bundle* b = GetHandle();
331 const char* str_array[] = {
336 int ret = bundle_add_str_array(b, "KEY", str_array, 2);
337 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
339 bool is_array = false;
341 [](const char* key, const int type, const bundle_keyval_t* kv,
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);
351 }, reinterpret_cast<void*>(&is_array));
352 ASSERT_EQ(is_array, true);
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);
360 bundle* b = GetHandle();
361 ret = bundle_add_str(b, "KEY", "VALUE");
362 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
364 bool is_array = false;
366 [](const char* key, const int type, const bundle_keyval_t* kv,
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);
377 }, reinterpret_cast<void*>(&is_array));
378 ASSERT_NE(is_array, true);
381 TEST_F(BundleTest, bundle_keyval_type_is_measurable_P) {
382 bundle* b = GetHandle();
383 const char* str_array[] = {
388 int ret = bundle_add_str_array(b, "KEY", str_array, 2);
389 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
391 bool is_measurable = false;
393 [](const char* key, const int type, const bundle_keyval_t* kv,
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);
400 *is_measurable = true;
401 }, reinterpret_cast<void*>(&is_measurable));
402 ASSERT_EQ(is_measurable, true);
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);
410 bundle* b = GetHandle();
411 ret = bundle_add_byte(b, "KEY", "VALUE", sizeof("VALUE"));
412 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
414 bool is_measurable = false;
416 [](const char* key, const int type, const bundle_keyval_t* kv,
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);
425 *is_measurable = true;
427 }, reinterpret_cast<void*>(&is_measurable));
428 ASSERT_NE(is_measurable, true);
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);
438 [](const char* key, const int type, const bundle_keyval_t* kv,
440 char** val = reinterpret_cast<char**>(user_data);
441 if (std::string(key) == "KEY") {
443 int ret = bundle_keyval_get_basic_val(
444 const_cast<bundle_keyval_t*>(kv),
445 reinterpret_cast<void**>(val),
447 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
449 }, reinterpret_cast<void*>(&val));
450 ASSERT_EQ(std::string(val), "VALUE");
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);
458 TEST_F(BundleTest, bundle_keyval_get_array_val_P) {
459 bundle* b = GetHandle();
460 const char* str_array[] = {
464 int ret = bundle_add_str_array(b, "KEY", str_array, 2);
465 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
467 char** array_val = nullptr;
469 [](const char* key, const int type, const bundle_keyval_t* kv,
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),
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"));
485 }, reinterpret_cast<void*>(&array_val));
486 ASSERT_EQ(std::string(array_val[0]), "VALUE1");
487 ASSERT_EQ(std::string(array_val[1]), "VALUE2");
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);
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);
500 bundle_keyval_t* kv = nullptr;
502 [](const char* key, const int type, const bundle_keyval_t* kv,
504 bundle_keyval_t** kv_dup = reinterpret_cast<bundle_keyval_t**>(
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);
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"));
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);
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);
532 bundle_keyval_t* kv = nullptr;
534 [](const char* key, const int type, const bundle_keyval_t* kv,
536 bundle_keyval_t** kv_dup = reinterpret_cast<bundle_keyval_t**>(
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);
543 ret = bundle_keyval_free(kv);
544 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
547 TEST_F(BundleTest, bundle_keyval_free_N) {
548 int ret = bundle_keyval_free(nullptr);
549 ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
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);
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);
562 const char* val = bundle_get_val(b_dup, "KEY");
563 ASSERT_EQ(std::string(val), "VALUE");
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);
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);
577 bundle_raw* raw = nullptr;
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);
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);
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");
597 TEST_F(BundleTest, bundle_encode_N) {
598 int ret = bundle_encode(nullptr, nullptr, nullptr);
599 ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
602 TEST_F(BundleTest, bundle_free_encoded_rawdata_P) {
603 bundle* b = GetHandle();
604 bundle_raw* raw = nullptr;
606 int ret = bundle_encode(b, &raw, &len);
607 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
609 ret = bundle_free_encoded_rawdata(&raw);
610 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
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);
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);
623 bundle_raw* raw = nullptr;
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);
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);
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");
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);
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);
654 bundle_raw* raw = nullptr;
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);
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);
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");
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);
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);
684 bundle_raw* raw = nullptr;
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);
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);
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");
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);
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[] = {
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);
731 int type = bundle_get_type(b, "KEY1");
732 ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
733 ASSERT_EQ(type, BUNDLE_TYPE_STR);
735 type = bundle_get_type(b, "KEY2");
736 ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
737 ASSERT_EQ(type, BUNDLE_TYPE_STR_ARRAY);
739 type = bundle_get_type(b, "KEY3");
740 ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
741 ASSERT_EQ(type, BUNDLE_TYPE_BYTE);
743 type = bundle_get_type(b, "KEY4");
744 ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
745 ASSERT_EQ(type, BUNDLE_TYPE_BYTE_ARRAY);
748 TEST_F(BundleTest, bundle_get_type_N) {
749 int type = bundle_get_type(nullptr, nullptr);
750 ASSERT_EQ(get_last_result(), BUNDLE_ERROR_INVALID_PARAMETER);
751 ASSERT_EQ(type, BUNDLE_TYPE_NONE);
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);
759 TEST_F(BundleTest, bundle_add_str_array_P) {
760 bundle* b = GetHandle();
761 const char* str_array[] = {
765 int ret = bundle_add_str_array(b, "KEY", str_array, 2);
766 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
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");
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);
781 bundle* b = GetHandle();
782 const char* str_array[] = {
786 ret = bundle_add_str_array(b, "KEY", str_array, 2);
787 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
789 ret = bundle_add_str_array(b, "KEY", str_array, 2);
790 ASSERT_EQ(ret, BUNDLE_ERROR_KEY_EXISTS);
793 TEST_F(BundleTest, bundle_get_str_array_P) {
794 bundle* b = GetHandle();
795 const char* str_array[] = {
799 int ret = bundle_add_str_array(b, "KEY", str_array, 2);
800 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
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");
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);
816 bundle* b = GetHandle();
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);
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);
828 void* bytes = nullptr;
830 ret = bundle_get_byte(b, "KEY", &bytes, &size);
831 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
832 ASSERT_NE(bytes, nullptr);
834 ASSERT_EQ(std::string(reinterpret_cast<char*>(bytes)), "VALUE");
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);
841 bundle* b = GetHandle();
842 ret = bundle_add_byte(b, "KEY", "VALUE", sizeof("VALUE"));
843 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
845 ret = bundle_add_byte(b, "KEY", "VALUE1", sizeof("VALUE1"));
846 ASSERT_EQ(ret, BUNDLE_ERROR_KEY_EXISTS);
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);
854 void* bytes = nullptr;
856 ret = bundle_get_byte(b, "KEY", &bytes, &size);
857 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
858 ASSERT_NE(bytes, nullptr);
860 ASSERT_EQ(std::string(reinterpret_cast<char*>(bytes)), "VALUE");
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);
867 bundle* b = GetHandle();
868 void* bytes = nullptr;
870 ret = bundle_get_byte(b, "KEY", &bytes, &size);
871 ASSERT_EQ(ret, BUNDLE_ERROR_KEY_NOT_AVAILABLE);
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);
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);
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,
889 ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
890 ASSERT_NE(imported_b, nullptr);
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");
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);
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);
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);
915 ret = bundle_free_exported_argv(argc, &argv);
916 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
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);
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);
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);
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,
939 ASSERT_EQ(get_last_result(), BUNDLE_ERROR_NONE);
940 ASSERT_NE(imported_b, nullptr);
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");
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);
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);
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);
964 ret = bundle_compare(b, b_dup);
968 TEST_F(BundleTest, bundle_compare_N) {
969 int ret = bundle_compare(nullptr, nullptr);
972 bundle* b = GetHandle();
973 ret = bundle_add_str(b, "KEY", "VALUE");
974 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
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);
981 ret = bundle_del(b, "KEY");
982 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
984 ret = bundle_compare(b, b_dup);
988 TEST_F(BundleTest, bundle_set_str_array_element_P) {
989 bundle* b = GetHandle();
990 const char* str_array[] = {
994 int ret = bundle_add_str_array(b, "KEY", str_array, 2);
995 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
997 ret = bundle_set_str_array_element(b, "KEY", 1, "VALUE3");
998 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
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);
1005 ASSERT_EQ(std::string(val_array[0]), "VALUE1");
1006 ASSERT_EQ(std::string(val_array[1]), "VALUE3");
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);
1013 bundle* b = GetHandle();
1014 ret = bundle_set_str_array_element(b, "KEY", 0, "VALUE");
1015 ASSERT_EQ(ret, BUNDLE_ERROR_KEY_NOT_AVAILABLE);
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);
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);
1028 bundle* b = GetHandle();
1029 ret = bundle_add_byte_array(b, "KEY", 2);
1030 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
1032 ret = bundle_add_byte_array(b, "KEY", 3);
1033 ASSERT_EQ(ret, BUNDLE_ERROR_KEY_EXISTS);
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);
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);
1046 bundle* b = GetHandle();
1047 ret = bundle_init_byte_array(b, "KEY", 2);
1048 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
1050 ret = bundle_init_byte_array(b, "KEY", 3);
1051 ASSERT_EQ(ret, BUNDLE_ERROR_KEY_EXISTS);
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);
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);
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"));
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);
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);
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);
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);
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"));
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);
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);
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);
1129 const char* str_array[] = {
1133 ret = bundle_add_str_array(b, "KEY2", str_array, 2);
1134 ASSERT_EQ(ret, BUNDLE_ERROR_NONE);
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);
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);
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");
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);
1157 ASSERT_EQ(std::string(val_array[0]), "VALUE1");
1158 ASSERT_EQ(std::string(val_array[1]), "VALUE2");
1161 TEST_F(BundleTest, bundle_to_json_N) {
1162 int ret = bundle_to_json(nullptr, nullptr);
1163 ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);
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);
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");
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);
1183 ASSERT_EQ(std::string(val_array[0]), "VALUE0");
1184 ASSERT_EQ(std::string(val_array[1]), "VALUE1");
1187 TEST_F(BundleTest, bundle_from_json_N) {
1188 int ret = bundle_from_json(nullptr, nullptr);
1189 ASSERT_EQ(ret, BUNDLE_ERROR_INVALID_PARAMETER);