Github/littlefs
1
Fork 0
Code Actions Activity

Replaced REMOUNT with small post-test loops where possible

Browse Source 
We've been wasting a lot of test cycles thanks to REMOUNT. Using a test
define for this effectively duplicates the test, when we really just
want to run more post-test code without additional mutation.

The main reason for REMOUNT has been to save typing, which, well, is not
a bad reason, these tests involve a lot of typing...

But this is probably a hammer/nail situation. If we replace these with a
small post-test loop, we can save quite a bit of time:

  make test -j before: 5791.9s
  make test -j after:  5123.8s (-11.5%)

Some tests still use a REMOUNT define, but these should be limited to
cases where remount actually changes the test's behavior.
This commit is contained in:
Christopher Haster
2024-05-28 03:10:03 -05:00
parent 76d3c49b5c
commit 1c363b428a
6 changed files with 4781 additions and 4657 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/test_alloc.toml
+154 -134
View File
@@ -219,35 +219,43 @@ code = '''
free(seen); free(seen);
// then check that we can read our directories after clobbering // then check that we can read our directories after clobbering
for (lfs_size_t i = 0; i < N; i++) { for (int remount = 0; remount < 2; remount++) {
char name[256]; // remount?
sprintf(name, "dir%03x", i); if (remount) {
struct lfs_info info; lfsr_unmount(&lfs) => 0;
lfsr_stat(&lfs, name, &info) => 0; lfsr_mount(&lfs, CFG) => 0;
assert(strcmp(info.name, name) == 0); }
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
}
lfsr_dir_open(&lfs, &dir, "/") => 0; for (lfs_size_t i = 0; i < N; i++) {
lfsr_dir_read(&lfs, &dir, &info) => 0; char name[256];
assert(strcmp(info.name, ".") == 0); sprintf(name, "dir%03x", i);
assert(info.type == LFS_TYPE_DIR); struct lfs_info info;
assert(info.size == 0); lfsr_stat(&lfs, name, &info) => 0;
lfsr_dir_read(&lfs, &dir, &info) => 0; assert(strcmp(info.name, name) == 0);
assert(strcmp(info.name, "..") == 0); assert(info.type == LFS_TYPE_DIR);
assert(info.type == LFS_TYPE_DIR); assert(info.size == 0);
assert(info.size == 0); }
for (lfs_size_t i = 0; i < N; i++) {
char name[256]; lfsr_dir_open(&lfs, &dir, "/") => 0;
sprintf(name, "dir%03x", i);
lfsr_dir_read(&lfs, &dir, &info) => 0; lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, name) == 0); assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR); assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0); assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
for (lfs_size_t i = 0; i < N; i++) {
char name[256];
sprintf(name, "dir%03x", i);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
}
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0;
} }
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0;
lfsr_unmount(&lfs) => 0; lfsr_unmount(&lfs) => 0;
''' '''
@@ -389,29 +397,37 @@ code = '''
free(seen); free(seen);
// then check that reading our files still works after clobbering // then check that reading our files still works after clobbering
prng = 42; for (int remount = 0; remount < 2; remount++) {
for (lfs_size_t i = 0; i < N; i++) { // remount?
// check with stat if (remount) {
char name[256]; lfsr_unmount(&lfs) => 0;
sprintf(name, "file%03x", i); lfsr_mount(&lfs, CFG) => 0;
struct lfs_info info;
lfsr_stat(&lfs, name, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == SIZE);
// try reading the file, note we reset prng above
uint8_t wbuf[SIZE];
for (lfs_size_t j = 0; j < SIZE; j++) {
wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26);
} }
lfsr_file_t file; prng = 42;
uint8_t rbuf[SIZE]; for (lfs_size_t i = 0; i < N; i++) {
lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; // check with stat
lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; char name[256];
assert(memcmp(rbuf, wbuf, SIZE) == 0); sprintf(name, "file%03x", i);
lfsr_file_close(&lfs, &file) => 0; struct lfs_info info;
lfsr_stat(&lfs, name, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == SIZE);
// try reading the file, note we reset prng above
uint8_t wbuf[SIZE];
for (lfs_size_t j = 0; j < SIZE; j++) {
wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26);
}
lfsr_file_t file;
uint8_t rbuf[SIZE];
lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0;
lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE;
assert(memcmp(rbuf, wbuf, SIZE) == 0);
lfsr_file_close(&lfs, &file) => 0;
}
} }
lfsr_unmount(&lfs) => 0; lfsr_unmount(&lfs) => 0;
@@ -430,7 +446,6 @@ defines.SIZE = [
'8*BLOCK_SIZE', '8*BLOCK_SIZE',
] ]
defines.VALIDATE = [false, true] defines.VALIDATE = [false, true]
defines.REMOUNT = [false, true]
in = 'lfs.c' in = 'lfs.c'
if = '(SIZE*N)/BLOCK_SIZE <= 32' if = '(SIZE*N)/BLOCK_SIZE <= 32'
code = ''' code = '''
@@ -556,34 +571,37 @@ code = '''
lfsr_file_close(&lfs, &files[i]) => 0; lfsr_file_close(&lfs, &files[i]) => 0;
} }
if (REMOUNT) { for (int remount = 0; remount < 2; remount++) {
lfsr_unmount(&lfs) => 0; // remount?
lfsr_mount(&lfs, CFG) => 0; if (remount) {
} lfsr_unmount(&lfs) => 0;
lfsr_mount(&lfs, CFG) => 0;
prng = 42;
for (lfs_size_t i = 0; i < N; i++) {
// check with stat
char name[256];
sprintf(name, "file%03x", i);
struct lfs_info info;
lfsr_stat(&lfs, name, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == SIZE);
// try reading the file, note we reset prng above
uint8_t wbuf[SIZE];
for (lfs_size_t j = 0; j < SIZE; j++) {
wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26);
} }
lfsr_file_t file; prng = 42;
uint8_t rbuf[SIZE]; for (lfs_size_t i = 0; i < N; i++) {
lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; // check with stat
lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; char name[256];
assert(memcmp(rbuf, wbuf, SIZE) == 0); sprintf(name, "file%03x", i);
lfsr_file_close(&lfs, &file) => 0; struct lfs_info info;
lfsr_stat(&lfs, name, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == SIZE);
// try reading the file, note we reset prng above
uint8_t wbuf[SIZE];
for (lfs_size_t j = 0; j < SIZE; j++) {
wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26);
}
lfsr_file_t file;
uint8_t rbuf[SIZE];
lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0;
lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE;
assert(memcmp(rbuf, wbuf, SIZE) == 0);
lfsr_file_close(&lfs, &file) => 0;
}
} }
lfsr_unmount(&lfs) => 0; lfsr_unmount(&lfs) => 0;
@@ -595,7 +613,6 @@ code = '''
# nospc tests mostly test that things still work when block allocation # nospc tests mostly test that things still work when block allocation
# wraparound occurs # wraparound occurs
[cases.test_alloc_nospc_dirs] [cases.test_alloc_nospc_dirs]
defines.REMOUNT = [false, true]
code = ''' code = '''
lfs_t lfs; lfs_t lfs;
lfsr_format(&lfs, CFG) => 0; lfsr_format(&lfs, CFG) => 0;
@@ -613,44 +630,46 @@ code = '''
} }
} }
// remount? for (int remount = 0; remount < 2; remount++) {
if (REMOUNT) { // remount?
lfsr_unmount(&lfs) => 0; if (remount) {
lfsr_mount(&lfs, CFG) => 0; lfsr_unmount(&lfs) => 0;
} lfsr_mount(&lfs, CFG) => 0;
}
// check that our mkdir worked until we ran out of space // check that our mkdir worked until we ran out of space
for (lfs_size_t i = 0; i < n; i++) { for (lfs_size_t i = 0; i < n; i++) {
char name[256]; char name[256];
sprintf(name, "dir%08d", i); sprintf(name, "dir%08d", i);
struct lfs_info info;
lfsr_stat(&lfs, name, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
}
lfsr_dir_t dir;
lfsr_dir_open(&lfs, &dir, "/") => 0;
struct lfs_info info; struct lfs_info info;
lfsr_stat(&lfs, name, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
}
lfsr_dir_t dir;
lfsr_dir_open(&lfs, &dir, "/") => 0;
struct lfs_info info;
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
for (lfs_size_t i = 0; i < n; i++) {
char name[256];
sprintf(name, "dir%08d", i);
lfsr_dir_read(&lfs, &dir, &info) => 0; lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, name) == 0); assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR); assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0); assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
for (lfs_size_t i = 0; i < n; i++) {
char name[256];
sprintf(name, "dir%08d", i);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
}
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0;
} }
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0;
lfsr_unmount(&lfs) => 0; lfsr_unmount(&lfs) => 0;
''' '''
@@ -665,7 +684,6 @@ defines.SIZE = [
'2*BLOCK_SIZE', '2*BLOCK_SIZE',
'8*BLOCK_SIZE', '8*BLOCK_SIZE',
] ]
defines.REMOUNT = [false, true]
code = ''' code = '''
lfs_t lfs; lfs_t lfs;
lfsr_format(&lfs, CFG) => 0; lfsr_format(&lfs, CFG) => 0;
@@ -705,36 +723,38 @@ code = '''
} }
} }
// remount? for (int remount = 0; remount < 2; remount++) {
if (REMOUNT) { // remount?
lfsr_unmount(&lfs) => 0; if (remount) {
lfsr_mount(&lfs, CFG) => 0; lfsr_unmount(&lfs) => 0;
} lfsr_mount(&lfs, CFG) => 0;
// check that our file writes worked until we ran out of space
prng = 42;
for (lfs_size_t i = 0; i < n; i++) {
// check with stat
char name[256];
sprintf(name, "file%08d", i);
struct lfs_info info;
lfsr_stat(&lfs, name, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == SIZE);
// try reading the file, note we reset prng above
uint8_t wbuf[SIZE];
for (lfs_size_t j = 0; j < SIZE; j++) {
wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26);
} }
lfsr_file_t file; // check that our file writes worked until we ran out of space
uint8_t rbuf[SIZE]; prng = 42;
lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; for (lfs_size_t i = 0; i < n; i++) {
lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; // check with stat
assert(memcmp(rbuf, wbuf, SIZE) == 0); char name[256];
lfsr_file_close(&lfs, &file) => 0; sprintf(name, "file%08d", i);
struct lfs_info info;
lfsr_stat(&lfs, name, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == SIZE);
// try reading the file, note we reset prng above
uint8_t wbuf[SIZE];
for (lfs_size_t j = 0; j < SIZE; j++) {
wbuf[j] = 'a' + (TEST_PRNG(&prng) % 26);
}
lfsr_file_t file;
uint8_t rbuf[SIZE];
lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0;
lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE;
assert(memcmp(rbuf, wbuf, SIZE) == 0);
lfsr_file_close(&lfs, &file) => 0;
}
} }
lfsr_unmount(&lfs) => 0; lfsr_unmount(&lfs) => 0;
tests/test_badblocks.toml
+426 -414
View File
@@ -332,7 +332,6 @@ defines.BADBLOCK_BEHAVIOR = [
defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256]
# do more ops than dirs to encourage rename collisions # do more ops than dirs to encourage rename collisions
defines.OPS = '2*N' defines.OPS = '2*N'
defines.REMOUNT = [false, true]
defines.SEED = 42 defines.SEED = 42
code = ''' code = '''
// test all possible bad blocks // test all possible bad blocks
@@ -382,49 +381,27 @@ code = '''
assert(!err || err == LFS_ERR_EXIST); assert(!err || err == LFS_ERR_EXIST);
} }
// remount? for (int remount = 0; remount < 2; remount++) {
if (REMOUNT) { // remount?
lfsr_unmount(&lfs) => 0; if (remount) {
lfsr_mount(&lfs, CFG) => 0; lfsr_unmount(&lfs) => 0;
} lfsr_mount(&lfs, CFG) => 0;
}
// test that our directories match our simulation // test that our directories match our simulation
for (lfs_size_t j = 0; j < sim_size; j++) { for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256]; char name[256];
sprintf(name, "dir%03x", sim[j]); sprintf(name, "dir%03x", sim[j]);
struct lfs_info info;
lfsr_stat(&lfs, name, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
}
lfsr_dir_t dir;
lfsr_dir_open(&lfs, &dir, "/") => 0;
struct lfs_info info; struct lfs_info info;
lfsr_stat(&lfs, name, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
}
lfsr_dir_t dir;
lfsr_dir_open(&lfs, &dir, "/") => 0;
struct lfs_info info;
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "dir%03x", sim[j]);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
}
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0;
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "dir%03x", sim[j]);
lfsr_dir_open(&lfs, &dir, name) => 0;
lfsr_dir_read(&lfs, &dir, &info) => 0; lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0); assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR); assert(info.type == LFS_TYPE_DIR);
@@ -433,8 +410,32 @@ code = '''
assert(strcmp(info.name, "..") == 0); assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR); assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0); assert(info.size == 0);
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "dir%03x", sim[j]);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
}
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0; lfsr_dir_close(&lfs, &dir) => 0;
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "dir%03x", sim[j]);
lfsr_dir_open(&lfs, &dir, name) => 0;
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0;
}
} }
// clean up sim/lfs // clean up sim/lfs
@@ -461,7 +462,6 @@ defines.MIRROR = [false, true]
defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256]
# do more ops than dirs to encourage rename collisions # do more ops than dirs to encourage rename collisions
defines.OPS = '2*N' defines.OPS = '2*N'
defines.REMOUNT = [false, true]
defines.SEED = 42 defines.SEED = 42
code = ''' code = '''
// test a large region of bad blocks // test a large region of bad blocks
@@ -516,49 +516,27 @@ code = '''
assert(!err || err == LFS_ERR_EXIST); assert(!err || err == LFS_ERR_EXIST);
} }
// remount? for (int remount = 0; remount < 2; remount++) {
if (REMOUNT) { // remount?
lfsr_unmount(&lfs) => 0; if (remount) {
lfsr_mount(&lfs, CFG) => 0; lfsr_unmount(&lfs) => 0;
} lfsr_mount(&lfs, CFG) => 0;
}
// test that our directories match our simulation // test that our directories match our simulation
for (lfs_size_t j = 0; j < sim_size; j++) { for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256]; char name[256];
sprintf(name, "dir%03x", sim[j]); sprintf(name, "dir%03x", sim[j]);
struct lfs_info info;
lfsr_stat(&lfs, name, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
}
lfsr_dir_t dir;
lfsr_dir_open(&lfs, &dir, "/") => 0;
struct lfs_info info; struct lfs_info info;
lfsr_stat(&lfs, name, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
}
lfsr_dir_t dir;
lfsr_dir_open(&lfs, &dir, "/") => 0;
struct lfs_info info;
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "dir%03x", sim[j]);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
}
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0;
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "dir%03x", sim[j]);
lfsr_dir_open(&lfs, &dir, name) => 0;
lfsr_dir_read(&lfs, &dir, &info) => 0; lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0); assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR); assert(info.type == LFS_TYPE_DIR);
@@ -567,8 +545,32 @@ code = '''
assert(strcmp(info.name, "..") == 0); assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR); assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0); assert(info.size == 0);
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "dir%03x", sim[j]);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
}
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0; lfsr_dir_close(&lfs, &dir) => 0;
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "dir%03x", sim[j]);
lfsr_dir_open(&lfs, &dir, name) => 0;
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0;
}
} }
// clean up sim/lfs // clean up sim/lfs
@@ -591,7 +593,6 @@ defines.MIRROR = [false, true]
defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256]
# do more ops than dirs to encourage rename collisions # do more ops than dirs to encourage rename collisions
defines.OPS = '2*N' defines.OPS = '2*N'
defines.REMOUNT = [false, true]
defines.SEED = 42 defines.SEED = 42
code = ''' code = '''
// test a large region of bad blocks // test a large region of bad blocks
@@ -646,49 +647,27 @@ code = '''
assert(!err || err == LFS_ERR_EXIST); assert(!err || err == LFS_ERR_EXIST);
} }
// remount? for (int remount = 0; remount < 2; remount++) {
if (REMOUNT) { // remount?
lfsr_unmount(&lfs) => 0; if (remount) {
lfsr_mount(&lfs, CFG) => 0; lfsr_unmount(&lfs) => 0;
} lfsr_mount(&lfs, CFG) => 0;
}
// test that our directories match our simulation // test that our directories match our simulation
for (lfs_size_t j = 0; j < sim_size; j++) { for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256]; char name[256];
sprintf(name, "dir%03x", sim[j]); sprintf(name, "dir%03x", sim[j]);
struct lfs_info info;
lfsr_stat(&lfs, name, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
}
lfsr_dir_t dir;
lfsr_dir_open(&lfs, &dir, "/") => 0;
struct lfs_info info; struct lfs_info info;
lfsr_stat(&lfs, name, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
}
lfsr_dir_t dir;
lfsr_dir_open(&lfs, &dir, "/") => 0;
struct lfs_info info;
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "dir%03x", sim[j]);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
}
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0;
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "dir%03x", sim[j]);
lfsr_dir_open(&lfs, &dir, name) => 0;
lfsr_dir_read(&lfs, &dir, &info) => 0; lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0); assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR); assert(info.type == LFS_TYPE_DIR);
@@ -697,8 +676,32 @@ code = '''
assert(strcmp(info.name, "..") == 0); assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR); assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0); assert(info.size == 0);
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "dir%03x", sim[j]);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
}
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT; lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0; lfsr_dir_close(&lfs, &dir) => 0;
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "dir%03x", sim[j]);
lfsr_dir_open(&lfs, &dir, name) => 0;
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0;
}
} }
// clean up sim/lfs // clean up sim/lfs
@@ -731,7 +734,6 @@ defines.SIZE = [
'2*BLOCK_SIZE', '2*BLOCK_SIZE',
'4*BLOCK_SIZE', '4*BLOCK_SIZE',
] ]
defines.REMOUNT = [false, true]
defines.SEED = 42 defines.SEED = 42
if = '(SIZE*N)/BLOCK_SIZE <= 16' if = '(SIZE*N)/BLOCK_SIZE <= 16'
code = ''' code = '''
@@ -797,62 +799,64 @@ code = '''
lfsr_file_close(&lfs, &file) => 0; lfsr_file_close(&lfs, &file) => 0;
} }
// remount? for (int remount = 0; remount < 2; remount++) {
if (REMOUNT) { // remount?
lfsr_unmount(&lfs) => 0; if (remount) {
lfsr_mount(&lfs, CFG) => 0; lfsr_unmount(&lfs) => 0;
} lfsr_mount(&lfs, CFG) => 0;
// check that our files match our simulation
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "amethyst%03x", sim[j]);
struct lfs_info info;
lfsr_stat(&lfs, name, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == SIZE);
}
lfsr_dir_t dir;
lfsr_dir_open(&lfs, &dir, "/") => 0;
struct lfs_info info;
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "amethyst%03x", sim[j]);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == SIZE);
}
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0;
// check the file contents
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "amethyst%03x", sim[j]);
lfsr_file_t file;
lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0;
uint32_t wprng = sim_prngs[j];
uint8_t wbuf[SIZE];
for (lfs_size_t j = 0; j < SIZE; j++) {
wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26);
} }
uint8_t rbuf[SIZE]; // check that our files match our simulation
lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; for (lfs_size_t j = 0; j < sim_size; j++) {
assert(memcmp(rbuf, wbuf, SIZE) == 0); char name[256];
lfsr_file_close(&lfs, &file) => 0; sprintf(name, "amethyst%03x", sim[j]);
struct lfs_info info;
lfsr_stat(&lfs, name, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == SIZE);
}
lfsr_dir_t dir;
lfsr_dir_open(&lfs, &dir, "/") => 0;
struct lfs_info info;
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "amethyst%03x", sim[j]);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == SIZE);
}
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0;
// check the file contents
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "amethyst%03x", sim[j]);
lfsr_file_t file;
lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0;
uint32_t wprng = sim_prngs[j];
uint8_t wbuf[SIZE];
for (lfs_size_t j = 0; j < SIZE; j++) {
wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26);
}
uint8_t rbuf[SIZE];
lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE;
assert(memcmp(rbuf, wbuf, SIZE) == 0);
lfsr_file_close(&lfs, &file) => 0;
}
} }
// clean up sim/lfs // clean up sim/lfs
@@ -889,7 +893,6 @@ defines.SIZE = [
'2*BLOCK_SIZE', '2*BLOCK_SIZE',
'4*BLOCK_SIZE', '4*BLOCK_SIZE',
] ]
defines.REMOUNT = [false, true]
defines.SEED = 42 defines.SEED = 42
if = '(SIZE*N)/BLOCK_SIZE <= 16' if = '(SIZE*N)/BLOCK_SIZE <= 16'
code = ''' code = '''
@@ -960,62 +963,64 @@ code = '''
lfsr_file_close(&lfs, &file) => 0; lfsr_file_close(&lfs, &file) => 0;
} }
// remount? for (int remount = 0; remount < 2; remount++) {
if (REMOUNT) { // remount?
lfsr_unmount(&lfs) => 0; if (remount) {
lfsr_mount(&lfs, CFG) => 0; lfsr_unmount(&lfs) => 0;
} lfsr_mount(&lfs, CFG) => 0;
// check that our files match our simulation
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "amethyst%03x", sim[j]);
struct lfs_info info;
lfsr_stat(&lfs, name, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == SIZE);
}
lfsr_dir_t dir;
lfsr_dir_open(&lfs, &dir, "/") => 0;
struct lfs_info info;
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "amethyst%03x", sim[j]);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == SIZE);
}
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0;
// check the file contents
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "amethyst%03x", sim[j]);
lfsr_file_t file;
lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0;
uint32_t wprng = sim_prngs[j];
uint8_t wbuf[SIZE];
for (lfs_size_t j = 0; j < SIZE; j++) {
wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26);
} }
uint8_t rbuf[SIZE]; // check that our files match our simulation
lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; for (lfs_size_t j = 0; j < sim_size; j++) {
assert(memcmp(rbuf, wbuf, SIZE) == 0); char name[256];
lfsr_file_close(&lfs, &file) => 0; sprintf(name, "amethyst%03x", sim[j]);
struct lfs_info info;
lfsr_stat(&lfs, name, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == SIZE);
}
lfsr_dir_t dir;
lfsr_dir_open(&lfs, &dir, "/") => 0;
struct lfs_info info;
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "amethyst%03x", sim[j]);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == SIZE);
}
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0;
// check the file contents
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "amethyst%03x", sim[j]);
lfsr_file_t file;
lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0;
uint32_t wprng = sim_prngs[j];
uint8_t wbuf[SIZE];
for (lfs_size_t j = 0; j < SIZE; j++) {
wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26);
}
uint8_t rbuf[SIZE];
lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE;
assert(memcmp(rbuf, wbuf, SIZE) == 0);
lfsr_file_close(&lfs, &file) => 0;
}
} }
// clean up sim/lfs // clean up sim/lfs
@@ -1048,7 +1053,6 @@ defines.SIZE = [
'2*BLOCK_SIZE', '2*BLOCK_SIZE',
'4*BLOCK_SIZE', '4*BLOCK_SIZE',
] ]
defines.REMOUNT = [false, true]
defines.SEED = 42 defines.SEED = 42
if = '(SIZE*N)/BLOCK_SIZE <= 16' if = '(SIZE*N)/BLOCK_SIZE <= 16'
code = ''' code = '''
@@ -1119,62 +1123,64 @@ code = '''
lfsr_file_close(&lfs, &file) => 0; lfsr_file_close(&lfs, &file) => 0;
} }
// remount? for (int remount = 0; remount < 2; remount++) {
if (REMOUNT) { // remount?
lfsr_unmount(&lfs) => 0; if (remount) {
lfsr_mount(&lfs, CFG) => 0; lfsr_unmount(&lfs) => 0;
} lfsr_mount(&lfs, CFG) => 0;
// check that our files match our simulation
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "amethyst%03x", sim[j]);
struct lfs_info info;
lfsr_stat(&lfs, name, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == SIZE);
}
lfsr_dir_t dir;
lfsr_dir_open(&lfs, &dir, "/") => 0;
struct lfs_info info;
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "amethyst%03x", sim[j]);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == SIZE);
}
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0;
// check the file contents
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "amethyst%03x", sim[j]);
lfsr_file_t file;
lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0;
uint32_t wprng = sim_prngs[j];
uint8_t wbuf[SIZE];
for (lfs_size_t j = 0; j < SIZE; j++) {
wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26);
} }
uint8_t rbuf[SIZE]; // check that our files match our simulation
lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; for (lfs_size_t j = 0; j < sim_size; j++) {
assert(memcmp(rbuf, wbuf, SIZE) == 0); char name[256];
lfsr_file_close(&lfs, &file) => 0; sprintf(name, "amethyst%03x", sim[j]);
struct lfs_info info;
lfsr_stat(&lfs, name, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == SIZE);
}
lfsr_dir_t dir;
lfsr_dir_open(&lfs, &dir, "/") => 0;
struct lfs_info info;
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "amethyst%03x", sim[j]);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == SIZE);
}
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0;
// check the file contents
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "amethyst%03x", sim[j]);
lfsr_file_t file;
lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0;
uint32_t wprng = sim_prngs[j];
uint8_t wbuf[SIZE];
for (lfs_size_t j = 0; j < SIZE; j++) {
wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26);
}
uint8_t rbuf[SIZE];
lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE;
assert(memcmp(rbuf, wbuf, SIZE) == 0);
lfsr_file_close(&lfs, &file) => 0;
}
} }
// clean up sim/lfs // clean up sim/lfs
@@ -1305,49 +1311,51 @@ code = '''
} }
lfsr_file_close(&lfs, &file) => 0; lfsr_file_close(&lfs, &file) => 0;
// remount? for (int remount = 0; remount < 2; remount++) {
if (REMOUNT) { // remount?
lfsr_unmount(&lfs) => 0; if (remount) {
lfsr_mount(&lfs, CFG) => 0; lfsr_unmount(&lfs) => 0;
lfsr_mount(&lfs, CFG) => 0;
}
// check our file with stat
struct lfs_info info;
lfsr_stat(&lfs, "hello", &info) => 0;
assert(strcmp(info.name, "hello") == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == size);
// and with dir read
lfsr_dir_t dir;
lfsr_dir_open(&lfs, &dir, "/") => 0;
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "hello") == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == size);
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0;
// try reading our file
lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0;
// is size correct?
lfsr_file_size(&lfs, &file) => size;
// try reading
uint8_t rbuf[2*SIZE];
memset(rbuf, 0xaa, 2*SIZE);
lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => size;
// does our file match our simulation?
assert(memcmp(rbuf, sim, size) == 0);
lfsr_file_close(&lfs, &file) => 0;
} }
// check our file with stat
struct lfs_info info;
lfsr_stat(&lfs, "hello", &info) => 0;
assert(strcmp(info.name, "hello") == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == size);
// and with dir read
lfsr_dir_t dir;
lfsr_dir_open(&lfs, &dir, "/") => 0;
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "hello") == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == size);
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0;
// try reading our file
lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0;
// is size correct?
lfsr_file_size(&lfs, &file) => size;
// try reading
uint8_t rbuf[2*SIZE];
memset(rbuf, 0xaa, 2*SIZE);
lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => size;
// does our file match our simulation?
assert(memcmp(rbuf, sim, size) == 0);
lfsr_file_close(&lfs, &file) => 0;
lfsr_unmount(&lfs) => 0; lfsr_unmount(&lfs) => 0;
// reset badblock // reset badblock
@@ -1481,49 +1489,51 @@ code = '''
} }
lfsr_file_close(&lfs, &file) => 0; lfsr_file_close(&lfs, &file) => 0;
// remount? for (int remount = 0; remount < 2; remount++) {
if (REMOUNT) { // remount?
lfsr_unmount(&lfs) => 0; if (remount) {
lfsr_mount(&lfs, CFG) => 0; lfsr_unmount(&lfs) => 0;
lfsr_mount(&lfs, CFG) => 0;
}
// check our file with stat
struct lfs_info info;
lfsr_stat(&lfs, "hello", &info) => 0;
assert(strcmp(info.name, "hello") == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == size);
// and with dir read
lfsr_dir_t dir;
lfsr_dir_open(&lfs, &dir, "/") => 0;
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "hello") == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == size);
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0;
// try reading our file
lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0;
// is size correct?
lfsr_file_size(&lfs, &file) => size;
// try reading
uint8_t rbuf[2*SIZE];
memset(rbuf, 0xaa, 2*SIZE);
lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => size;
// does our file match our simulation?
assert(memcmp(rbuf, sim, size) == 0);
lfsr_file_close(&lfs, &file) => 0;
} }
// check our file with stat
struct lfs_info info;
lfsr_stat(&lfs, "hello", &info) => 0;
assert(strcmp(info.name, "hello") == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == size);
// and with dir read
lfsr_dir_t dir;
lfsr_dir_open(&lfs, &dir, "/") => 0;
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "hello") == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == size);
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0;
// try reading our file
lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0;
// is size correct?
lfsr_file_size(&lfs, &file) => size;
// try reading
uint8_t rbuf[2*SIZE];
memset(rbuf, 0xaa, 2*SIZE);
lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => size;
// does our file match our simulation?
assert(memcmp(rbuf, sim, size) == 0);
lfsr_file_close(&lfs, &file) => 0;
lfsr_unmount(&lfs) => 0; lfsr_unmount(&lfs) => 0;
''' '''
@@ -1653,49 +1663,51 @@ code = '''
} }
lfsr_file_close(&lfs, &file) => 0; lfsr_file_close(&lfs, &file) => 0;
// remount? for (int remount = 0; remount < 2; remount++) {
if (REMOUNT) { // remount?
lfsr_unmount(&lfs) => 0; if (remount) {
lfsr_mount(&lfs, CFG) => 0; lfsr_unmount(&lfs) => 0;
lfsr_mount(&lfs, CFG) => 0;
}
// check our file with stat
struct lfs_info info;
lfsr_stat(&lfs, "hello", &info) => 0;
assert(strcmp(info.name, "hello") == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == size);
// and with dir read
lfsr_dir_t dir;
lfsr_dir_open(&lfs, &dir, "/") => 0;
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "hello") == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == size);
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0;
// try reading our file
lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0;
// is size correct?
lfsr_file_size(&lfs, &file) => size;
// try reading
uint8_t rbuf[2*SIZE];
memset(rbuf, 0xaa, 2*SIZE);
lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => size;
// does our file match our simulation?
assert(memcmp(rbuf, sim, size) == 0);
lfsr_file_close(&lfs, &file) => 0;
} }
// check our file with stat
struct lfs_info info;
lfsr_stat(&lfs, "hello", &info) => 0;
assert(strcmp(info.name, "hello") == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == size);
// and with dir read
lfsr_dir_t dir;
lfsr_dir_open(&lfs, &dir, "/") => 0;
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "hello") == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == size);
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0;
// try reading our file
lfsr_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0;
// is size correct?
lfsr_file_size(&lfs, &file) => size;
// try reading
uint8_t rbuf[2*SIZE];
memset(rbuf, 0xaa, 2*SIZE);
lfsr_file_read(&lfs, &file, rbuf, 2*SIZE) => size;
// does our file match our simulation?
assert(memcmp(rbuf, sim, size) == 0);
lfsr_file_close(&lfs, &file) => 0;
lfsr_unmount(&lfs) => 0; lfsr_unmount(&lfs) => 0;
''' '''
tests/test_dirs.toml
+2225 -2255
View File
File diff suppressed because it is too large Load Diff
tests/test_files.toml
+1161 -1099
View File
File diff suppressed because it is too large Load Diff
tests/test_fwrite.toml
+679 -623
View File
File diff suppressed because it is too large Load Diff
tests/test_relocations.toml
+136 -132
View File
@@ -15,7 +15,6 @@ after = [
defines.BLOCK_RECYCLES = [4, 1, 0] defines.BLOCK_RECYCLES = [4, 1, 0]
defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256] defines.N = [1, 2, 4, 8, 16, 32, 64, 128, 256]
defines.OPS = 1024 defines.OPS = 1024
defines.REMOUNT = [false, true]
defines.SEED = 'range(10)' defines.SEED = 'range(10)'
code = ''' code = '''
lfs_t lfs; lfs_t lfs;
@@ -110,48 +109,51 @@ code = '''
} }
} }
// remount? for (int remount = 0; remount < 2; remount++) {
if (REMOUNT) { // remount?
lfsr_unmount(&lfs) => 0; if (remount) {
lfsr_mount(&lfs, CFG) => 0; lfsr_unmount(&lfs) => 0;
lfsr_mount(&lfs, CFG) => 0;
}
// grm should be zero here // grm should be zero here
assert(lfs.grm_p[0] == 0); assert(lfs.grm_p[0] == 0);
}
// test that our directories match our simulation // test that our directories match our simulation
for (lfs_size_t j = 0; j < sim_size; j++) { for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256]; char name[256];
sprintf(name, "dir%03x", sim[j]); sprintf(name, "dir%03x", sim[j]);
struct lfs_info info;
lfsr_stat(&lfs, name, &info) => 0;
char name2[256];
sprintf(name2, "dir%03x", sim[j]);
assert(strcmp(info.name, name2) == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
}
lfsr_dir_t dir;
lfsr_dir_open(&lfs, &dir, "/") => 0;
struct lfs_info info; struct lfs_info info;
lfsr_stat(&lfs, name, &info) => 0;
char name2[256];
sprintf(name2, "dir%03x", sim[j]);
assert(strcmp(info.name, name2) == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
}
lfsr_dir_t dir;
lfsr_dir_open(&lfs, &dir, "/") => 0;
struct lfs_info info;
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "dir%03x", sim[j]);
lfsr_dir_read(&lfs, &dir, &info) => 0; lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, name) == 0); assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR); assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0); assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "dir%03x", sim[j]);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
}
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0;
} }
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0;
// clean up sim/lfs // clean up sim/lfs
free(sim); free(sim);
@@ -172,7 +174,6 @@ defines.SIZE = [
'2*BLOCK_SIZE', '2*BLOCK_SIZE',
'4*BLOCK_SIZE', '4*BLOCK_SIZE',
] ]
defines.REMOUNT = [false, true]
defines.SEED = 'range(10)' defines.SEED = 'range(10)'
if = '(SIZE*N)/BLOCK_SIZE <= 16' if = '(SIZE*N)/BLOCK_SIZE <= 16'
code = ''' code = '''
@@ -305,62 +306,64 @@ code = '''
} }
} }
// remount? for (int remount = 0; remount < 2; remount++) {
if (REMOUNT) { // remount?
lfsr_unmount(&lfs) => 0; if (remount) {
lfsr_mount(&lfs, CFG) => 0; lfsr_unmount(&lfs) => 0;
} lfsr_mount(&lfs, CFG) => 0;
// check that our files match our simulation
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "amethyst%03x", sim[j]);
struct lfs_info info;
lfsr_stat(&lfs, name, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == SIZE);
}
lfsr_dir_t dir;
lfsr_dir_open(&lfs, &dir, "/") => 0;
struct lfs_info info;
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "amethyst%03x", sim[j]);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == SIZE);
}
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0;
// check the file contents
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "amethyst%03x", sim[j]);
lfsr_file_t file;
lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0;
uint32_t wprng = sim_prngs[j];
uint8_t wbuf[SIZE];
for (lfs_size_t j = 0; j < SIZE; j++) {
wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26);
} }
uint8_t rbuf[SIZE]; // check that our files match our simulation
lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; for (lfs_size_t j = 0; j < sim_size; j++) {
assert(memcmp(rbuf, wbuf, SIZE) == 0); char name[256];
lfsr_file_close(&lfs, &file) => 0; sprintf(name, "amethyst%03x", sim[j]);
struct lfs_info info;
lfsr_stat(&lfs, name, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == SIZE);
}
lfsr_dir_t dir;
lfsr_dir_open(&lfs, &dir, "/") => 0;
struct lfs_info info;
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "amethyst%03x", sim[j]);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, name) == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == SIZE);
}
lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
lfsr_dir_close(&lfs, &dir) => 0;
// check the file contents
for (lfs_size_t j = 0; j < sim_size; j++) {
char name[256];
sprintf(name, "amethyst%03x", sim[j]);
lfsr_file_t file;
lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0;
uint32_t wprng = sim_prngs[j];
uint8_t wbuf[SIZE];
for (lfs_size_t j = 0; j < SIZE; j++) {
wbuf[j] = 'a' + (TEST_PRNG(&wprng) % 26);
}
uint8_t rbuf[SIZE];
lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE;
assert(memcmp(rbuf, wbuf, SIZE) == 0);
lfsr_file_close(&lfs, &file) => 0;
}
} }
// clean up sim/lfs // clean up sim/lfs
@@ -1146,7 +1149,6 @@ defines.SIZE = [
'2*BLOCK_SIZE', '2*BLOCK_SIZE',
'4*BLOCK_SIZE', '4*BLOCK_SIZE',
] ]
defines.REMOUNT = [false, true]
defines.SEED = 'range(10)' defines.SEED = 'range(10)'
if = '(SIZE*N)/BLOCK_SIZE <= 16' if = '(SIZE*N)/BLOCK_SIZE <= 16'
reentrant = true reentrant = true
@@ -1288,52 +1290,54 @@ code = '''
// go ahead and close our state file in case we remount // go ahead and close our state file in case we remount
lfsr_file_close(&lfs, &state_file) => 0; lfsr_file_close(&lfs, &state_file) => 0;
// remount? for (int remount = 0; remount < 2; remount++) {
if (REMOUNT) { // remount?
lfsr_unmount(&lfs) => 0; if (remount) {
lfsr_mount(&lfs, CFG) => 0; lfsr_unmount(&lfs) => 0;
} lfsr_mount(&lfs, CFG) => 0;
// check that things look more-or-less ok
lfsr_dir_t dir;
lfsr_dir_open(&lfs, &dir, "test") => 0;
struct lfs_info info;
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
while (true) {
int err = lfsr_dir_read(&lfs, &dir, &info);
assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
break;
} }
assert(strlen(info.name) == strlen("amethyst..."));
assert(memcmp(info.name, "amethyst", strlen("amethyst")) == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == SIZE);
// at least try to read the files // check that things look more-or-less ok
char name[256]; lfsr_dir_t dir;
sprintf(name, "test/%s", info.name); lfsr_dir_open(&lfs, &dir, "test") => 0;
lfsr_file_t file; struct lfs_info info;
lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0; lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, ".") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
lfsr_dir_read(&lfs, &dir, &info) => 0;
assert(strcmp(info.name, "..") == 0);
assert(info.type == LFS_TYPE_DIR);
assert(info.size == 0);
while (true) {
int err = lfsr_dir_read(&lfs, &dir, &info);
assert(!err || err == LFS_ERR_NOENT);
if (err == LFS_ERR_NOENT) {
break;
}
assert(strlen(info.name) == strlen("amethyst..."));
assert(memcmp(info.name, "amethyst", strlen("amethyst")) == 0);
assert(info.type == LFS_TYPE_REG);
assert(info.size == SIZE);
uint8_t rbuf[SIZE]; // at least try to read the files
lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE; char name[256];
// sum should be equal to 'a' mod 26 sprintf(name, "test/%s", info.name);
uint8_t ck = 0; lfsr_file_t file;
for (lfs_size_t j = 0; j < SIZE; j++) { lfsr_file_open(&lfs, &file, name, LFS_O_RDONLY) => 0;
ck = (ck + (rbuf[j] - 'a')) % 26;
uint8_t rbuf[SIZE];
lfsr_file_read(&lfs, &file, rbuf, SIZE) => SIZE;
// sum should be equal to 'a' mod 26
uint8_t ck = 0;
for (lfs_size_t j = 0; j < SIZE; j++) {
ck = (ck + (rbuf[j] - 'a')) % 26;
}
assert(ck == 0);
lfsr_file_close(&lfs, &file) => 0;
} }
assert(ck == 0); lfsr_dir_close(&lfs, &dir) => 0;
lfsr_file_close(&lfs, &file) => 0;
} }
lfsr_dir_close(&lfs, &dir) => 0;
lfsr_unmount(&lfs) => 0; lfsr_unmount(&lfs) => 0;
''' '''