Add routine to check file status

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

diff --git a/test/smoke_tests/extensive_smoke_test.cc b/test/smoke_tests/extensive_smoke_test.cc
index 3eb8e85987d2e7b5fb7b96eda2a1a2a3a21ccf68..dbee0fd96b8f0e8d779f3a310e6cf509b649184e 100644 (file)
--- a/test/smoke_tests/extensive_smoke_test.cc
+++ b/test/smoke_tests/extensive_smoke_test.cc
@@ -121,6 +121,9 @@ TEST_F(SmokeTest, DeltaMode_Tpk_Rollback) {
   std::string exec = "basicdali";
   ASSERT_EQ(backend.InstallWithSubprocess(path),
       BackendInterface::SubProcessResult::SUCCESS);
+  FileInfoCollector expected_file_status(pkgid, params);
+  ASSERT_TRUE(expected_file_status.Init());
+
   std::string test_uid_str = std::to_string(params.test_user.uid);
   const char* argv[] =
       {"", "-i", delta_package.c_str(), "-u", test_uid_str.c_str()};
@@ -139,6 +142,9 @@ TEST_F(SmokeTest, DeltaMode_Tpk_Rollback) {
                            "basicdali.png"));
     EXTENDED_ASSERT_TRUE(ValidateFileContentInPackage(pkgid,
         "res/MODIFIED", "version 1\n", params));
+    FileInfoCollector new_file_status(pkgid, params);
+    EXTENDED_ASSERT_TRUE(new_file_status.Init());
+    EXTENDED_ASSERT_TRUE(expected_file_status.IsEqual(new_file_status));
     return true;
   });
 }
@@ -149,6 +155,12 @@ TEST_F(SmokeTest, RecoveryMode_Tpk_Installation) {
   std::string appid = "smokeapp15.RecoveryModeTpkInstallation";
   std::string exec = "native";
   RemoveAllRecoveryFiles("/tpk-recovery", params.test_user.uid);
+  ASSERT_EQ(backend.InstallWithSubprocess(path),
+      BackendInterface::SubProcessResult::SUCCESS);
+  FileInfoCollector expected_file_status(pkgid, params);
+  ASSERT_TRUE(expected_file_status.Init());
+  ASSERT_EQ(backend.UninstallWithSubprocess(pkgid),
+      BackendInterface::SubProcessResult::SUCCESS);
 
   std::string test_uid_str = std::to_string(params.test_user.uid);
   std::vector<std::string> args =
@@ -163,6 +175,9 @@ TEST_F(SmokeTest, RecoveryMode_Tpk_Installation) {
       EXTENDED_ASSERT_EQ(backend.RecoverWithSubprocess(recovery_file),
           BackendInterface::SubProcessResult::SUCCESS);
       if (recovery_info->cleanup()) {
+        FileInfoCollector new_file_status(pkgid, params);
+        EXTENDED_ASSERT_TRUE(new_file_status.Init());
+        EXTENDED_ASSERT_TRUE(expected_file_status.IsEqual(new_file_status));
         EXTENDED_ASSERT_TRUE(ValidatePackage(pkgid, {appid, exec}, params));
         EXTENDED_ASSERT_EQ(backend.UninstallWithSubprocess(pkgid),
             BackendInterface::SubProcessResult::SUCCESS);
@@ -178,18 +193,28 @@ TEST_F(SmokeTest, RecoveryMode_Tpk_Installation) {
 TEST_F(SmokeTest, RecoveryMode_Tpk_Update) {
   bf::path path_old = kSmokePackagesDirectory / "RecoveryMode_Tpk_Update.tpk";
   bf::path path_new = kSmokePackagesDirectory / "RecoveryMode_Tpk_Update_2.tpk";
+  std::string pkgid = "smokeapp16";
+  std::string appid = "smokeapp16.RecoveryModeTpkUpdate";
+  std::string exec = "native";
   RemoveAllRecoveryFiles("/tpk-recovery", params.test_user.uid);
   ASSERT_EQ(backend.InstallWithSubprocess(path_old),
       BackendInterface::SubProcessResult::SUCCESS);
+  FileInfoCollector expected_file_status_old(pkgid, params);
+  ASSERT_TRUE(expected_file_status_old.Init());
+  ASSERT_EQ(backend.InstallWithSubprocess(path_new),
+      BackendInterface::SubProcessResult::SUCCESS);
+  FileInfoCollector expected_file_status_new(pkgid, params);
+  ASSERT_TRUE(expected_file_status_new.Init());
+  ASSERT_EQ(backend.UninstallWithSubprocess(pkgid),
+      BackendInterface::SubProcessResult::SUCCESS);
+  ASSERT_EQ(backend.InstallWithSubprocess(path_old),
+      BackendInterface::SubProcessResult::SUCCESS);
 
   std::string test_uid_str = std::to_string(params.test_user.uid);
   std::vector<std::string> args =
       {"", "-i", path_new.string(), "-u", test_uid_str.c_str()};
   backend.CrashAfterEachStep(&args, [&](int step) -> bool {
     if (step >= 2) {
-      std::string pkgid = "smokeapp16";
-      std::string appid = "smokeapp16.RecoveryModeTpkUpdate";
-      std::string exec = "native";
       bf::path recovery_file = FindRecoveryFile("/tpk-recovery",
           params.test_user.uid);
       EXTENDED_ASSERT_FALSE(recovery_file.empty());
@@ -202,13 +227,18 @@ TEST_F(SmokeTest, RecoveryMode_Tpk_Update) {
       std::string version = recovery_info->cleanup() ? "2" : "1";
       EXTENDED_ASSERT_TRUE(
           ValidateFileContentInPackage(pkgid, "res/VERSION", version, params));
+      FileInfoCollector new_file_status(pkgid, params);
+      EXTENDED_ASSERT_TRUE(new_file_status.Init());
       if (recovery_info->cleanup()) {
+        EXTENDED_ASSERT_TRUE(expected_file_status_new.IsEqual(new_file_status));
         EXTENDED_ASSERT_EQ(
             backend.UninstallWithSubprocess(pkgid),
             BackendInterface::SubProcessResult::SUCCESS);
         EXTENDED_ASSERT_EQ(
             backend.InstallWithSubprocess(path_old),
             BackendInterface::SubProcessResult::SUCCESS);
+      } else {
+        EXTENDED_ASSERT_TRUE(expected_file_status_old.IsEqual(new_file_status));
       }
     }
     return true;
@@ -231,10 +261,15 @@ TEST_F(SmokeTest, TEP_Tpk_TepInstallTepUpdateRollback) {
   TEP_TEST_STARTING_BLOCK(5)
   ASSERT_EQ(backend.InstallWithTEPWithSubprocess(path, tep1),
       BackendInterface::SubProcessResult::SUCCESS);
+  FileInfoCollector expected_file_status(pkgid, params);
+  ASSERT_TRUE(expected_file_status.Init());
   std::string test_uid_str = std::to_string(params.test_user.uid);
   const char* argv[] = {"", "-i", path.c_str(), "-u", test_uid_str.c_str(),
                         "-e", tep1.c_str()};
   backend.TestRollbackAfterEachStep(SIZEOFARRAY(argv), argv, [&]() -> bool {
+    FileInfoCollector new_file_status(pkgid, params);
+    EXTENDED_ASSERT_TRUE(new_file_status.Init());
+    EXTENDED_ASSERT_TRUE(expected_file_status.IsEqual(new_file_status));
     EXTENDED_ASSERT_TRUE(ValidatePackage(pkgid, {appid, exec}, params));
     EXTENDED_ASSERT_TRUE(ValidateFileContentInPackage(pkgid,
         "tep/tep1.tep", "tep1\n", params));
@@ -246,10 +281,15 @@ TEST_F(SmokeTest, TEP_Tpk_NoTepInstallTepUpdateRollback) {
   TEP_TEST_STARTING_BLOCK(6)
   ASSERT_EQ(backend.InstallWithSubprocess(path),
       BackendInterface::SubProcessResult::SUCCESS);
+  FileInfoCollector expected_file_status(pkgid, params);
+  ASSERT_TRUE(expected_file_status.Init());
   std::string test_uid_str = std::to_string(params.test_user.uid);
   const char* argv[] = {"", "-i", path.c_str(), "-u", test_uid_str.c_str(),
                         "-e", tep1.c_str()};
   backend.TestRollbackAfterEachStep(SIZEOFARRAY(argv), argv, [&]() -> bool {
+    FileInfoCollector new_file_status(pkgid, params);
+    EXTENDED_ASSERT_TRUE(new_file_status.Init());
+    EXTENDED_ASSERT_TRUE(expected_file_status.IsEqual(new_file_status));
     EXTENDED_ASSERT_TRUE(ValidatePackage(pkgid, {appid, exec}, params));
     bf::path root_path = ci::GetRootAppPath(params.is_readonly,
         params.test_user.uid);
@@ -263,9 +303,14 @@ TEST_F(SmokeTest, TEP_Tpk_TepInstallNoTepUpdateRollback) {
   TEP_TEST_STARTING_BLOCK(7)
   ASSERT_EQ(backend.InstallWithTEPWithSubprocess(path, tep1),
       BackendInterface::SubProcessResult::SUCCESS);
+  FileInfoCollector expected_file_status(pkgid, params);
+  ASSERT_TRUE(expected_file_status.Init());
   std::string test_uid_str = std::to_string(params.test_user.uid);
   const char* argv[] = {"", "-i", path.c_str(), "-u", test_uid_str.c_str()};
   backend.TestRollbackAfterEachStep(SIZEOFARRAY(argv), argv, [&]() -> bool {
+    FileInfoCollector new_file_status(pkgid, params);
+    EXTENDED_ASSERT_TRUE(new_file_status.Init());
+    EXTENDED_ASSERT_TRUE(expected_file_status.IsEqual(new_file_status));
     EXTENDED_ASSERT_TRUE(ValidatePackage(pkgid, {appid, exec}, params));
     EXTENDED_ASSERT_TRUE(ValidateFileContentInPackage(pkgid,
         "tep/tep1.tep", "tep1\n", params));
@@ -277,10 +322,15 @@ TEST_F(SmokeTest, TEP_Tpk_Mount_TepInstallTepUpdateRollback) {
   TEP_TEST_STARTING_BLOCK(12)
   ASSERT_EQ(backend.MountInstallWithTEPWithSubprocess(path, tep1),
       BackendInterface::SubProcessResult::SUCCESS);
+  FileInfoCollector expected_file_status(pkgid, params);
+  ASSERT_TRUE(expected_file_status.Init());
   std::string test_uid_str = std::to_string(params.test_user.uid);
   const char* argv[] = {"", "-w", path.c_str(), "-u", test_uid_str.c_str(),
                         "-e", tep2.c_str()};
   backend.TestRollbackAfterEachStep(SIZEOFARRAY(argv), argv, [&]() -> bool {
+    FileInfoCollector new_file_status(pkgid, params);
+    EXTENDED_ASSERT_TRUE(new_file_status.Init());
+    EXTENDED_ASSERT_TRUE(expected_file_status.IsEqual(new_file_status));
     ScopedTzipInterface package_mount(pkgid, params.test_user.uid);
     EXTENDED_ASSERT_TRUE(ValidatePackage(pkgid, {appid, exec}, params));
     EXTENDED_ASSERT_TRUE(ValidateFileContentInPackage(pkgid,
@@ -293,10 +343,15 @@ TEST_F(SmokeTest, TEP_Tpk_Mount_NoTepInstallTepUpdateRollback) {
   TEP_TEST_STARTING_BLOCK(13)
   ASSERT_EQ(backend.MountInstallWithSubprocess(path),
       BackendInterface::SubProcessResult::SUCCESS);
+  FileInfoCollector expected_file_status(pkgid, params);
+  ASSERT_TRUE(expected_file_status.Init());
   std::string test_uid_str = std::to_string(params.test_user.uid);
   const char* argv[] = {"", "-w", path.c_str(), "-u", test_uid_str.c_str(),
                         "-e", tep1.c_str()};
   backend.TestRollbackAfterEachStep(SIZEOFARRAY(argv), argv, [&]() -> bool {
+    FileInfoCollector new_file_status(pkgid, params);
+    EXTENDED_ASSERT_TRUE(new_file_status.Init());
+    EXTENDED_ASSERT_TRUE(expected_file_status.IsEqual(new_file_status));
     ScopedTzipInterface package_mount(pkgid, params.test_user.uid);
     EXTENDED_ASSERT_TRUE(ValidatePackage(pkgid, {appid, exec}, params));
     bf::path root_path = ci::GetRootAppPath(params.is_readonly,
@@ -311,9 +366,14 @@ TEST_F(SmokeTest, TEP_Tpk_Mount_TepInstallNoTepUpdateRollback) {
   TEP_TEST_STARTING_BLOCK(14)
   ASSERT_EQ(backend.MountInstallWithTEPWithSubprocess(path, tep1),
       BackendInterface::SubProcessResult::SUCCESS);
+  FileInfoCollector expected_file_status(pkgid, params);
+  ASSERT_TRUE(expected_file_status.Init());
   std::string test_uid_str = std::to_string(params.test_user.uid);
   const char* argv[] = {"", "-i", path.c_str(), "-u", test_uid_str.c_str()};
   backend.TestRollbackAfterEachStep(SIZEOFARRAY(argv), argv, [&]() -> bool {
+    FileInfoCollector new_file_status(pkgid, params);
+    EXTENDED_ASSERT_TRUE(new_file_status.Init());
+    EXTENDED_ASSERT_TRUE(expected_file_status.IsEqual(new_file_status));
     ScopedTzipInterface package_mount(pkgid, params.test_user.uid);
     EXTENDED_ASSERT_TRUE(ValidatePackage(pkgid, {appid, exec}, params));
     EXTENDED_ASSERT_TRUE(ValidateFileContentInPackage(pkgid,
@@ -337,18 +397,28 @@ TEST_F(SmokeTest, InstallationMode_Rollback) {
 TEST_F(SmokeTest, RecoveryMode_ForDelta) {
   bf::path path_old = kSmokePackagesDirectory / "RecoveryMode_ForDelta.tpk";
   bf::path path_new = kSmokePackagesDirectory / "RecoveryMode_ForDelta.delta";
+  std::string pkgid = "smoketpk35";
+  std::string appid = "smoketpk35.RecoveryMode_ForDelta";
+  std::string exec = "smoketpk35";
   RemoveAllRecoveryFiles("/tpk-recovery", params.test_user.uid);
   ASSERT_EQ(BackendInterface::SubProcessResult::SUCCESS,
       backend.InstallWithSubprocess(path_old));
+  FileInfoCollector expected_file_status_old(pkgid, params);
+  ASSERT_TRUE(expected_file_status_old.Init());
+  ASSERT_EQ(BackendInterface::SubProcessResult::SUCCESS,
+      backend.InstallWithSubprocess(path_new));
+  FileInfoCollector expected_file_status_new(pkgid, params);
+  ASSERT_TRUE(expected_file_status_new.Init());
+  ASSERT_EQ(BackendInterface::SubProcessResult::SUCCESS,
+      backend.UninstallWithSubprocess(pkgid));
+  ASSERT_EQ(BackendInterface::SubProcessResult::SUCCESS,
+      backend.InstallWithSubprocess(path_old));
 
   std::string test_uid_str = std::to_string(params.test_user.uid);
   std::vector<std::string> args =
     {"", "-i", path_new.string(), "-u", test_uid_str.c_str()};
   backend.CrashAfterEachStep(&args, [&](int step) -> bool {
     if (step >= 2) {
-      std::string pkgid = "smoketpk35";
-      std::string appid = "smoketpk35.RecoveryMode_ForDelta";
-      std::string exec = "smoketpk35";
       bf::path recovery_file = FindRecoveryFile("/tpk-recovery",
           params.test_user.uid);
       EXTENDED_ASSERT_FALSE(recovery_file.empty());
@@ -364,8 +434,11 @@ TEST_F(SmokeTest, RecoveryMode_ForDelta) {
               params));
       bf::path root_path = ci::GetRootAppPath(params.is_readonly,
           params.test_user.uid);
+      FileInfoCollector new_file_status(pkgid, params);
+      EXTENDED_ASSERT_TRUE(new_file_status.Init());
 
       if (recovery_info->cleanup()) {
+        EXTENDED_ASSERT_TRUE(expected_file_status_new.IsEqual(new_file_status));
         EXTENDED_ASSERT_FALSE(bf::exists(root_path / pkgid / "res/DELETED"));
         EXTENDED_ASSERT_TRUE(bf::exists(root_path / pkgid / "res/ADDED"));
         EXTENDED_ASSERT_EQ(backend.UninstallWithSubprocess(pkgid),
@@ -373,6 +446,7 @@ TEST_F(SmokeTest, RecoveryMode_ForDelta) {
         EXTENDED_ASSERT_EQ(backend.InstallWithSubprocess(path_old),
             BackendInterface::SubProcessResult::SUCCESS);
       } else {
+        EXTENDED_ASSERT_TRUE(expected_file_status_old.IsEqual(new_file_status));
         EXTENDED_ASSERT_TRUE(bf::exists(root_path / pkgid / "res/DELETED"));
         EXTENDED_ASSERT_FALSE(bf::exists(root_path / pkgid / "res/ADDED"));
       }
@@ -389,11 +463,16 @@ TEST_F(SmokeTest, UpdateMode_Rollback) {
   std::string exec = "smoketpk36";
   ASSERT_EQ(BackendInterface::SubProcessResult::SUCCESS,
       backend.InstallWithSubprocess(old_path));
+  FileInfoCollector expected_file_status(pkgid, params);
+  ASSERT_TRUE(expected_file_status.Init());
 
   std::string test_uid_str = std::to_string(params.test_user.uid);
   const char* argv[] =
       {"", "-i", new_path.c_str(), "-u", test_uid_str.c_str()};
   backend.TestRollbackAfterEachStep(SIZEOFARRAY(argv), argv, [&]() -> bool  {
+    FileInfoCollector new_file_status(pkgid, params);
+    EXTENDED_ASSERT_TRUE(new_file_status.Init());
+    EXTENDED_ASSERT_TRUE(expected_file_status.IsEqual(new_file_status));
     EXTENDED_ASSERT_TRUE(ValidatePackage(pkgid, {appid, exec}, params));
     EXTENDED_ASSERT_TRUE(ValidateFileContentInPackage(pkgid,
         "res/VERSION", "1", params));
@@ -438,19 +517,28 @@ TEST_F(SmokeTest, RecoveryMode_ForMountUpdate) {
       kSmokePackagesDirectory / "RecoveryMode_ForMountUpdate.tpk";
   bf::path path_new =
       kSmokePackagesDirectory / "RecoveryMode_ForMountUpdate2.tpk";
+  std::string pkgid = "smoketpk38";
+  std::string appid = "smoketpk38.RecoveryMode_ForMountUpdate";
+  std::string exec = "smoketpk38";
   RemoveAllRecoveryFiles("/tpk-recovery", params.test_user.uid);
   ASSERT_EQ(BackendInterface::SubProcessResult::SUCCESS,
       backend.MountInstallWithSubprocess(path_old));
+  FileInfoCollector expected_file_status_old(pkgid, params);
+  ASSERT_TRUE(expected_file_status_old.Init());
+  ASSERT_EQ(BackendInterface::SubProcessResult::SUCCESS,
+      backend.MountInstallWithSubprocess(path_new));
+  FileInfoCollector expected_file_status_new(pkgid, params);
+  ASSERT_TRUE(expected_file_status_new.Init());
+  ASSERT_EQ(BackendInterface::SubProcessResult::SUCCESS,
+      backend.UninstallWithSubprocess(pkgid));
+  ASSERT_EQ(BackendInterface::SubProcessResult::SUCCESS,
+      backend.MountInstallWithSubprocess(path_old));
 
   std::string test_uid_str = std::to_string(params.test_user.uid);
   std::vector<std::string> args =
       {"", "-w", path_new.string(), "-u", test_uid_str.c_str()};
   backend.CrashAfterEachStep(&args, [&](int step) -> bool {
     if (step >= 2) {
-      std::string pkgid = "smoketpk38";
-      std::string appid = "smoketpk38.RecoveryMode_ForMountUpdate";
-      std::string exec = "smoketpk38";
-
       // Filesystem may be mounted after crash
       ScopedTzipInterface poweroff_unmount_interface(pkgid,
           params.test_user.uid);
@@ -461,20 +549,27 @@ TEST_F(SmokeTest, RecoveryMode_ForMountUpdate) {
       EXTENDED_ASSERT_FALSE(recovery_file.empty());
       std::unique_ptr<ci::recovery::RecoveryFile> recovery_info =
           GetRecoverFileInfo(recovery_file);
+      std::cout << "recovery start" << std::endl;
       EXTENDED_ASSERT_EQ(backend.RecoverWithSubprocess(recovery_file),
           BackendInterface::SubProcessResult::SUCCESS);
+      std::cout << "recovery end" << std::endl;
       ScopedTzipInterface interface(pkgid, params.test_user.uid);
       EXTENDED_ASSERT_TRUE(ValidatePackage(pkgid, {appid, exec}, params));
       std::string version = recovery_info->cleanup() ? "2" : "1";
 
       EXTENDED_ASSERT_TRUE(ValidateFileContentInPackage(pkgid,
         "res/VERSION", version, params));
+      interface.Release();
+      FileInfoCollector new_file_status(pkgid, params);
+      EXTENDED_ASSERT_TRUE(new_file_status.Init());
       if (recovery_info->cleanup()) {
-        interface.Release();
+        EXTENDED_ASSERT_TRUE(expected_file_status_new.IsEqual(new_file_status));
         EXTENDED_ASSERT_EQ(backend.UninstallWithSubprocess(pkgid),
             BackendInterface::SubProcessResult::SUCCESS);
         EXTENDED_ASSERT_EQ(backend.MountInstallWithSubprocess(path_old),
             BackendInterface::SubProcessResult::SUCCESS);
+      } else {
+        EXTENDED_ASSERT_TRUE(expected_file_status_old.IsEqual(new_file_status));
       }
     }
     return true;
@@ -503,11 +598,16 @@ TEST_F(SmokeTest, MountUpdateMode_Rollback) {
   std::string exec = "smoketpk40";
   ASSERT_EQ(BackendInterface::SubProcessResult::SUCCESS,
       backend.MountInstallWithSubprocess(old_path));
+  FileInfoCollector expected_file_status(pkgid, params);
+  ASSERT_TRUE(expected_file_status.Init());
   std::string test_uid_str = std::to_string(params.test_user.uid);
   const char* argv[] =
     {"", "-w", new_path.c_str(), "-u", test_uid_str.c_str()};
 
   backend.TestRollbackAfterEachStep(SIZEOFARRAY(argv), argv, [&]() -> bool  {
+    FileInfoCollector new_file_status(pkgid, params);
+    EXTENDED_ASSERT_TRUE(new_file_status.Init());
+    EXTENDED_ASSERT_TRUE(expected_file_status.IsEqual(new_file_status));
     ScopedTzipInterface package_mount(pkgid, params.test_user.uid);
     EXTENDED_ASSERT_TRUE(ValidatePackage(pkgid, {appid, exec}, params));
     EXTENDED_ASSERT_TRUE(ValidateFileContentInPackage(pkgid,
@@ -521,18 +621,28 @@ TEST_F(PreloadSmokeTest, RecoveryMode_ForReadonlyUpdateInstall) {
       "RecoveryMode_ForReadonlyUpdateInstall.tpk";
   bf::path path_new = kSmokePackagesDirectory /
       "RecoveryMode_ForReadonlyUpdateInstall_2.tpk";
+  std::string pkgid = "smoketpk46";
+  std::string appid = "smoketpk46.RecoveryMode_ForReadonlyUpdateInstall";
+  std::string exec = "smoketpk46";
   RemoveAllRecoveryFiles("/tpk-recovery", params.test_user.uid);
   ASSERT_EQ(backend.InstallPreloadWithSubprocess(path_old),
       BackendInterface::SubProcessResult::SUCCESS);
+  FileInfoCollector expected_file_status_old(pkgid, params);
+  ASSERT_TRUE(expected_file_status_old.Init());
+  ASSERT_EQ(backend.InstallWithSubprocess(path_new),
+      BackendInterface::SubProcessResult::SUCCESS);
+  params.is_readonly = false;
+  FileInfoCollector expected_file_status_new(pkgid, params);
+  ASSERT_TRUE(expected_file_status_new.Init());
+  params.is_readonly = true;
+  ASSERT_EQ(backend.UninstallWithSubprocess(pkgid),
+      BackendInterface::SubProcessResult::SUCCESS);
 
   std::string test_uid_str = std::to_string(params.test_user.uid);
   std::vector<std::string> args =
       {"", "-i", path_new.string(), "-u", test_uid_str.c_str()};
   backend.CrashAfterEachStep(&args, [&](int step) -> bool {
     if (step >= 2) {
-      std::string pkgid = "smoketpk46";
-      std::string appid = "smoketpk46.RecoveryMode_ForReadonlyUpdateInstall";
-      std::string exec = "smoketpk46";
       bf::path recovery_file = FindRecoveryFile("/tpk-recovery",
           params.test_user.uid);
       EXTENDED_ASSERT_FALSE(recovery_file.empty());
@@ -540,8 +650,14 @@ TEST_F(PreloadSmokeTest, RecoveryMode_ForReadonlyUpdateInstall) {
           GetRecoverFileInfo(recovery_file);
       EXTENDED_ASSERT_EQ(backend.RecoverWithSubprocess(recovery_file),
           BackendInterface::SubProcessResult::SUCCESS);
-      if (recovery_info->cleanup())
+      FileInfoCollector* expected = &expected_file_status_old;
+      if (recovery_info->cleanup()) {
+        expected = &expected_file_status_new;
         params.is_readonly = false;
+      }
+      FileInfoCollector new_file_status(pkgid, params);
+      EXTENDED_ASSERT_TRUE(new_file_status.Init());
+      EXTENDED_ASSERT_TRUE(expected->IsEqual(new_file_status));
       EXTENDED_ASSERT_TRUE(ValidatePackage(pkgid, {appid, exec}, params));
       std::string version = recovery_info->cleanup() ? "2" : "1";
       EXTENDED_ASSERT_TRUE(
@@ -560,15 +676,24 @@ TEST_F(SmokeTest, RecoveryMode_AddResControl) {
       / "RecoveryMode_AddResControl.tpk";
   bf::path path_new = kSmokePackagesDirectory
       / "RecoveryMode_AddResControl_2.tpk";
-  RemoveAllRecoveryFiles("/tpk-recovery", params.test_user.uid);
-  ASSERT_EQ(backend.InstallWithSubprocess(path_old),
-      BackendInterface::SubProcessResult::SUCCESS);
-
   std::string pkgid = "smoketpk50";
   std::string appid = "smoketpk50.RecoveryMode_AddResControl";
   std::string exec = "native";
   bf::path root_path = ci::GetRootAppPath(params.is_readonly,
                                           params.test_user.uid);
+  RemoveAllRecoveryFiles("/tpk-recovery", params.test_user.uid);
+  ASSERT_EQ(backend.InstallWithSubprocess(path_old),
+      BackendInterface::SubProcessResult::SUCCESS);
+  FileInfoCollector expected_file_status_old(pkgid, params);
+  ASSERT_TRUE(expected_file_status_old.Init());
+  ASSERT_EQ(backend.InstallWithSubprocess(path_new),
+      BackendInterface::SubProcessResult::SUCCESS);
+  FileInfoCollector expected_file_status_new(pkgid, params);
+  ASSERT_TRUE(expected_file_status_new.Init());
+  ASSERT_EQ(backend.UninstallWithSubprocess(pkgid),
+      BackendInterface::SubProcessResult::SUCCESS);
+  ASSERT_EQ(backend.InstallWithSubprocess(path_old),
+      BackendInterface::SubProcessResult::SUCCESS);
 
   std::string test_uid_str = std::to_string(params.test_user.uid);
   std::vector<std::string> args =
@@ -588,12 +713,17 @@ TEST_F(SmokeTest, RecoveryMode_AddResControl) {
           dir_exists);
       EXTENDED_ASSERT_EQ(bf::exists(root_path / pkgid / "res/mount/global"),
           dir_exists);
+      FileInfoCollector new_file_status(pkgid, params);
+      EXTENDED_ASSERT_TRUE(new_file_status.Init());
 
       if (recovery_info->cleanup()) {
+        EXTENDED_ASSERT_TRUE(expected_file_status_new.IsEqual(new_file_status));
         EXTENDED_ASSERT_EQ(backend.UninstallWithSubprocess(pkgid),
             BackendInterface::SubProcessResult::SUCCESS);
         EXTENDED_ASSERT_EQ(backend.InstallWithSubprocess(path_old),
             BackendInterface::SubProcessResult::SUCCESS);
+      } else {
+        EXTENDED_ASSERT_TRUE(expected_file_status_old.IsEqual(new_file_status));
       }
     }
     return true;
@@ -605,15 +735,24 @@ TEST_F(SmokeTest, RecoveryMode_RemoveResControl) {
       / "RecoveryMode_RemoveResControl.tpk";
   bf::path path_new = kSmokePackagesDirectory
       / "RecoveryMode_RemoveResControl_2.tpk";
-  RemoveAllRecoveryFiles("/tpk-recovery", params.test_user.uid);
-  ASSERT_EQ(backend.InstallWithSubprocess(path_old),
-      BackendInterface::SubProcessResult::SUCCESS);
-
   std::string pkgid = "smoketpk51";
   std::string appid = "smoketpk51.RecoveryMode_RemoveResControl";
   std::string exec = "native";
   bf::path root_path = ci::GetRootAppPath(params.is_readonly,
                                           params.test_user.uid);
+  RemoveAllRecoveryFiles("/tpk-recovery", params.test_user.uid);
+  ASSERT_EQ(backend.InstallWithSubprocess(path_old),
+      BackendInterface::SubProcessResult::SUCCESS);
+  FileInfoCollector expected_file_status_old(pkgid, params);
+  ASSERT_TRUE(expected_file_status_old.Init());
+  ASSERT_EQ(backend.InstallWithSubprocess(path_new),
+      BackendInterface::SubProcessResult::SUCCESS);
+  FileInfoCollector expected_file_status_new(pkgid, params);
+  ASSERT_TRUE(expected_file_status_new.Init());
+  ASSERT_EQ(backend.UninstallWithSubprocess(pkgid),
+      BackendInterface::SubProcessResult::SUCCESS);
+  ASSERT_EQ(backend.InstallWithSubprocess(path_old),
+      BackendInterface::SubProcessResult::SUCCESS);
 
   std::string test_uid_str = std::to_string(params.test_user.uid);
   std::vector<std::string> args =
@@ -633,12 +772,17 @@ TEST_F(SmokeTest, RecoveryMode_RemoveResControl) {
           dir_exists);
       EXTENDED_ASSERT_EQ(bf::exists(root_path / pkgid / "res/mount/global"),
           dir_exists);
+      FileInfoCollector new_file_status(pkgid, params);
+      EXTENDED_ASSERT_TRUE(new_file_status.Init());
 
       if (recovery_info->cleanup()) {
+        EXTENDED_ASSERT_TRUE(expected_file_status_new.IsEqual(new_file_status));
         EXTENDED_ASSERT_EQ(backend.UninstallWithSubprocess(pkgid),
             BackendInterface::SubProcessResult::SUCCESS);
         EXTENDED_ASSERT_EQ(backend.InstallWithSubprocess(path_old),
             BackendInterface::SubProcessResult::SUCCESS);
+      } else {
+        EXTENDED_ASSERT_TRUE(expected_file_status_old.IsEqual(new_file_status));
       }
     }
     return true;