Renamed tests/benches such that order is logical
It doesn't make sense to test more complex logic, such as t2_btree.toml, when the logic it is built on, t1_rbyd.toml, does not past testing. The test runner already guarantees a consistent lexicographic order, so all we need to do is renamed these from test_* -> tn_*. Note, if we every have more than 10 tests, we will need to bump up the number of digits for all tests, so t1_rbyd.toml -> t01_rbyd.toml. This is the main downside of lexicographic ordering. But we'll cross that bridge when we get to it.
This commit is contained in:
Christopher Haster
@@ -1,891 +0,0 @@
|
||||
|
||||
# Tests covering properties of the block allocator
|
||||
|
||||
# TODO test all of these with weird block sizes? would be nice to make this
|
||||
# easy via the test_runner, either by handling it there or letting a single
|
||||
# config limit the block count by a couple blocks
|
||||
|
||||
# test that we can alloc
|
||||
[cases.test_alloc_blocks]
|
||||
in = 'lfs.c'
|
||||
code = '''
|
||||
lfs_t lfs;
|
||||
lfsr_format(&lfs, cfg) => 0;
|
||||
lfsr_mount(&lfs, cfg) => 0;
|
||||
|
||||
// start allocating
|
||||
lfs_alloc_ack(&lfs);
|
||||
lfs_size_t alloced = 0;
|
||||
while (true) {
|
||||
lfs_block_t block;
|
||||
int err = lfs_alloc(&lfs, &block);
|
||||
assert(!err || err == LFS_ERR_NOSPC);
|
||||
|
||||
if (err == LFS_ERR_NOSPC) {
|
||||
break;
|
||||
}
|
||||
alloced += 1;
|
||||
|
||||
// our allocator should stop at some point...
|
||||
assert(alloced < 2*BLOCK_COUNT);
|
||||
}
|
||||
|
||||
// excluding our mroot, we should have allocated exactly
|
||||
// block_count-2 blocks
|
||||
printf("alloced %d/%d blocks\n", alloced, (lfs_block_t)BLOCK_COUNT);
|
||||
assert(alloced == BLOCK_COUNT-2);
|
||||
|
||||
lfsr_unmount(&lfs) => 0;
|
||||
'''
|
||||
|
||||
# test that we can realloc after an ack
|
||||
[cases.test_alloc_reuse]
|
||||
in = 'lfs.c'
|
||||
code = '''
|
||||
lfs_t lfs;
|
||||
lfsr_format(&lfs, cfg) => 0;
|
||||
lfsr_mount(&lfs, cfg) => 0;
|
||||
|
||||
// start allocating
|
||||
lfs_alloc_ack(&lfs);
|
||||
lfs_size_t alloced = 0;
|
||||
while (true) {
|
||||
lfs_block_t block;
|
||||
int err = lfs_alloc(&lfs, &block);
|
||||
assert(!err || err == LFS_ERR_NOSPC);
|
||||
|
||||
if (err == LFS_ERR_NOSPC) {
|
||||
break;
|
||||
}
|
||||
alloced += 1;
|
||||
|
||||
// our allocator should stop at some point...
|
||||
assert(alloced < 2*BLOCK_COUNT);
|
||||
}
|
||||
|
||||
// excluding our mroot, we should have allocated exactly
|
||||
// block_count-2 blocks
|
||||
printf("alloced %d/%d blocks\n", alloced, (lfs_block_t)BLOCK_COUNT);
|
||||
assert(alloced == BLOCK_COUNT-2);
|
||||
|
||||
// ack again, effectively releasing all the previously alloced blocks
|
||||
lfs_alloc_ack(&lfs);
|
||||
alloced = 0;
|
||||
while (true) {
|
||||
lfs_block_t block;
|
||||
int err = lfs_alloc(&lfs, &block);
|
||||
assert(!err || err == LFS_ERR_NOSPC);
|
||||
|
||||
if (err == LFS_ERR_NOSPC) {
|
||||
break;
|
||||
}
|
||||
alloced += 1;
|
||||
|
||||
// our allocator should stop at some point...
|
||||
assert(alloced < 2*BLOCK_COUNT);
|
||||
}
|
||||
|
||||
// excluding our mroot, we should have allocated exactly
|
||||
// block_count-2 blocks
|
||||
printf("alloced %d/%d blocks\n", alloced, (lfs_block_t)BLOCK_COUNT);
|
||||
assert(alloced == BLOCK_COUNT-2);
|
||||
|
||||
lfsr_unmount(&lfs) => 0;
|
||||
'''
|
||||
|
||||
# test that we can alloc an mtree, the difference between this and mtree tests
|
||||
# is we expect this to be able to handle wrap-around
|
||||
[cases.test_alloc_mtree]
|
||||
in = 'lfs.c'
|
||||
code = '''
|
||||
const char *alphas = "abcdefghijklmnopqrstuvwxyz";
|
||||
lfs_t lfs;
|
||||
lfsr_format(&lfs, cfg) => 0;
|
||||
lfsr_mount(&lfs, cfg) => 0;
|
||||
|
||||
lfsr_mdir_t mdir;
|
||||
lfsr_mtree_lookup(&lfs, lfsr_mtree_weight(&lfs)-1, &mdir) => 0;
|
||||
lfs_ssize_t rid = 0;
|
||||
|
||||
lfs_size_t count = 0;
|
||||
while (true) {
|
||||
// at least try to catch infinite loops
|
||||
assert(count < BLOCK_SIZE * BLOCK_COUNT/2);
|
||||
|
||||
// ack before each commit to reset the allocator
|
||||
lfs_alloc_ack(&lfs);
|
||||
|
||||
// keep creating new metadata entries until we run out of space
|
||||
int err = lfsr_mdir_commit(&lfs, &mdir, &rid, LFSR_ATTRS(
|
||||
LFSR_ATTR(rid, INLINED, +1, &alphas[count % 26], 1)));
|
||||
assert(!err || err == LFS_ERR_NOSPC);
|
||||
if (err == LFS_ERR_NOSPC) {
|
||||
break;
|
||||
}
|
||||
|
||||
uint8_t buffer[4];
|
||||
lfsr_mdir_get(&lfs, &mdir, rid, LFSR_TAG_INLINED,
|
||||
buffer, 4) => 1;
|
||||
assert(memcmp(buffer, &alphas[count % 26], 1) == 0);
|
||||
|
||||
count += 1;
|
||||
rid += 1;
|
||||
}
|
||||
|
||||
printf("alloced %d metadata entries in %d blocks\n",
|
||||
count, (lfs_block_t)BLOCK_COUNT);
|
||||
|
||||
// test that all of our metadata entries are still there
|
||||
lfs_size_t i = 0;
|
||||
for (lfs_ssize_t mid = (lfsr_mtree_isinlined(&lfs) ? -1 : 0);
|
||||
mid < lfsr_mtree_weight(&lfs);
|
||||
mid++) {
|
||||
lfsr_mdir_t mdir;
|
||||
lfsr_mtree_lookup(&lfs, mid, &mdir) => 0;
|
||||
for (lfs_ssize_t rid = 0;
|
||||
rid < (lfs_ssize_t)lfsr_mdir_weight(&mdir);
|
||||
rid++) {
|
||||
uint8_t buffer[4];
|
||||
lfsr_mdir_get(&lfs, &mdir, rid, LFSR_TAG_INLINED,
|
||||
buffer, 4) => 1;
|
||||
assert(memcmp(buffer, &alphas[i % 26], 1) == 0);
|
||||
i += 1;
|
||||
}
|
||||
}
|
||||
assert(i == count);
|
||||
|
||||
lfsr_unmount(&lfs) => 0;
|
||||
'''
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
## allocator tests
|
||||
## note for these to work there are a number constraints on the device geometry
|
||||
#if = 'BLOCK_CYCLES == -1'
|
||||
#
|
||||
## parallel allocation test
|
||||
#[cases.test_alloc_parallel]
|
||||
#defines.FILES = 3
|
||||
#defines.SIZE = '(((BLOCK_SIZE-8)*(BLOCK_COUNT-6)) / FILES)'
|
||||
#code = '''
|
||||
# const char *names[] = {"bacon", "eggs", "pancakes"};
|
||||
# lfs_file_t files[FILES];
|
||||
#
|
||||
# lfs_t lfs;
|
||||
# lfs_format(&lfs, cfg) => 0;
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
# lfs_mkdir(&lfs, "breakfast") => 0;
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
#
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
# for (int n = 0; n < FILES; n++) {
|
||||
# char path[1024];
|
||||
# sprintf(path, "breakfast/%s", names[n]);
|
||||
# lfs_file_open(&lfs, &files[n], path,
|
||||
# LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0;
|
||||
# }
|
||||
# for (int n = 0; n < FILES; n++) {
|
||||
# size_t size = strlen(names[n]);
|
||||
# for (lfs_size_t i = 0; i < SIZE; i += size) {
|
||||
# lfs_file_write(&lfs, &files[n], names[n], size) => size;
|
||||
# }
|
||||
# }
|
||||
# for (int n = 0; n < FILES; n++) {
|
||||
# lfs_file_close(&lfs, &files[n]) => 0;
|
||||
# }
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
#
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
# for (int n = 0; n < FILES; n++) {
|
||||
# char path[1024];
|
||||
# sprintf(path, "breakfast/%s", names[n]);
|
||||
# lfs_file_t file;
|
||||
# lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0;
|
||||
# size_t size = strlen(names[n]);
|
||||
# for (lfs_size_t i = 0; i < SIZE; i += size) {
|
||||
# uint8_t buffer[1024];
|
||||
# lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
# assert(memcmp(buffer, names[n], size) == 0);
|
||||
# }
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
# }
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
#'''
|
||||
#
|
||||
## serial allocation test
|
||||
#[cases.test_alloc_serial]
|
||||
#defines.FILES = 3
|
||||
#defines.SIZE = '(((BLOCK_SIZE-8)*(BLOCK_COUNT-6)) / FILES)'
|
||||
#code = '''
|
||||
# const char *names[] = {"bacon", "eggs", "pancakes"};
|
||||
#
|
||||
# lfs_t lfs;
|
||||
# lfs_format(&lfs, cfg) => 0;
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
# lfs_mkdir(&lfs, "breakfast") => 0;
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
#
|
||||
# for (int n = 0; n < FILES; n++) {
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
# char path[1024];
|
||||
# sprintf(path, "breakfast/%s", names[n]);
|
||||
# lfs_file_t file;
|
||||
# lfs_file_open(&lfs, &file, path,
|
||||
# LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0;
|
||||
# size_t size = strlen(names[n]);
|
||||
# uint8_t buffer[1024];
|
||||
# memcpy(buffer, names[n], size);
|
||||
# for (int i = 0; i < SIZE; i += size) {
|
||||
# lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
# }
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
# }
|
||||
#
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
# for (int n = 0; n < FILES; n++) {
|
||||
# char path[1024];
|
||||
# sprintf(path, "breakfast/%s", names[n]);
|
||||
# lfs_file_t file;
|
||||
# lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0;
|
||||
# size_t size = strlen(names[n]);
|
||||
# for (int i = 0; i < SIZE; i += size) {
|
||||
# uint8_t buffer[1024];
|
||||
# lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
# assert(memcmp(buffer, names[n], size) == 0);
|
||||
# }
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
# }
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
#'''
|
||||
#
|
||||
## parallel allocation reuse test
|
||||
#[cases.test_alloc_parallel_reuse]
|
||||
#defines.FILES = 3
|
||||
#defines.SIZE = '(((BLOCK_SIZE-8)*(BLOCK_COUNT-6)) / FILES)'
|
||||
#defines.CYCLES = [1, 10]
|
||||
#code = '''
|
||||
# const char *names[] = {"bacon", "eggs", "pancakes"};
|
||||
# lfs_file_t files[FILES];
|
||||
#
|
||||
# lfs_t lfs;
|
||||
# lfs_format(&lfs, cfg) => 0;
|
||||
#
|
||||
# for (int c = 0; c < CYCLES; c++) {
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
# lfs_mkdir(&lfs, "breakfast") => 0;
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
#
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
# for (int n = 0; n < FILES; n++) {
|
||||
# char path[1024];
|
||||
# sprintf(path, "breakfast/%s", names[n]);
|
||||
# lfs_file_open(&lfs, &files[n], path,
|
||||
# LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0;
|
||||
# }
|
||||
# for (int n = 0; n < FILES; n++) {
|
||||
# size_t size = strlen(names[n]);
|
||||
# for (int i = 0; i < SIZE; i += size) {
|
||||
# lfs_file_write(&lfs, &files[n], names[n], size) => size;
|
||||
# }
|
||||
# }
|
||||
# for (int n = 0; n < FILES; n++) {
|
||||
# lfs_file_close(&lfs, &files[n]) => 0;
|
||||
# }
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
#
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
# for (int n = 0; n < FILES; n++) {
|
||||
# char path[1024];
|
||||
# sprintf(path, "breakfast/%s", names[n]);
|
||||
# lfs_file_t file;
|
||||
# lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0;
|
||||
# size_t size = strlen(names[n]);
|
||||
# for (int i = 0; i < SIZE; i += size) {
|
||||
# uint8_t buffer[1024];
|
||||
# lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
# assert(memcmp(buffer, names[n], size) == 0);
|
||||
# }
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
# }
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
#
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
# for (int n = 0; n < FILES; n++) {
|
||||
# char path[1024];
|
||||
# sprintf(path, "breakfast/%s", names[n]);
|
||||
# lfs_remove(&lfs, path) => 0;
|
||||
# }
|
||||
# lfs_remove(&lfs, "breakfast") => 0;
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
# }
|
||||
#'''
|
||||
#
|
||||
## serial allocation reuse test
|
||||
#[cases.test_alloc_serial_reuse]
|
||||
#defines.FILES = 3
|
||||
#defines.SIZE = '(((BLOCK_SIZE-8)*(BLOCK_COUNT-6)) / FILES)'
|
||||
#defines.CYCLES = [1, 10]
|
||||
#code = '''
|
||||
# const char *names[] = {"bacon", "eggs", "pancakes"};
|
||||
#
|
||||
# lfs_t lfs;
|
||||
# lfs_format(&lfs, cfg) => 0;
|
||||
#
|
||||
# for (int c = 0; c < CYCLES; c++) {
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
# lfs_mkdir(&lfs, "breakfast") => 0;
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
#
|
||||
# for (int n = 0; n < FILES; n++) {
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
# char path[1024];
|
||||
# sprintf(path, "breakfast/%s", names[n]);
|
||||
# lfs_file_t file;
|
||||
# lfs_file_open(&lfs, &file, path,
|
||||
# LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0;
|
||||
# size_t size = strlen(names[n]);
|
||||
# uint8_t buffer[1024];
|
||||
# memcpy(buffer, names[n], size);
|
||||
# for (int i = 0; i < SIZE; i += size) {
|
||||
# lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
# }
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
# }
|
||||
#
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
# for (int n = 0; n < FILES; n++) {
|
||||
# char path[1024];
|
||||
# sprintf(path, "breakfast/%s", names[n]);
|
||||
# lfs_file_t file;
|
||||
# lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0;
|
||||
# size_t size = strlen(names[n]);
|
||||
# for (int i = 0; i < SIZE; i += size) {
|
||||
# uint8_t buffer[1024];
|
||||
# lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
# assert(memcmp(buffer, names[n], size) == 0);
|
||||
# }
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
# }
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
#
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
# for (int n = 0; n < FILES; n++) {
|
||||
# char path[1024];
|
||||
# sprintf(path, "breakfast/%s", names[n]);
|
||||
# lfs_remove(&lfs, path) => 0;
|
||||
# }
|
||||
# lfs_remove(&lfs, "breakfast") => 0;
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
# }
|
||||
#'''
|
||||
#
|
||||
## exhaustion test
|
||||
#[cases.test_alloc_exhaustion]
|
||||
#code = '''
|
||||
# lfs_t lfs;
|
||||
# lfs_format(&lfs, cfg) => 0;
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
# lfs_file_t file;
|
||||
# lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
# size_t size = strlen("exhaustion");
|
||||
# uint8_t buffer[1024];
|
||||
# memcpy(buffer, "exhaustion", size);
|
||||
# lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
# lfs_file_sync(&lfs, &file) => 0;
|
||||
#
|
||||
# size = strlen("blahblahblahblah");
|
||||
# memcpy(buffer, "blahblahblahblah", size);
|
||||
# lfs_ssize_t res;
|
||||
# while (true) {
|
||||
# res = lfs_file_write(&lfs, &file, buffer, size);
|
||||
# if (res < 0) {
|
||||
# break;
|
||||
# }
|
||||
#
|
||||
# res => size;
|
||||
# }
|
||||
# res => LFS_ERR_NOSPC;
|
||||
#
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
#
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
# lfs_file_open(&lfs, &file, "exhaustion", LFS_O_RDONLY);
|
||||
# size = strlen("exhaustion");
|
||||
# lfs_file_size(&lfs, &file) => size;
|
||||
# lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
# memcmp(buffer, "exhaustion", size) => 0;
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
#'''
|
||||
#
|
||||
## exhaustion wraparound test
|
||||
#[cases.test_alloc_exhaustion_wraparound]
|
||||
#defines.SIZE = '(((BLOCK_SIZE-8)*(BLOCK_COUNT-4)) / 3)'
|
||||
#code = '''
|
||||
# lfs_t lfs;
|
||||
# lfs_format(&lfs, cfg) => 0;
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
#
|
||||
# lfs_file_t file;
|
||||
# lfs_file_open(&lfs, &file, "padding", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
# size_t size = strlen("buffering");
|
||||
# uint8_t buffer[1024];
|
||||
# memcpy(buffer, "buffering", size);
|
||||
# for (int i = 0; i < SIZE; i += size) {
|
||||
# lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
# }
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
# lfs_remove(&lfs, "padding") => 0;
|
||||
#
|
||||
# lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
# size = strlen("exhaustion");
|
||||
# memcpy(buffer, "exhaustion", size);
|
||||
# lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
# lfs_file_sync(&lfs, &file) => 0;
|
||||
#
|
||||
# size = strlen("blahblahblahblah");
|
||||
# memcpy(buffer, "blahblahblahblah", size);
|
||||
# lfs_ssize_t res;
|
||||
# while (true) {
|
||||
# res = lfs_file_write(&lfs, &file, buffer, size);
|
||||
# if (res < 0) {
|
||||
# break;
|
||||
# }
|
||||
#
|
||||
# res => size;
|
||||
# }
|
||||
# res => LFS_ERR_NOSPC;
|
||||
#
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
#
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
# lfs_file_open(&lfs, &file, "exhaustion", LFS_O_RDONLY);
|
||||
# size = strlen("exhaustion");
|
||||
# lfs_file_size(&lfs, &file) => size;
|
||||
# lfs_file_read(&lfs, &file, buffer, size) => size;
|
||||
# memcmp(buffer, "exhaustion", size) => 0;
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
# lfs_remove(&lfs, "exhaustion") => 0;
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
#'''
|
||||
#
|
||||
## dir exhaustion test
|
||||
#[cases.test_alloc_dir_exhaustion]
|
||||
#code = '''
|
||||
# lfs_t lfs;
|
||||
# lfs_format(&lfs, cfg) => 0;
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
#
|
||||
# // find out max file size
|
||||
# lfs_mkdir(&lfs, "exhaustiondir") => 0;
|
||||
# size_t size = strlen("blahblahblahblah");
|
||||
# uint8_t buffer[1024];
|
||||
# memcpy(buffer, "blahblahblahblah", size);
|
||||
# lfs_file_t file;
|
||||
# lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
# int count = 0;
|
||||
# int err;
|
||||
# while (true) {
|
||||
# err = lfs_file_write(&lfs, &file, buffer, size);
|
||||
# if (err < 0) {
|
||||
# break;
|
||||
# }
|
||||
#
|
||||
# count += 1;
|
||||
# }
|
||||
# err => LFS_ERR_NOSPC;
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
#
|
||||
# lfs_remove(&lfs, "exhaustion") => 0;
|
||||
# lfs_remove(&lfs, "exhaustiondir") => 0;
|
||||
#
|
||||
# // see if dir fits with max file size
|
||||
# lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
# for (int i = 0; i < count; i++) {
|
||||
# lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
# }
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
#
|
||||
# lfs_mkdir(&lfs, "exhaustiondir") => 0;
|
||||
# lfs_remove(&lfs, "exhaustiondir") => 0;
|
||||
# lfs_remove(&lfs, "exhaustion") => 0;
|
||||
#
|
||||
# // see if dir fits with > max file size
|
||||
# lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
# for (int i = 0; i < count+1; i++) {
|
||||
# lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
# }
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
#
|
||||
# lfs_mkdir(&lfs, "exhaustiondir") => LFS_ERR_NOSPC;
|
||||
#
|
||||
# lfs_remove(&lfs, "exhaustion") => 0;
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
#'''
|
||||
#
|
||||
## what if we have a bad block during an allocation scan?
|
||||
#[cases.test_alloc_bad_blocks]
|
||||
#in = "lfs.c"
|
||||
#defines.ERASE_CYCLES = 0xffffffff
|
||||
#defines.BADBLOCK_BEHAVIOR = 'LFS_EMUBD_BADBLOCK_READERROR'
|
||||
#code = '''
|
||||
# lfs_t lfs;
|
||||
# lfs_format(&lfs, cfg) => 0;
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
# // first fill to exhaustion to find available space
|
||||
# lfs_file_t file;
|
||||
# lfs_file_open(&lfs, &file, "pacman", LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
# uint8_t buffer[1024];
|
||||
# strcpy((char*)buffer, "waka");
|
||||
# size_t size = strlen("waka");
|
||||
# lfs_size_t filesize = 0;
|
||||
# while (true) {
|
||||
# lfs_ssize_t res = lfs_file_write(&lfs, &file, buffer, size);
|
||||
# assert(res == (lfs_ssize_t)size || res == LFS_ERR_NOSPC);
|
||||
# if (res == LFS_ERR_NOSPC) {
|
||||
# break;
|
||||
# }
|
||||
# filesize += size;
|
||||
# }
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
# // now fill all but a couple of blocks of the filesystem with data
|
||||
# filesize -= 3*BLOCK_SIZE;
|
||||
# lfs_file_open(&lfs, &file, "pacman", LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
# strcpy((char*)buffer, "waka");
|
||||
# size = strlen("waka");
|
||||
# for (lfs_size_t i = 0; i < filesize/size; i++) {
|
||||
# lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
# }
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
# // also save head of file so we can error during lookahead scan
|
||||
# lfs_block_t fileblock = file.ctz.head;
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
#
|
||||
# // remount to force an alloc scan
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
#
|
||||
# // but mark the head of our file as a "bad block", this is force our
|
||||
# // scan to bail early
|
||||
# lfs_emubd_setwear(cfg, fileblock, 0xffffffff) => 0;
|
||||
# lfs_file_open(&lfs, &file, "ghost", LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
# strcpy((char*)buffer, "chomp");
|
||||
# size = strlen("chomp");
|
||||
# while (true) {
|
||||
# lfs_ssize_t res = lfs_file_write(&lfs, &file, buffer, size);
|
||||
# assert(res == (lfs_ssize_t)size || res == LFS_ERR_CORRUPT);
|
||||
# if (res == LFS_ERR_CORRUPT) {
|
||||
# break;
|
||||
# }
|
||||
# }
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
#
|
||||
# // now reverse the "bad block" and try to write the file again until we
|
||||
# // run out of space
|
||||
# lfs_emubd_setwear(cfg, fileblock, 0) => 0;
|
||||
# lfs_file_open(&lfs, &file, "ghost", LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
# strcpy((char*)buffer, "chomp");
|
||||
# size = strlen("chomp");
|
||||
# while (true) {
|
||||
# lfs_ssize_t res = lfs_file_write(&lfs, &file, buffer, size);
|
||||
# assert(res == (lfs_ssize_t)size || res == LFS_ERR_NOSPC);
|
||||
# if (res == LFS_ERR_NOSPC) {
|
||||
# break;
|
||||
# }
|
||||
# }
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
#
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
#
|
||||
# // check that the disk isn't hurt
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
# lfs_file_open(&lfs, &file, "pacman", LFS_O_RDONLY) => 0;
|
||||
# strcpy((char*)buffer, "waka");
|
||||
# size = strlen("waka");
|
||||
# for (lfs_size_t i = 0; i < filesize/size; i++) {
|
||||
# uint8_t rbuffer[4];
|
||||
# lfs_file_read(&lfs, &file, rbuffer, size) => size;
|
||||
# assert(memcmp(rbuffer, buffer, size) == 0);
|
||||
# }
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
#'''
|
||||
#
|
||||
#
|
||||
## Below, I don't like these tests. They're fragile and depend _heavily_
|
||||
## on the geometry of the block device. But they are valuable. Eventually they
|
||||
## should be removed and replaced with generalized tests.
|
||||
#
|
||||
## chained dir exhaustion test
|
||||
#[cases.test_alloc_chained_dir_exhaustion]
|
||||
#if = 'BLOCK_SIZE == 512'
|
||||
#defines.BLOCK_COUNT = 1024
|
||||
#code = '''
|
||||
# lfs_t lfs;
|
||||
# lfs_format(&lfs, cfg) => 0;
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
#
|
||||
# // find out max file size
|
||||
# lfs_mkdir(&lfs, "exhaustiondir") => 0;
|
||||
# for (int i = 0; i < 10; i++) {
|
||||
# char path[1024];
|
||||
# sprintf(path, "dirwithanexhaustivelylongnameforpadding%d", i);
|
||||
# lfs_mkdir(&lfs, path) => 0;
|
||||
# }
|
||||
# size_t size = strlen("blahblahblahblah");
|
||||
# uint8_t buffer[1024];
|
||||
# memcpy(buffer, "blahblahblahblah", size);
|
||||
# lfs_file_t file;
|
||||
# lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
# int count = 0;
|
||||
# int err;
|
||||
# while (true) {
|
||||
# err = lfs_file_write(&lfs, &file, buffer, size);
|
||||
# if (err < 0) {
|
||||
# break;
|
||||
# }
|
||||
#
|
||||
# count += 1;
|
||||
# }
|
||||
# err => LFS_ERR_NOSPC;
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
#
|
||||
# lfs_remove(&lfs, "exhaustion") => 0;
|
||||
# lfs_remove(&lfs, "exhaustiondir") => 0;
|
||||
# for (int i = 0; i < 10; i++) {
|
||||
# char path[1024];
|
||||
# sprintf(path, "dirwithanexhaustivelylongnameforpadding%d", i);
|
||||
# lfs_remove(&lfs, path) => 0;
|
||||
# }
|
||||
#
|
||||
# // see that chained dir fails
|
||||
# lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
# for (int i = 0; i < count+1; i++) {
|
||||
# lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
# }
|
||||
# lfs_file_sync(&lfs, &file) => 0;
|
||||
#
|
||||
# for (int i = 0; i < 10; i++) {
|
||||
# char path[1024];
|
||||
# sprintf(path, "dirwithanexhaustivelylongnameforpadding%d", i);
|
||||
# lfs_mkdir(&lfs, path) => 0;
|
||||
# }
|
||||
#
|
||||
# lfs_mkdir(&lfs, "exhaustiondir") => LFS_ERR_NOSPC;
|
||||
#
|
||||
# // shorten file to try a second chained dir
|
||||
# while (true) {
|
||||
# err = lfs_mkdir(&lfs, "exhaustiondir");
|
||||
# if (err != LFS_ERR_NOSPC) {
|
||||
# break;
|
||||
# }
|
||||
#
|
||||
# lfs_ssize_t filesize = lfs_file_size(&lfs, &file);
|
||||
# filesize > 0 => true;
|
||||
#
|
||||
# lfs_file_truncate(&lfs, &file, filesize - size) => 0;
|
||||
# lfs_file_sync(&lfs, &file) => 0;
|
||||
# }
|
||||
# err => 0;
|
||||
#
|
||||
# lfs_mkdir(&lfs, "exhaustiondir2") => LFS_ERR_NOSPC;
|
||||
#
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
#'''
|
||||
#
|
||||
## split dir test
|
||||
#[cases.test_alloc_split_dir]
|
||||
#if = 'BLOCK_SIZE == 512'
|
||||
#defines.BLOCK_COUNT = 1024
|
||||
#code = '''
|
||||
# lfs_t lfs;
|
||||
# lfs_format(&lfs, cfg) => 0;
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
#
|
||||
# // create one block hole for half a directory
|
||||
# lfs_file_t file;
|
||||
# lfs_file_open(&lfs, &file, "bump", LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
# for (lfs_size_t i = 0; i < cfg->block_size; i += 2) {
|
||||
# uint8_t buffer[1024];
|
||||
# memcpy(&buffer[i], "hi", 2);
|
||||
# }
|
||||
# uint8_t buffer[1024];
|
||||
# lfs_file_write(&lfs, &file, buffer, cfg->block_size) => cfg->block_size;
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
#
|
||||
# lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
|
||||
# size_t size = strlen("blahblahblahblah");
|
||||
# memcpy(buffer, "blahblahblahblah", size);
|
||||
# for (lfs_size_t i = 0;
|
||||
# i < (cfg->block_count-4)*(cfg->block_size-8);
|
||||
# i += size) {
|
||||
# lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
# }
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
#
|
||||
# // remount to force reset of lookahead
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
#
|
||||
# // open hole
|
||||
# lfs_remove(&lfs, "bump") => 0;
|
||||
#
|
||||
# lfs_mkdir(&lfs, "splitdir") => 0;
|
||||
# lfs_file_open(&lfs, &file, "splitdir/bump",
|
||||
# LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
# for (lfs_size_t i = 0; i < cfg->block_size; i += 2) {
|
||||
# memcpy(&buffer[i], "hi", 2);
|
||||
# }
|
||||
# lfs_file_write(&lfs, &file, buffer, 2*cfg->block_size) => LFS_ERR_NOSPC;
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
#
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
#'''
|
||||
#
|
||||
## outdated lookahead test
|
||||
#[cases.test_alloc_outdated_lookahead]
|
||||
#if = 'BLOCK_SIZE == 512'
|
||||
#defines.BLOCK_COUNT = 1024
|
||||
#code = '''
|
||||
# lfs_t lfs;
|
||||
# lfs_format(&lfs, cfg) => 0;
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
#
|
||||
# // fill completely with two files
|
||||
# lfs_file_t file;
|
||||
# lfs_file_open(&lfs, &file, "exhaustion1",
|
||||
# LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
# size_t size = strlen("blahblahblahblah");
|
||||
# uint8_t buffer[1024];
|
||||
# memcpy(buffer, "blahblahblahblah", size);
|
||||
# for (lfs_size_t i = 0;
|
||||
# i < ((cfg->block_count-2)/2)*(cfg->block_size-8);
|
||||
# i += size) {
|
||||
# lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
# }
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
#
|
||||
# lfs_file_open(&lfs, &file, "exhaustion2",
|
||||
# LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
# size = strlen("blahblahblahblah");
|
||||
# memcpy(buffer, "blahblahblahblah", size);
|
||||
# for (lfs_size_t i = 0;
|
||||
# i < ((cfg->block_count-2+1)/2)*(cfg->block_size-8);
|
||||
# i += size) {
|
||||
# lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
# }
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
#
|
||||
# // remount to force reset of lookahead
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
#
|
||||
# // rewrite one file
|
||||
# lfs_file_open(&lfs, &file, "exhaustion1",
|
||||
# LFS_O_WRONLY | LFS_O_TRUNC) => 0;
|
||||
# lfs_file_sync(&lfs, &file) => 0;
|
||||
# size = strlen("blahblahblahblah");
|
||||
# memcpy(buffer, "blahblahblahblah", size);
|
||||
# for (lfs_size_t i = 0;
|
||||
# i < ((cfg->block_count-2)/2)*(cfg->block_size-8);
|
||||
# i += size) {
|
||||
# lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
# }
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
#
|
||||
# // rewrite second file, this requires lookahead does not
|
||||
# // use old population
|
||||
# lfs_file_open(&lfs, &file, "exhaustion2",
|
||||
# LFS_O_WRONLY | LFS_O_TRUNC) => 0;
|
||||
# lfs_file_sync(&lfs, &file) => 0;
|
||||
# size = strlen("blahblahblahblah");
|
||||
# memcpy(buffer, "blahblahblahblah", size);
|
||||
# for (lfs_size_t i = 0;
|
||||
# i < ((cfg->block_count-2+1)/2)*(cfg->block_size-8);
|
||||
# i += size) {
|
||||
# lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
# }
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
#
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
#'''
|
||||
#
|
||||
## outdated lookahead and split dir test
|
||||
#[cases.test_alloc_outdated_lookahead_split_dir]
|
||||
#if = 'BLOCK_SIZE == 512'
|
||||
#defines.BLOCK_COUNT = 1024
|
||||
#code = '''
|
||||
# lfs_t lfs;
|
||||
# lfs_format(&lfs, cfg) => 0;
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
#
|
||||
# // fill completely with two files
|
||||
# lfs_file_t file;
|
||||
# lfs_file_open(&lfs, &file, "exhaustion1",
|
||||
# LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
# size_t size = strlen("blahblahblahblah");
|
||||
# uint8_t buffer[1024];
|
||||
# memcpy(buffer, "blahblahblahblah", size);
|
||||
# for (lfs_size_t i = 0;
|
||||
# i < ((cfg->block_count-2)/2)*(cfg->block_size-8);
|
||||
# i += size) {
|
||||
# lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
# }
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
#
|
||||
# lfs_file_open(&lfs, &file, "exhaustion2",
|
||||
# LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
# size = strlen("blahblahblahblah");
|
||||
# memcpy(buffer, "blahblahblahblah", size);
|
||||
# for (lfs_size_t i = 0;
|
||||
# i < ((cfg->block_count-2+1)/2)*(cfg->block_size-8);
|
||||
# i += size) {
|
||||
# lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
# }
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
#
|
||||
# // remount to force reset of lookahead
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
# lfs_mount(&lfs, cfg) => 0;
|
||||
#
|
||||
# // rewrite one file with a hole of one block
|
||||
# lfs_file_open(&lfs, &file, "exhaustion1",
|
||||
# LFS_O_WRONLY | LFS_O_TRUNC) => 0;
|
||||
# lfs_file_sync(&lfs, &file) => 0;
|
||||
# size = strlen("blahblahblahblah");
|
||||
# memcpy(buffer, "blahblahblahblah", size);
|
||||
# for (lfs_size_t i = 0;
|
||||
# i < ((cfg->block_count-2)/2 - 1)*(cfg->block_size-8);
|
||||
# i += size) {
|
||||
# lfs_file_write(&lfs, &file, buffer, size) => size;
|
||||
# }
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
#
|
||||
# // try to allocate a directory, should fail!
|
||||
# lfs_mkdir(&lfs, "split") => LFS_ERR_NOSPC;
|
||||
#
|
||||
# // file should not fail
|
||||
# lfs_file_open(&lfs, &file, "notasplit",
|
||||
# LFS_O_WRONLY | LFS_O_CREAT) => 0;
|
||||
# lfs_file_write(&lfs, &file, "hi", 2) => 2;
|
||||
# lfs_file_close(&lfs, &file) => 0;
|
||||
#
|
||||
# lfs_unmount(&lfs) => 0;
|
||||
#'''
|
||||
Reference in New Issue
Block a user