// Copyright 2015 The Android Open Source Project
//
// This software is licensed under the terms of the GNU General Public
// License version 2, as published by the Free Software Foundation, and
// may be copied, distributed, and modified under those terms.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

#include "android/filesystems/partition_config.h"

#include "android/filesystems/internal/PartitionConfigBackend.h"

#include <gtest/gtest.h>

#include <errno.h>
#include <stdarg.h>
#include <stdio.h>

#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))

// A special file path used during unit-testing that corresponds to
// a non-existing file. See TestPartitionConfigBackend::pathExists() below.
#define DOESNT_EXIST_PREFIX "/DOES_NOT_EXISTS"

// A special file path to indicate a bad ramdisk.img path.
// Using this with extractRamdiskFile() below will return false.
static const char kBadRamdiskFile[] = "/BAD_RAMDISK.IMG";

// A special file path to indicate a ramdisk.img that contains an fstab
// file that will
static const char kYaffsFstabFile[] = "fstab.yaffs2";

// Fake fstab content corresponding to yaffs2 partitions.
static const char kYaffsFstabContent[] = "yaffs2";

// A special file path prefix that cannot be locked.
// This is a macro to use string concatenation at compile time,
// e.g. CANNOT_LOCK_PREFIX "2"
#define CANNOT_LOCK_PREFIX "/CANNOT_LOCK_FILE"

#define CANNOT_COPY_PREFIX "/CANNOT_COPY"

// A special file path prefix corresponding to an YAFFS2 partition.
#define YAFFS_PATH_PREFIX "/YAFFS_FILE"

static bool strStartsWith(const char* path, const char* prefix) {
    return !strncmp(path, prefix, strlen(prefix));
}

// Base unittest version of PartitionConfigBackend interface.
// All methods return success, and ext4 as the default partition type.
class TestPartitionConfigBackend
        : public android::internal::PartitionConfigBackend {
public:
    TestPartitionConfigBackend()
        : mPrevBackend(nullptr), mCommands(), mTempCounter(0) {
        // Save previous backend then inject self into the process.
        mPrevBackend = PartitionConfigBackend::setForTesting(this);
    }

    virtual ~TestPartitionConfigBackend() {
        // Restore previous backend.
        PartitionConfigBackend::setForTesting(mPrevBackend);
    }

    virtual bool pathExists(const char* path) override {
        if (strStartsWith(path, DOESNT_EXIST_PREFIX)) {
            return false;
        }
        return true;
    }

    virtual bool pathEmptyFile(const char* path) override {
        addCommand("EMPTY [%s]", path);
        return true;
    }

    virtual bool pathCopyFile(const char* dst, const char* src) override {
        if (strStartsWith(src, CANNOT_COPY_PREFIX)) {
            return false;
        }
        addCommand("COPY [%s] <- [%s]", dst, src);
        return true;
    }

    virtual bool pathLockFile(const char* path) override {
        if (strStartsWith(path, CANNOT_LOCK_PREFIX)) {
            errno = EINVAL;
            return false;
        }
        addCommand("LOCK [%s]", path);
        return true;
    }

    virtual bool pathCreateTempFile(std::string* path) override {
        char tmp[200];
        snprintf(tmp, sizeof(tmp), "/tmp/tempfile%d", ++mTempCounter);
        *path = tmp;
        addCommand("TEMPFILE [%s]", tmp);
        return true;
    }

    virtual AndroidPartitionType probePartitionFileType(
            const char* path) override {
        if (strStartsWith(path, YAFFS_PATH_PREFIX)) {
            return ANDROID_PARTITION_TYPE_YAFFS2;
        }
        return ANDROID_PARTITION_TYPE_EXT4;
    }

    virtual bool extractRamdiskFile(const char* ramdisk_path,
                                    const char* file_path,
                                    std::string* out) override {
        if (!strcmp(ramdisk_path, kBadRamdiskFile)) {
            return false;
        }
        if (!strcmp(file_path, kYaffsFstabFile)) {
            *out = kYaffsFstabContent;
            return true;
        }
        *out = "";
        return true;
    }

    virtual bool parsePartitionFormat(const std::string& fstab,
                                      const char* mountPath,
                                      std::string* partitionFormat) override {
        if (fstab == kYaffsFstabContent) {
            *partitionFormat = "yaffs2";
        } else {
            *partitionFormat = "ext4";
        }
        return true;
    }

    virtual bool makeEmptyPartition(AndroidPartitionType partitionType,
                                    uint64_t partitionSize,
                                    const char* partitionPath) override {
        addCommand("EMPTY_PARTITION format=%s size=%lld [%s]",
                   androidPartitionType_toString(partitionType),
                   static_cast<unsigned long long>(partitionSize),
                   partitionPath);
        return true;
    }

    // Resize an existing ext4 partition at |partitionPath| to a new
    // size in bytes given by |partitionSize|.
    virtual void resizeExt4Partition(const char* partitionPath,
                                     uint64_t partitionSize) override {
        addCommand("EXT4_RESIZE size=%lld [%s]",
                   static_cast<unsigned long long>(partitionSize),
                   partitionPath);
    }

    const std::string& commands() const { return mCommands; }

private:
    void addCommand(const char* fmt, ...) {
        char* str = NULL;
        va_list args;
        va_start(args, fmt);
        vasprintf(&str, fmt, args);
        va_end(args);
        mCommands += str;
        mCommands += "\n";
        free(str);
    }

    PartitionConfigBackend* mPrevBackend;
    std::string mCommands;
    int mTempCounter;
};

// A helper class used to collect the virtual NAND partition setup
// that is performed by android_partition_configuration_setup().
// Create a new instance, and use its |setupPartition| method address
// as the |setup_func| parameter, and |this| as |setup_opaque|.
class PartitionCollector {
public:
    // Virtual partition information after setup.
    struct Partition {
        std::string name;
        uint64_t size;
        std::string path;
        AndroidPartitionType format;
        bool readonly;
    };

    // All virtual partitions, as a simple public vector.
    std::vector<Partition> partitions;

    // A callback used as a |setup_func| parameter when calling
    // android_partition_configuration_setup(). Use the instance's |this|
    // value as |setup_opaque|.
    static void setupPartition(void* opaque,
                               const char* name,
                               uint64_t size,
                               const char* path,
                               AndroidPartitionType format,
                               bool readonly) {
        auto collector = static_cast<PartitionCollector*>(opaque);

        Partition part;
        part.name = name;
        part.size = size;
        part.path = path;
        part.format = format;
        part.readonly = readonly;

        collector->partitions.push_back(part);
    }
};

// Save a lot of typing.
typedef PartitionCollector::Partition Partition;

// Helper function to check the results of a given partition configuration.
// |config| is the input AndroidPartitionConfiguration instance.
// |expectedCommands| is the expected commands string.
// |expectedPartitions| is an array of expected Partition descriptors.
// |expectedPartitionsCount| is the number of items in the array.
static void checkConfig(const AndroidPartitionConfiguration* config,
                        const char* expectedCommands,
                        const Partition* expectedPartitions,
                        size_t expectedPartitionsCount) {
    TestPartitionConfigBackend testBackend;
    PartitionCollector collector;

    char* error_message = NULL;
    EXPECT_TRUE(android_partition_configuration_setup(
            config, PartitionCollector::setupPartition, &collector,
            &error_message));

    if (error_message) {
        EXPECT_STREQ("", error_message);
    } else {
        std::vector<Partition>& partitions = collector.partitions;

        EXPECT_EQ(expectedPartitionsCount, partitions.size());

        for (size_t n = 0; n < expectedPartitionsCount; ++n) {
            const Partition& expected = expectedPartitions[n];

            EXPECT_EQ(expected.name, partitions[n].name);
            EXPECT_EQ(expected.size, partitions[n].size);
            EXPECT_EQ(expected.path, partitions[n].path) << "#" << n;
            EXPECT_EQ(expected.format, partitions[n].format);
            EXPECT_EQ(expected.readonly, partitions[n].readonly);
        }
    }

    EXPECT_STREQ(expectedCommands, testBackend.commands().c_str());
}

static void checkErrorConfig(const AndroidPartitionConfiguration* config,
                             const char* expectedCommands,
                             const char* expectedError) {
    TestPartitionConfigBackend testBackend;
    PartitionCollector collector;

    char* error_message = NULL;
    EXPECT_FALSE(android_partition_configuration_setup(
            config, PartitionCollector::setupPartition, &collector,
            &error_message));
    if (!error_message) {
        EXPECT_TRUE(error_message);
    } else {
        EXPECT_STREQ(expectedError, error_message);
        free(error_message);
    }

    EXPECT_STREQ(expectedCommands, testBackend.commands().c_str());
}

TEST(PartitionConfig, normalSetup) {
    static const AndroidPartitionConfiguration config = {
            .ramdisk_path = "/foo/ramdisk.img",
            .fstab_name = "fstab.unittest",
            .system_partition =
                    {
                            .size = 123456ULL,
                            .path = nullptr,
                            .init_path = "/images/system.img",
                    },
            .data_partition =
                    {
                            .size = 400000ULL,
                            .path = "/avd/userdata-qemu.img",
                            .init_path = nullptr,
                    },
            .cache_partition =
                    {
                            .size = 100000ULL,
                            .path = "/avd/cache.img",
                            .init_path = nullptr,
                    },
            .kernel_supports_yaffs2 = false,
            .wipe_data = false,
            .writable_system = false,
    };

    static const char kExpectedCommands[] =
            "LOCK [/avd/userdata-qemu.img]\n"
            "LOCK [/avd/cache.img]\n";

    static const PartitionCollector::Partition kExpectedPartitions[] = {
            {"system", 123456ULL, "/images/system.img",
             ANDROID_PARTITION_TYPE_EXT4, true},
            {"userdata", 400000ULL, "/avd/userdata-qemu.img",
             ANDROID_PARTITION_TYPE_EXT4, false},
            {"cache", 100000ULL, "/avd/cache.img", ANDROID_PARTITION_TYPE_EXT4,
             false},
    };

    const size_t kExpectedPartitionsSize = ARRAY_SIZE(kExpectedPartitions);

    checkConfig(&config, kExpectedCommands, kExpectedPartitions,
                kExpectedPartitionsSize);
}

TEST(PartitionConfig, wipeData) {
    AndroidPartitionConfiguration config = {
            .ramdisk_path = "/foo/ramdisk.img",
            .fstab_name = "fstab.unittest",
            .system_partition =
                    {
                            .size = 123456ULL,
                            .path = "/avd/system.img",
                            .init_path = nullptr,
                    },
            .data_partition =
                    {
                            .size = 400000ULL,
                            .path = "/avd/userdata-qemu.img",
                            .init_path = "/images/userdata.img",
                    },
            .cache_partition =
                    {
                            .size = 100000ULL,
                            .path = "/avd/cache.img",
                            .init_path = nullptr,
                    },
            .kernel_supports_yaffs2 = false,
            .wipe_data = true,
            .writable_system = false,
    };

    static const char kExpectedCommands[] =
            "LOCK [/avd/userdata-qemu.img]\n"
            "COPY [/avd/userdata-qemu.img] <- [/images/userdata.img]\n"
            "EXT4_RESIZE size=400000 [/avd/userdata-qemu.img]\n"
            "LOCK [/avd/cache.img]\n"
            "EMPTY_PARTITION format=ext4 size=100000 [/avd/cache.img]\n";

    static const Partition kExpectedPartitions[3] = {
            {"system", 123456ULL, "/avd/system.img",
             ANDROID_PARTITION_TYPE_EXT4, true},
            {"userdata", 400000ULL, "/avd/userdata-qemu.img",
             ANDROID_PARTITION_TYPE_EXT4, false},
            {"cache", 100000ULL, "/avd/cache.img", ANDROID_PARTITION_TYPE_EXT4,
             false},
    };

    const size_t kExpectedPartitionsSize = ARRAY_SIZE(kExpectedPartitions);

    checkConfig(&config, kExpectedCommands, kExpectedPartitions,
                kExpectedPartitionsSize);
}

TEST(PartitionConfig, writableSystem) {
    AndroidPartitionConfiguration config = {
            .ramdisk_path = "/foo/ramdisk.img",
            .fstab_name = "fstab.unittest",
            .system_partition =
                    {
                            .size = 123456ULL,
                            .path = nullptr,
                            .init_path = "/images/system.img",
                    },
            .data_partition =
                    {
                            .size = 400000ULL,
                            .path = "/avd/userdata-qemu.img",
                            .init_path = nullptr,
                    },
            .cache_partition =
                    {
                            .size = 100000ULL,
                            .path = "/avd/cache.img",
                            .init_path = nullptr,
                    },
            .kernel_supports_yaffs2 = false,
            .wipe_data = false,
            .writable_system = true,
    };

    static const char kExpectedCommands[] =
            "TEMPFILE [/tmp/tempfile1]\n"
            "COPY [/tmp/tempfile1] <- [/images/system.img]\n"
            "LOCK [/avd/userdata-qemu.img]\n"
            "LOCK [/avd/cache.img]\n";

    static const Partition kExpectedPartitions[3] = {
            {"system", 123456ULL, "/tmp/tempfile1", ANDROID_PARTITION_TYPE_EXT4,
             false},
            {"userdata", 400000ULL, "/avd/userdata-qemu.img",
             ANDROID_PARTITION_TYPE_EXT4, false},
            {"cache", 100000ULL, "/avd/cache.img", ANDROID_PARTITION_TYPE_EXT4,
             false},
    };

    const size_t kExpectedPartitionsSize = ARRAY_SIZE(kExpectedPartitions);

    checkConfig(&config, kExpectedCommands, kExpectedPartitions,
                kExpectedPartitionsSize);
}

TEST(PartitionConfig, persistentWritableSystem) {
    AndroidPartitionConfiguration config = {
            .ramdisk_path = "/foo/ramdisk.img",
            .fstab_name = "fstab.unittest",
            .system_partition =
                    {
                            .size = 123456ULL,
                            .path = "/avd/system.img",
                            .init_path = nullptr,
                    },
            .data_partition =
                    {
                            .size = 400000ULL,
                            .path = "/avd/userdata-qemu.img",
                            .init_path = "/images/userdata.img",
                    },
            .cache_partition =
                    {
                            .size = 100000ULL,
                            .path = "/avd/cache.img",
                            .init_path = nullptr,
                    },
            .kernel_supports_yaffs2 = false,
            .wipe_data = true,
            .writable_system = true,
    };

    static const char kExpectedCommands[] =
            "LOCK [/avd/system.img]\n"
            "LOCK [/avd/userdata-qemu.img]\n"
            "COPY [/avd/userdata-qemu.img] <- [/images/userdata.img]\n"
            "EXT4_RESIZE size=400000 [/avd/userdata-qemu.img]\n"
            "LOCK [/avd/cache.img]\n"
            "EMPTY_PARTITION format=ext4 size=100000 [/avd/cache.img]\n";

    static const Partition kExpectedPartitions[3] = {
            {"system", 123456ULL, "/avd/system.img",
             ANDROID_PARTITION_TYPE_EXT4, false},
            {"userdata", 400000ULL, "/avd/userdata-qemu.img",
             ANDROID_PARTITION_TYPE_EXT4, false},
            {"cache", 100000ULL, "/avd/cache.img", ANDROID_PARTITION_TYPE_EXT4,
             false},
    };

    const size_t kExpectedPartitionsSize = ARRAY_SIZE(kExpectedPartitions);

    checkConfig(&config, kExpectedCommands, kExpectedPartitions,
                kExpectedPartitionsSize);
}

TEST(PartitionConfig, persistentWritableSystemWithWipeData) {
    AndroidPartitionConfiguration config = {
            .ramdisk_path = "/foo/ramdisk.img",
            .fstab_name = "fstab.unittest",
            .system_partition =
                    {
                            .size = 123456ULL,
                            .path = "/avd/system.img",
                            .init_path = "/images/system.img",
                    },
            .data_partition =
                    {
                            .size = 400000ULL,
                            .path = "/avd/userdata-qemu.img",
                            .init_path = "/images/userdata.img",
                    },
            .cache_partition =
                    {
                            .size = 100000ULL,
                            .path = "/avd/cache.img",
                            .init_path = nullptr,
                    },
            .kernel_supports_yaffs2 = false,
            .wipe_data = true,
            .writable_system = true,
    };

    static const char kExpectedCommands[] =
            "LOCK [/avd/system.img]\n"
            "COPY [/avd/system.img] <- [/images/system.img]\n"
            "LOCK [/avd/userdata-qemu.img]\n"
            "COPY [/avd/userdata-qemu.img] <- [/images/userdata.img]\n"
            "EXT4_RESIZE size=400000 [/avd/userdata-qemu.img]\n"
            "LOCK [/avd/cache.img]\n"
            "EMPTY_PARTITION format=ext4 size=100000 [/avd/cache.img]\n";

    static const Partition kExpectedPartitions[3] = {
            {"system", 123456ULL, "/avd/system.img",
             ANDROID_PARTITION_TYPE_EXT4, false},
            {"userdata", 400000ULL, "/avd/userdata-qemu.img",
             ANDROID_PARTITION_TYPE_EXT4, false},
            {"cache", 100000ULL, "/avd/cache.img", ANDROID_PARTITION_TYPE_EXT4,
             false},
    };

    const size_t kExpectedPartitionsSize = ARRAY_SIZE(kExpectedPartitions);

    checkConfig(&config, kExpectedCommands, kExpectedPartitions,
                kExpectedPartitionsSize);
}

TEST(PartitionConfig, LockedFiles) {
    static const char kLockedDataFile[] = CANNOT_LOCK_PREFIX "_data";
    static const char kLockedSystemFile[] = CANNOT_LOCK_PREFIX "_system";
    static const char kLockedCacheFile[] = CANNOT_LOCK_PREFIX "_cache";

    AndroidPartitionConfiguration config = {
            .ramdisk_path = "/foo/ramdisk.img",
            .fstab_name = "fstab.unittest",
            .system_partition =
                    {
                            .size = 123456ULL,
                            .path = kLockedSystemFile,
                            .init_path = "/images/system.img",
                    },
            .data_partition =
                    {
                            .size = 400000ULL,
                            .path = kLockedDataFile,
                            .init_path = nullptr,
                    },
            .cache_partition =
                    {
                            .size = 100000ULL,
                            .path = kLockedCacheFile,
                            .init_path = nullptr,
                    },
            .kernel_supports_yaffs2 = false,
            .wipe_data = false,
    };

    static const char kExpectedCommands[] =
            "TEMPFILE [/tmp/tempfile1]\n"
            "EMPTY_PARTITION format=ext4 size=400000 [/tmp/tempfile1]\n"
            "TEMPFILE [/tmp/tempfile2]\n"
            "EMPTY_PARTITION format=ext4 size=100000 [/tmp/tempfile2]\n";

    static const Partition kExpectedPartitions[3] = {
            {"system", 123456ULL, kLockedSystemFile,
             ANDROID_PARTITION_TYPE_EXT4, true},
            {"userdata", 400000ULL, "/tmp/tempfile1",
             ANDROID_PARTITION_TYPE_EXT4, false},
            {"cache", 100000ULL, "/tmp/tempfile2", ANDROID_PARTITION_TYPE_EXT4,
             false},
    };

    const size_t kExpectedPartitionsSize = ARRAY_SIZE(kExpectedPartitions);

    checkConfig(&config, kExpectedCommands, kExpectedPartitions,
                kExpectedPartitionsSize);
}

TEST(PartitionConfig, MissingDataPartition) {
    static const char kMissingDataFile[] = DOESNT_EXIST_PREFIX "_data";

    static const AndroidPartitionConfiguration config = {
            .ramdisk_path = "/foo/ramdisk.img",
            .fstab_name = "fstab.unittest",
            .system_partition =
                    {
                            .size = 123456ULL,
                            .path = nullptr,
                            .init_path = "/images/system.img",
                    },
            .data_partition =
                    {
                            .size = 400000ULL,
                            .path = kMissingDataFile,
                            .init_path = nullptr,
                    },
            .cache_partition =
                    {
                            .size = 100000ULL,
                            .path = "/avd/cache.img",
                            .init_path = nullptr,
                    },
            .kernel_supports_yaffs2 = false,
            .wipe_data = false,
            .writable_system = false,
    };

    static const char kExpectedCommands[] =
            "LOCK [/DOES_NOT_EXISTS_data]\n"
            "EMPTY [/DOES_NOT_EXISTS_data]\n"
            "EMPTY_PARTITION format=ext4 size=400000 [/DOES_NOT_EXISTS_data]\n"
            "LOCK [/avd/cache.img]\n";

    static const Partition kExpectedPartitions[3] = {
            {"system", 123456ULL, "/images/system.img",
             ANDROID_PARTITION_TYPE_EXT4, true},
            {"userdata", 400000ULL, kMissingDataFile,
             ANDROID_PARTITION_TYPE_EXT4, false},
            {"cache", 100000ULL, "/avd/cache.img", ANDROID_PARTITION_TYPE_EXT4,
             false},
    };

    const size_t kExpectedPartitionsSize = ARRAY_SIZE(kExpectedPartitions);

    checkConfig(&config, kExpectedCommands, kExpectedPartitions,
                kExpectedPartitionsSize);
}

TEST(PartitionConfig, MissingSystemPartition) {
    static const char kMissingSystemFile[] = DOESNT_EXIST_PREFIX "_system";

    static const AndroidPartitionConfiguration config = {
            .ramdisk_path = "/foo/ramdisk.img",
            .fstab_name = "fstab.unittest",
            .system_partition =
                    {
                            .size = 123456ULL,
                            .path = kMissingSystemFile,
                            .init_path = nullptr,
                    },
            .data_partition =
                    {
                            .size = 400000ULL,
                            .path = "/avd/userdata-qemu.img",
                            .init_path = nullptr,
                    },
            .cache_partition =
                    {
                            .size = 100000ULL,
                            .path = "/avd/cache.img",
                            .init_path = nullptr,
                    },
            .kernel_supports_yaffs2 = false,
            .wipe_data = false,
            .writable_system = false,
    };

    static const char kExpectedCommands[] = "";

    static const char kExpectedError[] =
            "Missing read-only system partition image: /DOES_NOT_EXISTS_system";

    checkErrorConfig(&config, kExpectedCommands, kExpectedError);
}

TEST(PartitionConfig, MissingCacheFile) {
    static const char kMissingCacheFile[] = DOESNT_EXIST_PREFIX "_cache";

    static const AndroidPartitionConfiguration config = {
            .ramdisk_path = "/foo/ramdisk.img",
            .fstab_name = "fstab.unittest",
            .system_partition =
                    {
                            .size = 123456ULL,
                            .path = nullptr,
                            .init_path = "/images/system.img",
                    },
            .data_partition =
                    {
                            .size = 400000ULL,
                            .path = "/avd/userdata-qemu.img",
                            .init_path = nullptr,
                    },
            .cache_partition =
                    {
                            .size = 100000ULL,
                            .path = kMissingCacheFile,
                            .init_path = nullptr,
                    },
            .kernel_supports_yaffs2 = false,
            .wipe_data = false,
            .writable_system = false,
    };

    static const char kExpectedCommands[] =
            "LOCK [/avd/userdata-qemu.img]\n"
            "LOCK [/DOES_NOT_EXISTS_cache]\n"
            "EMPTY [/DOES_NOT_EXISTS_cache]\n"
            "EMPTY_PARTITION format=ext4 size=100000 "
            "[/DOES_NOT_EXISTS_cache]\n";

    static const Partition kExpectedPartitions[3] = {
            {"system", 123456ULL, "/images/system.img",
             ANDROID_PARTITION_TYPE_EXT4, true},
            {"userdata", 400000ULL, "/avd/userdata-qemu.img",
             ANDROID_PARTITION_TYPE_EXT4, false},
            {"cache", 100000ULL, kMissingCacheFile, ANDROID_PARTITION_TYPE_EXT4,
             false},
    };

    const size_t kExpectedPartitionsSize = ARRAY_SIZE(kExpectedPartitions);

    checkConfig(&config, kExpectedCommands, kExpectedPartitions,
                kExpectedPartitionsSize);
}

TEST(PartitionConfig, Yaffs2Partitions) {
    static const char kYaffsSystemImage[] = YAFFS_PATH_PREFIX "_system";
    static const char kYaffsDataImage[] = YAFFS_PATH_PREFIX "_data";

    static const AndroidPartitionConfiguration config = {
            .ramdisk_path = "/foo/ramdisk.img",
            .fstab_name = kYaffsFstabFile,
            .system_partition =
                    {
                            .size = 123456ULL,
                            .path = kYaffsSystemImage,
                            .init_path = nullptr,
                    },
            .data_partition =
                    {
                            .size = 400000ULL,
                            .path = kYaffsDataImage,
                            .init_path = nullptr,
                    },
            .cache_partition =
                    {
                            .size = 100000ULL,
                            .path = "/avd/cache.img",
                            .init_path = nullptr,
                    },
            .kernel_supports_yaffs2 = true,
            .wipe_data = false,
            .writable_system = false,
    };

    static const char kExpectedCommands[] =
            "LOCK [/YAFFS_FILE_data]\n"
            "LOCK [/avd/cache.img]\n"
            "EMPTY_PARTITION format=yaffs2 size=100000 [/avd/cache.img]\n";

    static const PartitionCollector::Partition kExpectedPartitions[] = {
            {"system", 123456ULL, kYaffsSystemImage,
             ANDROID_PARTITION_TYPE_YAFFS2, true},
            {"userdata", 400000ULL, kYaffsDataImage,
             ANDROID_PARTITION_TYPE_YAFFS2, false},
            {"cache", 100000ULL, "/avd/cache.img",
             ANDROID_PARTITION_TYPE_YAFFS2, false},
    };

    const size_t kExpectedPartitionsSize = ARRAY_SIZE(kExpectedPartitions);

    checkConfig(&config, kExpectedCommands, kExpectedPartitions,
                kExpectedPartitionsSize);
}