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