diff options
author | Christopher Haster <chaster@utexas.edu> | 2020-01-27 06:37:49 +0300 |
---|---|---|
committer | Christopher Haster <chaster@utexas.edu> | 2020-01-27 19:16:29 +0300 |
commit | aab6aa0ed939303d7788e21bb547eb0a386636fb (patch) | |
tree | 2b4051471559e604b9f2db956a33ab361c3f8f46 /tests | |
parent | 52ef0c1c9efac025b71f2bf3d33e8785538e88c7 (diff) |
Cleaned up test script and directory naming
- Removed old tests and test scripts
- Reorganize the block devices to live under one directory
- Plugged new test framework into Makefile
renamed:
- scripts/test_.py -> scripts/test.py
- tests_ -> tests
- {file,ram,test}bd/* -> bd/*
It took a surprising amount of effort to make the Makefile behave since
it turns out the "test_%" rule could override "tests/test_%.toml.test"
which is generated as part of test.py.
Diffstat (limited to 'tests')
27 files changed, 6542 insertions, 3089 deletions
diff --git a/tests/test_alloc.sh b/tests/test_alloc.toml index 0669850..8bfb5ed 100755..100644 --- a/tests/test_alloc.sh +++ b/tests/test_alloc.toml @@ -1,127 +1,200 @@ -#!/bin/bash -set -euE -export TEST_FILE=$0 -trap 'export TEST_LINE=$LINENO' DEBUG - -echo "=== Allocator tests ===" -rm -rf blocks -scripts/test.py << TEST - lfs_format(&lfs, &cfg) => 0; -TEST +# allocator tests +# note for these to work there are many constraints on the device geometry -SIZE=15000 +[[case]] # parallel allocation test +define.FILES = 3 +define.SIZE = '(((LFS_BLOCK_SIZE-8)*(LFS_BLOCK_COUNT-4)) / FILES)' +code = ''' + const char *names[FILES] = {"bacon", "eggs", "pancakes"}; + lfs_file_t files[FILES]; -lfs_mkdir() { -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_mkdir(&lfs, "$1") => 0; - lfs_unmount(&lfs) => 0; -TEST -} - -lfs_remove() { -scripts/test.py << TEST + lfs_format(&lfs, &cfg) => 0; lfs_mount(&lfs, &cfg) => 0; - lfs_remove(&lfs, "$1/eggs") => 0; - lfs_remove(&lfs, "$1/bacon") => 0; - lfs_remove(&lfs, "$1/pancakes") => 0; - lfs_remove(&lfs, "$1") => 0; + lfs_mkdir(&lfs, "breakfast") => 0; lfs_unmount(&lfs) => 0; -TEST -} -lfs_alloc_singleproc() { -scripts/test.py << TEST - const char *names[] = {"bacon", "eggs", "pancakes"}; - lfs_file_t files[sizeof(names)/sizeof(names[0])]; lfs_mount(&lfs, &cfg) => 0; - for (unsigned n = 0; n < sizeof(names)/sizeof(names[0]); n++) { - sprintf(path, "$1/%s", names[n]); + for (int n = 0; n < FILES; n++) { + sprintf(path, "breakfast/%s", names[n]); lfs_file_open(&lfs, &files[n], path, LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0; } - for (unsigned n = 0; n < sizeof(names)/sizeof(names[0]); n++) { - lfs_size_t size = strlen(names[n]); - for (int i = 0; i < $SIZE; i++) { + for (int n = 0; n < FILES; n++) { + 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 (unsigned n = 0; n < sizeof(names)/sizeof(names[0]); n++) { + for (int n = 0; n < FILES; n++) { lfs_file_close(&lfs, &files[n]) => 0; } lfs_unmount(&lfs) => 0; -TEST -} -lfs_alloc_multiproc() { -for name in bacon eggs pancakes -do -scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file, "$1/$name", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0; - lfs_size_t size = strlen("$name"); - memcpy(buffer, "$name", size); - for (int i = 0; i < $SIZE; i++) { - lfs_file_write(&lfs, &file, buffer, size) => size; + for (int n = 0; n < FILES; n++) { + sprintf(path, "breakfast/%s", names[n]); + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + size = strlen(names[n]); + for (lfs_size_t i = 0; i < SIZE; i += size) { + lfs_file_read(&lfs, &file, buffer, size) => size; + assert(memcmp(buffer, names[n], size) == 0); + } + lfs_file_close(&lfs, &file) => 0; } - lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; -TEST -done -} - -lfs_verify() { -for name in bacon eggs pancakes -do -scripts/test.py << TEST +''' + +[[case]] # serial allocation test +define.FILES = 3 +define.SIZE = '(((LFS_BLOCK_SIZE-8)*(LFS_BLOCK_COUNT-4)) / FILES)' +code = ''' + const char *names[FILES] = {"bacon", "eggs", "pancakes"}; + + lfs_format(&lfs, &cfg) => 0; lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file, "$1/$name", LFS_O_RDONLY) => 0; - lfs_size_t size = strlen("$name"); - for (int i = 0; i < $SIZE; i++) { - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "$name", size) => 0; + lfs_mkdir(&lfs, "breakfast") => 0; + lfs_unmount(&lfs) => 0; + + for (int n = 0; n < FILES; n++) { + lfs_mount(&lfs, &cfg) => 0; + sprintf(path, "breakfast/%s", names[n]); + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0; + size = strlen(names[n]); + 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++) { + sprintf(path, "breakfast/%s", names[n]); + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + size = strlen(names[n]); + for (int i = 0; i < SIZE; i += size) { + lfs_file_read(&lfs, &file, buffer, size) => size; + assert(memcmp(buffer, names[n], size) == 0); + } + lfs_file_close(&lfs, &file) => 0; } - lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; -TEST -done -} - -echo "--- Single-process allocation test ---" -lfs_mkdir singleproc -lfs_alloc_singleproc singleproc -lfs_verify singleproc - -echo "--- Multi-process allocation test ---" -lfs_mkdir multiproc -lfs_alloc_multiproc multiproc -lfs_verify multiproc -lfs_verify singleproc - -echo "--- Single-process reuse test ---" -lfs_remove singleproc -lfs_mkdir singleprocreuse -lfs_alloc_singleproc singleprocreuse -lfs_verify singleprocreuse -lfs_verify multiproc - -echo "--- Multi-process reuse test ---" -lfs_remove multiproc -lfs_mkdir multiprocreuse -lfs_alloc_singleproc multiprocreuse -lfs_verify multiprocreuse -lfs_verify singleprocreuse - -echo "--- Cleanup ---" -lfs_remove multiprocreuse -lfs_remove singleprocreuse - -echo "--- Exhaustion test ---" -scripts/test.py << TEST +''' + +[[case]] # parallel allocation reuse test +define.FILES = 3 +define.SIZE = '(((LFS_BLOCK_SIZE-8)*(LFS_BLOCK_COUNT-4)) / FILES)' +define.CYCLES = [1, 10] +code = ''' + const char *names[FILES] = {"bacon", "eggs", "pancakes"}; + lfs_file_t files[FILES]; + + 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++) { + 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 = 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++) { + sprintf(path, "breakfast/%s", names[n]); + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + size = strlen(names[n]); + for (int i = 0; i < SIZE; i += size) { + 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++) { + sprintf(path, "breakfast/%s", names[n]); + lfs_remove(&lfs, path) => 0; + } + lfs_remove(&lfs, "breakfast") => 0; + lfs_unmount(&lfs) => 0; + } +''' + +[[case]] # serial allocation reuse test +define.FILES = 3 +define.SIZE = '(((LFS_BLOCK_SIZE-8)*(LFS_BLOCK_COUNT-4)) / FILES)' +define.CYCLES = [1, 10] +code = ''' + const char *names[FILES] = {"bacon", "eggs", "pancakes"}; + + 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; + sprintf(path, "breakfast/%s", names[n]); + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0; + size = strlen(names[n]); + 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++) { + sprintf(path, "breakfast/%s", names[n]); + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + size = strlen(names[n]); + for (int i = 0; i < SIZE; i += size) { + 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++) { + sprintf(path, "breakfast/%s", names[n]); + lfs_remove(&lfs, path) => 0; + } + lfs_remove(&lfs, "breakfast") => 0; + lfs_unmount(&lfs) => 0; + } +''' + +[[case]] # exhaustion test +code = ''' + lfs_format(&lfs, &cfg) => 0; lfs_mount(&lfs, &cfg) => 0; lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT); - lfs_size_t size = strlen("exhaustion"); + size = strlen("exhaustion"); memcpy(buffer, "exhaustion", size); lfs_file_write(&lfs, &file, buffer, size) => size; lfs_file_sync(&lfs, &file) => 0; @@ -141,27 +214,27 @@ scripts/test.py << TEST lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST + lfs_mount(&lfs, &cfg) => 0; lfs_file_open(&lfs, &file, "exhaustion", LFS_O_RDONLY); - lfs_size_t size = strlen("exhaustion"); + 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; -TEST +''' -echo "--- Exhaustion wraparound test ---" -scripts/test.py << TEST +[[case]] # exhaustion wraparound test +define.SIZE = '(((LFS_BLOCK_SIZE-8)*(LFS_BLOCK_COUNT-4)) / 3)' +code = ''' + lfs_format(&lfs, &cfg) => 0; lfs_mount(&lfs, &cfg) => 0; - lfs_remove(&lfs, "exhaustion") => 0; lfs_file_open(&lfs, &file, "padding", LFS_O_WRONLY | LFS_O_CREAT); - lfs_size_t size = strlen("buffering"); + size = strlen("buffering"); memcpy(buffer, "buffering", size); - for (int i = 0; i < $SIZE; i++) { + for (int i = 0; i < SIZE; i += size) { lfs_file_write(&lfs, &file, buffer, size) => size; } lfs_file_close(&lfs, &file) => 0; @@ -188,30 +261,29 @@ scripts/test.py << TEST lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST + lfs_mount(&lfs, &cfg) => 0; lfs_file_open(&lfs, &file, "exhaustion", LFS_O_RDONLY); - lfs_size_t size = strlen("exhaustion"); + 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; -TEST +''' -echo "--- Dir exhaustion test ---" -scripts/test.py << TEST +[[case]] # dir exhaustion test +code = ''' + lfs_format(&lfs, &cfg) => 0; lfs_mount(&lfs, &cfg) => 0; // find out max file size lfs_mkdir(&lfs, "exhaustiondir") => 0; - lfs_size_t size = strlen("blahblahblahblah"); + size = strlen("blahblahblahblah"); memcpy(buffer, "blahblahblahblah", size); 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) { @@ -248,18 +320,18 @@ scripts/test.py << TEST lfs_remove(&lfs, "exhaustion") => 0; lfs_unmount(&lfs) => 0; -TEST +''' -## Below, these tests depend _very_ heavily on the geometry of the -## block device being tested, they should be removed and replaced -## by generalized tests. For now we'll just skip if the geometry -## is customized. +# 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. -if [[ ! $MAKEFLAGS =~ "LFS_BLOCK_CYCLES" ]] -then - -echo "--- Chained dir exhaustion test ---" -scripts/test.py << TEST +[[case]] # chained dir exhaustion test +define.LFS_BLOCK_SIZE = 512 +define.LFS_BLOCK_COUNT = 1024 +if = 'LFS_BLOCK_SIZE == 512 and LFS_BLOCK_COUNT == 1024' +code = ''' + lfs_format(&lfs, &cfg) => 0; lfs_mount(&lfs, &cfg) => 0; // find out max file size @@ -268,11 +340,10 @@ scripts/test.py << TEST sprintf(path, "dirwithanexhaustivelylongnameforpadding%d", i); lfs_mkdir(&lfs, path) => 0; } - lfs_size_t size = strlen("blahblahblahblah"); + size = strlen("blahblahblahblah"); memcpy(buffer, "blahblahblahblah", size); 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) { @@ -324,13 +395,14 @@ scripts/test.py << TEST lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; -TEST +''' -echo "--- Split dir test ---" -scripts/test.py << TEST +[[case]] # split dir test +define.LFS_BLOCK_SIZE = 512 +define.LFS_BLOCK_COUNT = 1024 +if = 'LFS_BLOCK_SIZE == 512 and LFS_BLOCK_COUNT == 1024' +code = ''' lfs_format(&lfs, &cfg) => 0; -TEST -scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; // create one block hole for half a directory @@ -342,7 +414,7 @@ scripts/test.py << TEST lfs_file_close(&lfs, &file) => 0; lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT); - lfs_size_t size = strlen("blahblahblahblah"); + size = strlen("blahblahblahblah"); memcpy(buffer, "blahblahblahblah", size); for (lfs_size_t i = 0; i < (cfg.block_count-4)*(cfg.block_size-8); @@ -368,18 +440,20 @@ scripts/test.py << TEST lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; -TEST +''' -echo "--- Outdated lookahead test ---" -scripts/test.py << TEST +[[case]] # outdated lookahead test +define.LFS_BLOCK_SIZE = 512 +define.LFS_BLOCK_COUNT = 1024 +if = 'LFS_BLOCK_SIZE == 512 and LFS_BLOCK_COUNT == 1024' +code = ''' lfs_format(&lfs, &cfg) => 0; - lfs_mount(&lfs, &cfg) => 0; // fill completely with two files lfs_file_open(&lfs, &file, "exhaustion1", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfs_size_t size = strlen("blahblahblahblah"); + size = strlen("blahblahblahblah"); memcpy(buffer, "blahblahblahblah", size); for (lfs_size_t i = 0; i < ((cfg.block_count-2)/2)*(cfg.block_size-8); @@ -429,18 +503,22 @@ scripts/test.py << TEST lfs_file_write(&lfs, &file, buffer, size) => size; } lfs_file_close(&lfs, &file) => 0; -TEST -echo "--- Outdated lookahead and split dir test ---" -scripts/test.py << TEST - lfs_format(&lfs, &cfg) => 0; + lfs_unmount(&lfs) => 0; +''' +[[case]] # outdated lookahead and split dir test +define.LFS_BLOCK_SIZE = 512 +define.LFS_BLOCK_COUNT = 1024 +if = 'LFS_BLOCK_SIZE == 512 and LFS_BLOCK_COUNT == 1024' +code = ''' + lfs_format(&lfs, &cfg) => 0; lfs_mount(&lfs, &cfg) => 0; // fill completely with two files lfs_file_open(&lfs, &file, "exhaustion1", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfs_size_t size = strlen("blahblahblahblah"); + size = strlen("blahblahblahblah"); memcpy(buffer, "blahblahblahblah", size); for (lfs_size_t i = 0; i < ((cfg.block_count-2)/2)*(cfg.block_size-8); @@ -487,8 +565,4 @@ scripts/test.py << TEST lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; -TEST - -fi - -scripts/results.py +''' diff --git a/tests/test_attrs.sh b/tests/test_attrs.toml index 612cae1..db8d0c7 100755..100644 --- a/tests/test_attrs.sh +++ b/tests/test_attrs.toml @@ -1,25 +1,13 @@ -#!/bin/bash -set -eu -export TEST_FILE=$0 -trap 'export TEST_LINE=$LINENO' DEBUG - -echo "=== Attr tests ===" -rm -rf blocks -scripts/test.py << TEST +[[case]] # set/get attribute +code = ''' lfs_format(&lfs, &cfg) => 0; - lfs_mount(&lfs, &cfg) => 0; lfs_mkdir(&lfs, "hello") => 0; - lfs_file_open(&lfs, &file, "hello/hello", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfs_file_write(&lfs, &file, "hello", strlen("hello")) - => strlen("hello"); + lfs_file_open(&lfs, &file, "hello/hello", LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "hello", strlen("hello")) => strlen("hello"); lfs_file_close(&lfs, &file); lfs_unmount(&lfs) => 0; -TEST -echo "--- Set/get attribute ---" -scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; memset(buffer, 0, sizeof(buffer)); lfs_setattr(&lfs, "hello", 'A', "aaaa", 4) => 0; @@ -71,8 +59,7 @@ scripts/test.py << TEST lfs_getattr(&lfs, "hello", 'C', buffer+10, 5) => 5; lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST + lfs_mount(&lfs, &cfg) => 0; memset(buffer, 0, sizeof(buffer)); lfs_getattr(&lfs, "hello", 'A', buffer, 4) => 4; @@ -87,10 +74,18 @@ scripts/test.py << TEST memcmp(buffer, "hello", strlen("hello")) => 0; lfs_file_close(&lfs, &file); lfs_unmount(&lfs) => 0; -TEST +''' + +[[case]] # set/get root attribute +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "hello") => 0; + lfs_file_open(&lfs, &file, "hello/hello", LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "hello", strlen("hello")) => strlen("hello"); + lfs_file_close(&lfs, &file); + lfs_unmount(&lfs) => 0; -echo "--- Set/get root attribute ---" -scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; memset(buffer, 0, sizeof(buffer)); lfs_setattr(&lfs, "/", 'A', "aaaa", 4) => 0; @@ -141,8 +136,7 @@ scripts/test.py << TEST lfs_getattr(&lfs, "/", 'B', buffer+4, 6) => 9; lfs_getattr(&lfs, "/", 'C', buffer+10, 5) => 5; lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST + lfs_mount(&lfs, &cfg) => 0; memset(buffer, 0, sizeof(buffer)); lfs_getattr(&lfs, "/", 'A', buffer, 4) => 4; @@ -157,10 +151,18 @@ scripts/test.py << TEST memcmp(buffer, "hello", strlen("hello")) => 0; lfs_file_close(&lfs, &file); lfs_unmount(&lfs) => 0; -TEST +''' + +[[case]] # set/get file attribute +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "hello") => 0; + lfs_file_open(&lfs, &file, "hello/hello", LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "hello", strlen("hello")) => strlen("hello"); + lfs_file_close(&lfs, &file); + lfs_unmount(&lfs) => 0; -echo "--- Set/get file attribute ---" -scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; memset(buffer, 0, sizeof(buffer)); struct lfs_attr attrs1[] = { @@ -235,18 +237,17 @@ scripts/test.py << TEST lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST + lfs_mount(&lfs, &cfg) => 0; memset(buffer, 0, sizeof(buffer)); - struct lfs_attr attrs2[] = { + struct lfs_attr attrs3[] = { {'A', buffer, 4}, {'B', buffer+4, 9}, {'C', buffer+13, 5}, }; - struct lfs_file_config cfg2 = {.attrs=attrs2, .attr_count=3}; + struct lfs_file_config cfg3 = {.attrs=attrs3, .attr_count=3}; - lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg2) => 0; + lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg3) => 0; lfs_file_close(&lfs, &file) => 0; memcmp(buffer, "aaaa", 4) => 0; memcmp(buffer+4, "fffffffff", 9) => 0; @@ -257,11 +258,22 @@ scripts/test.py << TEST memcmp(buffer, "hello", strlen("hello")) => 0; lfs_file_close(&lfs, &file); lfs_unmount(&lfs) => 0; -TEST +''' -echo "--- Deferred file attributes ---" -scripts/test.py << TEST +[[case]] # deferred file attributes +code = ''' + lfs_format(&lfs, &cfg) => 0; lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "hello") => 0; + lfs_file_open(&lfs, &file, "hello/hello", LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "hello", strlen("hello")) => strlen("hello"); + lfs_file_close(&lfs, &file); + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_setattr(&lfs, "hello/hello", 'B', "fffffffff", 9) => 0; + lfs_setattr(&lfs, "hello/hello", 'C', "ccccc", 5) => 0; + memset(buffer, 0, sizeof(buffer)); struct lfs_attr attrs1[] = { {'B', "gggg", 4}, @@ -289,6 +301,4 @@ scripts/test.py << TEST lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; -TEST - -scripts/results.py +''' diff --git a/tests/test_badblocks.toml b/tests/test_badblocks.toml new file mode 100644 index 0000000..7969d43 --- /dev/null +++ b/tests/test_badblocks.toml @@ -0,0 +1,351 @@ +[[case]] # single bad blocks +define.LFS_ERASE_CYCLES = 0xffffffff +define.LFS_BADBLOCK_BEHAVIOR = 'LFS_TESTBD_BADBLOCK_NOPROG' +define.NAMEMULT = 64 +define.FILEMULT = 1 +code = ''' + for (lfs_block_t badblock = 2; badblock < LFS_BLOCK_COUNT; badblock++) { + lfs_testbd_setwear(&cfg, badblock-1, 0) => 0; + lfs_testbd_setwear(&cfg, badblock, 0xffffffff) => 0; + + lfs_format(&lfs, &cfg) => 0; + + lfs_mount(&lfs, &cfg) => 0; + for (int i = 1; i < 10; i++) { + for (int j = 0; j < NAMEMULT; j++) { + buffer[j] = '0'+i; + } + buffer[NAMEMULT] = '\0'; + lfs_mkdir(&lfs, (char*)buffer) => 0; + + buffer[NAMEMULT] = '/'; + for (int j = 0; j < NAMEMULT; j++) { + buffer[j+NAMEMULT+1] = '0'+i; + } + buffer[2*NAMEMULT+1] = '\0'; + lfs_file_open(&lfs, &file, (char*)buffer, + LFS_O_WRONLY | LFS_O_CREAT) => 0; + + size = NAMEMULT; + for (int j = 0; j < i*FILEMULT; j++) { + 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 i = 1; i < 10; i++) { + for (int j = 0; j < NAMEMULT; j++) { + buffer[j] = '0'+i; + } + buffer[NAMEMULT] = '\0'; + lfs_stat(&lfs, (char*)buffer, &info) => 0; + info.type => LFS_TYPE_DIR; + + buffer[NAMEMULT] = '/'; + for (int j = 0; j < NAMEMULT; j++) { + buffer[j+NAMEMULT+1] = '0'+i; + } + buffer[2*NAMEMULT+1] = '\0'; + lfs_file_open(&lfs, &file, (char*)buffer, LFS_O_RDONLY) => 0; + + size = NAMEMULT; + for (int j = 0; j < i*FILEMULT; j++) { + uint8_t rbuffer[1024]; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(buffer, rbuffer, size) => 0; + } + + lfs_file_close(&lfs, &file) => 0; + } + lfs_unmount(&lfs) => 0; + } +''' + +[[case]] # single persistent blocks (can't erase) +define.LFS_ERASE_CYCLES = 0xffffffff +define.LFS_BADBLOCK_BEHAVIOR = 'LFS_TESTBD_BADBLOCK_NOERASE' +define.NAMEMULT = 64 +define.FILEMULT = 1 +code = ''' + for (lfs_block_t badblock = 2; badblock < LFS_BLOCK_COUNT; badblock++) { + lfs_testbd_setwear(&cfg, badblock-1, 0) => 0; + lfs_testbd_setwear(&cfg, badblock, 0xffffffff) => 0; + + lfs_format(&lfs, &cfg) => 0; + + lfs_mount(&lfs, &cfg) => 0; + for (int i = 1; i < 10; i++) { + for (int j = 0; j < NAMEMULT; j++) { + buffer[j] = '0'+i; + } + buffer[NAMEMULT] = '\0'; + lfs_mkdir(&lfs, (char*)buffer) => 0; + + buffer[NAMEMULT] = '/'; + for (int j = 0; j < NAMEMULT; j++) { + buffer[j+NAMEMULT+1] = '0'+i; + } + buffer[2*NAMEMULT+1] = '\0'; + lfs_file_open(&lfs, &file, (char*)buffer, + LFS_O_WRONLY | LFS_O_CREAT) => 0; + + size = NAMEMULT; + for (int j = 0; j < i*FILEMULT; j++) { + 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 i = 1; i < 10; i++) { + for (int j = 0; j < NAMEMULT; j++) { + buffer[j] = '0'+i; + } + buffer[NAMEMULT] = '\0'; + lfs_stat(&lfs, (char*)buffer, &info) => 0; + info.type => LFS_TYPE_DIR; + + buffer[NAMEMULT] = '/'; + for (int j = 0; j < NAMEMULT; j++) { + buffer[j+NAMEMULT+1] = '0'+i; + } + buffer[2*NAMEMULT+1] = '\0'; + lfs_file_open(&lfs, &file, (char*)buffer, LFS_O_RDONLY) => 0; + + size = NAMEMULT; + for (int j = 0; j < i*FILEMULT; j++) { + uint8_t rbuffer[1024]; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(buffer, rbuffer, size) => 0; + } + + lfs_file_close(&lfs, &file) => 0; + } + lfs_unmount(&lfs) => 0; + } +''' + +[[case]] # single unreadable blocks (can't read) +define.LFS_ERASE_CYCLES = 0xffffffff +define.LFS_BADBLOCK_BEHAVIOR = 'LFS_TESTBD_BADBLOCK_NOREAD' +define.NAMEMULT = 64 +define.FILEMULT = 1 +code = ''' + for (lfs_block_t badblock = 2; badblock < LFS_BLOCK_COUNT/2; badblock++) { + lfs_testbd_setwear(&cfg, badblock-1, 0) => 0; + lfs_testbd_setwear(&cfg, badblock, 0xffffffff) => 0; + + lfs_format(&lfs, &cfg) => 0; + + lfs_mount(&lfs, &cfg) => 0; + for (int i = 1; i < 10; i++) { + for (int j = 0; j < NAMEMULT; j++) { + buffer[j] = '0'+i; + } + buffer[NAMEMULT] = '\0'; + lfs_mkdir(&lfs, (char*)buffer) => 0; + + buffer[NAMEMULT] = '/'; + for (int j = 0; j < NAMEMULT; j++) { + buffer[j+NAMEMULT+1] = '0'+i; + } + buffer[2*NAMEMULT+1] = '\0'; + lfs_file_open(&lfs, &file, (char*)buffer, + LFS_O_WRONLY | LFS_O_CREAT) => 0; + + size = NAMEMULT; + for (int j = 0; j < i*FILEMULT; j++) { + 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 i = 1; i < 10; i++) { + for (int j = 0; j < NAMEMULT; j++) { + buffer[j] = '0'+i; + } + buffer[NAMEMULT] = '\0'; + lfs_stat(&lfs, (char*)buffer, &info) => 0; + info.type => LFS_TYPE_DIR; + + buffer[NAMEMULT] = '/'; + for (int j = 0; j < NAMEMULT; j++) { + buffer[j+NAMEMULT+1] = '0'+i; + } + buffer[2*NAMEMULT+1] = '\0'; + lfs_file_open(&lfs, &file, (char*)buffer, LFS_O_RDONLY) => 0; + + size = NAMEMULT; + for (int j = 0; j < i*FILEMULT; j++) { + uint8_t rbuffer[1024]; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(buffer, rbuffer, size) => 0; + } + + lfs_file_close(&lfs, &file) => 0; + } + lfs_unmount(&lfs) => 0; + } +''' + +[[case]] # region corruption (causes cascading failures) +define.LFS_ERASE_CYCLES = 0xffffffff +define.LFS_BADBLOCK_BEHAVIOR = [ + 'LFS_TESTBD_BADBLOCK_NOPROG', + 'LFS_TESTBD_BADBLOCK_NOERASE', + 'LFS_TESTBD_BADBLOCK_NOREAD', +] +define.NAMEMULT = 64 +define.FILEMULT = 1 +code = ''' + for (lfs_block_t i = 0; i < (LFS_BLOCK_COUNT-2)/2; i++) { + lfs_testbd_setwear(&cfg, i+2, 0xffffffff) => 0; + } + + lfs_format(&lfs, &cfg) => 0; + + lfs_mount(&lfs, &cfg) => 0; + for (int i = 1; i < 10; i++) { + for (int j = 0; j < NAMEMULT; j++) { + buffer[j] = '0'+i; + } + buffer[NAMEMULT] = '\0'; + lfs_mkdir(&lfs, (char*)buffer) => 0; + + buffer[NAMEMULT] = '/'; + for (int j = 0; j < NAMEMULT; j++) { + buffer[j+NAMEMULT+1] = '0'+i; + } + buffer[2*NAMEMULT+1] = '\0'; + lfs_file_open(&lfs, &file, (char*)buffer, + LFS_O_WRONLY | LFS_O_CREAT) => 0; + + size = NAMEMULT; + for (int j = 0; j < i*FILEMULT; j++) { + 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 i = 1; i < 10; i++) { + for (int j = 0; j < NAMEMULT; j++) { + buffer[j] = '0'+i; + } + buffer[NAMEMULT] = '\0'; + lfs_stat(&lfs, (char*)buffer, &info) => 0; + info.type => LFS_TYPE_DIR; + + buffer[NAMEMULT] = '/'; + for (int j = 0; j < NAMEMULT; j++) { + buffer[j+NAMEMULT+1] = '0'+i; + } + buffer[2*NAMEMULT+1] = '\0'; + lfs_file_open(&lfs, &file, (char*)buffer, LFS_O_RDONLY) => 0; + + size = NAMEMULT; + for (int j = 0; j < i*FILEMULT; j++) { + uint8_t rbuffer[1024]; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(buffer, rbuffer, size) => 0; + } + + lfs_file_close(&lfs, &file) => 0; + } + lfs_unmount(&lfs) => 0; +''' + +[[case]] # alternating corruption (causes cascading failures) +define.LFS_ERASE_CYCLES = 0xffffffff +define.LFS_BADBLOCK_BEHAVIOR = [ + 'LFS_TESTBD_BADBLOCK_NOPROG', + 'LFS_TESTBD_BADBLOCK_NOERASE', + 'LFS_TESTBD_BADBLOCK_NOREAD', +] +define.NAMEMULT = 64 +define.FILEMULT = 1 +code = ''' + for (lfs_block_t i = 0; i < (LFS_BLOCK_COUNT-2)/2; i++) { + lfs_testbd_setwear(&cfg, (2*i) + 2, 0xffffffff) => 0; + } + + lfs_format(&lfs, &cfg) => 0; + + lfs_mount(&lfs, &cfg) => 0; + for (int i = 1; i < 10; i++) { + for (int j = 0; j < NAMEMULT; j++) { + buffer[j] = '0'+i; + } + buffer[NAMEMULT] = '\0'; + lfs_mkdir(&lfs, (char*)buffer) => 0; + + buffer[NAMEMULT] = '/'; + for (int j = 0; j < NAMEMULT; j++) { + buffer[j+NAMEMULT+1] = '0'+i; + } + buffer[2*NAMEMULT+1] = '\0'; + lfs_file_open(&lfs, &file, (char*)buffer, + LFS_O_WRONLY | LFS_O_CREAT) => 0; + + size = NAMEMULT; + for (int j = 0; j < i*FILEMULT; j++) { + 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 i = 1; i < 10; i++) { + for (int j = 0; j < NAMEMULT; j++) { + buffer[j] = '0'+i; + } + buffer[NAMEMULT] = '\0'; + lfs_stat(&lfs, (char*)buffer, &info) => 0; + info.type => LFS_TYPE_DIR; + + buffer[NAMEMULT] = '/'; + for (int j = 0; j < NAMEMULT; j++) { + buffer[j+NAMEMULT+1] = '0'+i; + } + buffer[2*NAMEMULT+1] = '\0'; + lfs_file_open(&lfs, &file, (char*)buffer, LFS_O_RDONLY) => 0; + + size = NAMEMULT; + for (int j = 0; j < i*FILEMULT; j++) { + uint8_t rbuffer[1024]; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(buffer, rbuffer, size) => 0; + } + + lfs_file_close(&lfs, &file) => 0; + } + lfs_unmount(&lfs) => 0; +''' + +# other corner cases +[[case]] # bad superblocks (corrupt 1 or 0) +define.LFS_ERASE_CYCLES = 0xffffffff +define.LFS_BADBLOCK_BEHAVIOR = [ + 'LFS_TESTBD_BADBLOCK_NOPROG', + 'LFS_TESTBD_BADBLOCK_NOERASE', + 'LFS_TESTBD_BADBLOCK_NOREAD', +] +code = ''' + lfs_testbd_setwear(&cfg, 0, 0xffffffff) => 0; + lfs_testbd_setwear(&cfg, 1, 0xffffffff) => 0; + + lfs_format(&lfs, &cfg) => LFS_ERR_NOSPC; + lfs_mount(&lfs, &cfg) => LFS_ERR_CORRUPT; +''' diff --git a/tests/test_corrupt.sh b/tests/test_corrupt.sh deleted file mode 100755 index 3001522..0000000 --- a/tests/test_corrupt.sh +++ /dev/null @@ -1,120 +0,0 @@ -#!/bin/bash -set -eu -export TEST_FILE=$0 -trap 'export TEST_LINE=$LINENO' DEBUG - -echo "=== Corrupt tests ===" - -NAMEMULT=64 -FILEMULT=1 - -lfs_mktree() { -scripts/test.py ${1:-} << TEST - lfs_format(&lfs, &cfg) => 0; - - lfs_mount(&lfs, &cfg) => 0; - for (int i = 1; i < 10; i++) { - for (int j = 0; j < $NAMEMULT; j++) { - buffer[j] = '0'+i; - } - buffer[$NAMEMULT] = '\0'; - lfs_mkdir(&lfs, (char*)buffer) => 0; - - buffer[$NAMEMULT] = '/'; - for (int j = 0; j < $NAMEMULT; j++) { - buffer[j+$NAMEMULT+1] = '0'+i; - } - buffer[2*$NAMEMULT+1] = '\0'; - lfs_file_open(&lfs, &file, (char*)buffer, - LFS_O_WRONLY | LFS_O_CREAT) => 0; - - lfs_size_t size = $NAMEMULT; - for (int j = 0; j < i*$FILEMULT; j++) { - lfs_file_write(&lfs, &file, buffer, size) => size; - } - - lfs_file_close(&lfs, &file) => 0; - } - lfs_unmount(&lfs) => 0; -TEST -} - -lfs_chktree() { -scripts/test.py ${1:-} << TEST - lfs_mount(&lfs, &cfg) => 0; - for (int i = 1; i < 10; i++) { - for (int j = 0; j < $NAMEMULT; j++) { - buffer[j] = '0'+i; - } - buffer[$NAMEMULT] = '\0'; - lfs_stat(&lfs, (char*)buffer, &info) => 0; - info.type => LFS_TYPE_DIR; - - buffer[$NAMEMULT] = '/'; - for (int j = 0; j < $NAMEMULT; j++) { - buffer[j+$NAMEMULT+1] = '0'+i; - } - buffer[2*$NAMEMULT+1] = '\0'; - lfs_file_open(&lfs, &file, (char*)buffer, LFS_O_RDONLY) => 0; - - lfs_size_t size = $NAMEMULT; - for (int j = 0; j < i*$FILEMULT; j++) { - uint8_t rbuffer[1024]; - lfs_file_read(&lfs, &file, rbuffer, size) => size; - memcmp(buffer, rbuffer, size) => 0; - } - - lfs_file_close(&lfs, &file) => 0; - } - lfs_unmount(&lfs) => 0; -TEST -} - -echo "--- Sanity check ---" -rm -rf blocks -lfs_mktree -lfs_chktree -BLOCKS="$(ls blocks | grep -vw '[01]')" - -echo "--- Block corruption ---" -for b in $BLOCKS -do - rm -rf blocks - mkdir blocks - ln -s /dev/zero blocks/$b - lfs_mktree - lfs_chktree -done - -echo "--- Block persistance ---" -for b in $BLOCKS -do - rm -rf blocks - mkdir blocks - lfs_mktree - chmod a-w blocks/$b || true - lfs_mktree - lfs_chktree -done - -echo "--- Big region corruption ---" -rm -rf blocks -mkdir blocks -for i in {2..512} -do - ln -s /dev/zero blocks/$(printf '%x' $i) -done -lfs_mktree -lfs_chktree - -echo "--- Alternating corruption ---" -rm -rf blocks -mkdir blocks -for i in {2..1024..2} -do - ln -s /dev/zero blocks/$(printf '%x' $i) -done -lfs_mktree -lfs_chktree - -scripts/results.py diff --git a/tests/test_dirs.sh b/tests/test_dirs.sh deleted file mode 100755 index 0125bfd..0000000 --- a/tests/test_dirs.sh +++ /dev/null @@ -1,489 +0,0 @@ -#!/bin/bash -set -eu -export TEST_FILE=$0 -trap 'export TEST_LINE=$LINENO' DEBUG - -echo "=== Directory tests ===" - -LARGESIZE=128 - -rm -rf blocks -scripts/test.py << TEST - lfs_format(&lfs, &cfg) => 0; -TEST - -echo "--- Root directory ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir, "/") => 0; - lfs_dir_close(&lfs, &dir) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Directory creation ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_mkdir(&lfs, "potato") => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- File creation ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file, "burito", LFS_O_CREAT | LFS_O_WRONLY) => 0; - lfs_file_close(&lfs, &file) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Directory iteration ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir, "/") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "burito") => 0; - info.type => LFS_TYPE_REG; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "potato") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Directory failures ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_mkdir(&lfs, "potato") => LFS_ERR_EXIST; - lfs_dir_open(&lfs, &dir, "tomato") => LFS_ERR_NOENT; - lfs_dir_open(&lfs, &dir, "burito") => LFS_ERR_NOTDIR; - lfs_file_open(&lfs, &file, "tomato", LFS_O_RDONLY) => LFS_ERR_NOENT; - lfs_file_open(&lfs, &file, "potato", LFS_O_RDONLY) => LFS_ERR_ISDIR; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Nested directories ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_mkdir(&lfs, "potato/baked") => 0; - lfs_mkdir(&lfs, "potato/sweet") => 0; - lfs_mkdir(&lfs, "potato/fried") => 0; - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir, "potato") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "baked") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "fried") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "sweet") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Multi-block directory ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_mkdir(&lfs, "cactus") => 0; - for (int i = 0; i < $LARGESIZE; i++) { - sprintf(path, "cactus/test%03d", i); - lfs_mkdir(&lfs, path) => 0; - } - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir, "cactus") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - info.type => LFS_TYPE_DIR; - for (int i = 0; i < $LARGESIZE; i++) { - sprintf(path, "test%03d", i); - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, path) => 0; - info.type => LFS_TYPE_DIR; - } - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Directory remove ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_remove(&lfs, "potato") => LFS_ERR_NOTEMPTY; - lfs_remove(&lfs, "potato/sweet") => 0; - lfs_remove(&lfs, "potato/baked") => 0; - lfs_remove(&lfs, "potato/fried") => 0; - - lfs_dir_open(&lfs, &dir, "potato") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - - lfs_remove(&lfs, "potato") => 0; - - lfs_dir_open(&lfs, &dir, "/") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "burito") => 0; - info.type => LFS_TYPE_REG; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "cactus") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir, "/") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "burito") => 0; - info.type => LFS_TYPE_REG; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "cactus") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Directory rename ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_mkdir(&lfs, "coldpotato") => 0; - lfs_mkdir(&lfs, "coldpotato/baked") => 0; - lfs_mkdir(&lfs, "coldpotato/sweet") => 0; - lfs_mkdir(&lfs, "coldpotato/fried") => 0; - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_rename(&lfs, "coldpotato", "hotpotato") => 0; - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir, "hotpotato") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "baked") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "fried") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "sweet") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_mkdir(&lfs, "warmpotato") => 0; - lfs_mkdir(&lfs, "warmpotato/mushy") => 0; - lfs_rename(&lfs, "hotpotato", "warmpotato") => LFS_ERR_NOTEMPTY; - - lfs_remove(&lfs, "warmpotato/mushy") => 0; - lfs_rename(&lfs, "hotpotato", "warmpotato") => 0; - - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir, "warmpotato") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "baked") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "fried") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "sweet") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_mkdir(&lfs, "coldpotato") => 0; - lfs_rename(&lfs, "warmpotato/baked", "coldpotato/baked") => 0; - lfs_rename(&lfs, "warmpotato/sweet", "coldpotato/sweet") => 0; - lfs_rename(&lfs, "warmpotato/fried", "coldpotato/fried") => 0; - lfs_remove(&lfs, "coldpotato") => LFS_ERR_NOTEMPTY; - lfs_remove(&lfs, "warmpotato") => 0; - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir, "coldpotato") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "baked") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "fried") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "sweet") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Recursive remove ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_remove(&lfs, "coldpotato") => LFS_ERR_NOTEMPTY; - - lfs_dir_open(&lfs, &dir, "coldpotato") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - lfs_dir_read(&lfs, &dir, &info) => 1; - - while (true) { - int err = lfs_dir_read(&lfs, &dir, &info); - err >= 0 => 1; - if (err == 0) { - break; - } - - strcpy(path, "coldpotato/"); - strcat(path, info.name); - lfs_remove(&lfs, path) => 0; - } - - lfs_remove(&lfs, "coldpotato") => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir, "/") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "burito") => 0; - info.type => LFS_TYPE_REG; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "cactus") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Multi-block rename ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - for (int i = 0; i < $LARGESIZE; i++) { - char oldpath[1024]; - char newpath[1024]; - sprintf(oldpath, "cactus/test%03d", i); - sprintf(newpath, "cactus/tedd%03d", i); - lfs_rename(&lfs, oldpath, newpath) => 0; - } - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir, "cactus") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - info.type => LFS_TYPE_DIR; - for (int i = 0; i < $LARGESIZE; i++) { - sprintf(path, "tedd%03d", i); - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, path) => 0; - info.type => LFS_TYPE_DIR; - } - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Multi-block remove ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_remove(&lfs, "cactus") => LFS_ERR_NOTEMPTY; - - for (int i = 0; i < $LARGESIZE; i++) { - sprintf(path, "cactus/tedd%03d", i); - lfs_remove(&lfs, path) => 0; - } - - lfs_remove(&lfs, "cactus") => 0; - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir, "/") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "burito") => 0; - info.type => LFS_TYPE_REG; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Multi-block directory with files ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_mkdir(&lfs, "prickly-pear") => 0; - for (int i = 0; i < $LARGESIZE; i++) { - sprintf(path, "prickly-pear/test%03d", i); - lfs_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfs_size_t size = 6; - memcpy(buffer, "Hello", size); - lfs_file_write(&lfs, &file, buffer, size) => size; - lfs_file_close(&lfs, &file) => 0; - } - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir, "prickly-pear") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - info.type => LFS_TYPE_DIR; - for (int i = 0; i < $LARGESIZE; i++) { - sprintf(path, "test%03d", i); - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, path) => 0; - info.type => LFS_TYPE_REG; - info.size => 6; - } - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Multi-block rename with files ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - for (int i = 0; i < $LARGESIZE; i++) { - char oldpath[1024]; - char newpath[1024]; - sprintf(oldpath, "prickly-pear/test%03d", i); - sprintf(newpath, "prickly-pear/tedd%03d", i); - lfs_rename(&lfs, oldpath, newpath) => 0; - } - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir, "prickly-pear") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - info.type => LFS_TYPE_DIR; - for (int i = 0; i < $LARGESIZE; i++) { - sprintf(path, "tedd%03d", i); - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, path) => 0; - info.type => LFS_TYPE_REG; - info.size => 6; - } - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Multi-block remove with files ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_remove(&lfs, "prickly-pear") => LFS_ERR_NOTEMPTY; - - for (int i = 0; i < $LARGESIZE; i++) { - sprintf(path, "prickly-pear/tedd%03d", i); - lfs_remove(&lfs, path) => 0; - } - - lfs_remove(&lfs, "prickly-pear") => 0; - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir, "/") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "burito") => 0; - info.type => LFS_TYPE_REG; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - lfs_unmount(&lfs) => 0; -TEST - -scripts/results.py diff --git a/tests/test_dirs.toml b/tests/test_dirs.toml new file mode 100644 index 0000000..712f24f --- /dev/null +++ b/tests/test_dirs.toml @@ -0,0 +1,838 @@ +[[case]] # root +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, ".") == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, "..") == 0); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # many directory creation +define.N = 'range(0, 100, 3)' +code = ''' + lfs_format(&lfs, &cfg) => 0; + + lfs_mount(&lfs, &cfg) => 0; + for (int i = 0; i < N; i++) { + sprintf(path, "dir%03d", i); + lfs_mkdir(&lfs, path) => 0; + } + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, ".") == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, "..") == 0); + for (int i = 0; i < N; i++) { + sprintf(path, "dir%03d", i); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, path) == 0); + } + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # many directory removal +define.N = 'range(3, 100, 11)' +code = ''' + lfs_format(&lfs, &cfg) => 0; + + lfs_mount(&lfs, &cfg) => 0; + for (int i = 0; i < N; i++) { + sprintf(path, "removeme%03d", i); + lfs_mkdir(&lfs, path) => 0; + } + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, ".") == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, "..") == 0); + for (int i = 0; i < N; i++) { + sprintf(path, "removeme%03d", i); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, path) == 0); + } + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs); + + lfs_mount(&lfs, &cfg) => 0; + for (int i = 0; i < N; i++) { + sprintf(path, "removeme%03d", i); + lfs_remove(&lfs, path) => 0; + } + lfs_unmount(&lfs); + + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, ".") == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, "..") == 0); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # many directory rename +define.N = 'range(3, 100, 11)' +code = ''' + lfs_format(&lfs, &cfg) => 0; + + lfs_mount(&lfs, &cfg) => 0; + for (int i = 0; i < N; i++) { + sprintf(path, "test%03d", i); + lfs_mkdir(&lfs, path) => 0; + } + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, ".") == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, "..") == 0); + for (int i = 0; i < N; i++) { + sprintf(path, "test%03d", i); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, path) == 0); + } + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs); + + lfs_mount(&lfs, &cfg) => 0; + for (int i = 0; i < N; i++) { + char oldpath[128]; + char newpath[128]; + sprintf(oldpath, "test%03d", i); + sprintf(newpath, "tedd%03d", i); + lfs_rename(&lfs, oldpath, newpath) => 0; + } + lfs_unmount(&lfs); + + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, ".") == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, "..") == 0); + for (int i = 0; i < N; i++) { + sprintf(path, "tedd%03d", i); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, path) == 0); + } + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs); +''' + +[[case]] # reentrant many directory creation/rename/removal +define.N = [5, 25] +reentrant = true +code = ''' + err = lfs_mount(&lfs, &cfg); + if (err) { + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + } + + for (int i = 0; i < N; i++) { + sprintf(path, "hi%03d", i); + err = lfs_mkdir(&lfs, path); + assert(err == 0 || err == LFS_ERR_EXIST); + } + + for (int i = 0; i < N; i++) { + sprintf(path, "hello%03d", i); + err = lfs_remove(&lfs, path); + assert(err == 0 || err == LFS_ERR_NOENT); + } + + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, ".") == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, "..") == 0); + for (int i = 0; i < N; i++) { + sprintf(path, "hi%03d", i); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, path) == 0); + } + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + for (int i = 0; i < N; i++) { + char oldpath[128]; + char newpath[128]; + sprintf(oldpath, "hi%03d", i); + sprintf(newpath, "hello%03d", i); + // YES this can overwrite an existing newpath + lfs_rename(&lfs, oldpath, newpath) => 0; + } + + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, ".") == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, "..") == 0); + for (int i = 0; i < N; i++) { + sprintf(path, "hello%03d", i); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, path) == 0); + } + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + for (int i = 0; i < N; i++) { + sprintf(path, "hello%03d", i); + lfs_remove(&lfs, path) => 0; + } + + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, ".") == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, "..") == 0); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # file creation +define.N = 'range(3, 100, 11)' +code = ''' + lfs_format(&lfs, &cfg) => 0; + + lfs_mount(&lfs, &cfg) => 0; + for (int i = 0; i < N; i++) { + sprintf(path, "file%03d", i); + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs_file_close(&lfs, &file) => 0; + } + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, ".") == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, "..") == 0); + for (int i = 0; i < N; i++) { + sprintf(path, "file%03d", i); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_REG); + assert(strcmp(info.name, path) == 0); + } + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs); +''' + +[[case]] # file removal +define.N = 'range(0, 100, 3)' +code = ''' + lfs_format(&lfs, &cfg) => 0; + + lfs_mount(&lfs, &cfg) => 0; + for (int i = 0; i < N; i++) { + sprintf(path, "removeme%03d", i); + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs_file_close(&lfs, &file) => 0; + } + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, ".") == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, "..") == 0); + for (int i = 0; i < N; i++) { + sprintf(path, "removeme%03d", i); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_REG); + assert(strcmp(info.name, path) == 0); + } + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs); + + lfs_mount(&lfs, &cfg) => 0; + for (int i = 0; i < N; i++) { + sprintf(path, "removeme%03d", i); + lfs_remove(&lfs, path) => 0; + } + lfs_unmount(&lfs); + + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, ".") == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, "..") == 0); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # file rename +define.N = 'range(0, 100, 3)' +code = ''' + lfs_format(&lfs, &cfg) => 0; + + lfs_mount(&lfs, &cfg) => 0; + for (int i = 0; i < N; i++) { + sprintf(path, "test%03d", i); + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs_file_close(&lfs, &file) => 0; + } + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, ".") == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, "..") == 0); + for (int i = 0; i < N; i++) { + sprintf(path, "test%03d", i); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_REG); + assert(strcmp(info.name, path) == 0); + } + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs); + + lfs_mount(&lfs, &cfg) => 0; + for (int i = 0; i < N; i++) { + char oldpath[128]; + char newpath[128]; + sprintf(oldpath, "test%03d", i); + sprintf(newpath, "tedd%03d", i); + lfs_rename(&lfs, oldpath, newpath) => 0; + } + lfs_unmount(&lfs); + + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, ".") == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, "..") == 0); + for (int i = 0; i < N; i++) { + sprintf(path, "tedd%03d", i); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_REG); + assert(strcmp(info.name, path) == 0); + } + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs); +''' + +[[case]] # reentrant file creation/rename/removal +define.N = [5, 25] +reentrant = true +code = ''' + err = lfs_mount(&lfs, &cfg); + if (err) { + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + } + + for (int i = 0; i < N; i++) { + sprintf(path, "hi%03d", i); + lfs_file_open(&lfs, &file, path, LFS_O_CREAT | LFS_O_WRONLY) => 0; + lfs_file_close(&lfs, &file) => 0; + } + + for (int i = 0; i < N; i++) { + sprintf(path, "hello%03d", i); + err = lfs_remove(&lfs, path); + assert(err == 0 || err == LFS_ERR_NOENT); + } + + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, ".") == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, "..") == 0); + for (int i = 0; i < N; i++) { + sprintf(path, "hi%03d", i); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_REG); + assert(strcmp(info.name, path) == 0); + } + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + for (int i = 0; i < N; i++) { + char oldpath[128]; + char newpath[128]; + sprintf(oldpath, "hi%03d", i); + sprintf(newpath, "hello%03d", i); + // YES this can overwrite an existing newpath + lfs_rename(&lfs, oldpath, newpath) => 0; + } + + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, ".") == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, "..") == 0); + for (int i = 0; i < N; i++) { + sprintf(path, "hello%03d", i); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_REG); + assert(strcmp(info.name, path) == 0); + } + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + for (int i = 0; i < N; i++) { + sprintf(path, "hello%03d", i); + lfs_remove(&lfs, path) => 0; + } + + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, ".") == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, "..") == 0); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # nested directories +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "potato") => 0; + lfs_file_open(&lfs, &file, "burito", + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "potato/baked") => 0; + lfs_mkdir(&lfs, "potato/sweet") => 0; + lfs_mkdir(&lfs, "potato/fried") => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "potato") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + info.type => LFS_TYPE_DIR; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + info.type => LFS_TYPE_DIR; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "baked") == 0); + info.type => LFS_TYPE_DIR; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "fried") == 0); + info.type => LFS_TYPE_DIR; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "sweet") == 0); + info.type => LFS_TYPE_DIR; + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs) => 0; + + // try removing? + lfs_mount(&lfs, &cfg) => 0; + lfs_remove(&lfs, "potato") => LFS_ERR_NOTEMPTY; + lfs_unmount(&lfs) => 0; + + // try renaming? + lfs_mount(&lfs, &cfg) => 0; + lfs_rename(&lfs, "potato", "coldpotato") => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_rename(&lfs, "coldpotato", "warmpotato") => 0; + lfs_rename(&lfs, "warmpotato", "hotpotato") => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_remove(&lfs, "potato") => LFS_ERR_NOENT; + lfs_remove(&lfs, "coldpotato") => LFS_ERR_NOENT; + lfs_remove(&lfs, "warmpotato") => LFS_ERR_NOENT; + lfs_remove(&lfs, "hotpotato") => LFS_ERR_NOTEMPTY; + lfs_unmount(&lfs) => 0; + + // try cross-directory renaming + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "coldpotato") => 0; + lfs_rename(&lfs, "hotpotato/baked", "coldpotato/baked") => 0; + lfs_rename(&lfs, "coldpotato", "hotpotato") => LFS_ERR_NOTEMPTY; + lfs_remove(&lfs, "coldpotato") => LFS_ERR_NOTEMPTY; + lfs_remove(&lfs, "hotpotato") => LFS_ERR_NOTEMPTY; + lfs_rename(&lfs, "hotpotato/fried", "coldpotato/fried") => 0; + lfs_rename(&lfs, "coldpotato", "hotpotato") => LFS_ERR_NOTEMPTY; + lfs_remove(&lfs, "coldpotato") => LFS_ERR_NOTEMPTY; + lfs_remove(&lfs, "hotpotato") => LFS_ERR_NOTEMPTY; + lfs_rename(&lfs, "hotpotato/sweet", "coldpotato/sweet") => 0; + lfs_rename(&lfs, "coldpotato", "hotpotato") => 0; + lfs_remove(&lfs, "coldpotato") => LFS_ERR_NOENT; + lfs_remove(&lfs, "hotpotato") => LFS_ERR_NOTEMPTY; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "hotpotato") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + info.type => LFS_TYPE_DIR; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + info.type => LFS_TYPE_DIR; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "baked") == 0); + info.type => LFS_TYPE_DIR; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "fried") == 0); + info.type => LFS_TYPE_DIR; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "sweet") == 0); + info.type => LFS_TYPE_DIR; + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs) => 0; + + // final remove + lfs_mount(&lfs, &cfg) => 0; + lfs_remove(&lfs, "hotpotato") => LFS_ERR_NOTEMPTY; + lfs_remove(&lfs, "hotpotato/baked") => 0; + lfs_remove(&lfs, "hotpotato") => LFS_ERR_NOTEMPTY; + lfs_remove(&lfs, "hotpotato/fried") => 0; + lfs_remove(&lfs, "hotpotato") => LFS_ERR_NOTEMPTY; + lfs_remove(&lfs, "hotpotato/sweet") => 0; + lfs_remove(&lfs, "hotpotato") => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + info.type => LFS_TYPE_DIR; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + info.type => LFS_TYPE_DIR; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "burito") == 0); + info.type => LFS_TYPE_REG; + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # recursive remove +define.N = [10, 100] +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "prickly-pear") => 0; + for (int i = 0; i < N; i++) { + sprintf(path, "prickly-pear/cactus%03d", i); + lfs_mkdir(&lfs, path) => 0; + } + lfs_dir_open(&lfs, &dir, "prickly-pear") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, ".") == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, "..") == 0); + for (int i = 0; i < N; i++) { + sprintf(path, "cactus%03d", i); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, path) == 0); + } + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs); + + lfs_mount(&lfs, &cfg) => 0; + lfs_remove(&lfs, "prickly-pear") => LFS_ERR_NOTEMPTY; + + lfs_dir_open(&lfs, &dir, "prickly-pear") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, ".") == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, "..") == 0); + for (int i = 0; i < N; i++) { + sprintf(path, "cactus%03d", i); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, path) == 0); + sprintf(path, "prickly-pear/%s", info.name); + lfs_remove(&lfs, path) => 0; + } + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_remove(&lfs, "prickly-pear") => 0; + lfs_remove(&lfs, "prickly-pear") => LFS_ERR_NOENT; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_remove(&lfs, "prickly-pear") => LFS_ERR_NOENT; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # other error cases +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "potato") => 0; + lfs_file_open(&lfs, &file, "burito", + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + + lfs_mkdir(&lfs, "potato") => LFS_ERR_EXIST; + lfs_mkdir(&lfs, "burito") => LFS_ERR_EXIST; + lfs_file_open(&lfs, &file, "burito", + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs_file_open(&lfs, &file, "potato", + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs_dir_open(&lfs, &dir, "tomato") => LFS_ERR_NOENT; + lfs_dir_open(&lfs, &dir, "burito") => LFS_ERR_NOTDIR; + lfs_file_open(&lfs, &file, "tomato", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs_file_open(&lfs, &file, "potato", LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs_file_open(&lfs, &file, "tomato", LFS_O_WRONLY) => LFS_ERR_NOENT; + lfs_file_open(&lfs, &file, "potato", LFS_O_WRONLY) => LFS_ERR_ISDIR; + lfs_file_open(&lfs, &file, "potato", + LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + + lfs_mkdir(&lfs, "/") => LFS_ERR_EXIST; + lfs_file_open(&lfs, &file, "/", + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => LFS_ERR_EXIST; + lfs_file_open(&lfs, &file, "/", LFS_O_RDONLY) => LFS_ERR_ISDIR; + lfs_file_open(&lfs, &file, "/", LFS_O_WRONLY) => LFS_ERR_ISDIR; + lfs_file_open(&lfs, &file, "/", + LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; + + // check that errors did not corrupt directory + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, ".") == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, "..") == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_REG); + assert(strcmp(info.name, "burito") == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, "potato") == 0); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_unmount(&lfs) => 0; + + // or on disk + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, ".") == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, "..") == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_REG); + assert(strcmp(info.name, "burito") == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(info.type == LFS_TYPE_DIR); + assert(strcmp(info.name, "potato") == 0); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # directory seek +define.COUNT = [4, 128, 132] +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "hello") => 0; + for (int i = 0; i < COUNT; i++) { + sprintf(path, "hello/kitty%03d", i); + lfs_mkdir(&lfs, path) => 0; + } + lfs_unmount(&lfs) => 0; + + for (int j = 2; j < COUNT; j++) { + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "hello") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + + lfs_soff_t pos; + for (int i = 0; i < j; i++) { + sprintf(path, "kitty%03d", i); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, path) == 0); + assert(info.type == LFS_TYPE_DIR); + pos = lfs_dir_tell(&lfs, &dir); + assert(pos >= 0); + } + + lfs_dir_seek(&lfs, &dir, pos) => 0; + sprintf(path, "kitty%03d", j); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, path) == 0); + assert(info.type == LFS_TYPE_DIR); + + lfs_dir_rewind(&lfs, &dir) => 0; + sprintf(path, "kitty%03d", 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, path) == 0); + assert(info.type == LFS_TYPE_DIR); + + lfs_dir_seek(&lfs, &dir, pos) => 0; + sprintf(path, "kitty%03d", j); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, path) == 0); + assert(info.type == LFS_TYPE_DIR); + + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs) => 0; + } +''' + +[[case]] # root seek +define.COUNT = [4, 128, 132] +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + for (int i = 0; i < COUNT; i++) { + sprintf(path, "hi%03d", i); + lfs_mkdir(&lfs, path) => 0; + } + lfs_unmount(&lfs) => 0; + + for (int j = 2; j < COUNT; j++) { + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + + lfs_soff_t pos; + for (int i = 0; i < j; i++) { + sprintf(path, "hi%03d", i); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, path) == 0); + assert(info.type == LFS_TYPE_DIR); + pos = lfs_dir_tell(&lfs, &dir); + assert(pos >= 0); + } + + lfs_dir_seek(&lfs, &dir, pos) => 0; + sprintf(path, "hi%03d", j); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, path) == 0); + assert(info.type == LFS_TYPE_DIR); + + lfs_dir_rewind(&lfs, &dir) => 0; + sprintf(path, "hi%03d", 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, path) == 0); + assert(info.type == LFS_TYPE_DIR); + + lfs_dir_seek(&lfs, &dir, pos) => 0; + sprintf(path, "hi%03d", j); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, path) == 0); + assert(info.type == LFS_TYPE_DIR); + + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs) => 0; + } +''' + diff --git a/tests/test_entries.sh b/tests/test_entries.sh deleted file mode 100755 index 5075faf..0000000 --- a/tests/test_entries.sh +++ /dev/null @@ -1,251 +0,0 @@ -#!/bin/bash -set -eu -export TEST_FILE=$0 -trap 'export TEST_LINE=$LINENO' DEBUG - -echo "=== Entry tests ===" - -# Note: These tests are intended for 512 byte inline size at different -# inline sizes they should still pass, but won't be testing anything - -rm -rf blocks -function read_file { -cat << TEST - - size = $2; - lfs_file_open(&lfs, &file, "$1", LFS_O_RDONLY) => 0; - lfs_file_read(&lfs, &file, rbuffer, size) => size; - memcmp(rbuffer, wbuffer, size) => 0; - lfs_file_close(&lfs, &file) => 0; -TEST -} - -function write_file { -cat << TEST - - size = $2; - lfs_file_open(&lfs, &file, "$1", - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; - memset(wbuffer, 'c', size); - lfs_file_write(&lfs, &file, wbuffer, size) => size; - lfs_file_close(&lfs, &file) => 0; -TEST -} - -echo "--- Entry grow test ---" -scripts/test.py << TEST - lfs_format(&lfs, &cfg) => 0; - - uint8_t wbuffer[1024]; - uint8_t rbuffer[1024]; - lfs_size_t size; - - lfs_mount(&lfs, &cfg) => 0; - $(write_file "hi0" 20) - $(write_file "hi1" 20) - $(write_file "hi2" 20) - $(write_file "hi3" 20) - - $(read_file "hi1" 20) - $(write_file "hi1" 200) - - $(read_file "hi0" 20) - $(read_file "hi1" 200) - $(read_file "hi2" 20) - $(read_file "hi3" 20) - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Entry shrink test ---" -scripts/test.py << TEST - lfs_format(&lfs, &cfg) => 0; - - uint8_t wbuffer[1024]; - uint8_t rbuffer[1024]; - lfs_size_t size; - - lfs_mount(&lfs, &cfg) => 0; - $(write_file "hi0" 20) - $(write_file "hi1" 200) - $(write_file "hi2" 20) - $(write_file "hi3" 20) - - $(read_file "hi1" 200) - $(write_file "hi1" 20) - - $(read_file "hi0" 20) - $(read_file "hi1" 20) - $(read_file "hi2" 20) - $(read_file "hi3" 20) - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Entry spill test ---" -scripts/test.py << TEST - lfs_format(&lfs, &cfg) => 0; - - uint8_t wbuffer[1024]; - uint8_t rbuffer[1024]; - lfs_size_t size; - - lfs_mount(&lfs, &cfg) => 0; - $(write_file "hi0" 200) - $(write_file "hi1" 200) - $(write_file "hi2" 200) - $(write_file "hi3" 200) - - $(read_file "hi0" 200) - $(read_file "hi1" 200) - $(read_file "hi2" 200) - $(read_file "hi3" 200) - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Entry push spill test ---" -scripts/test.py << TEST - lfs_format(&lfs, &cfg) => 0; - - uint8_t wbuffer[1024]; - uint8_t rbuffer[1024]; - lfs_size_t size; - - lfs_mount(&lfs, &cfg) => 0; - $(write_file "hi0" 200) - $(write_file "hi1" 20) - $(write_file "hi2" 200) - $(write_file "hi3" 200) - - $(read_file "hi1" 20) - $(write_file "hi1" 200) - - $(read_file "hi0" 200) - $(read_file "hi1" 200) - $(read_file "hi2" 200) - $(read_file "hi3" 200) - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Entry push spill two test ---" -scripts/test.py << TEST - lfs_format(&lfs, &cfg) => 0; - - uint8_t wbuffer[1024]; - uint8_t rbuffer[1024]; - lfs_size_t size; - - lfs_mount(&lfs, &cfg) => 0; - $(write_file "hi0" 200) - $(write_file "hi1" 20) - $(write_file "hi2" 200) - $(write_file "hi3" 200) - $(write_file "hi4" 200) - - $(read_file "hi1" 20) - $(write_file "hi1" 200) - - $(read_file "hi0" 200) - $(read_file "hi1" 200) - $(read_file "hi2" 200) - $(read_file "hi3" 200) - $(read_file "hi4" 200) - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Entry drop test ---" -scripts/test.py << TEST - lfs_format(&lfs, &cfg) => 0; - - uint8_t wbuffer[1024]; - uint8_t rbuffer[1024]; - lfs_size_t size; - - lfs_mount(&lfs, &cfg) => 0; - $(write_file "hi0" 200) - $(write_file "hi1" 200) - $(write_file "hi2" 200) - $(write_file "hi3" 200) - - lfs_remove(&lfs, "hi1") => 0; - lfs_stat(&lfs, "hi1", &info) => LFS_ERR_NOENT; - $(read_file "hi0" 200) - $(read_file "hi2" 200) - $(read_file "hi3" 200) - - lfs_remove(&lfs, "hi2") => 0; - lfs_stat(&lfs, "hi2", &info) => LFS_ERR_NOENT; - $(read_file "hi0" 200) - $(read_file "hi3" 200) - - lfs_remove(&lfs, "hi3") => 0; - lfs_stat(&lfs, "hi3", &info) => LFS_ERR_NOENT; - $(read_file "hi0" 200) - - lfs_remove(&lfs, "hi0") => 0; - lfs_stat(&lfs, "hi0", &info) => LFS_ERR_NOENT; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Create too big ---" -scripts/test.py << TEST - lfs_format(&lfs, &cfg) => 0; - - lfs_mount(&lfs, &cfg) => 0; - memset(path, 'm', 200); - path[200] = '\0'; - - lfs_size_t size = 400; - lfs_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; - uint8_t wbuffer[1024]; - memset(wbuffer, 'c', size); - lfs_file_write(&lfs, &file, wbuffer, size) => size; - lfs_file_close(&lfs, &file) => 0; - - size = 400; - lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; - uint8_t rbuffer[1024]; - lfs_file_read(&lfs, &file, rbuffer, size) => size; - memcmp(rbuffer, wbuffer, size) => 0; - lfs_file_close(&lfs, &file) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Resize too big ---" -scripts/test.py << TEST - lfs_format(&lfs, &cfg) => 0; - - lfs_mount(&lfs, &cfg) => 0; - memset(path, 'm', 200); - path[200] = '\0'; - - lfs_size_t size = 40; - lfs_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; - uint8_t wbuffer[1024]; - memset(wbuffer, 'c', size); - lfs_file_write(&lfs, &file, wbuffer, size) => size; - lfs_file_close(&lfs, &file) => 0; - - size = 40; - lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; - uint8_t rbuffer[1024]; - lfs_file_read(&lfs, &file, rbuffer, size) => size; - memcmp(rbuffer, wbuffer, size) => 0; - lfs_file_close(&lfs, &file) => 0; - - size = 400; - lfs_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; - memset(wbuffer, 'c', size); - lfs_file_write(&lfs, &file, wbuffer, size) => size; - lfs_file_close(&lfs, &file) => 0; - - size = 400; - lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; - lfs_file_read(&lfs, &file, rbuffer, size) => size; - memcmp(rbuffer, wbuffer, size) => 0; - lfs_file_close(&lfs, &file) => 0; - lfs_unmount(&lfs) => 0; -TEST - -scripts/results.py diff --git a/tests/test_entries.toml b/tests/test_entries.toml new file mode 100644 index 0000000..cbbf6a1 --- /dev/null +++ b/tests/test_entries.toml @@ -0,0 +1,611 @@ +# These tests are for some specific corner cases with neighboring inline files. +# Note that these tests are intended for 512 byte inline sizes. They should +# still pass with other inline sizes but wouldn't be testing anything. + +define.LFS_CACHE_SIZE = 512 +if = 'LFS_CACHE_SIZE == 512' + +[[case]] # entry grow test +code = ''' + uint8_t wbuffer[1024]; + uint8_t rbuffer[1024]; + + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + + // write hi0 20 + sprintf(path, "hi0"); size = 20; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + // write hi1 20 + sprintf(path, "hi1"); size = 20; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + // write hi2 20 + sprintf(path, "hi2"); size = 20; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + // write hi3 20 + sprintf(path, "hi3"); size = 20; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + + // read hi1 20 + sprintf(path, "hi1"); size = 20; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + // write hi1 200 + sprintf(path, "hi1"); size = 200; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + + // read hi0 20 + sprintf(path, "hi0"); size = 20; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + // read hi1 200 + sprintf(path, "hi1"); size = 200; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + // read hi2 20 + sprintf(path, "hi2"); size = 20; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + // read hi3 20 + sprintf(path, "hi3"); size = 20; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + + lfs_unmount(&lfs) => 0; +''' + +[[case]] # entry shrink test +code = ''' + uint8_t wbuffer[1024]; + uint8_t rbuffer[1024]; + + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + + // write hi0 20 + sprintf(path, "hi0"); size = 20; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + // write hi1 200 + sprintf(path, "hi1"); size = 200; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + // write hi2 20 + sprintf(path, "hi2"); size = 20; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + // write hi3 20 + sprintf(path, "hi3"); size = 20; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + + // read hi1 200 + sprintf(path, "hi1"); size = 200; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + // write hi1 20 + sprintf(path, "hi1"); size = 20; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + + // read hi0 20 + sprintf(path, "hi0"); size = 20; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + // read hi1 20 + sprintf(path, "hi1"); size = 20; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + // read hi2 20 + sprintf(path, "hi2"); size = 20; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + // read hi3 20 + sprintf(path, "hi3"); size = 20; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + + lfs_unmount(&lfs) => 0; +''' + +[[case]] # entry spill test +code = ''' + uint8_t wbuffer[1024]; + uint8_t rbuffer[1024]; + + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + + // write hi0 200 + sprintf(path, "hi0"); size = 200; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + // write hi1 200 + sprintf(path, "hi1"); size = 200; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + // write hi2 200 + sprintf(path, "hi2"); size = 200; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + // write hi3 200 + sprintf(path, "hi3"); size = 200; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + + // read hi0 200 + sprintf(path, "hi0"); size = 200; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + // read hi1 200 + sprintf(path, "hi1"); size = 200; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + // read hi2 200 + sprintf(path, "hi2"); size = 200; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + // read hi3 200 + sprintf(path, "hi3"); size = 200; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + + lfs_unmount(&lfs) => 0; +''' + +[[case]] # entry push spill test +code = ''' + uint8_t wbuffer[1024]; + uint8_t rbuffer[1024]; + + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + + // write hi0 200 + sprintf(path, "hi0"); size = 200; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + // write hi1 20 + sprintf(path, "hi1"); size = 20; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + // write hi2 200 + sprintf(path, "hi2"); size = 200; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + // write hi3 200 + sprintf(path, "hi3"); size = 200; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + + // read hi1 20 + sprintf(path, "hi1"); size = 20; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + // write hi1 200 + sprintf(path, "hi1"); size = 200; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + + // read hi0 200 + sprintf(path, "hi0"); size = 200; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + // read hi1 200 + sprintf(path, "hi1"); size = 200; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + // read hi2 200 + sprintf(path, "hi2"); size = 200; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + // read hi3 200 + sprintf(path, "hi3"); size = 200; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + + lfs_unmount(&lfs) => 0; +''' + +[[case]] # entry push spill two test +code = ''' + uint8_t wbuffer[1024]; + uint8_t rbuffer[1024]; + + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + + // write hi0 200 + sprintf(path, "hi0"); size = 200; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + // write hi1 20 + sprintf(path, "hi1"); size = 20; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + // write hi2 200 + sprintf(path, "hi2"); size = 200; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + // write hi3 200 + sprintf(path, "hi3"); size = 200; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + // write hi4 200 + sprintf(path, "hi4"); size = 200; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + + // read hi1 20 + sprintf(path, "hi1"); size = 20; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + // write hi1 200 + sprintf(path, "hi1"); size = 200; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + + // read hi0 200 + sprintf(path, "hi0"); size = 200; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + // read hi1 200 + sprintf(path, "hi1"); size = 200; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + // read hi2 200 + sprintf(path, "hi2"); size = 200; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + // read hi3 200 + sprintf(path, "hi3"); size = 200; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + // read hi4 200 + sprintf(path, "hi4"); size = 200; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + + lfs_unmount(&lfs) => 0; +''' + +[[case]] # entry drop test +code = ''' + uint8_t wbuffer[1024]; + uint8_t rbuffer[1024]; + + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + + // write hi0 200 + sprintf(path, "hi0"); size = 200; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + // write hi1 200 + sprintf(path, "hi1"); size = 200; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + // write hi2 200 + sprintf(path, "hi2"); size = 200; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + // write hi3 200 + sprintf(path, "hi3"); size = 200; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_close(&lfs, &file) => 0; + + lfs_remove(&lfs, "hi1") => 0; + lfs_stat(&lfs, "hi1", &info) => LFS_ERR_NOENT; + // read hi0 200 + sprintf(path, "hi0"); size = 200; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + // read hi2 200 + sprintf(path, "hi2"); size = 200; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + // read hi3 200 + sprintf(path, "hi3"); size = 200; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + + lfs_remove(&lfs, "hi2") => 0; + lfs_stat(&lfs, "hi2", &info) => LFS_ERR_NOENT; + // read hi0 200 + sprintf(path, "hi0"); size = 200; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + // read hi3 200 + sprintf(path, "hi3"); size = 200; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + + lfs_remove(&lfs, "hi3") => 0; + lfs_stat(&lfs, "hi3", &info) => LFS_ERR_NOENT; + // read hi0 200 + sprintf(path, "hi0"); size = 200; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => size; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + + lfs_remove(&lfs, "hi0") => 0; + lfs_stat(&lfs, "hi0", &info) => LFS_ERR_NOENT; + + lfs_unmount(&lfs) => 0; +''' + +[[case]] # create too big +code = ''' + lfs_format(&lfs, &cfg) => 0; + + lfs_mount(&lfs, &cfg) => 0; + memset(path, 'm', 200); + path[200] = '\0'; + + size = 400; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + uint8_t wbuffer[1024]; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_close(&lfs, &file) => 0; + + size = 400; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + uint8_t rbuffer[1024]; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # resize too big +code = ''' + lfs_format(&lfs, &cfg) => 0; + + lfs_mount(&lfs, &cfg) => 0; + memset(path, 'm', 200); + path[200] = '\0'; + + size = 40; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + uint8_t wbuffer[1024]; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_close(&lfs, &file) => 0; + + size = 40; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + uint8_t rbuffer[1024]; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + + size = 400; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + memset(wbuffer, 'c', size); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_close(&lfs, &file) => 0; + + size = 400; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + memcmp(rbuffer, wbuffer, size) => 0; + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; +''' diff --git a/tests/test_exhaustion.toml b/tests/test_exhaustion.toml new file mode 100644 index 0000000..fe64a80 --- /dev/null +++ b/tests/test_exhaustion.toml @@ -0,0 +1,341 @@ +[[case]] # test running a filesystem to exhaustion +define.LFS_ERASE_CYCLES = 10 +define.LFS_BLOCK_COUNT = 256 # small bd so it runs faster +define.LFS_BLOCK_CYCLES = 'LFS_ERASE_CYCLES / 2' +define.LFS_BADBLOCK_BEHAVIOR = [ + 'LFS_TESTBD_BADBLOCK_NOPROG', + 'LFS_TESTBD_BADBLOCK_NOERASE', + 'LFS_TESTBD_BADBLOCK_NOREAD', +] +define.FILES = 10 +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "roadrunner") => 0; + lfs_unmount(&lfs) => 0; + + uint32_t cycle = 0; + while (true) { + lfs_mount(&lfs, &cfg) => 0; + for (uint32_t i = 0; i < FILES; i++) { + // chose name, roughly random seed, and random 2^n size + sprintf(path, "roadrunner/test%d", i); + srand(cycle * i); + size = 1 << ((rand() % 10)+2); + + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + + for (lfs_size_t j = 0; j < size; j++) { + char c = 'a' + (rand() % 26); + lfs_ssize_t res = lfs_file_write(&lfs, &file, &c, 1); + assert(res == 1 || res == LFS_ERR_NOSPC); + if (res == LFS_ERR_NOSPC) { + goto exhausted; + } + } + + err = lfs_file_close(&lfs, &file); + assert(err == 0 || err == LFS_ERR_NOSPC); + if (err == LFS_ERR_NOSPC) { + goto exhausted; + } + } + + for (uint32_t i = 0; i < FILES; i++) { + // check for errors + sprintf(path, "roadrunner/test%d", i); + srand(cycle * i); + size = 1 << ((rand() % 10)+2); + + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + for (lfs_size_t j = 0; j < size; j++) { + char c = 'a' + (rand() % 26); + char r; + lfs_file_read(&lfs, &file, &r, 1) => 1; + assert(r == c); + } + + lfs_file_close(&lfs, &file) => 0; + } + lfs_unmount(&lfs) => 0; + + cycle += 1; + } + +exhausted: + // should still be readable + lfs_mount(&lfs, &cfg) => 0; + for (uint32_t i = 0; i < FILES; i++) { + // check for errors + sprintf(path, "roadrunner/test%d", i); + lfs_stat(&lfs, path, &info) => 0; + } + lfs_unmount(&lfs) => 0; + + LFS_WARN("completed %d cycles", cycle); +''' + +[[case]] # test running a filesystem to exhaustion + # which also requires expanding superblocks +define.LFS_ERASE_CYCLES = 10 +define.LFS_BLOCK_COUNT = 256 # small bd so it runs faster +define.LFS_BLOCK_CYCLES = 'LFS_ERASE_CYCLES / 2' +define.LFS_BADBLOCK_BEHAVIOR = [ + 'LFS_TESTBD_BADBLOCK_NOPROG', + 'LFS_TESTBD_BADBLOCK_NOERASE', + 'LFS_TESTBD_BADBLOCK_NOREAD', +] +define.FILES = 10 +code = ''' + lfs_format(&lfs, &cfg) => 0; + + uint32_t cycle = 0; + while (true) { + lfs_mount(&lfs, &cfg) => 0; + for (uint32_t i = 0; i < FILES; i++) { + // chose name, roughly random seed, and random 2^n size + sprintf(path, "test%d", i); + srand(cycle * i); + size = 1 << ((rand() % 10)+2); + + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + + for (lfs_size_t j = 0; j < size; j++) { + char c = 'a' + (rand() % 26); + lfs_ssize_t res = lfs_file_write(&lfs, &file, &c, 1); + assert(res == 1 || res == LFS_ERR_NOSPC); + if (res == LFS_ERR_NOSPC) { + goto exhausted; + } + } + + err = lfs_file_close(&lfs, &file); + assert(err == 0 || err == LFS_ERR_NOSPC); + if (err == LFS_ERR_NOSPC) { + goto exhausted; + } + } + + for (uint32_t i = 0; i < FILES; i++) { + // check for errors + sprintf(path, "test%d", i); + srand(cycle * i); + size = 1 << ((rand() % 10)+2); + + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + for (lfs_size_t j = 0; j < size; j++) { + char c = 'a' + (rand() % 26); + char r; + lfs_file_read(&lfs, &file, &r, 1) => 1; + assert(r == c); + } + + lfs_file_close(&lfs, &file) => 0; + } + lfs_unmount(&lfs) => 0; + + cycle += 1; + } + +exhausted: + // should still be readable + lfs_mount(&lfs, &cfg) => 0; + for (uint32_t i = 0; i < FILES; i++) { + // check for errors + sprintf(path, "test%d", i); + lfs_stat(&lfs, path, &info) => 0; + } + lfs_unmount(&lfs) => 0; + + LFS_WARN("completed %d cycles", cycle); +''' + +# These are a sort of high-level litmus test for wear-leveling. One definition +# of wear-leveling is that increasing a block device's space translates directly +# into increasing the block devices lifetime. This is something we can actually +# check for. + +[[case]] # wear-level test running a filesystem to exhaustion +define.LFS_ERASE_CYCLES = 10 +define.LFS_BLOCK_COUNT = 256 # small bd so it runs faster +define.LFS_BLOCK_CYCLES = 'LFS_ERASE_CYCLES / 2' +define.LFS_BADBLOCK_BEHAVIOR = [ + 'LFS_TESTBD_BADBLOCK_NOPROG', + 'LFS_TESTBD_BADBLOCK_NOERASE', + 'LFS_TESTBD_BADBLOCK_NOREAD', +] +define.FILES = 10 +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "roadrunner") => 0; + lfs_unmount(&lfs) => 0; + + uint32_t run_cycles[2]; + const uint32_t run_block_count[2] = {LFS_BLOCK_COUNT/2, LFS_BLOCK_COUNT}; + + for (int run = 0; run < 2; run++) { + for (lfs_block_t b = 0; b < LFS_BLOCK_COUNT; b++) { + lfs_testbd_setwear(&cfg, b, + (b < run_block_count[run]) ? 0 : LFS_ERASE_CYCLES) => 0; + } + + uint32_t cycle = 0; + while (true) { + lfs_mount(&lfs, &cfg) => 0; + for (uint32_t i = 0; i < FILES; i++) { + // chose name, roughly random seed, and random 2^n size + sprintf(path, "roadrunner/test%d", i); + srand(cycle * i); + size = 1 << ((rand() % 10)+2); + + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + + for (lfs_size_t j = 0; j < size; j++) { + char c = 'a' + (rand() % 26); + lfs_ssize_t res = lfs_file_write(&lfs, &file, &c, 1); + assert(res == 1 || res == LFS_ERR_NOSPC); + if (res == LFS_ERR_NOSPC) { + goto exhausted; + } + } + + err = lfs_file_close(&lfs, &file); + assert(err == 0 || err == LFS_ERR_NOSPC); + if (err == LFS_ERR_NOSPC) { + goto exhausted; + } + } + + for (uint32_t i = 0; i < FILES; i++) { + // check for errors + sprintf(path, "roadrunner/test%d", i); + srand(cycle * i); + size = 1 << ((rand() % 10)+2); + + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + for (lfs_size_t j = 0; j < size; j++) { + char c = 'a' + (rand() % 26); + char r; + lfs_file_read(&lfs, &file, &r, 1) => 1; + assert(r == c); + } + + lfs_file_close(&lfs, &file) => 0; + } + lfs_unmount(&lfs) => 0; + + cycle += 1; + } + +exhausted: + // should still be readable + lfs_mount(&lfs, &cfg) => 0; + for (uint32_t i = 0; i < FILES; i++) { + // check for errors + sprintf(path, "roadrunner/test%d", i); + lfs_stat(&lfs, path, &info) => 0; + } + lfs_unmount(&lfs) => 0; + + run_cycles[run] = cycle; + LFS_WARN("completed %d blocks %d cycles", + run_block_count[run], run_cycles[run]); + } + + // check we increased the lifetime by 2x with ~10% error + LFS_ASSERT(run_cycles[1] > 2*run_cycles[0]-run_cycles[0]/10); +''' + +[[case]] # wear-level test + expanding superblock +define.LFS_ERASE_CYCLES = 10 +define.LFS_BLOCK_COUNT = 256 # small bd so it runs faster +define.LFS_BLOCK_CYCLES = 'LFS_ERASE_CYCLES / 2' +define.LFS_BADBLOCK_BEHAVIOR = [ + 'LFS_TESTBD_BADBLOCK_NOPROG', + 'LFS_TESTBD_BADBLOCK_NOERASE', + 'LFS_TESTBD_BADBLOCK_NOREAD', +] +define.FILES = 10 +code = ''' + lfs_format(&lfs, &cfg) => 0; + + uint32_t run_cycles[2]; + const uint32_t run_block_count[2] = {LFS_BLOCK_COUNT/2, LFS_BLOCK_COUNT}; + + for (int run = 0; run < 2; run++) { + for (lfs_block_t b = 0; b < LFS_BLOCK_COUNT; b++) { + lfs_testbd_setwear(&cfg, b, + (b < run_block_count[run]) ? 0 : LFS_ERASE_CYCLES) => 0; + } + + uint32_t cycle = 0; + while (true) { + lfs_mount(&lfs, &cfg) => 0; + for (uint32_t i = 0; i < FILES; i++) { + // chose name, roughly random seed, and random 2^n size + sprintf(path, "test%d", i); + srand(cycle * i); + size = 1 << ((rand() % 10)+2); + + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + + for (lfs_size_t j = 0; j < size; j++) { + char c = 'a' + (rand() % 26); + lfs_ssize_t res = lfs_file_write(&lfs, &file, &c, 1); + assert(res == 1 || res == LFS_ERR_NOSPC); + if (res == LFS_ERR_NOSPC) { + goto exhausted; + } + } + + err = lfs_file_close(&lfs, &file); + assert(err == 0 || err == LFS_ERR_NOSPC); + if (err == LFS_ERR_NOSPC) { + goto exhausted; + } + } + + for (uint32_t i = 0; i < FILES; i++) { + // check for errors + sprintf(path, "test%d", i); + srand(cycle * i); + size = 1 << ((rand() % 10)+2); + + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + for (lfs_size_t j = 0; j < size; j++) { + char c = 'a' + (rand() % 26); + char r; + lfs_file_read(&lfs, &file, &r, 1) => 1; + assert(r == c); + } + + lfs_file_close(&lfs, &file) => 0; + } + lfs_unmount(&lfs) => 0; + + cycle += 1; + } + +exhausted: + // should still be readable + lfs_mount(&lfs, &cfg) => 0; + for (uint32_t i = 0; i < FILES; i++) { + // check for errors + sprintf(path, "test%d", i); + lfs_stat(&lfs, path, &info) => 0; + } + lfs_unmount(&lfs) => 0; + + run_cycles[run] = cycle; + LFS_WARN("completed %d blocks %d cycles", + run_block_count[run], run_cycles[run]); + } + + // check we increased the lifetime by 2x with ~10% error + LFS_ASSERT(run_cycles[1] > 2*run_cycles[0]-run_cycles[0]/10); +''' diff --git a/tests/test_files.sh b/tests/test_files.sh deleted file mode 100755 index f6535f6..0000000 --- a/tests/test_files.sh +++ /dev/null @@ -1,221 +0,0 @@ -#!/bin/bash -set -eu -export TEST_FILE=$0 -trap 'export TEST_LINE=$LINENO' DEBUG - -echo "=== File tests ===" - -SMALLSIZE=32 -MEDIUMSIZE=8192 -LARGESIZE=262144 - -rm -rf blocks -scripts/test.py << TEST - lfs_format(&lfs, &cfg) => 0; -TEST - -echo "--- Simple file test ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file, "hello", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfs_size_t size = strlen("Hello World!\n"); - uint8_t wbuffer[1024]; - memcpy(wbuffer, "Hello World!\n", size); - lfs_file_write(&lfs, &file, wbuffer, size) => size; - lfs_file_close(&lfs, &file) => 0; - - lfs_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; - size = strlen("Hello World!\n"); - uint8_t rbuffer[1024]; - lfs_file_read(&lfs, &file, rbuffer, size) => size; - memcmp(rbuffer, wbuffer, size) => 0; - lfs_file_close(&lfs, &file) => 0; - lfs_unmount(&lfs) => 0; -TEST - -w_test() { -scripts/test.py ${4:-} << TEST - lfs_size_t size = $1; - lfs_size_t chunk = 31; - srand(0); - lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file, "$2", - ${3:-LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC}) => 0; - for (lfs_size_t i = 0; i < size; i += chunk) { - chunk = (chunk < size - i) ? chunk : size - i; - for (lfs_size_t b = 0; b < chunk; b++) { - buffer[b] = rand() & 0xff; - } - lfs_file_write(&lfs, &file, buffer, chunk) => chunk; - } - lfs_file_close(&lfs, &file) => 0; - lfs_unmount(&lfs) => 0; -TEST -} - -r_test() { -scripts/test.py << TEST - lfs_size_t size = $1; - lfs_size_t chunk = 29; - srand(0); - lfs_mount(&lfs, &cfg) => 0; - lfs_stat(&lfs, "$2", &info) => 0; - info.type => LFS_TYPE_REG; - info.size => size; - lfs_file_open(&lfs, &file, "$2", ${3:-LFS_O_RDONLY}) => 0; - for (lfs_size_t i = 0; i < size; i += chunk) { - chunk = (chunk < size - i) ? chunk : size - i; - lfs_file_read(&lfs, &file, buffer, chunk) => chunk; - for (lfs_size_t b = 0; b < chunk && i+b < size; b++) { - buffer[b] => rand() & 0xff; - } - } - lfs_file_close(&lfs, &file) => 0; - lfs_unmount(&lfs) => 0; -TEST -} - -echo "--- Small file test ---" -w_test $SMALLSIZE smallavacado -r_test $SMALLSIZE smallavacado - -echo "--- Medium file test ---" -w_test $MEDIUMSIZE mediumavacado -r_test $MEDIUMSIZE mediumavacado - -echo "--- Large file test ---" -w_test $LARGESIZE largeavacado -r_test $LARGESIZE largeavacado - -echo "--- Zero file test ---" -w_test 0 noavacado -r_test 0 noavacado - -echo "--- Truncate small test ---" -w_test $SMALLSIZE mediumavacado -r_test $SMALLSIZE mediumavacado -w_test $MEDIUMSIZE mediumavacado -r_test $MEDIUMSIZE mediumavacado - -echo "--- Truncate zero test ---" -w_test $SMALLSIZE noavacado -r_test $SMALLSIZE noavacado -w_test 0 noavacado -r_test 0 noavacado - -echo "--- Non-overlap check ---" -r_test $SMALLSIZE smallavacado -r_test $MEDIUMSIZE mediumavacado -r_test $LARGESIZE largeavacado -r_test 0 noavacado - -echo "--- Dir check ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir, "/") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - lfs_dir_read(&lfs, &dir, &info) => 1; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "hello") => 0; - info.type => LFS_TYPE_REG; - info.size => strlen("Hello World!\n"); - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "largeavacado") => 0; - info.type => LFS_TYPE_REG; - info.size => $LARGESIZE; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "mediumavacado") => 0; - info.type => LFS_TYPE_REG; - info.size => $MEDIUMSIZE; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "noavacado") => 0; - info.type => LFS_TYPE_REG; - info.size => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "smallavacado") => 0; - info.type => LFS_TYPE_REG; - info.size => $SMALLSIZE; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Many files test ---" -scripts/test.py << TEST - lfs_format(&lfs, &cfg) => 0; -TEST -scripts/test.py << TEST - // Create 300 files of 7 bytes - lfs_mount(&lfs, &cfg) => 0; - for (unsigned i = 0; i < 300; i++) { - sprintf(path, "file_%03d", i); - lfs_file_open(&lfs, &file, path, - LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfs_size_t size = 7; - uint8_t wbuffer[1024]; - uint8_t rbuffer[1024]; - snprintf((char*)wbuffer, size, "Hi %03d", i); - lfs_file_write(&lfs, &file, wbuffer, size) => size; - lfs_file_rewind(&lfs, &file) => 0; - lfs_file_read(&lfs, &file, rbuffer, size) => size; - memcmp(wbuffer, rbuffer, size) => 0; - lfs_file_close(&lfs, &file) => 0; - } - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Many files with flush test ---" -scripts/test.py << TEST - lfs_format(&lfs, &cfg) => 0; -TEST -scripts/test.py << TEST - // Create 300 files of 7 bytes - lfs_mount(&lfs, &cfg) => 0; - for (unsigned i = 0; i < 300; i++) { - sprintf(path, "file_%03d", i); - lfs_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfs_size_t size = 7; - uint8_t wbuffer[1024]; - uint8_t rbuffer[1024]; - snprintf((char*)wbuffer, size, "Hi %03d", i); - lfs_file_write(&lfs, &file, wbuffer, size) => size; - lfs_file_close(&lfs, &file) => 0; - - lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; - lfs_file_read(&lfs, &file, rbuffer, size) => size; - memcmp(wbuffer, rbuffer, size) => 0; - lfs_file_close(&lfs, &file) => 0; - } - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Many files with power cycle test ---" -scripts/test.py << TEST - lfs_format(&lfs, &cfg) => 0; -TEST -scripts/test.py << TEST - // Create 300 files of 7 bytes - lfs_mount(&lfs, &cfg) => 0; - for (unsigned i = 0; i < 300; i++) { - sprintf(path, "file_%03d", i); - lfs_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - lfs_size_t size = 7; - uint8_t wbuffer[1024]; - uint8_t rbuffer[1024]; - snprintf((char*)wbuffer, size, "Hi %03d", i); - lfs_file_write(&lfs, &file, wbuffer, size) => size; - lfs_file_close(&lfs, &file) => 0; - lfs_unmount(&lfs) => 0; - - lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; - lfs_file_read(&lfs, &file, rbuffer, size) => size; - memcmp(wbuffer, rbuffer, size) => 0; - lfs_file_close(&lfs, &file) => 0; - } - lfs_unmount(&lfs) => 0; -TEST - -scripts/results.py diff --git a/tests/test_files.toml b/tests/test_files.toml new file mode 100644 index 0000000..565e665 --- /dev/null +++ b/tests/test_files.toml @@ -0,0 +1,486 @@ + +[[case]] # simple file test +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "hello", + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + size = strlen("Hello World!")+1; + strcpy((char*)buffer, "Hello World!"); + lfs_file_write(&lfs, &file, buffer, size) => size; + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, size) => size; + assert(strcmp((char*)buffer, "Hello World!") == 0); + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # larger files +define.SIZE = [32, 8192, 262144, 0, 7, 8193] +define.CHUNKSIZE = [31, 16, 33, 1, 1023] +code = ''' + lfs_format(&lfs, &cfg) => 0; + + // write + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "avacado", + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + srand(1); + for (lfs_size_t i = 0; i < SIZE; i += CHUNKSIZE) { + lfs_size_t chunk = lfs_min(CHUNKSIZE, SIZE-i); + for (lfs_size_t b = 0; b < chunk; b++) { + buffer[b] = rand() & 0xff; + } + lfs_file_write(&lfs, &file, buffer, chunk) => chunk; + } + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + // read + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "avacado", LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => SIZE; + srand(1); + for (lfs_size_t i = 0; i < SIZE; i += CHUNKSIZE) { + lfs_size_t chunk = lfs_min(CHUNKSIZE, SIZE-i); + lfs_file_read(&lfs, &file, buffer, chunk) => chunk; + for (lfs_size_t b = 0; b < chunk; b++) { + assert(buffer[b] == (rand() & 0xff)); + } + } + lfs_file_read(&lfs, &file, buffer, CHUNKSIZE) => 0; + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # rewriting files +define.SIZE1 = [32, 8192, 131072, 0, 7, 8193] +define.SIZE2 = [32, 8192, 131072, 0, 7, 8193] +define.CHUNKSIZE = [31, 16, 1] +code = ''' + lfs_format(&lfs, &cfg) => 0; + + // write + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "avacado", + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + srand(1); + for (lfs_size_t i = 0; i < SIZE1; i += CHUNKSIZE) { + lfs_size_t chunk = lfs_min(CHUNKSIZE, SIZE1-i); + for (lfs_size_t b = 0; b < chunk; b++) { + buffer[b] = rand() & 0xff; + } + lfs_file_write(&lfs, &file, buffer, chunk) => chunk; + } + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + // read + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "avacado", LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => SIZE1; + srand(1); + for (lfs_size_t i = 0; i < SIZE1; i += CHUNKSIZE) { + lfs_size_t chunk = lfs_min(CHUNKSIZE, SIZE1-i); + lfs_file_read(&lfs, &file, buffer, chunk) => chunk; + for (lfs_size_t b = 0; b < chunk; b++) { + assert(buffer[b] == (rand() & 0xff)); + } + } + lfs_file_read(&lfs, &file, buffer, CHUNKSIZE) => 0; + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + // rewrite + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "avacado", LFS_O_WRONLY) => 0; + srand(2); + for (lfs_size_t i = 0; i < SIZE2; i += CHUNKSIZE) { + lfs_size_t chunk = lfs_min(CHUNKSIZE, SIZE2-i); + for (lfs_size_t b = 0; b < chunk; b++) { + buffer[b] = rand() & 0xff; + } + lfs_file_write(&lfs, &file, buffer, chunk) => chunk; + } + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + // read + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "avacado", LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => lfs_max(SIZE1, SIZE2); + srand(2); + for (lfs_size_t i = 0; i < SIZE2; i += CHUNKSIZE) { + lfs_size_t chunk = lfs_min(CHUNKSIZE, SIZE2-i); + lfs_file_read(&lfs, &file, buffer, chunk) => chunk; + for (lfs_size_t b = 0; b < chunk; b++) { + assert(buffer[b] == (rand() & 0xff)); + } + } + if (SIZE1 > SIZE2) { + srand(1); + for (lfs_size_t b = 0; b < SIZE2; b++) { + rand(); + } + for (lfs_size_t i = SIZE2; i < SIZE1; i += CHUNKSIZE) { + lfs_size_t chunk = lfs_min(CHUNKSIZE, SIZE1-i); + lfs_file_read(&lfs, &file, buffer, chunk) => chunk; + for (lfs_size_t b = 0; b < chunk; b++) { + assert(buffer[b] == (rand() & 0xff)); + } + } + } + lfs_file_read(&lfs, &file, buffer, CHUNKSIZE) => 0; + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # appending files +define.SIZE1 = [32, 8192, 131072, 0, 7, 8193] +define.SIZE2 = [32, 8192, 131072, 0, 7, 8193] +define.CHUNKSIZE = [31, 16, 1] +code = ''' + lfs_format(&lfs, &cfg) => 0; + + // write + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "avacado", + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + srand(1); + for (lfs_size_t i = 0; i < SIZE1; i += CHUNKSIZE) { + lfs_size_t chunk = lfs_min(CHUNKSIZE, SIZE1-i); + for (lfs_size_t b = 0; b < chunk; b++) { + buffer[b] = rand() & 0xff; + } + lfs_file_write(&lfs, &file, buffer, chunk) => chunk; + } + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + // read + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "avacado", LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => SIZE1; + srand(1); + for (lfs_size_t i = 0; i < SIZE1; i += CHUNKSIZE) { + lfs_size_t chunk = lfs_min(CHUNKSIZE, SIZE1-i); + lfs_file_read(&lfs, &file, buffer, chunk) => chunk; + for (lfs_size_t b = 0; b < chunk; b++) { + assert(buffer[b] == (rand() & 0xff)); + } + } + lfs_file_read(&lfs, &file, buffer, CHUNKSIZE) => 0; + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + // append + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "avacado", LFS_O_WRONLY | LFS_O_APPEND) => 0; + srand(2); + for (lfs_size_t i = 0; i < SIZE2; i += CHUNKSIZE) { + lfs_size_t chunk = lfs_min(CHUNKSIZE, SIZE2-i); + for (lfs_size_t b = 0; b < chunk; b++) { + buffer[b] = rand() & 0xff; + } + lfs_file_write(&lfs, &file, buffer, chunk) => chunk; + } + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + // read + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "avacado", LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => SIZE1 + SIZE2; + srand(1); + for (lfs_size_t i = 0; i < SIZE1; i += CHUNKSIZE) { + lfs_size_t chunk = lfs_min(CHUNKSIZE, SIZE1-i); + lfs_file_read(&lfs, &file, buffer, chunk) => chunk; + for (lfs_size_t b = 0; b < chunk; b++) { + assert(buffer[b] == (rand() & 0xff)); + } + } + srand(2); + for (lfs_size_t i = 0; i < SIZE2; i += CHUNKSIZE) { + lfs_size_t chunk = lfs_min(CHUNKSIZE, SIZE2-i); + lfs_file_read(&lfs, &file, buffer, chunk) => chunk; + for (lfs_size_t b = 0; b < chunk; b++) { + assert(buffer[b] == (rand() & 0xff)); + } + } + lfs_file_read(&lfs, &file, buffer, CHUNKSIZE) => 0; + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # truncating files +define.SIZE1 = [32, 8192, 131072, 0, 7, 8193] +define.SIZE2 = [32, 8192, 131072, 0, 7, 8193] +define.CHUNKSIZE = [31, 16, 1] +code = ''' + lfs_format(&lfs, &cfg) => 0; + + // write + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "avacado", + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + srand(1); + for (lfs_size_t i = 0; i < SIZE1; i += CHUNKSIZE) { + lfs_size_t chunk = lfs_min(CHUNKSIZE, SIZE1-i); + for (lfs_size_t b = 0; b < chunk; b++) { + buffer[b] = rand() & 0xff; + } + lfs_file_write(&lfs, &file, buffer, chunk) => chunk; + } + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + // read + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "avacado", LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => SIZE1; + srand(1); + for (lfs_size_t i = 0; i < SIZE1; i += CHUNKSIZE) { + lfs_size_t chunk = lfs_min(CHUNKSIZE, SIZE1-i); + lfs_file_read(&lfs, &file, buffer, chunk) => chunk; + for (lfs_size_t b = 0; b < chunk; b++) { + assert(buffer[b] == (rand() & 0xff)); + } + } + lfs_file_read(&lfs, &file, buffer, CHUNKSIZE) => 0; + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + // truncate + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "avacado", LFS_O_WRONLY | LFS_O_TRUNC) => 0; + srand(2); + for (lfs_size_t i = 0; i < SIZE2; i += CHUNKSIZE) { + lfs_size_t chunk = lfs_min(CHUNKSIZE, SIZE2-i); + for (lfs_size_t b = 0; b < chunk; b++) { + buffer[b] = rand() & 0xff; + } + lfs_file_write(&lfs, &file, buffer, chunk) => chunk; + } + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + // read + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "avacado", LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => SIZE2; + srand(2); + for (lfs_size_t i = 0; i < SIZE2; i += CHUNKSIZE) { + lfs_size_t chunk = lfs_min(CHUNKSIZE, SIZE2-i); + lfs_file_read(&lfs, &file, buffer, chunk) => chunk; + for (lfs_size_t b = 0; b < chunk; b++) { + assert(buffer[b] == (rand() & 0xff)); + } + } + lfs_file_read(&lfs, &file, buffer, CHUNKSIZE) => 0; + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # reentrant file writing +define.SIZE = [32, 0, 7, 2049] +define.CHUNKSIZE = [31, 16, 65] +reentrant = true +code = ''' + err = lfs_mount(&lfs, &cfg); + if (err) { + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + } + + err = lfs_file_open(&lfs, &file, "avacado", LFS_O_RDONLY); + assert(err == LFS_ERR_NOENT || err == 0); + if (err == 0) { + // can only be 0 (new file) or full size + size = lfs_file_size(&lfs, &file); + assert(size == 0 || size == SIZE); + lfs_file_close(&lfs, &file) => 0; + } + + // write + lfs_file_open(&lfs, &file, "avacado", LFS_O_WRONLY | LFS_O_CREAT) => 0; + srand(1); + for (lfs_size_t i = 0; i < SIZE; i += CHUNKSIZE) { + lfs_size_t chunk = lfs_min(CHUNKSIZE, SIZE-i); + for (lfs_size_t b = 0; b < chunk; b++) { + buffer[b] = rand() & 0xff; + } + lfs_file_write(&lfs, &file, buffer, chunk) => chunk; + } + lfs_file_close(&lfs, &file) => 0; + + // read + lfs_file_open(&lfs, &file, "avacado", LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => SIZE; + srand(1); + for (lfs_size_t i = 0; i < SIZE; i += CHUNKSIZE) { + lfs_size_t chunk = lfs_min(CHUNKSIZE, SIZE-i); + lfs_file_read(&lfs, &file, buffer, chunk) => chunk; + for (lfs_size_t b = 0; b < chunk; b++) { + assert(buffer[b] == (rand() & 0xff)); + } + } + lfs_file_read(&lfs, &file, buffer, CHUNKSIZE) => 0; + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # reentrant file writing with syncs +define = [ + # append (O(n)) + {MODE='LFS_O_APPEND', SIZE=[32, 0, 7, 2049], CHUNKSIZE=[31, 16, 65]}, + # truncate (O(n^2)) + {MODE='LFS_O_TRUNC', SIZE=[32, 0, 7, 200], CHUNKSIZE=[31, 16, 65]}, + # rewrite (O(n^2)) + {MODE=0, SIZE=[32, 0, 7, 200], CHUNKSIZE=[31, 16, 65]}, +] +reentrant = true +code = ''' + err = lfs_mount(&lfs, &cfg); + if (err) { + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + } + + err = lfs_file_open(&lfs, &file, "avacado", LFS_O_RDONLY); + assert(err == LFS_ERR_NOENT || err == 0); + if (err == 0) { + // with syncs we could be any size, but it at least must be valid data + size = lfs_file_size(&lfs, &file); + assert(size <= SIZE); + srand(1); + for (lfs_size_t i = 0; i < size; i += CHUNKSIZE) { + lfs_size_t chunk = lfs_min(CHUNKSIZE, size-i); + lfs_file_read(&lfs, &file, buffer, chunk) => chunk; + for (lfs_size_t b = 0; b < chunk; b++) { + assert(buffer[b] == (rand() & 0xff)); + } + } + lfs_file_close(&lfs, &file) => 0; + } + + // write + lfs_file_open(&lfs, &file, "avacado", + LFS_O_WRONLY | LFS_O_CREAT | MODE) => 0; + size = lfs_file_size(&lfs, &file); + assert(size <= SIZE); + srand(1); + lfs_size_t skip = (MODE == LFS_O_APPEND) ? size : 0; + for (lfs_size_t b = 0; b < skip; b++) { + rand(); + } + for (lfs_size_t i = skip; i < SIZE; i += CHUNKSIZE) { + lfs_size_t chunk = lfs_min(CHUNKSIZE, SIZE-i); + for (lfs_size_t b = 0; b < chunk; b++) { + buffer[b] = rand() & 0xff; + } + lfs_file_write(&lfs, &file, buffer, chunk) => chunk; + lfs_file_sync(&lfs, &file) => 0; + } + lfs_file_close(&lfs, &file) => 0; + + // read + lfs_file_open(&lfs, &file, "avacado", LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => SIZE; + srand(1); + for (lfs_size_t i = 0; i < SIZE; i += CHUNKSIZE) { + lfs_size_t chunk = lfs_min(CHUNKSIZE, SIZE-i); + lfs_file_read(&lfs, &file, buffer, chunk) => chunk; + for (lfs_size_t b = 0; b < chunk; b++) { + assert(buffer[b] == (rand() & 0xff)); + } + } + lfs_file_read(&lfs, &file, buffer, CHUNKSIZE) => 0; + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # many files +define.N = 300 +code = ''' + lfs_format(&lfs, &cfg) => 0; + // create N files of 7 bytes + lfs_mount(&lfs, &cfg) => 0; + for (int i = 0; i < N; i++) { + sprintf(path, "file_%03d", i); + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + char wbuffer[1024]; + size = 7; + snprintf(wbuffer, size, "Hi %03d", i); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_close(&lfs, &file) => 0; + + char rbuffer[1024]; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + assert(strcmp(rbuffer, wbuffer) == 0); + lfs_file_close(&lfs, &file) => 0; + } + lfs_unmount(&lfs) => 0; +''' + +[[case]] # many files with power cycle +define.N = 300 +code = ''' + lfs_format(&lfs, &cfg) => 0; + // create N files of 7 bytes + lfs_mount(&lfs, &cfg) => 0; + for (int i = 0; i < N; i++) { + sprintf(path, "file_%03d", i); + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + char wbuffer[1024]; + size = 7; + snprintf(wbuffer, size, "Hi %03d", i); + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + char rbuffer[1024]; + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + assert(strcmp(rbuffer, wbuffer) == 0); + lfs_file_close(&lfs, &file) => 0; + } + lfs_unmount(&lfs) => 0; +''' + +[[case]] # many files with power loss +define.N = 300 +reentrant = true +code = ''' + err = lfs_mount(&lfs, &cfg); + if (err) { + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + } + // create N files of 7 bytes + for (int i = 0; i < N; i++) { + sprintf(path, "file_%03d", i); + err = lfs_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT); + char wbuffer[1024]; + size = 7; + snprintf(wbuffer, size, "Hi %03d", i); + if ((lfs_size_t)lfs_file_size(&lfs, &file) != size) { + lfs_file_write(&lfs, &file, wbuffer, size) => size; + } + lfs_file_close(&lfs, &file) => 0; + + char rbuffer[1024]; + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, rbuffer, size) => size; + assert(strcmp(rbuffer, wbuffer) == 0); + lfs_file_close(&lfs, &file) => 0; + } + lfs_unmount(&lfs) => 0; +''' diff --git a/tests/test_format.sh b/tests/test_format.sh deleted file mode 100755 index f0972bd..0000000 --- a/tests/test_format.sh +++ /dev/null @@ -1,51 +0,0 @@ -#!/bin/bash -set -eu -export TEST_FILE=$0 -trap 'export TEST_LINE=$LINENO' DEBUG - -echo "=== Formatting tests ===" -rm -rf blocks - -echo "--- Basic formatting ---" -scripts/test.py << TEST - lfs_format(&lfs, &cfg) => 0; -TEST - -echo "--- Basic mounting ---" -scripts/test.py << TEST - lfs_format(&lfs, &cfg) => 0; - - lfs_mount(&lfs, &cfg) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Invalid superblocks ---" -ln -f -s /dev/zero blocks/0 -ln -f -s /dev/zero blocks/1 -scripts/test.py << TEST - lfs_format(&lfs, &cfg) => LFS_ERR_NOSPC; -TEST -rm blocks/0 blocks/1 - -echo "--- Invalid mount ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => LFS_ERR_CORRUPT; -TEST - -echo "--- Expanding superblock ---" -scripts/test.py << TEST - lfs_format(&lfs, &cfg) => 0; - lfs_mount(&lfs, &cfg) => 0; - for (int i = 0; i < 100; i++) { - lfs_mkdir(&lfs, "dummy") => 0; - lfs_remove(&lfs, "dummy") => 0; - } - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_mkdir(&lfs, "dummy") => 0; - lfs_unmount(&lfs) => 0; -TEST - -scripts/results.py diff --git a/tests/test_format.toml b/tests/test_format.toml new file mode 100644 index 0000000..7932d54 --- /dev/null +++ b/tests/test_format.toml @@ -0,0 +1,103 @@ +[[case]] # simple formatting test +code = ''' + lfs_format(&lfs, &cfg) => 0; +''' + +[[case]] # mount/unmount +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # reentrant format +reentrant = true +code = ''' + err = lfs_mount(&lfs, &cfg); + if (err) { + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + } + lfs_unmount(&lfs) => 0; +''' + +[[case]] # invalid mount +code = ''' + lfs_mount(&lfs, &cfg) => LFS_ERR_CORRUPT; +''' + +[[case]] # expanding superblock +define.BLOCK_CYCLES = [32, 33, 1] +define.N = [10, 100, 1000] +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + for (int i = 0; i < N; i++) { + lfs_mkdir(&lfs, "dummy") => 0; + lfs_stat(&lfs, "dummy", &info) => 0; + assert(strcmp(info.name, "dummy") == 0); + lfs_remove(&lfs, "dummy") => 0; + } + lfs_unmount(&lfs) => 0; + + // one last check after power-cycle + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "dummy") => 0; + lfs_stat(&lfs, "dummy", &info) => 0; + assert(strcmp(info.name, "dummy") == 0); + lfs_unmount(&lfs) => 0; +''' + +[[case]] # expanding superblock with power cycle +define.BLOCK_CYCLES = [32, 33, 1] +define.N = [10, 100, 1000] +code = ''' + lfs_format(&lfs, &cfg) => 0; + for (int i = 0; i < N; i++) { + lfs_mount(&lfs, &cfg) => 0; + // remove lingering dummy? + err = lfs_remove(&lfs, "dummy"); + assert(err == 0 || (err == LFS_ERR_NOENT && i == 0)); + + lfs_mkdir(&lfs, "dummy") => 0; + lfs_stat(&lfs, "dummy", &info) => 0; + assert(strcmp(info.name, "dummy") == 0); + lfs_unmount(&lfs) => 0; + } + + // one last check after power-cycle + lfs_mount(&lfs, &cfg) => 0; + lfs_stat(&lfs, "dummy", &info) => 0; + assert(strcmp(info.name, "dummy") == 0); + lfs_unmount(&lfs) => 0; +''' + +[[case]] # reentrant expanding superblock +define.BLOCK_CYCLES = [2, 1] +define.N = 24 +reentrant = true +code = ''' + err = lfs_mount(&lfs, &cfg); + if (err) { + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + } + + for (int i = 0; i < N; i++) { + // remove lingering dummy? + err = lfs_remove(&lfs, "dummy"); + assert(err == 0 || (err == LFS_ERR_NOENT && i == 0)); + + lfs_mkdir(&lfs, "dummy") => 0; + lfs_stat(&lfs, "dummy", &info) => 0; + assert(strcmp(info.name, "dummy") == 0); + } + + lfs_unmount(&lfs) => 0; + + // one last check after power-cycle + lfs_mount(&lfs, &cfg) => 0; + lfs_stat(&lfs, "dummy", &info) => 0; + assert(strcmp(info.name, "dummy") == 0); + lfs_unmount(&lfs) => 0; +''' diff --git a/tests/test_interspersed.sh b/tests/test_interspersed.sh deleted file mode 100755 index 84c5dd8..0000000 --- a/tests/test_interspersed.sh +++ /dev/null @@ -1,190 +0,0 @@ -#!/bin/bash -set -eu -export TEST_FILE=$0 -trap 'export TEST_LINE=$LINENO' DEBUG - -echo "=== Interspersed tests ===" -rm -rf blocks -scripts/test.py << TEST - lfs_format(&lfs, &cfg) => 0; -TEST - -echo "--- Interspersed file test ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_file_t files[4]; - lfs_file_open(&lfs, &files[0], "a", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfs_file_open(&lfs, &files[1], "b", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfs_file_open(&lfs, &files[2], "c", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfs_file_open(&lfs, &files[3], "d", LFS_O_WRONLY | LFS_O_CREAT) => 0; - - for (int i = 0; i < 10; i++) { - lfs_file_write(&lfs, &files[0], (const void*)"a", 1) => 1; - lfs_file_write(&lfs, &files[1], (const void*)"b", 1) => 1; - lfs_file_write(&lfs, &files[2], (const void*)"c", 1) => 1; - lfs_file_write(&lfs, &files[3], (const void*)"d", 1) => 1; - } - - lfs_file_close(&lfs, &files[0]); - lfs_file_close(&lfs, &files[1]); - lfs_file_close(&lfs, &files[2]); - lfs_file_close(&lfs, &files[3]); - - lfs_dir_open(&lfs, &dir, "/") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "a") => 0; - info.type => LFS_TYPE_REG; - info.size => 10; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "b") => 0; - info.type => LFS_TYPE_REG; - info.size => 10; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "c") => 0; - info.type => LFS_TYPE_REG; - info.size => 10; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "d") => 0; - info.type => LFS_TYPE_REG; - info.size => 10; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - - lfs_file_open(&lfs, &files[0], "a", LFS_O_RDONLY) => 0; - lfs_file_open(&lfs, &files[1], "b", LFS_O_RDONLY) => 0; - lfs_file_open(&lfs, &files[2], "c", LFS_O_RDONLY) => 0; - lfs_file_open(&lfs, &files[3], "d", LFS_O_RDONLY) => 0; - - for (int i = 0; i < 10; i++) { - lfs_file_read(&lfs, &files[0], buffer, 1) => 1; - buffer[0] => 'a'; - lfs_file_read(&lfs, &files[1], buffer, 1) => 1; - buffer[0] => 'b'; - lfs_file_read(&lfs, &files[2], buffer, 1) => 1; - buffer[0] => 'c'; - lfs_file_read(&lfs, &files[3], buffer, 1) => 1; - buffer[0] => 'd'; - } - - lfs_file_close(&lfs, &files[0]); - lfs_file_close(&lfs, &files[1]); - lfs_file_close(&lfs, &files[2]); - lfs_file_close(&lfs, &files[3]); - - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Interspersed remove file test ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_file_t files[4]; - lfs_file_open(&lfs, &files[0], "e", LFS_O_WRONLY | LFS_O_CREAT) => 0; - - for (int i = 0; i < 5; i++) { - lfs_file_write(&lfs, &files[0], (const void*)"e", 1) => 1; - } - - lfs_remove(&lfs, "a") => 0; - lfs_remove(&lfs, "b") => 0; - lfs_remove(&lfs, "c") => 0; - lfs_remove(&lfs, "d") => 0; - - for (int i = 0; i < 5; i++) { - lfs_file_write(&lfs, &files[0], (const void*)"e", 1) => 1; - } - - lfs_file_close(&lfs, &files[0]); - - lfs_dir_open(&lfs, &dir, "/") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "e") => 0; - info.type => LFS_TYPE_REG; - info.size => 10; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - - lfs_file_open(&lfs, &files[0], "e", LFS_O_RDONLY) => 0; - - for (int i = 0; i < 10; i++) { - lfs_file_read(&lfs, &files[0], buffer, 1) => 1; - buffer[0] => 'e'; - } - - lfs_file_close(&lfs, &files[0]); - - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Remove inconveniently test ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_file_t files[4]; - lfs_file_open(&lfs, &files[0], "e", LFS_O_WRONLY | LFS_O_TRUNC) => 0; - lfs_file_open(&lfs, &files[1], "f", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfs_file_open(&lfs, &files[2], "g", LFS_O_WRONLY | LFS_O_CREAT) => 0; - - for (int i = 0; i < 5; i++) { - lfs_file_write(&lfs, &files[0], (const void*)"e", 1) => 1; - lfs_file_write(&lfs, &files[1], (const void*)"f", 1) => 1; - lfs_file_write(&lfs, &files[2], (const void*)"g", 1) => 1; - } - - lfs_remove(&lfs, "f") => 0; - - for (int i = 0; i < 5; i++) { - lfs_file_write(&lfs, &files[0], (const void*)"e", 1) => 1; - lfs_file_write(&lfs, &files[1], (const void*)"f", 1) => 1; - lfs_file_write(&lfs, &files[2], (const void*)"g", 1) => 1; - } - - lfs_file_close(&lfs, &files[0]); - lfs_file_close(&lfs, &files[1]); - lfs_file_close(&lfs, &files[2]); - - lfs_dir_open(&lfs, &dir, "/") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "e") => 0; - info.type => LFS_TYPE_REG; - info.size => 10; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "g") => 0; - info.type => LFS_TYPE_REG; - info.size => 10; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - - lfs_file_open(&lfs, &files[0], "e", LFS_O_RDONLY) => 0; - lfs_file_open(&lfs, &files[1], "g", LFS_O_RDONLY) => 0; - - for (int i = 0; i < 10; i++) { - lfs_file_read(&lfs, &files[0], buffer, 1) => 1; - buffer[0] => 'e'; - lfs_file_read(&lfs, &files[1], buffer, 1) => 1; - buffer[0] => 'g'; - } - - lfs_file_close(&lfs, &files[0]); - lfs_file_close(&lfs, &files[1]); - - lfs_unmount(&lfs) => 0; -TEST - -scripts/results.py diff --git a/tests/test_interspersed.toml b/tests/test_interspersed.toml new file mode 100644 index 0000000..87a0578 --- /dev/null +++ b/tests/test_interspersed.toml @@ -0,0 +1,244 @@ + +[[case]] # interspersed file test +define.SIZE = [10, 100] +define.FILES = [4, 10, 26] +code = ''' + lfs_file_t files[FILES]; + const char alphas[] = "abcdefghijklmnopqrstuvwxyz"; + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + for (int j = 0; j < FILES; j++) { + sprintf(path, "%c", alphas[j]); + lfs_file_open(&lfs, &files[j], path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + } + + for (int i = 0; i < SIZE; i++) { + for (int j = 0; j < FILES; j++) { + lfs_file_write(&lfs, &files[j], &alphas[j], 1) => 1; + } + } + + for (int j = 0; j < FILES; j++) { + lfs_file_close(&lfs, &files[j]); + } + + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + for (int j = 0; j < FILES; j++) { + sprintf(path, "%c", alphas[j]); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, path) == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == SIZE); + } + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + for (int j = 0; j < FILES; j++) { + sprintf(path, "%c", alphas[j]); + lfs_file_open(&lfs, &files[j], path, LFS_O_RDONLY) => 0; + } + + for (int i = 0; i < 10; i++) { + for (int j = 0; j < FILES; j++) { + lfs_file_read(&lfs, &files[j], buffer, 1) => 1; + assert(buffer[0] == alphas[j]); + } + } + + for (int j = 0; j < FILES; j++) { + lfs_file_close(&lfs, &files[j]); + } + + lfs_unmount(&lfs) => 0; +''' + +[[case]] # interspersed remove file test +define.SIZE = [10, 100] +define.FILES = [4, 10, 26] +code = ''' + const char alphas[] = "abcdefghijklmnopqrstuvwxyz"; + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + for (int j = 0; j < FILES; j++) { + sprintf(path, "%c", alphas[j]); + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; + for (int i = 0; i < SIZE; i++) { + lfs_file_write(&lfs, &file, &alphas[j], 1) => 1; + } + lfs_file_close(&lfs, &file); + } + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "zzz", LFS_O_WRONLY | LFS_O_CREAT) => 0; + for (int j = 0; j < FILES; j++) { + lfs_file_write(&lfs, &file, (const void*)"~", 1) => 1; + lfs_file_sync(&lfs, &file) => 0; + + sprintf(path, "%c", alphas[j]); + lfs_remove(&lfs, path) => 0; + } + lfs_file_close(&lfs, &file); + + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "zzz") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == FILES); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_file_open(&lfs, &file, "zzz", LFS_O_RDONLY) => 0; + for (int i = 0; i < FILES; i++) { + lfs_file_read(&lfs, &file, buffer, 1) => 1; + assert(buffer[0] == '~'); + } + lfs_file_close(&lfs, &file); + + lfs_unmount(&lfs) => 0; +''' + +[[case]] # remove inconveniently test +define.SIZE = [10, 100] +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_file_t files[3]; + lfs_file_open(&lfs, &files[0], "e", LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_open(&lfs, &files[1], "f", LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_open(&lfs, &files[2], "g", LFS_O_WRONLY | LFS_O_CREAT) => 0; + + for (int i = 0; i < SIZE/2; i++) { + lfs_file_write(&lfs, &files[0], (const void*)"e", 1) => 1; + lfs_file_write(&lfs, &files[1], (const void*)"f", 1) => 1; + lfs_file_write(&lfs, &files[2], (const void*)"g", 1) => 1; + } + + lfs_remove(&lfs, "f") => 0; + + for (int i = 0; i < SIZE/2; i++) { + lfs_file_write(&lfs, &files[0], (const void*)"e", 1) => 1; + lfs_file_write(&lfs, &files[1], (const void*)"f", 1) => 1; + lfs_file_write(&lfs, &files[2], (const void*)"g", 1) => 1; + } + + lfs_file_close(&lfs, &files[0]); + lfs_file_close(&lfs, &files[1]); + lfs_file_close(&lfs, &files[2]); + + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "e") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == SIZE); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "g") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == SIZE); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_file_open(&lfs, &files[0], "e", LFS_O_RDONLY) => 0; + lfs_file_open(&lfs, &files[1], "g", LFS_O_RDONLY) => 0; + for (int i = 0; i < SIZE; i++) { + lfs_file_read(&lfs, &files[0], buffer, 1) => 1; + assert(buffer[0] == 'e'); + lfs_file_read(&lfs, &files[1], buffer, 1) => 1; + assert(buffer[0] == 'g'); + } + lfs_file_close(&lfs, &files[0]); + lfs_file_close(&lfs, &files[1]); + + lfs_unmount(&lfs) => 0; +''' + +[[case]] # reentrant interspersed file test +define.SIZE = [10, 100] +define.FILES = [4, 10, 26] +reentrant = true +code = ''' + lfs_file_t files[FILES]; + const char alphas[] = "abcdefghijklmnopqrstuvwxyz"; + + err = lfs_mount(&lfs, &cfg); + if (err) { + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + } + + for (int j = 0; j < FILES; j++) { + sprintf(path, "%c", alphas[j]); + lfs_file_open(&lfs, &files[j], path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0; + } + + for (int i = 0; i < SIZE; i++) { + for (int j = 0; j < FILES; j++) { + size = lfs_file_size(&lfs, &files[j]); + assert((int)size >= 0); + if ((int)size <= i) { + lfs_file_write(&lfs, &files[j], &alphas[j], 1) => 1; + lfs_file_sync(&lfs, &files[j]) => 0; + } + } + } + + for (int j = 0; j < FILES; j++) { + lfs_file_close(&lfs, &files[j]); + } + + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + for (int j = 0; j < FILES; j++) { + sprintf(path, "%c", alphas[j]); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, path) == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == SIZE); + } + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + for (int j = 0; j < FILES; j++) { + sprintf(path, "%c", alphas[j]); + lfs_file_open(&lfs, &files[j], path, LFS_O_RDONLY) => 0; + } + + for (int i = 0; i < 10; i++) { + for (int j = 0; j < FILES; j++) { + lfs_file_read(&lfs, &files[j], buffer, 1) => 1; + assert(buffer[0] == alphas[j]); + } + } + + for (int j = 0; j < FILES; j++) { + lfs_file_close(&lfs, &files[j]); + } + + lfs_unmount(&lfs) => 0; +''' diff --git a/tests/test_move.sh b/tests/test_move.sh deleted file mode 100755 index f52ef22..0000000 --- a/tests/test_move.sh +++ /dev/null @@ -1,333 +0,0 @@ -#!/bin/bash -set -eu -export TEST_FILE=$0 -trap 'export TEST_LINE=$LINENO' DEBUG - -echo "=== Move tests ===" -rm -rf blocks -scripts/test.py << TEST - lfs_format(&lfs, &cfg) => 0; - - lfs_mount(&lfs, &cfg) => 0; - lfs_mkdir(&lfs, "a") => 0; - lfs_mkdir(&lfs, "b") => 0; - lfs_mkdir(&lfs, "c") => 0; - lfs_mkdir(&lfs, "d") => 0; - - lfs_mkdir(&lfs, "a/hi") => 0; - lfs_mkdir(&lfs, "a/hi/hola") => 0; - lfs_mkdir(&lfs, "a/hi/bonjour") => 0; - lfs_mkdir(&lfs, "a/hi/ohayo") => 0; - - lfs_file_open(&lfs, &file, "a/hello", LFS_O_CREAT | LFS_O_WRONLY) => 0; - lfs_file_write(&lfs, &file, "hola\n", 5) => 5; - lfs_file_write(&lfs, &file, "bonjour\n", 8) => 8; - lfs_file_write(&lfs, &file, "ohayo\n", 6) => 6; - lfs_file_close(&lfs, &file) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Move file ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_rename(&lfs, "a/hello", "b/hello") => 0; - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir, "a") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "hi") => 0; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - lfs_dir_open(&lfs, &dir, "b") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "hello") => 0; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Move file corrupt source ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_rename(&lfs, "b/hello", "c/hello") => 0; - lfs_unmount(&lfs) => 0; -TEST -scripts/corrupt.py -n 1 -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir, "b") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - lfs_dir_open(&lfs, &dir, "c") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "hello") => 0; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Move file corrupt source and dest ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_rename(&lfs, "c/hello", "d/hello") => 0; - lfs_unmount(&lfs) => 0; -TEST -scripts/corrupt.py -n 2 -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir, "c") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "hello") => 0; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - lfs_dir_open(&lfs, &dir, "d") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Move file after corrupt ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_rename(&lfs, "c/hello", "d/hello") => 0; - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir, "c") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - lfs_dir_open(&lfs, &dir, "d") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "hello") => 0; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Move dir ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_rename(&lfs, "a/hi", "b/hi") => 0; - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir, "a") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - lfs_dir_open(&lfs, &dir, "b") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "hi") => 0; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Move dir corrupt source ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_rename(&lfs, "b/hi", "c/hi") => 0; - lfs_unmount(&lfs) => 0; -TEST -scripts/corrupt.py -n 1 -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir, "b") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - lfs_dir_open(&lfs, &dir, "c") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "hi") => 0; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Move dir corrupt source and dest ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_rename(&lfs, "c/hi", "d/hi") => 0; - lfs_unmount(&lfs) => 0; -TEST -scripts/corrupt.py -n 2 -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir, "c") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "hi") => 0; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - lfs_dir_open(&lfs, &dir, "d") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "hello") => 0; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Move dir after corrupt ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_rename(&lfs, "c/hi", "d/hi") => 0; - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir, "c") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - lfs_dir_open(&lfs, &dir, "d") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "hello") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "hi") => 0; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Move check ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - - lfs_dir_open(&lfs, &dir, "a/hi") => LFS_ERR_NOENT; - lfs_dir_open(&lfs, &dir, "b/hi") => LFS_ERR_NOENT; - lfs_dir_open(&lfs, &dir, "c/hi") => LFS_ERR_NOENT; - - lfs_dir_open(&lfs, &dir, "d/hi") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "bonjour") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "hola") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "ohayo") => 0; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - - lfs_dir_open(&lfs, &dir, "a/hello") => LFS_ERR_NOENT; - lfs_dir_open(&lfs, &dir, "b/hello") => LFS_ERR_NOENT; - lfs_dir_open(&lfs, &dir, "c/hello") => LFS_ERR_NOENT; - - lfs_file_open(&lfs, &file, "d/hello", LFS_O_RDONLY) => 0; - lfs_file_read(&lfs, &file, buffer, 5) => 5; - memcmp(buffer, "hola\n", 5) => 0; - lfs_file_read(&lfs, &file, buffer, 8) => 8; - memcmp(buffer, "bonjour\n", 8) => 0; - lfs_file_read(&lfs, &file, buffer, 6) => 6; - memcmp(buffer, "ohayo\n", 6) => 0; - lfs_file_close(&lfs, &file) => 0; - - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Move state stealing ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - - lfs_remove(&lfs, "b") => 0; - lfs_remove(&lfs, "c") => 0; - - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - - lfs_dir_open(&lfs, &dir, "a/hi") => LFS_ERR_NOENT; - lfs_dir_open(&lfs, &dir, "b") => LFS_ERR_NOENT; - lfs_dir_open(&lfs, &dir, "c") => LFS_ERR_NOENT; - - lfs_dir_open(&lfs, &dir, "d/hi") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "bonjour") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "hola") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "ohayo") => 0; - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - - lfs_dir_open(&lfs, &dir, "a/hello") => LFS_ERR_NOENT; - lfs_dir_open(&lfs, &dir, "b") => LFS_ERR_NOENT; - lfs_dir_open(&lfs, &dir, "c") => LFS_ERR_NOENT; - - lfs_file_open(&lfs, &file, "d/hello", LFS_O_RDONLY) => 0; - lfs_file_read(&lfs, &file, buffer, 5) => 5; - memcmp(buffer, "hola\n", 5) => 0; - lfs_file_read(&lfs, &file, buffer, 8) => 8; - memcmp(buffer, "bonjour\n", 8) => 0; - lfs_file_read(&lfs, &file, buffer, 6) => 6; - memcmp(buffer, "ohayo\n", 6) => 0; - lfs_file_close(&lfs, &file) => 0; - - lfs_unmount(&lfs) => 0; -TEST - - -scripts/results.py diff --git a/tests/test_move.toml b/tests/test_move.toml new file mode 100644 index 0000000..f290ed4 --- /dev/null +++ b/tests/test_move.toml @@ -0,0 +1,1811 @@ +[[case]] # move file +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "a") => 0; + lfs_mkdir(&lfs, "b") => 0; + lfs_mkdir(&lfs, "c") => 0; + lfs_mkdir(&lfs, "d") => 0; + lfs_file_open(&lfs, &file, "a/hello", LFS_O_CREAT | LFS_O_WRONLY) => 0; + lfs_file_write(&lfs, &file, "hola\n", 5) => 5; + lfs_file_write(&lfs, &file, "bonjour\n", 8) => 8; + lfs_file_write(&lfs, &file, "ohayo\n", 6) => 6; + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_rename(&lfs, "a/hello", "c/hello") => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "a") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_dir_open(&lfs, &dir, "c") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "hello") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 5+8+6); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_file_open(&lfs, &file, "a/hello", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs_file_open(&lfs, &file, "b/hello", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs_file_open(&lfs, &file, "c/hello", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 5) => 5; + memcmp(buffer, "hola\n", 5) => 0; + lfs_file_read(&lfs, &file, buffer, 8) => 8; + memcmp(buffer, "bonjour\n", 8) => 0; + lfs_file_read(&lfs, &file, buffer, 6) => 6; + memcmp(buffer, "ohayo\n", 6) => 0; + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "d/hello", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # noop move, yes this is legal +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "hi") => 0; + lfs_rename(&lfs, "hi", "hi") => 0; + lfs_mkdir(&lfs, "hi/hi") => 0; + lfs_rename(&lfs, "hi/hi", "hi/hi") => 0; + lfs_mkdir(&lfs, "hi/hi/hi") => 0; + lfs_rename(&lfs, "hi/hi/hi", "hi/hi/hi") => 0; + lfs_stat(&lfs, "hi/hi/hi", &info) => 0; + assert(strcmp(info.name, "hi") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_unmount(&lfs) => 0; +''' + +[[case]] # move file corrupt source +in = "lfs.c" +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "a") => 0; + lfs_mkdir(&lfs, "b") => 0; + lfs_mkdir(&lfs, "c") => 0; + lfs_mkdir(&lfs, "d") => 0; + lfs_file_open(&lfs, &file, "a/hello", LFS_O_CREAT | LFS_O_WRONLY) => 0; + lfs_file_write(&lfs, &file, "hola\n", 5) => 5; + lfs_file_write(&lfs, &file, "bonjour\n", 8) => 8; + lfs_file_write(&lfs, &file, "ohayo\n", 6) => 6; + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_rename(&lfs, "a/hello", "c/hello") => 0; + lfs_unmount(&lfs) => 0; + + // corrupt the source + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "a") => 0; + lfs_block_t block = dir.m.pair[0]; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs) => 0; + uint8_t bbuffer[LFS_BLOCK_SIZE]; + cfg.read(&cfg, block, 0, bbuffer, LFS_BLOCK_SIZE) => 0; + int off = LFS_BLOCK_SIZE-1; + while (off >= 0 && bbuffer[off] == LFS_ERASE_VALUE) { + off -= 1; + } + memset(&bbuffer[off-3], LFS_BLOCK_SIZE, 3); + cfg.erase(&cfg, block) => 0; + cfg.prog(&cfg, block, 0, bbuffer, LFS_BLOCK_SIZE) => 0; + cfg.sync(&cfg) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "a") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_dir_open(&lfs, &dir, "c") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "hello") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 5+8+6); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_file_open(&lfs, &file, "a/hello", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs_file_open(&lfs, &file, "b/hello", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs_file_open(&lfs, &file, "c/hello", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 5) => 5; + memcmp(buffer, "hola\n", 5) => 0; + lfs_file_read(&lfs, &file, buffer, 8) => 8; + memcmp(buffer, "bonjour\n", 8) => 0; + lfs_file_read(&lfs, &file, buffer, 6) => 6; + memcmp(buffer, "ohayo\n", 6) => 0; + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "d/hello", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # move file corrupt source and dest +in = "lfs.c" +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "a") => 0; + lfs_mkdir(&lfs, "b") => 0; + lfs_mkdir(&lfs, "c") => 0; + lfs_mkdir(&lfs, "d") => 0; + lfs_file_open(&lfs, &file, "a/hello", LFS_O_CREAT | LFS_O_WRONLY) => 0; + lfs_file_write(&lfs, &file, "hola\n", 5) => 5; + lfs_file_write(&lfs, &file, "bonjour\n", 8) => 8; + lfs_file_write(&lfs, &file, "ohayo\n", 6) => 6; + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_rename(&lfs, "a/hello", "c/hello") => 0; + lfs_unmount(&lfs) => 0; + + // corrupt the source + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "a") => 0; + lfs_block_t block = dir.m.pair[0]; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs) => 0; + uint8_t bbuffer[LFS_BLOCK_SIZE]; + cfg.read(&cfg, block, 0, bbuffer, LFS_BLOCK_SIZE) => 0; + int off = LFS_BLOCK_SIZE-1; + while (off >= 0 && bbuffer[off] == LFS_ERASE_VALUE) { + off -= 1; + } + memset(&bbuffer[off-3], LFS_BLOCK_SIZE, 3); + cfg.erase(&cfg, block) => 0; + cfg.prog(&cfg, block, 0, bbuffer, LFS_BLOCK_SIZE) => 0; + cfg.sync(&cfg) => 0; + + // corrupt the destination + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "c") => 0; + block = dir.m.pair[0]; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs) => 0; + cfg.read(&cfg, block, 0, bbuffer, LFS_BLOCK_SIZE) => 0; + off = LFS_BLOCK_SIZE-1; + while (off >= 0 && bbuffer[off] == LFS_ERASE_VALUE) { + off -= 1; + } + memset(&bbuffer[off-3], LFS_BLOCK_SIZE, 3); + cfg.erase(&cfg, block) => 0; + cfg.prog(&cfg, block, 0, bbuffer, LFS_BLOCK_SIZE) => 0; + cfg.sync(&cfg) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "a") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "hello") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 5+8+6); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_dir_open(&lfs, &dir, "c") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_file_open(&lfs, &file, "a/hello", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 5) => 5; + memcmp(buffer, "hola\n", 5) => 0; + lfs_file_read(&lfs, &file, buffer, 8) => 8; + memcmp(buffer, "bonjour\n", 8) => 0; + lfs_file_read(&lfs, &file, buffer, 6) => 6; + memcmp(buffer, "ohayo\n", 6) => 0; + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "b/hello", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs_file_open(&lfs, &file, "c/hello", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs_file_open(&lfs, &file, "d/hello", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # move file after corrupt +in = "lfs.c" +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "a") => 0; + lfs_mkdir(&lfs, "b") => 0; + lfs_mkdir(&lfs, "c") => 0; + lfs_mkdir(&lfs, "d") => 0; + lfs_file_open(&lfs, &file, "a/hello", LFS_O_CREAT | LFS_O_WRONLY) => 0; + lfs_file_write(&lfs, &file, "hola\n", 5) => 5; + lfs_file_write(&lfs, &file, "bonjour\n", 8) => 8; + lfs_file_write(&lfs, &file, "ohayo\n", 6) => 6; + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_rename(&lfs, "a/hello", "c/hello") => 0; + lfs_unmount(&lfs) => 0; + + // corrupt the source + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "a") => 0; + lfs_block_t block = dir.m.pair[0]; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs) => 0; + uint8_t bbuffer[LFS_BLOCK_SIZE]; + cfg.read(&cfg, block, 0, bbuffer, LFS_BLOCK_SIZE) => 0; + int off = LFS_BLOCK_SIZE-1; + while (off >= 0 && bbuffer[off] == LFS_ERASE_VALUE) { + off -= 1; + } + memset(&bbuffer[off-3], LFS_BLOCK_SIZE, 3); + cfg.erase(&cfg, block) => 0; + cfg.prog(&cfg, block, 0, bbuffer, LFS_BLOCK_SIZE) => 0; + cfg.sync(&cfg) => 0; + + // corrupt the destination + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "c") => 0; + block = dir.m.pair[0]; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs) => 0; + cfg.read(&cfg, block, 0, bbuffer, LFS_BLOCK_SIZE) => 0; + off = LFS_BLOCK_SIZE-1; + while (off >= 0 && bbuffer[off] == LFS_ERASE_VALUE) { + off -= 1; + } + memset(&bbuffer[off-3], LFS_BLOCK_SIZE, 3); + cfg.erase(&cfg, block) => 0; + cfg.prog(&cfg, block, 0, bbuffer, LFS_BLOCK_SIZE) => 0; + cfg.sync(&cfg) => 0; + + // continue move + lfs_mount(&lfs, &cfg) => 0; + lfs_rename(&lfs, "a/hello", "c/hello") => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "a") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_dir_open(&lfs, &dir, "c") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "hello") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 5+8+6); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_file_open(&lfs, &file, "a/hello", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs_file_open(&lfs, &file, "b/hello", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs_file_open(&lfs, &file, "c/hello", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 5) => 5; + memcmp(buffer, "hola\n", 5) => 0; + lfs_file_read(&lfs, &file, buffer, 8) => 8; + memcmp(buffer, "bonjour\n", 8) => 0; + lfs_file_read(&lfs, &file, buffer, 6) => 6; + memcmp(buffer, "ohayo\n", 6) => 0; + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "d/hello", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # simple reentrant move file +reentrant = true +code = ''' + err = lfs_mount(&lfs, &cfg); + if (err) { + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + } + err = lfs_mkdir(&lfs, "a"); + assert(!err || err == LFS_ERR_EXIST); + err = lfs_mkdir(&lfs, "b"); + assert(!err || err == LFS_ERR_EXIST); + err = lfs_mkdir(&lfs, "c"); + assert(!err || err == LFS_ERR_EXIST); + err = lfs_mkdir(&lfs, "d"); + assert(!err || err == LFS_ERR_EXIST); + lfs_unmount(&lfs) => 0; + + while (true) { + lfs_mount(&lfs, &cfg) => 0; + // there should never exist _2_ hello files + int count = 0; + if (lfs_stat(&lfs, "a/hello", &info) == 0) { + assert(strcmp(info.name, "hello") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 5+8+6 || info.size == 0); + count += 1; + } + if (lfs_stat(&lfs, "b/hello", &info) == 0) { + assert(strcmp(info.name, "hello") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 5+8+6); + count += 1; + } + if (lfs_stat(&lfs, "c/hello", &info) == 0) { + assert(strcmp(info.name, "hello") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 5+8+6); + count += 1; + } + if (lfs_stat(&lfs, "d/hello", &info) == 0) { + assert(strcmp(info.name, "hello") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 5+8+6); + count += 1; + } + assert(count <= 1); + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + if (lfs_stat(&lfs, "a/hello", &info) == 0 && info.size > 0) { + lfs_rename(&lfs, "a/hello", "b/hello") => 0; + } else if (lfs_stat(&lfs, "b/hello", &info) == 0) { + lfs_rename(&lfs, "b/hello", "c/hello") => 0; + } else if (lfs_stat(&lfs, "c/hello", &info) == 0) { + lfs_rename(&lfs, "c/hello", "d/hello") => 0; + } else if (lfs_stat(&lfs, "d/hello", &info) == 0) { + // success + lfs_unmount(&lfs) => 0; + break; + } else { + // create file + lfs_file_open(&lfs, &file, "a/hello", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "hola\n", 5) => 5; + lfs_file_write(&lfs, &file, "bonjour\n", 8) => 8; + lfs_file_write(&lfs, &file, "ohayo\n", 6) => 6; + lfs_file_close(&lfs, &file) => 0; + } + lfs_unmount(&lfs) => 0; + } + + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "a") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_dir_open(&lfs, &dir, "d") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "hello") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 5+8+6); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_file_open(&lfs, &file, "a/hello", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs_file_open(&lfs, &file, "b/hello", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs_file_open(&lfs, &file, "c/hello", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs_file_open(&lfs, &file, "d/hello", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 5) => 5; + memcmp(buffer, "hola\n", 5) => 0; + lfs_file_read(&lfs, &file, buffer, 8) => 8; + memcmp(buffer, "bonjour\n", 8) => 0; + lfs_file_read(&lfs, &file, buffer, 6) => 6; + memcmp(buffer, "ohayo\n", 6) => 0; + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # move dir +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "a") => 0; + lfs_mkdir(&lfs, "b") => 0; + lfs_mkdir(&lfs, "c") => 0; + lfs_mkdir(&lfs, "d") => 0; + lfs_mkdir(&lfs, "a/hi") => 0; + lfs_mkdir(&lfs, "a/hi/hola") => 0; + lfs_mkdir(&lfs, "a/hi/bonjour") => 0; + lfs_mkdir(&lfs, "a/hi/ohayo") => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_rename(&lfs, "a/hi", "c/hi") => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "a") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_dir_open(&lfs, &dir, "c") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "hi") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_dir_open(&lfs, &dir, "a/hi") => LFS_ERR_NOENT; + lfs_dir_open(&lfs, &dir, "b/hi") => LFS_ERR_NOENT; + lfs_dir_open(&lfs, &dir, "c/hi") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "bonjour") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "hola") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "ohayo") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_dir_open(&lfs, &dir, "d/hi") => LFS_ERR_NOENT; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # move dir corrupt source +in = "lfs.c" +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "a") => 0; + lfs_mkdir(&lfs, "b") => 0; + lfs_mkdir(&lfs, "c") => 0; + lfs_mkdir(&lfs, "d") => 0; + lfs_mkdir(&lfs, "a/hi") => 0; + lfs_mkdir(&lfs, "a/hi/hola") => 0; + lfs_mkdir(&lfs, "a/hi/bonjour") => 0; + lfs_mkdir(&lfs, "a/hi/ohayo") => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_rename(&lfs, "a/hi", "c/hi") => 0; + lfs_unmount(&lfs) => 0; + + // corrupt the source + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "a") => 0; + lfs_block_t block = dir.m.pair[0]; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs) => 0; + uint8_t bbuffer[LFS_BLOCK_SIZE]; + cfg.read(&cfg, block, 0, bbuffer, LFS_BLOCK_SIZE) => 0; + int off = LFS_BLOCK_SIZE-1; + while (off >= 0 && bbuffer[off] == LFS_ERASE_VALUE) { + off -= 1; + } + memset(&bbuffer[off-3], LFS_BLOCK_SIZE, 3); + cfg.erase(&cfg, block) => 0; + cfg.prog(&cfg, block, 0, bbuffer, LFS_BLOCK_SIZE) => 0; + cfg.sync(&cfg) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "a") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_dir_open(&lfs, &dir, "c") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "hi") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_dir_open(&lfs, &dir, "a/hi") => LFS_ERR_NOENT; + lfs_dir_open(&lfs, &dir, "b/hi") => LFS_ERR_NOENT; + lfs_dir_open(&lfs, &dir, "c/hi") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "bonjour") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "hola") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "ohayo") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_dir_open(&lfs, &dir, "d/hi") => LFS_ERR_NOENT; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # move dir corrupt source and dest +in = "lfs.c" +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "a") => 0; + lfs_mkdir(&lfs, "b") => 0; + lfs_mkdir(&lfs, "c") => 0; + lfs_mkdir(&lfs, "d") => 0; + lfs_mkdir(&lfs, "a/hi") => 0; + lfs_mkdir(&lfs, "a/hi/hola") => 0; + lfs_mkdir(&lfs, "a/hi/bonjour") => 0; + lfs_mkdir(&lfs, "a/hi/ohayo") => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_rename(&lfs, "a/hi", "c/hi") => 0; + lfs_unmount(&lfs) => 0; + + // corrupt the source + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "a") => 0; + lfs_block_t block = dir.m.pair[0]; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs) => 0; + uint8_t bbuffer[LFS_BLOCK_SIZE]; + cfg.read(&cfg, block, 0, bbuffer, LFS_BLOCK_SIZE) => 0; + int off = LFS_BLOCK_SIZE-1; + while (off >= 0 && bbuffer[off] == LFS_ERASE_VALUE) { + off -= 1; + } + memset(&bbuffer[off-3], LFS_BLOCK_SIZE, 3); + cfg.erase(&cfg, block) => 0; + cfg.prog(&cfg, block, 0, bbuffer, LFS_BLOCK_SIZE) => 0; + cfg.sync(&cfg) => 0; + + // corrupt the destination + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "c") => 0; + block = dir.m.pair[0]; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs) => 0; + cfg.read(&cfg, block, 0, bbuffer, LFS_BLOCK_SIZE) => 0; + off = LFS_BLOCK_SIZE-1; + while (off >= 0 && bbuffer[off] == LFS_ERASE_VALUE) { + off -= 1; + } + memset(&bbuffer[off-3], LFS_BLOCK_SIZE, 3); + cfg.erase(&cfg, block) => 0; + cfg.prog(&cfg, block, 0, bbuffer, LFS_BLOCK_SIZE) => 0; + cfg.sync(&cfg) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "a") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "hi") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_dir_open(&lfs, &dir, "c") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_dir_open(&lfs, &dir, "a/hi") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "bonjour") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "hola") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "ohayo") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_dir_open(&lfs, &dir, "b/hi") => LFS_ERR_NOENT; + lfs_dir_open(&lfs, &dir, "c/hi") => LFS_ERR_NOENT; + lfs_dir_open(&lfs, &dir, "d/hi") => LFS_ERR_NOENT; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # move dir after corrupt +in = "lfs.c" +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "a") => 0; + lfs_mkdir(&lfs, "b") => 0; + lfs_mkdir(&lfs, "c") => 0; + lfs_mkdir(&lfs, "d") => 0; + lfs_mkdir(&lfs, "a/hi") => 0; + lfs_mkdir(&lfs, "a/hi/hola") => 0; + lfs_mkdir(&lfs, "a/hi/bonjour") => 0; + lfs_mkdir(&lfs, "a/hi/ohayo") => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_rename(&lfs, "a/hi", "c/hi") => 0; + lfs_unmount(&lfs) => 0; + + // corrupt the source + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "a") => 0; + lfs_block_t block = dir.m.pair[0]; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs) => 0; + uint8_t bbuffer[LFS_BLOCK_SIZE]; + cfg.read(&cfg, block, 0, bbuffer, LFS_BLOCK_SIZE) => 0; + int off = LFS_BLOCK_SIZE-1; + while (off >= 0 && bbuffer[off] == LFS_ERASE_VALUE) { + off -= 1; + } + memset(&bbuffer[off-3], LFS_BLOCK_SIZE, 3); + cfg.erase(&cfg, block) => 0; + cfg.prog(&cfg, block, 0, bbuffer, LFS_BLOCK_SIZE) => 0; + cfg.sync(&cfg) => 0; + + // corrupt the destination + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "c") => 0; + block = dir.m.pair[0]; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs) => 0; + cfg.read(&cfg, block, 0, bbuffer, LFS_BLOCK_SIZE) => 0; + off = LFS_BLOCK_SIZE-1; + while (off >= 0 && bbuffer[off] == LFS_ERASE_VALUE) { + off -= 1; + } + memset(&bbuffer[off-3], LFS_BLOCK_SIZE, 3); + cfg.erase(&cfg, block) => 0; + cfg.prog(&cfg, block, 0, bbuffer, LFS_BLOCK_SIZE) => 0; + cfg.sync(&cfg) => 0; + + // continue move + lfs_mount(&lfs, &cfg) => 0; + lfs_rename(&lfs, "a/hi", "c/hi") => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "a") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_dir_open(&lfs, &dir, "c") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "hi") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_dir_open(&lfs, &dir, "a/hi") => LFS_ERR_NOENT; + lfs_dir_open(&lfs, &dir, "b/hi") => LFS_ERR_NOENT; + lfs_dir_open(&lfs, &dir, "c/hi") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "bonjour") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "hola") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "ohayo") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_dir_open(&lfs, &dir, "d/hi") => LFS_ERR_NOENT; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # simple reentrant move dir +reentrant = true +code = ''' + err = lfs_mount(&lfs, &cfg); + if (err) { + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + } + err = lfs_mkdir(&lfs, "a"); + assert(!err || err == LFS_ERR_EXIST); + err = lfs_mkdir(&lfs, "b"); + assert(!err || err == LFS_ERR_EXIST); + err = lfs_mkdir(&lfs, "c"); + assert(!err || err == LFS_ERR_EXIST); + err = lfs_mkdir(&lfs, "d"); + assert(!err || err == LFS_ERR_EXIST); + lfs_unmount(&lfs) => 0; + + while (true) { + lfs_mount(&lfs, &cfg) => 0; + // there should never exist _2_ hi directories + int count = 0; + if (lfs_stat(&lfs, "a/hi", &info) == 0) { + assert(strcmp(info.name, "hi") == 0); + assert(info.type == LFS_TYPE_DIR); + count += 1; + } + if (lfs_stat(&lfs, "b/hi", &info) == 0) { + assert(strcmp(info.name, "hi") == 0); + assert(info.type == LFS_TYPE_DIR); + count += 1; + } + if (lfs_stat(&lfs, "c/hi", &info) == 0) { + assert(strcmp(info.name, "hi") == 0); + assert(info.type == LFS_TYPE_DIR); + count += 1; + } + if (lfs_stat(&lfs, "d/hi", &info) == 0) { + assert(strcmp(info.name, "hi") == 0); + assert(info.type == LFS_TYPE_DIR); + count += 1; + } + assert(count <= 1); + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + if (lfs_stat(&lfs, "a/hi", &info) == 0) { + lfs_rename(&lfs, "a/hi", "b/hi") => 0; + } else if (lfs_stat(&lfs, "b/hi", &info) == 0) { + lfs_rename(&lfs, "b/hi", "c/hi") => 0; + } else if (lfs_stat(&lfs, "c/hi", &info) == 0) { + lfs_rename(&lfs, "c/hi", "d/hi") => 0; + } else if (lfs_stat(&lfs, "d/hi", &info) == 0) { + lfs_unmount(&lfs) => 0; + break; // success + } else { + // create dir and rename for atomicity + err = lfs_mkdir(&lfs, "temp"); + assert(!err || err == LFS_ERR_EXIST); + err = lfs_mkdir(&lfs, "temp/hola"); + assert(!err || err == LFS_ERR_EXIST); + err = lfs_mkdir(&lfs, "temp/bonjour"); + assert(!err || err == LFS_ERR_EXIST); + err = lfs_mkdir(&lfs, "temp/ohayo"); + assert(!err || err == LFS_ERR_EXIST); + lfs_rename(&lfs, "temp", "a/hi") => 0; + } + lfs_unmount(&lfs) => 0; + } + + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "a") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_dir_open(&lfs, &dir, "d") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "hi") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_dir_open(&lfs, &dir, "a/hi") => LFS_ERR_NOENT; + lfs_dir_open(&lfs, &dir, "b/hi") => LFS_ERR_NOENT; + lfs_dir_open(&lfs, &dir, "c/hi") => LFS_ERR_NOENT; + lfs_dir_open(&lfs, &dir, "d/hi") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "bonjour") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "hola") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "ohayo") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # move state stealing +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "a") => 0; + lfs_mkdir(&lfs, "b") => 0; + lfs_mkdir(&lfs, "c") => 0; + lfs_mkdir(&lfs, "d") => 0; + lfs_file_open(&lfs, &file, "a/hello", LFS_O_CREAT | LFS_O_WRONLY) => 0; + lfs_file_write(&lfs, &file, "hola\n", 5) => 5; + lfs_file_write(&lfs, &file, "bonjour\n", 8) => 8; + lfs_file_write(&lfs, &file, "ohayo\n", 6) => 6; + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_rename(&lfs, "a/hello", "b/hello") => 0; + lfs_unmount(&lfs) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_rename(&lfs, "b/hello", "c/hello") => 0; + lfs_unmount(&lfs) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_rename(&lfs, "c/hello", "d/hello") => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "a/hello", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs_file_open(&lfs, &file, "b/hello", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs_file_open(&lfs, &file, "c/hello", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs_file_open(&lfs, &file, "d/hello", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 5) => 5; + memcmp(buffer, "hola\n", 5) => 0; + lfs_file_read(&lfs, &file, buffer, 8) => 8; + memcmp(buffer, "bonjour\n", 8) => 0; + lfs_file_read(&lfs, &file, buffer, 6) => 6; + memcmp(buffer, "ohayo\n", 6) => 0; + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_remove(&lfs, "b") => 0; + lfs_remove(&lfs, "c") => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_stat(&lfs, "a", &info) => 0; + lfs_stat(&lfs, "b", &info) => LFS_ERR_NOENT; + lfs_stat(&lfs, "c", &info) => LFS_ERR_NOENT; + lfs_stat(&lfs, "d", &info) => 0; + lfs_file_open(&lfs, &file, "a/hello", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs_file_open(&lfs, &file, "b/hello", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs_file_open(&lfs, &file, "c/hello", LFS_O_RDONLY) => LFS_ERR_NOENT; + lfs_file_open(&lfs, &file, "d/hello", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 5) => 5; + memcmp(buffer, "hola\n", 5) => 0; + lfs_file_read(&lfs, &file, buffer, 8) => 8; + memcmp(buffer, "bonjour\n", 8) => 0; + lfs_file_read(&lfs, &file, buffer, 6) => 6; + memcmp(buffer, "ohayo\n", 6) => 0; + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; +''' + +# Other specific corner cases +[[case]] # create + delete in same commit with neighbors +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + + // littlefs keeps files sorted, so we know the order these will be in + lfs_file_open(&lfs, &file, "/1.move_me", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_close(&lfs, &file) => 0; + + lfs_file_open(&lfs, &file, "/0.before", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "test.1", 7) => 7; + lfs_file_close(&lfs, &file) => 0; + + lfs_file_open(&lfs, &file, "/2.in_between", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "test.2", 7) => 7; + lfs_file_close(&lfs, &file) => 0; + + lfs_file_open(&lfs, &file, "/4.after", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "test.3", 7) => 7; + lfs_file_close(&lfs, &file) => 0; + + lfs_file_t files[3]; + lfs_file_open(&lfs, &files[0], "0.before", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_open(&lfs, &files[1], "2.in_between", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_open(&lfs, &files[2], "4.after", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_write(&lfs, &files[0], "test.4", 7) => 7; + lfs_file_write(&lfs, &files[1], "test.5", 7) => 7; + lfs_file_write(&lfs, &files[2], "test.6", 7) => 7; + + // rename file while everything is open, this triggers both + // a create and delete simultaneously + lfs_rename(&lfs, "/1.move_me", "/3.move_me") => 0; + + lfs_file_close(&lfs, &files[0]) => 0; + lfs_file_close(&lfs, &files[1]) => 0; + lfs_file_close(&lfs, &files[2]) => 0; + + // check that nothing was corrupted + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "0.before") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "2.in_between") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "3.move_me") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "4.after") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_file_open(&lfs, &file, "/0.before", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.4") == 0); + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/2.in_between", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.5") == 0); + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/4.after", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.6") == 0); + lfs_file_close(&lfs, &file) => 0; + + // now move back + lfs_file_open(&lfs, &files[0], "0.before", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_open(&lfs, &files[1], "2.in_between", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_open(&lfs, &files[2], "4.after", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_write(&lfs, &files[0], "test.7", 7) => 7; + lfs_file_write(&lfs, &files[1], "test.8", 7) => 7; + lfs_file_write(&lfs, &files[2], "test.9", 7) => 7; + + // rename file while everything is open, this triggers both + // a create and delete simultaneously + lfs_rename(&lfs, "/3.move_me", "/1.move_me") => 0; + + lfs_file_close(&lfs, &files[0]) => 0; + lfs_file_close(&lfs, &files[1]) => 0; + lfs_file_close(&lfs, &files[2]) => 0; + + // and check that nothing was corrupted again + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "0.before") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "1.move_me") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "2.in_between") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "4.after") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_file_open(&lfs, &file, "/0.before", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.7") == 0); + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/2.in_between", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.8") == 0); + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/4.after", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.9") == 0); + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; +''' + +# Other specific corner cases +[[case]] # create + delete + delete in same commit with neighbors +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + + // littlefs keeps files sorted, so we know the order these will be in + lfs_file_open(&lfs, &file, "/1.move_me", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/3.move_me", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "remove me", + sizeof("remove me")) => sizeof("remove me"); + lfs_file_close(&lfs, &file) => 0; + + lfs_file_open(&lfs, &file, "/0.before", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "test.1", 7) => 7; + lfs_file_close(&lfs, &file) => 0; + + lfs_file_open(&lfs, &file, "/2.in_between", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "test.2", 7) => 7; + lfs_file_close(&lfs, &file) => 0; + + lfs_file_open(&lfs, &file, "/4.after", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "test.3", 7) => 7; + lfs_file_close(&lfs, &file) => 0; + + lfs_file_t files[3]; + lfs_file_open(&lfs, &files[0], "0.before", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_open(&lfs, &files[1], "2.in_between", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_open(&lfs, &files[2], "4.after", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_write(&lfs, &files[0], "test.4", 7) => 7; + lfs_file_write(&lfs, &files[1], "test.5", 7) => 7; + lfs_file_write(&lfs, &files[2], "test.6", 7) => 7; + + // rename file while everything is open, this triggers both + // a create and delete simultaneously + lfs_rename(&lfs, "/1.move_me", "/3.move_me") => 0; + + lfs_file_close(&lfs, &files[0]) => 0; + lfs_file_close(&lfs, &files[1]) => 0; + lfs_file_close(&lfs, &files[2]) => 0; + + // check that nothing was corrupted + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "0.before") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "2.in_between") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "3.move_me") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "4.after") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_file_open(&lfs, &file, "/0.before", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.4") == 0); + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/2.in_between", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.5") == 0); + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/4.after", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.6") == 0); + lfs_file_close(&lfs, &file) => 0; + + // now move back + lfs_file_open(&lfs, &file, "/1.move_me", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "remove me", + sizeof("remove me")) => sizeof("remove me"); + lfs_file_close(&lfs, &file) => 0; + + lfs_file_open(&lfs, &files[0], "0.before", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_open(&lfs, &files[1], "2.in_between", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_open(&lfs, &files[2], "4.after", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_write(&lfs, &files[0], "test.7", 7) => 7; + lfs_file_write(&lfs, &files[1], "test.8", 7) => 7; + lfs_file_write(&lfs, &files[2], "test.9", 7) => 7; + + // rename file while everything is open, this triggers both + // a create and delete simultaneously + lfs_rename(&lfs, "/3.move_me", "/1.move_me") => 0; + + lfs_file_close(&lfs, &files[0]) => 0; + lfs_file_close(&lfs, &files[1]) => 0; + lfs_file_close(&lfs, &files[2]) => 0; + + // and check that nothing was corrupted again + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "0.before") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "1.move_me") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "2.in_between") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "4.after") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_file_open(&lfs, &file, "/0.before", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.7") == 0); + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/2.in_between", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.8") == 0); + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/4.after", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.9") == 0); + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # create + delete in different dirs with neighbors +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + + // littlefs keeps files sorted, so we know the order these will be in + lfs_mkdir(&lfs, "/dir.1") => 0; + lfs_mkdir(&lfs, "/dir.2") => 0; + lfs_file_open(&lfs, &file, "/dir.1/1.move_me", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/dir.2/1.move_me", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "remove me", + sizeof("remove me")) => sizeof("remove me"); + lfs_file_close(&lfs, &file) => 0; + + lfs_file_open(&lfs, &file, "/dir.1/0.before", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "test.1", 7) => 7; + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/dir.1/2.after", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "test.2", 7) => 7; + lfs_file_close(&lfs, &file) => 0; + + lfs_file_open(&lfs, &file, "/dir.2/0.before", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "test.3", 7) => 7; + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/dir.2/2.after", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "test.4", 7) => 7; + lfs_file_close(&lfs, &file) => 0; + + lfs_file_t files[4]; + lfs_file_open(&lfs, &files[0], "/dir.1/0.before", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_open(&lfs, &files[1], "/dir.1/2.after", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_open(&lfs, &files[2], "/dir.2/0.before", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_open(&lfs, &files[3], "/dir.2/2.after", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_write(&lfs, &files[0], "test.5", 7) => 7; + lfs_file_write(&lfs, &files[1], "test.6", 7) => 7; + lfs_file_write(&lfs, &files[2], "test.7", 7) => 7; + lfs_file_write(&lfs, &files[3], "test.8", 7) => 7; + + // rename file while everything is open, this triggers both + // a create and delete as it overwrites the destination file + lfs_rename(&lfs, "/dir.1/1.move_me", "/dir.2/1.move_me") => 0; + + lfs_file_close(&lfs, &files[0]) => 0; + lfs_file_close(&lfs, &files[1]) => 0; + lfs_file_close(&lfs, &files[2]) => 0; + lfs_file_close(&lfs, &files[3]) => 0; + + // check that nothing was corrupted + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "dir.1") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "dir.2") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_dir_open(&lfs, &dir, "/dir.1") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "0.before") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "2.after") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_dir_open(&lfs, &dir, "/dir.2") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "0.before") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "1.move_me") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "2.after") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_file_open(&lfs, &file, "/dir.1/0.before", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.5") == 0); + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/dir.1/2.after", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.6") == 0); + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/dir.2/0.before", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.7") == 0); + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/dir.2/2.after", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.8") == 0); + lfs_file_close(&lfs, &file) => 0; + + // now move back + lfs_file_open(&lfs, &file, "/dir.1/1.move_me", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "remove me", + sizeof("remove me")) => sizeof("remove me"); + lfs_file_close(&lfs, &file) => 0; + + lfs_file_open(&lfs, &files[0], "/dir.1/0.before", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_open(&lfs, &files[1], "/dir.1/2.after", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_open(&lfs, &files[2], "/dir.2/0.before", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_open(&lfs, &files[3], "/dir.2/2.after", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_write(&lfs, &files[0], "test.9", 7) => 7; + lfs_file_write(&lfs, &files[1], "test.a", 7) => 7; + lfs_file_write(&lfs, &files[2], "test.b", 7) => 7; + lfs_file_write(&lfs, &files[3], "test.c", 7) => 7; + + // rename file while everything is open, this triggers both + // a create and delete simultaneously + lfs_rename(&lfs, "/dir.2/1.move_me", "/dir.1/1.move_me") => 0; + + lfs_file_close(&lfs, &files[0]) => 0; + lfs_file_close(&lfs, &files[1]) => 0; + lfs_file_close(&lfs, &files[2]) => 0; + lfs_file_close(&lfs, &files[3]) => 0; + + // and check that nothing was corrupted again + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "dir.1") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "dir.2") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_dir_open(&lfs, &dir, "/dir.1") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "0.before") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "1.move_me") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 0); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "2.after") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_dir_open(&lfs, &dir, "/dir.2") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "0.before") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "2.after") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_file_open(&lfs, &file, "/dir.1/0.before", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.9") == 0); + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/dir.1/2.after", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.a") == 0); + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/dir.2/0.before", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.b") == 0); + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/dir.2/2.after", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.c") == 0); + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # move fix in relocation +in = "lfs.c" +define.RELOCATIONS = 'range(0x3+1)' +define.LFS_ERASE_CYCLES = 0xffffffff +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + + lfs_mkdir(&lfs, "/parent") => 0; + lfs_mkdir(&lfs, "/parent/child") => 0; + + lfs_file_open(&lfs, &file, "/parent/1.move_me", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "move me", + sizeof("move me")) => sizeof("move me"); + lfs_file_close(&lfs, &file) => 0; + + lfs_file_open(&lfs, &file, "/parent/0.before", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "test.1", 7) => 7; + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/parent/2.after", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "test.2", 7) => 7; + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/parent/child/0.before", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "test.3", 7) => 7; + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/parent/child/2.after", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "test.4", 7) => 7; + lfs_file_close(&lfs, &file) => 0; + + lfs_file_t files[4]; + lfs_file_open(&lfs, &files[0], "/parent/0.before", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_open(&lfs, &files[1], "/parent/2.after", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_open(&lfs, &files[2], "/parent/child/0.before", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_open(&lfs, &files[3], "/parent/child/2.after", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_write(&lfs, &files[0], "test.5", 7) => 7; + lfs_file_write(&lfs, &files[1], "test.6", 7) => 7; + lfs_file_write(&lfs, &files[2], "test.7", 7) => 7; + lfs_file_write(&lfs, &files[3], "test.8", 7) => 7; + + // force specific directories to relocate + if (RELOCATIONS & 0x1) { + lfs_dir_open(&lfs, &dir, "/parent"); + lfs_testbd_setwear(&cfg, dir.m.pair[0], 0xffffffff) => 0; + lfs_testbd_setwear(&cfg, dir.m.pair[1], 0xffffffff) => 0; + lfs_dir_close(&lfs, &dir) => 0; + } + if (RELOCATIONS & 0x2) { + lfs_dir_open(&lfs, &dir, "/parent/child"); + lfs_testbd_setwear(&cfg, dir.m.pair[0], 0xffffffff) => 0; + lfs_testbd_setwear(&cfg, dir.m.pair[1], 0xffffffff) => 0; + lfs_dir_close(&lfs, &dir) => 0; + } + + // ok, now we move the file, this creates a move that needs to be + // fixed, possibly in a metadata-pair that needs to be relocated + // + // the worst case is if we need to relocate and we need to implicit + // fix the move in our parent before it falls out of date + lfs_rename(&lfs, "/parent/1.move_me", "/parent/child/1.move_me") => 0; + + lfs_file_close(&lfs, &files[0]) => 0; + lfs_file_close(&lfs, &files[1]) => 0; + lfs_file_close(&lfs, &files[2]) => 0; + lfs_file_close(&lfs, &files[3]) => 0; + + // check that nothing was corrupted + lfs_dir_open(&lfs, &dir, "/parent") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "0.before") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "2.after") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "child") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_dir_open(&lfs, &dir, "/parent/child") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "0.before") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "1.move_me") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == sizeof("move me")); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "2.after") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_file_open(&lfs, &file, "/parent/0.before", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.5") == 0); + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/parent/2.after", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.6") == 0); + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/parent/child/0.before", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.7") == 0); + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/parent/child/2.after", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.8") == 0); + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # move fix in relocation with predecessor +in = "lfs.c" +define.RELOCATIONS = 'range(0x7+1)' +define.LFS_ERASE_CYCLES = 0xffffffff +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + + lfs_mkdir(&lfs, "/parent") => 0; + lfs_mkdir(&lfs, "/parent/child") => 0; + lfs_mkdir(&lfs, "/parent/sibling") => 0; + + lfs_file_open(&lfs, &file, "/parent/sibling/1.move_me", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "move me", + sizeof("move me")) => sizeof("move me"); + lfs_file_close(&lfs, &file) => 0; + + lfs_file_open(&lfs, &file, "/parent/sibling/0.before", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "test.1", 7) => 7; + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/parent/sibling/2.after", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "test.2", 7) => 7; + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/parent/child/0.before", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "test.3", 7) => 7; + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/parent/child/2.after", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_write(&lfs, &file, "test.4", 7) => 7; + lfs_file_close(&lfs, &file) => 0; + + lfs_file_t files[4]; + lfs_file_open(&lfs, &files[0], "/parent/sibling/0.before", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_open(&lfs, &files[1], "/parent/sibling/2.after", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_open(&lfs, &files[2], "/parent/child/0.before", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_open(&lfs, &files[3], "/parent/child/2.after", + LFS_O_WRONLY | LFS_O_TRUNC) => 0; + lfs_file_write(&lfs, &files[0], "test.5", 7) => 7; + lfs_file_write(&lfs, &files[1], "test.6", 7) => 7; + lfs_file_write(&lfs, &files[2], "test.7", 7) => 7; + lfs_file_write(&lfs, &files[3], "test.8", 7) => 7; + + // force specific directories to relocate + if (RELOCATIONS & 0x1) { + lfs_dir_open(&lfs, &dir, "/parent"); + lfs_testbd_setwear(&cfg, dir.m.pair[0], 0xffffffff) => 0; + lfs_testbd_setwear(&cfg, dir.m.pair[1], 0xffffffff) => 0; + lfs_dir_close(&lfs, &dir) => 0; + } + if (RELOCATIONS & 0x2) { + lfs_dir_open(&lfs, &dir, "/parent/sibling"); + lfs_testbd_setwear(&cfg, dir.m.pair[0], 0xffffffff) => 0; + lfs_testbd_setwear(&cfg, dir.m.pair[1], 0xffffffff) => 0; + lfs_dir_close(&lfs, &dir) => 0; + } + if (RELOCATIONS & 0x4) { + lfs_dir_open(&lfs, &dir, "/parent/child"); + lfs_testbd_setwear(&cfg, dir.m.pair[0], 0xffffffff) => 0; + lfs_testbd_setwear(&cfg, dir.m.pair[1], 0xffffffff) => 0; + lfs_dir_close(&lfs, &dir) => 0; + } + + // ok, now we move the file, this creates a move that needs to be + // fixed, possibly in a metadata-pair that needs to be relocated + // + // and now relocations can force us to need to fix our move in either + // the parent or child before things break + lfs_rename(&lfs, + "/parent/sibling/1.move_me", + "/parent/child/1.move_me") => 0; + + lfs_file_close(&lfs, &files[0]) => 0; + lfs_file_close(&lfs, &files[1]) => 0; + lfs_file_close(&lfs, &files[2]) => 0; + lfs_file_close(&lfs, &files[3]) => 0; + + // check that nothing was corrupted + lfs_dir_open(&lfs, &dir, "/parent") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "child") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "sibling") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_dir_open(&lfs, &dir, "/parent/sibling") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "0.before") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "2.after") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_dir_open(&lfs, &dir, "/parent/child") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, ".") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "..") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "0.before") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "1.move_me") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == sizeof("move me")); + lfs_dir_read(&lfs, &dir, &info) => 1; + assert(strcmp(info.name, "2.after") == 0); + assert(info.type == LFS_TYPE_REG); + assert(info.size == 7); + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; + + lfs_file_open(&lfs, &file, "/parent/sibling/0.before", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.5") == 0); + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/parent/sibling/2.after", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.6") == 0); + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/parent/child/0.before", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.7") == 0); + lfs_file_close(&lfs, &file) => 0; + lfs_file_open(&lfs, &file, "/parent/child/2.after", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, 7) => 7; + assert(strcmp((char*)buffer, "test.8") == 0); + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; +''' diff --git a/tests/test_orphan.sh b/tests/test_orphan.sh deleted file mode 100755 index b0a8493..0000000 --- a/tests/test_orphan.sh +++ /dev/null @@ -1,46 +0,0 @@ -#!/bin/bash -set -eu -export TEST_FILE=$0 -trap 'export TEST_LINE=$LINENO' DEBUG - -echo "=== Orphan tests ===" -rm -rf blocks -scripts/test.py << TEST - lfs_format(&lfs, &cfg) => 0; -TEST - -echo "--- Orphan test ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_mkdir(&lfs, "parent") => 0; - lfs_mkdir(&lfs, "parent/orphan") => 0; - lfs_mkdir(&lfs, "parent/child") => 0; - lfs_remove(&lfs, "parent/orphan") => 0; -TEST -# corrupt most recent commit, this should be the update to the previous -# linked-list entry and should orphan the child -scripts/corrupt.py -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - - lfs_stat(&lfs, "parent/orphan", &info) => LFS_ERR_NOENT; - lfs_ssize_t before = lfs_fs_size(&lfs); - before => 8; - - lfs_unmount(&lfs) => 0; - lfs_mount(&lfs, &cfg) => 0; - - lfs_stat(&lfs, "parent/orphan", &info) => LFS_ERR_NOENT; - lfs_ssize_t orphaned = lfs_fs_size(&lfs); - orphaned => 8; - - lfs_mkdir(&lfs, "parent/otherchild") => 0; - - lfs_stat(&lfs, "parent/orphan", &info) => LFS_ERR_NOENT; - lfs_ssize_t deorphaned = lfs_fs_size(&lfs); - deorphaned => 8; - - lfs_unmount(&lfs) => 0; -TEST - -scripts/results.py diff --git a/tests/test_orphans.toml b/tests/test_orphans.toml new file mode 100644 index 0000000..3bf0454 --- /dev/null +++ b/tests/test_orphans.toml @@ -0,0 +1,117 @@ +[[case]] # orphan test +in = "lfs.c" +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "parent") => 0; + lfs_mkdir(&lfs, "parent/orphan") => 0; + lfs_mkdir(&lfs, "parent/child") => 0; + lfs_remove(&lfs, "parent/orphan") => 0; + lfs_unmount(&lfs) => 0; + + // corrupt the child's most recent commit, this should be the update + // to the linked-list entry, which should orphan the orphan. Note this + // makes a lot of assumptions about the remove operation. + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "parent/child") => 0; + lfs_block_t block = dir.m.pair[0]; + lfs_dir_close(&lfs, &dir) => 0; + lfs_unmount(&lfs) => 0; + uint8_t bbuffer[LFS_BLOCK_SIZE]; + cfg.read(&cfg, block, 0, bbuffer, LFS_BLOCK_SIZE) => 0; + int off = LFS_BLOCK_SIZE-1; + while (off >= 0 && bbuffer[off] == LFS_ERASE_VALUE) { + off -= 1; + } + memset(&bbuffer[off-3], LFS_BLOCK_SIZE, 3); + cfg.erase(&cfg, block) => 0; + cfg.prog(&cfg, block, 0, bbuffer, LFS_BLOCK_SIZE) => 0; + cfg.sync(&cfg) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_stat(&lfs, "parent/orphan", &info) => LFS_ERR_NOENT; + lfs_stat(&lfs, "parent/child", &info) => 0; + lfs_fs_size(&lfs) => 8; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_stat(&lfs, "parent/orphan", &info) => LFS_ERR_NOENT; + lfs_stat(&lfs, "parent/child", &info) => 0; + lfs_fs_size(&lfs) => 8; + // this mkdir should both create a dir and deorphan, so size + // should be unchanged + lfs_mkdir(&lfs, "parent/otherchild") => 0; + lfs_stat(&lfs, "parent/orphan", &info) => LFS_ERR_NOENT; + lfs_stat(&lfs, "parent/child", &info) => 0; + lfs_stat(&lfs, "parent/otherchild", &info) => 0; + lfs_fs_size(&lfs) => 8; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_stat(&lfs, "parent/orphan", &info) => LFS_ERR_NOENT; + lfs_stat(&lfs, "parent/child", &info) => 0; + lfs_stat(&lfs, "parent/otherchild", &info) => 0; + lfs_fs_size(&lfs) => 8; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # reentrant testing for orphans, basically just spam mkdir/remove +reentrant = true +define = [ + {FILES=6, DEPTH=1, CYCLES=50}, + {FILES=26, DEPTH=1, CYCLES=50}, + {FILES=3, DEPTH=3, CYCLES=50}, +] +code = ''' + err = lfs_mount(&lfs, &cfg); + if (err) { + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + } + + srand(1); + const char alpha[] = "abcdefghijklmnopqrstuvwxyz"; + for (int i = 0; i < CYCLES; i++) { + // create random path + char full_path[256]; + for (int d = 0; d < DEPTH; d++) { + sprintf(&full_path[2*d], "/%c", alpha[rand() % FILES]); + } + + // if it does not exist, we create it, else we destroy + int res = lfs_stat(&lfs, full_path, &info); + if (res == LFS_ERR_NOENT) { + // create each directory in turn, ignore if dir already exists + for (int d = 0; d < DEPTH; d++) { + strcpy(path, full_path); + path[2*d+2] = '\0'; + err = lfs_mkdir(&lfs, path); + assert(!err || err == LFS_ERR_EXIST); + } + + for (int d = 0; d < DEPTH; d++) { + 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 (int d = DEPTH-1; d >= 0; d--) { + 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; +''' + diff --git a/tests/test_paths.sh b/tests/test_paths.sh deleted file mode 100755 index cfdcd98..0000000 --- a/tests/test_paths.sh +++ /dev/null @@ -1,202 +0,0 @@ -#!/bin/bash -set -eu -export TEST_FILE=$0 -trap 'export TEST_LINE=$LINENO' DEBUG - -echo "=== Path tests ===" -rm -rf blocks -scripts/test.py << TEST - lfs_format(&lfs, &cfg) => 0; -TEST - -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_mkdir(&lfs, "tea") => 0; - lfs_mkdir(&lfs, "coffee") => 0; - lfs_mkdir(&lfs, "soda") => 0; - lfs_mkdir(&lfs, "tea/hottea") => 0; - lfs_mkdir(&lfs, "tea/warmtea") => 0; - lfs_mkdir(&lfs, "tea/coldtea") => 0; - lfs_mkdir(&lfs, "coffee/hotcoffee") => 0; - lfs_mkdir(&lfs, "coffee/warmcoffee") => 0; - lfs_mkdir(&lfs, "coffee/coldcoffee") => 0; - lfs_mkdir(&lfs, "soda/hotsoda") => 0; - lfs_mkdir(&lfs, "soda/warmsoda") => 0; - lfs_mkdir(&lfs, "soda/coldsoda") => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Root path tests ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_stat(&lfs, "tea/hottea", &info) => 0; - strcmp(info.name, "hottea") => 0; - lfs_stat(&lfs, "/tea/hottea", &info) => 0; - strcmp(info.name, "hottea") => 0; - - lfs_mkdir(&lfs, "/milk1") => 0; - lfs_stat(&lfs, "/milk1", &info) => 0; - strcmp(info.name, "milk1") => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Redundant slash path tests ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_stat(&lfs, "/tea/hottea", &info) => 0; - strcmp(info.name, "hottea") => 0; - lfs_stat(&lfs, "//tea//hottea", &info) => 0; - strcmp(info.name, "hottea") => 0; - lfs_stat(&lfs, "///tea///hottea", &info) => 0; - strcmp(info.name, "hottea") => 0; - - lfs_mkdir(&lfs, "///milk2") => 0; - lfs_stat(&lfs, "///milk2", &info) => 0; - strcmp(info.name, "milk2") => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Dot path tests ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_stat(&lfs, "./tea/hottea", &info) => 0; - strcmp(info.name, "hottea") => 0; - lfs_stat(&lfs, "/./tea/hottea", &info) => 0; - strcmp(info.name, "hottea") => 0; - lfs_stat(&lfs, "/././tea/hottea", &info) => 0; - strcmp(info.name, "hottea") => 0; - lfs_stat(&lfs, "/./tea/./hottea", &info) => 0; - strcmp(info.name, "hottea") => 0; - - lfs_mkdir(&lfs, "/./milk3") => 0; - lfs_stat(&lfs, "/./milk3", &info) => 0; - strcmp(info.name, "milk3") => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Dot dot path tests ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_stat(&lfs, "coffee/../tea/hottea", &info) => 0; - strcmp(info.name, "hottea") => 0; - lfs_stat(&lfs, "tea/coldtea/../hottea", &info) => 0; - strcmp(info.name, "hottea") => 0; - lfs_stat(&lfs, "coffee/coldcoffee/../../tea/hottea", &info) => 0; - strcmp(info.name, "hottea") => 0; - lfs_stat(&lfs, "coffee/../soda/../tea/hottea", &info) => 0; - strcmp(info.name, "hottea") => 0; - - lfs_mkdir(&lfs, "coffee/../milk4") => 0; - lfs_stat(&lfs, "coffee/../milk4", &info) => 0; - strcmp(info.name, "milk4") => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Trailing dot path tests ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_stat(&lfs, "tea/hottea/", &info) => 0; - strcmp(info.name, "hottea") => 0; - lfs_stat(&lfs, "tea/hottea/.", &info) => 0; - strcmp(info.name, "hottea") => 0; - lfs_stat(&lfs, "tea/hottea/./.", &info) => 0; - strcmp(info.name, "hottea") => 0; - lfs_stat(&lfs, "tea/hottea/..", &info) => 0; - strcmp(info.name, "tea") => 0; - lfs_stat(&lfs, "tea/hottea/../.", &info) => 0; - strcmp(info.name, "tea") => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Root dot dot path tests ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_stat(&lfs, "coffee/../../../../../../tea/hottea", &info) => 0; - strcmp(info.name, "hottea") => 0; - - lfs_mkdir(&lfs, "coffee/../../../../../../milk5") => 0; - lfs_stat(&lfs, "coffee/../../../../../../milk5", &info) => 0; - strcmp(info.name, "milk5") => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Root tests ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_stat(&lfs, "/", &info) => 0; - info.type => LFS_TYPE_DIR; - strcmp(info.name, "/") => 0; - - lfs_mkdir(&lfs, "/") => LFS_ERR_EXIST; - lfs_file_open(&lfs, &file, "/", LFS_O_WRONLY | LFS_O_CREAT) - => LFS_ERR_ISDIR; - - // more corner cases - lfs_remove(&lfs, "") => LFS_ERR_INVAL; - lfs_remove(&lfs, ".") => LFS_ERR_INVAL; - lfs_remove(&lfs, "..") => LFS_ERR_INVAL; - lfs_remove(&lfs, "/") => LFS_ERR_INVAL; - lfs_remove(&lfs, "//") => LFS_ERR_INVAL; - lfs_remove(&lfs, "./") => LFS_ERR_INVAL; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Sketchy path tests ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_mkdir(&lfs, "dirt/ground") => LFS_ERR_NOENT; - lfs_mkdir(&lfs, "dirt/ground/earth") => LFS_ERR_NOENT; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Superblock conflict test ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_mkdir(&lfs, "littlefs") => 0; - lfs_remove(&lfs, "littlefs") => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Max path test ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - memset(path, 'w', LFS_NAME_MAX+1); - path[LFS_NAME_MAX+2] = '\0'; - lfs_mkdir(&lfs, path) => LFS_ERR_NAMETOOLONG; - lfs_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NAMETOOLONG; - - memcpy(path, "coffee/", strlen("coffee/")); - memset(path+strlen("coffee/"), 'w', LFS_NAME_MAX+1); - path[strlen("coffee/")+LFS_NAME_MAX+2] = '\0'; - lfs_mkdir(&lfs, path) => LFS_ERR_NAMETOOLONG; - lfs_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NAMETOOLONG; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Really big path test ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - memset(path, 'w', LFS_NAME_MAX); - path[LFS_NAME_MAX] = '\0'; - lfs_mkdir(&lfs, path) => 0; - lfs_remove(&lfs, path) => 0; - lfs_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfs_file_close(&lfs, &file) => 0; - lfs_remove(&lfs, path) => 0; - - memcpy(path, "coffee/", strlen("coffee/")); - memset(path+strlen("coffee/"), 'w', LFS_NAME_MAX); - path[strlen("coffee/")+LFS_NAME_MAX] = '\0'; - lfs_mkdir(&lfs, path) => 0; - lfs_remove(&lfs, path) => 0; - lfs_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfs_file_close(&lfs, &file) => 0; - lfs_remove(&lfs, path) => 0; - lfs_unmount(&lfs) => 0; -TEST - -scripts/results.py diff --git a/tests/test_paths.toml b/tests/test_paths.toml new file mode 100644 index 0000000..480dd9a --- /dev/null +++ b/tests/test_paths.toml @@ -0,0 +1,294 @@ + +[[case]] # simple path test +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "tea") => 0; + lfs_mkdir(&lfs, "tea/hottea") => 0; + lfs_mkdir(&lfs, "tea/warmtea") => 0; + lfs_mkdir(&lfs, "tea/coldtea") => 0; + + lfs_stat(&lfs, "tea/hottea", &info) => 0; + assert(strcmp(info.name, "hottea") == 0); + lfs_stat(&lfs, "/tea/hottea", &info) => 0; + assert(strcmp(info.name, "hottea") == 0); + + lfs_mkdir(&lfs, "/milk") => 0; + lfs_stat(&lfs, "/milk", &info) => 0; + assert(strcmp(info.name, "milk") == 0); + lfs_stat(&lfs, "milk", &info) => 0; + assert(strcmp(info.name, "milk") == 0); + lfs_unmount(&lfs) => 0; +''' + +[[case]] # redundant slashes +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "tea") => 0; + lfs_mkdir(&lfs, "tea/hottea") => 0; + lfs_mkdir(&lfs, "tea/warmtea") => 0; + lfs_mkdir(&lfs, "tea/coldtea") => 0; + + lfs_stat(&lfs, "/tea/hottea", &info) => 0; + assert(strcmp(info.name, "hottea") == 0); + lfs_stat(&lfs, "//tea//hottea", &info) => 0; + assert(strcmp(info.name, "hottea") == 0); + lfs_stat(&lfs, "///tea///hottea", &info) => 0; + assert(strcmp(info.name, "hottea") == 0); + + lfs_mkdir(&lfs, "////milk") => 0; + lfs_stat(&lfs, "////milk", &info) => 0; + assert(strcmp(info.name, "milk") == 0); + lfs_stat(&lfs, "milk", &info) => 0; + assert(strcmp(info.name, "milk") == 0); + lfs_unmount(&lfs) => 0; +''' + +[[case]] # dot path test +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "tea") => 0; + lfs_mkdir(&lfs, "tea/hottea") => 0; + lfs_mkdir(&lfs, "tea/warmtea") => 0; + lfs_mkdir(&lfs, "tea/coldtea") => 0; + + lfs_stat(&lfs, "./tea/hottea", &info) => 0; + assert(strcmp(info.name, "hottea") == 0); + lfs_stat(&lfs, "/./tea/hottea", &info) => 0; + assert(strcmp(info.name, "hottea") == 0); + lfs_stat(&lfs, "/././tea/hottea", &info) => 0; + assert(strcmp(info.name, "hottea") == 0); + lfs_stat(&lfs, "/./tea/./hottea", &info) => 0; + assert(strcmp(info.name, "hottea") == 0); + + lfs_mkdir(&lfs, "/./milk") => 0; + lfs_stat(&lfs, "/./milk", &info) => 0; + assert(strcmp(info.name, "milk") == 0); + lfs_stat(&lfs, "milk", &info) => 0; + assert(strcmp(info.name, "milk") == 0); + lfs_unmount(&lfs) => 0; +''' + +[[case]] # dot dot path test +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "tea") => 0; + lfs_mkdir(&lfs, "tea/hottea") => 0; + lfs_mkdir(&lfs, "tea/warmtea") => 0; + lfs_mkdir(&lfs, "tea/coldtea") => 0; + lfs_mkdir(&lfs, "coffee") => 0; + lfs_mkdir(&lfs, "coffee/hotcoffee") => 0; + lfs_mkdir(&lfs, "coffee/warmcoffee") => 0; + lfs_mkdir(&lfs, "coffee/coldcoffee") => 0; + + lfs_stat(&lfs, "coffee/../tea/hottea", &info) => 0; + assert(strcmp(info.name, "hottea") == 0); + lfs_stat(&lfs, "tea/coldtea/../hottea", &info) => 0; + assert(strcmp(info.name, "hottea") == 0); + lfs_stat(&lfs, "coffee/coldcoffee/../../tea/hottea", &info) => 0; + assert(strcmp(info.name, "hottea") == 0); + lfs_stat(&lfs, "coffee/../coffee/../tea/hottea", &info) => 0; + assert(strcmp(info.name, "hottea") == 0); + + lfs_mkdir(&lfs, "coffee/../milk") => 0; + lfs_stat(&lfs, "coffee/../milk", &info) => 0; + strcmp(info.name, "milk") => 0; + lfs_stat(&lfs, "milk", &info) => 0; + strcmp(info.name, "milk") => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # trailing dot path test +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "tea") => 0; + lfs_mkdir(&lfs, "tea/hottea") => 0; + lfs_mkdir(&lfs, "tea/warmtea") => 0; + lfs_mkdir(&lfs, "tea/coldtea") => 0; + + lfs_stat(&lfs, "tea/hottea/", &info) => 0; + assert(strcmp(info.name, "hottea") == 0); + lfs_stat(&lfs, "tea/hottea/.", &info) => 0; + assert(strcmp(info.name, "hottea") == 0); + lfs_stat(&lfs, "tea/hottea/./.", &info) => 0; + assert(strcmp(info.name, "hottea") == 0); + lfs_stat(&lfs, "tea/hottea/..", &info) => 0; + assert(strcmp(info.name, "tea") == 0); + lfs_stat(&lfs, "tea/hottea/../.", &info) => 0; + assert(strcmp(info.name, "tea") == 0); + lfs_unmount(&lfs) => 0; +''' + +[[case]] # leading dot path test +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, ".milk") => 0; + lfs_stat(&lfs, ".milk", &info) => 0; + strcmp(info.name, ".milk") => 0; + lfs_stat(&lfs, "tea/.././.milk", &info) => 0; + strcmp(info.name, ".milk") => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # root dot dot path test +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "tea") => 0; + lfs_mkdir(&lfs, "tea/hottea") => 0; + lfs_mkdir(&lfs, "tea/warmtea") => 0; + lfs_mkdir(&lfs, "tea/coldtea") => 0; + lfs_mkdir(&lfs, "coffee") => 0; + lfs_mkdir(&lfs, "coffee/hotcoffee") => 0; + lfs_mkdir(&lfs, "coffee/warmcoffee") => 0; + lfs_mkdir(&lfs, "coffee/coldcoffee") => 0; + + lfs_stat(&lfs, "coffee/../../../../../../tea/hottea", &info) => 0; + strcmp(info.name, "hottea") => 0; + + lfs_mkdir(&lfs, "coffee/../../../../../../milk") => 0; + lfs_stat(&lfs, "coffee/../../../../../../milk", &info) => 0; + strcmp(info.name, "milk") => 0; + lfs_stat(&lfs, "milk", &info) => 0; + strcmp(info.name, "milk") => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # invalid path tests +code = ''' + lfs_format(&lfs, &cfg); + lfs_mount(&lfs, &cfg) => 0; + lfs_stat(&lfs, "dirt", &info) => LFS_ERR_NOENT; + lfs_stat(&lfs, "dirt/ground", &info) => LFS_ERR_NOENT; + lfs_stat(&lfs, "dirt/ground/earth", &info) => LFS_ERR_NOENT; + + lfs_remove(&lfs, "dirt") => LFS_ERR_NOENT; + lfs_remove(&lfs, "dirt/ground") => LFS_ERR_NOENT; + lfs_remove(&lfs, "dirt/ground/earth") => LFS_ERR_NOENT; + + lfs_mkdir(&lfs, "dirt/ground") => LFS_ERR_NOENT; + lfs_file_open(&lfs, &file, "dirt/ground", LFS_O_WRONLY | LFS_O_CREAT) + => LFS_ERR_NOENT; + lfs_mkdir(&lfs, "dirt/ground/earth") => LFS_ERR_NOENT; + lfs_file_open(&lfs, &file, "dirt/ground/earth", LFS_O_WRONLY | LFS_O_CREAT) + => LFS_ERR_NOENT; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # root operations +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_stat(&lfs, "/", &info) => 0; + assert(strcmp(info.name, "/") == 0); + assert(info.type == LFS_TYPE_DIR); + + lfs_mkdir(&lfs, "/") => LFS_ERR_EXIST; + lfs_file_open(&lfs, &file, "/", LFS_O_WRONLY | LFS_O_CREAT) + => LFS_ERR_ISDIR; + + lfs_remove(&lfs, "/") => LFS_ERR_INVAL; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # root representations +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_stat(&lfs, "/", &info) => 0; + assert(strcmp(info.name, "/") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_stat(&lfs, "", &info) => 0; + assert(strcmp(info.name, "/") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_stat(&lfs, ".", &info) => 0; + assert(strcmp(info.name, "/") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_stat(&lfs, "..", &info) => 0; + assert(strcmp(info.name, "/") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_stat(&lfs, "//", &info) => 0; + assert(strcmp(info.name, "/") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_stat(&lfs, "./", &info) => 0; + assert(strcmp(info.name, "/") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_unmount(&lfs) => 0; +''' + +[[case]] # superblock conflict test +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_stat(&lfs, "littlefs", &info) => LFS_ERR_NOENT; + lfs_remove(&lfs, "littlefs") => LFS_ERR_NOENT; + + lfs_mkdir(&lfs, "littlefs") => 0; + lfs_stat(&lfs, "littlefs", &info) => 0; + assert(strcmp(info.name, "littlefs") == 0); + assert(info.type == LFS_TYPE_DIR); + lfs_remove(&lfs, "littlefs") => 0; + lfs_stat(&lfs, "littlefs", &info) => LFS_ERR_NOENT; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # max path test +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "coffee") => 0; + lfs_mkdir(&lfs, "coffee/hotcoffee") => 0; + lfs_mkdir(&lfs, "coffee/warmcoffee") => 0; + lfs_mkdir(&lfs, "coffee/coldcoffee") => 0; + + memset(path, 'w', LFS_NAME_MAX+1); + path[LFS_NAME_MAX+2] = '\0'; + lfs_mkdir(&lfs, path) => LFS_ERR_NAMETOOLONG; + lfs_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT) + => LFS_ERR_NAMETOOLONG; + + memcpy(path, "coffee/", strlen("coffee/")); + memset(path+strlen("coffee/"), 'w', LFS_NAME_MAX+1); + path[strlen("coffee/")+LFS_NAME_MAX+2] = '\0'; + lfs_mkdir(&lfs, path) => LFS_ERR_NAMETOOLONG; + lfs_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT) + => LFS_ERR_NAMETOOLONG; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # really big path test +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_mkdir(&lfs, "coffee") => 0; + lfs_mkdir(&lfs, "coffee/hotcoffee") => 0; + lfs_mkdir(&lfs, "coffee/warmcoffee") => 0; + lfs_mkdir(&lfs, "coffee/coldcoffee") => 0; + + lfs_mount(&lfs, &cfg) => 0; + memset(path, 'w', LFS_NAME_MAX); + path[LFS_NAME_MAX] = '\0'; + lfs_mkdir(&lfs, path) => 0; + lfs_remove(&lfs, path) => 0; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_close(&lfs, &file) => 0; + lfs_remove(&lfs, path) => 0; + + memcpy(path, "coffee/", strlen("coffee/")); + memset(path+strlen("coffee/"), 'w', LFS_NAME_MAX); + path[strlen("coffee/")+LFS_NAME_MAX] = '\0'; + lfs_mkdir(&lfs, path) => 0; + lfs_remove(&lfs, path) => 0; + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_close(&lfs, &file) => 0; + lfs_remove(&lfs, path) => 0; + lfs_unmount(&lfs) => 0; +''' + diff --git a/tests/test_relocations.sh b/tests/test_relocations.sh deleted file mode 100755 index 5244e5e..0000000 --- a/tests/test_relocations.sh +++ /dev/null @@ -1,139 +0,0 @@ -#!/bin/bash -set -eu -export TEST_FILE=$0 -trap 'export TEST_LINE=$LINENO' DEBUG - -ITERATIONS=20 -COUNT=10 - -echo "=== Relocation tests ===" -rm -rf blocks -scripts/test.py << TEST - lfs_format(&lfs, &cfg) => 0; - // fill up filesystem so only ~16 blocks are left - lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file, "padding", LFS_O_CREAT | LFS_O_WRONLY) => 0; - memset(buffer, 0, 512); - while (LFS_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; -TEST - -echo "--- Dangling split dir test ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - for (int j = 0; j < $ITERATIONS; j++) { - for (int i = 0; i < $COUNT; i++) { - 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_open(&lfs, &dir, "child") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - lfs_dir_read(&lfs, &dir, &info) => 1; - for (int i = 0; i < $COUNT; i++) { - 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 == $ITERATIONS-1) { - break; - } - - for (int i = 0; i < $COUNT; i++) { - sprintf(path, "child/test%03d_loooooooooooooooooong_name", i); - lfs_remove(&lfs, path) => 0; - } - } - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir, "child") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - lfs_dir_read(&lfs, &dir, &info) => 1; - for (int i = 0; i < $COUNT; i++) { - 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 (int i = 0; i < $COUNT; i++) { - sprintf(path, "child/test%03d_loooooooooooooooooong_name", i); - lfs_remove(&lfs, path) => 0; - } - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Outdated head test ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - for (int j = 0; j < $ITERATIONS; j++) { - for (int i = 0; i < $COUNT; i++) { - 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_open(&lfs, &dir, "child") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - lfs_dir_read(&lfs, &dir, &info) => 1; - for (int i = 0; i < $COUNT; i++) { - 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 (int i = 0; i < $COUNT; i++) { - 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 (int i = 0; i < $COUNT; i++) { - 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 (int i = 0; i < $COUNT; i++) { - sprintf(path, "child/test%03d_loooooooooooooooooong_name", i); - lfs_remove(&lfs, path) => 0; - } - } - lfs_unmount(&lfs) => 0; -TEST - -scripts/results.py diff --git a/tests/test_relocations.toml b/tests/test_relocations.toml new file mode 100644 index 0000000..ad267b5 --- /dev/null +++ b/tests/test_relocations.toml @@ -0,0 +1,301 @@ +# specific corner cases worth explicitly testing for +[[case]] # dangling split dir test +define.ITERATIONS = 20 +define.COUNT = 10 +define.LFS_BLOCK_CYCLES = [8, 1] +code = ''' + lfs_format(&lfs, &cfg) => 0; + // fill up filesystem so only ~16 blocks are left + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "padding", LFS_O_CREAT | LFS_O_WRONLY) => 0; + memset(buffer, 0, 512); + while (LFS_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 (int j = 0; j < ITERATIONS; j++) { + for (int i = 0; i < COUNT; i++) { + 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_open(&lfs, &dir, "child") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; + for (int i = 0; i < COUNT; i++) { + 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 == ITERATIONS-1) { + break; + } + + for (int i = 0; i < COUNT; i++) { + sprintf(path, "child/test%03d_loooooooooooooooooong_name", i); + lfs_remove(&lfs, path) => 0; + } + } + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_dir_open(&lfs, &dir, "child") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; + for (int i = 0; i < COUNT; i++) { + 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 (int i = 0; i < COUNT; i++) { + sprintf(path, "child/test%03d_loooooooooooooooooong_name", i); + lfs_remove(&lfs, path) => 0; + } + lfs_unmount(&lfs) => 0; +''' + +[[case]] # outdated head test +define.ITERATIONS = 20 +define.COUNT = 10 +define.LFS_BLOCK_CYCLES = [8, 1] +code = ''' + lfs_format(&lfs, &cfg) => 0; + // fill up filesystem so only ~16 blocks are left + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "padding", LFS_O_CREAT | LFS_O_WRONLY) => 0; + memset(buffer, 0, 512); + while (LFS_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 (int j = 0; j < ITERATIONS; j++) { + for (int i = 0; i < COUNT; i++) { + 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_open(&lfs, &dir, "child") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; + for (int i = 0; i < COUNT; i++) { + 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 (int i = 0; i < COUNT; i++) { + 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 (int i = 0; i < COUNT; i++) { + 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 (int i = 0; i < COUNT; i++) { + sprintf(path, "child/test%03d_loooooooooooooooooong_name", i); + lfs_remove(&lfs, path) => 0; + } + } + lfs_unmount(&lfs) => 0; +''' + +[[case]] # 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 +reentrant = true +define = [ + {FILES=6, DEPTH=1, CYCLES=50, LFS_BLOCK_CYCLES=1}, + {FILES=26, DEPTH=1, CYCLES=50, LFS_BLOCK_CYCLES=1}, + {FILES=3, DEPTH=3, CYCLES=50, LFS_BLOCK_CYCLES=1}, +] +code = ''' + err = lfs_mount(&lfs, &cfg); + if (err) { + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + } + + srand(1); + const char alpha[] = "abcdefghijklmnopqrstuvwxyz"; + for (int i = 0; i < CYCLES; i++) { + // create random path + char full_path[256]; + for (int d = 0; d < DEPTH; d++) { + sprintf(&full_path[2*d], "/%c", alpha[rand() % FILES]); + } + + // if it does not exist, we create it, else we destroy + int res = lfs_stat(&lfs, full_path, &info); + if (res == LFS_ERR_NOENT) { + // create each directory in turn, ignore if dir already exists + for (int d = 0; d < DEPTH; d++) { + strcpy(path, full_path); + path[2*d+2] = '\0'; + err = lfs_mkdir(&lfs, path); + assert(!err || err == LFS_ERR_EXIST); + } + + for (int d = 0; d < DEPTH; d++) { + 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 (int d = DEPTH-1; d >= 0; d--) { + 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; +''' + +[[case]] # reentrant testing for relocations, but now with random renames! +reentrant = true +define = [ + {FILES=6, DEPTH=1, CYCLES=50, LFS_BLOCK_CYCLES=1}, + {FILES=26, DEPTH=1, CYCLES=50, LFS_BLOCK_CYCLES=1}, + {FILES=3, DEPTH=3, CYCLES=50, LFS_BLOCK_CYCLES=1}, +] +code = ''' + err = lfs_mount(&lfs, &cfg); + if (err) { + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + } + + srand(1); + const char alpha[] = "abcdefghijklmnopqrstuvwxyz"; + for (int i = 0; i < CYCLES; i++) { + // create random path + char full_path[256]; + for (int d = 0; d < DEPTH; d++) { + sprintf(&full_path[2*d], "/%c", alpha[rand() % FILES]); + } + + // if it does not exist, we create it, else we destroy + 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 (int d = 0; d < DEPTH; d++) { + strcpy(path, full_path); + path[2*d+2] = '\0'; + err = lfs_mkdir(&lfs, path); + assert(!err || err == LFS_ERR_EXIST); + } + + for (int d = 0; d < DEPTH; d++) { + 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 (int d = 0; d < DEPTH; d++) { + sprintf(&new_path[2*d], "/%c", alpha[rand() % 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 (int d = 0; d < DEPTH; d++) { + 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 (int d = 0; d < DEPTH; d++) { + 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 (int d = DEPTH-1; d >= 0; d--) { + 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; +''' diff --git a/tests/test_seek.sh b/tests/test_seek.sh deleted file mode 100755 index e136aa0..0000000 --- a/tests/test_seek.sh +++ /dev/null @@ -1,505 +0,0 @@ -#!/bin/bash -set -eu -export TEST_FILE=$0 -trap 'export TEST_LINE=$LINENO' DEBUG - -echo "=== Seek tests ===" - -SMALLSIZE=4 -MEDIUMSIZE=128 -LARGESIZE=132 - -rm -rf blocks -scripts/test.py << TEST - lfs_format(&lfs, &cfg) => 0; - lfs_mount(&lfs, &cfg) => 0; - lfs_mkdir(&lfs, "hello") => 0; - for (int i = 0; i < $LARGESIZE; i++) { - sprintf(path, "hello/kitty%03d", i); - lfs_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0; - - lfs_size_t size = strlen("kittycatcat"); - memcpy(buffer, "kittycatcat", size); - for (int j = 0; j < $LARGESIZE; j++) { - lfs_file_write(&lfs, &file, buffer, size); - } - - lfs_file_close(&lfs, &file) => 0; - } - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Simple dir seek ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir, "hello") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - - lfs_soff_t pos; - int i; - for (i = 0; i < $SMALLSIZE; i++) { - sprintf(path, "kitty%03d", i); - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, path) => 0; - pos = lfs_dir_tell(&lfs, &dir); - } - pos >= 0 => 1; - - lfs_dir_seek(&lfs, &dir, pos) => 0; - sprintf(path, "kitty%03d", i); - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, path) => 0; - - lfs_dir_rewind(&lfs, &dir) => 0; - sprintf(path, "kitty%03d", 0); - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, path) => 0; - - lfs_dir_seek(&lfs, &dir, pos) => 0; - sprintf(path, "kitty%03d", i); - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, path) => 0; - - lfs_dir_close(&lfs, &dir) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Large dir seek ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir, "hello") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - - lfs_soff_t pos; - int i; - for (i = 0; i < $MEDIUMSIZE; i++) { - sprintf(path, "kitty%03d", i); - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, path) => 0; - pos = lfs_dir_tell(&lfs, &dir); - } - pos >= 0 => 1; - - lfs_dir_seek(&lfs, &dir, pos) => 0; - sprintf(path, "kitty%03d", i); - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, path) => 0; - - lfs_dir_rewind(&lfs, &dir) => 0; - sprintf(path, "kitty%03d", 0); - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, path) => 0; - - lfs_dir_seek(&lfs, &dir, pos) => 0; - sprintf(path, "kitty%03d", i); - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(info.name, path) => 0; - - lfs_dir_close(&lfs, &dir) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Simple file seek ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file, "hello/kitty042", LFS_O_RDONLY) => 0; - - lfs_soff_t pos; - lfs_size_t size = strlen("kittycatcat"); - for (int i = 0; i < $SMALLSIZE; i++) { - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "kittycatcat", size) => 0; - pos = lfs_file_tell(&lfs, &file); - } - pos >= 0 => 1; - - lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos; - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "kittycatcat", size) => 0; - - lfs_file_rewind(&lfs, &file) => 0; - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "kittycatcat", size) => 0; - - lfs_file_seek(&lfs, &file, 0, LFS_SEEK_CUR) => size; - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "kittycatcat", size) => 0; - - lfs_file_seek(&lfs, &file, size, LFS_SEEK_CUR) => 3*size; - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "kittycatcat", size) => 0; - - lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos; - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "kittycatcat", size) => 0; - - lfs_file_seek(&lfs, &file, -size, LFS_SEEK_CUR) => pos; - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "kittycatcat", size) => 0; - - lfs_file_seek(&lfs, &file, -size, LFS_SEEK_END) >= 0 => 1; - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "kittycatcat", size) => 0; - - size = lfs_file_size(&lfs, &file); - lfs_file_seek(&lfs, &file, 0, LFS_SEEK_CUR) => size; - - lfs_file_close(&lfs, &file) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Large file seek ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file, "hello/kitty042", LFS_O_RDONLY) => 0; - - lfs_soff_t pos; - lfs_size_t size = strlen("kittycatcat"); - for (int i = 0; i < $MEDIUMSIZE; i++) { - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "kittycatcat", size) => 0; - pos = lfs_file_tell(&lfs, &file); - } - pos >= 0 => 1; - - lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos; - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "kittycatcat", size) => 0; - - lfs_file_rewind(&lfs, &file) => 0; - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "kittycatcat", size) => 0; - - lfs_file_seek(&lfs, &file, 0, LFS_SEEK_CUR) => size; - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "kittycatcat", size) => 0; - - lfs_file_seek(&lfs, &file, size, LFS_SEEK_CUR) => 3*size; - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "kittycatcat", size) => 0; - - lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos; - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "kittycatcat", size) => 0; - - lfs_file_seek(&lfs, &file, -size, LFS_SEEK_CUR) => pos; - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "kittycatcat", size) => 0; - - lfs_file_seek(&lfs, &file, -size, LFS_SEEK_END) >= 0 => 1; - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "kittycatcat", size) => 0; - - size = lfs_file_size(&lfs, &file); - lfs_file_seek(&lfs, &file, 0, LFS_SEEK_CUR) => size; - - lfs_file_close(&lfs, &file) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Simple file seek and write ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file, "hello/kitty042", LFS_O_RDWR) => 0; - - lfs_soff_t pos; - lfs_size_t size = strlen("kittycatcat"); - for (int i = 0; i < $SMALLSIZE; i++) { - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "kittycatcat", size) => 0; - pos = lfs_file_tell(&lfs, &file); - } - pos >= 0 => 1; - - memcpy(buffer, "doggodogdog", size); - lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos; - lfs_file_write(&lfs, &file, buffer, size) => size; - - lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos; - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "doggodogdog", size) => 0; - - lfs_file_rewind(&lfs, &file) => 0; - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "kittycatcat", size) => 0; - - lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos; - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "doggodogdog", size) => 0; - - lfs_file_seek(&lfs, &file, -size, LFS_SEEK_END) >= 0 => 1; - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "kittycatcat", size) => 0; - - size = lfs_file_size(&lfs, &file); - lfs_file_seek(&lfs, &file, 0, LFS_SEEK_CUR) => size; - - lfs_file_close(&lfs, &file) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Large file seek and write ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file, "hello/kitty042", LFS_O_RDWR) => 0; - - lfs_soff_t pos; - lfs_size_t size = strlen("kittycatcat"); - for (int i = 0; i < $MEDIUMSIZE; i++) { - lfs_file_read(&lfs, &file, buffer, size) => size; - if (i != $SMALLSIZE) { - memcmp(buffer, "kittycatcat", size) => 0; - } - pos = lfs_file_tell(&lfs, &file); - } - pos >= 0 => 1; - - memcpy(buffer, "doggodogdog", size); - lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos; - lfs_file_write(&lfs, &file, buffer, size) => size; - - lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos; - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "doggodogdog", size) => 0; - - lfs_file_rewind(&lfs, &file) => 0; - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "kittycatcat", size) => 0; - - lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos; - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "doggodogdog", size) => 0; - - lfs_file_seek(&lfs, &file, -size, LFS_SEEK_END) >= 0 => 1; - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "kittycatcat", size) => 0; - - size = lfs_file_size(&lfs, &file); - lfs_file_seek(&lfs, &file, 0, LFS_SEEK_CUR) => size; - - lfs_file_close(&lfs, &file) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Boundary seek and write ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file, "hello/kitty042", LFS_O_RDWR) => 0; - - lfs_size_t size = strlen("hedgehoghog"); - const lfs_soff_t offsets[] = {512, 1020, 513, 1021, 511, 1019}; - - for (unsigned i = 0; i < sizeof(offsets) / sizeof(offsets[0]); i++) { - lfs_soff_t off = offsets[i]; - memcpy(buffer, "hedgehoghog", size); - lfs_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off; - lfs_file_write(&lfs, &file, buffer, size) => size; - lfs_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off; - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "hedgehoghog", size) => 0; - - lfs_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0; - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "kittycatcat", size) => 0; - - lfs_file_sync(&lfs, &file) => 0; - } - - lfs_file_close(&lfs, &file) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Out-of-bounds seek ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file, "hello/kitty042", LFS_O_RDWR) => 0; - - lfs_size_t size = strlen("kittycatcat"); - lfs_file_size(&lfs, &file) => $LARGESIZE*size; - lfs_file_seek(&lfs, &file, ($LARGESIZE+$SMALLSIZE)*size, - LFS_SEEK_SET) => ($LARGESIZE+$SMALLSIZE)*size; - lfs_file_read(&lfs, &file, buffer, size) => 0; - - memcpy(buffer, "porcupineee", size); - lfs_file_write(&lfs, &file, buffer, size) => size; - - lfs_file_seek(&lfs, &file, ($LARGESIZE+$SMALLSIZE)*size, - LFS_SEEK_SET) => ($LARGESIZE+$SMALLSIZE)*size; - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "porcupineee", size) => 0; - - lfs_file_seek(&lfs, &file, $LARGESIZE*size, - LFS_SEEK_SET) => $LARGESIZE*size; - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "\0\0\0\0\0\0\0\0\0\0\0", size) => 0; - - lfs_file_seek(&lfs, &file, -(($LARGESIZE+$SMALLSIZE)*size), - LFS_SEEK_CUR) => LFS_ERR_INVAL; - lfs_file_tell(&lfs, &file) => ($LARGESIZE+1)*size; - - lfs_file_seek(&lfs, &file, -(($LARGESIZE+2*$SMALLSIZE)*size), - LFS_SEEK_END) => LFS_ERR_INVAL; - lfs_file_tell(&lfs, &file) => ($LARGESIZE+1)*size; - - lfs_file_close(&lfs, &file) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Inline write and seek ---" -for SIZE in $SMALLSIZE $MEDIUMSIZE $LARGESIZE -do -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file, "hello/tinykitty$SIZE", - LFS_O_RDWR | LFS_O_CREAT) => 0; - int j = 0; - int k = 0; - - memcpy(buffer, "abcdefghijklmnopqrstuvwxyz", 26); - for (unsigned i = 0; i < $SIZE; i++) { - lfs_file_write(&lfs, &file, &buffer[j++ % 26], 1) => 1; - lfs_file_tell(&lfs, &file) => i+1; - lfs_file_size(&lfs, &file) => i+1; - } - - lfs_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0; - lfs_file_tell(&lfs, &file) => 0; - lfs_file_size(&lfs, &file) => $SIZE; - for (unsigned i = 0; i < $SIZE; i++) { - uint8_t c; - lfs_file_read(&lfs, &file, &c, 1) => 1; - c => buffer[k++ % 26]; - } - - lfs_file_sync(&lfs, &file) => 0; - lfs_file_tell(&lfs, &file) => $SIZE; - lfs_file_size(&lfs, &file) => $SIZE; - - lfs_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0; - for (unsigned i = 0; i < $SIZE; i++) { - lfs_file_write(&lfs, &file, &buffer[j++ % 26], 1) => 1; - lfs_file_tell(&lfs, &file) => i+1; - lfs_file_size(&lfs, &file) => $SIZE; - lfs_file_sync(&lfs, &file) => 0; - lfs_file_tell(&lfs, &file) => i+1; - lfs_file_size(&lfs, &file) => $SIZE; - if (i < $SIZE-2) { - uint8_t c[3]; - lfs_file_seek(&lfs, &file, -1, LFS_SEEK_CUR) => i; - lfs_file_read(&lfs, &file, &c, 3) => 3; - lfs_file_tell(&lfs, &file) => i+3; - lfs_file_size(&lfs, &file) => $SIZE; - lfs_file_seek(&lfs, &file, i+1, LFS_SEEK_SET) => i+1; - lfs_file_tell(&lfs, &file) => i+1; - lfs_file_size(&lfs, &file) => $SIZE; - } - } - - lfs_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0; - lfs_file_tell(&lfs, &file) => 0; - lfs_file_size(&lfs, &file) => $SIZE; - for (unsigned i = 0; i < $SIZE; i++) { - uint8_t c; - lfs_file_read(&lfs, &file, &c, 1) => 1; - c => buffer[k++ % 26]; - } - - lfs_file_sync(&lfs, &file) => 0; - lfs_file_tell(&lfs, &file) => $SIZE; - lfs_file_size(&lfs, &file) => $SIZE; - - lfs_file_close(&lfs, &file) => 0; - lfs_unmount(&lfs) => 0; -TEST -done - -echo "--- Root seek test ---" -./scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - for (int i = 3; i < $MEDIUMSIZE; i++) { - sprintf(path, "hi%03d", i); - lfs_mkdir(&lfs, path) => 0; - } - - lfs_dir_open(&lfs, &dir, "/") => 0; - for (int i = 0; i < $MEDIUMSIZE; i++) { - if (i == 0) { - sprintf(path, "."); - } else if (i == 1) { - sprintf(path, ".."); - } else if (i == 2) { - sprintf(path, "hello"); - } else { - sprintf(path, "hi%03d", i); - } - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(path, info.name) => 0; - } - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - - for (int j = 0; j < $MEDIUMSIZE; j++) { - lfs_soff_t off = -1; - - lfs_dir_open(&lfs, &dir, "/") => 0; - for (int i = 0; i < $MEDIUMSIZE; i++) { - if (i == 0) { - sprintf(path, "."); - } else if (i == 1) { - sprintf(path, ".."); - } else if (i == 2) { - sprintf(path, "hello"); - } else { - sprintf(path, "hi%03d", i); - } - - if (i == j) { - off = lfs_dir_tell(&lfs, &dir); - off >= 0 => true; - } - - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(path, info.name) => 0; - } - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - - lfs_dir_open(&lfs, &dir, "/") => 0; - lfs_dir_seek(&lfs, &dir, off) => 0; - for (int i = j; i < $MEDIUMSIZE; i++) { - if (i == 0) { - sprintf(path, "."); - } else if (i == 1) { - sprintf(path, ".."); - } else if (i == 2) { - sprintf(path, "hello"); - } else { - sprintf(path, "hi%03d", i); - } - - lfs_dir_read(&lfs, &dir, &info) => 1; - strcmp(path, info.name) => 0; - } - lfs_dir_read(&lfs, &dir, &info) => 0; - lfs_dir_close(&lfs, &dir) => 0; - } - - lfs_unmount(&lfs) => 0; -TEST - -scripts/results.py diff --git a/tests/test_seek.toml b/tests/test_seek.toml new file mode 100644 index 0000000..79d7728 --- /dev/null +++ b/tests/test_seek.toml @@ -0,0 +1,380 @@ + +[[case]] # simple file seek +define = [ + {COUNT=132, SKIP=4}, + {COUNT=132, SKIP=128}, + {COUNT=200, SKIP=10}, + {COUNT=200, SKIP=100}, + {COUNT=4, SKIP=1}, + {COUNT=4, SKIP=2}, +] +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "kitty", + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0; + size = strlen("kittycatcat"); + memcpy(buffer, "kittycatcat", size); + for (int j = 0; j < COUNT; j++) { + lfs_file_write(&lfs, &file, buffer, size); + } + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "kitty", LFS_O_RDONLY) => 0; + + lfs_soff_t pos = -1; + size = strlen("kittycatcat"); + for (int i = 0; i < SKIP; i++) { + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "kittycatcat", size) => 0; + pos = lfs_file_tell(&lfs, &file); + } + assert(pos >= 0); + + lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos; + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "kittycatcat", size) => 0; + + lfs_file_rewind(&lfs, &file) => 0; + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "kittycatcat", size) => 0; + + lfs_file_seek(&lfs, &file, 0, LFS_SEEK_CUR) => size; + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "kittycatcat", size) => 0; + + lfs_file_seek(&lfs, &file, size, LFS_SEEK_CUR) => 3*size; + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "kittycatcat", size) => 0; + + lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos; + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "kittycatcat", size) => 0; + + lfs_file_seek(&lfs, &file, -size, LFS_SEEK_CUR) => pos; + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "kittycatcat", size) => 0; + + lfs_file_seek(&lfs, &file, -size, LFS_SEEK_END) >= 0 => 1; + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "kittycatcat", size) => 0; + + size = lfs_file_size(&lfs, &file); + lfs_file_seek(&lfs, &file, 0, LFS_SEEK_CUR) => size; + + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # simple file seek and write +define = [ + {COUNT=132, SKIP=4}, + {COUNT=132, SKIP=128}, + {COUNT=200, SKIP=10}, + {COUNT=200, SKIP=100}, + {COUNT=4, SKIP=1}, + {COUNT=4, SKIP=2}, +] +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "kitty", + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0; + size = strlen("kittycatcat"); + memcpy(buffer, "kittycatcat", size); + for (int j = 0; j < COUNT; j++) { + lfs_file_write(&lfs, &file, buffer, size); + } + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "kitty", LFS_O_RDWR) => 0; + + lfs_soff_t pos = -1; + size = strlen("kittycatcat"); + for (int i = 0; i < SKIP; i++) { + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "kittycatcat", size) => 0; + pos = lfs_file_tell(&lfs, &file); + } + assert(pos >= 0); + + memcpy(buffer, "doggodogdog", size); + lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos; + lfs_file_write(&lfs, &file, buffer, size) => size; + + lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos; + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "doggodogdog", size) => 0; + + lfs_file_rewind(&lfs, &file) => 0; + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "kittycatcat", size) => 0; + + lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos; + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "doggodogdog", size) => 0; + + lfs_file_seek(&lfs, &file, -size, LFS_SEEK_END) >= 0 => 1; + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "kittycatcat", size) => 0; + + size = lfs_file_size(&lfs, &file); + lfs_file_seek(&lfs, &file, 0, LFS_SEEK_CUR) => size; + + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # boundary seek and writes +define.COUNT = 132 +define.OFFSETS = '"{512, 1020, 513, 1021, 511, 1019, 1441}"' +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "kitty", + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0; + size = strlen("kittycatcat"); + memcpy(buffer, "kittycatcat", size); + for (int j = 0; j < COUNT; j++) { + lfs_file_write(&lfs, &file, buffer, size); + } + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "kitty", LFS_O_RDWR) => 0; + + size = strlen("hedgehoghog"); + const lfs_soff_t offsets[] = OFFSETS; + + for (unsigned i = 0; i < sizeof(offsets) / sizeof(offsets[0]); i++) { + lfs_soff_t off = offsets[i]; + memcpy(buffer, "hedgehoghog", size); + lfs_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off; + lfs_file_write(&lfs, &file, buffer, size) => size; + lfs_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off; + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "hedgehoghog", size) => 0; + + lfs_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0; + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "kittycatcat", size) => 0; + + lfs_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off; + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "hedgehoghog", size) => 0; + + lfs_file_sync(&lfs, &file) => 0; + + lfs_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0; + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "kittycatcat", size) => 0; + + lfs_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off; + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "hedgehoghog", size) => 0; + } + + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # out of bounds seek +define = [ + {COUNT=132, SKIP=4}, + {COUNT=132, SKIP=128}, + {COUNT=200, SKIP=10}, + {COUNT=200, SKIP=100}, + {COUNT=4, SKIP=2}, + {COUNT=4, SKIP=3}, +] +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "kitty", + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0; + size = strlen("kittycatcat"); + memcpy(buffer, "kittycatcat", size); + for (int j = 0; j < COUNT; j++) { + lfs_file_write(&lfs, &file, buffer, size); + } + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "kitty", LFS_O_RDWR) => 0; + + size = strlen("kittycatcat"); + lfs_file_size(&lfs, &file) => COUNT*size; + lfs_file_seek(&lfs, &file, (COUNT+SKIP)*size, + LFS_SEEK_SET) => (COUNT+SKIP)*size; + lfs_file_read(&lfs, &file, buffer, size) => 0; + + memcpy(buffer, "porcupineee", size); + lfs_file_write(&lfs, &file, buffer, size) => size; + + lfs_file_seek(&lfs, &file, (COUNT+SKIP)*size, + LFS_SEEK_SET) => (COUNT+SKIP)*size; + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "porcupineee", size) => 0; + + lfs_file_seek(&lfs, &file, COUNT*size, + LFS_SEEK_SET) => COUNT*size; + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "\0\0\0\0\0\0\0\0\0\0\0", size) => 0; + + lfs_file_seek(&lfs, &file, -((COUNT+SKIP)*size), + LFS_SEEK_CUR) => LFS_ERR_INVAL; + lfs_file_tell(&lfs, &file) => (COUNT+1)*size; + + lfs_file_seek(&lfs, &file, -((COUNT+2*SKIP)*size), + LFS_SEEK_END) => LFS_ERR_INVAL; + lfs_file_tell(&lfs, &file) => (COUNT+1)*size; + + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # inline write and seek +define.SIZE = [2, 4, 128, 132] +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "tinykitty", + LFS_O_RDWR | LFS_O_CREAT) => 0; + int j = 0; + int k = 0; + + memcpy(buffer, "abcdefghijklmnopqrstuvwxyz", 26); + for (unsigned i = 0; i < SIZE; i++) { + lfs_file_write(&lfs, &file, &buffer[j++ % 26], 1) => 1; + lfs_file_tell(&lfs, &file) => i+1; + lfs_file_size(&lfs, &file) => i+1; + } + + lfs_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0; + lfs_file_tell(&lfs, &file) => 0; + lfs_file_size(&lfs, &file) => SIZE; + for (unsigned i = 0; i < SIZE; i++) { + uint8_t c; + lfs_file_read(&lfs, &file, &c, 1) => 1; + c => buffer[k++ % 26]; + } + + lfs_file_sync(&lfs, &file) => 0; + lfs_file_tell(&lfs, &file) => SIZE; + lfs_file_size(&lfs, &file) => SIZE; + + lfs_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0; + for (unsigned i = 0; i < SIZE; i++) { + lfs_file_write(&lfs, &file, &buffer[j++ % 26], 1) => 1; + lfs_file_tell(&lfs, &file) => i+1; + lfs_file_size(&lfs, &file) => SIZE; + lfs_file_sync(&lfs, &file) => 0; + lfs_file_tell(&lfs, &file) => i+1; + lfs_file_size(&lfs, &file) => SIZE; + if (i < SIZE-2) { + uint8_t c[3]; + lfs_file_seek(&lfs, &file, -1, LFS_SEEK_CUR) => i; + lfs_file_read(&lfs, &file, &c, 3) => 3; + lfs_file_tell(&lfs, &file) => i+3; + lfs_file_size(&lfs, &file) => SIZE; + lfs_file_seek(&lfs, &file, i+1, LFS_SEEK_SET) => i+1; + lfs_file_tell(&lfs, &file) => i+1; + lfs_file_size(&lfs, &file) => SIZE; + } + } + + lfs_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0; + lfs_file_tell(&lfs, &file) => 0; + lfs_file_size(&lfs, &file) => SIZE; + for (unsigned i = 0; i < SIZE; i++) { + uint8_t c; + lfs_file_read(&lfs, &file, &c, 1) => 1; + c => buffer[k++ % 26]; + } + + lfs_file_sync(&lfs, &file) => 0; + lfs_file_tell(&lfs, &file) => SIZE; + lfs_file_size(&lfs, &file) => SIZE; + + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # file seek and write with power-loss +# must be power-of-2 for quadratic probing to be exhaustive +define.COUNT = [4, 64, 128] +reentrant = true +code = ''' + err = lfs_mount(&lfs, &cfg); + if (err) { + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + } + err = lfs_file_open(&lfs, &file, "kitty", LFS_O_RDONLY); + assert(!err || err == LFS_ERR_NOENT); + if (!err) { + if (lfs_file_size(&lfs, &file) != 0) { + lfs_file_size(&lfs, &file) => 11*COUNT; + for (int j = 0; j < COUNT; j++) { + memset(buffer, 0, 11+1); + lfs_file_read(&lfs, &file, buffer, 11) => 11; + assert(memcmp(buffer, "kittycatcat", 11) == 0 || + memcmp(buffer, "doggodogdog", 11) == 0); + } + } + lfs_file_close(&lfs, &file) => 0; + } + + lfs_file_open(&lfs, &file, "kitty", LFS_O_WRONLY | LFS_O_CREAT) => 0; + if (lfs_file_size(&lfs, &file) == 0) { + for (int j = 0; j < COUNT; j++) { + strcpy((char*)buffer, "kittycatcat"); + size = strlen((char*)buffer); + lfs_file_write(&lfs, &file, buffer, size) => size; + } + } + lfs_file_close(&lfs, &file) => 0; + + strcpy((char*)buffer, "doggodogdog"); + size = strlen((char*)buffer); + + lfs_file_open(&lfs, &file, "kitty", LFS_O_RDWR) => 0; + lfs_file_size(&lfs, &file) => COUNT*size; + // seek and write using quadratic probing to touch all + // 11-byte words in the file + lfs_off_t off = 0; + for (int j = 0; j < COUNT; j++) { + off = (5*off + 1) % COUNT; + lfs_file_seek(&lfs, &file, off*size, LFS_SEEK_SET) => off*size; + lfs_file_read(&lfs, &file, buffer, size) => size; + assert(memcmp(buffer, "kittycatcat", size) == 0 || + memcmp(buffer, "doggodogdog", size) == 0); + if (memcmp(buffer, "doggodogdog", size) != 0) { + lfs_file_seek(&lfs, &file, off*size, LFS_SEEK_SET) => off*size; + strcpy((char*)buffer, "doggodogdog"); + lfs_file_write(&lfs, &file, buffer, size) => size; + lfs_file_seek(&lfs, &file, off*size, LFS_SEEK_SET) => off*size; + lfs_file_read(&lfs, &file, buffer, size) => size; + assert(memcmp(buffer, "doggodogdog", size) == 0); + lfs_file_sync(&lfs, &file) => 0; + lfs_file_seek(&lfs, &file, off*size, LFS_SEEK_SET) => off*size; + lfs_file_read(&lfs, &file, buffer, size) => size; + assert(memcmp(buffer, "doggodogdog", size) == 0); + } + } + lfs_file_close(&lfs, &file) => 0; + + lfs_file_open(&lfs, &file, "kitty", LFS_O_RDWR) => 0; + lfs_file_size(&lfs, &file) => COUNT*size; + for (int j = 0; j < COUNT; j++) { + lfs_file_read(&lfs, &file, buffer, size) => size; + assert(memcmp(buffer, "doggodogdog", size) == 0); + } + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; +''' diff --git a/tests/test_truncate.sh b/tests/test_truncate.sh deleted file mode 100755 index f33717d..0000000 --- a/tests/test_truncate.sh +++ /dev/null @@ -1,355 +0,0 @@ -#!/bin/bash -set -eu -export TEST_FILE=$0 -trap 'export TEST_LINE=$LINENO' DEBUG - -echo "=== Truncate tests ===" - -SMALLSIZE=32 -MEDIUMSIZE=2048 -LARGESIZE=8192 - -rm -rf blocks -scripts/test.py << TEST - lfs_format(&lfs, &cfg) => 0; -TEST - -echo "--- Simple truncate ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file, "baldynoop", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - - strcpy((char*)buffer, "hair"); - lfs_size_t size = strlen((char*)buffer); - for (lfs_off_t j = 0; j < $LARGESIZE; j += size) { - lfs_file_write(&lfs, &file, buffer, size) => size; - } - lfs_file_size(&lfs, &file) => $LARGESIZE; - - lfs_file_close(&lfs, &file) => 0; - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file, "baldynoop", LFS_O_RDWR) => 0; - lfs_file_size(&lfs, &file) => $LARGESIZE; - - lfs_file_truncate(&lfs, &file, $MEDIUMSIZE) => 0; - lfs_file_size(&lfs, &file) => $MEDIUMSIZE; - - lfs_file_close(&lfs, &file) => 0; - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file, "baldynoop", LFS_O_RDONLY) => 0; - lfs_file_size(&lfs, &file) => $MEDIUMSIZE; - - lfs_size_t size = strlen("hair"); - for (lfs_off_t j = 0; j < $MEDIUMSIZE; j += size) { - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "hair", size) => 0; - } - lfs_file_read(&lfs, &file, buffer, size) => 0; - - lfs_file_close(&lfs, &file) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Truncate and read ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file, "baldyread", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - - strcpy((char*)buffer, "hair"); - lfs_size_t size = strlen((char*)buffer); - for (lfs_off_t j = 0; j < $LARGESIZE; j += size) { - lfs_file_write(&lfs, &file, buffer, size) => size; - } - lfs_file_size(&lfs, &file) => $LARGESIZE; - - lfs_file_close(&lfs, &file) => 0; - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file, "baldyread", LFS_O_RDWR) => 0; - lfs_file_size(&lfs, &file) => $LARGESIZE; - - lfs_file_truncate(&lfs, &file, $MEDIUMSIZE) => 0; - lfs_file_size(&lfs, &file) => $MEDIUMSIZE; - - lfs_size_t size = strlen("hair"); - for (lfs_off_t j = 0; j < $MEDIUMSIZE; j += size) { - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "hair", size) => 0; - } - lfs_file_read(&lfs, &file, buffer, size) => 0; - - lfs_file_close(&lfs, &file) => 0; - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file, "baldyread", LFS_O_RDONLY) => 0; - lfs_file_size(&lfs, &file) => $MEDIUMSIZE; - - lfs_size_t size = strlen("hair"); - for (lfs_off_t j = 0; j < $MEDIUMSIZE; j += size) { - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "hair", size) => 0; - } - lfs_file_read(&lfs, &file, buffer, size) => 0; - - lfs_file_close(&lfs, &file) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Write, truncate, and read ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file, "sequence", - LFS_O_RDWR | LFS_O_CREAT | LFS_O_TRUNC) => 0; - - lfs_size_t size = lfs.cfg->cache_size; - lfs_size_t qsize = size / 4; - uint8_t *wb = buffer; - uint8_t *rb = buffer + size; - for (lfs_off_t j = 0; j < size; ++j) { - wb[j] = j; - } - - /* Spread sequence over size */ - lfs_file_write(&lfs, &file, wb, size) => size; - lfs_file_size(&lfs, &file) => size; - lfs_file_tell(&lfs, &file) => size; - - lfs_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0; - lfs_file_tell(&lfs, &file) => 0; - - /* Chop off the last quarter */ - lfs_size_t trunc = size - qsize; - lfs_file_truncate(&lfs, &file, trunc) => 0; - lfs_file_tell(&lfs, &file) => 0; - lfs_file_size(&lfs, &file) => trunc; - - /* Read should produce first 3/4 */ - lfs_file_read(&lfs, &file, rb, size) => trunc; - memcmp(rb, wb, trunc) => 0; - - /* Move to 1/4 */ - lfs_file_size(&lfs, &file) => trunc; - lfs_file_seek(&lfs, &file, qsize, LFS_SEEK_SET) => qsize; - lfs_file_tell(&lfs, &file) => qsize; - - /* Chop to 1/2 */ - trunc -= qsize; - lfs_file_truncate(&lfs, &file, trunc) => 0; - lfs_file_tell(&lfs, &file) => qsize; - lfs_file_size(&lfs, &file) => trunc; - - /* Read should produce second quarter */ - lfs_file_read(&lfs, &file, rb, size) => trunc - qsize; - memcmp(rb, wb + qsize, trunc - qsize) => 0; - - lfs_file_close(&lfs, &file) => 0; - lfs_unmount(&lfs) => 0; -TEST - -echo "--- Truncate and write ---" -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file, "baldywrite", - LFS_O_WRONLY | LFS_O_CREAT) => 0; - - strcpy((char*)buffer, "hair"); - lfs_size_t size = strlen((char*)buffer); - for (lfs_off_t j = 0; j < $LARGESIZE; j += size) { - lfs_file_write(&lfs, &file, buffer, size) => size; - } - lfs_file_size(&lfs, &file) => $LARGESIZE; - - lfs_file_close(&lfs, &file) => 0; - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file, "baldywrite", LFS_O_RDWR) => 0; - lfs_file_size(&lfs, &file) => $LARGESIZE; - - lfs_file_truncate(&lfs, &file, $MEDIUMSIZE) => 0; - lfs_file_size(&lfs, &file) => $MEDIUMSIZE; - - strcpy((char*)buffer, "bald"); - lfs_size_t size = strlen((char*)buffer); - for (lfs_off_t j = 0; j < $MEDIUMSIZE; j += size) { - lfs_file_write(&lfs, &file, buffer, size) => size; - } - lfs_file_size(&lfs, &file) => $MEDIUMSIZE; - - lfs_file_close(&lfs, &file) => 0; - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file, "baldywrite", LFS_O_RDONLY) => 0; - lfs_file_size(&lfs, &file) => $MEDIUMSIZE; - - lfs_size_t size = strlen("bald"); - for (lfs_off_t j = 0; j < $MEDIUMSIZE; j += size) { - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "bald", size) => 0; - } - lfs_file_read(&lfs, &file, buffer, size) => 0; - - lfs_file_close(&lfs, &file) => 0; - lfs_unmount(&lfs) => 0; -TEST - -# More aggressive general truncation tests -truncate_test() { -STARTSIZES="$1" -STARTSEEKS="$2" -HOTSIZES="$3" -COLDSIZES="$4" -scripts/test.py << TEST - static const lfs_off_t startsizes[] = {$STARTSIZES}; - static const lfs_off_t startseeks[] = {$STARTSEEKS}; - static const lfs_off_t hotsizes[] = {$HOTSIZES}; - - lfs_mount(&lfs, &cfg) => 0; - - for (unsigned i = 0; i < sizeof(startsizes)/sizeof(startsizes[0]); i++) { - sprintf(path, "hairyhead%d", i); - lfs_file_open(&lfs, &file, path, - LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; - - strcpy((char*)buffer, "hair"); - lfs_size_t size = strlen((char*)buffer); - for (lfs_off_t j = 0; j < startsizes[i]; j += size) { - lfs_file_write(&lfs, &file, buffer, size) => size; - } - lfs_file_size(&lfs, &file) => startsizes[i]; - - if (startseeks[i] != startsizes[i]) { - lfs_file_seek(&lfs, &file, - startseeks[i], LFS_SEEK_SET) => startseeks[i]; - } - - lfs_file_truncate(&lfs, &file, hotsizes[i]) => 0; - lfs_file_size(&lfs, &file) => hotsizes[i]; - - lfs_file_close(&lfs, &file) => 0; - } - - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - static const lfs_off_t startsizes[] = {$STARTSIZES}; - static const lfs_off_t hotsizes[] = {$HOTSIZES}; - static const lfs_off_t coldsizes[] = {$COLDSIZES}; - - lfs_mount(&lfs, &cfg) => 0; - - for (unsigned i = 0; i < sizeof(startsizes)/sizeof(startsizes[0]); i++) { - sprintf(path, "hairyhead%d", i); - lfs_file_open(&lfs, &file, path, LFS_O_RDWR) => 0; - lfs_file_size(&lfs, &file) => hotsizes[i]; - - lfs_size_t size = strlen("hair"); - lfs_off_t j = 0; - for (; j < startsizes[i] && j < hotsizes[i]; j += size) { - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "hair", size) => 0; - } - - for (; j < hotsizes[i]; j += size) { - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "\0\0\0\0", size) => 0; - } - - lfs_file_truncate(&lfs, &file, coldsizes[i]) => 0; - lfs_file_size(&lfs, &file) => coldsizes[i]; - - lfs_file_close(&lfs, &file) => 0; - } - - lfs_unmount(&lfs) => 0; -TEST -scripts/test.py << TEST - static const lfs_off_t startsizes[] = {$STARTSIZES}; - static const lfs_off_t hotsizes[] = {$HOTSIZES}; - static const lfs_off_t coldsizes[] = {$COLDSIZES}; - - lfs_mount(&lfs, &cfg) => 0; - - for (unsigned i = 0; i < sizeof(startsizes)/sizeof(startsizes[0]); i++) { - sprintf(path, "hairyhead%d", i); - lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; - lfs_file_size(&lfs, &file) => coldsizes[i]; - - lfs_size_t size = strlen("hair"); - lfs_off_t j = 0; - for (; j < startsizes[i] && j < hotsizes[i] && j < coldsizes[i]; - j += size) { - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "hair", size) => 0; - } - - for (; j < coldsizes[i]; j += size) { - lfs_file_read(&lfs, &file, buffer, size) => size; - memcmp(buffer, "\0\0\0\0", size) => 0; - } - - lfs_file_close(&lfs, &file) => 0; - } - - lfs_unmount(&lfs) => 0; -TEST -} - -echo "--- Cold shrinking truncate ---" -truncate_test \ - "2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE" \ - "2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE" \ - "2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE" \ - " 0, $SMALLSIZE, $MEDIUMSIZE, $LARGESIZE, 2*$LARGESIZE" - -echo "--- Cold expanding truncate ---" -truncate_test \ - " 0, $SMALLSIZE, $MEDIUMSIZE, $LARGESIZE, 2*$LARGESIZE" \ - " 0, $SMALLSIZE, $MEDIUMSIZE, $LARGESIZE, 2*$LARGESIZE" \ - " 0, $SMALLSIZE, $MEDIUMSIZE, $LARGESIZE, 2*$LARGESIZE" \ - "2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE" - -echo "--- Warm shrinking truncate ---" -truncate_test \ - "2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE" \ - "2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE" \ - " 0, $SMALLSIZE, $MEDIUMSIZE, $LARGESIZE, 2*$LARGESIZE" \ - " 0, 0, 0, 0, 0" - -echo "--- Warm expanding truncate ---" -truncate_test \ - " 0, $SMALLSIZE, $MEDIUMSIZE, $LARGESIZE, 2*$LARGESIZE" \ - " 0, $SMALLSIZE, $MEDIUMSIZE, $LARGESIZE, 2*$LARGESIZE" \ - "2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE" \ - "2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE" - -echo "--- Mid-file shrinking truncate ---" -truncate_test \ - "2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE" \ - " $LARGESIZE, $LARGESIZE, $LARGESIZE, $LARGESIZE, $LARGESIZE" \ - " 0, $SMALLSIZE, $MEDIUMSIZE, $LARGESIZE, 2*$LARGESIZE" \ - " 0, 0, 0, 0, 0" - -echo "--- Mid-file expanding truncate ---" -truncate_test \ - " 0, $SMALLSIZE, $MEDIUMSIZE, $LARGESIZE, 2*$LARGESIZE" \ - " 0, 0, $SMALLSIZE, $MEDIUMSIZE, $LARGESIZE" \ - "2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE" \ - "2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE" - -scripts/results.py diff --git a/tests/test_truncate.toml b/tests/test_truncate.toml new file mode 100644 index 0000000..4416986 --- /dev/null +++ b/tests/test_truncate.toml @@ -0,0 +1,394 @@ +[[case]] # simple truncate +define.MEDIUMSIZE = [32, 2048] +define.LARGESIZE = 8192 +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "baldynoop", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + + strcpy((char*)buffer, "hair"); + size = strlen((char*)buffer); + for (lfs_off_t j = 0; j < LARGESIZE; j += size) { + lfs_file_write(&lfs, &file, buffer, size) => size; + } + lfs_file_size(&lfs, &file) => LARGESIZE; + + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "baldynoop", LFS_O_RDWR) => 0; + lfs_file_size(&lfs, &file) => LARGESIZE; + + lfs_file_truncate(&lfs, &file, MEDIUMSIZE) => 0; + lfs_file_size(&lfs, &file) => MEDIUMSIZE; + + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "baldynoop", LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => MEDIUMSIZE; + + size = strlen("hair"); + for (lfs_off_t j = 0; j < MEDIUMSIZE; j += size) { + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "hair", size) => 0; + } + lfs_file_read(&lfs, &file, buffer, size) => 0; + + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # truncate and read +define.MEDIUMSIZE = [32, 2048] +define.LARGESIZE = 8192 +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "baldyread", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + + strcpy((char*)buffer, "hair"); + size = strlen((char*)buffer); + for (lfs_off_t j = 0; j < LARGESIZE; j += size) { + lfs_file_write(&lfs, &file, buffer, size) => size; + } + lfs_file_size(&lfs, &file) => LARGESIZE; + + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "baldyread", LFS_O_RDWR) => 0; + lfs_file_size(&lfs, &file) => LARGESIZE; + + lfs_file_truncate(&lfs, &file, MEDIUMSIZE) => 0; + lfs_file_size(&lfs, &file) => MEDIUMSIZE; + + size = strlen("hair"); + for (lfs_off_t j = 0; j < MEDIUMSIZE; j += size) { + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "hair", size) => 0; + } + lfs_file_read(&lfs, &file, buffer, size) => 0; + + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "baldyread", LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => MEDIUMSIZE; + + size = strlen("hair"); + for (lfs_off_t j = 0; j < MEDIUMSIZE; j += size) { + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "hair", size) => 0; + } + lfs_file_read(&lfs, &file, buffer, size) => 0; + + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # write, truncate, and read +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "sequence", + LFS_O_RDWR | LFS_O_CREAT | LFS_O_TRUNC) => 0; + + size = lfs.cfg->cache_size; + lfs_size_t qsize = size / 4; + uint8_t *wb = buffer; + uint8_t *rb = buffer + size; + for (lfs_off_t j = 0; j < size; ++j) { + wb[j] = j; + } + + /* Spread sequence over size */ + lfs_file_write(&lfs, &file, wb, size) => size; + lfs_file_size(&lfs, &file) => size; + lfs_file_tell(&lfs, &file) => size; + + lfs_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0; + lfs_file_tell(&lfs, &file) => 0; + + /* Chop off the last quarter */ + lfs_size_t trunc = size - qsize; + lfs_file_truncate(&lfs, &file, trunc) => 0; + lfs_file_tell(&lfs, &file) => 0; + lfs_file_size(&lfs, &file) => trunc; + + /* Read should produce first 3/4 */ + lfs_file_read(&lfs, &file, rb, size) => trunc; + memcmp(rb, wb, trunc) => 0; + + /* Move to 1/4 */ + lfs_file_size(&lfs, &file) => trunc; + lfs_file_seek(&lfs, &file, qsize, LFS_SEEK_SET) => qsize; + lfs_file_tell(&lfs, &file) => qsize; + + /* Chop to 1/2 */ + trunc -= qsize; + lfs_file_truncate(&lfs, &file, trunc) => 0; + lfs_file_tell(&lfs, &file) => qsize; + lfs_file_size(&lfs, &file) => trunc; + + /* Read should produce second quarter */ + lfs_file_read(&lfs, &file, rb, size) => trunc - qsize; + memcmp(rb, wb + qsize, trunc - qsize) => 0; + + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # truncate and write +define.MEDIUMSIZE = [32, 2048] +define.LARGESIZE = 8192 +code = ''' + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "baldywrite", + LFS_O_WRONLY | LFS_O_CREAT) => 0; + + strcpy((char*)buffer, "hair"); + size = strlen((char*)buffer); + for (lfs_off_t j = 0; j < LARGESIZE; j += size) { + lfs_file_write(&lfs, &file, buffer, size) => size; + } + lfs_file_size(&lfs, &file) => LARGESIZE; + + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "baldywrite", LFS_O_RDWR) => 0; + lfs_file_size(&lfs, &file) => LARGESIZE; + + lfs_file_truncate(&lfs, &file, MEDIUMSIZE) => 0; + lfs_file_size(&lfs, &file) => MEDIUMSIZE; + + strcpy((char*)buffer, "bald"); + size = strlen((char*)buffer); + for (lfs_off_t j = 0; j < MEDIUMSIZE; j += size) { + lfs_file_write(&lfs, &file, buffer, size) => size; + } + lfs_file_size(&lfs, &file) => MEDIUMSIZE; + + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + lfs_file_open(&lfs, &file, "baldywrite", LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => MEDIUMSIZE; + + size = strlen("bald"); + for (lfs_off_t j = 0; j < MEDIUMSIZE; j += size) { + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "bald", size) => 0; + } + lfs_file_read(&lfs, &file, buffer, size) => 0; + + lfs_file_close(&lfs, &file) => 0; + lfs_unmount(&lfs) => 0; +''' + +[[case]] # truncate write under powerloss +define.SMALLSIZE = [4, 512] +define.MEDIUMSIZE = [32, 1024] +define.LARGESIZE = 2048 +reentrant = true +code = ''' + err = lfs_mount(&lfs, &cfg); + if (err) { + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + } + err = lfs_file_open(&lfs, &file, "baldy", LFS_O_RDONLY); + assert(!err || err == LFS_ERR_NOENT); + if (!err) { + size = lfs_file_size(&lfs, &file); + assert(size == 0 || + size == LARGESIZE || + size == MEDIUMSIZE || + size == SMALLSIZE); + for (lfs_off_t j = 0; j < size; j += 4) { + lfs_file_read(&lfs, &file, buffer, 4) => 4; + assert(memcmp(buffer, "hair", 4) == 0 || + memcmp(buffer, "bald", 4) == 0 || + memcmp(buffer, "comb", 4) == 0); + } + lfs_file_close(&lfs, &file) => 0; + } + + lfs_file_open(&lfs, &file, "baldy", + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + lfs_file_size(&lfs, &file) => 0; + strcpy((char*)buffer, "hair"); + size = strlen((char*)buffer); + for (lfs_off_t j = 0; j < LARGESIZE; j += size) { + lfs_file_write(&lfs, &file, buffer, size) => size; + } + lfs_file_size(&lfs, &file) => LARGESIZE; + lfs_file_close(&lfs, &file) => 0; + + lfs_file_open(&lfs, &file, "baldy", LFS_O_RDWR) => 0; + lfs_file_size(&lfs, &file) => LARGESIZE; + lfs_file_truncate(&lfs, &file, MEDIUMSIZE) => 0; + lfs_file_size(&lfs, &file) => MEDIUMSIZE; + strcpy((char*)buffer, "bald"); + size = strlen((char*)buffer); + for (lfs_off_t j = 0; j < MEDIUMSIZE; j += size) { + lfs_file_write(&lfs, &file, buffer, size) => size; + } + lfs_file_size(&lfs, &file) => MEDIUMSIZE; + lfs_file_close(&lfs, &file) => 0; + + lfs_file_open(&lfs, &file, "baldy", LFS_O_RDWR) => 0; + lfs_file_size(&lfs, &file) => MEDIUMSIZE; + lfs_file_truncate(&lfs, &file, SMALLSIZE) => 0; + lfs_file_size(&lfs, &file) => SMALLSIZE; + strcpy((char*)buffer, "comb"); + size = strlen((char*)buffer); + for (lfs_off_t j = 0; j < SMALLSIZE; j += size) { + lfs_file_write(&lfs, &file, buffer, size) => size; + } + lfs_file_size(&lfs, &file) => SMALLSIZE; + lfs_file_close(&lfs, &file) => 0; + + lfs_unmount(&lfs) => 0; +''' + +[[case]] # more aggressive general truncation tests +define.CONFIG = 'range(6)' +define.SMALLSIZE = 32 +define.MEDIUMSIZE = 2048 +define.LARGESIZE = 8192 +code = ''' + #define COUNT 5 + const struct { + lfs_off_t startsizes[COUNT]; + lfs_off_t startseeks[COUNT]; + lfs_off_t hotsizes[COUNT]; + lfs_off_t coldsizes[COUNT]; + } configs[] = { + // cold shrinking + {{2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE}, + {2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE}, + {2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE}, + { 0, SMALLSIZE, MEDIUMSIZE, LARGESIZE, 2*LARGESIZE}}, + // cold expanding + {{2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE}, + {2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE}, + {2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE}, + { 0, SMALLSIZE, MEDIUMSIZE, LARGESIZE, 2*LARGESIZE}}, + // warm shrinking truncate + {{2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE}, + {2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE}, + { 0, SMALLSIZE, MEDIUMSIZE, LARGESIZE, 2*LARGESIZE}, + { 0, 0, 0, 0, 0}}, + // warm expanding truncate + {{ 0, SMALLSIZE, MEDIUMSIZE, LARGESIZE, 2*LARGESIZE}, + { 0, SMALLSIZE, MEDIUMSIZE, LARGESIZE, 2*LARGESIZE}, + {2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE}, + {2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE}}, + // mid-file shrinking truncate + {{2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE}, + { LARGESIZE, LARGESIZE, LARGESIZE, LARGESIZE, LARGESIZE}, + { 0, SMALLSIZE, MEDIUMSIZE, LARGESIZE, 2*LARGESIZE}, + { 0, 0, 0, 0, 0}}, + // mid-file expanding truncate + {{ 0, SMALLSIZE, MEDIUMSIZE, LARGESIZE, 2*LARGESIZE}, + { 0, 0, SMALLSIZE, MEDIUMSIZE, LARGESIZE}, + {2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE}, + {2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE, 2*LARGESIZE}}, + }; + + const lfs_off_t *startsizes = configs[CONFIG].startsizes; + const lfs_off_t *startseeks = configs[CONFIG].startseeks; + const lfs_off_t *hotsizes = configs[CONFIG].hotsizes; + const lfs_off_t *coldsizes = configs[CONFIG].coldsizes; + + lfs_format(&lfs, &cfg) => 0; + lfs_mount(&lfs, &cfg) => 0; + + for (unsigned i = 0; i < COUNT; i++) { + sprintf(path, "hairyhead%d", i); + lfs_file_open(&lfs, &file, path, + LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0; + + strcpy((char*)buffer, "hair"); + size = strlen((char*)buffer); + for (lfs_off_t j = 0; j < startsizes[i]; j += size) { + lfs_file_write(&lfs, &file, buffer, size) => size; + } + lfs_file_size(&lfs, &file) => startsizes[i]; + + if (startseeks[i] != startsizes[i]) { + lfs_file_seek(&lfs, &file, + startseeks[i], LFS_SEEK_SET) => startseeks[i]; + } + + lfs_file_truncate(&lfs, &file, hotsizes[i]) => 0; + lfs_file_size(&lfs, &file) => hotsizes[i]; + + lfs_file_close(&lfs, &file) => 0; + } + + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + + for (unsigned i = 0; i < COUNT; i++) { + sprintf(path, "hairyhead%d", i); + lfs_file_open(&lfs, &file, path, LFS_O_RDWR) => 0; + lfs_file_size(&lfs, &file) => hotsizes[i]; + + size = strlen("hair"); + lfs_off_t j = 0; + for (; j < startsizes[i] && j < hotsizes[i]; j += size) { + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "hair", size) => 0; + } + + for (; j < hotsizes[i]; j += size) { + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "\0\0\0\0", size) => 0; + } + + lfs_file_truncate(&lfs, &file, coldsizes[i]) => 0; + lfs_file_size(&lfs, &file) => coldsizes[i]; + + lfs_file_close(&lfs, &file) => 0; + } + + lfs_unmount(&lfs) => 0; + + lfs_mount(&lfs, &cfg) => 0; + + for (unsigned i = 0; i < COUNT; i++) { + sprintf(path, "hairyhead%d", i); + lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => coldsizes[i]; + + size = strlen("hair"); + lfs_off_t j = 0; + for (; j < startsizes[i] && j < hotsizes[i] && j < coldsizes[i]; + j += size) { + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "hair", size) => 0; + } + + for (; j < coldsizes[i]; j += size) { + lfs_file_read(&lfs, &file, buffer, size) => size; + memcmp(buffer, "\0\0\0\0", size) => 0; + } + + lfs_file_close(&lfs, &file) => 0; + } + + lfs_unmount(&lfs) => 0; +''' |