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

Commit 0562d7d7 authored by Automerger Merge Worker's avatar Automerger Merge Worker
Browse files

Merge "directly call data loader manager service from incremental service"... 

Merge "directly call data loader manager service from incremental service" into rvc-dev am: 8412d575

Change-Id: Ibc58237516e3e5b249c666c83c44ec2922c136f2
parents cb13e713 8412d575

services/incremental/IncrementalService.cpp

+17 −19
Original line number Diff line number Diff line
@@ -155,7 +155,7 @@ std::string makeBindMdName() { 
} // namespace



IncrementalService::IncFsMount::~IncFsMount() {

    incrementalService.mIncrementalManager->destroyDataLoader(mountId);

    incrementalService.mDataLoaderManager->destroyDataLoader(mountId);

    control.reset();

    LOG(INFO) << "Unmounting and cleaning up mount " << mountId << " with root '" << root << '\'';

    for (auto&& [target, _] : bindPoints) {
@@ -229,14 +229,14 @@ void IncrementalService::IncFsMount::cleanupFilesystem(std::string_view root) { 


IncrementalService::IncrementalService(ServiceManagerWrapper&& sm, std::string_view rootDir)

      : mVold(sm.getVoldService()),

        mIncrementalManager(sm.getIncrementalManager()),

        mDataLoaderManager(sm.getDataLoaderManager()),

        mIncFs(sm.getIncFs()),

        mIncrementalDir(rootDir) {

    if (!mVold) {

        LOG(FATAL) << "Vold service is unavailable";

    }

    if (!mIncrementalManager) {

        LOG(FATAL) << "IncrementalManager service is unavailable";

    if (!mDataLoaderManager) {

        LOG(FATAL) << "DataLoaderManagerService is unavailable";

    }

    mountExistingImages();

}
@@ -921,7 +921,6 @@ bool IncrementalService::startLoading(StorageId storage) const { 
    if (!ifs) {

        return false;

    }

    bool started = false;

    std::unique_lock l(ifs->lock);

    if (ifs->dataLoaderStatus != IDataLoaderStatusListener::DATA_LOADER_CREATED) {

        if (ifs->dataLoaderReady.wait_for(l, Seconds(5)) == std::cv_status::timeout) {
@@ -929,11 +928,19 @@ bool IncrementalService::startLoading(StorageId storage) const { 
            return false;

        }

    }

    auto status = mIncrementalManager->startDataLoader(ifs->mountId, &started);

    sp<IDataLoader> dataloader;

    auto status = mDataLoaderManager->getDataLoader(ifs->mountId, &dataloader);

    if (!status.isOk()) {

        return false;

    }

    return started;

    if (!dataloader) {

        return false;

    }

    status = dataloader->start();

    if (!status.isOk()) {

        return false;

    }

    return true;

}



void IncrementalService::mountExistingImages() {
@@ -1086,7 +1093,7 @@ bool IncrementalService::prepareDataLoader(IncrementalService::IncFsMount& ifs, 
    sp<IncrementalDataLoaderListener> listener =

            new IncrementalDataLoaderListener(*this, *externalListener);

    bool created = false;

    auto status = mIncrementalManager->prepareDataLoader(ifs.mountId, fsControlParcel, *dlp,

    auto status = mDataLoaderManager->initializeDataLoader(ifs.mountId, *dlp, fsControlParcel,

                                                           listener, &created);

    if (!status.isOk() || !created) {

        LOG(ERROR) << "Failed to create a data loader for mount " << ifs.mountId;
@@ -1229,16 +1236,7 @@ binder::Status IncrementalService::IncrementalDataLoaderListener::onStatusChange 
    ifs->dataLoaderStatus = newStatus;

    switch (newStatus) {

        case IDataLoaderStatusListener::DATA_LOADER_NO_CONNECTION: {

            auto now = Clock::now();

            if (ifs->connectionLostTime.time_since_epoch().count() == 0) {

                ifs->connectionLostTime = now;

                break;

            }

            auto duration =

                    std::chrono::duration_cast<Seconds>(now - ifs->connectionLostTime).count();

            if (duration >= 10) {

                incrementalService.mIncrementalManager->showHealthBlockedUI(mountId);

            }

            // TODO(b/150411019): handle data loader connection loss

            break;

        }

        case IDataLoaderStatusListener::DATA_LOADER_CONNECTION_OK: {

services/incremental/IncrementalService.h

+1 −2
Original line number Diff line number Diff line
@@ -19,7 +19,6 @@ 
#include <android-base/strings.h>

#include <android-base/unique_fd.h>

#include <android/content/pm/DataLoaderParamsParcel.h>

#include <android/os/incremental/IIncrementalManager.h>

#include <binder/IServiceManager.h>

#include <utils/String16.h>

#include <utils/StrongPointer.h>
@@ -220,7 +219,7 @@ private: 


    // Member variables

    std::unique_ptr<VoldServiceWrapper> mVold;

    std::unique_ptr<IncrementalManagerWrapper> mIncrementalManager;

    std::unique_ptr<DataLoaderManagerWrapper> mDataLoaderManager;

    std::unique_ptr<IncFsWrapper> mIncFs;

    const std::string mIncrementalDir;

services/incremental/ServiceWrappers.cpp

+5 −5
Original line number Diff line number Diff line
@@ -23,7 +23,7 @@ using namespace std::literals; 
namespace android::os::incremental {



static constexpr auto kVoldServiceName = "vold"sv;

static constexpr auto kIncrementalManagerName = "incremental"sv;

static constexpr auto kDataLoaderManagerName = "dataloader_manager"sv;



RealServiceManager::RealServiceManager(sp<IServiceManager> serviceManager)

      : mServiceManager(std::move(serviceManager)) {}
@@ -46,11 +46,11 @@ std::unique_ptr<VoldServiceWrapper> RealServiceManager::getVoldService() { 
    return nullptr;

}



std::unique_ptr<IncrementalManagerWrapper> RealServiceManager::getIncrementalManager() {

    sp<IIncrementalManager> manager =

            RealServiceManager::getRealService<IIncrementalManager>(kIncrementalManagerName);

std::unique_ptr<DataLoaderManagerWrapper> RealServiceManager::getDataLoaderManager() {

    sp<IDataLoaderManager> manager =

            RealServiceManager::getRealService<IDataLoaderManager>(kDataLoaderManagerName);

    if (manager) {

        return std::make_unique<RealIncrementalManager>(manager);

        return std::make_unique<RealDataLoaderManager>(manager);

    }

    return nullptr;

}

services/incremental/ServiceWrappers.h

+23 −26
Original line number Diff line number Diff line
@@ -20,9 +20,10 @@ 
#include <android-base/unique_fd.h>

#include <android/content/pm/DataLoaderParamsParcel.h>

#include <android/content/pm/FileSystemControlParcel.h>

#include <android/content/pm/IDataLoader.h>

#include <android/content/pm/IDataLoaderManager.h>

#include <android/content/pm/IDataLoaderStatusListener.h>

#include <android/os/IVold.h>

#include <android/os/incremental/IIncrementalManager.h>

#include <binder/IServiceManager.h>

#include <incfs.h>
@@ -50,17 +51,16 @@ public: 
                                     const std::string& targetDir) const = 0;

};



class IncrementalManagerWrapper {

class DataLoaderManagerWrapper {

public:

    virtual ~IncrementalManagerWrapper() = default;

    virtual binder::Status prepareDataLoader(MountId mountId,

                                             const FileSystemControlParcel& control,

    virtual ~DataLoaderManagerWrapper() = default;

    virtual binder::Status initializeDataLoader(MountId mountId,

                                                const DataLoaderParamsParcel& params,

                                                const FileSystemControlParcel& control,

                                                const sp<IDataLoaderStatusListener>& listener,

                                                bool* _aidl_return) const = 0;

    virtual binder::Status startDataLoader(MountId mountId, bool* _aidl_return) const = 0;

    virtual binder::Status getDataLoader(MountId mountId, sp<IDataLoader>* _aidl_return) const = 0;

    virtual binder::Status destroyDataLoader(MountId mountId) const = 0;

    virtual binder::Status showHealthBlockedUI(MountId mountId) const = 0;

};



class IncFsWrapper {
@@ -82,7 +82,7 @@ class ServiceManagerWrapper { 
public:

    virtual ~ServiceManagerWrapper() = default;

    virtual std::unique_ptr<VoldServiceWrapper> getVoldService() = 0;

    virtual std::unique_ptr<IncrementalManagerWrapper> getIncrementalManager() = 0;

    virtual std::unique_ptr<DataLoaderManagerWrapper> getDataLoaderManager() = 0;

    virtual std::unique_ptr<IncFsWrapper> getIncFs() = 0;

};
@@ -109,29 +109,26 @@ private: 
    sp<os::IVold> mInterface;

};



class RealIncrementalManager : public IncrementalManagerWrapper {

class RealDataLoaderManager : public DataLoaderManagerWrapper {

public:

    RealIncrementalManager(const sp<os::incremental::IIncrementalManager> manager)

    RealDataLoaderManager(const sp<content::pm::IDataLoaderManager> manager)

          : mInterface(manager) {}

    ~RealIncrementalManager() = default;

    binder::Status prepareDataLoader(MountId mountId, const FileSystemControlParcel& control,

                                     const DataLoaderParamsParcel& params,

    ~RealDataLoaderManager() = default;

    binder::Status initializeDataLoader(MountId mountId, const DataLoaderParamsParcel& params,

                                        const FileSystemControlParcel& control,

                                        const sp<IDataLoaderStatusListener>& listener,

                                        bool* _aidl_return) const override {

        return mInterface->prepareDataLoader(mountId, control, params, listener, _aidl_return);

        return mInterface->initializeDataLoader(mountId, params, control, listener, _aidl_return);

    }

    binder::Status startDataLoader(MountId mountId, bool* _aidl_return) const override {

        return mInterface->startDataLoader(mountId, _aidl_return);

    binder::Status getDataLoader(MountId mountId, sp<IDataLoader>* _aidl_return) const override {

        return mInterface->getDataLoader(mountId, _aidl_return);

    }

    binder::Status destroyDataLoader(MountId mountId) const override {

        return mInterface->destroyDataLoader(mountId);

    }

    binder::Status showHealthBlockedUI(MountId mountId) const override {

        return mInterface->showHealthBlockedUI(mountId);

    }



private:

    sp<os::incremental::IIncrementalManager> mInterface;

    sp<content::pm::IDataLoaderManager> mInterface;

};



class RealServiceManager : public ServiceManagerWrapper {
@@ -139,7 +136,7 @@ public: 
    RealServiceManager(sp<IServiceManager> serviceManager);

    ~RealServiceManager() = default;

    std::unique_ptr<VoldServiceWrapper> getVoldService() override;

    std::unique_ptr<IncrementalManagerWrapper> getIncrementalManager() override;

    std::unique_ptr<DataLoaderManagerWrapper> getDataLoaderManager() override;

    std::unique_ptr<IncFsWrapper> getIncFs() override;



private:

services/incremental/test/IncrementalServiceTest.cpp

+68 −54
Original line number Diff line number Diff line
@@ -93,22 +93,35 @@ private: 
    TemporaryFile logFile;

};



class MockIncrementalManager : public IncrementalManagerWrapper {

class FakeDataLoader : public IDataLoader {

public:

    MOCK_CONST_METHOD5(prepareDataLoader,

                       binder::Status(int32_t mountId, const FileSystemControlParcel& control,

                                      const DataLoaderParamsParcel& params,

    IBinder* onAsBinder() override { return nullptr; }

    binder::Status create(int32_t, const DataLoaderParamsParcel&, const FileSystemControlParcel&,

                          const sp<IDataLoaderStatusListener>&) override {

        return binder::Status::ok();

    }

    binder::Status start() override { return binder::Status::ok(); }

    binder::Status stop() override { return binder::Status::ok(); }

    binder::Status destroy() override { return binder::Status::ok(); }

    binder::Status prepareImage(const std::vector<InstallationFileParcel>&,

                                const std::vector<std::string>&) override {

        return binder::Status::ok();

    }

};



class MockDataLoaderManager : public DataLoaderManagerWrapper {

public:

    MOCK_CONST_METHOD5(initializeDataLoader,

                       binder::Status(int32_t mountId, const DataLoaderParamsParcel& params,

                                      const FileSystemControlParcel& control,

                                      const sp<IDataLoaderStatusListener>& listener,

                                      bool* _aidl_return));

    MOCK_CONST_METHOD2(startDataLoader, binder::Status(int32_t mountId, bool* _aidl_return));

    MOCK_CONST_METHOD2(getDataLoader,

                       binder::Status(int32_t mountId, sp<IDataLoader>* _aidl_return));

    MOCK_CONST_METHOD1(destroyDataLoader, binder::Status(int32_t mountId));

    MOCK_CONST_METHOD3(newFileForDataLoader,

                       binder::Status(int32_t mountId, FileId fileId,

                                      const ::std::vector<uint8_t>& metadata));

    MOCK_CONST_METHOD1(showHealthBlockedUI, binder::Status(int32_t mountId));



    binder::Status prepareDataLoaderOk(int32_t mountId, const FileSystemControlParcel& control,

                                       const DataLoaderParamsParcel& params,

    binder::Status initializeDataLoaderOk(int32_t mountId, const DataLoaderParamsParcel& params,

                                          const FileSystemControlParcel& control,

                                          const sp<IDataLoaderStatusListener>& listener,

                                          bool* _aidl_return) {

        mId = mountId;
@@ -117,23 +130,23 @@ public: 
        return binder::Status::ok();

    }



    binder::Status startDataLoaderOk(int32_t mountId, bool* _aidl_return) {

        *_aidl_return = true;

    binder::Status getDataLoaderOk(int32_t mountId, sp<IDataLoader>* _aidl_return) {

        *_aidl_return = mDataLoader;

        return binder::Status::ok();

    }



    void prepareDataLoaderFails() {

        ON_CALL(*this, prepareDataLoader(_, _, _, _, _))

    void initializeDataLoaderFails() {

        ON_CALL(*this, initializeDataLoader(_, _, _, _, _))

                .WillByDefault(Return(

                        (binder::Status::fromExceptionCode(1, String8("failed to prepare")))));

    }

    void prepareDataLoaderSuccess() {

        ON_CALL(*this, prepareDataLoader(_, _, _, _, _))

                .WillByDefault(Invoke(this, &MockIncrementalManager::prepareDataLoaderOk));

    void initializeDataLoaderSuccess() {

        ON_CALL(*this, initializeDataLoader(_, _, _, _, _))

                .WillByDefault(Invoke(this, &MockDataLoaderManager::initializeDataLoaderOk));

    }

    void startDataLoaderSuccess() {

        ON_CALL(*this, startDataLoader(_, _))

                .WillByDefault(Invoke(this, &MockIncrementalManager::startDataLoaderOk));

    void getDataLoaderSuccess() {

        ON_CALL(*this, getDataLoader(_, _))

                .WillByDefault(Invoke(this, &MockDataLoaderManager::getDataLoaderOk));

    }

    void setDataLoaderStatusNotReady() {

        mListener->onStatusChanged(mId, IDataLoaderStatusListener::DATA_LOADER_DESTROYED);
@@ -145,6 +158,7 @@ public: 
private:

    int mId;

    sp<IDataLoaderStatusListener> mListener;

    sp<IDataLoader> mDataLoader = sp<IDataLoader>(new FakeDataLoader());

};



class MockIncFs : public IncFsWrapper {
@@ -197,20 +211,20 @@ public: 
class MockServiceManager : public ServiceManagerWrapper {

public:

    MockServiceManager(std::unique_ptr<MockVoldService> vold,

                       std::unique_ptr<MockIncrementalManager> manager,

                       std::unique_ptr<MockDataLoaderManager> manager,

                       std::unique_ptr<MockIncFs> incfs)

          : mVold(std::move(vold)),

            mIncrementalManager(std::move(manager)),

            mDataLoaderManager(std::move(manager)),

            mIncFs(std::move(incfs)) {}

    std::unique_ptr<VoldServiceWrapper> getVoldService() final { return std::move(mVold); }

    std::unique_ptr<IncrementalManagerWrapper> getIncrementalManager() final {

        return std::move(mIncrementalManager);

    std::unique_ptr<DataLoaderManagerWrapper> getDataLoaderManager() final {

        return std::move(mDataLoaderManager);

    }

    std::unique_ptr<IncFsWrapper> getIncFs() final { return std::move(mIncFs); }



private:

    std::unique_ptr<MockVoldService> mVold;

    std::unique_ptr<MockIncrementalManager> mIncrementalManager;

    std::unique_ptr<MockDataLoaderManager> mDataLoaderManager;

    std::unique_ptr<MockIncFs> mIncFs;

};
@@ -221,14 +235,14 @@ public: 
    void SetUp() override {

        auto vold = std::make_unique<NiceMock<MockVoldService>>();

        mVold = vold.get();

        auto incrementalManager = std::make_unique<NiceMock<MockIncrementalManager>>();

        mIncrementalManager = incrementalManager.get();

        auto dataloaderManager = std::make_unique<NiceMock<MockDataLoaderManager>>();

        mDataLoaderManager = dataloaderManager.get();

        auto incFs = std::make_unique<NiceMock<MockIncFs>>();

        mIncFs = incFs.get();

        mIncrementalService =

                std::make_unique<IncrementalService>(MockServiceManager(std::move(vold),

                                                                        std::move(

                                                                                incrementalManager),

                                                                                dataloaderManager),

                                                                        std::move(incFs)),

                                                     mRootDir.path);

        mDataLoaderParcel.packageName = "com.test";
@@ -260,7 +274,7 @@ public: 
protected:

    NiceMock<MockVoldService>* mVold;

    NiceMock<MockIncFs>* mIncFs;

    NiceMock<MockIncrementalManager>* mIncrementalManager;

    NiceMock<MockDataLoaderManager>* mDataLoaderManager;

    std::unique_ptr<IncrementalService> mIncrementalService;

    TemporaryDir mRootDir;

    DataLoaderParamsParcel mDataLoaderParcel;
@@ -268,7 +282,7 @@ protected: 


TEST_F(IncrementalServiceTest, testCreateStorageMountIncFsFails) {

    mVold->mountIncFsFails();

    EXPECT_CALL(*mIncrementalManager, prepareDataLoader(_, _, _, _, _)).Times(0);

    EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(0);

    TemporaryDir tempDir;

    int storageId =

            mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
@@ -278,7 +292,7 @@ TEST_F(IncrementalServiceTest, testCreateStorageMountIncFsFails) { 


TEST_F(IncrementalServiceTest, testCreateStorageMountIncFsInvalidControlParcel) {

    mVold->mountIncFsInvalidControlParcel();

    EXPECT_CALL(*mIncrementalManager, prepareDataLoader(_, _, _, _, _)).Times(0);

    EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(0);

    TemporaryDir tempDir;

    int storageId =

            mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
@@ -289,8 +303,8 @@ TEST_F(IncrementalServiceTest, testCreateStorageMountIncFsInvalidControlParcel) 
TEST_F(IncrementalServiceTest, testCreateStorageMakeFileFails) {

    mVold->mountIncFsSuccess();

    mIncFs->makeFileFails();

    EXPECT_CALL(*mIncrementalManager, prepareDataLoader(_, _, _, _, _)).Times(0);

    EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));

    EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(0);

    EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));

    EXPECT_CALL(*mVold, unmountIncFs(_));

    TemporaryDir tempDir;

    int storageId =
@@ -303,8 +317,8 @@ TEST_F(IncrementalServiceTest, testCreateStorageBindMountFails) { 
    mVold->mountIncFsSuccess();

    mIncFs->makeFileSuccess();

    mVold->bindMountFails();

    EXPECT_CALL(*mIncrementalManager, prepareDataLoader(_, _, _, _, _)).Times(0);

    EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));

    EXPECT_CALL(*mDataLoaderManager, initializeDataLoader(_, _, _, _, _)).Times(0);

    EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));

    EXPECT_CALL(*mVold, unmountIncFs(_));

    TemporaryDir tempDir;

    int storageId =
@@ -317,8 +331,8 @@ TEST_F(IncrementalServiceTest, testCreateStoragePrepareDataLoaderFails) { 
    mVold->mountIncFsSuccess();

    mIncFs->makeFileSuccess();

    mVold->bindMountSuccess();

    mIncrementalManager->prepareDataLoaderFails();

    EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));

    mDataLoaderManager->initializeDataLoaderFails();

    EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));

    EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);

    TemporaryDir tempDir;

    int storageId =
@@ -331,8 +345,8 @@ TEST_F(IncrementalServiceTest, testDeleteStorageSuccess) { 
    mVold->mountIncFsSuccess();

    mIncFs->makeFileSuccess();

    mVold->bindMountSuccess();

    mIncrementalManager->prepareDataLoaderSuccess();

    EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));

    mDataLoaderManager->initializeDataLoaderSuccess();

    EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));

    EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);

    TemporaryDir tempDir;

    int storageId =
@@ -346,31 +360,31 @@ TEST_F(IncrementalServiceTest, testOnStatusNotReady) { 
    mVold->mountIncFsSuccess();

    mIncFs->makeFileSuccess();

    mVold->bindMountSuccess();

    mIncrementalManager->prepareDataLoaderSuccess();

    EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));

    mDataLoaderManager->initializeDataLoaderSuccess();

    EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));

    EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);

    TemporaryDir tempDir;

    int storageId =

            mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},

                                               IncrementalService::CreateOptions::CreateNew);

    ASSERT_GE(storageId, 0);

    mIncrementalManager->setDataLoaderStatusNotReady();

    mDataLoaderManager->setDataLoaderStatusNotReady();

}



TEST_F(IncrementalServiceTest, testStartDataLoaderSuccess) {

    mVold->mountIncFsSuccess();

    mIncFs->makeFileSuccess();

    mVold->bindMountSuccess();

    mIncrementalManager->prepareDataLoaderSuccess();

    mIncrementalManager->startDataLoaderSuccess();

    EXPECT_CALL(*mIncrementalManager, destroyDataLoader(_));

    mDataLoaderManager->initializeDataLoaderSuccess();

    mDataLoaderManager->getDataLoaderSuccess();

    EXPECT_CALL(*mDataLoaderManager, destroyDataLoader(_));

    EXPECT_CALL(*mVold, unmountIncFs(_)).Times(2);

    TemporaryDir tempDir;

    int storageId =

            mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},

                                               IncrementalService::CreateOptions::CreateNew);

    ASSERT_GE(storageId, 0);

    mIncrementalManager->setDataLoaderStatusReady();

    mDataLoaderManager->setDataLoaderStatusReady();

    ASSERT_TRUE(mIncrementalService->startLoading(storageId));

}
@@ -378,8 +392,8 @@ TEST_F(IncrementalServiceTest, testMakeDirectory) { 
    mVold->mountIncFsSuccess();

    mIncFs->makeFileSuccess();

    mVold->bindMountSuccess();

    mIncrementalManager->prepareDataLoaderSuccess();

    mIncrementalManager->startDataLoaderSuccess();

    mDataLoaderManager->initializeDataLoaderSuccess();

    mDataLoaderManager->getDataLoaderSuccess();

    TemporaryDir tempDir;

    int storageId =

            mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},
@@ -402,8 +416,8 @@ TEST_F(IncrementalServiceTest, testMakeDirectories) { 
    mVold->mountIncFsSuccess();

    mIncFs->makeFileSuccess();

    mVold->bindMountSuccess();

    mIncrementalManager->prepareDataLoaderSuccess();

    mIncrementalManager->startDataLoaderSuccess();

    mDataLoaderManager->initializeDataLoaderSuccess();

    mDataLoaderManager->getDataLoaderSuccess();

    TemporaryDir tempDir;

    int storageId =

            mIncrementalService->createStorage(tempDir.path, std::move(mDataLoaderParcel), {},