test/unit_tests/test_client.cc

   1 #include "package-manager.h"
   2
   3 #include <gtest/gtest.h>
   4 #include <gmock/gmock.h>
   5
   6 #include "unit_tests/mock/rpc_port_mock.hh"
   7 #include "unit_tests/mock/test_fixture.hh"
   8
   9 using ::testing::_;
  10 using ::testing::Invoke;
  11
  12 namespace {
  13 class Mocks : public ::testing::NiceMock<RpcPortMock> {};
  14
  15 }  // namespace
  16
  17 class ClientTest : public TestFixture {
  18  public:
  19   ClientTest() : TestFixture(std::make_unique<::Mocks>()) {}
  20
  21   virtual void SetUp() {
  22     handle_ = pkgmgr_client_new(PC_REQUEST);
  23     listen_handle_ = pkgmgr_client_new(PC_LISTENING);
  24     handler_ = [](uid_t target_uid, int req_id,
  25           const char* pkg_type, const char* pkgid, const char* key,
  26           const char* val, const void* pmsg, void* data) {
  27             return 0;
  28         };
  29     app_handler_ = [](uid_t target_uid, int req_id, const char *pkg_type,
  30           const char *pkgid, const char *appid, const char *key,
  31           const char *val, const void *pmsg, void *data) {
  32             return 0;
  33         };
  34     pkg_size_handler_ = [](pkgmgr_client *pc, const char *pkgid,
  35           const pkg_size_info_t *size_info, void *user_data) {
  36     };
  37
  38     ON_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
  39       .WillByDefault(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
  40         rpc_port_parcel_h parcel;
  41         rpc_port_parcel_create(&parcel);
  42         rpc_port_parcel_write_int32(parcel, 0); // __Result
  43         rpc_port_parcel_write_string(parcel, "req_key");
  44         rpc_port_parcel_write_int32(parcel, 0);
  45         *h = parcel;
  46         return 0;
  47       }));
  48   }
  49
  50   virtual void TearDown() {
  51     if (handle_)
  52       pkgmgr_client_free(handle_);
  53   }
  54
  55   pkgmgr_client* GetHandle() {
  56     return handle_;
  57   }
  58
  59   pkgmgr_client* GetListenHandle() {
  60     return listen_handle_;
  61   }
  62
  63   pkgmgr_handler GetDefaultHandler() {
  64     return handler_;
  65   }
  66
  67   pkgmgr_app_handler GetDefaultAppHandler() {
  68     return app_handler_;
  69   }
  70
  71   pkgmgr_pkg_size_info_receive_cb GetDefaultPkgSizeHandler() {
  72     return pkg_size_handler_;
  73   }
  74
  75  private:
  76   pkgmgr_client* handle_ = nullptr;
  77   pkgmgr_client* listen_handle_ = nullptr;
  78   pkgmgr_handler handler_ = nullptr;
  79   pkgmgr_app_handler app_handler_ = nullptr;
  80   pkgmgr_pkg_size_info_receive_cb pkg_size_handler_ = nullptr;
  81 };
  82
  83 TEST_F(ClientTest, pkgmgr_client_set_tep_path) {
  84   int ret = pkgmgr_client_set_tep_path(GetHandle(), "/tmp/test.tep", true);
  85   EXPECT_TRUE(ret == PKGMGR_R_OK);
  86 }
  87
  88 TEST_F(ClientTest, pkgmgr_client_set_tep_path_n) {
  89   int ret = pkgmgr_client_set_tep_path(GetHandle(), nullptr, true);
  90   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
  91 }
  92
  93 TEST_F(ClientTest, pkgmgr_client_install_packages) {
  94   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
  95       .Times(1);
  96   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
  97       .Times(1);
  98   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
  99       .Times(1);
 100
 101   const char* paths[3] = { "/tmp/a.tpk", "/tmp/b.tpk", "/tmp/c.tpk" };
 102   int ret = pkgmgr_client_install_packages(GetHandle(), paths, 3,
 103       GetDefaultHandler(), nullptr);
 104   EXPECT_TRUE(ret > 0);
 105 }
 106
 107 TEST_F(ClientTest, pkgmgr_client_install_packages_n) {
 108   int ret = pkgmgr_client_install_packages(GetHandle(), nullptr, 0,
 109       GetDefaultHandler(), nullptr);
 110   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 111 }
 112
 113 TEST_F(ClientTest, pkgmgr_client_install) {
 114   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 115       .Times(1);
 116   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 117       .Times(1);
 118   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 119       .Times(1);
 120
 121   int ret = pkgmgr_client_install(GetHandle(), "tpk", "/tmp/desc"
 122       , "/tmp/test.tpk", "", PM_DEFAULT, GetDefaultHandler(), nullptr);
 123   EXPECT_TRUE(ret > 0);
 124 }
 125
 126 TEST_F(ClientTest, pkgmgr_client_install_n) {
 127   int ret = pkgmgr_client_install(GetHandle(), "tpk", "/tmp/desc"
 128       , nullptr, "", PM_DEFAULT, GetDefaultHandler(), nullptr);
 129   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 130 }
 131
 132 TEST_F(ClientTest, pkgmgr_client_reinstall) {
 133   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 134       .Times(1);
 135   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 136       .Times(1);
 137   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 138       .Times(1);
 139
 140   int ret = pkgmgr_client_reinstall(GetHandle(), "tpk", "org.tizen.test"
 141       ,"", PM_DEFAULT, GetDefaultHandler(), nullptr);
 142   EXPECT_TRUE(ret > 0);
 143 }
 144
 145
 146 TEST_F(ClientTest, pkgmgr_client_reinstall_n) {
 147   int ret = pkgmgr_client_reinstall(GetHandle(), "tpk", nullptr,
 148       "", PM_DEFAULT, GetDefaultHandler(), nullptr);
 149   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 150 }
 151
 152 TEST_F(ClientTest, pkgmgr_client_uninstall_packages) {
 153   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 154       .Times(1);
 155   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 156       .Times(1);
 157   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 158       .Times(1);
 159
 160   const char* pkgs[3] = { "/tmp/a.tpk", "/tmp/b.tpk", "/tmp/c.tpk" };
 161   int ret = pkgmgr_client_uninstall_packages(GetHandle(), pkgs, 3,
 162       GetDefaultHandler(), nullptr);
 163   EXPECT_TRUE(ret > 0);
 164 }
 165
 166 TEST_F(ClientTest, pkgmgr_client_uninstall_packages_n) {
 167   int ret = pkgmgr_client_uninstall_packages(GetHandle(), nullptr, 0,
 168       GetDefaultHandler(), nullptr);
 169   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 170 }
 171
 172 TEST_F(ClientTest, pkgmgr_client_uninstall) {
 173   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 174       .Times(1);
 175   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 176       .Times(1);
 177   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 178       .Times(1);
 179
 180   int ret = pkgmgr_client_uninstall(GetHandle(), "tpk", "org.tizen.test",
 181       PM_DEFAULT, GetDefaultHandler(), nullptr);
 182   EXPECT_TRUE(ret > 0);
 183 }
 184
 185 TEST_F(ClientTest, pkgmgr_client_uninstall_n) {
 186   int ret = pkgmgr_client_uninstall(GetHandle(), "tpk", nullptr,
 187       PM_DEFAULT, GetDefaultHandler(), nullptr);
 188   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 189 }
 190
 191 TEST_F(ClientTest, pkgmgr_client_move) {
 192   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 193       .Times(1);
 194   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 195       .Times(1);
 196   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 197       .Times(1);
 198
 199   int ret = pkgmgr_client_move(GetHandle(), "tpk", "org.tizen.test",
 200       PM_MOVE_TO_SDCARD, GetDefaultHandler(), nullptr);
 201   EXPECT_TRUE(ret > 0);
 202 }
 203
 204 TEST_F(ClientTest, pkgmgr_client_move_n) {
 205   int ret = pkgmgr_client_move(GetHandle(), "tpk", nullptr,
 206       PM_MOVE_TO_SDCARD, GetDefaultHandler(), nullptr);
 207   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 208 }
 209
 210 TEST_F(ClientTest, pkgmgr_client_mount_install) {
 211   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 212       .Times(1);
 213   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 214       .Times(1);
 215   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 216       .Times(1);
 217
 218   int ret = pkgmgr_client_mount_install(GetHandle(), "tpk", "/tmp",
 219       "/tmp/test.tpk", "", PM_DEFAULT, GetDefaultHandler(), nullptr);
 220   EXPECT_TRUE(ret > 0);
 221 }
 222
 223 TEST_F(ClientTest, pkgmgr_client_mount_install_n) {
 224   int ret = pkgmgr_client_mount_install(GetHandle(), "tpk", "/tmp",
 225       nullptr, "", PM_DEFAULT, GetDefaultHandler(), nullptr);
 226   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 227 }
 228
 229 TEST_F(ClientTest, pkgmgr_client_mount_install_packages) {
 230   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 231       .Times(1);
 232   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 233       .Times(1);
 234   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 235       .Times(1);
 236
 237   const char* paths[3] = { "/tmp/a.tpk", "/tmp/b.tpk", "/tmp/c.tpk" };
 238   int ret = pkgmgr_client_mount_install_packages(GetHandle(), paths, 3,
 239       GetDefaultHandler(), nullptr);
 240   EXPECT_TRUE(ret > 0);
 241 }
 242
 243 TEST_F(ClientTest, pkgmgr_client_mount_install_packages_n) {
 244   int ret = pkgmgr_client_mount_install_packages(GetHandle(), nullptr, 0,
 245       GetDefaultHandler(), nullptr);
 246   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 247 }
 248
 249 TEST_F(ClientTest, pkgmgr_client_register_pkg_update_info) {
 250   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 251       .Times(2);
 252   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 253       .Times(2);
 254   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 255       .Times(2)
 256       .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
 257         rpc_port_parcel_h parcel;
 258         rpc_port_parcel_create(&parcel);
 259         rpc_port_parcel_write_int32(parcel, 0); // __Result
 260         rpc_port_parcel_write_string(parcel, "req_key");
 261         rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
 262         *h = parcel;
 263         return 0;
 264       }))
 265       .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
 266         rpc_port_parcel_h parcel;
 267         rpc_port_parcel_create(&parcel);
 268         rpc_port_parcel_write_int32(parcel, 0); // __Result
 269         rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
 270         rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
 271         *h = parcel;
 272         return 0;
 273       }));
 274
 275   pkg_update_info_t info = {
 276     .pkgid = const_cast<char*>("org.tizen.test"),
 277     .version = const_cast<char*>("1.0.0"),
 278     .type = PM_UPDATEINFO_TYPE_FORCE
 279   };
 280   int ret = pkgmgr_client_register_pkg_update_info(GetHandle(), &info);
 281   EXPECT_TRUE(ret == PKGMGR_R_OK);
 282 }
 283
 284 TEST_F(ClientTest, pkgmgr_client_register_pkg_update_info_n) {
 285   int ret = pkgmgr_client_register_pkg_update_info(GetHandle(), nullptr);
 286   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 287 }
 288
 289 TEST_F(ClientTest, pkgmgr_client_unregister_pkg_update_info) {
 290   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 291       .Times(2);
 292   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 293       .Times(2);
 294   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 295       .Times(2)
 296       .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
 297         rpc_port_parcel_h parcel;
 298         rpc_port_parcel_create(&parcel);
 299         rpc_port_parcel_write_int32(parcel, 0); // __Result
 300         rpc_port_parcel_write_string(parcel, "req_key");
 301         rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
 302         *h = parcel;
 303         return 0;
 304       }))
 305       .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
 306         rpc_port_parcel_h parcel;
 307         rpc_port_parcel_create(&parcel);
 308         rpc_port_parcel_write_int32(parcel, 0); // __Result
 309         rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
 310         rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
 311         *h = parcel;
 312         return 0;
 313       }));
 314
 315   int ret = pkgmgr_client_unregister_pkg_update_info(GetHandle(),
 316       "org.tizen.test");
 317   EXPECT_TRUE(ret == PKGMGR_R_OK);
 318 }
 319
 320 TEST_F(ClientTest, pkgmgr_client_unregister_pkg_update_info_n) {
 321   int ret = pkgmgr_client_unregister_pkg_update_info(GetHandle(),
 322       nullptr);
 323   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 324 }
 325
 326 TEST_F(ClientTest, pkgmgr_client_unregister_all_pkg_update_info) {
 327   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 328       .Times(1);
 329   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 330       .Times(1);
 331   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 332       .Times(1)
 333       .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
 334         rpc_port_parcel_h parcel;
 335         rpc_port_parcel_create(&parcel);
 336         rpc_port_parcel_write_int32(parcel, 0); // __Result
 337         rpc_port_parcel_write_string(parcel, "req_key");
 338         rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
 339         *h = parcel;
 340         return 0;
 341       }));
 342
 343   int ret = pkgmgr_client_unregister_all_pkg_update_info(GetHandle());
 344   EXPECT_TRUE(ret == PKGMGR_R_OK);
 345 }
 346
 347 TEST_F(ClientTest, pkgmgr_client_unregister_all_pkg_update_info_n) {
 348   int ret = pkgmgr_client_unregister_all_pkg_update_info(nullptr);
 349   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 350 }
 351
 352 TEST_F(ClientTest, pkgmgr_client_activate) {
 353   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 354       .Times(1);
 355   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 356       .Times(1);
 357   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 358       .Times(1);
 359
 360   int ret = pkgmgr_client_activate(GetHandle(), "tpk", "org.tizen.test");
 361   EXPECT_TRUE(ret == PKGMGR_R_OK);
 362 }
 363
 364 TEST_F(ClientTest, pkgmgr_client_activate_n) {
 365   int ret = pkgmgr_client_activate(GetHandle(), "tpk", nullptr);
 366   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 367 }
 368
 369 TEST_F(ClientTest, pkgmgr_client_activate_packages) {
 370   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 371       .Times(1);
 372   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 373       .Times(1);
 374   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 375       .Times(1);
 376
 377   const char* pkgs[3] = { "org.tizen.test1", "org.tizen.test2",
 378       "org.tizen.test3" };
 379   int ret = pkgmgr_client_activate_packages(GetHandle(), "tpk", pkgs, 3,
 380       GetDefaultHandler(), nullptr);
 381   EXPECT_TRUE(ret > 0);
 382 }
 383
 384 TEST_F(ClientTest, pkgmgr_client_activate_packages_n) {
 385   int ret = pkgmgr_client_activate_packages(GetHandle(), "tpk", nullptr, 3,
 386       GetDefaultHandler(), nullptr);
 387   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 388 }
 389
 390 TEST_F(ClientTest, pkgmgr_client_deactivate) {
 391   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 392       .Times(1);
 393   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 394       .Times(1);
 395   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 396       .Times(1);
 397
 398   int ret = pkgmgr_client_deactivate(GetHandle(), "tpk", "org.tizen.test1");
 399   EXPECT_TRUE(ret == PKGMGR_R_OK);
 400 }
 401
 402 TEST_F(ClientTest, pkgmgr_client_deactivate_n) {
 403   int ret = pkgmgr_client_deactivate(GetHandle(), "tpk", nullptr);
 404   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 405 }
 406
 407 TEST_F(ClientTest, pkgmgr_client_deactivate_packages) {
 408   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 409       .Times(1);
 410   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 411       .Times(1);
 412   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 413       .Times(1);
 414
 415   const char* pkgs[3] = { "org.tizen.test1", "org.tizen.test2",
 416       "org.tizen.test3" };
 417   int ret = pkgmgr_client_deactivate_packages(GetHandle(), "tpk", pkgs, 3,
 418       GetDefaultHandler(), nullptr);
 419   EXPECT_TRUE(ret > 0);
 420 }
 421
 422 TEST_F(ClientTest, pkgmgr_client_deactivate_packages_n) {
 423   int ret = pkgmgr_client_deactivate_packages(GetHandle(), "tpk", nullptr, 3,
 424       GetDefaultHandler(), nullptr);
 425   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 426 }
 427
 428 TEST_F(ClientTest, pkgmgr_client_activate_app) {
 429   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 430       .Times(1);
 431   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 432       .Times(1);
 433   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 434       .Times(1);
 435
 436   int ret = pkgmgr_client_activate_app(GetHandle(), "org.tizen.test",
 437       GetDefaultAppHandler(), nullptr);
 438   EXPECT_TRUE(ret > 0);
 439 }
 440
 441 TEST_F(ClientTest, pkgmgr_client_activate_app_n) {
 442   int ret = pkgmgr_client_activate_app(GetHandle(), nullptr,
 443       GetDefaultAppHandler(), nullptr);
 444   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 445 }
 446
 447 TEST_F(ClientTest, pkgmgr_client_activate_apps) {
 448   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 449       .Times(1);
 450   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 451       .Times(1);
 452   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 453       .Times(1);
 454
 455   const char* apps[3] = { "org.tizen.test1", "org.tizen.test2",
 456       "org.tizen.test3" };
 457   int ret = pkgmgr_client_activate_apps(GetHandle(), apps, 3,
 458       GetDefaultAppHandler(), nullptr);
 459   EXPECT_TRUE(ret > 0);
 460 }
 461
 462 TEST_F(ClientTest, pkgmgr_client_activate_apps_n) {
 463   int ret = pkgmgr_client_activate_apps(GetHandle(), nullptr, 3,
 464       GetDefaultAppHandler(), nullptr);
 465   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 466 }
 467
 468 TEST_F(ClientTest, pkgmgr_client_activate_global_app_for_uid) {
 469   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 470       .Times(1);
 471   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 472       .Times(1);
 473   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 474       .Times(1);
 475
 476   int ret = pkgmgr_client_activate_global_app_for_uid(GetHandle(),
 477       "org.tizen.test1", GetDefaultAppHandler(), nullptr, 0);
 478   EXPECT_TRUE(ret > 0);
 479 }
 480
 481 TEST_F(ClientTest, pkgmgr_client_activate_global_app_for_uid_n) {
 482   int ret = pkgmgr_client_activate_global_app_for_uid(GetHandle(), nullptr,
 483       GetDefaultAppHandler(), nullptr, 0);
 484   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 485 }
 486
 487 TEST_F(ClientTest, pkgmgr_client_deactivate_app) {
 488   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 489       .Times(1);
 490   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 491       .Times(1);
 492   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 493       .Times(1);
 494
 495   int ret = pkgmgr_client_deactivate_app(GetHandle(), "org.tizen.test",
 496       GetDefaultAppHandler(), nullptr);
 497   EXPECT_TRUE(ret > 0);
 498 }
 499
 500 TEST_F(ClientTest, pkgmgr_client_deactivate_app_n) {
 501   int ret = pkgmgr_client_deactivate_app(GetHandle(), nullptr,
 502       GetDefaultAppHandler(), nullptr);
 503   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 504 }
 505
 506 TEST_F(ClientTest, pkgmgr_client_deactivate_apps) {
 507   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 508       .Times(1);
 509   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 510       .Times(1);
 511   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 512       .Times(1);
 513
 514   const char* apps[3] = { "org.tizen.test1", "org.tizen.test2",
 515       "org.tizen.test3" };
 516   int ret = pkgmgr_client_deactivate_apps(GetHandle(), apps, 3,
 517       GetDefaultAppHandler(), nullptr);
 518   EXPECT_TRUE(ret > 0);
 519 }
 520
 521 TEST_F(ClientTest, pkgmgr_client_deactivate_apps_n) {
 522   int ret = pkgmgr_client_deactivate_apps(GetHandle(), nullptr, 3,
 523       GetDefaultAppHandler(), nullptr);
 524   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 525 }
 526
 527 TEST_F(ClientTest, pkgmgr_client_deactivate_global_app_for_uid) {
 528   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 529       .Times(1);
 530   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 531       .Times(1);
 532   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 533       .Times(1);
 534
 535   int ret = pkgmgr_client_deactivate_global_app_for_uid(GetHandle(),
 536       "org.tizen.test1", GetDefaultAppHandler(), nullptr, 0);
 537   EXPECT_TRUE(ret > 0);
 538 }
 539
 540 TEST_F(ClientTest, pkgmgr_client_deactivate_global_app_for_uid_n) {
 541   int ret = pkgmgr_client_deactivate_global_app_for_uid(GetHandle(), nullptr,
 542       GetDefaultAppHandler(), nullptr, 0);
 543   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 544 }
 545
 546 TEST_F(ClientTest, pkgmgr_client_clear_user_data) {
 547   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 548       .Times(1);
 549   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 550       .Times(1);
 551   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 552       .Times(1)
 553       .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
 554         rpc_port_parcel_h parcel;
 555         rpc_port_parcel_create(&parcel);
 556         rpc_port_parcel_write_int32(parcel, 0); // __Result
 557         rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
 558         *h = parcel;
 559         return 0;
 560       }));
 561
 562   int ret = pkgmgr_client_clear_user_data(GetHandle(), "tpk",
 563       "org.tizen.test1", PM_DEFAULT);
 564   EXPECT_TRUE(ret == PKGMGR_R_OK);
 565 }
 566
 567 TEST_F(ClientTest, pkgmgr_client_clear_user_data_n) {
 568   int ret = pkgmgr_client_clear_user_data(GetHandle(), "tpk",
 569       nullptr, PM_DEFAULT);
 570   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 571 }
 572
 573 TEST_F(ClientTest, pkgmgr_client_listen_status) {
 574   int ret = pkgmgr_client_listen_status(GetListenHandle(), GetDefaultHandler(), nullptr);
 575   EXPECT_TRUE(ret > 0);
 576 }
 577
 578 TEST_F(ClientTest, pkgmgr_client_listen_status_n) {
 579   int ret = pkgmgr_client_listen_status(nullptr, GetDefaultHandler(), nullptr);
 580   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 581 }
 582
 583 TEST_F(ClientTest, pkgmgr_client_listen_app_status) {
 584   int ret = pkgmgr_client_listen_app_status(GetListenHandle(), GetDefaultAppHandler(), nullptr);
 585   EXPECT_TRUE(ret > 0);
 586 }
 587
 588 TEST_F(ClientTest, pkgmgr_client_listen_app_status_n) {
 589   int ret = pkgmgr_client_listen_app_status(nullptr, GetDefaultAppHandler(), nullptr);
 590   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 591 }
 592
 593 TEST_F(ClientTest, pkgmgr_client_get_size) {
 594   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 595       .Times(1);
 596   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 597       .Times(1);
 598   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 599       .Times(1);
 600
 601   int ret = pkgmgr_client_get_size(GetHandle(), "org.tizen.test",
 602       PM_GET_PKG_SIZE_INFO, GetDefaultHandler(), nullptr);
 603   EXPECT_TRUE(ret > 0);
 604 }
 605
 606 TEST_F(ClientTest, pkgmgr_client_get_size_n) {
 607   int ret = pkgmgr_client_get_size(GetHandle(), nullptr,
 608       PM_GET_PKG_SIZE_INFO, GetDefaultHandler(), nullptr);
 609   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 610 }
 611
 612 TEST_F(ClientTest, pkgmgr_client_get_package_size_info) {
 613   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 614       .Times(1);
 615   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 616       .Times(1);
 617   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 618       .Times(1);
 619
 620   int ret = pkgmgr_client_get_package_size_info(GetHandle(), "org.tizen.test",
 621       GetDefaultPkgSizeHandler(), nullptr);
 622   EXPECT_TRUE(ret > 0);
 623 }
 624
 625 TEST_F(ClientTest, pkgmgr_client_get_package_size_info_n) {
 626   int ret = pkgmgr_client_get_package_size_info(GetHandle(), nullptr,
 627       GetDefaultPkgSizeHandler(), nullptr);
 628   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 629 }
 630
 631 TEST_F(ClientTest, pkgmgr_client_generate_license_request) {
 632   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 633       .Times(1);
 634   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 635       .Times(2);
 636   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 637       .Times(2)
 638       .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
 639         rpc_port_parcel_h parcel;
 640         rpc_port_parcel_create(&parcel);
 641         rpc_port_parcel_write_int32(parcel, 0); // __Result
 642         rpc_port_parcel_write_string(parcel, "req_key");
 643         rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
 644         *h = parcel;
 645         return 0;
 646       }))
 647       .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
 648         rpc_port_parcel_h parcel;
 649         rpc_port_parcel_create(&parcel);
 650         rpc_port_parcel_write_int32(parcel, 0); // __Result
 651         rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
 652         rpc_port_parcel_write_string(parcel, "req_data");
 653         rpc_port_parcel_write_string(parcel, "license_url");
 654         rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
 655         *h = parcel;
 656         return 0;
 657       }));
 658
 659   char* req_data = nullptr;
 660   char* license_url = nullptr;
 661   int ret = pkgmgr_client_generate_license_request(GetHandle(), "data",
 662       &req_data, &license_url);
 663   EXPECT_TRUE(ret == PKGMGR_R_OK);
 664   free(req_data);
 665   free(license_url);
 666 }
 667
 668 TEST_F(ClientTest, pkgmgr_client_generate_license_request_n) {
 669   int ret = pkgmgr_client_generate_license_request(GetHandle(), nullptr,
 670       nullptr, nullptr);
 671   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 672 }
 673
 674 TEST_F(ClientTest, pkgmgr_client_register_license) {
 675   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 676       .Times(2);
 677   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 678       .Times(2);
 679   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 680       .Times(2)
 681       .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
 682         rpc_port_parcel_h parcel;
 683         rpc_port_parcel_create(&parcel);
 684         rpc_port_parcel_write_int32(parcel, 0); // __Result
 685         rpc_port_parcel_write_string(parcel, "req_key");
 686         rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
 687         *h = parcel;
 688         return 0;
 689       }))
 690       .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
 691         rpc_port_parcel_h parcel;
 692         rpc_port_parcel_create(&parcel);
 693         rpc_port_parcel_write_int32(parcel, 0); // __Result
 694         rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
 695         rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
 696         *h = parcel;
 697         return 0;
 698       }));
 699
 700   int ret = pkgmgr_client_register_license(GetHandle(), "data");
 701   EXPECT_TRUE(ret == PKGMGR_R_OK);
 702 }
 703
 704 TEST_F(ClientTest, pkgmgr_client_register_license_n) {
 705   int ret = pkgmgr_client_register_license(GetHandle(), nullptr);
 706   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 707 }
 708
 709 TEST_F(ClientTest, pkgmgr_client_decrypt_package) {
 710   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 711       .Times(2);
 712   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 713       .Times(2);
 714   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 715       .Times(2)
 716       .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
 717         rpc_port_parcel_h parcel;
 718         rpc_port_parcel_create(&parcel);
 719         rpc_port_parcel_write_int32(parcel, 0); // __Result
 720         rpc_port_parcel_write_string(parcel, "req_key");
 721         rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
 722         *h = parcel;
 723         return 0;
 724       }))
 725       .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
 726         rpc_port_parcel_h parcel;
 727         rpc_port_parcel_create(&parcel);
 728         rpc_port_parcel_write_int32(parcel, 0); // __Result
 729         rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
 730         rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
 731         *h = parcel;
 732         return 0;
 733       }));
 734
 735   int ret = pkgmgr_client_decrypt_package(GetHandle(), "path1", "path2");
 736   EXPECT_TRUE(ret == PKGMGR_R_OK);
 737 }
 738
 739 TEST_F(ClientTest, pkgmgr_client_decrypt_package_n) {
 740   int ret = pkgmgr_client_decrypt_package(GetHandle(), nullptr, nullptr);
 741   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 742 }
 743
 744 TEST_F(ClientTest, pkgmgr_client_enable_splash_screen) {
 745   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 746       .Times(1);
 747   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 748       .Times(1);
 749   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 750       .Times(1)
 751       .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
 752         rpc_port_parcel_h parcel;
 753         rpc_port_parcel_create(&parcel);
 754         rpc_port_parcel_write_int32(parcel, 0); // __Result
 755         rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
 756         *h = parcel;
 757         return 0;
 758       }));
 759
 760   int ret = pkgmgr_client_enable_splash_screen(GetHandle(), "org.tizen.test1");
 761   EXPECT_TRUE(ret == PKGMGR_R_OK);
 762 }
 763
 764 TEST_F(ClientTest, pkgmgr_client_enable_splash_screen_n) {
 765   int ret = pkgmgr_client_enable_splash_screen(GetHandle(), nullptr);
 766   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 767 }
 768
 769 TEST_F(ClientTest, pkgmgr_client_disable_splash_screen) {
 770   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 771       .Times(1);
 772   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 773       .Times(1);
 774   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 775       .Times(1)
 776       .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
 777         rpc_port_parcel_h parcel;
 778         rpc_port_parcel_create(&parcel);
 779         rpc_port_parcel_write_int32(parcel, 0); // __Result
 780         rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
 781         *h = parcel;
 782         return 0;
 783       }));
 784
 785   int ret = pkgmgr_client_disable_splash_screen(GetHandle(), "org.tizen.test1");
 786   EXPECT_TRUE(ret == PKGMGR_R_OK);
 787 }
 788
 789 TEST_F(ClientTest, pkgmgr_client_disable_splash_screen_n) {
 790   int ret = pkgmgr_client_disable_splash_screen(GetHandle(), nullptr);
 791   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 792 }
 793
 794 TEST_F(ClientTest, pkgmgr_client_set_pkg_restriction_mode) {
 795   int ret = pkgmgr_client_set_pkg_restriction_mode(GetHandle(), "org.tizen.test1", 1);
 796   EXPECT_TRUE(ret == PKGMGR_R_OK);
 797 }
 798
 799 TEST_F(ClientTest, pkgmgr_client_set_pkg_restriction_mode_n) {
 800   int ret = pkgmgr_client_set_pkg_restriction_mode(GetHandle(), nullptr, 0);
 801   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 802 }
 803
 804 TEST_F(ClientTest, pkgmgr_client_unset_pkg_restriction_mode) {
 805   int ret = pkgmgr_client_unset_pkg_restriction_mode(GetHandle(), "org.tizen.test1", 1);
 806   EXPECT_TRUE(ret == PKGMGR_R_OK);
 807 }
 808
 809 TEST_F(ClientTest, pkgmgr_client_unset_pkg_restriction_mode_n) {
 810   int ret = pkgmgr_client_unset_pkg_restriction_mode(GetHandle(), nullptr, 0);
 811   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 812 }
 813
 814 TEST_F(ClientTest, pkgmgr_client_get_pkg_restriction_mode) {
 815   int mode = 0;
 816   int ret = pkgmgr_client_get_pkg_restriction_mode(GetHandle(),
 817       "org.tizen.test1", &mode);
 818   EXPECT_TRUE(ret == PKGMGR_R_OK);
 819 }
 820
 821 TEST_F(ClientTest, pkgmgr_client_get_pkg_restriction_mode_n) {
 822   int mode;
 823   int ret = pkgmgr_client_get_pkg_restriction_mode(GetHandle(), nullptr, &mode);
 824   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 825 }
 826
 827 TEST_F(ClientTest, pkgmgr_client_set_restriction_mode) {
 828   int ret = pkgmgr_client_set_restriction_mode(GetHandle(), 2);
 829   EXPECT_TRUE(ret == PKGMGR_R_OK);
 830 }
 831
 832 TEST_F(ClientTest, pkgmgr_client_set_restriction_mode_n) {
 833   int ret = pkgmgr_client_set_restriction_mode(nullptr, 2);
 834   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 835 }
 836
 837 TEST_F(ClientTest, pkgmgr_client_unset_restriction_mode) {
 838   int ret = pkgmgr_client_unset_restriction_mode(GetHandle(), 2);
 839   EXPECT_TRUE(ret == PKGMGR_R_OK);
 840 }
 841
 842 TEST_F(ClientTest, pkgmgr_client_unset_restriction_mode_n) {
 843   int ret = pkgmgr_client_unset_restriction_mode(nullptr, 2);
 844   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 845 }
 846
 847 TEST_F(ClientTest, pkgmgr_client_get_restriction_mode) {
 848   int mode = 0;
 849   int ret = pkgmgr_client_get_restriction_mode(GetHandle(), &mode);
 850   EXPECT_TRUE(ret == PKGMGR_R_OK);
 851 }
 852
 853 TEST_F(ClientTest, pkgmgr_client_get_restriction_mode_n) {
 854   int mode = 0;
 855   int ret = pkgmgr_client_get_restriction_mode(nullptr, &mode);
 856   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 857 }
 858
 859 TEST_F(ClientTest, pkgmgr_client_set_app_label) {
 860   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 861       .Times(2);
 862   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 863       .Times(2);
 864   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 865       .Times(2)
 866       .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
 867         rpc_port_parcel_h parcel;
 868         rpc_port_parcel_create(&parcel);
 869         rpc_port_parcel_write_int32(parcel, 0); // __Result
 870         rpc_port_parcel_write_string(parcel, "req_key");
 871         rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
 872         *h = parcel;
 873         return 0;
 874       }))
 875       .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
 876         rpc_port_parcel_h parcel;
 877         rpc_port_parcel_create(&parcel);
 878         rpc_port_parcel_write_int32(parcel, 0); // __Result
 879         rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
 880         rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
 881         *h = parcel;
 882         return 0;
 883       }));
 884
 885   int ret = pkgmgr_client_set_app_label(GetHandle(),
 886       const_cast<char*>("org.tizen.test1"), const_cast<char*>("test1"));
 887   EXPECT_TRUE(ret == PKGMGR_R_OK);
 888 }
 889
 890 TEST_F(ClientTest, pkgmgr_client_set_app_label_n) {
 891   int ret = pkgmgr_client_set_app_label(nullptr, nullptr, nullptr);
 892   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 893 }
 894
 895 TEST_F(ClientTest, pkgmgr_client_set_app_icon) {
 896   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 897       .Times(2);
 898   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 899       .Times(2);
 900   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 901       .Times(2)
 902       .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
 903         rpc_port_parcel_h parcel;
 904         rpc_port_parcel_create(&parcel);
 905         rpc_port_parcel_write_int32(parcel, 0); // __Result
 906         rpc_port_parcel_write_string(parcel, "req_key");
 907         rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
 908         *h = parcel;
 909         return 0;
 910       }))
 911       .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
 912         rpc_port_parcel_h parcel;
 913         rpc_port_parcel_create(&parcel);
 914         rpc_port_parcel_write_int32(parcel, 0); // __Result
 915         rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
 916         rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
 917         *h = parcel;
 918         return 0;
 919       }));
 920
 921   int ret = pkgmgr_client_set_app_icon(GetHandle(),
 922       const_cast<char*>("org.tizen.test1"), const_cast<char*>("path"));
 923   EXPECT_TRUE(ret == PKGMGR_R_OK);
 924 }
 925
 926 TEST_F(ClientTest, pkgmgr_client_set_app_icon_n) {
 927   int ret = pkgmgr_client_set_app_icon(nullptr, nullptr, nullptr);
 928   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 929 }
 930
 931 TEST_F(ClientTest, pkgmgr_client_usr_migrate_external_image) {
 932   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
 933       .Times(1);
 934   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
 935       .Times(1);
 936   EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
 937       .Times(1)
 938       .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
 939         rpc_port_parcel_h parcel;
 940         rpc_port_parcel_create(&parcel);
 941         rpc_port_parcel_write_int32(parcel, 0); // __Result
 942         rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
 943         *h = parcel;
 944         return 0;
 945       }));
 946
 947   int ret = pkgmgr_client_usr_migrate_external_image(GetHandle(),
 948       "org.tizen.test1", 0);
 949   EXPECT_TRUE(ret == PKGMGR_R_OK);
 950 }
 951
 952 TEST_F(ClientTest, pkgmgr_client_usr_migrate_external_image_n) {
 953   int ret = pkgmgr_client_usr_migrate_external_image(nullptr,
 954       "org.tizen.test1", 0);
 955   EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
 956 }