tests/parcel_unittests/test_parcel.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 <gmock/gmock.h>
  18 #include <gtest/gtest.h>
  19
  20 #include <iostream>
  21 #include <stdexcept>
  22 #include <string>
  23
  24 #include "parcel/api/parcel.h"
  25
  26 class ParcelTest : public ::testing::Test {
  27  public:
  28   virtual void SetUp() {
  29     parcel_create(&parcel_);
  30   }
  31
  32   virtual void TearDown() {
  33     if (parcel_)
  34       parcel_destroy(parcel_);
  35   }
  36
  37   parcel_h GetHandle() {
  38     return parcel_;
  39   }
  40
  41   void SetHandle(parcel_h* parcel) {
  42     parcel_ = parcel;
  43   }
  44
  45  private:
  46   parcel_h parcel_ = nullptr;
  47 };
  48
  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);
  56 }
  57
  58 TEST_F(ParcelTest, parcel_create_N) {
  59   int ret = parcel_create(nullptr);
  60   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
  61 }
  62
  63 TEST_F(ParcelTest, parcel_destroy_P) {
  64   int ret = parcel_destroy(GetHandle());
  65   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
  66   SetHandle(nullptr);
  67 }
  68
  69 TEST_F(ParcelTest, parcel_destroy_N) {
  70   int ret = parcel_destroy(nullptr);
  71   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
  72 }
  73
  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);
  81 }
  82
  83 TEST_F(ParcelTest, parcel_clone_N) {
  84   int ret = parcel_clone(nullptr, nullptr);
  85   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
  86 }
  87
  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);
  92   char read_buf[1024];
  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);
  96 }
  97
  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);
 101 }
 102
 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);
 107   char read_buf[1024];
 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);
 111 }
 112
 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);
 116 }
 117
 118 TEST_F(ParcelTest, parcel_write_bool_P) {
 119   int ret = parcel_write_bool(GetHandle(), true);
 120   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 121   bool val = false;
 122   ret = parcel_read_bool(GetHandle(), &val);
 123   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 124   ASSERT_EQ(val, true);
 125 }
 126
 127 TEST_F(ParcelTest, parcel_write_bool_N) {
 128   int ret = parcel_write_bool(nullptr, false);
 129   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 130 }
 131
 132 TEST_F(ParcelTest, parcel_write_byte_P) {
 133   int ret = parcel_write_byte(GetHandle(), 1);
 134   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 135   char val = 0;
 136   ret = parcel_read_byte(GetHandle(), &val);
 137   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 138   ASSERT_EQ(val, 1);
 139 }
 140
 141 TEST_F(ParcelTest, parcel_write_byte_N) {
 142   int ret = parcel_write_byte(nullptr, 1);
 143   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 144 }
 145
 146 TEST_F(ParcelTest, parcel_write_uint16_P) {
 147   int ret = parcel_write_uint16(GetHandle(), 1);
 148   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 149   uint16_t val = 0;
 150   ret = parcel_read_uint16(GetHandle(), &val);
 151   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 152   ASSERT_EQ(val, 1);
 153 }
 154
 155 TEST_F(ParcelTest, parcel_write_uint16_N) {
 156   int ret = parcel_write_uint16(nullptr, 1);
 157   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 158 }
 159
 160 TEST_F(ParcelTest, parcel_write_uint32_P) {
 161   int ret = parcel_write_uint32(GetHandle(), 1);
 162   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 163   uint32_t val = 0;
 164   ret = parcel_read_uint32(GetHandle(), &val);
 165   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 166   ASSERT_EQ(val, 1);
 167 }
 168
 169 TEST_F(ParcelTest, parcel_write_uint32_N) {
 170   int ret = parcel_write_uint32(nullptr, 1);
 171   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 172 }
 173
 174 TEST_F(ParcelTest, parcel_write_uint64_P) {
 175   int ret = parcel_write_uint64(GetHandle(), 1);
 176   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 177   uint64_t val = 0;
 178   ret = parcel_read_uint64(GetHandle(), &val);
 179   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 180   ASSERT_EQ(val, 1);
 181 }
 182
 183 TEST_F(ParcelTest, parcel_write_uint64_N) {
 184   int ret = parcel_write_uint64(nullptr, 1);
 185   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 186 }
 187
 188 TEST_F(ParcelTest, parcel_write_int16_P) {
 189   int ret = parcel_write_int16(GetHandle(), 1);
 190   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 191   int16_t val = 0;
 192   ret = parcel_read_int16(GetHandle(), &val);
 193   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 194   ASSERT_EQ(val, 1);
 195 }
 196
 197 TEST_F(ParcelTest, parcel_write_int16_N) {
 198   int ret = parcel_write_int16(nullptr, 1);
 199   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 200 }
 201
 202 TEST_F(ParcelTest, parcel_write_int32_P) {
 203   int ret = parcel_write_int32(GetHandle(), 1);
 204   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 205   int32_t val = 0;
 206   ret = parcel_read_int32(GetHandle(), &val);
 207   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 208   ASSERT_EQ(val, 1);
 209 }
 210
 211 TEST_F(ParcelTest, parcel_write_int32_N) {
 212   int ret = parcel_write_int32(nullptr, 1);
 213   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 214 }
 215
 216 TEST_F(ParcelTest, parcel_write_int64_P) {
 217   int ret = parcel_write_int64(GetHandle(), 1);
 218   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 219   int64_t val = 0;
 220   ret = parcel_read_int64(GetHandle(), &val);
 221   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 222   ASSERT_EQ(val, 1);
 223 }
 224
 225 TEST_F(ParcelTest, parcel_write_int64_N) {
 226   int ret = parcel_write_int64(nullptr, 1);
 227   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 228 }
 229
 230 TEST_F(ParcelTest, parcel_write_float_P) {
 231   int ret = parcel_write_float(GetHandle(), 0.1f);
 232   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 233   float val = 0.0f;
 234   ret = parcel_read_float(GetHandle(), &val);
 235   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 236   ASSERT_EQ(val, 0.1f);
 237 }
 238
 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);
 242 }
 243
 244 TEST_F(ParcelTest, parcel_write_double_P) {
 245   int ret = parcel_write_double(GetHandle(), 0.1f);
 246   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 247   double val = 0.0f;
 248   ret = parcel_read_double(GetHandle(), &val);
 249   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 250   ASSERT_EQ(val, 0.1f);
 251 }
 252
 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);
 256 }
 257
 258 TEST_F(ParcelTest, parcel_write_string_P) {
 259   int ret = parcel_write_string(GetHandle(), "TestString");
 260   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 261   char* str = nullptr;
 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");
 267 }
 268
 269 TEST_F(ParcelTest, parcel_write_string_N) {
 270   int ret = parcel_write_string(nullptr, nullptr);
 271   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 272 }
 273
 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);
 278   bundle_free(b);
 279   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 280   b = nullptr;
 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);
 286   char* str = nullptr;
 287   bundle_get_str(b, "Key", &str);
 288   ASSERT_EQ(std::string(str), "Value");
 289 }
 290
 291 TEST_F(ParcelTest, parcel_write_bundle_N) {
 292   int ret = parcel_write_bundle(nullptr, nullptr);
 293   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 294 }
 295
 296 TEST_F(ParcelTest, parcel_read_bool_P) {
 297   int ret = parcel_write_bool(GetHandle(), false);
 298   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 299   bool val = true;
 300   ret = parcel_read_bool(GetHandle(), &val);
 301   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 302   ASSERT_EQ(val, false);
 303 }
 304
 305 TEST_F(ParcelTest, parcel_read_bool_N) {
 306   int ret = parcel_read_bool(nullptr, nullptr);
 307   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 308 }
 309
 310 TEST_F(ParcelTest, parcel_read_byte_P) {
 311   int ret = parcel_write_byte(GetHandle(), 2);
 312   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 313   char val = 0;
 314   ret = parcel_read_byte(GetHandle(), &val);
 315   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 316   ASSERT_EQ(val, 2);
 317 }
 318
 319 TEST_F(ParcelTest, parcel_read_byte_N) {
 320   int ret = parcel_read_byte(nullptr, nullptr);
 321   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 322 }
 323
 324 TEST_F(ParcelTest, parcel_read_uint16_P) {
 325   int ret = parcel_write_uint16(GetHandle(), 2);
 326   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 327   uint16_t val = 0;
 328   ret = parcel_read_uint16(GetHandle(), &val);
 329   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 330   ASSERT_EQ(val, 2);
 331 }
 332
 333 TEST_F(ParcelTest, parcel_read_uint16_N) {
 334   int ret = parcel_read_uint16(nullptr, nullptr);
 335   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 336 }
 337
 338 TEST_F(ParcelTest, parcel_read_uint32_P) {
 339   int ret = parcel_write_uint32(GetHandle(), 2);
 340   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 341   uint32_t val = 0;
 342   ret = parcel_read_uint32(GetHandle(), &val);
 343   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 344   ASSERT_EQ(val, 2);
 345 }
 346
 347 TEST_F(ParcelTest, parcel_read_uint32_N) {
 348   int ret = parcel_read_uint32(nullptr, nullptr);
 349   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 350 }
 351
 352 TEST_F(ParcelTest, parcel_read_uint64_P) {
 353   int ret = parcel_write_uint64(GetHandle(), 2);
 354   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 355   uint64_t val = 0;
 356   ret = parcel_read_uint64(GetHandle(), &val);
 357   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 358   ASSERT_EQ(val, 2);
 359 }
 360
 361 TEST_F(ParcelTest, parcel_read_uint64_N) {
 362   int ret = parcel_read_uint64(nullptr, nullptr);
 363   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 364 }
 365
 366 TEST_F(ParcelTest, parcel_read_int16_P) {
 367   int ret = parcel_write_int16(GetHandle(), 2);
 368   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 369   int16_t val = 0;
 370   ret = parcel_read_int16(GetHandle(), &val);
 371   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 372   ASSERT_EQ(val, 2);
 373 }
 374
 375 TEST_F(ParcelTest, parcel_read_int16_N) {
 376   int ret = parcel_read_int16(nullptr, nullptr);
 377   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 378 }
 379
 380 TEST_F(ParcelTest, parcel_read_int32_P) {
 381   int ret = parcel_write_int32(GetHandle(), 2);
 382   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 383   int32_t val = 0;
 384   ret = parcel_read_int32(GetHandle(), &val);
 385   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 386   ASSERT_EQ(val, 2);
 387 }
 388
 389 TEST_F(ParcelTest, parcel_read_int32_N) {
 390   int ret = parcel_read_int32(nullptr, nullptr);
 391   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 392 }
 393
 394 TEST_F(ParcelTest, parcel_read_int64_P) {
 395   int ret = parcel_write_int64(GetHandle(), 2);
 396   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 397   int64_t val = 0;
 398   ret = parcel_read_int64(GetHandle(), &val);
 399   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 400   ASSERT_EQ(val, 2);
 401 }
 402
 403 TEST_F(ParcelTest, parcel_read_int64_N) {
 404   int ret = parcel_read_int64(nullptr, nullptr);
 405   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 406 }
 407
 408 TEST_F(ParcelTest, parcel_read_float_P) {
 409   int ret = parcel_write_float(GetHandle(), 0.2f);
 410   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 411   float val = 0.0f;
 412   ret = parcel_read_float(GetHandle(), &val);
 413   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 414   ASSERT_EQ(val, 0.2f);
 415 }
 416
 417 TEST_F(ParcelTest, parcel_read_float_N) {
 418   int ret = parcel_read_float(nullptr, nullptr);
 419   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 420 }
 421
 422 TEST_F(ParcelTest, parcel_read_double_P) {
 423   int ret = parcel_write_double(GetHandle(), 0.2f);
 424   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 425   double val = 0.0f;
 426   ret = parcel_read_double(GetHandle(), &val);
 427   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 428   ASSERT_EQ(val, 0.2f);
 429 }
 430
 431 TEST_F(ParcelTest, parcel_read_double_N) {
 432   int ret = parcel_read_double(nullptr, nullptr);
 433   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 434 }
 435
 436 TEST_F(ParcelTest, parcel_read_string_P) {
 437   int ret = parcel_write_string(GetHandle(), "ReadCString");
 438   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 439   char* str = nullptr;
 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");
 445 }
 446
 447 TEST_F(ParcelTest, parcel_read_string_N) {
 448   int ret = parcel_read_string(nullptr, nullptr);
 449   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 450 }
 451
 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);
 456   bundle_free(b);
 457   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 458   b = nullptr;
 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);
 464   char* str = nullptr;
 465   bundle_get_str(b, "Key", &str);
 466   ASSERT_EQ(std::string(str), "Value");
 467 }
 468
 469 TEST_F(ParcelTest, parcel_read_bundle_N) {
 470   int ret = parcel_read_bundle(nullptr, nullptr);
 471   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 472 }
 473
 474 TEST_F(ParcelTest, parcel_reset_reader_P) {
 475   int ret = parcel_reset_reader(GetHandle());
 476   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 477 }
 478
 479 TEST_F(ParcelTest, parcel_reset_reader_N) {
 480   int ret = parcel_reset_reader(nullptr);
 481   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 482 }
 483
 484 TEST_F(ParcelTest, parcel_clear_P) {
 485   int ret = parcel_clear(GetHandle());
 486   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 487 }
 488
 489 TEST_F(ParcelTest, parcel_clear_N) {
 490   int ret = parcel_clear(nullptr);
 491   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 492 }
 493
 494 TEST_F(ParcelTest, parcel_reset_P) {
 495   char buf[1024] = { 'P', };
 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]);
 502 }
 503
 504 TEST_F(ParcelTest, parcel_reset_N) {
 505   int ret = parcel_reset(nullptr, nullptr, 0);
 506   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 507 }
 508
 509 static void __write_to_parcel(parcel_h parcel, void* data) {
 510   parcel_write_int32(parcel, 1);
 511 }
 512
 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);
 516 }
 517
 518 TEST_F(ParcelTest, parcel_write_P) {
 519   parcelable_t parcelable = {
 520     .to = __write_to_parcel,
 521     .from = __read_from_parcel
 522   };
 523   int ret = parcel_write(GetHandle(), &parcelable, nullptr);
 524   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 525   int32_t val = 0;
 526   ret = parcel_read(GetHandle(), &parcelable, static_cast<void*>(&val));
 527   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 528   ASSERT_EQ(val, 1);
 529 }
 530
 531 TEST_F(ParcelTest, parcel_write_N) {
 532   int ret = parcel_write(nullptr, nullptr, nullptr);
 533   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 534 }
 535
 536 TEST_F(ParcelTest, parcel_read_P) {
 537   parcelable_t parcelable = {
 538     .to = __write_to_parcel,
 539     .from = __read_from_parcel
 540   };
 541   int ret = parcel_write(GetHandle(), &parcelable, nullptr);
 542   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 543   int32_t val = 0;
 544   ret = parcel_read(GetHandle(), &parcelable, static_cast<void*>(&val));
 545   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 546   ASSERT_EQ(val, 1);
 547 }
 548
 549 TEST_F(ParcelTest, parcel_read_N) {
 550   int ret = parcel_read(nullptr, nullptr, nullptr);
 551   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 552 }
 553
 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;
 558   uint32_t size = 0;
 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(int32_t));
 563 }
 564
 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);
 568 }