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_read_bool_P) {
 275   int ret = parcel_write_bool(GetHandle(), false);
 276   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 277   bool val = true;
 278   ret = parcel_read_bool(GetHandle(), &val);
 279   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 280   ASSERT_EQ(val, false);
 281 }
 282
 283 TEST_F(ParcelTest, parcel_read_bool_N) {
 284   int ret = parcel_read_bool(nullptr, nullptr);
 285   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 286 }
 287
 288 TEST_F(ParcelTest, parcel_read_byte_P) {
 289   int ret = parcel_write_byte(GetHandle(), 2);
 290   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 291   char val = 0;
 292   ret = parcel_read_byte(GetHandle(), &val);
 293   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 294   ASSERT_EQ(val, 2);
 295 }
 296
 297 TEST_F(ParcelTest, parcel_read_byte_N) {
 298   int ret = parcel_read_byte(nullptr, nullptr);
 299   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 300 }
 301
 302 TEST_F(ParcelTest, parcel_read_uint16_P) {
 303   int ret = parcel_write_uint16(GetHandle(), 2);
 304   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 305   uint16_t val = 0;
 306   ret = parcel_read_uint16(GetHandle(), &val);
 307   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 308   ASSERT_EQ(val, 2);
 309 }
 310
 311 TEST_F(ParcelTest, parcel_read_uint16_N) {
 312   int ret = parcel_read_uint16(nullptr, nullptr);
 313   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 314 }
 315
 316 TEST_F(ParcelTest, parcel_read_uint32_P) {
 317   int ret = parcel_write_uint32(GetHandle(), 2);
 318   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 319   uint32_t val = 0;
 320   ret = parcel_read_uint32(GetHandle(), &val);
 321   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 322   ASSERT_EQ(val, 2);
 323 }
 324
 325 TEST_F(ParcelTest, parcel_read_uint32_N) {
 326   int ret = parcel_read_uint32(nullptr, nullptr);
 327   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 328 }
 329
 330 TEST_F(ParcelTest, parcel_read_uint64_P) {
 331   int ret = parcel_write_uint64(GetHandle(), 2);
 332   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 333   uint64_t val = 0;
 334   ret = parcel_read_uint64(GetHandle(), &val);
 335   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 336   ASSERT_EQ(val, 2);
 337 }
 338
 339 TEST_F(ParcelTest, parcel_read_uint64_N) {
 340   int ret = parcel_read_uint64(nullptr, nullptr);
 341   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 342 }
 343
 344 TEST_F(ParcelTest, parcel_read_int16_P) {
 345   int ret = parcel_write_int16(GetHandle(), 2);
 346   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 347   int16_t val = 0;
 348   ret = parcel_read_int16(GetHandle(), &val);
 349   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 350   ASSERT_EQ(val, 2);
 351 }
 352
 353 TEST_F(ParcelTest, parcel_read_int16_N) {
 354   int ret = parcel_read_int16(nullptr, nullptr);
 355   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 356 }
 357
 358 TEST_F(ParcelTest, parcel_read_int32_P) {
 359   int ret = parcel_write_int32(GetHandle(), 2);
 360   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 361   int32_t val = 0;
 362   ret = parcel_read_int32(GetHandle(), &val);
 363   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 364   ASSERT_EQ(val, 2);
 365 }
 366
 367 TEST_F(ParcelTest, parcel_read_int32_N) {
 368   int ret = parcel_read_int32(nullptr, nullptr);
 369   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 370 }
 371
 372 TEST_F(ParcelTest, parcel_read_int64_P) {
 373   int ret = parcel_write_int64(GetHandle(), 2);
 374   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 375   int64_t val = 0;
 376   ret = parcel_read_int64(GetHandle(), &val);
 377   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 378   ASSERT_EQ(val, 2);
 379 }
 380
 381 TEST_F(ParcelTest, parcel_read_int64_N) {
 382   int ret = parcel_read_int64(nullptr, nullptr);
 383   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 384 }
 385
 386 TEST_F(ParcelTest, parcel_read_float_P) {
 387   int ret = parcel_write_float(GetHandle(), 0.2f);
 388   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 389   float val = 0.0f;
 390   ret = parcel_read_float(GetHandle(), &val);
 391   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 392   ASSERT_EQ(val, 0.2f);
 393 }
 394
 395 TEST_F(ParcelTest, parcel_read_float_N) {
 396   int ret = parcel_read_float(nullptr, nullptr);
 397   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 398 }
 399
 400 TEST_F(ParcelTest, parcel_read_double_P) {
 401   int ret = parcel_write_double(GetHandle(), 0.2f);
 402   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 403   double val = 0.0f;
 404   ret = parcel_read_double(GetHandle(), &val);
 405   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 406   ASSERT_EQ(val, 0.2f);
 407 }
 408
 409 TEST_F(ParcelTest, parcel_read_double_N) {
 410   int ret = parcel_read_double(nullptr, nullptr);
 411   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 412 }
 413
 414 TEST_F(ParcelTest, parcel_read_string_P) {
 415   int ret = parcel_write_string(GetHandle(), "ReadCString");
 416   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 417   char* str = nullptr;
 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");
 423 }
 424
 425 TEST_F(ParcelTest, parcel_read_string_N) {
 426   int ret = parcel_read_string(nullptr, nullptr);
 427   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 428 }
 429
 430 TEST_F(ParcelTest, parcel_reset_reader_P) {
 431   int ret = parcel_reset_reader(GetHandle());
 432   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 433 }
 434
 435 TEST_F(ParcelTest, parcel_reset_reader_N) {
 436   int ret = parcel_reset_reader(nullptr);
 437   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 438 }
 439
 440 TEST_F(ParcelTest, parcel_clear_P) {
 441   int ret = parcel_clear(GetHandle());
 442   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 443 }
 444
 445 TEST_F(ParcelTest, parcel_clear_N) {
 446   int ret = parcel_clear(nullptr);
 447   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 448 }
 449
 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]);
 458 }
 459
 460 TEST_F(ParcelTest, parcel_reset_N) {
 461   int ret = parcel_reset(nullptr, nullptr, 0);
 462   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 463 }
 464
 465 static void __write_to_parcel(parcel_h parcel, void* data) {
 466   parcel_write_int32(parcel, 1);
 467 }
 468
 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);
 472 }
 473
 474 TEST_F(ParcelTest, parcel_write_P) {
 475   parcelable_t parcelable = {
 476     .to = __write_to_parcel,
 477     .from = __read_from_parcel
 478   };
 479   int ret = parcel_write(GetHandle(), &parcelable, nullptr);
 480   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 481   int32_t val = 0;
 482   ret = parcel_read(GetHandle(), &parcelable, static_cast<void*>(&val));
 483   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 484   ASSERT_EQ(val, 1);
 485 }
 486
 487 TEST_F(ParcelTest, parcel_write_N) {
 488   int ret = parcel_write(nullptr, nullptr, nullptr);
 489   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 490 }
 491
 492 TEST_F(ParcelTest, parcel_read_P) {
 493   parcelable_t parcelable = {
 494     .to = __write_to_parcel,
 495     .from = __read_from_parcel
 496   };
 497   int ret = parcel_write(GetHandle(), &parcelable, nullptr);
 498   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 499   int32_t val = 0;
 500   ret = parcel_read(GetHandle(), &parcelable, static_cast<void*>(&val));
 501   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 502   ASSERT_EQ(val, 1);
 503 }
 504
 505 TEST_F(ParcelTest, parcel_read_N) {
 506   int ret = parcel_read(nullptr, nullptr, nullptr);
 507   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 508 }
 509
 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;
 514   uint32_t size = 0;
 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));
 519 }
 520
 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);
 524 }
 525
 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);
 531   int32_t val = 0;
 532   ret = parcel_read_int32(GetHandle(), &val);
 533   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 534   ASSERT_EQ(val, 1);
 535 }
 536
 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);
 540 }
 541
 542 TEST_F(ParcelTest, parcel_get_data_capacity_P) {
 543   size_t size = 0;
 544   int ret = parcel_get_data_capacity(GetHandle(), &size);
 545   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 546   ASSERT_NE(size, 0);
 547 }
 548
 549 TEST_F(ParcelTest, parcel_get_data_capacity_N) {
 550   int ret = parcel_get_data_capacity(nullptr, nullptr);
 551   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 552 }
 553
 554 TEST_F(ParcelTest, parcel_set_data_capacity_P) {
 555   int ret = parcel_set_data_capacity(GetHandle(), 128);
 556   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 557
 558   size_t size = 0;
 559   ret = parcel_get_data_capacity(GetHandle(), &size);
 560   ASSERT_EQ(ret, PARCEL_ERROR_NONE);
 561   ASSERT_EQ(size, 128);
 562 }
 563
 564 TEST_F(ParcelTest, parcel_set_data_capacity_N) {
 565   int ret = parcel_set_data_capacity(nullptr, 0);
 566   ASSERT_EQ(ret, PARCEL_ERROR_INVALID_PARAMETER);
 567 }