## specific corner cases worth explicitly testing for
#[cases.test_relocations_dangling_split_dir]
#defines.ITERATIONS = 20
#defines.COUNT = 10
#defines.BLOCK_CYCLES = [8, 1]
#code = '''
#    lfs_t lfs;
#    lfs_format(&lfs, cfg) => 0;
#    // fill up filesystem so only ~16 blocks are left
#    lfs_mount(&lfs, cfg) => 0;
#    lfs_file_t file;
#    lfs_file_open(&lfs, &file, "padding", LFS_O_CREAT | LFS_O_WRONLY) => 0;
#    uint8_t buffer[512];
#    memset(buffer, 0, 512);
#    while (BLOCK_COUNT - lfs_fs_size(&lfs) > 16) {
#        lfs_file_write(&lfs, &file, buffer, 512) => 512;
#    }
#    lfs_file_close(&lfs, &file) => 0;
#    // make a child dir to use in bounded space
#    lfs_mkdir(&lfs, "child") => 0;
#    lfs_unmount(&lfs) => 0;
#
#    lfs_mount(&lfs, cfg) => 0;
#    for (unsigned j = 0; j < ITERATIONS; j++) {
#        for (unsigned i = 0; i < COUNT; i++) {
#            char path[1024];
#            sprintf(path, "child/test%03d_loooooooooooooooooong_name", i);
#            lfs_file_open(&lfs, &file, path, LFS_O_CREAT | LFS_O_WRONLY) => 0;
#            lfs_file_close(&lfs, &file) => 0;
#        }
#
#        lfs_dir_t dir;
#        struct lfs_info info;
#        lfs_dir_open(&lfs, &dir, "child") => 0;
#        lfs_dir_read(&lfs, &dir, &info) => 1;
#        lfs_dir_read(&lfs, &dir, &info) => 1;
#        for (unsigned i = 0; i < COUNT; i++) {
#            char path[1024];
#            sprintf(path, "test%03d_loooooooooooooooooong_name", i);
#            lfs_dir_read(&lfs, &dir, &info) => 1;
#            strcmp(info.name, path) => 0;
#        }
#        lfs_dir_read(&lfs, &dir, &info) => 0;
#        lfs_dir_close(&lfs, &dir) => 0;
#
#        if (j == (unsigned)ITERATIONS-1) {
#            break;
#        }
#
#        for (unsigned i = 0; i < COUNT; i++) {
#            char path[1024];
#            sprintf(path, "child/test%03d_loooooooooooooooooong_name", i);
#            lfs_remove(&lfs, path) => 0;
#        }
#    }
#    lfs_unmount(&lfs) => 0;
#
#    lfs_mount(&lfs, cfg) => 0;
#    lfs_dir_t dir;
#    struct lfs_info info;
#    lfs_dir_open(&lfs, &dir, "child") => 0;
#    lfs_dir_read(&lfs, &dir, &info) => 1;
#    lfs_dir_read(&lfs, &dir, &info) => 1;
#    for (unsigned i = 0; i < COUNT; i++) {
#        char path[1024];
#        sprintf(path, "test%03d_loooooooooooooooooong_name", i);
#        lfs_dir_read(&lfs, &dir, &info) => 1;
#        strcmp(info.name, path) => 0;
#    }
#    lfs_dir_read(&lfs, &dir, &info) => 0;
#    lfs_dir_close(&lfs, &dir) => 0;
#    for (unsigned i = 0; i < COUNT; i++) {
#        char path[1024];
#        sprintf(path, "child/test%03d_loooooooooooooooooong_name", i);
#        lfs_remove(&lfs, path) => 0;
#    }
#    lfs_unmount(&lfs) => 0;
#'''
#
#[cases.test_relocations_outdated_head]
#defines.ITERATIONS = 20
#defines.COUNT = 10
#defines.BLOCK_CYCLES = [8, 1]
#code = '''
#    lfs_t lfs;
#    lfs_format(&lfs, cfg) => 0;
#    // fill up filesystem so only ~16 blocks are left
#    lfs_mount(&lfs, cfg) => 0;
#    lfs_file_t file;
#    lfs_file_open(&lfs, &file, "padding", LFS_O_CREAT | LFS_O_WRONLY) => 0;
#    uint8_t buffer[512];
#    memset(buffer, 0, 512);
#    while (BLOCK_COUNT - lfs_fs_size(&lfs) > 16) {
#        lfs_file_write(&lfs, &file, buffer, 512) => 512;
#    }
#    lfs_file_close(&lfs, &file) => 0;
#    // make a child dir to use in bounded space
#    lfs_mkdir(&lfs, "child") => 0;
#    lfs_unmount(&lfs) => 0;
#
#    lfs_mount(&lfs, cfg) => 0;
#    for (unsigned j = 0; j < ITERATIONS; j++) {
#        for (unsigned i = 0; i < COUNT; i++) {
#            char path[1024];
#            sprintf(path, "child/test%03d_loooooooooooooooooong_name", i);
#            lfs_file_open(&lfs, &file, path, LFS_O_CREAT | LFS_O_WRONLY) => 0;
#            lfs_file_close(&lfs, &file) => 0;
#        }
#
#        lfs_dir_t dir;
#        struct lfs_info info;
#        lfs_dir_open(&lfs, &dir, "child") => 0;
#        lfs_dir_read(&lfs, &dir, &info) => 1;
#        lfs_dir_read(&lfs, &dir, &info) => 1;
#        for (unsigned i = 0; i < COUNT; i++) {
#            char path[1024];
#            sprintf(path, "test%03d_loooooooooooooooooong_name", i);
#            lfs_dir_read(&lfs, &dir, &info) => 1;
#            strcmp(info.name, path) => 0;
#            info.size => 0;
#
#            sprintf(path, "child/test%03d_loooooooooooooooooong_name", i);
#            lfs_file_open(&lfs, &file, path, LFS_O_WRONLY) => 0;
#            lfs_file_write(&lfs, &file, "hi", 2) => 2;
#            lfs_file_close(&lfs, &file) => 0;
#        }
#        lfs_dir_read(&lfs, &dir, &info) => 0;
#
#        lfs_dir_rewind(&lfs, &dir) => 0;
#        lfs_dir_read(&lfs, &dir, &info) => 1;
#        lfs_dir_read(&lfs, &dir, &info) => 1;
#        for (unsigned i = 0; i < COUNT; i++) {
#            char path[1024];
#            sprintf(path, "test%03d_loooooooooooooooooong_name", i);
#            lfs_dir_read(&lfs, &dir, &info) => 1;
#            strcmp(info.name, path) => 0;
#            info.size => 2;
#
#            sprintf(path, "child/test%03d_loooooooooooooooooong_name", i);
#            lfs_file_open(&lfs, &file, path, LFS_O_WRONLY) => 0;
#            lfs_file_write(&lfs, &file, "hi", 2) => 2;
#            lfs_file_close(&lfs, &file) => 0;
#        }
#        lfs_dir_read(&lfs, &dir, &info) => 0;
#
#        lfs_dir_rewind(&lfs, &dir) => 0;
#        lfs_dir_read(&lfs, &dir, &info) => 1;
#        lfs_dir_read(&lfs, &dir, &info) => 1;
#        for (unsigned i = 0; i < COUNT; i++) {
#            char path[1024];
#            sprintf(path, "test%03d_loooooooooooooooooong_name", i);
#            lfs_dir_read(&lfs, &dir, &info) => 1;
#            strcmp(info.name, path) => 0;
#            info.size => 2;
#        }
#        lfs_dir_read(&lfs, &dir, &info) => 0;
#        lfs_dir_close(&lfs, &dir) => 0;
#
#        for (unsigned i = 0; i < COUNT; i++) {
#            char path[1024];
#            sprintf(path, "child/test%03d_loooooooooooooooooong_name", i);
#            lfs_remove(&lfs, path) => 0;
#        }
#    }
#    lfs_unmount(&lfs) => 0;
#'''
#
## reentrant testing for relocations, this is the same as the
## orphan testing, except here we also set block_cycles so that
## almost every tree operation needs a relocation
#[cases.test_relocations_reentrant]
#reentrant = true
## TODO fix this case, caused by non-DAG trees
## NOTE the second condition is required
#if = '!(DEPTH == 3 && CACHE_SIZE != 64) && 2*FILES < BLOCK_COUNT'
#defines = [
#    {FILES=6,  DEPTH=1, CYCLES=20, BLOCK_CYCLES=1},
#    {FILES=26, DEPTH=1, CYCLES=20, BLOCK_CYCLES=1},
#    {FILES=3,  DEPTH=3, CYCLES=20, BLOCK_CYCLES=1},
#]
#code = '''
#    lfs_t lfs;
#    int err = lfs_mount(&lfs, cfg);
#    if (err) {
#        lfs_format(&lfs, cfg) => 0;
#        lfs_mount(&lfs, cfg) => 0;
#    }
#
#    uint32_t prng = 1;
#    const char alpha[] = "abcdefghijklmnopqrstuvwxyz";
#    for (unsigned i = 0; i < CYCLES; i++) {
#        // create random path
#        char full_path[256];
#        for (unsigned d = 0; d < DEPTH; d++) {
#            sprintf(&full_path[2*d], "/%c", alpha[TEST_PRNG(&prng) % FILES]);
#        }
#
#        // if it does not exist, we create it, else we destroy
#        struct lfs_info info;
#        int res = lfs_stat(&lfs, full_path, &info);
#        if (res == LFS_ERR_NOENT) {
#            // create each directory in turn, ignore if dir already exists
#            for (unsigned d = 0; d < DEPTH; d++) {
#                char path[1024];
#                strcpy(path, full_path);
#                path[2*d+2] = '\0';
#                err = lfs_mkdir(&lfs, path);
#                assert(!err || err == LFS_ERR_EXIST);
#            }
#
#            for (unsigned d = 0; d < DEPTH; d++) {
#                char path[1024];
#                strcpy(path, full_path);
#                path[2*d+2] = '\0';
#                lfs_stat(&lfs, path, &info) => 0;
#                assert(strcmp(info.name, &path[2*d+1]) == 0);
#                assert(info.type == LFS_TYPE_DIR);
#            }
#        } else {
#            // is valid dir?
#            assert(strcmp(info.name, &full_path[2*(DEPTH-1)+1]) == 0);
#            assert(info.type == LFS_TYPE_DIR);
#
#            // try to delete path in reverse order, ignore if dir is not empty
#            for (unsigned d = DEPTH-1; d+1 > 0; d--) {
#                char path[1024];
#                strcpy(path, full_path);
#                path[2*d+2] = '\0';
#                err = lfs_remove(&lfs, path);
#                assert(!err || err == LFS_ERR_NOTEMPTY);
#            }
#
#            lfs_stat(&lfs, full_path, &info) => LFS_ERR_NOENT;
#        }
#    }
#    lfs_unmount(&lfs) => 0;
#'''
#
## reentrant testing for relocations, but now with random renames!
#[cases.test_relocations_reentrant_renames]
#reentrant = true
## TODO fix this case, caused by non-DAG trees
## NOTE the second condition is required
#if = '!(DEPTH == 3 && CACHE_SIZE != 64) && 2*FILES < BLOCK_COUNT'
#defines = [
#    {FILES=6,  DEPTH=1, CYCLES=20, BLOCK_CYCLES=1},
#    {FILES=26, DEPTH=1, CYCLES=20, BLOCK_CYCLES=1},
#    {FILES=3,  DEPTH=3, CYCLES=20, BLOCK_CYCLES=1},
#]
#code = '''
#    lfs_t lfs;
#    int err = lfs_mount(&lfs, cfg);
#    if (err) {
#        lfs_format(&lfs, cfg) => 0;
#        lfs_mount(&lfs, cfg) => 0;
#    }
#
#    uint32_t prng = 1;
#    const char alpha[] = "abcdefghijklmnopqrstuvwxyz";
#    for (unsigned i = 0; i < CYCLES; i++) {
#        // create random path
#        char full_path[256];
#        for (unsigned d = 0; d < DEPTH; d++) {
#            sprintf(&full_path[2*d], "/%c", alpha[TEST_PRNG(&prng) % FILES]);
#        }
#
#        // if it does not exist, we create it, else we destroy
#        struct lfs_info info;
#        int res = lfs_stat(&lfs, full_path, &info);
#        assert(!res || res == LFS_ERR_NOENT);
#        if (res == LFS_ERR_NOENT) {
#            // create each directory in turn, ignore if dir already exists
#            for (unsigned d = 0; d < DEPTH; d++) {
#                char path[1024];
#                strcpy(path, full_path);
#                path[2*d+2] = '\0';
#                err = lfs_mkdir(&lfs, path);
#                assert(!err || err == LFS_ERR_EXIST);
#            }
#
#            for (unsigned d = 0; d < DEPTH; d++) {
#                char path[1024];
#                strcpy(path, full_path);
#                path[2*d+2] = '\0';
#                lfs_stat(&lfs, path, &info) => 0;
#                assert(strcmp(info.name, &path[2*d+1]) == 0);
#                assert(info.type == LFS_TYPE_DIR);
#            }
#        } else {
#            assert(strcmp(info.name, &full_path[2*(DEPTH-1)+1]) == 0);
#            assert(info.type == LFS_TYPE_DIR);
#
#            // create new random path
#            char new_path[256];
#            for (unsigned d = 0; d < DEPTH; d++) {
#                sprintf(&new_path[2*d], "/%c", alpha[TEST_PRNG(&prng) % FILES]);
#            }
#
#            // if new path does not exist, rename, otherwise destroy
#            res = lfs_stat(&lfs, new_path, &info);
#            assert(!res || res == LFS_ERR_NOENT);
#            if (res == LFS_ERR_NOENT) {
#                // stop once some dir is renamed
#                for (unsigned d = 0; d < DEPTH; d++) {
#                    char path[1024];
#                    strcpy(&path[2*d], &full_path[2*d]);
#                    path[2*d+2] = '\0';
#                    strcpy(&path[128+2*d], &new_path[2*d]);
#                    path[128+2*d+2] = '\0';
#                    err = lfs_rename(&lfs, path, path+128);
#                    assert(!err || err == LFS_ERR_NOTEMPTY);
#                    if (!err) {
#                        strcpy(path, path+128);
#                    }
#                }
#
#                for (unsigned d = 0; d < DEPTH; d++) {
#                    char path[1024];
#                    strcpy(path, new_path);
#                    path[2*d+2] = '\0';
#                    lfs_stat(&lfs, path, &info) => 0;
#                    assert(strcmp(info.name, &path[2*d+1]) == 0);
#                    assert(info.type == LFS_TYPE_DIR);
#                }
#                
#                lfs_stat(&lfs, full_path, &info) => LFS_ERR_NOENT;
#            } else {
#                // try to delete path in reverse order,
#                // ignore if dir is not empty
#                for (unsigned d = DEPTH-1; d+1 > 0; d--) {
#                    char path[1024];
#                    strcpy(path, full_path);
#                    path[2*d+2] = '\0';
#                    err = lfs_remove(&lfs, path);
#                    assert(!err || err == LFS_ERR_NOTEMPTY);
#                }
#
#                lfs_stat(&lfs, full_path, &info) => LFS_ERR_NOENT;
#            }
#        }
#    }
#    lfs_unmount(&lfs) => 0;
#'''