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 <gmock/gmock.h>
18 #include <gtest/gtest.h>
24 #include "parcel/api/parcel.h"
26 class ParcelTest : public ::testing::Test {
28 virtual void SetUp() {
29 parcel_create(&parcel_);
32 virtual void TearDown() {
34 parcel_destroy(parcel_);
37 parcel_h GetHandle() {
41 void SetHandle(parcel_h* parcel) {
46 parcel_h parcel_ = nullptr;
49 TEST_F(ParcelTest, parcel_create_P) {
50 parcel_h parcel = nullptr;
51 int ret = parcel_create(&parcel);
52 auto ptr = std::unique_ptr<std::remove_pointer<parcel_h>::type,
53 decltype(parcel_destroy)*>(parcel, parcel_destroy);
54 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
55 ASSERT_NE(parcel, nullptr);
58 TEST_F(ParcelTest, parcel_create_N) {
59 int ret = parcel_create(nullptr);
60 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
63 TEST_F(ParcelTest, parcel_destroy_P) {
64 int ret = parcel_destroy(GetHandle());
65 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
69 TEST_F(ParcelTest, parcel_destroy_N) {
70 int ret = parcel_destroy(nullptr);
71 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
74 TEST_F(ParcelTest, parcel_clone_P) {
75 parcel_h clone = nullptr;
76 int ret = parcel_clone(GetHandle(), &clone);
77 auto ptr = std::unique_ptr<std::remove_pointer<parcel_h>::type,
78 decltype(parcel_destroy)*>(clone, parcel_destroy);
79 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
80 ASSERT_NE(clone, nullptr);
83 TEST_F(ParcelTest, parcel_clone_N) {
84 int ret = parcel_clone(nullptr, nullptr);
85 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
88 TEST_F(ParcelTest, parcel_burst_write_P) {
89 char buf[1024] = { 1, };
90 int ret = parcel_burst_write(GetHandle(), buf, sizeof(buf));
91 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
93 ret = parcel_burst_read(GetHandle(), read_buf, sizeof(read_buf));
94 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
95 ASSERT_EQ(read_buf[0], 1);
98 TEST_F(ParcelTest, parcel_burst_write_N) {
99 int ret = parcel_burst_write(nullptr, nullptr, 0);
100 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
103 TEST_F(ParcelTest, parcel_burst_read_P) {
104 char buf[1024] = { 2, };
105 int ret = parcel_burst_write(GetHandle(), buf, sizeof(buf));
106 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
108 ret = parcel_burst_read(GetHandle(), read_buf, sizeof(read_buf));
109 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
110 ASSERT_EQ(read_buf[0], 2);
113 TEST_F(ParcelTest, parcel_burst_read_N) {
114 int ret = parcel_burst_read(nullptr, nullptr, 0);
115 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
118 TEST_F(ParcelTest, parcel_write_bool_P) {
119 int ret = parcel_write_bool(GetHandle(), true);
120 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
122 ret = parcel_read_bool(GetHandle(), &val);
123 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
124 ASSERT_EQ(val, true);
127 TEST_F(ParcelTest, parcel_write_bool_N) {
128 int ret = parcel_write_bool(nullptr, false);
129 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
132 TEST_F(ParcelTest, parcel_write_byte_P) {
133 int ret = parcel_write_byte(GetHandle(), 1);
134 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
136 ret = parcel_read_byte(GetHandle(), &val);
137 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
141 TEST_F(ParcelTest, parcel_write_byte_N) {
142 int ret = parcel_write_byte(nullptr, 1);
143 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
146 TEST_F(ParcelTest, parcel_write_uint16_P) {
147 int ret = parcel_write_uint16(GetHandle(), 1);
148 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
150 ret = parcel_read_uint16(GetHandle(), &val);
151 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
155 TEST_F(ParcelTest, parcel_write_uint16_N) {
156 int ret = parcel_write_uint16(nullptr, 1);
157 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
160 TEST_F(ParcelTest, parcel_write_uint32_P) {
161 int ret = parcel_write_uint32(GetHandle(), 1);
162 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
164 ret = parcel_read_uint32(GetHandle(), &val);
165 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
169 TEST_F(ParcelTest, parcel_write_uint32_N) {
170 int ret = parcel_write_uint32(nullptr, 1);
171 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
174 TEST_F(ParcelTest, parcel_write_uint64_P) {
175 int ret = parcel_write_uint64(GetHandle(), 1);
176 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
178 ret = parcel_read_uint64(GetHandle(), &val);
179 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
183 TEST_F(ParcelTest, parcel_write_uint64_N) {
184 int ret = parcel_write_uint64(nullptr, 1);
185 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
188 TEST_F(ParcelTest, parcel_write_int16_P) {
189 int ret = parcel_write_int16(GetHandle(), 1);
190 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
192 ret = parcel_read_int16(GetHandle(), &val);
193 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
197 TEST_F(ParcelTest, parcel_write_int16_N) {
198 int ret = parcel_write_int16(nullptr, 1);
199 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
202 TEST_F(ParcelTest, parcel_write_int32_P) {
203 int ret = parcel_write_int32(GetHandle(), 1);
204 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
206 ret = parcel_read_int32(GetHandle(), &val);
207 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
211 TEST_F(ParcelTest, parcel_write_int32_N) {
212 int ret = parcel_write_int32(nullptr, 1);
213 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
216 TEST_F(ParcelTest, parcel_write_int64_P) {
217 int ret = parcel_write_int64(GetHandle(), 1);
218 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
220 ret = parcel_read_int64(GetHandle(), &val);
221 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
225 TEST_F(ParcelTest, parcel_write_int64_N) {
226 int ret = parcel_write_int64(nullptr, 1);
227 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
230 TEST_F(ParcelTest, parcel_write_float_P) {
231 int ret = parcel_write_float(GetHandle(), 0.1f);
232 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
234 ret = parcel_read_float(GetHandle(), &val);
235 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
236 ASSERT_EQ(val, 0.1f);
239 TEST_F(ParcelTest, parcel_write_float_N) {
240 int ret = parcel_write_float(nullptr, 0.1f);
241 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
244 TEST_F(ParcelTest, parcel_write_double_P) {
245 int ret = parcel_write_double(GetHandle(), 0.1f);
246 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
248 ret = parcel_read_double(GetHandle(), &val);
249 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
250 ASSERT_EQ(val, 0.1f);
253 TEST_F(ParcelTest, parcel_write_double_N) {
254 int ret = parcel_write_double(nullptr, 0.1f);
255 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
258 TEST_F(ParcelTest, parcel_write_string_P) {
259 int ret = parcel_write_string(GetHandle(), "TestString");
260 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
262 ret = parcel_read_string(GetHandle(), &str);
263 ASSERT_NE(str, nullptr);
264 auto ptr = std::unique_ptr<char, decltype(std::free)*>(str, std::free);
265 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
266 ASSERT_EQ(std::string(str), "TestString");
269 TEST_F(ParcelTest, parcel_write_string_N) {
270 int ret = parcel_write_string(nullptr, nullptr);
271 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
274 TEST_F(ParcelTest, parcel_write_bundle_P) {
275 bundle* b = bundle_create();
276 bundle_add_str(b, "Key", "Value");
277 int ret = parcel_write_bundle(GetHandle(), b);
279 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
281 ret = parcel_read_bundle(GetHandle(), &b);
282 ASSERT_NE(b, nullptr);
283 auto ptr = std::unique_ptr<std::remove_pointer<bundle>::type,
284 decltype(bundle_free)*>(b, bundle_free);
285 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
287 bundle_get_str(b, "Key", &str);
288 ASSERT_EQ(std::string(str), "Value");
291 TEST_F(ParcelTest, parcel_write_bundle_N) {
292 int ret = parcel_write_bundle(nullptr, nullptr);
293 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
296 TEST_F(ParcelTest, parcel_read_bool_P) {
297 int ret = parcel_write_bool(GetHandle(), false);
298 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
300 ret = parcel_read_bool(GetHandle(), &val);
301 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
302 ASSERT_EQ(val, false);
305 TEST_F(ParcelTest, parcel_read_bool_N) {
306 int ret = parcel_read_bool(nullptr, nullptr);
307 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
310 TEST_F(ParcelTest, parcel_read_byte_P) {
311 int ret = parcel_write_byte(GetHandle(), 2);
312 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
314 ret = parcel_read_byte(GetHandle(), &val);
315 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
319 TEST_F(ParcelTest, parcel_read_byte_N) {
320 int ret = parcel_read_byte(nullptr, nullptr);
321 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
324 TEST_F(ParcelTest, parcel_read_uint16_P) {
325 int ret = parcel_write_uint16(GetHandle(), 2);
326 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
328 ret = parcel_read_uint16(GetHandle(), &val);
329 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
333 TEST_F(ParcelTest, parcel_read_uint16_N) {
334 int ret = parcel_read_uint16(nullptr, nullptr);
335 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
338 TEST_F(ParcelTest, parcel_read_uint32_P) {
339 int ret = parcel_write_uint32(GetHandle(), 2);
340 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
342 ret = parcel_read_uint32(GetHandle(), &val);
343 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
347 TEST_F(ParcelTest, parcel_read_uint32_N) {
348 int ret = parcel_read_uint32(nullptr, nullptr);
349 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
352 TEST_F(ParcelTest, parcel_read_uint64_P) {
353 int ret = parcel_write_uint64(GetHandle(), 2);
354 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
356 ret = parcel_read_uint64(GetHandle(), &val);
357 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
361 TEST_F(ParcelTest, parcel_read_uint64_N) {
362 int ret = parcel_read_uint64(nullptr, nullptr);
363 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
366 TEST_F(ParcelTest, parcel_read_int16_P) {
367 int ret = parcel_write_int16(GetHandle(), 2);
368 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
370 ret = parcel_read_int16(GetHandle(), &val);
371 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
375 TEST_F(ParcelTest, parcel_read_int16_N) {
376 int ret = parcel_read_int16(nullptr, nullptr);
377 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
380 TEST_F(ParcelTest, parcel_read_int32_P) {
381 int ret = parcel_write_int32(GetHandle(), 2);
382 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
384 ret = parcel_read_int32(GetHandle(), &val);
385 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
389 TEST_F(ParcelTest, parcel_read_int32_N) {
390 int ret = parcel_read_int32(nullptr, nullptr);
391 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
394 TEST_F(ParcelTest, parcel_read_int64_P) {
395 int ret = parcel_write_int64(GetHandle(), 2);
396 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
398 ret = parcel_read_int64(GetHandle(), &val);
399 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
403 TEST_F(ParcelTest, parcel_read_int64_N) {
404 int ret = parcel_read_int64(nullptr, nullptr);
405 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
408 TEST_F(ParcelTest, parcel_read_float_P) {
409 int ret = parcel_write_float(GetHandle(), 0.2f);
410 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
412 ret = parcel_read_float(GetHandle(), &val);
413 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
414 ASSERT_EQ(val, 0.2f);
417 TEST_F(ParcelTest, parcel_read_float_N) {
418 int ret = parcel_read_float(nullptr, nullptr);
419 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
422 TEST_F(ParcelTest, parcel_read_double_P) {
423 int ret = parcel_write_double(GetHandle(), 0.2f);
424 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
426 ret = parcel_read_double(GetHandle(), &val);
427 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
428 ASSERT_EQ(val, 0.2f);
431 TEST_F(ParcelTest, parcel_read_double_N) {
432 int ret = parcel_read_double(nullptr, nullptr);
433 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
436 TEST_F(ParcelTest, parcel_read_string_P) {
437 int ret = parcel_write_string(GetHandle(), "ReadCString");
438 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
440 ret = parcel_read_string(GetHandle(), &str);
441 ASSERT_NE(str, nullptr);
442 auto ptr = std::unique_ptr<char, decltype(std::free)*>(str, std::free);
443 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
444 ASSERT_EQ(std::string(str), "ReadCString");
447 TEST_F(ParcelTest, parcel_read_string_N) {
448 int ret = parcel_read_string(nullptr, nullptr);
449 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
452 TEST_F(ParcelTest, parcel_read_bundle_P) {
453 bundle* b = bundle_create();
454 bundle_add_str(b, "Key", "Value");
455 int ret = parcel_write_bundle(GetHandle(), b);
457 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
459 ret = parcel_read_bundle(GetHandle(), &b);
460 ASSERT_NE(b, nullptr);
461 auto ptr = std::unique_ptr<std::remove_pointer<bundle>::type,
462 decltype(bundle_free)*>(b, bundle_free);
463 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
465 bundle_get_str(b, "Key", &str);
466 ASSERT_EQ(std::string(str), "Value");
469 TEST_F(ParcelTest, parcel_read_bundle_N) {
470 int ret = parcel_read_bundle(nullptr, nullptr);
471 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
474 TEST_F(ParcelTest, parcel_reset_reader_P) {
475 int ret = parcel_reset_reader(GetHandle());
476 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
479 TEST_F(ParcelTest, parcel_reset_reader_N) {
480 int ret = parcel_reset_reader(nullptr);
481 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
484 TEST_F(ParcelTest, parcel_clear_P) {
485 int ret = parcel_clear(GetHandle());
486 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
489 TEST_F(ParcelTest, parcel_clear_N) {
490 int ret = parcel_clear(nullptr);
491 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
494 TEST_F(ParcelTest, parcel_reset_P) {
495 char buf[1024] = { 128, };
496 int ret = parcel_reset(GetHandle(), buf, sizeof(buf));
497 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
498 char read_buf[1024] = { 0, };
499 ret = parcel_burst_read(GetHandle(), read_buf, sizeof(read_buf));
500 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
501 ASSERT_EQ(read_buf[0], buf[0]);
504 TEST_F(ParcelTest, parcel_reset_N) {
505 int ret = parcel_reset(nullptr, nullptr, 0);
506 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
509 static void __write_to_parcel(parcel_h parcel, void* data) {
510 parcel_write_int32(parcel, 1);
513 static void __read_from_parcel(parcel_h parcel, void* data) {
514 int32_t* val = static_cast<int32_t*>(data);
515 parcel_read_int32(parcel, val);
518 TEST_F(ParcelTest, parcel_write_P) {
519 parcelable_t parcelable = {
520 .to = __write_to_parcel,
521 .from = __read_from_parcel
523 int ret = parcel_write(GetHandle(), &parcelable, nullptr);
524 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
526 ret = parcel_read(GetHandle(), &parcelable, static_cast<void*>(&val));
527 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
531 TEST_F(ParcelTest, parcel_write_N) {
532 int ret = parcel_write(nullptr, nullptr, nullptr);
533 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
536 TEST_F(ParcelTest, parcel_read_P) {
537 parcelable_t parcelable = {
538 .to = __write_to_parcel,
539 .from = __read_from_parcel
541 int ret = parcel_write(GetHandle(), &parcelable, nullptr);
542 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
544 ret = parcel_read(GetHandle(), &parcelable, static_cast<void*>(&val));
545 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
549 TEST_F(ParcelTest, parcel_read_N) {
550 int ret = parcel_read(nullptr, nullptr, nullptr);
551 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
554 TEST_F(ParcelTest, parcel_get_raw_P) {
555 int ret = parcel_write_int32(GetHandle(), 1);
556 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
557 uint8_t* raw = nullptr;
559 ret = parcel_get_raw(GetHandle(), reinterpret_cast<void**>(&raw), &size);
560 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
561 ASSERT_NE(raw, nullptr);
562 ASSERT_EQ(size, sizeof(uint32_t) + sizeof(int32_t));
565 TEST_F(ParcelTest, parcel_get_raw_N) {
566 int ret = parcel_get_raw(nullptr, nullptr, nullptr);
567 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);