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

Commit 111bec1e authored by David Anderson's avatar David Anderson
Browse files

libsnapshot: Improve low space tests. 

These tests have historically been pretty flaky, and have gone through a
few rounds of improvement. This is yet another: remove the
parameterization, so we can test that at least one variant of the test
succeeds, rather than all of them.

Filesystems (especially F2FS) have a lot going on underneath the hood,
and there's no guarantee that precise free space can be allocated,
measured, or relied upon in the ways this test expects. And all that we
really need to test is that some kind of out-of-space error can be
triggered.

Bug: 266645706
Test: vts_libsnapshot_test
Change-Id: I9620e5b496d5020b21cc37074e87dd21fc419ed2
parent d019150a

fs_mgr/libsnapshot/snapshot_test.cpp

+24 −22
Original line number Diff line number Diff line
@@ -2669,44 +2669,46 @@ INSTANTIATE_TEST_SUITE_P(Snapshot, FlashAfterUpdateTest, Combine(Values(0, 1), B 
                                    "Merge"s;

                         });



// Test behavior of ImageManager::Create on low space scenario. These tests assumes image manager

// uses /data as backup device.

class ImageManagerTest : public SnapshotTest, public WithParamInterface<uint64_t> {

class ImageManagerTest : public SnapshotTest {

  protected:

    void SetUp() override {

        SKIP_IF_NON_VIRTUAL_AB();

        SnapshotTest::SetUp();

        userdata_ = std::make_unique<LowSpaceUserdata>();

        ASSERT_TRUE(userdata_->Init(GetParam()));

    }

    void TearDown() override {

        RETURN_IF_NON_VIRTUAL_AB();



        CleanUp();

    }

    void CleanUp() {

        EXPECT_TRUE(!image_manager_->BackingImageExists(kImageName) ||

                    image_manager_->DeleteBackingImage(kImageName));

    }



    static constexpr const char* kImageName = "my_image";

    std::unique_ptr<LowSpaceUserdata> userdata_;

};



TEST_P(ImageManagerTest, CreateImageNoSpace) {

    uint64_t to_allocate = userdata_->free_space() + userdata_->bsize();

TEST_F(ImageManagerTest, CreateImageNoSpace) {

    bool at_least_one_failure = false;

    for (uint64_t size = 1_MiB; size <= 512_MiB; size *= 2) {

        auto userdata = std::make_unique<LowSpaceUserdata>();

        ASSERT_TRUE(userdata->Init(size));



        uint64_t to_allocate = userdata->free_space() + userdata->bsize();



        auto res = image_manager_->CreateBackingImage(kImageName, to_allocate,

                                                      IImageManager::CREATE_IMAGE_DEFAULT);

    ASSERT_FALSE(res) << "Should not be able to create image with size = " << to_allocate

                      << " bytes because only " << userdata_->free_space() << " bytes are free";

    ASSERT_EQ(FiemapStatus::ErrorCode::NO_SPACE, res.error_code()) << res.string();

        if (!res) {

            at_least_one_failure = true;

        } else {

            ASSERT_EQ(res.error_code(), FiemapStatus::ErrorCode::NO_SPACE) << res.string();

        }



std::vector<uint64_t> ImageManagerTestParams() {

    std::vector<uint64_t> ret;

    for (uint64_t size = 1_MiB; size <= 512_MiB; size *= 2) {

        ret.push_back(size);

    }

    return ret;

        CleanUp();

    }



INSTANTIATE_TEST_SUITE_P(ImageManagerTest, ImageManagerTest, ValuesIn(ImageManagerTestParams()));

    ASSERT_TRUE(at_least_one_failure)

            << "We should have failed to allocate at least one over-sized image";

}



bool Mkdir(const std::string& path) {

    if (mkdir(path.c_str(), 0700) && errno != EEXIST) {

fs_mgr/libsnapshot/test_helpers.cpp

+1 −1
Original line number Diff line number Diff line
@@ -227,7 +227,7 @@ AssertionResult LowSpaceUserdata::Init(uint64_t max_free_space) { 
        return AssertionFailure() << "Temp file allocated to " << big_file_->path << ", not in "

                                  << kUserDataDevice;

    }

    uint64_t next_consume = std::min(available_space_ - max_free_space,

    uint64_t next_consume = std::min(std::max(available_space_, max_free_space) - max_free_space,

                                     (uint64_t)std::numeric_limits<off_t>::max());

    off_t allocated = 0;

    while (next_consume > 0 && free_space_ > max_free_space) {