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_read_bool_P) {
275 int ret = parcel_write_bool(GetHandle(), false);
276 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
278 ret = parcel_read_bool(GetHandle(), &val);
279 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
280 ASSERT_EQ(val, false);
283 TEST_F(ParcelTest, parcel_read_bool_N) {
284 int ret = parcel_read_bool(nullptr, nullptr);
285 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
288 TEST_F(ParcelTest, parcel_read_byte_P) {
289 int ret = parcel_write_byte(GetHandle(), 2);
290 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
292 ret = parcel_read_byte(GetHandle(), &val);
293 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
297 TEST_F(ParcelTest, parcel_read_byte_N) {
298 int ret = parcel_read_byte(nullptr, nullptr);
299 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
302 TEST_F(ParcelTest, parcel_read_uint16_P) {
303 int ret = parcel_write_uint16(GetHandle(), 2);
304 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
306 ret = parcel_read_uint16(GetHandle(), &val);
307 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
311 TEST_F(ParcelTest, parcel_read_uint16_N) {
312 int ret = parcel_read_uint16(nullptr, nullptr);
313 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
316 TEST_F(ParcelTest, parcel_read_uint32_P) {
317 int ret = parcel_write_uint32(GetHandle(), 2);
318 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
320 ret = parcel_read_uint32(GetHandle(), &val);
321 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
325 TEST_F(ParcelTest, parcel_read_uint32_N) {
326 int ret = parcel_read_uint32(nullptr, nullptr);
327 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
330 TEST_F(ParcelTest, parcel_read_uint64_P) {
331 int ret = parcel_write_uint64(GetHandle(), 2);
332 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
334 ret = parcel_read_uint64(GetHandle(), &val);
335 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
339 TEST_F(ParcelTest, parcel_read_uint64_N) {
340 int ret = parcel_read_uint64(nullptr, nullptr);
341 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
344 TEST_F(ParcelTest, parcel_read_int16_P) {
345 int ret = parcel_write_int16(GetHandle(), 2);
346 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
348 ret = parcel_read_int16(GetHandle(), &val);
349 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
353 TEST_F(ParcelTest, parcel_read_int16_N) {
354 int ret = parcel_read_int16(nullptr, nullptr);
355 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
358 TEST_F(ParcelTest, parcel_read_int32_P) {
359 int ret = parcel_write_int32(GetHandle(), 2);
360 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
362 ret = parcel_read_int32(GetHandle(), &val);
363 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
367 TEST_F(ParcelTest, parcel_read_int32_N) {
368 int ret = parcel_read_int32(nullptr, nullptr);
369 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
372 TEST_F(ParcelTest, parcel_read_int64_P) {
373 int ret = parcel_write_int64(GetHandle(), 2);
374 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
376 ret = parcel_read_int64(GetHandle(), &val);
377 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
381 TEST_F(ParcelTest, parcel_read_int64_N) {
382 int ret = parcel_read_int64(nullptr, nullptr);
383 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
386 TEST_F(ParcelTest, parcel_read_float_P) {
387 int ret = parcel_write_float(GetHandle(), 0.2f);
388 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
390 ret = parcel_read_float(GetHandle(), &val);
391 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
392 ASSERT_EQ(val, 0.2f);
395 TEST_F(ParcelTest, parcel_read_float_N) {
396 int ret = parcel_read_float(nullptr, nullptr);
397 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
400 TEST_F(ParcelTest, parcel_read_double_P) {
401 int ret = parcel_write_double(GetHandle(), 0.2f);
402 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
404 ret = parcel_read_double(GetHandle(), &val);
405 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
406 ASSERT_EQ(val, 0.2f);
409 TEST_F(ParcelTest, parcel_read_double_N) {
410 int ret = parcel_read_double(nullptr, nullptr);
411 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
414 TEST_F(ParcelTest, parcel_read_string_P) {
415 int ret = parcel_write_string(GetHandle(), "ReadCString");
416 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
418 ret = parcel_read_string(GetHandle(), &str);
419 ASSERT_NE(str, nullptr);
420 auto ptr = std::unique_ptr<char, decltype(std::free)*>(str, std::free);
421 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
422 ASSERT_EQ(std::string(str), "ReadCString");
425 TEST_F(ParcelTest, parcel_read_string_N) {
426 int ret = parcel_read_string(nullptr, nullptr);
427 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
430 TEST_F(ParcelTest, parcel_reset_reader_P) {
431 int ret = parcel_reset_reader(GetHandle());
432 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
435 TEST_F(ParcelTest, parcel_reset_reader_N) {
436 int ret = parcel_reset_reader(nullptr);
437 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
440 TEST_F(ParcelTest, parcel_clear_P) {
441 int ret = parcel_clear(GetHandle());
442 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
445 TEST_F(ParcelTest, parcel_clear_N) {
446 int ret = parcel_clear(nullptr);
447 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
450 TEST_F(ParcelTest, parcel_reset_P) {
451 char buf[1024] = { 'P', };
452 int ret = parcel_reset(GetHandle(), buf, sizeof(buf));
453 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
454 char read_buf[1024] = { 0, };
455 ret = parcel_burst_read(GetHandle(), read_buf, sizeof(read_buf));
456 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
457 ASSERT_EQ(read_buf[0], buf[0]);
460 TEST_F(ParcelTest, parcel_reset_N) {
461 int ret = parcel_reset(nullptr, nullptr, 0);
462 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
465 static void __write_to_parcel(parcel_h parcel, void* data) {
466 parcel_write_int32(parcel, 1);
469 static void __read_from_parcel(parcel_h parcel, void* data) {
470 int32_t* val = static_cast<int32_t*>(data);
471 parcel_read_int32(parcel, val);
474 TEST_F(ParcelTest, parcel_write_P) {
475 parcelable_t parcelable = {
476 .to = __write_to_parcel,
477 .from = __read_from_parcel
479 int ret = parcel_write(GetHandle(), &parcelable, nullptr);
480 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
482 ret = parcel_read(GetHandle(), &parcelable, static_cast<void*>(&val));
483 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
487 TEST_F(ParcelTest, parcel_write_N) {
488 int ret = parcel_write(nullptr, nullptr, nullptr);
489 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
492 TEST_F(ParcelTest, parcel_read_P) {
493 parcelable_t parcelable = {
494 .to = __write_to_parcel,
495 .from = __read_from_parcel
497 int ret = parcel_write(GetHandle(), &parcelable, nullptr);
498 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
500 ret = parcel_read(GetHandle(), &parcelable, static_cast<void*>(&val));
501 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
505 TEST_F(ParcelTest, parcel_read_N) {
506 int ret = parcel_read(nullptr, nullptr, nullptr);
507 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
510 TEST_F(ParcelTest, parcel_get_raw_P) {
511 int ret = parcel_write_int32(GetHandle(), 1);
512 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
513 uint8_t* raw = nullptr;
515 ret = parcel_get_raw(GetHandle(), reinterpret_cast<void**>(&raw), &size);
516 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
517 ASSERT_NE(raw, nullptr);
518 ASSERT_EQ(size, sizeof(int32_t));
521 TEST_F(ParcelTest, parcel_get_raw_N) {
522 int ret = parcel_get_raw(nullptr, nullptr, nullptr);
523 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
526 TEST_F(ParcelTest, parcel_set_byte_order_P) {
527 int ret = parcel_set_byte_order(GetHandle(), true);
528 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
529 ret = parcel_write_int32(GetHandle(), 1);
530 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
532 ret = parcel_read_int32(GetHandle(), &val);
533 ASSERT_EQ(ret, PARCEL_ERROR_NONE);
537 TEST_F(ParcelTest, parcel_set_byte_order_N) {
538 int ret = parcel_set_byte_order(nullptr, false);
539 ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);