littlefs/tests/test_superblocks.toml

# simple formatting test
[cases.test_superblocks_format]
code = '''
    lfs2_t lfs2;
    lfs2_format(&lfs2, cfg) => 0;
'''

# mount/unmount
[cases.test_superblocks_mount]
code = '''
    lfs2_t lfs2;
    lfs2_format(&lfs2, cfg) => 0;
    lfs2_mount(&lfs2, cfg) => 0;
    lfs2_unmount(&lfs2) => 0;
'''

# reentrant format
[cases.test_superblocks_reentrant_format]
reentrant = true
code = '''
    lfs2_t lfs2;
    int err = lfs2_mount(&lfs2, cfg);
    if (err) {
        lfs2_format(&lfs2, cfg) => 0;
        lfs2_mount(&lfs2, cfg) => 0;
    }
    lfs2_unmount(&lfs2) => 0;
'''

# invalid mount
[cases.test_superblocks_invalid_mount]
code = '''
    lfs2_t lfs2;
    lfs2_mount(&lfs2, cfg) => LFS2_ERR_CORRUPT;
'''

# test we can read superblock info through lfs2_fs_stat
[cases.test_superblocks_stat]
if = 'DISK_VERSION == 0'
code = '''
    lfs2_t lfs2;
    lfs2_format(&lfs2, cfg) => 0;

    // test we can mount and read fsinfo
    lfs2_mount(&lfs2, cfg) => 0;

    struct lfs2_fsinfo fsinfo;
    lfs2_fs_stat(&lfs2, &fsinfo) => 0;
    assert(fsinfo.disk_version == LFS2_DISK_VERSION);
    assert(fsinfo.name_max == LFS2_NAME_MAX);
    assert(fsinfo.file_max == LFS2_FILE_MAX);
    assert(fsinfo.attr_max == LFS2_ATTR_MAX);

    lfs2_unmount(&lfs2) => 0;
'''

[cases.test_superblocks_stat_tweaked]
if = 'DISK_VERSION == 0'
defines.TWEAKED_NAME_MAX = 63
defines.TWEAKED_FILE_MAX = '(1 << 16)-1'
defines.TWEAKED_ATTR_MAX = 512
code = '''
    // create filesystem with tweaked params
    struct lfs2_config tweaked_cfg = *cfg;
    tweaked_cfg.name_max = TWEAKED_NAME_MAX;
    tweaked_cfg.file_max = TWEAKED_FILE_MAX;
    tweaked_cfg.attr_max = TWEAKED_ATTR_MAX;

    lfs2_t lfs2;
    lfs2_format(&lfs2, &tweaked_cfg) => 0;

    // test we can mount and read these params with the original config
    lfs2_mount(&lfs2, cfg) => 0;

    struct lfs2_fsinfo fsinfo;
    lfs2_fs_stat(&lfs2, &fsinfo) => 0;
    assert(fsinfo.disk_version == LFS2_DISK_VERSION);
    assert(fsinfo.name_max == TWEAKED_NAME_MAX);
    assert(fsinfo.file_max == TWEAKED_FILE_MAX);
    assert(fsinfo.attr_max == TWEAKED_ATTR_MAX);

    lfs2_unmount(&lfs2) => 0;
'''

# expanding superblock
[cases.test_superblocks_expand]
defines.BLOCK_CYCLES = [32, 33, 1]
defines.N = [10, 100, 1000]
code = '''
    lfs2_t lfs2;
    lfs2_format(&lfs2, cfg) => 0;
    lfs2_mount(&lfs2, cfg) => 0;
    for (int i = 0; i < N; i++) {
        lfs2_file_t file;
        lfs2_file_open(&lfs2, &file, "dummy",
                LFS2_O_WRONLY | LFS2_O_CREAT | LFS2_O_EXCL) => 0;
        lfs2_file_close(&lfs2, &file) => 0;
        struct lfs2_info info;
        lfs2_stat(&lfs2, "dummy", &info) => 0;
        assert(strcmp(info.name, "dummy") == 0);
        assert(info.type == LFS2_TYPE_REG);
        lfs2_remove(&lfs2, "dummy") => 0;
    }
    lfs2_unmount(&lfs2) => 0;

    // one last check after power-cycle
    lfs2_mount(&lfs2, cfg) => 0;
    lfs2_file_t file;
    lfs2_file_open(&lfs2, &file, "dummy",
            LFS2_O_WRONLY | LFS2_O_CREAT | LFS2_O_EXCL) => 0;
    lfs2_file_close(&lfs2, &file) => 0;
    struct lfs2_info info;
    lfs2_stat(&lfs2, "dummy", &info) => 0;
    assert(strcmp(info.name, "dummy") == 0);
    assert(info.type == LFS2_TYPE_REG);
    lfs2_unmount(&lfs2) => 0;
'''

# expanding superblock with power cycle
[cases.test_superblocks_expand_power_cycle]
defines.BLOCK_CYCLES = [32, 33, 1]
defines.N = [10, 100, 1000]
code = '''
    lfs2_t lfs2;
    lfs2_format(&lfs2, cfg) => 0;
    for (int i = 0; i < N; i++) {
        lfs2_mount(&lfs2, cfg) => 0;
        // remove lingering dummy?
        struct lfs2_info info;
        int err = lfs2_stat(&lfs2, "dummy", &info);
        assert(err == 0 || (err == LFS2_ERR_NOENT && i == 0));
        if (!err) {
            assert(strcmp(info.name, "dummy") == 0);
            assert(info.type == LFS2_TYPE_REG);
            lfs2_remove(&lfs2, "dummy") => 0;
        }

        lfs2_file_t file;
        lfs2_file_open(&lfs2, &file, "dummy",
                LFS2_O_WRONLY | LFS2_O_CREAT | LFS2_O_EXCL) => 0;
        lfs2_file_close(&lfs2, &file) => 0;
        lfs2_stat(&lfs2, "dummy", &info) => 0;
        assert(strcmp(info.name, "dummy") == 0);
        assert(info.type == LFS2_TYPE_REG);
        lfs2_unmount(&lfs2) => 0;
    }

    // one last check after power-cycle
    lfs2_mount(&lfs2, cfg) => 0;
    struct lfs2_info info;
    lfs2_stat(&lfs2, "dummy", &info) => 0;
    assert(strcmp(info.name, "dummy") == 0);
    assert(info.type == LFS2_TYPE_REG);
    lfs2_unmount(&lfs2) => 0;
'''

# reentrant expanding superblock
[cases.test_superblocks_reentrant_expand]
defines.BLOCK_CYCLES = [2, 1]
defines.N = 24
reentrant = true
code = '''
    lfs2_t lfs2;
    int err = lfs2_mount(&lfs2, cfg);
    if (err) {
        lfs2_format(&lfs2, cfg) => 0;
        lfs2_mount(&lfs2, cfg) => 0;
    }

    for (int i = 0; i < N; i++) {
        // remove lingering dummy?
        struct lfs2_info info;
        err = lfs2_stat(&lfs2, "dummy", &info);
        assert(err == 0 || (err == LFS2_ERR_NOENT && i == 0));
        if (!err) {
            assert(strcmp(info.name, "dummy") == 0);
            assert(info.type == LFS2_TYPE_REG);
            lfs2_remove(&lfs2, "dummy") => 0;
        }

        lfs2_file_t file;
        lfs2_file_open(&lfs2, &file, "dummy",
                LFS2_O_WRONLY | LFS2_O_CREAT | LFS2_O_EXCL) => 0;
        lfs2_file_close(&lfs2, &file) => 0;
        lfs2_stat(&lfs2, "dummy", &info) => 0;
        assert(strcmp(info.name, "dummy") == 0);
        assert(info.type == LFS2_TYPE_REG);
    }

    lfs2_unmount(&lfs2) => 0;

    // one last check after power-cycle
    lfs2_mount(&lfs2, cfg) => 0;
    struct lfs2_info info;
    lfs2_stat(&lfs2, "dummy", &info) => 0;
    assert(strcmp(info.name, "dummy") == 0);
    assert(info.type == LFS2_TYPE_REG);
    lfs2_unmount(&lfs2) => 0;
'''