Support upgrade normal rw pkg to added ro pkg

Change-Id: Iea454634283a0131b1795c86d17e818901544c21
Signed-off-by: Ilho Kim <ilho159.kim@samsung.com>

diff --git a/src/pkg_upgrade/include/common_type.hh b/src/pkg_upgrade/include/common_type.hh
index 40e33b4cdeba7d3ab24116580cf6968555eec76e..be301ced7a0af941b1f9af99bea4ba5e6a7f619b 100644 (file)
--- a/src/pkg_upgrade/include/common_type.hh
+++ b/src/pkg_upgrade/include/common_type.hh
@@ -62,10 +62,10 @@ enum class PkgUpgradeResult {
 class PkgContext {
  public:
   PkgContext(std::string id, std::string version, std::string type,
-      bool read_only, bool update = false, bool removable = false)
+      bool read_only, bool update = false, bool preload = true, bool removable = false)
       : id_(std::move(id)), version_(std::move(version)),
         type_(std::move(type)), read_only_(read_only), update_(update),
-        removable_(removable) {
+        preload_(preload), removable_(removable) {
     if (read_only)
       removable_ = false;
   }
@@ -87,6 +87,7 @@ class PkgContext {
   bool IsReadOnly() const { return read_only_; }
   bool IsUpdate() const { return update_; }
   bool IsRemovable() const { return removable_; }
+  bool IsPreload() const { return preload_; }
 
  private:
   std::string id_;
@@ -94,6 +95,7 @@ class PkgContext {
   std::string type_;
   bool read_only_;
   bool update_;  // update means ReadonlyUpdated pkg
+  bool preload_;
   bool removable_;
 };
 

diff --git a/src/pkg_upgrade/include/pkg_finder.hh b/src/pkg_upgrade/include/pkg_finder.hh
index 011b57d183cbc5c58576921c8a93aa25767417da..70c823093235974a1bbc5bcc301f8b2e5172b5fb 100644 (file)
--- a/src/pkg_upgrade/include/pkg_finder.hh
+++ b/src/pkg_upgrade/include/pkg_finder.hh
@@ -42,7 +42,7 @@ class PkgFinder {
 
  private:
   static int PkgidListCb(const pkgmgrinfo_pkginfo_h handle, void* user_data);
-  int FindPreloadPkgidFromDb(bool read_only = true);
+  int FindPkgidFromDb();
   int FindPreloadPkgidFromXml(const std::string& xml_directory);
   int FindPreloadPkgidFromFile();
   int FindPriorityPkgs();
@@ -59,7 +59,6 @@ class PkgFinder {
   std::list<PkgContext> old_pkgs_;
   std::list<PkgContext> new_pkgs_;
   std::list<std::string> priority_pkgs_;
-  bool read_only_ = true;
   std::string manifest_dir_;
   std::string preload_rw_list_path_;
   std::string priority_list_path_;

diff --git a/src/pkg_upgrade/include/pkg_upgrader.hh b/src/pkg_upgrade/include/pkg_upgrader.hh
index 94b487f8732b80d69ceb9b0cfb380ec273c8a4a3..3ba5318e13854b8f042a783e171ab6a5cd064e4a 100644 (file)
--- a/src/pkg_upgrade/include/pkg_upgrader.hh
+++ b/src/pkg_upgrade/include/pkg_upgrader.hh
@@ -27,7 +27,7 @@ namespace common_fota {
 class PkgUpgrader {
  public:
   PkgUpgrader(const PkgContext& context, PkgOperation pkg_op);
-  PkgUpgrader(std::string id, std::string version);
+  PkgUpgrader(std::string id, std::string version, bool is_preload);
   virtual ~PkgUpgrader() = default;
 
   PkgType GetType() const;
@@ -35,6 +35,7 @@ class PkgUpgrader {
   PkgOperation GetOperation() const;
   std::string GetId() const;
   std::string GetVersion() const;
+  bool GetIsPreload() const;
   const BackendInvoker& GetBackendInvoker() const;
   PkgVersionCmpResult CompareVersion(const PkgUpgrader& pkg) const;
   PkgUpgradeResult GetResult() const;
@@ -50,6 +51,7 @@ class PkgUpgrader {
   PkgOperation op_;
   std::string id_;
   std::string version_;
+  bool is_preload_;
   BackendInvoker backend_;
 };
 

diff --git a/src/pkg_upgrade/include/rw2ro_upgrader.hh b/src/pkg_upgrade/include/rw2ro_upgrader.hh
index 5e2cb2871db278e2f183b930a71cd78db099a0fe..c320228c704c49b937556294d971d83311ae6d08 100644 (file)
--- a/src/pkg_upgrade/include/rw2ro_upgrader.hh
+++ b/src/pkg_upgrade/include/rw2ro_upgrader.hh
@@ -32,6 +32,9 @@ class Rw2RoUpgrader : public PkgUpgrader {
   bool Upgrade() override;
 
  private:
+  bool UpgradeToRw();
+  bool UpgradeToRo();
+
   std::unique_ptr<PkgUpgrader> old_pkg_;
   std::unique_ptr<PkgUpgrader> new_pkg_;
 };

diff --git a/src/pkg_upgrade/src/pkg_finder.cc b/src/pkg_upgrade/src/pkg_finder.cc
index bd02d96f3c9895a074ca153eb5780a9df5a57938..baceaefbda18759392cce90e9a222f60cc074a18 100644 (file)
--- a/src/pkg_upgrade/src/pkg_finder.cc
+++ b/src/pkg_upgrade/src/pkg_finder.cc
@@ -90,13 +90,8 @@ int PkgFinder::UnzipFileOnlyToPath(const char* dest_path,
 }
 
 int PkgFinder::Find() {
-  if (FindPreloadPkgidFromDb(true) != 0) {
-    LOG(ERROR) << "FindPreloadPkgidFromDb(true) failed";
-    return -1;
-  }
-
-  if (FindPreloadPkgidFromDb(false) != 0) {
-    LOG(ERROR) << "FindPreloadPkgidFromDb(false) failed";
+  if (FindPkgidFromDb() != 0) {
+    LOG(ERROR) << "FindPkgidFromDb(true) failed";
     return -1;
   }
 
@@ -147,14 +142,22 @@ int PkgFinder::PkgidListCb(const pkgmgrinfo_pkginfo_h handle, void* user_data) {
   if (pkgmgrinfo_pkginfo_is_update(handle, &update) != PMINFO_R_OK)
     return 0;
 
+  bool preload = false;
+  if (pkgmgrinfo_pkginfo_is_preload(handle, &preload) != PMINFO_R_OK)
+    return 0;
+
+  bool readonly = false;
+  if (pkgmgrinfo_pkginfo_is_readonly(handle, &readonly) != PMINFO_R_OK)
+    return 0;
+
   PkgFinder* finder = static_cast<PkgFinder*>(user_data);
-  finder->old_pkgs_.emplace_back(pkgid, version, type, finder->read_only_,
-      update);
+  finder->old_pkgs_.emplace_back(pkgid, version, type, readonly,
+      update, preload);
 
   return 0;
 }
 
-int PkgFinder::FindPreloadPkgidFromDb(bool read_only) {
+int PkgFinder::FindPkgidFromDb() {
   int ret;
   pkgmgrinfo_pkginfo_filter_h handle;
 
@@ -168,21 +171,6 @@ int PkgFinder::FindPreloadPkgidFromDb(bool read_only) {
       decltype(pkgmgrinfo_pkginfo_filter_destroy)*> handle_auto(
           handle, pkgmgrinfo_pkginfo_filter_destroy);
 
-  ret = pkgmgrinfo_pkginfo_filter_add_bool(handle_auto.get(),
-    PMINFO_PKGINFO_PROP_PACKAGE_PRELOAD, 1);
-  if (ret != PMINFO_R_OK) {
-    LOG(ERROR) << "pkgmgrinfo_pkginfo_filter_add_bool failed " << ret;
-    return -1;
-  }
-
-  ret = pkgmgrinfo_pkginfo_filter_add_bool(handle_auto.get(),
-    PMINFO_PKGINFO_PROP_PACKAGE_READONLY, read_only ? 1 : 0);
-  if (ret != PMINFO_R_OK) {
-    LOG(ERROR) << "pkgmgrinfo_pkginfo_filter_add_bool failed " << ret;
-    return -1;
-  }
-  read_only_ = read_only;
-
   ret = pkgmgrinfo_pkginfo_filter_foreach_pkginfo(handle_auto.get(),
     PkgidListCb, this);
   if (ret != PMINFO_R_OK) {
@@ -377,9 +365,9 @@ void PkgFinder::AddRwPkgInfoFromFile(const char* info_str) {
       });
 
   if (removable == "false")
-    new_pkgs_.emplace_back(pkgid, version, type, false, false, false);
+    new_pkgs_.emplace_back(pkgid, version, type, false, false, true, false);
   else
-    new_pkgs_.emplace_back(pkgid, version, type, false, false, true);
+    new_pkgs_.emplace_back(pkgid, version, type, false, false, true, true);
 }
 
 string PkgFinder::GetToken(const char* pBuf, const char* pKey) {

diff --git a/src/pkg_upgrade/src/pkg_upgrader.cc b/src/pkg_upgrade/src/pkg_upgrader.cc
index 72f4706e1638ee06b024903b32346a218ed45a80..674dc0818fedda6ee624d41808241a5edc57b4c3 100644 (file)
--- a/src/pkg_upgrade/src/pkg_upgrader.cc
+++ b/src/pkg_upgrade/src/pkg_upgrader.cc
@@ -26,14 +26,16 @@ PkgUpgrader::PkgUpgrader(const PkgContext& context, PkgOperation pkg_op)
   : result_(PkgUpgradeResult::UNKNOWN), type_(context.GetType()),
     loc_(context.GetLocation()), op_(pkg_op),
     id_(context.GetId()), version_(context.GetVersion()),
+    is_preload_(context.IsPreload()),
     backend_(context.GetId(), context.GetType(), context.GetLocation(),
         pkg_op, context.IsRemovable()) {
 }
 
-PkgUpgrader::PkgUpgrader(std::string id, std::string version)
+PkgUpgrader::PkgUpgrader(std::string id, std::string version, bool is_preload)
     : result_(PkgUpgradeResult::UNKNOWN), type_(PkgType::UNKNOWN),
       loc_(PkgLocation::UNKNOWN), op_(PkgOperation::COMPLEX),
-      id_(std::move(id)), version_(std::move(version)) {
+      id_(std::move(id)), version_(std::move(version)),
+      is_preload_(is_preload) {
 }
 
 PkgType PkgUpgrader::GetType() const {
@@ -56,6 +58,11 @@ std::string PkgUpgrader::GetVersion() const {
   return version_;
 }
 
+
+bool PkgUpgrader::GetIsPreload() const {
+  return is_preload_;
+}
+
 const BackendInvoker& PkgUpgrader::GetBackendInvoker() const {
   return backend_;
 }

diff --git a/src/pkg_upgrade/src/pkg_upgrader_factory.cc b/src/pkg_upgrade/src/pkg_upgrader_factory.cc
index 4f0ff7f52cb6f075d978b292a1345df240f1e3b5..9c4556da468d0ab7c50e7f7c668b09920c85699c 100644 (file)
--- a/src/pkg_upgrade/src/pkg_upgrader_factory.cc
+++ b/src/pkg_upgrade/src/pkg_upgrader_factory.cc
@@ -46,7 +46,7 @@ UpdateType GetUpdateType(
   if (old_pkg.IsReadOnly() && new_pkg.IsReadOnly())
     return UpdateType::kRo2Ro;
 
-  if (!old_pkg.IsReadOnly() && !new_pkg.IsReadOnly())
+  if (old_pkg.IsPreload() && !old_pkg.IsReadOnly() && !new_pkg.IsReadOnly())
     return UpdateType::kRw2Rw;
 
   if (!old_pkg.IsReadOnly() && new_pkg.IsReadOnly())
@@ -146,6 +146,9 @@ list<unique_ptr<PkgUpgrader>> PkgUpgraderFactory::Merge(
   }
 
   for (auto& old_pkg : old_pkgs) {
+    if (!old_pkg.IsPreload())
+      continue;
+
     const auto* new_pkg = FindPkgById(new_pkgs, old_pkg.GetId());
     if (new_pkg == nullptr) {
       // UNINSTALL

diff --git a/src/pkg_upgrade/src/ro2rw_upgrader.cc b/src/pkg_upgrade/src/ro2rw_upgrader.cc
index 4e46b7494bdf0787b8e7128cb87d655a3044d30c..12846ae55ea08675a3a2dffa4e6868db6e68580b 100644 (file)
--- a/src/pkg_upgrade/src/ro2rw_upgrader.cc
+++ b/src/pkg_upgrade/src/ro2rw_upgrader.cc
@@ -24,7 +24,8 @@ namespace common_fota {
 
 Ro2RwUpgrader::Ro2RwUpgrader(std::unique_ptr<RoUpgrader> old_pkg,
     std::unique_ptr<RwUpgrader> new_pkg)
-    : PkgUpgrader(new_pkg->GetId(), new_pkg->GetVersion()),
+    : PkgUpgrader(new_pkg->GetId(), new_pkg->GetVersion(),
+          new_pkg->GetIsPreload()),
       old_pkg_(std::move(old_pkg)), new_pkg_(std::move(new_pkg)) {
 }
 

diff --git a/src/pkg_upgrade/src/ro_upgrader.cc b/src/pkg_upgrade/src/ro_upgrader.cc
index 282c7501fd039c39f79c59f0fd2a54b97d482d7f..8ea48a06b9518ea1bbb0e78fa8a40c9a15841e6e 100644 (file)
--- a/src/pkg_upgrade/src/ro_upgrader.cc
+++ b/src/pkg_upgrade/src/ro_upgrader.cc
@@ -23,7 +23,8 @@ namespace common_fota {
 
 RoUpgrader::RoUpgrader(std::unique_ptr<PkgUpgrader> old_pkg,
     std::unique_ptr<PkgUpgrader> new_pkg)
-    : PkgUpgrader(new_pkg->GetId(), new_pkg->GetVersion()),
+    : PkgUpgrader(new_pkg->GetId(), new_pkg->GetVersion(),
+          new_pkg->GetIsPreload()),
       old_pkg_(std::move(old_pkg)), new_pkg_(std::move(new_pkg)) {
 }
 

diff --git a/src/pkg_upgrade/src/rw2ro_upgrader.cc b/src/pkg_upgrade/src/rw2ro_upgrader.cc
index add08ef56ceca64021a6513256d8659903014908..a5eb71ac182fd962c9ec6b15c59011131c3703d2 100644 (file)
--- a/src/pkg_upgrade/src/rw2ro_upgrader.cc
+++ b/src/pkg_upgrade/src/rw2ro_upgrader.cc
@@ -16,6 +16,8 @@
 
 #include "rw2ro_upgrader.hh"
 
+#include <pkgmgr_parser_db.h>
+
 #include "logging.hh"
 #include "ro_upgrader.hh"
 #include "rw_upgrader.hh"
@@ -24,7 +26,8 @@ namespace common_fota {
 
 Rw2RoUpgrader::Rw2RoUpgrader(std::unique_ptr<RwUpgrader> old_pkg,
     std::unique_ptr<RoUpgrader> new_pkg)
-    : PkgUpgrader(new_pkg->GetId(), new_pkg->GetVersion()),
+    : PkgUpgrader(new_pkg->GetId(), new_pkg->GetVersion(),
+          new_pkg->GetIsPreload()),
       old_pkg_(std::move(old_pkg)), new_pkg_(std::move(new_pkg)) {
 }
 
@@ -38,13 +41,30 @@ bool Rw2RoUpgrader::Upgrade() {
     return false;
   }
 
-  if (result == PkgVersionCmpResult::LOWER) {
+  return result != PkgVersionCmpResult::LOWER ? UpgradeToRo() : UpgradeToRw();
+}
+
+bool Rw2RoUpgrader::UpgradeToRw() {
+  if (old_pkg_->GetIsPreload()) {
     LOG(INFO) << old_pkg_->GetId() << " has higher version("
               << old_pkg_->GetVersion() << ") already. Nothing to do.";
     result_ = PkgUpgradeResult::SKIPPED;
-    return true;
+  } else {
+    if (pkgmgr_parser_update_rw_to_ro_updated_pkg_in_db(
+        old_pkg_->GetId().c_str()) != PM_PARSER_R_OK) {
+      LOG(ERROR) << "Failed to update pkg " << old_pkg_->GetId();
+      result_ = PkgUpgradeResult::FAILED;
+      return false;
+    }
+    LOG(INFO) << "Preloaded files of " << old_pkg_->GetId() <<
+        " has been added. This package will be readonly updated package";
+    result_ = PkgUpgradeResult::UPDATED;
   }
 
+  return true;
+}
+
+bool Rw2RoUpgrader::UpgradeToRo() {
   if (!old_pkg_->Upgrade()) {
     LOG(ERROR) << "Upgrade operation of old RW package failed";
     result_ = PkgUpgradeResult::FAILED;

diff --git a/src/pkg_upgrade/src/rw_upgrader.cc b/src/pkg_upgrade/src/rw_upgrader.cc
index 479d5e49c1e236677335bf90f099d1ffb0dd508d..707cb5f62c626ec77a25e78f33243a049586cf73 100644 (file)
--- a/src/pkg_upgrade/src/rw_upgrader.cc
+++ b/src/pkg_upgrade/src/rw_upgrader.cc
@@ -29,7 +29,8 @@ namespace common_fota {
 
 RwUpgrader::RwUpgrader(std::unique_ptr<PkgUpgrader> old_pkg,
     std::unique_ptr<PkgUpgrader> new_pkg)
-    : PkgUpgrader(new_pkg->GetId(), new_pkg->GetVersion()),
+    : PkgUpgrader(new_pkg->GetId(), new_pkg->GetVersion(),
+          new_pkg->GetIsPreload()),
       old_pkg_(std::move(old_pkg)), new_pkg_(std::move(new_pkg)) {
 }
 

diff --git a/tests/mock/pkgmgr_info_mock.cc b/tests/mock/pkgmgr_info_mock.cc
index ca428c5f40318d4c0aa275c58d8c4cc200946073..0f19cb3701782f06563a22fbf005a682fdc70409 100644 (file)
--- a/tests/mock/pkgmgr_info_mock.cc
+++ b/tests/mock/pkgmgr_info_mock.cc
@@ -78,3 +78,15 @@ extern "C" int pkgmgrinfo_pkginfo_destroy_pkginfo(
   return MOCK_HOOK_P1(
       PkgMgrInfoMock, pkgmgrinfo_pkginfo_destroy_pkginfo, handle);
 }
+
+extern "C" int pkgmgrinfo_pkginfo_is_preload(pkgmgrinfo_pkginfo_h handle,
+    bool *preload) {
+  return MOCK_HOOK_P2(PkgMgrInfoMock, pkgmgrinfo_pkginfo_is_preload,
+      handle, preload);
+}
+
+extern "C" int pkgmgrinfo_pkginfo_is_readonly(pkgmgrinfo_pkginfo_h handle,
+    bool *readonly) {
+  return MOCK_HOOK_P2(PkgMgrInfoMock, pkgmgrinfo_pkginfo_is_readonly,
+      handle, readonly);
+}

diff --git a/tests/mock/pkgmgr_info_mock.h b/tests/mock/pkgmgr_info_mock.h
index f008ae9a2e3571aef8bffaa6bd93159a54ef8a67..65feea5f051b06b0a6770d1de45eca8e722c2484 100644 (file)
--- a/tests/mock/pkgmgr_info_mock.h
+++ b/tests/mock/pkgmgr_info_mock.h
@@ -44,6 +44,9 @@ class PkgMgrInfoMock : public virtual ModuleMock {
   MOCK_METHOD3(pkgmgrinfo_pkginfo_get_usr_pkginfo,
       int(const char*, uid_t, pkgmgrinfo_pkginfo_h*));
   MOCK_METHOD1(pkgmgrinfo_pkginfo_destroy_pkginfo, int(pkgmgrinfo_pkginfo_h));
+  MOCK_METHOD2(pkgmgrinfo_pkginfo_is_preload, int(pkgmgrinfo_pkginfo_h, bool*));
+  MOCK_METHOD2(pkgmgrinfo_pkginfo_is_readonly,
+      int(pkgmgrinfo_pkginfo_h, bool*));
 };
 
 #endif  // TESTS_MOCK_PKGMGR_INFO_MOCK_H_

diff --git a/tests/mock/pkgmgr_parser_mock.cc b/tests/mock/pkgmgr_parser_mock.cc
new file mode 100644 (file)
index 0000000..065ba18
--- /dev/null
+++ b/tests/mock/pkgmgr_parser_mock.cc
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "mock/mock_hook.h"
+#include "mock/pkgmgr_parser_mock.h"
+#include "mock/test_fixture.h"
+
+extern "C" int pkgmgr_parser_update_rw_to_ro_updated_pkg_in_db(
+    const char* pkgid) {
+  return MOCK_HOOK_P1(PkgMgrParserMock,
+      pkgmgr_parser_update_rw_to_ro_updated_pkg_in_db, pkgid);
+}

diff --git a/tests/mock/pkgmgr_parser_mock.h b/tests/mock/pkgmgr_parser_mock.h
new file mode 100644 (file)
index 0000000..9812cba
--- /dev/null
+++ b/tests/mock/pkgmgr_parser_mock.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TESTS_MOCK_PKGMGR_PARSER_MOCK_H_
+#define TESTS_MOCK_PKGMGR_PARSER_MOCK_H_
+
+#include <tizen.h>
+#include <gmock/gmock.h>
+#include <pkgmgr_parser_db.h>
+
+#include "mock/module_mock.h"
+
+class PkgMgrParserMock : public virtual ModuleMock {
+ public:
+  virtual ~PkgMgrParserMock() {}
+
+  MOCK_METHOD1(pkgmgr_parser_update_rw_to_ro_updated_pkg_in_db,
+      int(const char*));
+};
+
+#endif  // TESTS_MOCK_PKGMGR_PARSER_MOCK_H_

diff --git a/tests/unit_tests/pkg_upgrade/src/test_pkg_upgrader.cc b/tests/unit_tests/pkg_upgrade/src/test_pkg_upgrader.cc
index 16c144b9e16b94c8d8121e95a6bd29044b530e1d..acb285497b696865a01e72267607a67f36b4d329 100644 (file)
--- a/tests/unit_tests/pkg_upgrade/src/test_pkg_upgrader.cc
+++ b/tests/unit_tests/pkg_upgrade/src/test_pkg_upgrader.cc
@@ -26,6 +26,7 @@
 
 #include "mock/os_mock.h"
 #include "mock/pkgmgr_info_mock.h"
+#include "mock/pkgmgr_parser_mock.h"
 #include "mock/aul_mock.h"
 #include "mock/test_fixture.h"
 #include "pkg_finder.hh"
@@ -45,7 +46,23 @@ using common_fota::PkgUpgraderFactory;
 using common_fota::Upgrader;
 
 class Mocks : public ::testing::NiceMock<PkgMgrInfoMock>,
-    public ::testing::NiceMock<OsMock> {};
+    public ::testing::NiceMock<OsMock>,
+    public ::testing::NiceMock<PkgMgrParserMock> {};
+
+class PkgInfo {
+public:
+  PkgInfo(const char* id, const char* type, const char* version,
+      bool is_update, bool is_preload, bool is_readonly) :
+          id_(id), type_(type), version_(version), is_update_(is_update),
+          is_preload_(is_preload), is_readonly_(is_readonly) {}
+
+  const char* id_;
+  const char* type_;
+  const char* version_;
+  bool is_update_;
+  bool is_preload_;
+  bool is_readonly_;
+};
 
 class PkgFinderTest : public TestFixture {
  public:
@@ -58,50 +75,54 @@ class PkgFinderTest : public TestFixture {
   virtual void TearDown() {
   }
 
-  void SetOldPkgInfo(const char* ro_pkg_id, const char* ro_pkg_type,
-      const char* ro_pkg_version, const char* rw_pkg_id,
-      const char* rw_pkg_type, const char* rw_pkg_version) {
+  void SetOldPkgInfo(const std::vector<PkgInfo>& pkgs) {
     static int k;
     pkgmgrinfo_pkginfo_filter_h dummy_filter = (pkgmgrinfo_pkginfo_filter_h)&k;
 
     EXPECT_CALL(GetMock<PkgMgrInfoMock>(), pkgmgrinfo_pkginfo_filter_create(_))
         .WillRepeatedly(DoAll(SetArgPointee<0>(dummy_filter), Return(0)));
-    EXPECT_CALL(GetMock<PkgMgrInfoMock>(),
-        pkgmgrinfo_pkginfo_filter_add_bool(_, _, _))
-        .WillRepeatedly(Return(0));
 
+    int pkgs_size = pkgs.size();
     EXPECT_CALL(GetMock<PkgMgrInfoMock>(),
         pkgmgrinfo_pkginfo_filter_foreach_pkginfo(_, _, _))
         .WillOnce(
-            Invoke([](pkgmgrinfo_pkginfo_filter_h handle,
+            Invoke([pkgs_size](pkgmgrinfo_pkginfo_filter_h handle,
                 pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data) -> int {
-              pkg_cb(nullptr, user_data);
+              for (int i = 0; i < pkgs_size; ++i)
+                pkg_cb(nullptr, user_data);
               return 0;
             })
-        )
-        .WillOnce(Invoke([](pkgmgrinfo_pkginfo_filter_h handle,
-                pkgmgrinfo_pkg_list_cb pkg_cb, void *user_data) -> int {
-              pkg_cb(nullptr, user_data);
-              return 0;
-            }));
-    EXPECT_CALL(GetMock<PkgMgrInfoMock>(),
-        pkgmgrinfo_pkginfo_get_pkgid(_, _))
-        .WillOnce(DoAll(SetArgPointee<1>(
-            const_cast<char*>(ro_pkg_id)), Return(0)))
-        .WillOnce(DoAll(SetArgPointee<1>(
-            const_cast<char*>(rw_pkg_id)), Return(0)));
-    EXPECT_CALL(GetMock<PkgMgrInfoMock>(),
-        pkgmgrinfo_pkginfo_get_type(_, _))
-        .WillOnce(DoAll(SetArgPointee<1>(
-            const_cast<char*>(ro_pkg_type)), Return(0)))
-        .WillOnce(DoAll(SetArgPointee<1>(
-            const_cast<char*>(rw_pkg_type)), Return(0)));
-    EXPECT_CALL(GetMock<PkgMgrInfoMock>(),
-        pkgmgrinfo_pkginfo_get_version(_, _))
-        .WillOnce(DoAll(SetArgPointee<1>(
-            const_cast<char*>(ro_pkg_version)), Return(0)))
-        .WillOnce(DoAll(SetArgPointee<1>(
-            const_cast<char*>(rw_pkg_version)), Return(0)));
+        );
+    auto& get_pkgid_mock = EXPECT_CALL(GetMock<PkgMgrInfoMock>(),
+        pkgmgrinfo_pkginfo_get_pkgid(_, _));
+    for (const auto& pkg : pkgs)
+      get_pkgid_mock.WillOnce(DoAll(SetArgPointee<1>(
+          const_cast<char*>(pkg.id_)), Return(0)));
+    auto& get_type_mock = EXPECT_CALL(GetMock<PkgMgrInfoMock>(),
+        pkgmgrinfo_pkginfo_get_type(_, _));
+    for (const auto& pkg : pkgs)
+      get_type_mock.WillOnce(DoAll(SetArgPointee<1>(
+          const_cast<char*>(pkg.type_)), Return(0)));
+    auto& get_version_mock = EXPECT_CALL(GetMock<PkgMgrInfoMock>(),
+        pkgmgrinfo_pkginfo_get_version(_, _));
+    for (const auto& pkg : pkgs)
+      get_version_mock.WillOnce(DoAll(SetArgPointee<1>(
+          const_cast<char*>(pkg.version_)), Return(0)));
+    auto& get_is_update_mock = EXPECT_CALL(GetMock<PkgMgrInfoMock>(),
+        pkgmgrinfo_pkginfo_is_update(_, _));
+    for (const auto& pkg : pkgs)
+      get_is_update_mock.WillOnce(DoAll(SetArgPointee<1>(
+          pkg.is_update_), Return(0)));
+    auto& get_is_preload_mock = EXPECT_CALL(GetMock<PkgMgrInfoMock>(),
+        pkgmgrinfo_pkginfo_is_preload(_, _));
+    for (const auto& pkg : pkgs)
+      get_is_preload_mock.WillOnce(DoAll(SetArgPointee<1>(
+          pkg.is_preload_), Return(0)));
+    auto& get_is_readonly_mock = EXPECT_CALL(GetMock<PkgMgrInfoMock>(),
+        pkgmgrinfo_pkginfo_is_readonly(_, _));
+    for (const auto& pkg : pkgs)
+      get_is_readonly_mock.WillOnce(DoAll(SetArgPointee<1>(
+          pkg.is_readonly_), Return(0)));
 
     EXPECT_CALL(GetMock<PkgMgrInfoMock>(), pkgmgrinfo_pkginfo_filter_destroy(_))
         .WillRepeatedly(Return(0));
@@ -115,8 +136,10 @@ class PkgFinderTest : public TestFixture {
 };
 
 TEST_F(PkgFinderTest, PkgFinder) {
-  SetOldPkgInfo("org.tizen.alarm", "tpk", "1.0.0",  // RO
-      "org.test.test1", "wgt", "1.0.0");  // RW
+  SetOldPkgInfo(std::vector<PkgInfo>{
+      PkgInfo("org.tizen.alarm", "tpk", "1.0.0", false, true, true),
+      PkgInfo("org.test.test1", "wgt", "1.0.0", false, true, false),
+  });
 
   finder_.Find();
   EXPECT_EQ(finder_.GetOldPkgs().size(), 2);
@@ -125,8 +148,10 @@ TEST_F(PkgFinderTest, PkgFinder) {
 
 TEST_F(PkgFinderTest, PkgUpgraderFactory) {
   PkgUpgraderFactory factory;
-  SetOldPkgInfo("org.tizen.alarm", "tpk", "1.0.0",  // RO
-      "org.test.test1", "wgt", "1.0.0");  // RW
+  SetOldPkgInfo(std::vector<PkgInfo>{
+      PkgInfo("org.tizen.alarm", "tpk", "1.0.0", false, true, true),
+      PkgInfo("org.test.test1", "wgt", "1.0.0", false, true, false),
+  });
 
   auto list = factory.MakeList(&finder_);
   EXPECT_EQ(list.size(), 2);
@@ -134,8 +159,10 @@ TEST_F(PkgFinderTest, PkgUpgraderFactory) {
 
 TEST_F(PkgFinderTest, PriorityList) {
   PkgUpgraderFactory factory;
-  SetOldPkgInfo("org.tizen.alarm", "tpk", "1.0.0",  // RO
-      "org.test.test1", "wgt", "1.0.0");  // RW
+  SetOldPkgInfo(std::vector<PkgInfo>{
+      PkgInfo("org.tizen.alarm", "tpk", "1.0.0", false, true, true),
+      PkgInfo("org.test.test1", "wgt", "1.0.0", false, true, false),
+  });
   finder_.SetPriorityListPath(
       "./tests/unit_tests/pkg_upgrade/data/priority_list");
 
@@ -183,8 +210,10 @@ TEST_F(PkgUpgraderTest, Upgrader_RO2RO_RW2RW_HIGH_VERSION) {
   Upgrader upgrader;
   upgrader.SetDbPath("./tests/unit_tests/pkg_upgrade/data/db");
   std::vector<std::string> cmds;
-  SetOldPkgInfo("org.tizen.alarm", "tpk", "1.0.0",  // RO
-      "org.tizen.new_rw", "tpk", "1.0.0");  // RW
+  SetOldPkgInfo(std::vector<PkgInfo>{
+      PkgInfo("org.tizen.alarm", "tpk", "1.0.0", false, true, true),
+      PkgInfo("org.tizen.new_rw", "tpk", "1.0.0", false, true, false),
+  });
   // New pkg : org.tizen.alarm 2.0.0 (ro), org.tizen.new_rw 1.2.0 (rw)
 
   EXPECT_CALL(GetMock<OsMock>(),
@@ -219,8 +248,10 @@ TEST_F(PkgUpgraderTest, Upgrader_RO2RO_RW2RW_SAME_VERSION) {
   Upgrader upgrader;
   upgrader.SetDbPath("./tests/unit_tests/pkg_upgrade/data/db");
   std::vector<std::string> cmds;
-  SetOldPkgInfo("org.tizen.alarm", "tpk", "2.0.0",  // RO
-      "org.tizen.new_rw", "tpk", "1.2.0");  // RW
+  SetOldPkgInfo(std::vector<PkgInfo>{
+      PkgInfo("org.tizen.alarm", "tpk", "2.0.0", false, true, true),
+      PkgInfo("org.tizen.new_rw", "tpk", "1.2.0", false, true, false),
+  });
   // New pkg : org.tizen.alarm 2.0.0 (ro), org.tizen.new_rw 1.2.0 (rw)
 
   EXPECT_CALL(GetMock<OsMock>(),
@@ -245,8 +276,10 @@ TEST_F(PkgUpgraderTest, Upgrader_RO2RO_RW2RW_LOW_VERSION) {
   Upgrader upgrader;
   upgrader.SetDbPath("./tests/unit_tests/pkg_upgrade/data/db");
   std::vector<std::string> cmds;
-  SetOldPkgInfo("org.tizen.alarm", "tpk", "2.5.0",  // RO
-      "org.tizen.new_rw", "tpk", "2.0.0");  // RW
+  SetOldPkgInfo(std::vector<PkgInfo>{
+      PkgInfo("org.tizen.alarm", "tpk", "2.5.0", false, true, true),
+      PkgInfo("org.tizen.new_rw", "tpk", "2.0.0", false, true, false),
+  });
   // New pkg : org.tizen.alarm 2.0.0 (ro), org.tizen.new_rw 1.2.0 (rw)
 
   EXPECT_CALL(GetMock<OsMock>(),
@@ -277,8 +310,10 @@ TEST_F(PkgUpgraderTest, Upgrader_RO_REMOVE) {
   Upgrader upgrader;
   upgrader.SetDbPath("./tests/unit_tests/pkg_upgrade/data/db");
   std::vector<std::string> cmds;
-  SetOldPkgInfo("org.test.del", "tpk", "1.0.0",  // RO
-      "org.tizen.new_rw", "tpk", "1.2.0");  // RW
+  SetOldPkgInfo(std::vector<PkgInfo>{
+      PkgInfo("org.test.del", "tpk", "1.0.0", false, true, true),
+      PkgInfo("org.tizen.new_rw", "tpk", "1.2.0", false, true, false),
+  });
   // New pkg : org.tizen.alarm 2.0.0 (ro), org.tizen.new_rw 1.2.0 (rw)
 
   EXPECT_CALL(GetMock<OsMock>(),
@@ -302,8 +337,10 @@ TEST_F(PkgUpgraderTest, Upgrader_RW_DO_NOT_REMOVE) {
   Upgrader upgrader;
   upgrader.SetDbPath("./tests/unit_tests/pkg_upgrade/data/db");
   std::vector<std::string> cmds;
-  SetOldPkgInfo("org.tizen.alarm", "tpk", "2.0.0",  // RO
-      "org.test.don'tDel", "tpk", "1.0.0");  // RW
+  SetOldPkgInfo(std::vector<PkgInfo>{
+      PkgInfo("org.tizen.alarm", "tpk", "2.0.0", false, true, true),
+      PkgInfo("org.test.don'tDel", "tpk", "1.0.0", false, true, false),
+  });
   // New pkg : org.tizen.alarm 2.0.0 (ro), org.tizen.new_rw 1.2.0 (rw)
 
   EXPECT_CALL(GetMock<OsMock>(),
@@ -331,8 +368,10 @@ TEST_F(PkgUpgraderTest, Upgrader_RW2RO_HIGH_VERSION) {
   Upgrader upgrader;
   upgrader.SetDbPath("./tests/unit_tests/pkg_upgrade/data/db");
   std::vector<std::string> cmds;
-  SetOldPkgInfo("org.tizen.test", "tpk", "1.0.0",  // RO
-      "org.tizen.alarm", "tpk", "1.5.0");  // RW
+  SetOldPkgInfo(std::vector<PkgInfo>{
+      PkgInfo("org.tizen.test", "tpk", "1.0.0", false, true, true),
+      PkgInfo("org.tizen.alarm", "tpk", "1.5.0", false, true, false),
+  });
   // New pkg : org.tizen.alarm 2.0.0 (ro), org.tizen.new_rw 1.2.0 (rw)
 
   EXPECT_CALL(GetMock<OsMock>(),
@@ -367,8 +406,10 @@ TEST_F(PkgUpgraderTest, Upgrader_RW2RO_LOW_VERSION) {
   Upgrader upgrader;
   upgrader.SetDbPath("./tests/unit_tests/pkg_upgrade/data/db");
   std::vector<std::string> cmds;
-  SetOldPkgInfo("org.tizen.test", "tpk", "1.0.0",  // RO
-      "org.tizen.alarm", "tpk", "2.5.0");  // RW
+  SetOldPkgInfo(std::vector<PkgInfo>{
+      PkgInfo("org.tizen.test", "tpk", "1.0.0", false, true, true),
+      PkgInfo("org.tizen.alarm", "tpk", "2.5.0", false, true, false),
+  });
   // New pkg : org.tizen.alarm 2.0.0 (ro), org.tizen.new_rw 1.2.0 (rw)
 
   EXPECT_CALL(GetMock<OsMock>(),
@@ -399,8 +440,10 @@ TEST_F(PkgUpgraderTest, Upgrader_RW2RO_SAME_VERSION) {
   Upgrader upgrader;
   upgrader.SetDbPath("./tests/unit_tests/pkg_upgrade/data/db");
   std::vector<std::string> cmds;
-  SetOldPkgInfo("org.tizen.test", "tpk", "1.0.0",  // RO
-      "org.tizen.alarm", "tpk", "2.0.0");  // RW
+  SetOldPkgInfo(std::vector<PkgInfo>{
+      PkgInfo("org.tizen.test", "tpk", "1.0.0", false, true, true),
+      PkgInfo("org.tizen.alarm", "tpk", "2.0.0", false, true, false),
+  });
   // New pkg : org.tizen.alarm 2.0.0 (ro), org.tizen.new_rw 1.2.0 (rw)
 
   EXPECT_CALL(GetMock<OsMock>(),
@@ -435,8 +478,10 @@ TEST_F(PkgUpgraderTest, Upgrader_RO2RW_HIGH_VERSION) {
   Upgrader upgrader;
   upgrader.SetDbPath("./tests/unit_tests/pkg_upgrade/data/db");
   std::vector<std::string> cmds;
-  SetOldPkgInfo("org.tizen.new_rw", "tpk", "1.0.0",  // RO
-      "org.tizen.alarm", "tpk", "2.0.0");  // RW
+  SetOldPkgInfo(std::vector<PkgInfo>{
+      PkgInfo("org.tizen.new_rw", "tpk", "1.0.0", false, true, true),
+      PkgInfo("org.tizen.alarm", "tpk", "2.0.0", false, true, false),
+  });
   // New pkg : org.tizen.alarm 2.0.0 (ro), org.tizen.new_rw 1.2.0 (rw)
 
   EXPECT_CALL(GetMock<OsMock>(),
@@ -471,8 +516,10 @@ TEST_F(PkgUpgraderTest, Upgrader_RO2RW_LOW_VERSION) {
   Upgrader upgrader;
   upgrader.SetDbPath("./tests/unit_tests/pkg_upgrade/data/db");
   std::vector<std::string> cmds;
-  SetOldPkgInfo("org.tizen.new_rw", "tpk", "2.0.0",  // RO
-      "org.tizen.alarm", "tpk", "2.0.0");  // RW
+  SetOldPkgInfo(std::vector<PkgInfo>{
+      PkgInfo("org.tizen.new_rw", "tpk", "2.0.0", false, true, true),
+      PkgInfo("org.tizen.alarm", "tpk", "2.0.0", false, true, false),
+  });
   // New pkg : org.tizen.alarm 2.0.0 (ro), org.tizen.new_rw 1.2.0 (rw)
 
   EXPECT_CALL(GetMock<OsMock>(),
@@ -507,8 +554,10 @@ TEST_F(PkgUpgraderTest, Upgrader_RO2RW_SAME_VERSION) {
   Upgrader upgrader;
   upgrader.SetDbPath("./tests/unit_tests/pkg_upgrade/data/db");
   std::vector<std::string> cmds;
-  SetOldPkgInfo("org.tizen.new_rw", "tpk", "1.2.0",  // RO
-      "org.tizen.alarm", "tpk", "2.0.0");  // RW
+  SetOldPkgInfo(std::vector<PkgInfo>{
+      PkgInfo("org.tizen.new_rw", "tpk", "1.2.0", false, true, true),
+      PkgInfo("org.tizen.alarm", "tpk", "2.0.0", false, true, false),
+  });
   // New pkg : org.tizen.alarm 2.0.0 (ro), org.tizen.new_rw 1.2.0 (rw)
 
   EXPECT_CALL(GetMock<OsMock>(),
@@ -545,6 +594,123 @@ TEST_F(PkgUpgraderTest, Upgrader_db_bck) {
   EXPECT_TRUE(upgrader.Process(&finder_));
 }
 
+TEST_F(PkgUpgraderTest, Upgrader_RW2ADDED_RO_LOW_VERSION) {
+  Upgrader upgrader;
+  upgrader.SetDbPath("./tests/unit_tests/pkg_upgrade/data/db");
+  std::vector<std::string> cmds;
+  SetOldPkgInfo(std::vector<PkgInfo>{
+      PkgInfo("org.tizen.new_rw", "tpk", "1.2.0", false, true, true),
+      PkgInfo("org.tizen.alarm", "tpk", "3.0.0", false, false, false)
+  });
+  // New pkg : org.tizen.alarm 2.0.0 (ro), org.tizen.new_rw 1.2.0 (rw)
+
+  EXPECT_CALL(GetMock<OsMock>(),
+        execvp(_, _))
+        .WillRepeatedly(
+            Invoke([&](const char* file, char* const argv[]) -> int {
+              std::string cmd = GetCmd(argv);
+              cmds.push_back(std::move(cmd));
+              return 0;
+            }));
+  EXPECT_CALL(GetMock<PkgMgrParserMock>(),
+      pkgmgr_parser_update_rw_to_ro_updated_pkg_in_db(_))
+      .WillOnce(Return(0));
+
+  ASSERT_TRUE(upgrader.Process(&finder_));
+
+  EXPECT_EQ(cmds.size(), 5);
+  EXPECT_EQ(cmds[0], "/usr/bin/tpk-backend --preload -d org.tizen.new_rw "
+      "--force-remove --keep-rwdata");
+  EXPECT_EQ(cmds[1], "/usr/bin/unzip -oXqq /usr/system/RestoreDir/opt.zip "
+      "opt/share/packages/org.tizen.new_rw.xml -d /");
+  EXPECT_EQ(cmds[2], "/usr/bin/unzip -oXqq /usr/system/RestoreDir/opt.zip "
+      "opt/usr/globalapps/org.tizen.new_rw/* -d /");
+  EXPECT_EQ(cmds[3], "/usr/bin/unzip -oXqq /usr/system/RestoreDir/opt.zip "
+      "opt/etc/skel/apps_rw/org.tizen.new_rw/* -d /");
+  EXPECT_EQ(cmds[4], "/usr/bin/tpk-backend -y org.tizen.new_rw --preload-rw "
+      "--skip-check-reference");
+}
+
+TEST_F(PkgUpgraderTest, Upgrader_RW2ADDED_RO_HIGH_VERSION) {
+  Upgrader upgrader;
+  upgrader.SetDbPath("./tests/unit_tests/pkg_upgrade/data/db");
+  std::vector<std::string> cmds;
+  SetOldPkgInfo(std::vector<PkgInfo>{
+      PkgInfo("org.tizen.new_rw", "tpk", "1.2.0", false, true, true),
+      PkgInfo("org.tizen.alarm", "tpk", "1.0.0", false, false, false)
+  });
+  // New pkg : org.tizen.alarm 2.0.0 (ro), org.tizen.new_rw 1.2.0 (rw)
+
+  EXPECT_CALL(GetMock<OsMock>(),
+        execvp(_, _))
+        .WillRepeatedly(
+            Invoke([&](const char* file, char* const argv[]) -> int {
+              std::string cmd = GetCmd(argv);
+              cmds.push_back(std::move(cmd));
+              return 0;
+            }));
+
+  ASSERT_TRUE(upgrader.Process(&finder_));
+
+  for (const auto& cmd : cmds)
+    std::cout << cmd << std::endl;
+
+  EXPECT_EQ(cmds.size(), 7);
+  EXPECT_EQ(cmds[0], "/usr/bin/tpk-backend -d org.tizen.alarm --keep-rwdata");
+  EXPECT_EQ(cmds[1], "/usr/bin/tpk-backend --preload -y org.tizen.alarm "
+      "--partial-rw --skip-check-reference");
+  EXPECT_EQ(cmds[2], "/usr/bin/tpk-backend --preload -d org.tizen.new_rw "
+      "--force-remove --keep-rwdata");
+  EXPECT_EQ(cmds[3], "/usr/bin/unzip -oXqq /usr/system/RestoreDir/opt.zip "
+      "opt/share/packages/org.tizen.new_rw.xml -d /");
+  EXPECT_EQ(cmds[4], "/usr/bin/unzip -oXqq /usr/system/RestoreDir/opt.zip "
+      "opt/usr/globalapps/org.tizen.new_rw/* -d /");
+  EXPECT_EQ(cmds[5], "/usr/bin/unzip -oXqq /usr/system/RestoreDir/opt.zip "
+      "opt/etc/skel/apps_rw/org.tizen.new_rw/* -d /");
+  EXPECT_EQ(cmds[6], "/usr/bin/tpk-backend -y org.tizen.new_rw --preload-rw "
+      "--skip-check-reference");
+}
+
+TEST_F(PkgUpgraderTest, Upgrader_RW2ADDED_RO_SAME_VERSION) {
+  Upgrader upgrader;
+  upgrader.SetDbPath("./tests/unit_tests/pkg_upgrade/data/db");
+  std::vector<std::string> cmds;
+  SetOldPkgInfo(std::vector<PkgInfo>{
+      PkgInfo("org.tizen.new_rw", "tpk", "1.2.0", false, true, true),
+      PkgInfo("org.tizen.alarm", "tpk", "2.0.0", false, false, false)
+  });
+  // New pkg : org.tizen.alarm 2.0.0 (ro), org.tizen.new_rw 1.2.0 (rw)
+
+  EXPECT_CALL(GetMock<OsMock>(),
+        execvp(_, _))
+        .WillRepeatedly(
+            Invoke([&](const char* file, char* const argv[]) -> int {
+              std::string cmd = GetCmd(argv);
+              cmds.push_back(std::move(cmd));
+              return 0;
+            }));
+
+  ASSERT_TRUE(upgrader.Process(&finder_));
+
+  for (const auto& cmd : cmds)
+    std::cout << cmd << std::endl;
+
+  EXPECT_EQ(cmds.size(), 7);
+  EXPECT_EQ(cmds[0], "/usr/bin/tpk-backend -d org.tizen.alarm --keep-rwdata");
+  EXPECT_EQ(cmds[1], "/usr/bin/tpk-backend --preload -y org.tizen.alarm "
+      "--partial-rw --skip-check-reference");
+  EXPECT_EQ(cmds[2], "/usr/bin/tpk-backend --preload -d org.tizen.new_rw "
+      "--force-remove --keep-rwdata");
+  EXPECT_EQ(cmds[3], "/usr/bin/unzip -oXqq /usr/system/RestoreDir/opt.zip "
+      "opt/share/packages/org.tizen.new_rw.xml -d /");
+  EXPECT_EQ(cmds[4], "/usr/bin/unzip -oXqq /usr/system/RestoreDir/opt.zip "
+      "opt/usr/globalapps/org.tizen.new_rw/* -d /");
+  EXPECT_EQ(cmds[5], "/usr/bin/unzip -oXqq /usr/system/RestoreDir/opt.zip "
+      "opt/etc/skel/apps_rw/org.tizen.new_rw/* -d /");
+  EXPECT_EQ(cmds[6], "/usr/bin/tpk-backend -y org.tizen.new_rw --preload-rw "
+      "--skip-check-reference");
+}
+
 class PkgUpgraderTestForInvalidDbPath : public TestFixture {
  public:
   PkgUpgraderTestForInvalidDbPath() : TestFixture(std::make_unique<Mocks>()) {}

diff --git a/tests/unit_tests/res-copy/src/test_condition_validator.cc b/tests/unit_tests/res-copy/src/test_condition_validator.cc
index c2fe687c061926874c0707c70a51abc32e6cc0e5..8cd2251adf984a6d9928dd50b4b9b8f42c84a918 100644 (file)
--- a/tests/unit_tests/res-copy/src/test_condition_validator.cc
+++ b/tests/unit_tests/res-copy/src/test_condition_validator.cc
@@ -22,6 +22,7 @@
 
 #include "mock/os_mock.h"
 #include "mock/pkgmgr_info_mock.h"
+#include "mock/pkgmgr_parser_mock.h"
 #include "mock/test_fixture.h"
 
 #include "include/condition_validator.hh"
@@ -39,7 +40,8 @@ using res_handler::ConditionValidator;
 using res_handler::ParamChecker;
 
 class Mocks : public ::testing::NiceMock<PkgMgrInfoMock>,
-    public ::testing::NiceMock<OsMock> {};
+    public ::testing::NiceMock<OsMock>,
+    public ::testing::NiceMock<PkgMgrParserMock> {};
 
 class ConditionValidatorTest : public TestFixture {
  public:

diff --git a/tests/unit_tests/res-copy/src/test_param_checker.cc b/tests/unit_tests/res-copy/src/test_param_checker.cc
index ffbe9b9fc2bd894f42b1fd7ec40f21e440a577f0..41079c891f7166d2e13a27ea37bbeae557cd1e69 100644 (file)
--- a/tests/unit_tests/res-copy/src/test_param_checker.cc
+++ b/tests/unit_tests/res-copy/src/test_param_checker.cc
@@ -22,6 +22,7 @@
 
 #include "mock/os_mock.h"
 #include "mock/pkgmgr_info_mock.h"
+#include "mock/pkgmgr_parser_mock.h"
 #include "mock/test_fixture.h"
 #include "include/param_checker.hh"
 #include "include/request_type.hh"
@@ -37,7 +38,8 @@ using ::testing::SaveArg;
 using res_handler::ParamChecker;
 
 class Mocks : public ::testing::NiceMock<PkgMgrInfoMock>,
-    public ::testing::NiceMock<OsMock> {};
+    public ::testing::NiceMock<OsMock>,
+    public ::testing::NiceMock<PkgMgrParserMock> {};
 
 class ParamCheckerTest : public TestFixture {
  public:

diff --git a/tests/unit_tests/res-copy/src/test_request_handler.cc b/tests/unit_tests/res-copy/src/test_request_handler.cc
index 4763a6c8899bfbc3d401b811b388fd40897fac83..1c8f86ead8ac2d8b43a77d5682cd9ab4446cced9 100644 (file)
--- a/tests/unit_tests/res-copy/src/test_request_handler.cc
+++ b/tests/unit_tests/res-copy/src/test_request_handler.cc
@@ -25,6 +25,7 @@
 
 #include "mock/os_mock.h"
 #include "mock/pkgmgr_info_mock.h"
+#include "mock/pkgmgr_parser_mock.h"
 #include "mock/test_fixture.h"
 
 #include "include/abstract_request_handler.hh"
@@ -75,7 +76,8 @@ fs::path GetDstRootPath() {
 }  // namespace
 
 class Mocks : public ::testing::NiceMock<PkgMgrInfoMock>,
-    public ::testing::NiceMock<OsMock> {};
+    public ::testing::NiceMock<OsMock>,
+    public ::testing::NiceMock<PkgMgrParserMock> {};
 
 class CopyRequestHandlerTest : public TestFixture {
  public:

diff --git a/tests/unit_tests/res-copy/src/test_request_handler_invoker.cc b/tests/unit_tests/res-copy/src/test_request_handler_invoker.cc
index deb1b580ebe1dae43fef22b6ea3358d0194ddb45..dd8b9896a11d88e0565e93381039f9d0ef361535 100644 (file)
--- a/tests/unit_tests/res-copy/src/test_request_handler_invoker.cc
+++ b/tests/unit_tests/res-copy/src/test_request_handler_invoker.cc
@@ -22,6 +22,7 @@
 
 #include "mock/os_mock.h"
 #include "mock/pkgmgr_info_mock.h"
+#include "mock/pkgmgr_parser_mock.h"
 #include "mock/test_fixture.h"
 #include "include/event_signal_sender.hh"
 #include "include/param_checker.hh"
@@ -40,7 +41,8 @@ using res_handler::ParamChecker;
 using res_handler::RequestHandlerInvoker;
 
 class Mocks : public ::testing::NiceMock<PkgMgrInfoMock>,
-    public ::testing::NiceMock<OsMock> {};
+    public ::testing::NiceMock<OsMock>,
+    public ::testing::NiceMock<PkgMgrParserMock> {};
 
 class RequestHandlerInvokerTest : public TestFixture {
  public: