diff options
author | Christopher Haster <chaster@utexas.edu> | 2019-07-29 05:53:55 +0300 |
---|---|---|
committer | GitHub <noreply@github.com> | 2019-07-29 05:53:55 +0300 |
commit | 501b0240a952177d4dae5f9526551f8659e5bf97 (patch) | |
tree | b3065f1fb5d7ea7f0040191a94ca5ded1a439adb | |
parent | 74fe46de3de98cecdff8681ccd53c481c31352e6 (diff) | |
parent | e1f3b90b56c31503473ab19cc1c6b466cc699eff (diff) |
Merge pull request #232 from ARMmbed/debug-improvements
Debug improvements
-rw-r--r-- | Makefile | 20 | ||||
-rw-r--r-- | emubd/lfs_emubd.c | 144 | ||||
-rw-r--r-- | lfs.c | 292 | ||||
-rw-r--r-- | lfs_util.h | 18 | ||||
-rwxr-xr-x | scripts/corrupt.py (renamed from tests/corrupt.py) | 0 | ||||
-rwxr-xr-x | scripts/debug.py (renamed from tests/debug.py) | 2 | ||||
-rwxr-xr-x | scripts/results.py | 28 | ||||
-rw-r--r-- | scripts/template.fmt (renamed from tests/template.fmt) | 44 | ||||
-rwxr-xr-x | scripts/test.py | 81 | ||||
-rwxr-xr-x | tests/stats.py | 30 | ||||
-rwxr-xr-x | tests/test.py | 61 | ||||
-rwxr-xr-x | tests/test_alloc.sh | 251 | ||||
-rwxr-xr-x | tests/test_attrs.sh | 104 | ||||
-rwxr-xr-x | tests/test_corrupt.sh | 26 | ||||
-rwxr-xr-x | tests/test_dirs.sh | 351 | ||||
-rwxr-xr-x | tests/test_entries.sh | 112 | ||||
-rwxr-xr-x | tests/test_files.sh | 140 | ||||
-rwxr-xr-x | tests/test_format.sh | 17 | ||||
-rwxr-xr-x | tests/test_interspersed.sh | 158 | ||||
-rwxr-xr-x | tests/test_move.sh | 305 | ||||
-rwxr-xr-x | tests/test_orphan.sh | 13 | ||||
-rwxr-xr-x | tests/test_paths.sh | 83 | ||||
-rwxr-xr-x | tests/test_seek.sh | 394 | ||||
-rwxr-xr-x | tests/test_truncate.sh | 192 |
24 files changed, 1624 insertions, 1242 deletions
@@ -24,6 +24,9 @@ endif ifdef WORD override CFLAGS += -m$(WORD) endif +ifdef TRACE +override CFLAGS += -DLFS_YES_TRACE +endif override CFLAGS += -I. override CFLAGS += -std=c99 -Wall -pedantic override CFLAGS += -Wextra -Wshadow -Wjump-misses-init @@ -39,9 +42,20 @@ size: $(OBJ) $(SIZE) -t $^ .SUFFIXES: -test: test_format test_dirs test_files test_seek test_truncate \ - test_entries test_interspersed test_alloc test_paths test_attrs \ - test_move test_orphan test_corrupt +test: \ + test_format \ + test_dirs \ + test_files \ + test_seek \ + test_truncate \ + test_entries \ + test_interspersed \ + test_alloc \ + test_paths \ + test_attrs \ + test_move \ + test_orphan \ + test_corrupt @rm test.c test_%: tests/test_%.sh diff --git a/emubd/lfs_emubd.c b/emubd/lfs_emubd.c index f0f0971..ee20f27 100644 --- a/emubd/lfs_emubd.c +++ b/emubd/lfs_emubd.c @@ -54,6 +54,15 @@ static inline void lfs_emubd_fromle32(lfs_emubd_t *emu) { // Block device emulated on existing filesystem int lfs_emubd_create(const struct lfs_config *cfg, const char *path) { + LFS_TRACE("lfs_emubd_create(%p {.context=%p, " + ".read=%p, .prog=%p, .erase=%p, .sync=%p, " + ".read_size=%"PRIu32", .prog_size=%"PRIu32", " + ".block_size=%"PRIu32", .block_count=%"PRIu32"}, \"%s\")", + (void*)cfg, cfg->context, + (void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog, + (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync, + cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count, + path); lfs_emubd_t *emu = cfg->context; emu->cfg.read_size = cfg->read_size; emu->cfg.prog_size = cfg->prog_size; @@ -64,7 +73,9 @@ int lfs_emubd_create(const struct lfs_config *cfg, const char *path) { size_t pathlen = strlen(path); emu->path = malloc(pathlen + 1 + LFS_NAME_MAX + 1); if (!emu->path) { - return -ENOMEM; + int err = -ENOMEM; + LFS_TRACE("lfs_emubd_create -> %"PRId32, err); + return err; } strcpy(emu->path, path); @@ -75,7 +86,9 @@ int lfs_emubd_create(const struct lfs_config *cfg, const char *path) { // Create directory if it doesn't exist int err = mkdir(path, 0777); if (err && errno != EEXIST) { - return -errno; + err = -errno; + LFS_TRACE("lfs_emubd_create -> %"PRId32, err); + return err; } // Load stats to continue incrementing @@ -87,12 +100,16 @@ int lfs_emubd_create(const struct lfs_config *cfg, const char *path) { size_t res = fread(&emu->stats, sizeof(emu->stats), 1, f); lfs_emubd_fromle32(emu); if (res < 1) { - return -errno; + err = -errno; + LFS_TRACE("lfs_emubd_create -> %"PRId32, err); + return err; } err = fclose(f); if (err) { - return -errno; + err = -errno; + LFS_TRACE("lfs_emubd_create -> %"PRId32, err); + return err; } } @@ -105,27 +122,36 @@ int lfs_emubd_create(const struct lfs_config *cfg, const char *path) { size_t res = fread(&emu->history, sizeof(emu->history), 1, f); lfs_emubd_fromle32(emu); if (res < 1) { - return -errno; + err = -errno; + LFS_TRACE("lfs_emubd_create -> %"PRId32, err); + return err; } err = fclose(f); if (err) { - return -errno; + err = -errno; + LFS_TRACE("lfs_emubd_create -> %"PRId32, err); + return err; } } + LFS_TRACE("lfs_emubd_create -> %"PRId32, 0); return 0; } void lfs_emubd_destroy(const struct lfs_config *cfg) { + LFS_TRACE("lfs_emubd_destroy(%p)", (void*)cfg); lfs_emubd_sync(cfg); lfs_emubd_t *emu = cfg->context; free(emu->path); + LFS_TRACE("lfs_emubd_destroy -> %s", "void"); } int lfs_emubd_read(const struct lfs_config *cfg, lfs_block_t block, lfs_off_t off, void *buffer, lfs_size_t size) { + LFS_TRACE("lfs_emubd_read(%p, 0x%"PRIx32", %"PRIu32", %p, %"PRIu32")", + (void*)cfg, block, off, buffer, size); lfs_emubd_t *emu = cfg->context; uint8_t *data = buffer; @@ -142,32 +168,43 @@ int lfs_emubd_read(const struct lfs_config *cfg, lfs_block_t block, FILE *f = fopen(emu->path, "rb"); if (!f && errno != ENOENT) { - return -errno; + int err = -errno; + LFS_TRACE("lfs_emubd_read -> %d", err); + return err; } if (f) { int err = fseek(f, off, SEEK_SET); if (err) { - return -errno; + err = -errno; + LFS_TRACE("lfs_emubd_read -> %d", err); + return err; } size_t res = fread(data, 1, size, f); if (res < size && !feof(f)) { - return -errno; + err = -errno; + LFS_TRACE("lfs_emubd_read -> %d", err); + return err; } err = fclose(f); if (err) { - return -errno; + err = -errno; + LFS_TRACE("lfs_emubd_read -> %d", err); + return err; } } - emu->stats.read_count += 1; + emu->stats.read_count += size; + LFS_TRACE("lfs_emubd_read -> %d", 0); return 0; } int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block, lfs_off_t off, const void *buffer, lfs_size_t size) { + LFS_TRACE("lfs_emubd_prog(%p, 0x%"PRIx32", %"PRIu32", %p, %"PRIu32")", + (void*)cfg, block, off, buffer, size); lfs_emubd_t *emu = cfg->context; const uint8_t *data = buffer; @@ -181,7 +218,9 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block, FILE *f = fopen(emu->path, "r+b"); if (!f) { - return (errno == EACCES) ? 0 : -errno; + int err = (errno == EACCES) ? 0 : -errno; + LFS_TRACE("lfs_emubd_prog -> %d", err); + return err; } // Check that file was erased @@ -189,28 +228,38 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block, int err = fseek(f, off, SEEK_SET); if (err) { - return -errno; + err = -errno; + LFS_TRACE("lfs_emubd_prog -> %d", err); + return err; } size_t res = fwrite(data, 1, size, f); if (res < size) { - return -errno; + err = -errno; + LFS_TRACE("lfs_emubd_prog -> %d", err); + return err; } err = fseek(f, off, SEEK_SET); if (err) { - return -errno; + err = -errno; + LFS_TRACE("lfs_emubd_prog -> %d", err); + return err; } uint8_t dat; res = fread(&dat, 1, 1, f); if (res < 1) { - return -errno; + err = -errno; + LFS_TRACE("lfs_emubd_prog -> %d", err); + return err; } err = fclose(f); if (err) { - return -errno; + err = -errno; + LFS_TRACE("lfs_emubd_prog -> %d", err); + return err; } // update history and stats @@ -220,11 +269,13 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block, emu->history.blocks[0] = block; } - emu->stats.prog_count += 1; + emu->stats.prog_count += size; + LFS_TRACE("lfs_emubd_prog -> %d", 0); return 0; } int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) { + LFS_TRACE("lfs_emubd_erase(%p, 0x%"PRIx32")", (void*)cfg, block); lfs_emubd_t *emu = cfg->context; // Check if erase is valid @@ -235,89 +286,118 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) { struct stat st; int err = stat(emu->path, &st); if (err && errno != ENOENT) { - return -errno; + err = -errno; + LFS_TRACE("lfs_emubd_erase -> %d", err); + return err; } if (!err && S_ISREG(st.st_mode) && (S_IWUSR & st.st_mode)) { err = unlink(emu->path); if (err) { - return -errno; + err = -errno; + LFS_TRACE("lfs_emubd_erase -> %d", err); + return err; } } if (err || (S_ISREG(st.st_mode) && (S_IWUSR & st.st_mode))) { FILE *f = fopen(emu->path, "w"); if (!f) { - return -errno; + err = -errno; + LFS_TRACE("lfs_emubd_erase -> %d", err); + return err; } err = fclose(f); if (err) { - return -errno; + err = -errno; + LFS_TRACE("lfs_emubd_erase -> %d", err); + return err; } } - emu->stats.erase_count += 1; + emu->stats.erase_count += cfg->block_size; + LFS_TRACE("lfs_emubd_erase -> %d", 0); return 0; } int lfs_emubd_sync(const struct lfs_config *cfg) { + LFS_TRACE("lfs_emubd_sync(%p)", (void*)cfg); lfs_emubd_t *emu = cfg->context; // Just write out info/stats for later lookup snprintf(emu->child, LFS_NAME_MAX, ".config"); FILE *f = fopen(emu->path, "w"); if (!f) { - return -errno; + int err = -errno; + LFS_TRACE("lfs_emubd_sync -> %d", err); + return err; } lfs_emubd_tole32(emu); size_t res = fwrite(&emu->cfg, sizeof(emu->cfg), 1, f); lfs_emubd_fromle32(emu); if (res < 1) { - return -errno; + int err = -errno; + LFS_TRACE("lfs_emubd_sync -> %d", err); + return err; } int err = fclose(f); if (err) { - return -errno; + err = -errno; + LFS_TRACE("lfs_emubd_sync -> %d", err); + return err; } snprintf(emu->child, LFS_NAME_MAX, ".stats"); f = fopen(emu->path, "w"); if (!f) { - return -errno; + err = -errno; + LFS_TRACE("lfs_emubd_sync -> %d", err); + return err; } lfs_emubd_tole32(emu); res = fwrite(&emu->stats, sizeof(emu->stats), 1, f); lfs_emubd_fromle32(emu); if (res < 1) { - return -errno; + err = -errno; + LFS_TRACE("lfs_emubd_sync -> %d", err); + return err; } err = fclose(f); if (err) { - return -errno; + err = -errno; + LFS_TRACE("lfs_emubd_sync -> %d", err); + return err; } snprintf(emu->child, LFS_NAME_MAX, ".history"); f = fopen(emu->path, "w"); if (!f) { - return -errno; + err = -errno; + LFS_TRACE("lfs_emubd_sync -> %d", err); + return err; } lfs_emubd_tole32(emu); res = fwrite(&emu->history, sizeof(emu->history), 1, f); lfs_emubd_fromle32(emu); if (res < 1) { - return -errno; + err = -errno; + LFS_TRACE("lfs_emubd_sync -> %d", err); + return err; } err = fclose(f); if (err) { - return -errno; + err = -errno; + LFS_TRACE("lfs_emubd_sync -> %d", err); + return err; } + LFS_TRACE("lfs_emubd_sync -> %d", 0); return 0; } @@ -81,6 +81,7 @@ static int lfs_bd_read(lfs_t *lfs, lfs->cfg->cache_size); int err = lfs->cfg->read(lfs->cfg, rcache->block, rcache->off, rcache->buffer, rcache->size); + LFS_ASSERT(err <= 0); if (err) { return err; } @@ -125,6 +126,7 @@ static int lfs_bd_flush(lfs_t *lfs, lfs_size_t diff = lfs_alignup(pcache->size, lfs->cfg->prog_size); int err = lfs->cfg->prog(lfs->cfg, pcache->block, pcache->off, pcache->buffer, diff); + LFS_ASSERT(err <= 0); if (err) { return err; } @@ -159,7 +161,9 @@ static int lfs_bd_sync(lfs_t *lfs, return err; } - return lfs->cfg->sync(lfs->cfg); + err = lfs->cfg->sync(lfs->cfg); + LFS_ASSERT(err <= 0); + return err; } static int lfs_bd_prog(lfs_t *lfs, @@ -210,7 +214,9 @@ static int lfs_bd_prog(lfs_t *lfs, static int lfs_bd_erase(lfs_t *lfs, lfs_block_t block) { LFS_ASSERT(block < lfs->cfg->block_count); - return lfs->cfg->erase(lfs->cfg, block); + int err = lfs->cfg->erase(lfs->cfg, block); + LFS_ASSERT(err <= 0); + return err; } @@ -460,7 +466,7 @@ static int lfs_alloc(lfs_t *lfs, lfs_block_t *block) { // check if we have looked at all blocks since last ack if (lfs->free.ack == 0) { - LFS_WARN("No more free space %"PRIu32, + LFS_ERROR("No more free space %"PRIu32, lfs->free.i + lfs->free.off); return LFS_ERR_NOSPC; } @@ -960,7 +966,7 @@ static lfs_stag_t lfs_dir_fetchmatch(lfs_t *lfs, dir->rev = revs[(r+1)%2]; } - LFS_ERROR("Corrupted dir pair at %"PRIu32" %"PRIu32, + LFS_ERROR("Corrupted dir pair at %"PRIx32" %"PRIx32, dir->pair[0], dir->pair[1]); return LFS_ERR_CORRUPT; } @@ -1616,12 +1622,12 @@ relocate: relocated = true; lfs_cache_drop(lfs, &lfs->pcache); if (!exhausted) { - LFS_DEBUG("Bad block at %"PRIu32, dir->pair[1]); + LFS_DEBUG("Bad block at %"PRIx32, dir->pair[1]); } // can't relocate superblock, filesystem is now frozen if (lfs_pair_cmp(oldpair, (const lfs_block_t[2]){0, 1}) == 0) { - LFS_WARN("Superblock %"PRIu32" has become unwritable", oldpair[1]); + LFS_WARN("Superblock %"PRIx32" has become unwritable", oldpair[1]); return LFS_ERR_NOSPC; } @@ -1639,7 +1645,7 @@ relocate: lfs->gdelta = (struct lfs_gstate){0}; } else { // update references if we relocated - LFS_DEBUG("Relocating %"PRIu32" %"PRIu32" to %"PRIu32" %"PRIu32, + LFS_DEBUG("Relocating %"PRIx32" %"PRIx32" -> %"PRIx32" %"PRIx32, oldpair[0], oldpair[1], dir->pair[0], dir->pair[1]); int err = lfs_fs_relocate(lfs, oldpair, dir->pair); if (err) { @@ -1833,9 +1839,11 @@ compact: /// Top level directory operations /// int lfs_mkdir(lfs_t *lfs, const char *path) { + LFS_TRACE("lfs_mkdir(%p, \"%s\")", (void*)lfs, path); // deorphan if we haven't yet, needed at most once after poweron int err = lfs_fs_forceconsistency(lfs); if (err) { + LFS_TRACE("lfs_mkdir -> %d", err); return err; } @@ -1843,12 +1851,14 @@ int lfs_mkdir(lfs_t *lfs, const char *path) { uint16_t id; err = lfs_dir_find(lfs, &cwd, &path, &id); if (!(err == LFS_ERR_NOENT && id != 0x3ff)) { + LFS_TRACE("lfs_mkdir -> %d", (err < 0) ? err : LFS_ERR_EXIST); return (err < 0) ? err : LFS_ERR_EXIST; } // check that name fits lfs_size_t nlen = strlen(path); if (nlen > lfs->name_max) { + LFS_TRACE("lfs_mkdir -> %d", LFS_ERR_NAMETOOLONG); return LFS_ERR_NAMETOOLONG; } @@ -1857,6 +1867,7 @@ int lfs_mkdir(lfs_t *lfs, const char *path) { lfs_mdir_t dir; err = lfs_dir_alloc(lfs, &dir); if (err) { + LFS_TRACE("lfs_mkdir -> %d", err); return err; } @@ -1865,6 +1876,7 @@ int lfs_mkdir(lfs_t *lfs, const char *path) { while (pred.split) { err = lfs_dir_fetch(lfs, &pred, pred.tail); if (err) { + LFS_TRACE("lfs_mkdir -> %d", err); return err; } } @@ -1875,6 +1887,7 @@ int lfs_mkdir(lfs_t *lfs, const char *path) { {LFS_MKTAG(LFS_TYPE_SOFTTAIL, 0x3ff, 8), pred.tail})); lfs_pair_fromle32(pred.tail); if (err) { + LFS_TRACE("lfs_mkdir -> %d", err); return err; } @@ -1887,6 +1900,7 @@ int lfs_mkdir(lfs_t *lfs, const char *path) { {LFS_MKTAG(LFS_TYPE_SOFTTAIL, 0x3ff, 8), dir.pair})); lfs_pair_fromle32(dir.pair); if (err) { + LFS_TRACE("lfs_mkdir -> %d", err); return err; } lfs_fs_preporphans(lfs, -1); @@ -1903,19 +1917,24 @@ int lfs_mkdir(lfs_t *lfs, const char *path) { : LFS_MKTAG(LFS_FROM_NOOP, 0, 0), dir.pair})); lfs_pair_fromle32(dir.pair); if (err) { + LFS_TRACE("lfs_mkdir -> %d", err); return err; } + LFS_TRACE("lfs_mkdir -> %d", 0); return 0; } int lfs_dir_open(lfs_t *lfs, lfs_dir_t *dir, const char *path) { + LFS_TRACE("lfs_dir_open(%p, %p, \"%s\")", (void*)lfs, (void*)dir, path); lfs_stag_t tag = lfs_dir_find(lfs, &dir->m, &path, NULL); if (tag < 0) { + LFS_TRACE("lfs_dir_open -> %d", tag); return tag; } if (lfs_tag_type3(tag) != LFS_TYPE_DIR) { + LFS_TRACE("lfs_dir_open -> %d", LFS_ERR_NOTDIR); return LFS_ERR_NOTDIR; } @@ -1929,6 +1948,7 @@ int lfs_dir_open(lfs_t *lfs, lfs_dir_t *dir, const char *path) { lfs_stag_t res = lfs_dir_get(lfs, &dir->m, LFS_MKTAG(0x700, 0x3ff, 0), LFS_MKTAG(LFS_TYPE_STRUCT, lfs_tag_id(tag), 8), pair); if (res < 0) { + LFS_TRACE("lfs_dir_open -> %d", res); return res; } lfs_pair_fromle32(pair); @@ -1937,6 +1957,7 @@ int lfs_dir_open(lfs_t *lfs, lfs_dir_t *dir, const char *path) { // fetch first pair int err = lfs_dir_fetch(lfs, &dir->m, pair); if (err) { + LFS_TRACE("lfs_dir_open -> %d", err); return err; } @@ -1951,10 +1972,12 @@ int lfs_dir_open(lfs_t *lfs, lfs_dir_t *dir, const char *path) { dir->next = (lfs_dir_t*)lfs->mlist; lfs->mlist = (struct lfs_mlist*)dir; + LFS_TRACE("lfs_dir_open -> %d", 0); return 0; } int lfs_dir_close(lfs_t *lfs, lfs_dir_t *dir) { + LFS_TRACE("lfs_dir_close(%p, %p)", (void*)lfs, (void*)dir); // remove from list of mdirs for (struct lfs_mlist **p = &lfs->mlist; *p; p = &(*p)->next) { if (*p == (struct lfs_mlist*)dir) { @@ -1963,10 +1986,13 @@ int lfs_dir_close(lfs_t *lfs, lfs_dir_t *dir) { } } + LFS_TRACE("lfs_dir_close -> %d", 0); return 0; } int lfs_dir_read(lfs_t *lfs, lfs_dir_t *dir, struct lfs_info *info) { + LFS_TRACE("lfs_dir_read(%p, %p, %p)", + (void*)lfs, (void*)dir, (void*)info); memset(info, 0, sizeof(*info)); // special offset for '.' and '..' @@ -1974,22 +2000,26 @@ int lfs_dir_read(lfs_t *lfs, lfs_dir_t *dir, struct lfs_info *info) { info->type = LFS_TYPE_DIR; strcpy(info->name, "."); dir->pos += 1; - return 1; + LFS_TRACE("lfs_dir_read -> %d", true); + return true; } else if (dir->pos == 1) { info->type = LFS_TYPE_DIR; strcpy(info->name, ".."); dir->pos += 1; - return 1; + LFS_TRACE("lfs_dir_read -> %d", true); + return true; } while (true) { if (dir->id == dir->m.count) { if (!dir->m.split) { + LFS_TRACE("lfs_dir_read -> %d", false); return false; } int err = lfs_dir_fetch(lfs, &dir->m, dir->m.tail); if (err) { + LFS_TRACE("lfs_dir_read -> %d", err); return err; } @@ -1998,6 +2028,7 @@ int lfs_dir_read(lfs_t *lfs, lfs_dir_t *dir, struct lfs_info *info) { int err = lfs_dir_getinfo(lfs, &dir->m, dir->id, info); if (err && err != LFS_ERR_NOENT) { + LFS_TRACE("lfs_dir_read -> %d", err); return err; } @@ -2008,13 +2039,17 @@ int lfs_dir_read(lfs_t *lfs, lfs_dir_t *dir, struct lfs_info *info) { } dir->pos += 1; + LFS_TRACE("lfs_dir_read -> %d", true); return true; } int lfs_dir_seek(lfs_t *lfs, lfs_dir_t *dir, lfs_off_t off) { + LFS_TRACE("lfs_dir_seek(%p, %p, %"PRIu32")", + (void*)lfs, (void*)dir, off); // simply walk from head dir int err = lfs_dir_rewind(lfs, dir); if (err) { + LFS_TRACE("lfs_dir_seek -> %d", err); return err; } @@ -2029,28 +2064,35 @@ int lfs_dir_seek(lfs_t *lfs, lfs_dir_t *dir, lfs_off_t off) { if (dir->id == dir->m.count) { if (!dir->m.split) { + LFS_TRACE("lfs_dir_seek -> %d", LFS_ERR_INVAL); return LFS_ERR_INVAL; } err = lfs_dir_fetch(lfs, &dir->m, dir->m.tail); if (err) { + LFS_TRACE("lfs_dir_seek -> %d", err); return err; } } } + LFS_TRACE("lfs_dir_seek -> %d", 0); return 0; } lfs_soff_t lfs_dir_tell(lfs_t *lfs, lfs_dir_t *dir) { + LFS_TRACE("lfs_dir_tell(%p, %p)", (void*)lfs, (void*)dir); (void)lfs; + LFS_TRACE("lfs_dir_tell -> %"PRId32, dir->pos); return dir->pos; } int lfs_dir_rewind(lfs_t *lfs, lfs_dir_t *dir) { + LFS_TRACE("lfs_dir_rewind(%p, %p)", (void*)lfs, (void*)dir); // reload the head dir int err = lfs_dir_fetch(lfs, &dir->m, dir->head); if (err) { + LFS_TRACE("lfs_dir_rewind -> %d", err); return err; } @@ -2058,6 +2100,7 @@ int lfs_dir_rewind(lfs_t *lfs, lfs_dir_t *dir) { dir->m.pair[1] = dir->head[1]; dir->id = 0; dir->pos = 0; + LFS_TRACE("lfs_dir_rewind -> %d", 0); return 0; } @@ -2205,7 +2248,7 @@ static int lfs_ctz_extend(lfs_t *lfs, } relocate: - LFS_DEBUG("Bad block at %"PRIu32, nblock); + LFS_DEBUG("Bad block at %"PRIx32, nblock); // just clear cache and try a new block lfs_cache_drop(lfs, pcache); @@ -2260,6 +2303,11 @@ static int lfs_ctz_traverse(lfs_t *lfs, int lfs_file_opencfg(lfs_t *lfs, lfs_file_t *file, const char *path, int flags, const struct lfs_file_config *cfg) { + LFS_TRACE("lfs_file_opencfg(%p, %p, \"%s\", %x, %p {" + ".buffer=%p, .attrs=%p, .attr_count=%"PRIu32"})", + (void*)lfs, (void*)file, path, flags, + (void*)cfg, cfg->buffer, (void*)cfg->attrs, cfg->attr_count); + // do not allow open for already opened file LFS_ASSERT(0 == (file->flags & LFS_F_OPENED)); @@ -2267,6 +2315,7 @@ int lfs_file_opencfg(lfs_t *lfs, lfs_file_t *file, if ((flags & 3) != LFS_O_RDONLY) { int err = lfs_fs_forceconsistency(lfs); if (err) { + LFS_TRACE("lfs_file_opencfg -> %d", err); return err; } } @@ -2396,22 +2445,29 @@ int lfs_file_opencfg(lfs_t *lfs, lfs_file_t *file, } } + LFS_TRACE("lfs_file_opencfg -> %d", 0); return 0; cleanup: // clean up lingering resources file->flags |= LFS_F_ERRED; lfs_file_close(lfs, file); + LFS_TRACE("lfs_file_opencfg -> %d", err); return err; } int lfs_file_open(lfs_t *lfs, lfs_file_t *file, const char *path, int flags) { + LFS_TRACE("lfs_file_open(%p, %p, \"%s\", %x)", + (void*)lfs, (void*)file, path, flags); static const struct lfs_file_config defaults = {0}; - return lfs_file_opencfg(lfs, file, path, flags, &defaults); + int err = lfs_file_opencfg(lfs, file, path, flags, &defaults); + LFS_TRACE("lfs_file_open -> %d", err); + return err; } int lfs_file_close(lfs_t *lfs, lfs_file_t *file) { + LFS_TRACE("lfs_file_close(%p, %p)", (void*)lfs, (void*)file); LFS_ASSERT(file->flags & LFS_F_OPENED); int err = lfs_file_sync(lfs, file); @@ -2430,7 +2486,7 @@ int lfs_file_close(lfs_t *lfs, lfs_file_t *file) { } file->flags &= ~LFS_F_OPENED; - + LFS_TRACE("lfs_file_close -> %d", err); return err; } @@ -2498,7 +2554,7 @@ static int lfs_file_relocate(lfs_t *lfs, lfs_file_t *file) { return 0; relocate: - LFS_DEBUG("Bad block at %"PRIu32, nblock); + LFS_DEBUG("Bad block at %"PRIx32, nblock); // just clear cache and try a new block lfs_cache_drop(lfs, &lfs->pcache); @@ -2575,7 +2631,7 @@ static int lfs_file_flush(lfs_t *lfs, lfs_file_t *file) { break; relocate: - LFS_DEBUG("Bad block at %"PRIu32, file->block); + LFS_DEBUG("Bad block at %"PRIx32, file->block); err = lfs_file_relocate(lfs, file); if (err) { return err; @@ -2598,12 +2654,14 @@ relocate: } int lfs_file_sync(lfs_t *lfs, lfs_file_t *file) { + LFS_TRACE("lfs_file_sync(%p, %p)", (void*)lfs, (void*)file); LFS_ASSERT(file->flags & LFS_F_OPENED); while (true) { int err = lfs_file_flush(lfs, file); if (err) { file->flags |= LFS_F_ERRED; + LFS_TRACE("lfs_file_sync -> %d", err); return err; } @@ -2640,12 +2698,14 @@ int lfs_file_sync(lfs_t *lfs, lfs_file_t *file) { goto relocate; } file->flags |= LFS_F_ERRED; + LFS_TRACE("lfs_file_sync -> %d", err); return err; } file->flags &= ~LFS_F_DIRTY; } + LFS_TRACE("lfs_file_sync -> %d", 0); return 0; relocate: @@ -2653,6 +2713,7 @@ relocate: err = lfs_file_outline(lfs, file); if (err) { file->flags |= LFS_F_ERRED; + LFS_TRACE("lfs_file_sync -> %d", err); return err; } } @@ -2660,22 +2721,26 @@ relocate: lfs_ssize_t lfs_file_read(lfs_t *lfs, lfs_file_t *file, void *buffer, lfs_size_t size) { - uint8_t *data = buffer; - lfs_size_t nsize = size; - + LFS_TRACE("lfs_file_read(%p, %p, %p, %"PRIu32")", + (void*)lfs, (void*)file, buffer, size); LFS_ASSERT(file->flags & LFS_F_OPENED); LFS_ASSERT((file->flags & 3) != LFS_O_WRONLY); + uint8_t *data = buffer; + lfs_size_t nsize = size; + if (file->flags & LFS_F_WRITING) { // flush out any writes int err = lfs_file_flush(lfs, file); if (err) { + LFS_TRACE("lfs_file_read -> %"PRId32, err); return err; } } if (file->pos >= file->ctz.size) { // eof if past end + LFS_TRACE("lfs_file_read -> %"PRId32, 0); return 0; } @@ -2691,6 +2756,7 @@ lfs_ssize_t lfs_file_read(lfs_t *lfs, lfs_file_t *file, file->ctz.head, file->ctz.size, file->pos, &file->block, &file->off); if (err) { + LFS_TRACE("lfs_file_read -> %"PRId32, err); return err; } } else { @@ -2710,6 +2776,7 @@ lfs_ssize_t lfs_file_read(lfs_t *lfs, lfs_file_t *file, LFS_MKTAG(LFS_TYPE_INLINESTRUCT, file->id, 0), file->off, data, diff); if (err) { + LFS_TRACE("lfs_file_read -> %"PRId32, err); return err; } } else { @@ -2717,6 +2784,7 @@ lfs_ssize_t lfs_file_read(lfs_t *lfs, lfs_file_t *file, NULL, &file->cache, lfs->cfg->block_size, file->block, file->off, data, diff); if (err) { + LFS_TRACE("lfs_file_read -> %"PRId32, err); return err; } } @@ -2727,21 +2795,25 @@ lfs_ssize_t lfs_file_read(lfs_t *lfs, lfs_file_t *file, nsize -= diff; } + LFS_TRACE("lfs_file_read -> %"PRId32, size); return size; } lfs_ssize_t lfs_file_write(lfs_t *lfs, lfs_file_t *file, const void *buffer, lfs_size_t size) { - const uint8_t *data = buffer; - lfs_size_t nsize = size; - + LFS_TRACE("lfs_file_write(%p, %p, %p, %"PRIu32")", + (void*)lfs, (void*)file, buffer, size); LFS_ASSERT(file->flags & LFS_F_OPENED); LFS_ASSERT((file->flags & 3) != LFS_O_RDONLY); + const uint8_t *data = buffer; + lfs_size_t nsize = size; + if (file->flags & LFS_F_READING) { // drop any reads int err = lfs_file_flush(lfs, file); if (err) { + LFS_TRACE("lfs_file_write -> %"PRId32, err); return err; } } @@ -2752,6 +2824,7 @@ lfs_ssize_t lfs_file_write(lfs_t *lfs, lfs_file_t *file, if (file->pos + size > lfs->file_max) { // Larger than file limit? + LFS_TRACE("lfs_file_write -> %"PRId32, LFS_ERR_FBIG); return LFS_ERR_FBIG; } @@ -2763,6 +2836,7 @@ lfs_ssize_t lfs_file_write(lfs_t *lfs, lfs_file_t *file, while (file->pos < pos) { lfs_ssize_t res = lfs_file_write(lfs, file, &(uint8_t){0}, 1); if (res < 0) { + LFS_TRACE("lfs_file_write -> %"PRId32, res); return res; } } @@ -2776,6 +2850,7 @@ lfs_ssize_t lfs_file_write(lfs_t *lfs, lfs_file_t *file, int err = lfs_file_outline(lfs, file); if (err) { file->flags |= LFS_F_ERRED; + LFS_TRACE("lfs_file_write -> %"PRId32, err); return err; } } @@ -2792,6 +2867,7 @@ lfs_ssize_t lfs_file_write(lfs_t *lfs, lfs_file_t *file, file->pos-1, &file->block, &file->off); if (err) { file->flags |= LFS_F_ERRED; + LFS_TRACE("lfs_file_write -> %"PRId32, err); return err; } @@ -2806,6 +2882,7 @@ lfs_ssize_t lfs_file_write(lfs_t *lfs, lfs_file_t *file, &file->block, &file->off); if (err) { file->flags |= LFS_F_ERRED; + LFS_TRACE("lfs_file_write -> %"PRId32, err); return err; } } else { @@ -2826,6 +2903,7 @@ lfs_ssize_t lfs_file_write(lfs_t *lfs, lfs_file_t *file, goto relocate; } file->flags |= LFS_F_ERRED; + LFS_TRACE("lfs_file_write -> %"PRId32, err); return err; } @@ -2834,6 +2912,7 @@ relocate: err = lfs_file_relocate(lfs, file); if (err) { file->flags |= LFS_F_ERRED; + LFS_TRACE("lfs_file_write -> %"PRId32, err); return err; } } @@ -2847,16 +2926,20 @@ relocate: } file->flags &= ~LFS_F_ERRED; + LFS_TRACE("lfs_file_write -> %"PRId32, size); return size; } lfs_soff_t lfs_file_seek(lfs_t *lfs, lfs_file_t *file, lfs_soff_t off, int whence) { + LFS_TRACE("lfs_file_seek(%p, %p, %"PRId32", %d)", + (void*)lfs, (void*)file, off, whence); LFS_ASSERT(file->flags & LFS_F_OPENED); // write out everything beforehand, may be noop if rdonly int err = lfs_file_flush(lfs, file); if (err) { + LFS_TRACE("lfs_file_seek -> %"PRId32, err); return err; } @@ -2872,19 +2955,24 @@ lfs_soff_t lfs_file_seek(lfs_t *lfs, lfs_file_t *file, if (npos > lfs->file_max) { // file position out of range + LFS_TRACE("lfs_file_seek -> %"PRId32, LFS_ERR_INVAL); return LFS_ERR_INVAL; } // update pos file->pos = npos; + LFS_TRACE("lfs_file_seek -> %"PRId32, npos); return npos; } int lfs_file_truncate(lfs_t *lfs, lfs_file_t *file, lfs_off_t size) { + LFS_TRACE("lfs_file_truncate(%p, %p, %"PRIu32")", + (void*)lfs, (void*)file, size); LFS_ASSERT(file->flags & LFS_F_OPENED); LFS_ASSERT((file->flags & 3) != LFS_O_RDONLY); if (size > LFS_FILE_MAX) { + LFS_TRACE("lfs_file_truncate -> %d", LFS_ERR_INVAL); return LFS_ERR_INVAL; } @@ -2893,6 +2981,7 @@ int lfs_file_truncate(lfs_t *lfs, lfs_file_t *file, lfs_off_t size) { // need to flush since directly changing metadata int err = lfs_file_flush(lfs, file); if (err) { + LFS_TRACE("lfs_file_truncate -> %d", err); return err; } @@ -2901,6 +2990,7 @@ int lfs_file_truncate(lfs_t *lfs, lfs_file_t *file, lfs_off_t size) { file->ctz.head, file->ctz.size, size, &file->block, &file->off); if (err) { + LFS_TRACE("lfs_file_truncate -> %d", err); return err; } @@ -2914,6 +3004,7 @@ int lfs_file_truncate(lfs_t *lfs, lfs_file_t *file, lfs_off_t size) { if (file->pos != oldsize) { int err = lfs_file_seek(lfs, file, 0, LFS_SEEK_END); if (err < 0) { + LFS_TRACE("lfs_file_truncate -> %d", err); return err; } } @@ -2922,6 +3013,7 @@ int lfs_file_truncate(lfs_t *lfs, lfs_file_t *file, lfs_off_t size) { while (file->pos < size) { lfs_ssize_t res = lfs_file_write(lfs, file, &(uint8_t){0}, 1); if (res < 0) { + LFS_TRACE("lfs_file_truncate -> %d", res); return res; } } @@ -2929,34 +3021,45 @@ int lfs_file_truncate(lfs_t *lfs, lfs_file_t *file, lfs_off_t size) { // restore pos int err = lfs_file_seek(lfs, file, pos, LFS_SEEK_SET); if (err < 0) { + LFS_TRACE("lfs_file_truncate -> %d", err); return err; } } + LFS_TRACE("lfs_file_truncate -> %d", 0); return 0; } lfs_soff_t lfs_file_tell(lfs_t *lfs, lfs_file_t *file) { - (void)lfs; + LFS_TRACE("lfs_file_tell(%p, %p)", (void*)lfs, (void*)file); LFS_ASSERT(file->flags & LFS_F_OPENED); + (void)lfs; + LFS_TRACE("lfs_file_tell -> %"PRId32, file->pos); return file->pos; } int lfs_file_rewind(lfs_t *lfs, lfs_file_t *file) { + LFS_TRACE("lfs_file_rewind(%p, %p)", (void*)lfs, (void*)file); lfs_soff_t res = lfs_file_seek(lfs, file, 0, LFS_SEEK_SET); if (res < 0) { + LFS_TRACE("lfs_file_rewind -> %d", res); return res; } + LFS_TRACE("lfs_file_rewind -> %d", 0); return 0; } lfs_soff_t lfs_file_size(lfs_t *lfs, lfs_file_t *file) { - (void)lfs; + LFS_TRACE("lfs_file_size(%p, %p)", (void*)lfs, (void*)file); LFS_ASSERT(file->flags & LFS_F_OPENED); + (void)lfs; if (file->flags & LFS_F_WRITING) { + LFS_TRACE("lfs_file_size -> %"PRId32, + lfs_max(file->pos, file->ctz.size)); return lfs_max(file->pos, file->ctz.size); } else { + LFS_TRACE("lfs_file_size -> %"PRId32, file->ctz.size); return file->ctz.size; } } @@ -2964,25 +3067,32 @@ lfs_soff_t lfs_file_size(lfs_t *lfs, lfs_file_t *file) { /// General fs operations /// int lfs_stat(lfs_t *lfs, const char *path, struct lfs_info *info) { + LFS_TRACE("lfs_stat(%p, \"%s\", %p)", (void*)lfs, path, (void*)info); lfs_mdir_t cwd; lfs_stag_t tag = lfs_dir_find(lfs, &cwd, &path, NULL); if (tag < 0) { + LFS_TRACE("lfs_stat -> %d", tag); return tag; } - return lfs_dir_getinfo(lfs, &cwd, lfs_tag_id(tag), info); + int err = lfs_dir_getinfo(lfs, &cwd, lfs_tag_id(tag), info); + LFS_TRACE("lfs_stat -> %d", err); + return err; } int lfs_remove(lfs_t *lfs, const char *path) { + LFS_TRACE("lfs_remove(%p, \"%s\")", (void*)lfs, path); // deorphan if we haven't yet, needed at most once after poweron int err = lfs_fs_forceconsistency(lfs); if (err) { + LFS_TRACE("lfs_remove -> %d", err); return err; } lfs_mdir_t cwd; lfs_stag_t tag = lfs_dir_find(lfs, &cwd, &path, NULL); if (tag < 0 || lfs_tag_id(tag) == 0x3ff) { + LFS_TRACE("lfs_remove -> %d", (tag < 0) ? tag : LFS_ERR_INVAL); return (tag < 0) ? tag : LFS_ERR_INVAL; } @@ -2993,16 +3103,19 @@ int lfs_remove(lfs_t *lfs, const char *path) { lfs_stag_t res = lfs_dir_get(lfs, &cwd, LFS_MKTAG(0x700, 0x3ff, 0), LFS_MKTAG(LFS_TYPE_STRUCT, lfs_tag_id(tag), 8), pair); if (res < 0) { + LFS_TRACE("lfs_remove -> %d", res); return res; } lfs_pair_fromle32(pair); err = lfs_dir_fetch(lfs, &dir, pair); if (err) { + LFS_TRACE("lfs_remove -> %d", err); return err; } if (dir.count > 0 || dir.split) { + LFS_TRACE("lfs_remove -> %d", LFS_ERR_NOTEMPTY); return LFS_ERR_NOTEMPTY; } @@ -3014,6 +3127,7 @@ int lfs_remove(lfs_t *lfs, const char *path) { err = lfs_dir_commit(lfs, &cwd, LFS_MKATTRS( {LFS_MKTAG(LFS_TYPE_DELETE, lfs_tag_id(tag), 0), NULL})); if (err) { + LFS_TRACE("lfs_remove -> %d", err); return err; } @@ -3023,22 +3137,28 @@ int lfs_remove(lfs_t *lfs, const char *path) { err = lfs_fs_pred(lfs, dir.pair, &cwd); if (err) { + LFS_TRACE("lfs_remove -> %d", err); return err; } err = lfs_dir_drop(lfs, &cwd, &dir); if (err) { + LFS_TRACE("lfs_remove -> %d", err); return err; } } + LFS_TRACE("lfs_remove -> %d", 0); return 0; } int lfs_rename(lfs_t *lfs, const char *oldpath, const char *newpath) { + LFS_TRACE("lfs_rename(%p, \"%s\", \"%s\")", (void*)lfs, oldpath, newpath); + // deorphan if we haven't yet, needed at most once after poweron int err = lfs_fs_forceconsistency(lfs); if (err) { + LFS_TRACE("lfs_rename -> %d", err); return err; } @@ -3046,6 +3166,7 @@ int lfs_rename(lfs_t *lfs, const char *oldpath, const char *newpath) { lfs_mdir_t oldcwd; lfs_stag_t oldtag = lfs_dir_find(lfs, &oldcwd, &oldpath, NULL); if (oldtag < 0 || lfs_tag_id(oldtag) == 0x3ff) { + LFS_TRACE("lfs_rename -> %d", (oldtag < 0) ? oldtag : LFS_ERR_INVAL); return (oldtag < 0) ? oldtag : LFS_ERR_INVAL; } @@ -3055,6 +3176,7 @@ int lfs_rename(lfs_t *lfs, const char *oldpath, const char *newpath) { lfs_stag_t prevtag = lfs_dir_find(lfs, &newcwd, &newpath, &newid); if ((prevtag < 0 || lfs_tag_id(prevtag) == 0x3ff) && !(prevtag == LFS_ERR_NOENT && newid != 0x3ff)) { + LFS_TRACE("lfs_rename -> %d", (prevtag < 0) ? prevtag : LFS_ERR_INVAL); return (prevtag < 0) ? prevtag : LFS_ERR_INVAL; } @@ -3063,9 +3185,11 @@ int lfs_rename(lfs_t *lfs, const char *oldpath, const char *newpath) { // check that name fits lfs_size_t nlen = strlen(newpath); if (nlen > lfs->name_max) { + LFS_TRACE("lfs_rename -> %d", LFS_ERR_NAMETOOLONG); return LFS_ERR_NAMETOOLONG; } } else if (lfs_tag_type3(prevtag) != lfs_tag_type3(oldtag)) { + LFS_TRACE("lfs_rename -> %d", LFS_ERR_ISDIR); return LFS_ERR_ISDIR; } else if (lfs_tag_type3(prevtag) == LFS_TYPE_DIR) { // must be empty before removal @@ -3073,6 +3197,7 @@ int lfs_rename(lfs_t *lfs, const char *oldpath, const char *newpath) { lfs_stag_t res = lfs_dir_get(lfs, &newcwd, LFS_MKTAG(0x700, 0x3ff, 0), LFS_MKTAG(LFS_TYPE_STRUCT, newid, 8), prevpair); if (res < 0) { + LFS_TRACE("lfs_rename -> %d", res); return res; } lfs_pair_fromle32(prevpair); @@ -3080,10 +3205,12 @@ int lfs_rename(lfs_t *lfs, const char *oldpath, const char *newpath) { // must be empty before removal err = lfs_dir_fetch(lfs, &prevdir, prevpair); if (err) { + LFS_TRACE("lfs_rename -> %d", err); return err; } if (prevdir.count > 0 || prevdir.split) { + LFS_TRACE("lfs_rename -> %d", LFS_ERR_NOTEMPTY); return LFS_ERR_NOTEMPTY; } @@ -3113,6 +3240,7 @@ int lfs_rename(lfs_t *lfs, const char *oldpath, const char *newpath) { newpath}, {LFS_MKTAG(LFS_FROM_MOVE, newid, lfs_tag_id(oldtag)), &oldcwd})); if (err) { + LFS_TRACE("lfs_rename -> %d", err); return err; } @@ -3121,6 +3249,7 @@ int lfs_rename(lfs_t *lfs, const char *oldpath, const char *newpath) { if (lfs_pair_cmp(oldcwd.pair, newcwd.pair) != 0) { err = lfs_dir_commit(lfs, &oldcwd, NULL, 0); if (err) { + LFS_TRACE("lfs_rename -> %d", err); return err; } } @@ -3131,23 +3260,29 @@ int lfs_rename(lfs_t *lfs, const char *oldpath, const char *newpath) { err = lfs_fs_pred(lfs, prevdir.pair, &newcwd); if (err) { + LFS_TRACE("lfs_rename -> %d", err); return err; } err = lfs_dir_drop(lfs, &newcwd, &prevdir); if (err) { + LFS_TRACE("lfs_rename -> %d", err); return err; } } + LFS_TRACE("lfs_rename -> %d", 0); return 0; } lfs_ssize_t lfs_getattr(lfs_t *lfs, const char *path, uint8_t type, void *buffer, lfs_size_t size) { + LFS_TRACE("lfs_getattr(%p, \"%s\", %"PRIu8", %p, %"PRIu32")", + (void*)lfs, path, type, buffer, size); lfs_mdir_t cwd; lfs_stag_t tag = lfs_dir_find(lfs, &cwd, &path, NULL); if (tag < 0) { + LFS_TRACE("lfs_getattr -> %"PRId32, tag); return tag; } @@ -3157,6 +3292,7 @@ lfs_ssize_t lfs_getattr(lfs_t *lfs, const char *path, id = 0; int err = lfs_dir_fetch(lfs, &cwd, lfs->root); if (err) { + LFS_TRACE("lfs_getattr -> %"PRId32, err); return err; } } @@ -3167,12 +3303,17 @@ lfs_ssize_t lfs_getattr(lfs_t *lfs, const char *path, buffer); if (tag < 0) { if (tag == LFS_ERR_NOENT) { + LFS_TRACE("lfs_getattr -> %"PRId32, LFS_ERR_NOATTR); return LFS_ERR_NOATTR; } + + LFS_TRACE("lfs_getattr -> %"PRId32, tag); return tag; } - return lfs_tag_size(tag); + size = lfs_tag_size(tag); + LFS_TRACE("lfs_getattr -> %"PRId32, size); + return size; } static int lfs_commitattr(lfs_t *lfs, const char *path, @@ -3199,15 +3340,23 @@ static int lfs_commitattr(lfs_t *lfs, const char *path, int lfs_setattr(lfs_t *lfs, const char *path, uint8_t type, const void *buffer, lfs_size_t size) { + LFS_TRACE("lfs_setattr(%p, \"%s\", %"PRIu8", %p, %"PRIu32")", + (void*)lfs, path, type, buffer, size); if (size > lfs->attr_max) { + LFS_TRACE("lfs_setattr -> %d", LFS_ERR_NOSPC); return LFS_ERR_NOSPC; } - return lfs_commitattr(lfs, path, type, buffer, size); + int err = lfs_commitattr(lfs, path, type, buffer, size); + LFS_TRACE("lfs_setattr -> %d", err); + return err; } int lfs_removeattr(lfs_t *lfs, const char *path, uint8_t type) { - return lfs_commitattr(lfs, path, type, NULL, 0x3ff); + LFS_TRACE("lfs_removeattr(%p, \"%s\", %"PRIu8")", (void*)lfs, path, type); + int err = lfs_commitattr(lfs, path, type, NULL, 0x3ff); + LFS_TRACE("lfs_removeattr -> %d", err); + return err; } @@ -3331,10 +3480,27 @@ static int lfs_deinit(lfs_t *lfs) { } int lfs_format(lfs_t *lfs, const struct lfs_config *cfg) { + LFS_TRACE("lfs_format(%p, %p {.context=%p, " + ".read=%p, .prog=%p, .erase=%p, .sync=%p, " + ".read_size=%"PRIu32", .prog_size=%"PRIu32", " + ".block_size=%"PRIu32", .block_count=%"PRIu32", " + ".block_cycles=%"PRIu32", .cache_size=%"PRIu32", " + ".lookahead_size=%"PRIu32", .read_buffer=%p, " + ".prog_buffer=%p, .lookahead_buffer=%p, " + ".name_max=%"PRIu32", .file_max=%"PRIu32", " + ".attr_max=%"PRIu32"})", + (void*)lfs, (void*)cfg, cfg->context, + (void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog, + (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync, + cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count, + cfg->block_cycles, cfg->cache_size, cfg->lookahead_size, + cfg->read_buffer, cfg->prog_buffer, cfg->lookahead_buffer, + cfg->name_max, cfg->file_max, cfg->attr_max); int err = 0; { err = lfs_init(lfs, cfg); if (err) { + LFS_TRACE("lfs_format -> %d", err); return err; } @@ -3390,12 +3556,30 @@ int lfs_format(lfs_t *lfs, const struct lfs_config *cfg) { cleanup: lfs_deinit(lfs); + LFS_TRACE("lfs_format -> %d", err); return err; } int lfs_mount(lfs_t *lfs, const struct lfs_config *cfg) { + LFS_TRACE("lfs_mount(%p, %p {.context=%p, " + ".read=%p, .prog=%p, .erase=%p, .sync=%p, " + ".read_size=%"PRIu32", .prog_size=%"PRIu32", " + ".block_size=%"PRIu32", .block_count=%"PRIu32", " + ".block_cycles=%"PRIu32", .cache_size=%"PRIu32", " + ".lookahead_size=%"PRIu32", .read_buffer=%p, " + ".prog_buffer=%p, .lookahead_buffer=%p, " + ".name_max=%"PRIu32", .file_max=%"PRIu32", " + ".attr_max=%"PRIu32"})", + (void*)lfs, (void*)cfg, cfg->context, + (void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog, + (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync, + cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count, + cfg->block_cycles, cfg->cache_size, cfg->lookahead_size, + cfg->read_buffer, cfg->prog_buffer, cfg->lookahead_buffer, + cfg->name_max, cfg->file_max, cfg->attr_max); int err = lfs_init(lfs, cfg); if (err) { + LFS_TRACE("lfs_mount -> %d", err); return err; } @@ -3480,7 +3664,7 @@ int lfs_mount(lfs_t *lfs, const struct lfs_config *cfg) { // has gstate? err = lfs_dir_getgstate(lfs, &dir, &lfs->gpending); if (err) { - return err; + goto cleanup; } } @@ -3494,7 +3678,7 @@ int lfs_mount(lfs_t *lfs, const struct lfs_config *cfg) { lfs->gpending.tag += !lfs_tag_isvalid(lfs->gpending.tag); lfs->gstate = lfs->gpending; if (lfs_gstate_hasmove(&lfs->gstate)) { - LFS_DEBUG("Found move %"PRIu32" %"PRIu32" %"PRIu16, + LFS_DEBUG("Found move %"PRIx32" %"PRIx32" %"PRIx16, lfs->gstate.pair[0], lfs->gstate.pair[1], lfs_tag_id(lfs->gstate.tag)); @@ -3506,21 +3690,28 @@ int lfs_mount(lfs_t *lfs, const struct lfs_config *cfg) { lfs->free.i = 0; lfs_alloc_ack(lfs); + LFS_TRACE("lfs_mount -> %d", 0); return 0; cleanup: lfs_unmount(lfs); + LFS_TRACE("lfs_mount -> %d", err); return err; } int lfs_unmount(lfs_t *lfs) { - return lfs_deinit(lfs); + LFS_TRACE("lfs_unmount(%p)", (void*)lfs); + int err = lfs_deinit(lfs); + LFS_TRACE("lfs_unmount -> %d", err); + return err; } /// Filesystem filesystem operations /// int lfs_fs_traverse(lfs_t *lfs, int (*cb)(void *data, lfs_block_t block), void *data) { + LFS_TRACE("lfs_fs_traverse(%p, %p, %p)", + (void*)lfs, (void*)(uintptr_t)cb, data); // iterate over metadata pairs lfs_mdir_t dir = {.tail = {0, 1}}; @@ -3529,6 +3720,7 @@ int lfs_fs_traverse(lfs_t *lfs, if (lfs->lfs1) { int err = lfs1_traverse(lfs, cb, data); if (err) { + LFS_TRACE("lfs_fs_traverse -> %d", err); return err; } @@ -3541,6 +3733,7 @@ int lfs_fs_traverse(lfs_t *lfs, for (int i = 0; i < 2; i++) { int err = cb(data, dir.tail[i]); if (err) { + LFS_TRACE("lfs_fs_traverse -> %d", err); return err; } } @@ -3548,6 +3741,7 @@ int lfs_fs_traverse(lfs_t *lfs, // iterate through ids in directory int err = lfs_dir_fetch(lfs, &dir, dir.tail); if (err) { + LFS_TRACE("lfs_fs_traverse -> %d", err); return err; } @@ -3559,6 +3753,7 @@ int lfs_fs_traverse(lfs_t *lfs, if (tag == LFS_ERR_NOENT) { continue; } + LFS_TRACE("lfs_fs_traverse -> %d", tag); return tag; } lfs_ctz_fromle32(&ctz); @@ -3567,6 +3762,7 @@ int lfs_fs_traverse(lfs_t *lfs, err = lfs_ctz_traverse(lfs, NULL, &lfs->rcache, ctz.head, ctz.size, cb, data); if (err) { + LFS_TRACE("lfs_fs_traverse -> %d", err); return err; } } @@ -3583,6 +3779,7 @@ int lfs_fs_traverse(lfs_t *lfs, int err = lfs_ctz_traverse(lfs, &f->cache, &lfs->rcache, f->ctz.head, f->ctz.size, cb, data); if (err) { + LFS_TRACE("lfs_fs_traverse -> %d", err); return err; } } @@ -3591,11 +3788,13 @@ int lfs_fs_traverse(lfs_t *lfs, int err = lfs_ctz_traverse(lfs, &f->cache, &lfs->rcache, f->block, f->pos, cb, data); if (err) { + LFS_TRACE("lfs_fs_traverse -> %d", err); return err; } } } + LFS_TRACE("lfs_fs_traverse -> %d", 0); return 0; } @@ -3666,7 +3865,7 @@ static int lfs_fs_relocate(lfs_t *lfs, const lfs_block_t oldpair[2], lfs_block_t newpair[2]) { // update internal root if (lfs_pair_cmp(oldpair, lfs->root) == 0) { - LFS_DEBUG("Relocating root %"PRIu32" %"PRIu32, + LFS_DEBUG("Relocating root %"PRIx32" %"PRIx32, newpair[0], newpair[1]); lfs->root[0] = newpair[0]; lfs->root[1] = newpair[1]; @@ -3744,7 +3943,7 @@ static int lfs_fs_demove(lfs_t *lfs) { } // Fix bad moves - LFS_DEBUG("Fixing move %"PRIu32" %"PRIu32" %"PRIu16, + LFS_DEBUG("Fixing move %"PRIx32" %"PRIx32" %"PRIx16, lfs->gstate.pair[0], lfs->gstate.pair[1], lfs_tag_id(lfs->gstate.tag)); @@ -3792,7 +3991,7 @@ static int lfs_fs_deorphan(lfs_t *lfs) { if (tag == LFS_ERR_NOENT) { // we are an orphan - LFS_DEBUG("Fixing orphan %"PRIu32" %"PRIu32, + LFS_DEBUG("Fixing orphan %"PRIx32" %"PRIx32, pdir.tail[0], pdir.tail[1]); err = lfs_dir_drop(lfs, &pdir, &dir); @@ -3813,7 +4012,7 @@ static int lfs_fs_deorphan(lfs_t *lfs) { if (!lfs_pair_sync(pair, pdir.tail)) { // we have desynced - LFS_DEBUG("Fixing half-orphan %"PRIu32" %"PRIu32, + LFS_DEBUG("Fixing half-orphan %"PRIx32" %"PRIx32, pair[0], pair[1]); lfs_pair_tole32(pair); @@ -3859,13 +4058,16 @@ static int lfs_fs_size_count(void *p, lfs_block_t block) { } lfs_ssize_t lfs_fs_size(lfs_t *lfs) { + LFS_TRACE("lfs_fs_size(%p)", (void*)lfs); lfs_size_t size = 0; int err = lfs_fs_traverse(lfs, lfs_fs_size_count, &size); if (err) { + LFS_TRACE("lfs_fs_size -> %"PRId32, err); return err; } - return size; + LFS_TRACE("lfs_fs_size -> %"PRId32, err); + return size; } #ifdef LFS_MIGRATE @@ -4073,7 +4275,7 @@ static int lfs1_dir_fetch(lfs_t *lfs, } if (!valid) { - LFS_ERROR("Corrupted dir pair at %" PRIu32 " %" PRIu32 , + LFS_ERROR("Corrupted dir pair at %" PRIx32 " %" PRIx32 , tpair[0], tpair[1]); return LFS_ERR_CORRUPT; } @@ -4289,9 +4491,26 @@ static int lfs1_unmount(lfs_t *lfs) { /// v1 migration /// int lfs_migrate(lfs_t *lfs, const struct lfs_config *cfg) { + LFS_TRACE("lfs_migrate(%p, %p {.context=%p, " + ".read=%p, .prog=%p, .erase=%p, .sync=%p, " + ".read_size=%"PRIu32", .prog_size=%"PRIu32", " + ".block_size=%"PRIu32", .block_count=%"PRIu32", " + ".block_cycles=%"PRIu32", .cache_size=%"PRIu32", " + ".lookahead_size=%"PRIu32", .read_buffer=%p, " + ".prog_buffer=%p, .lookahead_buffer=%p, " + ".name_max=%"PRIu32", .file_max=%"PRIu32", " + ".attr_max=%"PRIu32"})", + (void*)lfs, (void*)cfg, cfg->context, + (void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog, + (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync, + cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count, + cfg->block_cycles, cfg->cache_size, cfg->lookahead_size, + cfg->read_buffer, cfg->prog_buffer, cfg->lookahead_buffer, + cfg->name_max, cfg->file_max, cfg->attr_max); struct lfs1 lfs1; int err = lfs1_mount(lfs, &lfs1, cfg); if (err) { + LFS_TRACE("lfs_migrate -> %d", err); return err; } @@ -4418,7 +4637,7 @@ int lfs_migrate(lfs_t *lfs, const struct lfs_config *cfg) { // Copy over first block to thread into fs. Unfortunately // if this fails there is not much we can do. - LFS_DEBUG("Migrating %"PRIu32" %"PRIu32" -> %"PRIu32" %"PRIu32, + LFS_DEBUG("Migrating %"PRIx32" %"PRIx32" -> %"PRIx32" %"PRIx32, lfs->root[0], lfs->root[1], dir1.head[0], dir1.head[1]); err = lfs_bd_erase(lfs, dir1.head[1]); @@ -4506,6 +4725,7 @@ int lfs_migrate(lfs_t *lfs, const struct lfs_config *cfg) { cleanup: lfs1_unmount(lfs); + LFS_TRACE("lfs_migrate -> %d", err); return err; } @@ -31,7 +31,10 @@ #ifndef LFS_NO_ASSERT #include <assert.h> #endif -#if !defined(LFS_NO_DEBUG) || !defined(LFS_NO_WARN) || !defined(LFS_NO_ERROR) +#if !defined(LFS_NO_DEBUG) || \ + !defined(LFS_NO_WARN) || \ + !defined(LFS_NO_ERROR) || \ + defined(LFS_YES_TRACE) #include <stdio.h> #endif @@ -46,23 +49,30 @@ extern "C" // code footprint // Logging functions +#ifdef LFS_YES_TRACE +#define LFS_TRACE(fmt, ...) \ + printf("lfs_trace:%d: " fmt "\n", __LINE__, __VA_ARGS__) +#else +#define LFS_TRACE(fmt, ...) +#endif + #ifndef LFS_NO_DEBUG #define LFS_DEBUG(fmt, ...) \ - printf("lfs debug:%d: " fmt "\n", __LINE__, __VA_ARGS__) + printf("lfs_debug:%d: " fmt "\n", __LINE__, __VA_ARGS__) #else #define LFS_DEBUG(fmt, ...) #endif #ifndef LFS_NO_WARN #define LFS_WARN(fmt, ...) \ - printf("lfs warn:%d: " fmt "\n", __LINE__, __VA_ARGS__) + printf("lfs_warn:%d: " fmt "\n", __LINE__, __VA_ARGS__) #else #define LFS_WARN(fmt, ...) #endif #ifndef LFS_NO_ERROR #define LFS_ERROR(fmt, ...) \ - printf("lfs error:%d: " fmt "\n", __LINE__, __VA_ARGS__) + printf("lfs_error:%d: " fmt "\n", __LINE__, __VA_ARGS__) #else #define LFS_ERROR(fmt, ...) #endif diff --git a/tests/corrupt.py b/scripts/corrupt.py index c452c42..c452c42 100755 --- a/tests/corrupt.py +++ b/scripts/corrupt.py diff --git a/tests/debug.py b/scripts/debug.py index f8c0484..ba7525d 100755 --- a/tests/debug.py +++ b/scripts/debug.py @@ -95,7 +95,7 @@ def main(*blocks): print '%04x: %08x %-15s %3s %4s %-23s %-8s' % ( off, tag, typeof(type) + (' bad!' if iscrc and ~crc else ''), - id if id != 0x3ff else '.', + hex(id)[2:] if id != 0x3ff else '.', size if size != 0x3ff else 'x', ' '.join('%02x' % ord(c) for c in data[:8]), ''.join(c if c >= ' ' and c <= '~' else '.' for c in data[:8])) diff --git a/scripts/results.py b/scripts/results.py new file mode 100755 index 0000000..0e5cfc6 --- /dev/null +++ b/scripts/results.py @@ -0,0 +1,28 @@ +#!/usr/bin/env python2 + +import struct +import sys +import time +import os +import re + +def main(): + with open('blocks/.config') as file: + read_size, prog_size, block_size, block_count = ( + struct.unpack('<LLLL', file.read())) + + real_size = sum( + os.path.getsize(os.path.join('blocks', f)) + for f in os.listdir('blocks') if re.match('\d+', f)) + + with open('blocks/.stats') as file: + read_count, prog_count, erase_count = ( + struct.unpack('<QQQ', file.read())) + + runtime = time.time() - os.stat('blocks').st_ctime + + print 'results: %dB %dB %dB %.3fs' % ( + read_count, prog_count, erase_count, runtime) + +if __name__ == "__main__": + main(*sys.argv[1:]) diff --git a/tests/template.fmt b/scripts/template.fmt index b52d907..969e198 100644 --- a/tests/template.fmt +++ b/scripts/template.fmt @@ -7,34 +7,21 @@ // test stuff -static void test_log(const char *s, uintmax_t v) {{ - printf("%s: %jd\n", s, v); -}} - static void test_assert(const char *file, unsigned line, const char *s, uintmax_t v, uintmax_t e) {{ - static const char *last[6] = {{0, 0}}; - if (v != e || !(last[0] == s || last[1] == s || - last[2] == s || last[3] == s || - last[4] == s || last[5] == s)) {{ - test_log(s, v); - last[0] = last[1]; - last[1] = last[2]; - last[2] = last[3]; - last[3] = last[4]; - last[4] = last[5]; - last[5] = s; - }} - if (v != e) {{ - fprintf(stderr, "\033[31m%s:%u: assert %s failed with %jd, " - "expected %jd\033[0m\n", file, line, s, v, e); + fprintf(stderr, "\033[97m%s:%u: \033[91m" + "assert failed with %jd, expected %jd\033[0m\n" + " %s\n\n", file, line, v, e, s); exit(-2); }} }} -#define test_assert(s, v, e) test_assert(__FILE__, __LINE__, s, v, e) +#define test_assert(v, e) \ + test_assert(__FILE__, __LINE__, #v " => " #e, v, e) +// implicit variable for asserts +uintmax_t test; // utility functions for traversals static int __attribute__((used)) test_count(void *p, lfs_block_t b) {{ @@ -44,23 +31,17 @@ static int __attribute__((used)) test_count(void *p, lfs_block_t b) {{ return 0; }} - // lfs declarations lfs_t lfs; lfs_emubd_t bd; -lfs_file_t file[4]; -lfs_dir_t dir[4]; +// other declarations for convenience +lfs_file_t file; +lfs_dir_t dir; struct lfs_info info; - uint8_t buffer[1024]; -uint8_t wbuffer[1024]; -uint8_t rbuffer[1024]; -lfs_size_t size; -lfs_size_t wsize; -lfs_size_t rsize; - -uintmax_t test; +char path[1024]; +// test configuration options #ifndef LFS_READ_SIZE #define LFS_READ_SIZE 16 #endif @@ -111,6 +92,5 @@ int main(void) {{ lfs_emubd_create(&cfg, "blocks"); {tests} - lfs_emubd_destroy(&cfg); }} diff --git a/scripts/test.py b/scripts/test.py new file mode 100755 index 0000000..3135c65 --- /dev/null +++ b/scripts/test.py @@ -0,0 +1,81 @@ +#!/usr/bin/env python2 + +import re +import sys +import subprocess +import os + + +def generate(test): + with open("scripts/template.fmt") as file: + template = file.read() + + haslines = 'TEST_LINE' in os.environ and 'TEST_FILE' in os.environ + + lines = [] + for offset, line in enumerate( + re.split('(?<=(?:.;| [{}]))\n', test.read())): + match = re.match('((?: *\n)*)( *)(.*)=>(.*);', + line, re.DOTALL | re.MULTILINE) + if match: + preface, tab, test, expect = match.groups() + lines.extend(['']*preface.count('\n')) + lines.append(tab+'test_assert({test}, {expect});'.format( + test=test.strip(), expect=expect.strip())) + else: + lines.append(line) + + # Create test file + with open('test.c', 'w') as file: + if 'TEST_LINE' in os.environ and 'TEST_FILE' in os.environ: + lines.insert(0, '#line %d "%s"' % ( + int(os.environ['TEST_LINE']) + 1, + os.environ['TEST_FILE'])) + lines.append('#line %d "test.c"' % ( + template[:template.find('{tests}')].count('\n') + + len(lines) + 2)) + + file.write(template.format(tests='\n'.join(lines))) + + # Remove build artifacts to force rebuild + try: + os.remove('test.o') + os.remove('lfs') + except OSError: + pass + +def compile(): + subprocess.check_call([ + os.environ.get('MAKE', 'make'), + '--no-print-directory', '-s']) + +def execute(): + if 'EXEC' in os.environ: + subprocess.check_call([os.environ['EXEC'], "./lfs"]) + else: + subprocess.check_call(["./lfs"]) + +def main(test=None): + try: + if test and not test.startswith('-'): + with open(test) as file: + generate(file) + else: + generate(sys.stdin) + + compile() + + if test == '-s': + sys.exit(1) + + execute() + + except subprocess.CalledProcessError: + # Python stack trace is counterproductive, just exit + sys.exit(2) + except KeyboardInterrupt: + # Python stack trace is counterproductive, just exit + sys.exit(3) + +if __name__ == "__main__": + main(*sys.argv[1:]) diff --git a/tests/stats.py b/tests/stats.py deleted file mode 100755 index c2d0fab..0000000 --- a/tests/stats.py +++ /dev/null @@ -1,30 +0,0 @@ -#!/usr/bin/env python2 - -import struct -import sys -import time -import os -import re - -def main(): - with open('blocks/.config') as file: - s = struct.unpack('<LLLL', file.read()) - print 'read_size: %d' % s[0] - print 'prog_size: %d' % s[1] - print 'block_size: %d' % s[2] - print 'block_size: %d' % s[3] - - print 'real_size: %d' % sum( - os.path.getsize(os.path.join('blocks', f)) - for f in os.listdir('blocks') if re.match('\d+', f)) - - with open('blocks/.stats') as file: - s = struct.unpack('<QQQ', file.read()) - print 'read_count: %d' % s[0] - print 'prog_count: %d' % s[1] - print 'erase_count: %d' % s[2] - - print 'runtime: %.3f' % (time.time() - os.stat('blocks').st_ctime) - -if __name__ == "__main__": - main(*sys.argv[1:]) diff --git a/tests/test.py b/tests/test.py deleted file mode 100755 index 2d4f599..0000000 --- a/tests/test.py +++ /dev/null @@ -1,61 +0,0 @@ -#!/usr/bin/env python2 - -import re -import sys -import subprocess -import os - -def generate(test): - with open("tests/template.fmt") as file: - template = file.read() - - lines = [] - for line in re.split('(?<=(?:.;| [{}]))\n', test.read()): - match = re.match('(?: *\n)*( *)(.*)=>(.*);', line, re.DOTALL | re.MULTILINE) - if match: - tab, test, expect = match.groups() - lines.append(tab+'test = {test};'.format(test=test.strip())) - lines.append(tab+'test_assert("{name}", test, {expect});'.format( - name = re.match('\w*', test.strip()).group(), - expect = expect.strip())) - else: - lines.append(line) - - # Create test file - with open('test.c', 'w') as file: - file.write(template.format(tests='\n'.join(lines))) - - # Remove build artifacts to force rebuild - try: - os.remove('test.o') - os.remove('lfs') - except OSError: - pass - -def compile(): - subprocess.check_call([ - os.environ.get('MAKE', 'make'), - '--no-print-directory', '-s']) - -def execute(): - if 'EXEC' in os.environ: - subprocess.check_call([os.environ['EXEC'], "./lfs"]) - else: - subprocess.check_call(["./lfs"]) - -def main(test=None): - if test and not test.startswith('-'): - with open(test) as file: - generate(file) - else: - generate(sys.stdin) - - compile() - - if test == '-s': - sys.exit(1) - - execute() - -if __name__ == "__main__": - main(*sys.argv[1:]) diff --git a/tests/test_alloc.sh b/tests/test_alloc.sh index 3f993e9..d9f233b 100755 --- a/tests/test_alloc.sh +++ b/tests/test_alloc.sh @@ -1,16 +1,18 @@ #!/bin/bash -set -eu +set -euE +export TEST_FILE=$0 +trap 'export TEST_LINE=$LINENO' DEBUG echo "=== Allocator tests ===" rm -rf blocks -tests/test.py << TEST +scripts/test.py << TEST lfs_format(&lfs, &cfg) => 0; TEST SIZE=15000 lfs_mkdir() { -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_mkdir(&lfs, "$1") => 0; lfs_unmount(&lfs) => 0; @@ -18,7 +20,7 @@ TEST } lfs_remove() { -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_remove(&lfs, "$1/eggs") => 0; lfs_remove(&lfs, "$1/bacon") => 0; @@ -29,22 +31,23 @@ TEST } lfs_alloc_singleproc() { -tests/test.py << TEST +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((char*)buffer, "$1/%s", names[n]); - lfs_file_open(&lfs, &file[n], (char*)buffer, + sprintf(path, "$1/%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++) { - size = strlen(names[n]); + lfs_size_t size = strlen(names[n]); for (int i = 0; i < $SIZE; i++) { - lfs_file_write(&lfs, &file[n], names[n], size) => size; + lfs_file_write(&lfs, &files[n], names[n], size) => size; } } for (unsigned n = 0; n < sizeof(names)/sizeof(names[0]); n++) { - lfs_file_close(&lfs, &file[n]) => 0; + lfs_file_close(&lfs, &files[n]) => 0; } lfs_unmount(&lfs) => 0; TEST @@ -53,16 +56,16 @@ TEST lfs_alloc_multiproc() { for name in bacon eggs pancakes do -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file[0], "$1/$name", + lfs_file_open(&lfs, &file, "$1/$name", LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0; - size = strlen("$name"); + lfs_size_t size = strlen("$name"); memcpy(buffer, "$name", size); for (int i = 0; i < $SIZE; i++) { - lfs_file_write(&lfs, &file[0], buffer, size) => size; + lfs_file_write(&lfs, &file, buffer, size) => size; } - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST done @@ -71,15 +74,15 @@ done lfs_verify() { for name in bacon eggs pancakes do -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file[0], "$1/$name", LFS_O_RDONLY) => 0; - size = strlen("$name"); + 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[0], buffer, size) => size; + lfs_file_read(&lfs, &file, buffer, size) => size; memcmp(buffer, "$name", size) => 0; } - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST done @@ -115,19 +118,19 @@ lfs_remove multiprocreuse lfs_remove singleprocreuse echo "--- Exhaustion test ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT); - size = strlen("exhaustion"); + lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT); + lfs_size_t size = strlen("exhaustion"); memcpy(buffer, "exhaustion", size); - lfs_file_write(&lfs, &file[0], buffer, size) => size; - lfs_file_sync(&lfs, &file[0]) => 0; + lfs_file_write(&lfs, &file, buffer, size) => size; + lfs_file_sync(&lfs, &file) => 0; size = strlen("blahblahblahblah"); memcpy(buffer, "blahblahblahblah", size); lfs_ssize_t res; while (true) { - res = lfs_file_write(&lfs, &file[0], buffer, size); + res = lfs_file_write(&lfs, &file, buffer, size); if (res < 0) { break; } @@ -136,45 +139,45 @@ tests/test.py << TEST } res => LFS_ERR_NOSPC; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_RDONLY); - size = strlen("exhaustion"); - lfs_file_size(&lfs, &file[0]) => size; - lfs_file_read(&lfs, &file[0], buffer, size) => size; + lfs_file_open(&lfs, &file, "exhaustion", LFS_O_RDONLY); + lfs_size_t 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]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Exhaustion wraparound test ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_remove(&lfs, "exhaustion") => 0; - lfs_file_open(&lfs, &file[0], "padding", LFS_O_WRONLY | LFS_O_CREAT); - size = strlen("buffering"); + lfs_file_open(&lfs, &file, "padding", LFS_O_WRONLY | LFS_O_CREAT); + lfs_size_t size = strlen("buffering"); memcpy(buffer, "buffering", size); for (int i = 0; i < $SIZE; i++) { - lfs_file_write(&lfs, &file[0], buffer, size) => size; + lfs_file_write(&lfs, &file, buffer, size) => size; } - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_remove(&lfs, "padding") => 0; - lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT); + lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT); size = strlen("exhaustion"); memcpy(buffer, "exhaustion", size); - lfs_file_write(&lfs, &file[0], buffer, size) => size; - lfs_file_sync(&lfs, &file[0]) => 0; + lfs_file_write(&lfs, &file, buffer, size) => size; + lfs_file_sync(&lfs, &file) => 0; size = strlen("blahblahblahblah"); memcpy(buffer, "blahblahblahblah", size); lfs_ssize_t res; while (true) { - res = lfs_file_write(&lfs, &file[0], buffer, size); + res = lfs_file_write(&lfs, &file, buffer, size); if (res < 0) { break; } @@ -183,34 +186,34 @@ tests/test.py << TEST } res => LFS_ERR_NOSPC; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_RDONLY); - size = strlen("exhaustion"); - lfs_file_size(&lfs, &file[0]) => size; - lfs_file_read(&lfs, &file[0], buffer, size) => size; + lfs_file_open(&lfs, &file, "exhaustion", LFS_O_RDONLY); + lfs_size_t 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]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_remove(&lfs, "exhaustion") => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Dir exhaustion test ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; // find out max file size lfs_mkdir(&lfs, "exhaustiondir") => 0; - size = strlen("blahblahblahblah"); + lfs_size_t size = strlen("blahblahblahblah"); memcpy(buffer, "blahblahblahblah", size); - lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT); + 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[0], buffer, size); + err = lfs_file_write(&lfs, &file, buffer, size); if (err < 0) { break; } @@ -218,28 +221,28 @@ tests/test.py << TEST count += 1; } err => LFS_ERR_NOSPC; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_remove(&lfs, "exhaustion") => 0; lfs_remove(&lfs, "exhaustiondir") => 0; // see if dir fits with max file size - lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT); + lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT); for (int i = 0; i < count; i++) { - lfs_file_write(&lfs, &file[0], buffer, size) => size; + lfs_file_write(&lfs, &file, buffer, size) => size; } - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_mkdir(&lfs, "exhaustiondir") => 0; lfs_remove(&lfs, "exhaustiondir") => 0; lfs_remove(&lfs, "exhaustion") => 0; // see if dir fits with > max file size - lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT); + lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT); for (int i = 0; i < count+1; i++) { - lfs_file_write(&lfs, &file[0], buffer, size) => size; + lfs_file_write(&lfs, &file, buffer, size) => size; } - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_mkdir(&lfs, "exhaustiondir") => LFS_ERR_NOSPC; @@ -248,22 +251,22 @@ tests/test.py << TEST TEST echo "--- Chained dir exhaustion test ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; // find out max file size lfs_mkdir(&lfs, "exhaustiondir") => 0; for (int i = 0; i < 10; i++) { - sprintf((char*)buffer, "dirwithanexhaustivelylongnameforpadding%d", i); - lfs_mkdir(&lfs, (char*)buffer) => 0; + sprintf(path, "dirwithanexhaustivelylongnameforpadding%d", i); + lfs_mkdir(&lfs, path) => 0; } - size = strlen("blahblahblahblah"); + lfs_size_t size = strlen("blahblahblahblah"); memcpy(buffer, "blahblahblahblah", size); - lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT); + 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[0], buffer, size); + err = lfs_file_write(&lfs, &file, buffer, size); if (err < 0) { break; } @@ -271,25 +274,25 @@ tests/test.py << TEST count += 1; } err => LFS_ERR_NOSPC; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_remove(&lfs, "exhaustion") => 0; lfs_remove(&lfs, "exhaustiondir") => 0; for (int i = 0; i < 10; i++) { - sprintf((char*)buffer, "dirwithanexhaustivelylongnameforpadding%d", i); - lfs_remove(&lfs, (char*)buffer) => 0; + sprintf(path, "dirwithanexhaustivelylongnameforpadding%d", i); + lfs_remove(&lfs, path) => 0; } // see that chained dir fails - lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT); + lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT); for (int i = 0; i < count+1; i++) { - lfs_file_write(&lfs, &file[0], buffer, size) => size; + lfs_file_write(&lfs, &file, buffer, size) => size; } - lfs_file_sync(&lfs, &file[0]) => 0; + lfs_file_sync(&lfs, &file) => 0; for (int i = 0; i < 10; i++) { - sprintf((char*)buffer, "dirwithanexhaustivelylongnameforpadding%d", i); - lfs_mkdir(&lfs, (char*)buffer) => 0; + sprintf(path, "dirwithanexhaustivelylongnameforpadding%d", i); + lfs_mkdir(&lfs, path) => 0; } lfs_mkdir(&lfs, "exhaustiondir") => LFS_ERR_NOSPC; @@ -301,45 +304,44 @@ tests/test.py << TEST break; } - lfs_ssize_t filesize = lfs_file_size(&lfs, &file[0]); + lfs_ssize_t filesize = lfs_file_size(&lfs, &file); filesize > 0 => true; - lfs_file_truncate(&lfs, &file[0], filesize - size) => 0; - lfs_file_sync(&lfs, &file[0]) => 0; + lfs_file_truncate(&lfs, &file, filesize - size) => 0; + lfs_file_sync(&lfs, &file) => 0; } err => 0; lfs_mkdir(&lfs, "exhaustiondir2") => LFS_ERR_NOSPC; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Split dir test ---" -rm -rf blocks -tests/test.py << TEST +scripts/test.py << TEST lfs_format(&lfs, &cfg) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; // create one block hole for half a directory - lfs_file_open(&lfs, &file[0], "bump", LFS_O_WRONLY | LFS_O_CREAT) => 0; + lfs_file_open(&lfs, &file, "bump", LFS_O_WRONLY | LFS_O_CREAT) => 0; for (lfs_size_t i = 0; i < cfg.block_size; i += 2) { memcpy(&buffer[i], "hi", 2); } - lfs_file_write(&lfs, &file[0], buffer, cfg.block_size) => cfg.block_size; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_write(&lfs, &file, buffer, cfg.block_size) => cfg.block_size; + lfs_file_close(&lfs, &file) => 0; - lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT); - size = strlen("blahblahblahblah"); + lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT); + lfs_size_t size = strlen("blahblahblahblah"); memcpy(buffer, "blahblahblahblah", size); for (lfs_size_t i = 0; i < (cfg.block_count-4)*(cfg.block_size-8); i += size) { - lfs_file_write(&lfs, &file[0], buffer, size) => size; + lfs_file_write(&lfs, &file, buffer, size) => size; } - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; // remount to force reset of lookahead lfs_unmount(&lfs) => 0; @@ -349,137 +351,134 @@ tests/test.py << TEST lfs_remove(&lfs, "bump") => 0; lfs_mkdir(&lfs, "splitdir") => 0; - lfs_file_open(&lfs, &file[0], "splitdir/bump", + lfs_file_open(&lfs, &file, "splitdir/bump", LFS_O_WRONLY | LFS_O_CREAT) => 0; for (lfs_size_t i = 0; i < cfg.block_size; i += 2) { memcpy(&buffer[i], "hi", 2); } - lfs_file_write(&lfs, &file[0], buffer, 2*cfg.block_size) => LFS_ERR_NOSPC; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_write(&lfs, &file, buffer, 2*cfg.block_size) => LFS_ERR_NOSPC; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Outdated lookahead test ---" -rm -rf blocks -tests/test.py << TEST +scripts/test.py << TEST lfs_format(&lfs, &cfg) => 0; lfs_mount(&lfs, &cfg) => 0; // fill completely with two files - lfs_file_open(&lfs, &file[0], "exhaustion1", + lfs_file_open(&lfs, &file, "exhaustion1", LFS_O_WRONLY | LFS_O_CREAT) => 0; - size = strlen("blahblahblahblah"); + lfs_size_t size = strlen("blahblahblahblah"); memcpy(buffer, "blahblahblahblah", size); for (lfs_size_t i = 0; i < ((cfg.block_count-2)/2)*(cfg.block_size-8); i += size) { - lfs_file_write(&lfs, &file[0], buffer, size) => size; + lfs_file_write(&lfs, &file, buffer, size) => size; } - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; - lfs_file_open(&lfs, &file[0], "exhaustion2", + lfs_file_open(&lfs, &file, "exhaustion2", LFS_O_WRONLY | LFS_O_CREAT) => 0; size = strlen("blahblahblahblah"); memcpy(buffer, "blahblahblahblah", size); for (lfs_size_t i = 0; i < ((cfg.block_count-2+1)/2)*(cfg.block_size-8); i += size) { - lfs_file_write(&lfs, &file[0], buffer, size) => size; + lfs_file_write(&lfs, &file, buffer, size) => size; } - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; // remount to force reset of lookahead lfs_unmount(&lfs) => 0; lfs_mount(&lfs, &cfg) => 0; // rewrite one file - lfs_file_open(&lfs, &file[0], "exhaustion1", + lfs_file_open(&lfs, &file, "exhaustion1", LFS_O_WRONLY | LFS_O_TRUNC) => 0; - lfs_file_sync(&lfs, &file[0]) => 0; + lfs_file_sync(&lfs, &file) => 0; size = strlen("blahblahblahblah"); memcpy(buffer, "blahblahblahblah", size); for (lfs_size_t i = 0; i < ((cfg.block_count-2)/2)*(cfg.block_size-8); i += size) { - lfs_file_write(&lfs, &file[0], buffer, size) => size; + lfs_file_write(&lfs, &file, buffer, size) => size; } - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; // rewrite second file, this requires lookahead does not // use old population - lfs_file_open(&lfs, &file[0], "exhaustion2", + lfs_file_open(&lfs, &file, "exhaustion2", LFS_O_WRONLY | LFS_O_TRUNC) => 0; - lfs_file_sync(&lfs, &file[0]) => 0; + lfs_file_sync(&lfs, &file) => 0; size = strlen("blahblahblahblah"); memcpy(buffer, "blahblahblahblah", size); for (lfs_size_t i = 0; i < ((cfg.block_count-2+1)/2)*(cfg.block_size-8); i += size) { - lfs_file_write(&lfs, &file[0], buffer, size) => size; + lfs_file_write(&lfs, &file, buffer, size) => size; } - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; TEST echo "--- Outdated lookahead and split dir test ---" -rm -rf blocks -tests/test.py << TEST +scripts/test.py << TEST lfs_format(&lfs, &cfg) => 0; lfs_mount(&lfs, &cfg) => 0; // fill completely with two files - lfs_file_open(&lfs, &file[0], "exhaustion1", + lfs_file_open(&lfs, &file, "exhaustion1", LFS_O_WRONLY | LFS_O_CREAT) => 0; - size = strlen("blahblahblahblah"); + lfs_size_t size = strlen("blahblahblahblah"); memcpy(buffer, "blahblahblahblah", size); for (lfs_size_t i = 0; i < ((cfg.block_count-2)/2)*(cfg.block_size-8); i += size) { - lfs_file_write(&lfs, &file[0], buffer, size) => size; + lfs_file_write(&lfs, &file, buffer, size) => size; } - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; - lfs_file_open(&lfs, &file[0], "exhaustion2", + lfs_file_open(&lfs, &file, "exhaustion2", LFS_O_WRONLY | LFS_O_CREAT) => 0; size = strlen("blahblahblahblah"); memcpy(buffer, "blahblahblahblah", size); for (lfs_size_t i = 0; i < ((cfg.block_count-2+1)/2)*(cfg.block_size-8); i += size) { - lfs_file_write(&lfs, &file[0], buffer, size) => size; + lfs_file_write(&lfs, &file, buffer, size) => size; } - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; // remount to force reset of lookahead lfs_unmount(&lfs) => 0; lfs_mount(&lfs, &cfg) => 0; // rewrite one file with a hole of one block - lfs_file_open(&lfs, &file[0], "exhaustion1", + lfs_file_open(&lfs, &file, "exhaustion1", LFS_O_WRONLY | LFS_O_TRUNC) => 0; - lfs_file_sync(&lfs, &file[0]) => 0; + lfs_file_sync(&lfs, &file) => 0; size = strlen("blahblahblahblah"); memcpy(buffer, "blahblahblahblah", size); for (lfs_size_t i = 0; i < ((cfg.block_count-2)/2 - 1)*(cfg.block_size-8); i += size) { - lfs_file_write(&lfs, &file[0], buffer, size) => size; + lfs_file_write(&lfs, &file, buffer, size) => size; } - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; // try to allocate a directory, should fail! lfs_mkdir(&lfs, "split") => LFS_ERR_NOSPC; // file should not fail - lfs_file_open(&lfs, &file[0], "notasplit", + lfs_file_open(&lfs, &file, "notasplit", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfs_file_write(&lfs, &file[0], "hi", 2) => 2; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_write(&lfs, &file, "hi", 2) => 2; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST -echo "--- Results ---" -tests/stats.py +scripts/results.py diff --git a/tests/test_attrs.sh b/tests/test_attrs.sh index e4ff4ce..612cae1 100755 --- a/tests/test_attrs.sh +++ b/tests/test_attrs.sh @@ -1,24 +1,27 @@ #!/bin/bash set -eu +export TEST_FILE=$0 +trap 'export TEST_LINE=$LINENO' DEBUG echo "=== Attr tests ===" rm -rf blocks -tests/test.py << TEST +scripts/test.py << TEST lfs_format(&lfs, &cfg) => 0; lfs_mount(&lfs, &cfg) => 0; lfs_mkdir(&lfs, "hello") => 0; - lfs_file_open(&lfs, &file[0], "hello/hello", + lfs_file_open(&lfs, &file, "hello/hello", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfs_file_write(&lfs, &file[0], "hello", strlen("hello")) + lfs_file_write(&lfs, &file, "hello", strlen("hello")) => strlen("hello"); - lfs_file_close(&lfs, &file[0]); + lfs_file_close(&lfs, &file); lfs_unmount(&lfs) => 0; TEST echo "--- Set/get attribute ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; + memset(buffer, 0, sizeof(buffer)); lfs_setattr(&lfs, "hello", 'A', "aaaa", 4) => 0; lfs_setattr(&lfs, "hello", 'B', "bbbbbb", 6) => 0; lfs_setattr(&lfs, "hello", 'C', "ccccc", 5) => 0; @@ -69,8 +72,9 @@ tests/test.py << TEST lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; + memset(buffer, 0, sizeof(buffer)); lfs_getattr(&lfs, "hello", 'A', buffer, 4) => 4; lfs_getattr(&lfs, "hello", 'B', buffer+4, 9) => 9; lfs_getattr(&lfs, "hello", 'C', buffer+13, 5) => 5; @@ -78,16 +82,17 @@ tests/test.py << TEST memcmp(buffer+4, "fffffffff", 9) => 0; memcmp(buffer+13, "ccccc", 5) => 0; - lfs_file_open(&lfs, &file[0], "hello/hello", LFS_O_RDONLY) => 0; - lfs_file_read(&lfs, &file[0], buffer, sizeof(buffer)) => strlen("hello"); + lfs_file_open(&lfs, &file, "hello/hello", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, sizeof(buffer)) => strlen("hello"); memcmp(buffer, "hello", strlen("hello")) => 0; - lfs_file_close(&lfs, &file[0]); + lfs_file_close(&lfs, &file); lfs_unmount(&lfs) => 0; TEST echo "--- Set/get root attribute ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; + memset(buffer, 0, sizeof(buffer)); lfs_setattr(&lfs, "/", 'A', "aaaa", 4) => 0; lfs_setattr(&lfs, "/", 'B', "bbbbbb", 6) => 0; lfs_setattr(&lfs, "/", 'C', "ccccc", 5) => 0; @@ -137,8 +142,9 @@ tests/test.py << TEST lfs_getattr(&lfs, "/", 'C', buffer+10, 5) => 5; lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; + memset(buffer, 0, sizeof(buffer)); lfs_getattr(&lfs, "/", 'A', buffer, 4) => 4; lfs_getattr(&lfs, "/", 'B', buffer+4, 9) => 9; lfs_getattr(&lfs, "/", 'C', buffer+13, 5) => 5; @@ -146,16 +152,17 @@ tests/test.py << TEST memcmp(buffer+4, "fffffffff", 9) => 0; memcmp(buffer+13, "ccccc", 5) => 0; - lfs_file_open(&lfs, &file[0], "hello/hello", LFS_O_RDONLY) => 0; - lfs_file_read(&lfs, &file[0], buffer, sizeof(buffer)) => strlen("hello"); + lfs_file_open(&lfs, &file, "hello/hello", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, sizeof(buffer)) => strlen("hello"); memcmp(buffer, "hello", strlen("hello")) => 0; - lfs_file_close(&lfs, &file[0]); + lfs_file_close(&lfs, &file); lfs_unmount(&lfs) => 0; TEST echo "--- Set/get file attribute ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; + memset(buffer, 0, sizeof(buffer)); struct lfs_attr attrs1[] = { {'A', buffer, 4}, {'B', buffer+4, 6}, @@ -163,55 +170,55 @@ tests/test.py << TEST }; struct lfs_file_config cfg1 = {.attrs=attrs1, .attr_count=3}; - lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_WRONLY, &cfg1) => 0; + lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_WRONLY, &cfg1) => 0; memcpy(buffer, "aaaa", 4); memcpy(buffer+4, "bbbbbb", 6); memcpy(buffer+10, "ccccc", 5); - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; memset(buffer, 0, 15); - lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_RDONLY, &cfg1) => 0; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg1) => 0; + lfs_file_close(&lfs, &file) => 0; memcmp(buffer, "aaaa", 4) => 0; memcmp(buffer+4, "bbbbbb", 6) => 0; memcmp(buffer+10, "ccccc", 5) => 0; attrs1[1].size = 0; - lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_WRONLY, &cfg1) => 0; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_WRONLY, &cfg1) => 0; + lfs_file_close(&lfs, &file) => 0; memset(buffer, 0, 15); attrs1[1].size = 6; - lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_RDONLY, &cfg1) => 0; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg1) => 0; + lfs_file_close(&lfs, &file) => 0; memcmp(buffer, "aaaa", 4) => 0; memcmp(buffer+4, "\0\0\0\0\0\0", 6) => 0; memcmp(buffer+10, "ccccc", 5) => 0; attrs1[1].size = 6; - lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_WRONLY, &cfg1) => 0; + lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_WRONLY, &cfg1) => 0; memcpy(buffer+4, "dddddd", 6); - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; memset(buffer, 0, 15); attrs1[1].size = 6; - lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_RDONLY, &cfg1) => 0; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg1) => 0; + lfs_file_close(&lfs, &file) => 0; memcmp(buffer, "aaaa", 4) => 0; memcmp(buffer+4, "dddddd", 6) => 0; memcmp(buffer+10, "ccccc", 5) => 0; attrs1[1].size = 3; - lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_WRONLY, &cfg1) => 0; + lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_WRONLY, &cfg1) => 0; memcpy(buffer+4, "eee", 3); - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; memset(buffer, 0, 15); attrs1[1].size = 6; - lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_RDONLY, &cfg1) => 0; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg1) => 0; + lfs_file_close(&lfs, &file) => 0; memcmp(buffer, "aaaa", 4) => 0; memcmp(buffer+4, "eee\0\0\0", 6) => 0; memcmp(buffer+10, "ccccc", 5) => 0; attrs1[0].size = LFS_ATTR_MAX+1; - lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_WRONLY, &cfg1) + lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_WRONLY, &cfg1) => LFS_ERR_NOSPC; struct lfs_attr attrs2[] = { @@ -220,17 +227,18 @@ tests/test.py << TEST {'C', buffer+13, 5}, }; struct lfs_file_config cfg2 = {.attrs=attrs2, .attr_count=3}; - lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_RDWR, &cfg2) => 0; + lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDWR, &cfg2) => 0; memcpy(buffer+4, "fffffffff", 9); - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; attrs1[0].size = 4; - lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_RDONLY, &cfg1) => 0; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg1) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; + memset(buffer, 0, sizeof(buffer)); struct lfs_attr attrs2[] = { {'A', buffer, 4}, {'B', buffer+4, 9}, @@ -238,22 +246,23 @@ tests/test.py << TEST }; struct lfs_file_config cfg2 = {.attrs=attrs2, .attr_count=3}; - lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_RDONLY, &cfg2) => 0; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg2) => 0; + lfs_file_close(&lfs, &file) => 0; memcmp(buffer, "aaaa", 4) => 0; memcmp(buffer+4, "fffffffff", 9) => 0; memcmp(buffer+13, "ccccc", 5) => 0; - lfs_file_open(&lfs, &file[0], "hello/hello", LFS_O_RDONLY) => 0; - lfs_file_read(&lfs, &file[0], buffer, sizeof(buffer)) => strlen("hello"); + lfs_file_open(&lfs, &file, "hello/hello", LFS_O_RDONLY) => 0; + lfs_file_read(&lfs, &file, buffer, sizeof(buffer)) => strlen("hello"); memcmp(buffer, "hello", strlen("hello")) => 0; - lfs_file_close(&lfs, &file[0]); + lfs_file_close(&lfs, &file); lfs_unmount(&lfs) => 0; TEST echo "--- Deferred file attributes ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; + memset(buffer, 0, sizeof(buffer)); struct lfs_attr attrs1[] = { {'B', "gggg", 4}, {'C', "", 0}, @@ -261,7 +270,7 @@ tests/test.py << TEST }; struct lfs_file_config cfg1 = {.attrs=attrs1, .attr_count=3}; - lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_WRONLY, &cfg1) => 0; + lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_WRONLY, &cfg1) => 0; lfs_getattr(&lfs, "hello/hello", 'B', buffer, 9) => 9; lfs_getattr(&lfs, "hello/hello", 'C', buffer+9, 9) => 5; @@ -270,7 +279,7 @@ tests/test.py << TEST memcmp(buffer+9, "ccccc\0\0\0\0", 9) => 0; memcmp(buffer+18, "\0\0\0\0\0\0\0\0\0", 9) => 0; - lfs_file_sync(&lfs, &file[0]) => 0; + lfs_file_sync(&lfs, &file) => 0; lfs_getattr(&lfs, "hello/hello", 'B', buffer, 9) => 4; lfs_getattr(&lfs, "hello/hello", 'C', buffer+9, 9) => 0; lfs_getattr(&lfs, "hello/hello", 'D', buffer+18, 9) => 4; @@ -278,9 +287,8 @@ tests/test.py << TEST memcmp(buffer+9, "\0\0\0\0\0\0\0\0\0", 9) => 0; memcmp(buffer+18, "hhhh\0\0\0\0\0", 9) => 0; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST -echo "--- Results ---" -tests/stats.py +scripts/results.py diff --git a/tests/test_corrupt.sh b/tests/test_corrupt.sh index 81b0674..3001522 100755 --- a/tests/test_corrupt.sh +++ b/tests/test_corrupt.sh @@ -1,5 +1,7 @@ #!/bin/bash set -eu +export TEST_FILE=$0 +trap 'export TEST_LINE=$LINENO' DEBUG echo "=== Corrupt tests ===" @@ -7,7 +9,7 @@ NAMEMULT=64 FILEMULT=1 lfs_mktree() { -tests/test.py ${1:-} << TEST +scripts/test.py ${1:-} << TEST lfs_format(&lfs, &cfg) => 0; lfs_mount(&lfs, &cfg) => 0; @@ -23,22 +25,22 @@ tests/test.py ${1:-} << TEST buffer[j+$NAMEMULT+1] = '0'+i; } buffer[2*$NAMEMULT+1] = '\0'; - lfs_file_open(&lfs, &file[0], (char*)buffer, + lfs_file_open(&lfs, &file, (char*)buffer, LFS_O_WRONLY | LFS_O_CREAT) => 0; - size = $NAMEMULT; + lfs_size_t size = $NAMEMULT; for (int j = 0; j < i*$FILEMULT; j++) { - lfs_file_write(&lfs, &file[0], buffer, size) => size; + lfs_file_write(&lfs, &file, buffer, size) => size; } - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; } lfs_unmount(&lfs) => 0; TEST } lfs_chktree() { -tests/test.py ${1:-} << TEST +scripts/test.py ${1:-} << TEST lfs_mount(&lfs, &cfg) => 0; for (int i = 1; i < 10; i++) { for (int j = 0; j < $NAMEMULT; j++) { @@ -53,15 +55,16 @@ tests/test.py ${1:-} << TEST buffer[j+$NAMEMULT+1] = '0'+i; } buffer[2*$NAMEMULT+1] = '\0'; - lfs_file_open(&lfs, &file[0], (char*)buffer, LFS_O_RDONLY) => 0; + lfs_file_open(&lfs, &file, (char*)buffer, LFS_O_RDONLY) => 0; - size = $NAMEMULT; + lfs_size_t size = $NAMEMULT; for (int j = 0; j < i*$FILEMULT; j++) { - lfs_file_read(&lfs, &file[0], rbuffer, size) => size; + uint8_t rbuffer[1024]; + lfs_file_read(&lfs, &file, rbuffer, size) => size; memcmp(buffer, rbuffer, size) => 0; } - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; } lfs_unmount(&lfs) => 0; TEST @@ -114,5 +117,4 @@ done lfs_mktree lfs_chktree -echo "--- Results ---" -tests/stats.py +scripts/results.py diff --git a/tests/test_dirs.sh b/tests/test_dirs.sh index 5f2020f..0125bfd 100755 --- a/tests/test_dirs.sh +++ b/tests/test_dirs.sh @@ -1,188 +1,191 @@ #!/bin/bash set -eu +export TEST_FILE=$0 +trap 'export TEST_LINE=$LINENO' DEBUG + +echo "=== Directory tests ===" LARGESIZE=128 -echo "=== Directory tests ===" rm -rf blocks -tests/test.py << TEST +scripts/test.py << TEST lfs_format(&lfs, &cfg) => 0; TEST echo "--- Root directory ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "/") => 0; - lfs_dir_close(&lfs, &dir[0]) => 0; + lfs_dir_open(&lfs, &dir, "/") => 0; + lfs_dir_close(&lfs, &dir) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Directory creation ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_mkdir(&lfs, "potato") => 0; lfs_unmount(&lfs) => 0; TEST echo "--- File creation ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file[0], "burito", LFS_O_CREAT | LFS_O_WRONLY) => 0; - lfs_file_close(&lfs, &file[0]) => 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 ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "/") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "burito") => 0; info.type => LFS_TYPE_REG; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "potato") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 0; - lfs_dir_close(&lfs, &dir[0]) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Directory failures ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_mkdir(&lfs, "potato") => LFS_ERR_EXIST; - lfs_dir_open(&lfs, &dir[0], "tomato") => LFS_ERR_NOENT; - lfs_dir_open(&lfs, &dir[0], "burito") => LFS_ERR_NOTDIR; - lfs_file_open(&lfs, &file[0], "tomato", LFS_O_RDONLY) => LFS_ERR_NOENT; - lfs_file_open(&lfs, &file[0], "potato", LFS_O_RDONLY) => LFS_ERR_ISDIR; + 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 ---" -tests/test.py << TEST +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 -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "potato") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "baked") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "fried") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "sweet") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 0; - lfs_dir_close(&lfs, &dir[0]) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Multi-block directory ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_mkdir(&lfs, "cactus") => 0; for (int i = 0; i < $LARGESIZE; i++) { - sprintf((char*)buffer, "cactus/test%03d", i); - lfs_mkdir(&lfs, (char*)buffer) => 0; + sprintf(path, "cactus/test%03d", i); + lfs_mkdir(&lfs, path) => 0; } lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "cactus") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; info.type => LFS_TYPE_DIR; for (int i = 0; i < $LARGESIZE; i++) { - sprintf((char*)buffer, "test%03d", i); - lfs_dir_read(&lfs, &dir[0], &info) => 1; - strcmp(info.name, (char*)buffer) => 0; + 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[0], &info) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Directory remove ---" -tests/test.py << TEST +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[0], "potato") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 0; - lfs_dir_close(&lfs, &dir[0]) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; lfs_remove(&lfs, "potato") => 0; - lfs_dir_open(&lfs, &dir[0], "/") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "burito") => 0; info.type => LFS_TYPE_REG; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "cactus") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 0; - lfs_dir_close(&lfs, &dir[0]) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "/") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "burito") => 0; info.type => LFS_TYPE_REG; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "cactus") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 0; - lfs_dir_close(&lfs, &dir[0]) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Directory rename ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_mkdir(&lfs, "coldpotato") => 0; lfs_mkdir(&lfs, "coldpotato/baked") => 0; @@ -190,34 +193,34 @@ tests/test.py << TEST lfs_mkdir(&lfs, "coldpotato/fried") => 0; lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_rename(&lfs, "coldpotato", "hotpotato") => 0; lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "hotpotato") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "baked") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "fried") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "sweet") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 0; - lfs_dir_close(&lfs, &dir[0]) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_mkdir(&lfs, "warmpotato") => 0; lfs_mkdir(&lfs, "warmpotato/mushy") => 0; @@ -228,29 +231,29 @@ tests/test.py << TEST lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "warmpotato") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "baked") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "fried") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "sweet") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 0; - lfs_dir_close(&lfs, &dir[0]) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_mkdir(&lfs, "coldpotato") => 0; lfs_rename(&lfs, "warmpotato/baked", "coldpotato/baked") => 0; @@ -260,225 +263,227 @@ tests/test.py << TEST lfs_remove(&lfs, "warmpotato") => 0; lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "coldpotato") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "baked") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "fried") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "sweet") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 0; - lfs_dir_close(&lfs, &dir[0]) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Recursive remove ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_remove(&lfs, "coldpotato") => LFS_ERR_NOTEMPTY; - lfs_dir_open(&lfs, &dir[0], "coldpotato") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info); + int err = lfs_dir_read(&lfs, &dir, &info); err >= 0 => 1; if (err == 0) { break; } - strcpy((char*)buffer, "coldpotato/"); - strcat((char*)buffer, info.name); - lfs_remove(&lfs, (char*)buffer) => 0; + strcpy(path, "coldpotato/"); + strcat(path, info.name); + lfs_remove(&lfs, path) => 0; } lfs_remove(&lfs, "coldpotato") => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "/") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "burito") => 0; info.type => LFS_TYPE_REG; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "cactus") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 0; - lfs_dir_close(&lfs, &dir[0]) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Multi-block rename ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; for (int i = 0; i < $LARGESIZE; i++) { - sprintf((char*)buffer, "cactus/test%03d", i); - sprintf((char*)wbuffer, "cactus/tedd%03d", i); - lfs_rename(&lfs, (char*)buffer, (char*)wbuffer) => 0; + 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 -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "cactus") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; info.type => LFS_TYPE_DIR; for (int i = 0; i < $LARGESIZE; i++) { - sprintf((char*)buffer, "tedd%03d", i); - lfs_dir_read(&lfs, &dir[0], &info) => 1; - strcmp(info.name, (char*)buffer) => 0; + 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[0], &info) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Multi-block remove ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_remove(&lfs, "cactus") => LFS_ERR_NOTEMPTY; for (int i = 0; i < $LARGESIZE; i++) { - sprintf((char*)buffer, "cactus/tedd%03d", i); - lfs_remove(&lfs, (char*)buffer) => 0; + sprintf(path, "cactus/tedd%03d", i); + lfs_remove(&lfs, path) => 0; } lfs_remove(&lfs, "cactus") => 0; lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "/") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "burito") => 0; info.type => LFS_TYPE_REG; - lfs_dir_read(&lfs, &dir[0], &info) => 0; - lfs_dir_close(&lfs, &dir[0]) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Multi-block directory with files ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_mkdir(&lfs, "prickly-pear") => 0; for (int i = 0; i < $LARGESIZE; i++) { - sprintf((char*)buffer, "prickly-pear/test%03d", i); - lfs_file_open(&lfs, &file[0], (char*)buffer, - LFS_O_WRONLY | LFS_O_CREAT) => 0; - size = 6; - memcpy(wbuffer, "Hello", size); - lfs_file_write(&lfs, &file[0], wbuffer, size) => size; - lfs_file_close(&lfs, &file[0]) => 0; + 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 -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "prickly-pear") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; info.type => LFS_TYPE_DIR; for (int i = 0; i < $LARGESIZE; i++) { - sprintf((char*)buffer, "test%03d", i); - lfs_dir_read(&lfs, &dir[0], &info) => 1; - strcmp(info.name, (char*)buffer) => 0; + 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[0], &info) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Multi-block rename with files ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; for (int i = 0; i < $LARGESIZE; i++) { - sprintf((char*)buffer, "prickly-pear/test%03d", i); - sprintf((char*)wbuffer, "prickly-pear/tedd%03d", i); - lfs_rename(&lfs, (char*)buffer, (char*)wbuffer) => 0; + 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 -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "prickly-pear") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; info.type => LFS_TYPE_DIR; for (int i = 0; i < $LARGESIZE; i++) { - sprintf((char*)buffer, "tedd%03d", i); - lfs_dir_read(&lfs, &dir[0], &info) => 1; - strcmp(info.name, (char*)buffer) => 0; + 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[0], &info) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Multi-block remove with files ---" -tests/test.py << TEST +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((char*)buffer, "prickly-pear/tedd%03d", i); - lfs_remove(&lfs, (char*)buffer) => 0; + sprintf(path, "prickly-pear/tedd%03d", i); + lfs_remove(&lfs, path) => 0; } lfs_remove(&lfs, "prickly-pear") => 0; lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "/") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "burito") => 0; info.type => LFS_TYPE_REG; - lfs_dir_read(&lfs, &dir[0], &info) => 0; - lfs_dir_close(&lfs, &dir[0]) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; lfs_unmount(&lfs) => 0; TEST -echo "--- Results ---" -tests/stats.py +scripts/results.py diff --git a/tests/test_entries.sh b/tests/test_entries.sh index 4728b7f..5075faf 100755 --- a/tests/test_entries.sh +++ b/tests/test_entries.sh @@ -1,19 +1,22 @@ #!/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 -echo "=== Entry tests ===" rm -rf blocks function read_file { cat << TEST size = $2; - lfs_file_open(&lfs, &file[0], "$1", LFS_O_RDONLY) => 0; - lfs_file_read(&lfs, &file[0], rbuffer, size) => size; + 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]) => 0; + lfs_file_close(&lfs, &file) => 0; TEST } @@ -21,18 +24,22 @@ function write_file { cat << TEST size = $2; - lfs_file_open(&lfs, &file[0], "$1", + 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[0], wbuffer, size) => size; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_close(&lfs, &file) => 0; TEST } echo "--- Entry grow test ---" -tests/test.py << 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) @@ -50,9 +57,13 @@ tests/test.py << TEST TEST echo "--- Entry shrink test ---" -tests/test.py << 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) @@ -70,9 +81,13 @@ tests/test.py << TEST TEST echo "--- Entry spill test ---" -tests/test.py << 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) @@ -87,9 +102,13 @@ tests/test.py << TEST TEST echo "--- Entry push spill test ---" -tests/test.py << 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) @@ -107,9 +126,13 @@ tests/test.py << TEST TEST echo "--- Entry push spill two test ---" -tests/test.py << 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) @@ -129,9 +152,13 @@ tests/test.py << TEST TEST echo "--- Entry drop test ---" -tests/test.py << 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) @@ -159,63 +186,66 @@ tests/test.py << TEST TEST echo "--- Create too big ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_format(&lfs, &cfg) => 0; lfs_mount(&lfs, &cfg) => 0; - memset(buffer, 'm', 200); - buffer[200] = '\0'; + memset(path, 'm', 200); + path[200] = '\0'; - size = 400; - lfs_file_open(&lfs, &file[0], (char*)buffer, + 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[0], wbuffer, size) => size; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_close(&lfs, &file) => 0; size = 400; - lfs_file_open(&lfs, &file[0], (char*)buffer, LFS_O_RDONLY) => 0; - lfs_file_read(&lfs, &file[0], rbuffer, size) => size; + 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]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Resize too big ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_format(&lfs, &cfg) => 0; lfs_mount(&lfs, &cfg) => 0; - memset(buffer, 'm', 200); - buffer[200] = '\0'; + memset(path, 'm', 200); + path[200] = '\0'; - size = 40; - lfs_file_open(&lfs, &file[0], (char*)buffer, + 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[0], wbuffer, size) => size; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_close(&lfs, &file) => 0; size = 40; - lfs_file_open(&lfs, &file[0], (char*)buffer, LFS_O_RDONLY) => 0; - lfs_file_read(&lfs, &file[0], rbuffer, size) => size; + 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]) => 0; + lfs_file_close(&lfs, &file) => 0; size = 400; - lfs_file_open(&lfs, &file[0], (char*)buffer, + 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[0], wbuffer, size) => size; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_close(&lfs, &file) => 0; size = 400; - lfs_file_open(&lfs, &file[0], (char*)buffer, LFS_O_RDONLY) => 0; - lfs_file_read(&lfs, &file[0], rbuffer, size) => size; + 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]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST -echo "--- Results ---" -tests/stats.py +scripts/results.py diff --git a/tests/test_files.sh b/tests/test_files.sh index 950636a..f6535f6 100755 --- a/tests/test_files.sh +++ b/tests/test_files.sh @@ -1,71 +1,76 @@ #!/bin/bash set -eu +export TEST_FILE=$0 +trap 'export TEST_LINE=$LINENO' DEBUG + +echo "=== File tests ===" SMALLSIZE=32 MEDIUMSIZE=8192 LARGESIZE=262144 -echo "=== File tests ===" rm -rf blocks -tests/test.py << TEST +scripts/test.py << TEST lfs_format(&lfs, &cfg) => 0; TEST echo "--- Simple file test ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file[0], "hello", LFS_O_WRONLY | LFS_O_CREAT) => 0; - size = strlen("Hello World!\n"); + 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[0], wbuffer, size) => size; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_close(&lfs, &file) => 0; - lfs_file_open(&lfs, &file[0], "hello", LFS_O_RDONLY) => 0; + lfs_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0; size = strlen("Hello World!\n"); - lfs_file_read(&lfs, &file[0], rbuffer, size) => size; + uint8_t rbuffer[1024]; + lfs_file_read(&lfs, &file, rbuffer, size) => size; memcmp(rbuffer, wbuffer, size) => 0; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST w_test() { -tests/test.py ${4:-} << TEST - size = $1; +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[0], "$2", + 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[0], buffer, chunk) => chunk; + lfs_file_write(&lfs, &file, buffer, chunk) => chunk; } - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST } r_test() { -tests/test.py << TEST - size = $1; +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[0], "$2", ${3:-LFS_O_RDONLY}) => 0; + 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[0], buffer, chunk) => chunk; + 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]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST } @@ -105,113 +110,112 @@ r_test $LARGESIZE largeavacado r_test 0 noavacado echo "--- Dir check ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "/") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; - lfs_dir_read(&lfs, &dir[0], &info) => 1; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + 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[0], &info) => 1; + 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[0], &info) => 1; + 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[0], &info) => 1; + 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[0], &info) => 0; - lfs_dir_close(&lfs, &dir[0]) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Many files test ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_format(&lfs, &cfg) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST // Create 300 files of 7 bytes lfs_mount(&lfs, &cfg) => 0; for (unsigned i = 0; i < 300; i++) { - snprintf((char*)buffer, sizeof(buffer), "file_%03d", i); - lfs_file_open(&lfs, &file[0], (char*)buffer, + sprintf(path, "file_%03d", i); + lfs_file_open(&lfs, &file, path, LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0; - size = 7; + 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[0], wbuffer, size) => size; - lfs_file_rewind(&lfs, &file[0]) => 0; - lfs_file_read(&lfs, &file[0], rbuffer, size) => size; + 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]) => 0; + lfs_file_close(&lfs, &file) => 0; } lfs_unmount(&lfs) => 0; TEST echo "--- Many files with flush test ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_format(&lfs, &cfg) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST // Create 300 files of 7 bytes lfs_mount(&lfs, &cfg) => 0; for (unsigned i = 0; i < 300; i++) { - snprintf((char*)buffer, sizeof(buffer), "file_%03d", i); - lfs_file_open(&lfs, &file[0], (char*)buffer, + sprintf(path, "file_%03d", i); + lfs_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - size = 7; + 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[0], wbuffer, size) => size; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_close(&lfs, &file) => 0; - snprintf((char*)buffer, sizeof(buffer), "file_%03d", i); - lfs_file_open(&lfs, &file[0], (char*)buffer, LFS_O_RDONLY) => 0; - size = 7; - snprintf((char*)wbuffer, size, "Hi %03d", i); - lfs_file_read(&lfs, &file[0], rbuffer, size) => size; + 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]) => 0; + lfs_file_close(&lfs, &file) => 0; } lfs_unmount(&lfs) => 0; TEST echo "--- Many files with power cycle test ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_format(&lfs, &cfg) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST // Create 300 files of 7 bytes lfs_mount(&lfs, &cfg) => 0; for (unsigned i = 0; i < 300; i++) { - snprintf((char*)buffer, sizeof(buffer), "file_%03d", i); - lfs_file_open(&lfs, &file[0], (char*)buffer, + sprintf(path, "file_%03d", i); + lfs_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0; - size = 7; + 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[0], wbuffer, size) => size; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_write(&lfs, &file, wbuffer, size) => size; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; lfs_mount(&lfs, &cfg) => 0; - snprintf((char*)buffer, sizeof(buffer), "file_%03d", i); - lfs_file_open(&lfs, &file[0], (char*)buffer, LFS_O_RDONLY) => 0; - size = 7; - snprintf((char*)wbuffer, size, "Hi %03d", i); - lfs_file_read(&lfs, &file[0], rbuffer, size) => size; + 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]) => 0; + lfs_file_close(&lfs, &file) => 0; } lfs_unmount(&lfs) => 0; TEST -echo "--- Results ---" -tests/stats.py +scripts/results.py diff --git a/tests/test_format.sh b/tests/test_format.sh index 5a11535..f0972bd 100755 --- a/tests/test_format.sh +++ b/tests/test_format.sh @@ -1,16 +1,18 @@ #!/bin/bash set -eu +export TEST_FILE=$0 +trap 'export TEST_LINE=$LINENO' DEBUG echo "=== Formatting tests ===" rm -rf blocks echo "--- Basic formatting ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_format(&lfs, &cfg) => 0; TEST echo "--- Basic mounting ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_format(&lfs, &cfg) => 0; lfs_mount(&lfs, &cfg) => 0; @@ -20,18 +22,18 @@ TEST echo "--- Invalid superblocks ---" ln -f -s /dev/zero blocks/0 ln -f -s /dev/zero blocks/1 -tests/test.py << TEST +scripts/test.py << TEST lfs_format(&lfs, &cfg) => LFS_ERR_NOSPC; TEST rm blocks/0 blocks/1 echo "--- Invalid mount ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => LFS_ERR_CORRUPT; TEST echo "--- Expanding superblock ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_format(&lfs, &cfg) => 0; lfs_mount(&lfs, &cfg) => 0; for (int i = 0; i < 100; i++) { @@ -40,11 +42,10 @@ tests/test.py << TEST } lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_mkdir(&lfs, "dummy") => 0; lfs_unmount(&lfs) => 0; TEST -echo "--- Results ---" -tests/stats.py +scripts/results.py diff --git a/tests/test_interspersed.sh b/tests/test_interspersed.sh index 52e24bc..84c5dd8 100755 --- a/tests/test_interspersed.sh +++ b/tests/test_interspersed.sh @@ -1,89 +1,93 @@ #!/bin/bash set -eu +export TEST_FILE=$0 +trap 'export TEST_LINE=$LINENO' DEBUG echo "=== Interspersed tests ===" rm -rf blocks -tests/test.py << TEST +scripts/test.py << TEST lfs_format(&lfs, &cfg) => 0; TEST echo "--- Interspersed file test ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file[0], "a", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfs_file_open(&lfs, &file[1], "b", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfs_file_open(&lfs, &file[2], "c", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfs_file_open(&lfs, &file[3], "d", LFS_O_WRONLY | LFS_O_CREAT) => 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, &file[0], (const void*)"a", 1) => 1; - lfs_file_write(&lfs, &file[1], (const void*)"b", 1) => 1; - lfs_file_write(&lfs, &file[2], (const void*)"c", 1) => 1; - lfs_file_write(&lfs, &file[3], (const void*)"d", 1) => 1; + 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, &file[0]); - lfs_file_close(&lfs, &file[1]); - lfs_file_close(&lfs, &file[2]); - lfs_file_close(&lfs, &file[3]); + 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], "/") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + 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[0], &info) => 1; + 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[0], &info) => 1; + 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[0], &info) => 0; - lfs_dir_close(&lfs, &dir[0]) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; - lfs_file_open(&lfs, &file[0], "a", LFS_O_RDONLY) => 0; - lfs_file_open(&lfs, &file[1], "b", LFS_O_RDONLY) => 0; - lfs_file_open(&lfs, &file[2], "c", LFS_O_RDONLY) => 0; - lfs_file_open(&lfs, &file[3], "d", LFS_O_RDONLY) => 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, &file[0], buffer, 1) => 1; + lfs_file_read(&lfs, &files[0], buffer, 1) => 1; buffer[0] => 'a'; - lfs_file_read(&lfs, &file[1], buffer, 1) => 1; + lfs_file_read(&lfs, &files[1], buffer, 1) => 1; buffer[0] => 'b'; - lfs_file_read(&lfs, &file[2], buffer, 1) => 1; + lfs_file_read(&lfs, &files[2], buffer, 1) => 1; buffer[0] => 'c'; - lfs_file_read(&lfs, &file[3], buffer, 1) => 1; + lfs_file_read(&lfs, &files[3], buffer, 1) => 1; buffer[0] => 'd'; } - lfs_file_close(&lfs, &file[0]); - lfs_file_close(&lfs, &file[1]); - lfs_file_close(&lfs, &file[2]); - lfs_file_close(&lfs, &file[3]); + 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 ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file[0], "e", LFS_O_WRONLY | LFS_O_CREAT) => 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, &file[0], (const void*)"e", 1) => 1; + lfs_file_write(&lfs, &files[0], (const void*)"e", 1) => 1; } lfs_remove(&lfs, "a") => 0; @@ -92,95 +96,95 @@ tests/test.py << TEST lfs_remove(&lfs, "d") => 0; for (int i = 0; i < 5; i++) { - lfs_file_write(&lfs, &file[0], (const void*)"e", 1) => 1; + lfs_file_write(&lfs, &files[0], (const void*)"e", 1) => 1; } - lfs_file_close(&lfs, &file[0]); + lfs_file_close(&lfs, &files[0]); - lfs_dir_open(&lfs, &dir[0], "/") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 0; - lfs_dir_close(&lfs, &dir[0]) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; - lfs_file_open(&lfs, &file[0], "e", LFS_O_RDONLY) => 0; + lfs_file_open(&lfs, &files[0], "e", LFS_O_RDONLY) => 0; for (int i = 0; i < 10; i++) { - lfs_file_read(&lfs, &file[0], buffer, 1) => 1; + lfs_file_read(&lfs, &files[0], buffer, 1) => 1; buffer[0] => 'e'; } - lfs_file_close(&lfs, &file[0]); + lfs_file_close(&lfs, &files[0]); lfs_unmount(&lfs) => 0; TEST echo "--- Remove inconveniently test ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file[0], "e", LFS_O_WRONLY | LFS_O_TRUNC) => 0; - lfs_file_open(&lfs, &file[1], "f", LFS_O_WRONLY | LFS_O_CREAT) => 0; - lfs_file_open(&lfs, &file[2], "g", LFS_O_WRONLY | LFS_O_CREAT) => 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, &file[0], (const void*)"e", 1) => 1; - lfs_file_write(&lfs, &file[1], (const void*)"f", 1) => 1; - lfs_file_write(&lfs, &file[2], (const void*)"g", 1) => 1; + 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, &file[0], (const void*)"e", 1) => 1; - lfs_file_write(&lfs, &file[1], (const void*)"f", 1) => 1; - lfs_file_write(&lfs, &file[2], (const void*)"g", 1) => 1; + 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, &file[0]); - lfs_file_close(&lfs, &file[1]); - lfs_file_close(&lfs, &file[2]); + lfs_file_close(&lfs, &files[0]); + lfs_file_close(&lfs, &files[1]); + lfs_file_close(&lfs, &files[2]); - lfs_dir_open(&lfs, &dir[0], "/") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; info.type => LFS_TYPE_DIR; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + 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[0], &info) => 0; - lfs_dir_close(&lfs, &dir[0]) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; - lfs_file_open(&lfs, &file[0], "e", LFS_O_RDONLY) => 0; - lfs_file_open(&lfs, &file[1], "g", LFS_O_RDONLY) => 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, &file[0], buffer, 1) => 1; + lfs_file_read(&lfs, &files[0], buffer, 1) => 1; buffer[0] => 'e'; - lfs_file_read(&lfs, &file[1], buffer, 1) => 1; + lfs_file_read(&lfs, &files[1], buffer, 1) => 1; buffer[0] => 'g'; } - lfs_file_close(&lfs, &file[0]); - lfs_file_close(&lfs, &file[1]); + lfs_file_close(&lfs, &files[0]); + lfs_file_close(&lfs, &files[1]); lfs_unmount(&lfs) => 0; TEST -echo "--- Results ---" -tests/stats.py +scripts/results.py diff --git a/tests/test_move.sh b/tests/test_move.sh index 458ca1e..f52ef22 100755 --- a/tests/test_move.sh +++ b/tests/test_move.sh @@ -1,9 +1,11 @@ #!/bin/bash set -eu +export TEST_FILE=$0 +trap 'export TEST_LINE=$LINENO' DEBUG echo "=== Move tests ===" rm -rf blocks -tests/test.py << TEST +scripts/test.py << TEST lfs_format(&lfs, &cfg) => 0; lfs_mount(&lfs, &cfg) => 0; @@ -17,272 +19,272 @@ tests/test.py << TEST lfs_mkdir(&lfs, "a/hi/bonjour") => 0; lfs_mkdir(&lfs, "a/hi/ohayo") => 0; - lfs_file_open(&lfs, &file[0], "a/hello", LFS_O_CREAT | LFS_O_WRONLY) => 0; - lfs_file_write(&lfs, &file[0], "hola\n", 5) => 5; - lfs_file_write(&lfs, &file[0], "bonjour\n", 8) => 8; - lfs_file_write(&lfs, &file[0], "ohayo\n", 6) => 6; - lfs_file_close(&lfs, &file[0]) => 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 ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_rename(&lfs, "a/hello", "b/hello") => 0; lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "a") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_open(&lfs, &dir, "a") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "hi") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 0; - lfs_dir_close(&lfs, &dir[0]) => 0; - lfs_dir_open(&lfs, &dir[0], "b") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "hello") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Move file corrupt source ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_rename(&lfs, "b/hello", "c/hello") => 0; lfs_unmount(&lfs) => 0; TEST -tests/corrupt.py -n 1 -tests/test.py << TEST +scripts/corrupt.py -n 1 +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "b") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_open(&lfs, &dir, "b") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 0; - lfs_dir_close(&lfs, &dir[0]) => 0; - lfs_dir_open(&lfs, &dir[0], "c") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "hello") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Move file corrupt source and dest ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_rename(&lfs, "c/hello", "d/hello") => 0; lfs_unmount(&lfs) => 0; TEST -tests/corrupt.py -n 2 -tests/test.py << TEST +scripts/corrupt.py -n 2 +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "c") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_open(&lfs, &dir, "c") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "hello") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 0; - lfs_dir_close(&lfs, &dir[0]) => 0; - lfs_dir_open(&lfs, &dir[0], "d") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Move file after corrupt ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_rename(&lfs, "c/hello", "d/hello") => 0; lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "c") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_open(&lfs, &dir, "c") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 0; - lfs_dir_close(&lfs, &dir[0]) => 0; - lfs_dir_open(&lfs, &dir[0], "d") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "hello") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Move dir ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_rename(&lfs, "a/hi", "b/hi") => 0; lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "a") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_open(&lfs, &dir, "a") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 0; - lfs_dir_close(&lfs, &dir[0]) => 0; - lfs_dir_open(&lfs, &dir[0], "b") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "hi") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Move dir corrupt source ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_rename(&lfs, "b/hi", "c/hi") => 0; lfs_unmount(&lfs) => 0; TEST -tests/corrupt.py -n 1 -tests/test.py << TEST +scripts/corrupt.py -n 1 +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "b") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_open(&lfs, &dir, "b") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 0; - lfs_dir_close(&lfs, &dir[0]) => 0; - lfs_dir_open(&lfs, &dir[0], "c") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "hi") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Move dir corrupt source and dest ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_rename(&lfs, "c/hi", "d/hi") => 0; lfs_unmount(&lfs) => 0; TEST -tests/corrupt.py -n 2 -tests/test.py << TEST +scripts/corrupt.py -n 2 +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "c") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_open(&lfs, &dir, "c") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "hi") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 0; - lfs_dir_close(&lfs, &dir[0]) => 0; - lfs_dir_open(&lfs, &dir[0], "d") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "hello") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Move dir after corrupt ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_rename(&lfs, "c/hi", "d/hi") => 0; lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "c") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_open(&lfs, &dir, "c") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 0; - lfs_dir_close(&lfs, &dir[0]) => 0; - lfs_dir_open(&lfs, &dir[0], "d") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "hello") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "hi") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Move check ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "a/hi") => LFS_ERR_NOENT; - lfs_dir_open(&lfs, &dir[0], "b/hi") => LFS_ERR_NOENT; - lfs_dir_open(&lfs, &dir[0], "c/hi") => LFS_ERR_NOENT; + 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[0], "d/hi") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_open(&lfs, &dir, "d/hi") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "bonjour") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "hola") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "ohayo") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 0; - lfs_dir_close(&lfs, &dir[0]) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; - lfs_dir_open(&lfs, &dir[0], "a/hello") => LFS_ERR_NOENT; - lfs_dir_open(&lfs, &dir[0], "b/hello") => LFS_ERR_NOENT; - lfs_dir_open(&lfs, &dir[0], "c/hello") => LFS_ERR_NOENT; + 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[0], "d/hello", LFS_O_RDONLY) => 0; - lfs_file_read(&lfs, &file[0], buffer, 5) => 5; + 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[0], buffer, 8) => 8; + lfs_file_read(&lfs, &file, buffer, 8) => 8; memcmp(buffer, "bonjour\n", 8) => 0; - lfs_file_read(&lfs, &file[0], buffer, 6) => 6; + lfs_file_read(&lfs, &file, buffer, 6) => 6; memcmp(buffer, "ohayo\n", 6) => 0; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Move state stealing ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_remove(&lfs, "b") => 0; @@ -290,43 +292,42 @@ tests/test.py << TEST lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "a/hi") => LFS_ERR_NOENT; - lfs_dir_open(&lfs, &dir[0], "b") => LFS_ERR_NOENT; - lfs_dir_open(&lfs, &dir[0], "c") => LFS_ERR_NOENT; + 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[0], "d/hi") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_open(&lfs, &dir, "d/hi") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "bonjour") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "hola") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "ohayo") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 0; - lfs_dir_close(&lfs, &dir[0]) => 0; + lfs_dir_read(&lfs, &dir, &info) => 0; + lfs_dir_close(&lfs, &dir) => 0; - lfs_dir_open(&lfs, &dir[0], "a/hello") => LFS_ERR_NOENT; - lfs_dir_open(&lfs, &dir[0], "b") => LFS_ERR_NOENT; - lfs_dir_open(&lfs, &dir[0], "c") => LFS_ERR_NOENT; + 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[0], "d/hello", LFS_O_RDONLY) => 0; - lfs_file_read(&lfs, &file[0], buffer, 5) => 5; + 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[0], buffer, 8) => 8; + lfs_file_read(&lfs, &file, buffer, 8) => 8; memcmp(buffer, "bonjour\n", 8) => 0; - lfs_file_read(&lfs, &file[0], buffer, 6) => 6; + lfs_file_read(&lfs, &file, buffer, 6) => 6; memcmp(buffer, "ohayo\n", 6) => 0; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST -echo "--- Results ---" -tests/stats.py +scripts/results.py diff --git a/tests/test_orphan.sh b/tests/test_orphan.sh index 9c2cb7b..b0a8493 100755 --- a/tests/test_orphan.sh +++ b/tests/test_orphan.sh @@ -1,14 +1,16 @@ #!/bin/bash set -eu +export TEST_FILE=$0 +trap 'export TEST_LINE=$LINENO' DEBUG echo "=== Orphan tests ===" rm -rf blocks -tests/test.py << TEST +scripts/test.py << TEST lfs_format(&lfs, &cfg) => 0; TEST echo "--- Orphan test ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_mkdir(&lfs, "parent") => 0; lfs_mkdir(&lfs, "parent/orphan") => 0; @@ -17,8 +19,8 @@ tests/test.py << TEST TEST # corrupt most recent commit, this should be the update to the previous # linked-list entry and should orphan the child -tests/corrupt.py -tests/test.py << TEST +scripts/corrupt.py +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_stat(&lfs, "parent/orphan", &info) => LFS_ERR_NOENT; @@ -41,5 +43,4 @@ tests/test.py << TEST lfs_unmount(&lfs) => 0; TEST -echo "--- Results ---" -tests/stats.py +scripts/results.py diff --git a/tests/test_paths.sh b/tests/test_paths.sh index 3cffcfe..f720e39 100755 --- a/tests/test_paths.sh +++ b/tests/test_paths.sh @@ -1,13 +1,15 @@ #!/bin/bash set -eu +export TEST_FILE=$0 +trap 'export TEST_LINE=$LINENO' DEBUG echo "=== Path tests ===" rm -rf blocks -tests/test.py << TEST +scripts/test.py << TEST lfs_format(&lfs, &cfg) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_mkdir(&lfs, "tea") => 0; lfs_mkdir(&lfs, "coffee") => 0; @@ -25,7 +27,7 @@ tests/test.py << TEST TEST echo "--- Root path tests ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_stat(&lfs, "tea/hottea", &info) => 0; strcmp(info.name, "hottea") => 0; @@ -39,7 +41,7 @@ tests/test.py << TEST TEST echo "--- Redundant slash path tests ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_stat(&lfs, "/tea/hottea", &info) => 0; strcmp(info.name, "hottea") => 0; @@ -55,7 +57,7 @@ tests/test.py << TEST TEST echo "--- Dot path tests ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_stat(&lfs, "./tea/hottea", &info) => 0; strcmp(info.name, "hottea") => 0; @@ -73,7 +75,7 @@ tests/test.py << TEST TEST echo "--- Dot dot path tests ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_stat(&lfs, "coffee/../tea/hottea", &info) => 0; strcmp(info.name, "hottea") => 0; @@ -91,7 +93,7 @@ tests/test.py << TEST TEST echo "--- Trailing dot path tests ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_stat(&lfs, "tea/hottea/", &info) => 0; strcmp(info.name, "hottea") => 0; @@ -107,7 +109,7 @@ tests/test.py << TEST TEST echo "--- Root dot dot path tests ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_stat(&lfs, "coffee/../../../../../../tea/hottea", &info) => 0; strcmp(info.name, "hottea") => 0; @@ -119,14 +121,14 @@ tests/test.py << TEST TEST echo "--- Root tests ---" -tests/test.py << TEST +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[0], "/", LFS_O_WRONLY | LFS_O_CREAT) + lfs_file_open(&lfs, &file, "/", LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_ISDIR; // more corner cases @@ -140,7 +142,7 @@ tests/test.py << TEST TEST echo "--- Sketchy path tests ---" -tests/test.py << TEST +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; @@ -148,7 +150,7 @@ tests/test.py << TEST TEST echo "--- Superblock conflict test ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; lfs_mkdir(&lfs, "littlefs") => 0; lfs_remove(&lfs, "littlefs") => 0; @@ -156,46 +158,45 @@ tests/test.py << TEST TEST echo "--- Max path test ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - memset(buffer, 'w', LFS_NAME_MAX+1); - buffer[LFS_NAME_MAX+2] = '\0'; - lfs_mkdir(&lfs, (char*)buffer) => LFS_ERR_NAMETOOLONG; - lfs_file_open(&lfs, &file[0], (char*)buffer, + 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(buffer, "coffee/", strlen("coffee/")); - memset(buffer+strlen("coffee/"), 'w', LFS_NAME_MAX+1); - buffer[strlen("coffee/")+LFS_NAME_MAX+2] = '\0'; - lfs_mkdir(&lfs, (char*)buffer) => LFS_ERR_NAMETOOLONG; - lfs_file_open(&lfs, &file[0], (char*)buffer, + 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 ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - memset(buffer, 'w', LFS_NAME_MAX); - buffer[LFS_NAME_MAX+1] = '\0'; - lfs_mkdir(&lfs, (char*)buffer) => 0; - lfs_remove(&lfs, (char*)buffer) => 0; - lfs_file_open(&lfs, &file[0], (char*)buffer, + memset(path, 'w', LFS_NAME_MAX); + path[LFS_NAME_MAX+1] = '\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]) => 0; - lfs_remove(&lfs, (char*)buffer) => 0; - - memcpy(buffer, "coffee/", strlen("coffee/")); - memset(buffer+strlen("coffee/"), 'w', LFS_NAME_MAX); - buffer[strlen("coffee/")+LFS_NAME_MAX+1] = '\0'; - lfs_mkdir(&lfs, (char*)buffer) => 0; - lfs_remove(&lfs, (char*)buffer) => 0; - lfs_file_open(&lfs, &file[0], (char*)buffer, + 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+1] = '\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]) => 0; - lfs_remove(&lfs, (char*)buffer) => 0; + lfs_file_close(&lfs, &file) => 0; + lfs_remove(&lfs, path) => 0; lfs_unmount(&lfs) => 0; TEST -echo "--- Results ---" -tests/stats.py +scripts/results.py diff --git a/tests/test_seek.sh b/tests/test_seek.sh index 97a6f15..e5696d0 100755 --- a/tests/test_seek.sh +++ b/tests/test_seek.sh @@ -1,429 +1,431 @@ #!/bin/bash set -eu +export TEST_FILE=$0 +trap 'export TEST_LINE=$LINENO' DEBUG + +echo "=== Seek tests ===" SMALLSIZE=4 MEDIUMSIZE=128 LARGESIZE=132 -echo "=== Seek tests ===" rm -rf blocks -tests/test.py << TEST +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((char*)buffer, "hello/kitty%03d", i); - lfs_file_open(&lfs, &file[0], (char*)buffer, + sprintf(path, "hello/kitty%03d", i); + lfs_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0; - size = strlen("kittycatcat"); + lfs_size_t size = strlen("kittycatcat"); memcpy(buffer, "kittycatcat", size); for (int j = 0; j < $LARGESIZE; j++) { - lfs_file_write(&lfs, &file[0], buffer, size); + lfs_file_write(&lfs, &file, buffer, size); } - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; } lfs_unmount(&lfs) => 0; TEST echo "--- Simple dir seek ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "hello") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_open(&lfs, &dir, "hello") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; lfs_soff_t pos; int i; for (i = 0; i < $SMALLSIZE; i++) { - sprintf((char*)buffer, "kitty%03d", i); - lfs_dir_read(&lfs, &dir[0], &info) => 1; - strcmp(info.name, (char*)buffer) => 0; - pos = lfs_dir_tell(&lfs, &dir[0]); + 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[0], pos) => 0; - sprintf((char*)buffer, "kitty%03d", i); - lfs_dir_read(&lfs, &dir[0], &info) => 1; - strcmp(info.name, (char*)buffer) => 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_rewind(&lfs, &dir[0]) => 0; - sprintf((char*)buffer, "kitty%03d", 0); - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; - strcmp(info.name, (char*)buffer) => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + strcmp(info.name, path) => 0; - lfs_dir_seek(&lfs, &dir[0], pos) => 0; - sprintf((char*)buffer, "kitty%03d", i); - lfs_dir_read(&lfs, &dir[0], &info) => 1; - strcmp(info.name, (char*)buffer) => 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]) => 0; + lfs_dir_close(&lfs, &dir) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Large dir seek ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_dir_open(&lfs, &dir[0], "hello") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_open(&lfs, &dir, "hello") => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, ".") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; lfs_soff_t pos; int i; for (i = 0; i < $MEDIUMSIZE; i++) { - sprintf((char*)buffer, "kitty%03d", i); - lfs_dir_read(&lfs, &dir[0], &info) => 1; - strcmp(info.name, (char*)buffer) => 0; - pos = lfs_dir_tell(&lfs, &dir[0]); + 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[0], pos) => 0; - sprintf((char*)buffer, "kitty%03d", i); - lfs_dir_read(&lfs, &dir[0], &info) => 1; - strcmp(info.name, (char*)buffer) => 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_rewind(&lfs, &dir[0]) => 0; - sprintf((char*)buffer, "kitty%03d", 0); - lfs_dir_read(&lfs, &dir[0], &info) => 1; + 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[0], &info) => 1; + lfs_dir_read(&lfs, &dir, &info) => 1; strcmp(info.name, "..") => 0; - lfs_dir_read(&lfs, &dir[0], &info) => 1; - strcmp(info.name, (char*)buffer) => 0; + lfs_dir_read(&lfs, &dir, &info) => 1; + strcmp(info.name, path) => 0; - lfs_dir_seek(&lfs, &dir[0], pos) => 0; - sprintf((char*)buffer, "kitty%03d", i); - lfs_dir_read(&lfs, &dir[0], &info) => 1; - strcmp(info.name, (char*)buffer) => 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]) => 0; + lfs_dir_close(&lfs, &dir) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Simple file seek ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file[0], "hello/kitty042", LFS_O_RDONLY) => 0; + lfs_file_open(&lfs, &file, "hello/kitty042", LFS_O_RDONLY) => 0; lfs_soff_t pos; - size = strlen("kittycatcat"); + lfs_size_t size = strlen("kittycatcat"); for (int i = 0; i < $SMALLSIZE; i++) { - lfs_file_read(&lfs, &file[0], buffer, size) => size; + lfs_file_read(&lfs, &file, buffer, size) => size; memcmp(buffer, "kittycatcat", size) => 0; - pos = lfs_file_tell(&lfs, &file[0]); + pos = lfs_file_tell(&lfs, &file); } pos >= 0 => 1; - lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos; - lfs_file_read(&lfs, &file[0], buffer, size) => size; + 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]) => 0; - lfs_file_read(&lfs, &file[0], buffer, size) => size; + 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], 0, LFS_SEEK_CUR) => size; - lfs_file_read(&lfs, &file[0], buffer, size) => size; + 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[0], size, LFS_SEEK_CUR) => 3*size; - lfs_file_read(&lfs, &file[0], buffer, size) => size; + 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[0], pos, LFS_SEEK_SET) => pos; - lfs_file_read(&lfs, &file[0], buffer, size) => size; + 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[0], -size, LFS_SEEK_CUR) => pos; - lfs_file_read(&lfs, &file[0], buffer, size) => size; + 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[0], -size, LFS_SEEK_END) >= 0 => 1; - lfs_file_read(&lfs, &file[0], buffer, size) => size; + 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[0]); - lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_CUR) => size; + size = lfs_file_size(&lfs, &file); + lfs_file_seek(&lfs, &file, 0, LFS_SEEK_CUR) => size; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Large file seek ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file[0], "hello/kitty042", LFS_O_RDONLY) => 0; + lfs_file_open(&lfs, &file, "hello/kitty042", LFS_O_RDONLY) => 0; lfs_soff_t pos; - size = strlen("kittycatcat"); + lfs_size_t size = strlen("kittycatcat"); for (int i = 0; i < $MEDIUMSIZE; i++) { - lfs_file_read(&lfs, &file[0], buffer, size) => size; + lfs_file_read(&lfs, &file, buffer, size) => size; memcmp(buffer, "kittycatcat", size) => 0; - pos = lfs_file_tell(&lfs, &file[0]); + pos = lfs_file_tell(&lfs, &file); } pos >= 0 => 1; - lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos; - lfs_file_read(&lfs, &file[0], buffer, size) => size; + 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]) => 0; - lfs_file_read(&lfs, &file[0], buffer, size) => size; + 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], 0, LFS_SEEK_CUR) => size; - lfs_file_read(&lfs, &file[0], buffer, size) => size; + 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[0], size, LFS_SEEK_CUR) => 3*size; - lfs_file_read(&lfs, &file[0], buffer, size) => size; + 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[0], pos, LFS_SEEK_SET) => pos; - lfs_file_read(&lfs, &file[0], buffer, size) => size; + 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[0], -size, LFS_SEEK_CUR) => pos; - lfs_file_read(&lfs, &file[0], buffer, size) => size; + 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[0], -size, LFS_SEEK_END) >= 0 => 1; - lfs_file_read(&lfs, &file[0], buffer, size) => size; + 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[0]); - lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_CUR) => size; + size = lfs_file_size(&lfs, &file); + lfs_file_seek(&lfs, &file, 0, LFS_SEEK_CUR) => size; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Simple file seek and write ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file[0], "hello/kitty042", LFS_O_RDWR) => 0; + lfs_file_open(&lfs, &file, "hello/kitty042", LFS_O_RDWR) => 0; lfs_soff_t pos; - size = strlen("kittycatcat"); + lfs_size_t size = strlen("kittycatcat"); for (int i = 0; i < $SMALLSIZE; i++) { - lfs_file_read(&lfs, &file[0], buffer, size) => size; + lfs_file_read(&lfs, &file, buffer, size) => size; memcmp(buffer, "kittycatcat", size) => 0; - pos = lfs_file_tell(&lfs, &file[0]); + pos = lfs_file_tell(&lfs, &file); } pos >= 0 => 1; memcpy(buffer, "doggodogdog", size); - lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos; - lfs_file_write(&lfs, &file[0], buffer, size) => size; + lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos; + lfs_file_write(&lfs, &file, buffer, size) => size; - lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos; - lfs_file_read(&lfs, &file[0], 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]) => 0; - lfs_file_read(&lfs, &file[0], buffer, size) => size; + 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], pos, LFS_SEEK_SET) => pos; - lfs_file_read(&lfs, &file[0], 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_seek(&lfs, &file[0], -size, LFS_SEEK_END) >= 0 => 1; - lfs_file_read(&lfs, &file[0], buffer, size) => size; + 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[0]); - lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_CUR) => size; + size = lfs_file_size(&lfs, &file); + lfs_file_seek(&lfs, &file, 0, LFS_SEEK_CUR) => size; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Large file seek and write ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file[0], "hello/kitty042", LFS_O_RDWR) => 0; + lfs_file_open(&lfs, &file, "hello/kitty042", LFS_O_RDWR) => 0; lfs_soff_t pos; - size = strlen("kittycatcat"); + lfs_size_t size = strlen("kittycatcat"); for (int i = 0; i < $MEDIUMSIZE; i++) { - lfs_file_read(&lfs, &file[0], buffer, size) => size; + lfs_file_read(&lfs, &file, buffer, size) => size; if (i != $SMALLSIZE) { memcmp(buffer, "kittycatcat", size) => 0; } - pos = lfs_file_tell(&lfs, &file[0]); + pos = lfs_file_tell(&lfs, &file); } pos >= 0 => 1; memcpy(buffer, "doggodogdog", size); - lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos; - lfs_file_write(&lfs, &file[0], buffer, size) => size; + lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos; + lfs_file_write(&lfs, &file, buffer, size) => size; - lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos; - lfs_file_read(&lfs, &file[0], 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]) => 0; - lfs_file_read(&lfs, &file[0], buffer, size) => size; + 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], pos, LFS_SEEK_SET) => pos; - lfs_file_read(&lfs, &file[0], 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_seek(&lfs, &file[0], -size, LFS_SEEK_END) >= 0 => 1; - lfs_file_read(&lfs, &file[0], buffer, size) => size; + 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[0]); - lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_CUR) => size; + size = lfs_file_size(&lfs, &file); + lfs_file_seek(&lfs, &file, 0, LFS_SEEK_CUR) => size; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Boundary seek and write ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file[0], "hello/kitty042", LFS_O_RDWR) => 0; + lfs_file_open(&lfs, &file, "hello/kitty042", LFS_O_RDWR) => 0; - size = strlen("hedgehoghog"); + 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[0], off, LFS_SEEK_SET) => off; - lfs_file_write(&lfs, &file[0], buffer, size) => size; - lfs_file_seek(&lfs, &file[0], off, LFS_SEEK_SET) => off; - lfs_file_read(&lfs, &file[0], buffer, size) => 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], 0, LFS_SEEK_SET) => 0; - lfs_file_read(&lfs, &file[0], buffer, size) => size; + 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]) => 0; + lfs_file_sync(&lfs, &file) => 0; } - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Out-of-bounds seek ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file[0], "hello/kitty042", LFS_O_RDWR) => 0; + lfs_file_open(&lfs, &file, "hello/kitty042", LFS_O_RDWR) => 0; - size = strlen("kittycatcat"); - lfs_file_size(&lfs, &file[0]) => $LARGESIZE*size; - lfs_file_seek(&lfs, &file[0], ($LARGESIZE+$SMALLSIZE)*size, + 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[0], buffer, size) => 0; + lfs_file_read(&lfs, &file, buffer, size) => 0; memcpy(buffer, "porcupineee", size); - lfs_file_write(&lfs, &file[0], buffer, size) => size; + lfs_file_write(&lfs, &file, buffer, size) => size; - lfs_file_seek(&lfs, &file[0], ($LARGESIZE+$SMALLSIZE)*size, + lfs_file_seek(&lfs, &file, ($LARGESIZE+$SMALLSIZE)*size, LFS_SEEK_SET) => ($LARGESIZE+$SMALLSIZE)*size; - lfs_file_read(&lfs, &file[0], buffer, size) => size; + lfs_file_read(&lfs, &file, buffer, size) => size; memcmp(buffer, "porcupineee", size) => 0; - lfs_file_seek(&lfs, &file[0], $LARGESIZE*size, + lfs_file_seek(&lfs, &file, $LARGESIZE*size, LFS_SEEK_SET) => $LARGESIZE*size; - lfs_file_read(&lfs, &file[0], buffer, size) => 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[0], -(($LARGESIZE+$SMALLSIZE)*size), + lfs_file_seek(&lfs, &file, -(($LARGESIZE+$SMALLSIZE)*size), LFS_SEEK_CUR) => LFS_ERR_INVAL; - lfs_file_tell(&lfs, &file[0]) => ($LARGESIZE+1)*size; + lfs_file_tell(&lfs, &file) => ($LARGESIZE+1)*size; - lfs_file_seek(&lfs, &file[0], -(($LARGESIZE+2*$SMALLSIZE)*size), + lfs_file_seek(&lfs, &file, -(($LARGESIZE+2*$SMALLSIZE)*size), LFS_SEEK_END) => LFS_ERR_INVAL; - lfs_file_tell(&lfs, &file[0]) => ($LARGESIZE+1)*size; + lfs_file_tell(&lfs, &file) => ($LARGESIZE+1)*size; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Inline write and seek ---" for SIZE in $SMALLSIZE $MEDIUMSIZE $LARGESIZE do -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file[0], "hello/tinykitty$SIZE", + 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[0], &buffer[j++ % 26], 1) => 1; - lfs_file_tell(&lfs, &file[0]) => i+1; - lfs_file_size(&lfs, &file[0]) => i+1; + 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], 0, LFS_SEEK_SET) => 0; - lfs_file_tell(&lfs, &file[0]) => 0; - lfs_file_size(&lfs, &file[0]) => $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[0], &c, 1) => 1; + lfs_file_read(&lfs, &file, &c, 1) => 1; c => buffer[k++ % 26]; } - lfs_file_sync(&lfs, &file[0]) => 0; - lfs_file_tell(&lfs, &file[0]) => $SIZE; - lfs_file_size(&lfs, &file[0]) => $SIZE; + lfs_file_sync(&lfs, &file) => 0; + lfs_file_tell(&lfs, &file) => $SIZE; + lfs_file_size(&lfs, &file) => $SIZE; - lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_SET) => 0; + lfs_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0; for (unsigned i = 0; i < $SIZE; i++) { - lfs_file_write(&lfs, &file[0], &buffer[j++ % 26], 1) => 1; - lfs_file_tell(&lfs, &file[0]) => i+1; - lfs_file_size(&lfs, &file[0]) => $SIZE; - lfs_file_sync(&lfs, &file[0]) => 0; - lfs_file_tell(&lfs, &file[0]) => i+1; - lfs_file_size(&lfs, &file[0]) => $SIZE; + 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[0], -1, LFS_SEEK_CUR) => i; - lfs_file_read(&lfs, &file[0], &c, 3) => 3; - lfs_file_tell(&lfs, &file[0]) => i+3; - lfs_file_size(&lfs, &file[0]) => $SIZE; - lfs_file_seek(&lfs, &file[0], i+1, LFS_SEEK_SET) => i+1; - lfs_file_tell(&lfs, &file[0]) => i+1; - lfs_file_size(&lfs, &file[0]) => $SIZE; + 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], 0, LFS_SEEK_SET) => 0; - lfs_file_tell(&lfs, &file[0]) => 0; - lfs_file_size(&lfs, &file[0]) => $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[0], &c, 1) => 1; + lfs_file_read(&lfs, &file, &c, 1) => 1; c => buffer[k++ % 26]; } - lfs_file_sync(&lfs, &file[0]) => 0; - lfs_file_tell(&lfs, &file[0]) => $SIZE; - lfs_file_size(&lfs, &file[0]) => $SIZE; + lfs_file_sync(&lfs, &file) => 0; + lfs_file_tell(&lfs, &file) => $SIZE; + lfs_file_size(&lfs, &file) => $SIZE; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST done -echo "--- Results ---" -tests/stats.py +scripts/results.py diff --git a/tests/test_truncate.sh b/tests/test_truncate.sh index c12fc0d..ee42693 100755 --- a/tests/test_truncate.sh +++ b/tests/test_truncate.sh @@ -1,156 +1,159 @@ #!/bin/bash set -eu +export TEST_FILE=$0 +trap 'export TEST_LINE=$LINENO' DEBUG + +echo "=== Truncate tests ===" SMALLSIZE=32 MEDIUMSIZE=2048 LARGESIZE=8192 -echo "=== Truncate tests ===" rm -rf blocks -tests/test.py << TEST +scripts/test.py << TEST lfs_format(&lfs, &cfg) => 0; TEST echo "--- Simple truncate ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file[0], "baldynoop", + lfs_file_open(&lfs, &file, "baldynoop", LFS_O_WRONLY | LFS_O_CREAT) => 0; strcpy((char*)buffer, "hair"); - size = strlen((char*)buffer); + lfs_size_t size = strlen((char*)buffer); for (lfs_off_t j = 0; j < $LARGESIZE; j += size) { - lfs_file_write(&lfs, &file[0], buffer, size) => size; + lfs_file_write(&lfs, &file, buffer, size) => size; } - lfs_file_size(&lfs, &file[0]) => $LARGESIZE; + lfs_file_size(&lfs, &file) => $LARGESIZE; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file[0], "baldynoop", LFS_O_RDWR) => 0; - lfs_file_size(&lfs, &file[0]) => $LARGESIZE; + lfs_file_open(&lfs, &file, "baldynoop", LFS_O_RDWR) => 0; + lfs_file_size(&lfs, &file) => $LARGESIZE; - lfs_file_truncate(&lfs, &file[0], $MEDIUMSIZE) => 0; - lfs_file_size(&lfs, &file[0]) => $MEDIUMSIZE; + lfs_file_truncate(&lfs, &file, $MEDIUMSIZE) => 0; + lfs_file_size(&lfs, &file) => $MEDIUMSIZE; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file[0], "baldynoop", LFS_O_RDONLY) => 0; - lfs_file_size(&lfs, &file[0]) => $MEDIUMSIZE; + lfs_file_open(&lfs, &file, "baldynoop", LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => $MEDIUMSIZE; - size = strlen("hair"); + lfs_size_t size = strlen("hair"); for (lfs_off_t j = 0; j < $MEDIUMSIZE; j += size) { - lfs_file_read(&lfs, &file[0], buffer, size) => size; + lfs_file_read(&lfs, &file, buffer, size) => size; memcmp(buffer, "hair", size) => 0; } - lfs_file_read(&lfs, &file[0], buffer, size) => 0; + lfs_file_read(&lfs, &file, buffer, size) => 0; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Truncate and read ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file[0], "baldyread", + lfs_file_open(&lfs, &file, "baldyread", LFS_O_WRONLY | LFS_O_CREAT) => 0; strcpy((char*)buffer, "hair"); - size = strlen((char*)buffer); + lfs_size_t size = strlen((char*)buffer); for (lfs_off_t j = 0; j < $LARGESIZE; j += size) { - lfs_file_write(&lfs, &file[0], buffer, size) => size; + lfs_file_write(&lfs, &file, buffer, size) => size; } - lfs_file_size(&lfs, &file[0]) => $LARGESIZE; + lfs_file_size(&lfs, &file) => $LARGESIZE; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file[0], "baldyread", LFS_O_RDWR) => 0; - lfs_file_size(&lfs, &file[0]) => $LARGESIZE; + lfs_file_open(&lfs, &file, "baldyread", LFS_O_RDWR) => 0; + lfs_file_size(&lfs, &file) => $LARGESIZE; - lfs_file_truncate(&lfs, &file[0], $MEDIUMSIZE) => 0; - lfs_file_size(&lfs, &file[0]) => $MEDIUMSIZE; + lfs_file_truncate(&lfs, &file, $MEDIUMSIZE) => 0; + lfs_file_size(&lfs, &file) => $MEDIUMSIZE; - size = strlen("hair"); + lfs_size_t size = strlen("hair"); for (lfs_off_t j = 0; j < $MEDIUMSIZE; j += size) { - lfs_file_read(&lfs, &file[0], buffer, size) => size; + lfs_file_read(&lfs, &file, buffer, size) => size; memcmp(buffer, "hair", size) => 0; } - lfs_file_read(&lfs, &file[0], buffer, size) => 0; + lfs_file_read(&lfs, &file, buffer, size) => 0; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file[0], "baldyread", LFS_O_RDONLY) => 0; - lfs_file_size(&lfs, &file[0]) => $MEDIUMSIZE; + lfs_file_open(&lfs, &file, "baldyread", LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => $MEDIUMSIZE; - size = strlen("hair"); + lfs_size_t size = strlen("hair"); for (lfs_off_t j = 0; j < $MEDIUMSIZE; j += size) { - lfs_file_read(&lfs, &file[0], buffer, size) => size; + lfs_file_read(&lfs, &file, buffer, size) => size; memcmp(buffer, "hair", size) => 0; } - lfs_file_read(&lfs, &file[0], buffer, size) => 0; + lfs_file_read(&lfs, &file, buffer, size) => 0; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST echo "--- Truncate and write ---" -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file[0], "baldywrite", + lfs_file_open(&lfs, &file, "baldywrite", LFS_O_WRONLY | LFS_O_CREAT) => 0; strcpy((char*)buffer, "hair"); - size = strlen((char*)buffer); + lfs_size_t size = strlen((char*)buffer); for (lfs_off_t j = 0; j < $LARGESIZE; j += size) { - lfs_file_write(&lfs, &file[0], buffer, size) => size; + lfs_file_write(&lfs, &file, buffer, size) => size; } - lfs_file_size(&lfs, &file[0]) => $LARGESIZE; + lfs_file_size(&lfs, &file) => $LARGESIZE; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file[0], "baldywrite", LFS_O_RDWR) => 0; - lfs_file_size(&lfs, &file[0]) => $LARGESIZE; + lfs_file_open(&lfs, &file, "baldywrite", LFS_O_RDWR) => 0; + lfs_file_size(&lfs, &file) => $LARGESIZE; - lfs_file_truncate(&lfs, &file[0], $MEDIUMSIZE) => 0; - lfs_file_size(&lfs, &file[0]) => $MEDIUMSIZE; + lfs_file_truncate(&lfs, &file, $MEDIUMSIZE) => 0; + lfs_file_size(&lfs, &file) => $MEDIUMSIZE; strcpy((char*)buffer, "bald"); - size = strlen((char*)buffer); + lfs_size_t size = strlen((char*)buffer); for (lfs_off_t j = 0; j < $MEDIUMSIZE; j += size) { - lfs_file_write(&lfs, &file[0], buffer, size) => size; + lfs_file_write(&lfs, &file, buffer, size) => size; } - lfs_file_size(&lfs, &file[0]) => $MEDIUMSIZE; + lfs_file_size(&lfs, &file) => $MEDIUMSIZE; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST -tests/test.py << TEST +scripts/test.py << TEST lfs_mount(&lfs, &cfg) => 0; - lfs_file_open(&lfs, &file[0], "baldywrite", LFS_O_RDONLY) => 0; - lfs_file_size(&lfs, &file[0]) => $MEDIUMSIZE; + lfs_file_open(&lfs, &file, "baldywrite", LFS_O_RDONLY) => 0; + lfs_file_size(&lfs, &file) => $MEDIUMSIZE; - size = strlen("bald"); + lfs_size_t size = strlen("bald"); for (lfs_off_t j = 0; j < $MEDIUMSIZE; j += size) { - lfs_file_read(&lfs, &file[0], buffer, size) => size; + lfs_file_read(&lfs, &file, buffer, size) => size; memcmp(buffer, "bald", size) => 0; } - lfs_file_read(&lfs, &file[0], buffer, size) => 0; + lfs_file_read(&lfs, &file, buffer, size) => 0; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; lfs_unmount(&lfs) => 0; TEST @@ -160,7 +163,7 @@ STARTSIZES="$1" STARTSEEKS="$2" HOTSIZES="$3" COLDSIZES="$4" -tests/test.py << TEST +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}; @@ -168,31 +171,31 @@ tests/test.py << TEST lfs_mount(&lfs, &cfg) => 0; for (unsigned i = 0; i < sizeof(startsizes)/sizeof(startsizes[0]); i++) { - sprintf((char*)buffer, "hairyhead%d", i); - lfs_file_open(&lfs, &file[0], (const char*)buffer, + 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); + lfs_size_t size = strlen((char*)buffer); for (lfs_off_t j = 0; j < startsizes[i]; j += size) { - lfs_file_write(&lfs, &file[0], buffer, size) => size; + lfs_file_write(&lfs, &file, buffer, size) => size; } - lfs_file_size(&lfs, &file[0]) => startsizes[i]; + lfs_file_size(&lfs, &file) => startsizes[i]; if (startseeks[i] != startsizes[i]) { - lfs_file_seek(&lfs, &file[0], + lfs_file_seek(&lfs, &file, startseeks[i], LFS_SEEK_SET) => startseeks[i]; } - lfs_file_truncate(&lfs, &file[0], hotsizes[i]) => 0; - lfs_file_size(&lfs, &file[0]) => hotsizes[i]; + lfs_file_truncate(&lfs, &file, hotsizes[i]) => 0; + lfs_file_size(&lfs, &file) => hotsizes[i]; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; } lfs_unmount(&lfs) => 0; TEST -tests/test.py << 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}; @@ -200,31 +203,31 @@ tests/test.py << TEST lfs_mount(&lfs, &cfg) => 0; for (unsigned i = 0; i < sizeof(startsizes)/sizeof(startsizes[0]); i++) { - sprintf((char*)buffer, "hairyhead%d", i); - lfs_file_open(&lfs, &file[0], (const char*)buffer, LFS_O_RDWR) => 0; - lfs_file_size(&lfs, &file[0]) => hotsizes[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_size_t size = strlen("hair"); lfs_off_t j = 0; for (; j < startsizes[i] && j < hotsizes[i]; j += size) { - lfs_file_read(&lfs, &file[0], buffer, size) => 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[0], buffer, size) => size; + lfs_file_read(&lfs, &file, buffer, size) => size; memcmp(buffer, "\0\0\0\0", size) => 0; } - lfs_file_truncate(&lfs, &file[0], coldsizes[i]) => 0; - lfs_file_size(&lfs, &file[0]) => coldsizes[i]; + lfs_file_truncate(&lfs, &file, coldsizes[i]) => 0; + lfs_file_size(&lfs, &file) => coldsizes[i]; - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; } lfs_unmount(&lfs) => 0; TEST -tests/test.py << 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}; @@ -232,24 +235,24 @@ tests/test.py << TEST lfs_mount(&lfs, &cfg) => 0; for (unsigned i = 0; i < sizeof(startsizes)/sizeof(startsizes[0]); i++) { - sprintf((char*)buffer, "hairyhead%d", i); - lfs_file_open(&lfs, &file[0], (const char*)buffer, LFS_O_RDONLY) => 0; - lfs_file_size(&lfs, &file[0]) => coldsizes[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_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[0], buffer, size) => 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[0], buffer, size) => size; + lfs_file_read(&lfs, &file, buffer, size) => size; memcmp(buffer, "\0\0\0\0", size) => 0; } - lfs_file_close(&lfs, &file[0]) => 0; + lfs_file_close(&lfs, &file) => 0; } lfs_unmount(&lfs) => 0; @@ -298,5 +301,4 @@ truncate_test \ "2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE" \ "2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE" -echo "--- Results ---" -tests/stats.py +scripts/results.py |