Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e222fa4d authored by Yo Chiang's avatar Yo Chiang Committed by Gerrit Code Review
Browse files

Merge "Enable disabled CtsFsMgrTestCases test cases"

parents 6cbc7e01 7e122fed

fs_mgr/tests/fs_mgr_test.cpp

+102 −92
Original line number Original line Diff line number Diff line
@@ -184,6 +184,36 @@ const std::vector<std::pair<std::string, std::string>> bootconfig_result_space = 
        {"androidboot.space", "sha256 5248 androidboot.nospace = nope"},

        {"androidboot.space", "sha256 5248 androidboot.nospace = nope"},

};

};





bool CompareFlags(FstabEntry::FsMgrFlags& lhs, FstabEntry::FsMgrFlags& rhs) {

    // clang-format off

    return lhs.wait == rhs.wait &&

           lhs.check == rhs.check &&

           lhs.crypt == rhs.crypt &&

           lhs.nonremovable == rhs.nonremovable &&

           lhs.vold_managed == rhs.vold_managed &&

           lhs.recovery_only == rhs.recovery_only &&

           lhs.verify == rhs.verify &&

           lhs.force_crypt == rhs.force_crypt &&

           lhs.no_emulated_sd == rhs.no_emulated_sd &&

           lhs.no_trim == rhs.no_trim &&

           lhs.file_encryption == rhs.file_encryption &&

           lhs.formattable == rhs.formattable &&

           lhs.slot_select == rhs.slot_select &&

           lhs.force_fde_or_fbe == rhs.force_fde_or_fbe &&

           lhs.late_mount == rhs.late_mount &&

           lhs.no_fail == rhs.no_fail &&

           lhs.verify_at_boot == rhs.verify_at_boot &&

           lhs.quota == rhs.quota &&

           lhs.avb == rhs.avb &&

           lhs.logical == rhs.logical &&

           lhs.checkpoint_blk == rhs.checkpoint_blk &&

           lhs.checkpoint_fs == rhs.checkpoint_fs &&

           lhs.first_stage_mount == rhs.first_stage_mount &&

           lhs.slot_select_other == rhs.slot_select_other &&

           lhs.fs_verity == rhs.fs_verity;

    // clang-format on

}



}  // namespace

}  // namespace





TEST(fs_mgr, fs_mgr_parse_cmdline) {

TEST(fs_mgr, fs_mgr_parse_cmdline) {
@@ -291,8 +321,7 @@ TEST(fs_mgr, fs_mgr_read_fstab_file_proc_mounts) { 
    EXPECT_EQ(i, fstab.size());

    EXPECT_EQ(i, fstab.size());

}

}





// TODO(124837435): enable it later when it can pass TreeHugger.

TEST(fs_mgr, ReadFstabFromFile_MountOptions) {

TEST(fs_mgr, DISABLED_ReadFstabFromFile_MountOptions) {

    TemporaryFile tf;

    TemporaryFile tf;

    ASSERT_TRUE(tf.fd != -1);

    ASSERT_TRUE(tf.fd != -1);

    std::string fstab_contents = R"fs(

    std::string fstab_contents = R"fs(
@@ -316,88 +345,69 @@ source none5 swap rw zramsize=1073741824, 




    Fstab fstab;

    Fstab fstab;

    EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));

    EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));

    ASSERT_EQ(11U, fstab.size());

    ASSERT_LE(11U, fstab.size());





    EXPECT_EQ("/", fstab[0].mount_point);

    FstabEntry* entry = GetEntryForMountPoint(&fstab, "/");

    EXPECT_EQ(static_cast<unsigned long>(MS_RDONLY), fstab[0].flags);

    ASSERT_NE(nullptr, entry);

    EXPECT_EQ("barrier=1", fstab[0].fs_options);

    EXPECT_EQ(static_cast<unsigned long>(MS_RDONLY), entry->flags);



    EXPECT_EQ("barrier=1", entry->fs_options);

    EXPECT_EQ("/metadata", fstab[1].mount_point);



    EXPECT_EQ(static_cast<unsigned long>(MS_NOATIME | MS_NOSUID | MS_NODEV), fstab[1].flags);

    entry = GetEntryForMountPoint(&fstab, "/metadata");

    EXPECT_EQ("discard", fstab[1].fs_options);

    ASSERT_NE(nullptr, entry);



    EXPECT_EQ(static_cast<unsigned long>(MS_NOATIME | MS_NOSUID | MS_NODEV), entry->flags);

    EXPECT_EQ("/data", fstab[2].mount_point);

    EXPECT_EQ("discard", entry->fs_options);

    EXPECT_EQ(static_cast<unsigned long>(MS_NOATIME | MS_NOSUID | MS_NODEV), fstab[2].flags);



    EXPECT_EQ("discard,reserve_root=32768,resgid=1065,fsync_mode=nobarrier", fstab[2].fs_options);

    entry = GetEntryForMountPoint(&fstab, "/data");



    ASSERT_NE(nullptr, entry);

    EXPECT_EQ("/misc", fstab[3].mount_point);

    EXPECT_EQ(static_cast<unsigned long>(MS_NOATIME | MS_NOSUID | MS_NODEV), entry->flags);

    EXPECT_EQ(0U, fstab[3].flags);

    EXPECT_EQ("discard,reserve_root=32768,resgid=1065,fsync_mode=nobarrier", entry->fs_options);

    EXPECT_EQ("", fstab[3].fs_options);





    entry = GetEntryForMountPoint(&fstab, "/misc");

    EXPECT_EQ("/vendor/firmware_mnt", fstab[4].mount_point);

    ASSERT_NE(nullptr, entry);

    EXPECT_EQ(static_cast<unsigned long>(MS_RDONLY), fstab[4].flags);

    EXPECT_EQ(0U, entry->flags);

    EXPECT_EQ("", entry->fs_options);



    entry = GetEntryForMountPoint(&fstab, "/vendor/firmware_mnt");

    ASSERT_NE(nullptr, entry);

    EXPECT_EQ(static_cast<unsigned long>(MS_RDONLY), entry->flags);

    EXPECT_EQ(

    EXPECT_EQ(

            "shortname=lower,uid=1000,gid=1000,dmask=227,fmask=337,"

            "shortname=lower,uid=1000,gid=1000,dmask=227,fmask=337,"

            "context=u:object_r:firmware_file:s0",

            "context=u:object_r:firmware_file:s0",

            fstab[4].fs_options);

            entry->fs_options);





    EXPECT_EQ("auto", fstab[5].mount_point);

    entry = GetEntryForMountPoint(&fstab, "auto");

    EXPECT_EQ(0U, fstab[5].flags);

    ASSERT_NE(nullptr, entry);

    EXPECT_EQ("", fstab[5].fs_options);

    EXPECT_EQ(0U, entry->flags);



    EXPECT_EQ("", entry->fs_options);

    EXPECT_EQ("none", fstab[6].mount_point);



    EXPECT_EQ(0U, fstab[6].flags);

    entry = GetEntryForMountPoint(&fstab, "none");

    EXPECT_EQ("", fstab[6].fs_options);

    ASSERT_NE(nullptr, entry);



    EXPECT_EQ(0U, entry->flags);

    EXPECT_EQ("none2", fstab[7].mount_point);

    EXPECT_EQ("", entry->fs_options);

    EXPECT_EQ(static_cast<unsigned long>(MS_NODIRATIME | MS_REMOUNT | MS_BIND), fstab[7].flags);



    EXPECT_EQ("", fstab[7].fs_options);

    entry = GetEntryForMountPoint(&fstab, "none2");



    ASSERT_NE(nullptr, entry);

    EXPECT_EQ("none3", fstab[8].mount_point);

    EXPECT_EQ(static_cast<unsigned long>(MS_NODIRATIME | MS_REMOUNT | MS_BIND), entry->flags);

    EXPECT_EQ(static_cast<unsigned long>(MS_UNBINDABLE | MS_PRIVATE | MS_SLAVE), fstab[8].flags);

    EXPECT_EQ("", entry->fs_options);

    EXPECT_EQ("", fstab[8].fs_options);





    entry = GetEntryForMountPoint(&fstab, "none3");

    EXPECT_EQ("none4", fstab[9].mount_point);

    ASSERT_NE(nullptr, entry);

    EXPECT_EQ(static_cast<unsigned long>(MS_NOEXEC | MS_SHARED | MS_REC), fstab[9].flags);

    EXPECT_EQ(static_cast<unsigned long>(MS_UNBINDABLE | MS_PRIVATE | MS_SLAVE), entry->flags);

    EXPECT_EQ("", fstab[9].fs_options);

    EXPECT_EQ("", entry->fs_options);





    EXPECT_EQ("none5", fstab[10].mount_point);

    entry = GetEntryForMountPoint(&fstab, "none4");

    EXPECT_EQ(0U, fstab[10].flags);  // rw is the same as defaults

    ASSERT_NE(nullptr, entry);

    EXPECT_EQ("", fstab[10].fs_options);

    EXPECT_EQ(static_cast<unsigned long>(MS_NOEXEC | MS_SHARED | MS_REC), entry->flags);

}

    EXPECT_EQ("", entry->fs_options);





static bool CompareFlags(FstabEntry::FsMgrFlags& lhs, FstabEntry::FsMgrFlags& rhs) {

    entry = GetEntryForMountPoint(&fstab, "none5");

    // clang-format off

    ASSERT_NE(nullptr, entry);

    return lhs.wait == rhs.wait &&

    // rw is the default.

           lhs.check == rhs.check &&

    EXPECT_EQ(0U, entry->flags);

           lhs.crypt == rhs.crypt &&

    EXPECT_EQ("", entry->fs_options);

           lhs.nonremovable == rhs.nonremovable &&

           lhs.vold_managed == rhs.vold_managed &&

           lhs.recovery_only == rhs.recovery_only &&

           lhs.verify == rhs.verify &&

           lhs.force_crypt == rhs.force_crypt &&

           lhs.no_emulated_sd == rhs.no_emulated_sd &&

           lhs.no_trim == rhs.no_trim &&

           lhs.file_encryption == rhs.file_encryption &&

           lhs.formattable == rhs.formattable &&

           lhs.slot_select == rhs.slot_select &&

           lhs.force_fde_or_fbe == rhs.force_fde_or_fbe &&

           lhs.late_mount == rhs.late_mount &&

           lhs.no_fail == rhs.no_fail &&

           lhs.verify_at_boot == rhs.verify_at_boot &&

           lhs.quota == rhs.quota &&

           lhs.avb == rhs.avb &&

           lhs.logical == rhs.logical &&

           lhs.checkpoint_blk == rhs.checkpoint_blk &&

           lhs.checkpoint_fs == rhs.checkpoint_fs &&

           lhs.first_stage_mount == rhs.first_stage_mount &&

           lhs.slot_select_other == rhs.slot_select_other &&

           lhs.fs_verity == rhs.fs_verity;

    // clang-format on

}

}





// TODO(124837435): enable it later when it can pass TreeHugger.

TEST(fs_mgr, ReadFstabFromFile_FsMgrFlags) {

TEST(fs_mgr, DISABLED_ReadFstabFromFile_FsMgrFlags) {

    TemporaryFile tf;

    TemporaryFile tf;

    ASSERT_TRUE(tf.fd != -1);

    ASSERT_TRUE(tf.fd != -1);

    std::string fstab_contents = R"fs(

    std::string fstab_contents = R"fs(
@@ -412,10 +422,10 @@ source none5 swap defaults defaults 




    Fstab fstab;

    Fstab fstab;

    EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));

    EXPECT_TRUE(ReadFstabFromFile(tf.path, &fstab));

    ASSERT_EQ(6U, fstab.size());

    ASSERT_LE(6U, fstab.size());





    auto entry = fstab.begin();

    FstabEntry* entry = GetEntryForMountPoint(&fstab, "none0");

    EXPECT_EQ("none0", entry->mount_point);

    ASSERT_NE(nullptr, entry);

    {

    {

        FstabEntry::FsMgrFlags flags = {};

        FstabEntry::FsMgrFlags flags = {};

        flags.wait = true;

        flags.wait = true;
@@ -426,9 +436,9 @@ source none5 swap defaults defaults 
        flags.verify = true;

        flags.verify = true;

        EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));

        EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));

    }

    }

    entry++;





    EXPECT_EQ("none1", entry->mount_point);

    entry = GetEntryForMountPoint(&fstab, "none1");

    ASSERT_NE(nullptr, entry);

    {

    {

        FstabEntry::FsMgrFlags flags = {};

        FstabEntry::FsMgrFlags flags = {};

        flags.avb = true;

        flags.avb = true;
@@ -439,9 +449,9 @@ source none5 swap defaults defaults 
        flags.no_fail = true;

        flags.no_fail = true;

        EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));

        EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));

    }

    }

    entry++;





    EXPECT_EQ("none2", entry->mount_point);

    entry = GetEntryForMountPoint(&fstab, "none2");

    ASSERT_NE(nullptr, entry);

    {

    {

        FstabEntry::FsMgrFlags flags = {};

        FstabEntry::FsMgrFlags flags = {};

        flags.first_stage_mount = true;

        flags.first_stage_mount = true;
@@ -451,25 +461,25 @@ source none5 swap defaults defaults 
        flags.slot_select_other = true;

        flags.slot_select_other = true;

        EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));

        EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));

    }

    }

    entry++;





    EXPECT_EQ("none3", entry->mount_point);

    entry = GetEntryForMountPoint(&fstab, "none3");

    ASSERT_NE(nullptr, entry);

    {

    {

        FstabEntry::FsMgrFlags flags = {};

        FstabEntry::FsMgrFlags flags = {};

        flags.checkpoint_blk = true;

        flags.checkpoint_blk = true;

        EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));

        EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));

    }

    }

    entry++;





    EXPECT_EQ("none4", entry->mount_point);

    entry = GetEntryForMountPoint(&fstab, "none4");

    ASSERT_NE(nullptr, entry);

    {

    {

        FstabEntry::FsMgrFlags flags = {};

        FstabEntry::FsMgrFlags flags = {};

        flags.checkpoint_fs = true;

        flags.checkpoint_fs = true;

        EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));

        EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));

    }

    }

    entry++;





    EXPECT_EQ("none5", entry->mount_point);

    entry = GetEntryForMountPoint(&fstab, "none5");

    ASSERT_NE(nullptr, entry);

    {

    {

        FstabEntry::FsMgrFlags flags = {};

        FstabEntry::FsMgrFlags flags = {};

        EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));

        EXPECT_TRUE(CompareFlags(flags, entry->fs_mgr_flags));