mirror of
https://github.com/eledio-devices/thirdparty-littlefs.git
synced 2025-11-01 00:38:29 +01:00
Compare commits
1 Commits
open-file-
...
dir-read-r
| Author | SHA1 | Date | |
|---|---|---|---|
|
e50a0677c0 |
265
lfs.c
265
lfs.c
@@ -24,14 +24,6 @@ static inline void lfs_cache_zero(lfs_t *lfs, lfs_cache_t *pcache) {
|
||||
pcache->block = LFS_BLOCK_NULL;
|
||||
}
|
||||
|
||||
static inline void lfs_cache_copy(lfs_t *lfs,
|
||||
lfs_cache_t *dcache, const lfs_cache_t *scache) {
|
||||
memcpy(dcache->buffer, scache->buffer, lfs->cfg->cache_size);
|
||||
dcache->block = scache->block;
|
||||
dcache->off = scache->off;
|
||||
dcache->size = scache->size;
|
||||
}
|
||||
|
||||
static int lfs_bd_read(lfs_t *lfs,
|
||||
const lfs_cache_t *pcache, lfs_cache_t *rcache, lfs_size_t hint,
|
||||
lfs_block_t block, lfs_off_t off,
|
||||
@@ -638,6 +630,8 @@ static lfs_stag_t lfs_dir_getslice(lfs_t *lfs, const lfs_mdir_t *dir,
|
||||
return err;
|
||||
}
|
||||
|
||||
memset((uint8_t*)gbuffer + diff, 0, gsize - diff);
|
||||
|
||||
return tag + gdiff;
|
||||
}
|
||||
}
|
||||
@@ -821,12 +815,8 @@ static int lfs_dir_traverse(lfs_t *lfs,
|
||||
return err;
|
||||
}
|
||||
} else if (lfs_tag_type3(tag) == LFS_FROM_USERATTRS) {
|
||||
const struct lfs_attr *a = buffer;
|
||||
for (unsigned i = 0; i < lfs_tag_size(tag); i++) {
|
||||
if (a[i].size > lfs->attr_max) {
|
||||
return LFS_ERR_NOSPC;
|
||||
}
|
||||
|
||||
const struct lfs_attr *a = buffer;
|
||||
int err = cb(data, LFS_MKTAG(LFS_TYPE_USERATTR + a[i].type,
|
||||
lfs_tag_id(tag) + diff, a[i].size), a[i].buffer);
|
||||
if (err) {
|
||||
@@ -1090,7 +1080,7 @@ static int lfs_dir_fetch(lfs_t *lfs,
|
||||
|
||||
static int lfs_dir_getgstate(lfs_t *lfs, const lfs_mdir_t *dir,
|
||||
lfs_gstate_t *gstate) {
|
||||
lfs_gstate_t temp = {0};
|
||||
lfs_gstate_t temp;
|
||||
lfs_stag_t res = lfs_dir_get(lfs, dir, LFS_MKTAG(0x7ff, 0, 0),
|
||||
LFS_MKTAG(LFS_TYPE_MOVESTATE, 0, sizeof(temp)), &temp);
|
||||
if (res < 0 && res != LFS_ERR_NOENT) {
|
||||
@@ -1116,11 +1106,10 @@ static int lfs_dir_getinfo(lfs_t *lfs, lfs_mdir_t *dir,
|
||||
}
|
||||
|
||||
lfs_stag_t tag = lfs_dir_get(lfs, dir, LFS_MKTAG(0x780, 0x3ff, 0),
|
||||
LFS_MKTAG(LFS_TYPE_NAME, id, lfs->name_max), info->name);
|
||||
LFS_MKTAG(LFS_TYPE_NAME, id, lfs->name_max+1), info->name);
|
||||
if (tag < 0) {
|
||||
return (int)tag;
|
||||
}
|
||||
info->name[lfs_tag_size(tag)] = '\0';
|
||||
|
||||
info->type = lfs_tag_type3(tag);
|
||||
|
||||
@@ -1184,11 +1173,6 @@ static lfs_stag_t lfs_dir_find(lfs_t *lfs, lfs_mdir_t *dir,
|
||||
dir->tail[0] = lfs->root[0];
|
||||
dir->tail[1] = lfs->root[1];
|
||||
|
||||
// NULL path == root
|
||||
if (!name) {
|
||||
return tag;
|
||||
}
|
||||
|
||||
while (true) {
|
||||
nextname:
|
||||
// skip slashes
|
||||
@@ -1837,7 +1821,7 @@ relocate:
|
||||
#ifndef LFS_READONLY
|
||||
static int lfs_dir_commit(lfs_t *lfs, lfs_mdir_t *dir,
|
||||
const struct lfs_mattr *attrs, int attrcount) {
|
||||
// check for any open inline files that aren't RAM backed and
|
||||
// check for any inline files that aren't RAM backed and
|
||||
// forcefully evict them, needed for filesystem consistency
|
||||
for (lfs_file_t *f = (lfs_file_t*)lfs->mlist; f; f = f->next) {
|
||||
if (dir != &f->m && lfs_pair_cmp(f->m.pair, dir->pair) == 0 &&
|
||||
@@ -2029,7 +2013,6 @@ compact:
|
||||
#ifndef LFS_READONLY
|
||||
static int lfs_rawmkdir(lfs_t *lfs, const char *path) {
|
||||
// deorphan if we haven't yet, needed at most once after poweron
|
||||
LFS_ASSERT(path);
|
||||
int err = lfs_fs_forceconsistency(lfs);
|
||||
if (err) {
|
||||
return err;
|
||||
@@ -2177,18 +2160,19 @@ static int lfs_dir_rawread(lfs_t *lfs, lfs_dir_t *dir, struct lfs_info *info) {
|
||||
info->type = LFS_TYPE_DIR;
|
||||
strcpy(info->name, ".");
|
||||
dir->pos += 1;
|
||||
return true;
|
||||
return 0;
|
||||
} else if (dir->pos == 1) {
|
||||
info->type = LFS_TYPE_DIR;
|
||||
strcpy(info->name, "..");
|
||||
dir->pos += 1;
|
||||
return true;
|
||||
return 0;
|
||||
}
|
||||
|
||||
while (true) {
|
||||
if (dir->id == dir->m.count) {
|
||||
if (!dir->m.split) {
|
||||
return false;
|
||||
// reached end of traversal
|
||||
return LFS_ERR_NOENT;
|
||||
}
|
||||
|
||||
int err = lfs_dir_fetch(lfs, &dir->m, dir->m.tail);
|
||||
@@ -2211,7 +2195,7 @@ static int lfs_dir_rawread(lfs_t *lfs, lfs_dir_t *dir, struct lfs_info *info) {
|
||||
}
|
||||
|
||||
dir->pos += 1;
|
||||
return true;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int lfs_dir_rawseek(lfs_t *lfs, lfs_dir_t *dir, lfs_off_t off) {
|
||||
@@ -2467,14 +2451,14 @@ static int lfs_file_rawopencfg(lfs_t *lfs, lfs_file_t *file,
|
||||
const struct lfs_file_config *cfg) {
|
||||
#ifndef LFS_READONLY
|
||||
// deorphan if we haven't yet, needed at most once after poweron
|
||||
if (flags & LFS_O_WRONLY) {
|
||||
if ((flags & LFS_O_WRONLY) == LFS_O_WRONLY) {
|
||||
int err = lfs_fs_forceconsistency(lfs);
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
}
|
||||
#else
|
||||
LFS_ASSERT(flags & LFS_O_RDONLY);
|
||||
LFS_ASSERT((flags & LFS_O_RDONLY) == LFS_O_RDONLY);
|
||||
#endif
|
||||
|
||||
// setup simple file details
|
||||
@@ -2485,7 +2469,7 @@ static int lfs_file_rawopencfg(lfs_t *lfs, lfs_file_t *file,
|
||||
file->off = 0;
|
||||
file->cache.buffer = NULL;
|
||||
|
||||
// find path
|
||||
// allocate entry for file if it doesn't exist
|
||||
lfs_stag_t tag = lfs_dir_find(lfs, &file->m, &path, &file->id);
|
||||
if (tag < 0 && !(tag == LFS_ERR_NOENT && file->id != 0x3ff)) {
|
||||
err = tag;
|
||||
@@ -2493,22 +2477,19 @@ static int lfs_file_rawopencfg(lfs_t *lfs, lfs_file_t *file,
|
||||
}
|
||||
|
||||
// get id, add to list of mdirs to catch update changes
|
||||
if (!(flags & LFS_O_SNAPSHOT)) {
|
||||
file->type = LFS_TYPE_REG;
|
||||
lfs_mlist_append(lfs, (struct lfs_mlist *)file);
|
||||
}
|
||||
file->type = LFS_TYPE_REG;
|
||||
lfs_mlist_append(lfs, (struct lfs_mlist *)file);
|
||||
|
||||
#ifndef LFS_READONLY
|
||||
if ((flags & LFS_O_CREAT) && (flags & LFS_O_SNAPSHOT) &&
|
||||
(tag == LFS_ERR_NOENT || lfs_tag_type3(tag) != LFS_TYPE_REG)) {
|
||||
// special case for "temporary" files
|
||||
tag = LFS_MKTAG(LFS_TYPE_INLINESTRUCT, 0, 0);
|
||||
} else if ((flags & LFS_O_EXCL) && tag != LFS_ERR_NOENT) {
|
||||
err = LFS_ERR_EXIST;
|
||||
#ifdef LFS_READONLY
|
||||
if (tag == LFS_ERR_NOENT) {
|
||||
err = LFS_ERR_NOENT;
|
||||
goto cleanup;
|
||||
} else if ((flags & LFS_O_CREAT) && tag == LFS_ERR_NOENT) {
|
||||
// allocate entry for file if it doesn't exist
|
||||
LFS_ASSERT(path);
|
||||
#else
|
||||
if (tag == LFS_ERR_NOENT) {
|
||||
if (!(flags & LFS_O_CREAT)) {
|
||||
err = LFS_ERR_NOENT;
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
// check that name fits
|
||||
lfs_size_t nlen = strlen(path);
|
||||
@@ -2521,57 +2502,63 @@ static int lfs_file_rawopencfg(lfs_t *lfs, lfs_file_t *file,
|
||||
err = lfs_dir_commit(lfs, &file->m, LFS_MKATTRS(
|
||||
{LFS_MKTAG(LFS_TYPE_CREATE, file->id, 0), NULL},
|
||||
{LFS_MKTAG(LFS_TYPE_REG, file->id, nlen), path},
|
||||
{LFS_MKTAG(LFS_TYPE_INLINESTRUCT, file->id, 0), NULL},
|
||||
{LFS_MKTAG(LFS_FROM_USERATTRS, file->id,
|
||||
file->cfg->attr_count), file->cfg->attrs}));
|
||||
{LFS_MKTAG(LFS_TYPE_INLINESTRUCT, file->id, 0), NULL}));
|
||||
if (err) {
|
||||
err = LFS_ERR_NAMETOOLONG;
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
tag = LFS_MKTAG(LFS_TYPE_INLINESTRUCT, 0, 0);
|
||||
} else /**/
|
||||
#endif /**/
|
||||
/*********/
|
||||
/**/ if (tag == LFS_ERR_NOENT) {
|
||||
err = LFS_ERR_NOENT;
|
||||
} else if (flags & LFS_O_EXCL) {
|
||||
err = LFS_ERR_EXIST;
|
||||
goto cleanup;
|
||||
#endif
|
||||
} else if (lfs_tag_type3(tag) != LFS_TYPE_REG) {
|
||||
err = LFS_ERR_ISDIR;
|
||||
goto cleanup;
|
||||
} else {
|
||||
#ifndef LFS_READONLY
|
||||
if (flags & LFS_O_TRUNC) {
|
||||
// truncate if requested
|
||||
// always mark dirty in case we have custom attributes
|
||||
tag = LFS_MKTAG(LFS_TYPE_INLINESTRUCT, 0, 0);
|
||||
file->flags |= LFS_F_DIRTY;
|
||||
} else /**/
|
||||
#endif /*********/
|
||||
/**/ {
|
||||
// try to load what's on disk, if it's inlined we'll fix it later
|
||||
tag = lfs_dir_get(lfs, &file->m, LFS_MKTAG(0x700, 0x3ff, 0),
|
||||
LFS_MKTAG(LFS_TYPE_STRUCT, file->id, 8), &file->ctz);
|
||||
if (tag < 0) {
|
||||
err = tag;
|
||||
} else if (flags & LFS_O_TRUNC) {
|
||||
// truncate if requested
|
||||
tag = LFS_MKTAG(LFS_TYPE_INLINESTRUCT, file->id, 0);
|
||||
file->flags |= LFS_F_DIRTY;
|
||||
#endif
|
||||
} else {
|
||||
// try to load what's on disk, if it's inlined we'll fix it later
|
||||
tag = lfs_dir_get(lfs, &file->m, LFS_MKTAG(0x700, 0x3ff, 0),
|
||||
LFS_MKTAG(LFS_TYPE_STRUCT, file->id, 8), &file->ctz);
|
||||
if (tag < 0) {
|
||||
err = tag;
|
||||
goto cleanup;
|
||||
}
|
||||
lfs_ctz_fromle32(&file->ctz);
|
||||
}
|
||||
|
||||
// fetch attrs
|
||||
for (unsigned i = 0; i < file->cfg->attr_count; i++) {
|
||||
// if opened for read / read-write operations
|
||||
if ((file->flags & LFS_O_RDONLY) == LFS_O_RDONLY) {
|
||||
lfs_stag_t res = lfs_dir_get(lfs, &file->m,
|
||||
LFS_MKTAG(0x7ff, 0x3ff, 0),
|
||||
LFS_MKTAG(LFS_TYPE_USERATTR + file->cfg->attrs[i].type,
|
||||
file->id, file->cfg->attrs[i].size),
|
||||
file->cfg->attrs[i].buffer);
|
||||
if (res < 0 && res != LFS_ERR_NOENT) {
|
||||
err = res;
|
||||
goto cleanup;
|
||||
}
|
||||
lfs_ctz_fromle32(&file->ctz);
|
||||
}
|
||||
|
||||
// fetch attrs if opened for read / read-write operations
|
||||
if (flags & LFS_O_RDONLY) {
|
||||
for (lfs_size_t i = 0; i < file->cfg->attr_count; i++) {
|
||||
lfs_stag_t res = lfs_dir_get(lfs, &file->m,
|
||||
LFS_MKTAG(0x7ff, 0x3ff, 0),
|
||||
LFS_MKTAG(LFS_TYPE_USERATTR + file->cfg->attrs[i].type,
|
||||
file->id, file->cfg->attrs[i].size),
|
||||
file->cfg->attrs[i].buffer);
|
||||
if (res < 0 && res != LFS_ERR_NOENT) {
|
||||
err = res;
|
||||
goto cleanup;
|
||||
}
|
||||
#ifndef LFS_READONLY
|
||||
// if opened for write / read-write operations
|
||||
if ((file->flags & LFS_O_WRONLY) == LFS_O_WRONLY) {
|
||||
if (file->cfg->attrs[i].size > lfs->attr_max) {
|
||||
err = LFS_ERR_NOSPC;
|
||||
goto cleanup;
|
||||
}
|
||||
|
||||
file->flags |= LFS_F_DIRTY;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
// allocate buffer if needed
|
||||
@@ -2616,7 +2603,7 @@ static int lfs_file_rawopencfg(lfs_t *lfs, lfs_file_t *file,
|
||||
cleanup:
|
||||
// clean up lingering resources
|
||||
#ifndef LFS_READONLY
|
||||
file->flags |= LFS_F_ZOMBIE;
|
||||
file->flags |= LFS_F_ERRED;
|
||||
#endif
|
||||
lfs_file_rawclose(lfs, file);
|
||||
return err;
|
||||
@@ -2630,9 +2617,10 @@ static int lfs_file_rawopen(lfs_t *lfs, lfs_file_t *file,
|
||||
}
|
||||
|
||||
static int lfs_file_rawclose(lfs_t *lfs, lfs_file_t *file) {
|
||||
int err = 0;
|
||||
#ifndef LFS_READONLY
|
||||
err = lfs_file_rawsync(lfs, file);
|
||||
int err = lfs_file_rawsync(lfs, file);
|
||||
#else
|
||||
int err = 0;
|
||||
#endif
|
||||
|
||||
// remove from list of mdirs
|
||||
@@ -2814,21 +2802,17 @@ relocate:
|
||||
|
||||
#ifndef LFS_READONLY
|
||||
static int lfs_file_rawsync(lfs_t *lfs, lfs_file_t *file) {
|
||||
if (file->flags & LFS_F_ZOMBIE) {
|
||||
if (file->flags & LFS_F_ERRED) {
|
||||
// it's not safe to do anything if our file errored
|
||||
return 0;
|
||||
}
|
||||
|
||||
int err = lfs_file_flush(lfs, file);
|
||||
if (err) {
|
||||
file->flags |= LFS_F_ZOMBIE;
|
||||
file->flags |= LFS_F_ERRED;
|
||||
return err;
|
||||
}
|
||||
|
||||
if (file->flags & LFS_O_SNAPSHOT) {
|
||||
// we do flush snapshot files, but we don't commit, so stop here
|
||||
return 0;
|
||||
}
|
||||
|
||||
if ((file->flags & LFS_F_DIRTY) &&
|
||||
!lfs_pair_isnull(file->m.pair)) {
|
||||
@@ -2858,41 +2842,10 @@ static int lfs_file_rawsync(lfs_t *lfs, lfs_file_t *file) {
|
||||
{LFS_MKTAG(LFS_FROM_USERATTRS, file->id,
|
||||
file->cfg->attr_count), file->cfg->attrs}));
|
||||
if (err) {
|
||||
file->flags |= LFS_F_ZOMBIE;
|
||||
file->flags |= LFS_F_ERRED;
|
||||
return err;
|
||||
}
|
||||
|
||||
// update readable handles referencing this file device-side
|
||||
for (lfs_file_t *f = (lfs_file_t*)lfs->mlist; f; f = f->next) {
|
||||
if (f != file &&
|
||||
f->type == LFS_TYPE_REG &&
|
||||
lfs_pair_cmp(f->m.pair, file->m.pair) == 0 &&
|
||||
f->id == file->id &&
|
||||
// only readable handles because wronly files
|
||||
// may reference attributes in ROM
|
||||
(f->flags & LFS_O_RDONLY)) {
|
||||
// sync disk structure
|
||||
f->ctz = file->ctz;
|
||||
// copying the cache is required for inline files
|
||||
lfs_cache_copy(lfs, &f->cache, &file->cache);
|
||||
|
||||
// sync attrs
|
||||
for (lfs_size_t i = 0; i < f->cfg->attr_count; i++) {
|
||||
for (lfs_size_t j = 0; j < file->cfg->attr_count; j++) {
|
||||
if (f->cfg->attrs[i].type == file->cfg->attrs[i].type) {
|
||||
memcpy(f->cfg->attrs[i].buffer,
|
||||
file->cfg->attrs[i].buffer,
|
||||
lfs_min(
|
||||
f->cfg->attrs[i].size,
|
||||
file->cfg->attrs[i].size));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
f->flags &= ~(LFS_F_DIRTY | LFS_F_WRITING | LFS_F_READING);
|
||||
}
|
||||
}
|
||||
|
||||
file->flags &= ~LFS_F_DIRTY;
|
||||
}
|
||||
|
||||
@@ -2902,7 +2855,7 @@ static int lfs_file_rawsync(lfs_t *lfs, lfs_file_t *file) {
|
||||
|
||||
static lfs_ssize_t lfs_file_rawread(lfs_t *lfs, lfs_file_t *file,
|
||||
void *buffer, lfs_size_t size) {
|
||||
LFS_ASSERT(file->flags & LFS_O_RDONLY);
|
||||
LFS_ASSERT((file->flags & LFS_O_RDONLY) == LFS_O_RDONLY);
|
||||
|
||||
uint8_t *data = buffer;
|
||||
lfs_size_t nsize = size;
|
||||
@@ -2976,7 +2929,7 @@ static lfs_ssize_t lfs_file_rawread(lfs_t *lfs, lfs_file_t *file,
|
||||
#ifndef LFS_READONLY
|
||||
static lfs_ssize_t lfs_file_rawwrite(lfs_t *lfs, lfs_file_t *file,
|
||||
const void *buffer, lfs_size_t size) {
|
||||
LFS_ASSERT(file->flags & LFS_O_WRONLY);
|
||||
LFS_ASSERT((file->flags & LFS_O_WRONLY) == LFS_O_WRONLY);
|
||||
|
||||
const uint8_t *data = buffer;
|
||||
lfs_size_t nsize = size;
|
||||
@@ -3018,7 +2971,7 @@ static lfs_ssize_t lfs_file_rawwrite(lfs_t *lfs, lfs_file_t *file,
|
||||
// inline file doesn't fit anymore
|
||||
int err = lfs_file_outline(lfs, file);
|
||||
if (err) {
|
||||
file->flags |= LFS_F_ZOMBIE;
|
||||
file->flags |= LFS_F_ERRED;
|
||||
return err;
|
||||
}
|
||||
}
|
||||
@@ -3034,7 +2987,7 @@ static lfs_ssize_t lfs_file_rawwrite(lfs_t *lfs, lfs_file_t *file,
|
||||
file->ctz.head, file->ctz.size,
|
||||
file->pos-1, &file->block, &file->off);
|
||||
if (err) {
|
||||
file->flags |= LFS_F_ZOMBIE;
|
||||
file->flags |= LFS_F_ERRED;
|
||||
return err;
|
||||
}
|
||||
|
||||
@@ -3048,7 +3001,7 @@ static lfs_ssize_t lfs_file_rawwrite(lfs_t *lfs, lfs_file_t *file,
|
||||
file->block, file->pos,
|
||||
&file->block, &file->off);
|
||||
if (err) {
|
||||
file->flags |= LFS_F_ZOMBIE;
|
||||
file->flags |= LFS_F_ERRED;
|
||||
return err;
|
||||
}
|
||||
} else {
|
||||
@@ -3068,7 +3021,7 @@ static lfs_ssize_t lfs_file_rawwrite(lfs_t *lfs, lfs_file_t *file,
|
||||
if (err == LFS_ERR_CORRUPT) {
|
||||
goto relocate;
|
||||
}
|
||||
file->flags |= LFS_F_ZOMBIE;
|
||||
file->flags |= LFS_F_ERRED;
|
||||
return err;
|
||||
}
|
||||
|
||||
@@ -3076,7 +3029,7 @@ static lfs_ssize_t lfs_file_rawwrite(lfs_t *lfs, lfs_file_t *file,
|
||||
relocate:
|
||||
err = lfs_file_relocate(lfs, file);
|
||||
if (err) {
|
||||
file->flags |= LFS_F_ZOMBIE;
|
||||
file->flags |= LFS_F_ERRED;
|
||||
return err;
|
||||
}
|
||||
}
|
||||
@@ -3089,7 +3042,7 @@ relocate:
|
||||
lfs_alloc_ack(lfs);
|
||||
}
|
||||
|
||||
file->flags &= ~LFS_F_ZOMBIE;
|
||||
file->flags &= ~LFS_F_ERRED;
|
||||
return size;
|
||||
}
|
||||
#endif
|
||||
@@ -3126,7 +3079,7 @@ static lfs_soff_t lfs_file_rawseek(lfs_t *lfs, lfs_file_t *file,
|
||||
|
||||
#ifndef LFS_READONLY
|
||||
static int lfs_file_rawtruncate(lfs_t *lfs, lfs_file_t *file, lfs_off_t size) {
|
||||
LFS_ASSERT(file->flags & LFS_O_WRONLY);
|
||||
LFS_ASSERT((file->flags & LFS_O_WRONLY) == LFS_O_WRONLY);
|
||||
|
||||
if (size > LFS_FILE_MAX) {
|
||||
return LFS_ERR_INVAL;
|
||||
@@ -3472,34 +3425,8 @@ static int lfs_commitattr(lfs_t *lfs, const char *path,
|
||||
}
|
||||
}
|
||||
|
||||
int err = lfs_dir_commit(lfs, &cwd, LFS_MKATTRS(
|
||||
return lfs_dir_commit(lfs, &cwd, LFS_MKATTRS(
|
||||
{LFS_MKTAG(LFS_TYPE_USERATTR + type, id, size), buffer}));
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
|
||||
if (lfs_tag_type3(tag) == LFS_TYPE_REG && size != 0x3ff) {
|
||||
// sync attrs with any files open for reading, this follows
|
||||
// the behavior of lfs_file_sync with attributes
|
||||
for (lfs_file_t *f = (lfs_file_t*)lfs->mlist; f; f = f->next) {
|
||||
if (f->type == LFS_TYPE_REG &&
|
||||
lfs_pair_cmp(f->m.pair, cwd.pair) == 0 &&
|
||||
f->id == id &&
|
||||
// only readable handles because wronly files
|
||||
// may reference attributes in ROM
|
||||
(f->flags & LFS_O_RDONLY)) {
|
||||
// sync attrs
|
||||
for (lfs_size_t i = 0; i < f->cfg->attr_count; i++) {
|
||||
if (f->cfg->attrs[i].type == type) {
|
||||
memcpy(f->cfg->attrs[i].buffer, buffer,
|
||||
lfs_min(f->cfg->attrs[i].size, size));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -3903,7 +3830,7 @@ int lfs_fs_rawtraverse(lfs_t *lfs,
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
} else if (includeorphans &&
|
||||
} else if (includeorphans &&
|
||||
lfs_tag_type3(tag) == LFS_TYPE_DIRSTRUCT) {
|
||||
for (int i = 0; i < 2; i++) {
|
||||
err = cb(data, (&ctz.head)[i]);
|
||||
@@ -5158,8 +5085,7 @@ int lfs_file_close(lfs_t *lfs, lfs_file_t *file) {
|
||||
return err;
|
||||
}
|
||||
LFS_TRACE("lfs_file_close(%p, %p)", (void*)lfs, (void*)file);
|
||||
LFS_ASSERT((file->flags & LFS_O_SNAPSHOT) ||
|
||||
lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
|
||||
LFS_ASSERT(lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
|
||||
|
||||
err = lfs_file_rawclose(lfs, file);
|
||||
|
||||
@@ -5175,8 +5101,7 @@ int lfs_file_sync(lfs_t *lfs, lfs_file_t *file) {
|
||||
return err;
|
||||
}
|
||||
LFS_TRACE("lfs_file_sync(%p, %p)", (void*)lfs, (void*)file);
|
||||
LFS_ASSERT((file->flags & LFS_O_SNAPSHOT) ||
|
||||
lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
|
||||
LFS_ASSERT(lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
|
||||
|
||||
err = lfs_file_rawsync(lfs, file);
|
||||
|
||||
@@ -5194,8 +5119,7 @@ lfs_ssize_t lfs_file_read(lfs_t *lfs, lfs_file_t *file,
|
||||
}
|
||||
LFS_TRACE("lfs_file_read(%p, %p, %p, %"PRIu32")",
|
||||
(void*)lfs, (void*)file, buffer, size);
|
||||
LFS_ASSERT((file->flags & LFS_O_SNAPSHOT) ||
|
||||
lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
|
||||
LFS_ASSERT(lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
|
||||
|
||||
lfs_ssize_t res = lfs_file_rawread(lfs, file, buffer, size);
|
||||
|
||||
@@ -5213,8 +5137,7 @@ lfs_ssize_t lfs_file_write(lfs_t *lfs, lfs_file_t *file,
|
||||
}
|
||||
LFS_TRACE("lfs_file_write(%p, %p, %p, %"PRIu32")",
|
||||
(void*)lfs, (void*)file, buffer, size);
|
||||
LFS_ASSERT((file->flags & LFS_O_SNAPSHOT) ||
|
||||
lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
|
||||
LFS_ASSERT(lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
|
||||
|
||||
lfs_ssize_t res = lfs_file_rawwrite(lfs, file, buffer, size);
|
||||
|
||||
@@ -5232,8 +5155,7 @@ lfs_soff_t lfs_file_seek(lfs_t *lfs, lfs_file_t *file,
|
||||
}
|
||||
LFS_TRACE("lfs_file_seek(%p, %p, %"PRId32", %d)",
|
||||
(void*)lfs, (void*)file, off, whence);
|
||||
LFS_ASSERT((file->flags & LFS_O_SNAPSHOT) ||
|
||||
lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
|
||||
LFS_ASSERT(lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
|
||||
|
||||
lfs_soff_t res = lfs_file_rawseek(lfs, file, off, whence);
|
||||
|
||||
@@ -5250,8 +5172,7 @@ 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_O_SNAPSHOT) ||
|
||||
lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
|
||||
LFS_ASSERT(lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
|
||||
|
||||
err = lfs_file_rawtruncate(lfs, file, size);
|
||||
|
||||
@@ -5267,8 +5188,7 @@ lfs_soff_t lfs_file_tell(lfs_t *lfs, lfs_file_t *file) {
|
||||
return err;
|
||||
}
|
||||
LFS_TRACE("lfs_file_tell(%p, %p)", (void*)lfs, (void*)file);
|
||||
LFS_ASSERT((file->flags & LFS_O_SNAPSHOT) ||
|
||||
lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
|
||||
LFS_ASSERT(lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
|
||||
|
||||
lfs_soff_t res = lfs_file_rawtell(lfs, file);
|
||||
|
||||
@@ -5297,8 +5217,7 @@ lfs_soff_t lfs_file_size(lfs_t *lfs, lfs_file_t *file) {
|
||||
return err;
|
||||
}
|
||||
LFS_TRACE("lfs_file_size(%p, %p)", (void*)lfs, (void*)file);
|
||||
LFS_ASSERT((file->flags & LFS_O_SNAPSHOT) ||
|
||||
lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
|
||||
LFS_ASSERT(lfs_mlist_isopen(lfs->mlist, (struct lfs_mlist*)file));
|
||||
|
||||
lfs_soff_t res = lfs_file_rawsize(lfs, file);
|
||||
|
||||
|
||||
55
lfs.h
55
lfs.h
@@ -123,30 +123,26 @@ enum lfs_type {
|
||||
// File open flags
|
||||
enum lfs_open_flags {
|
||||
// open flags
|
||||
LFS_O_RDONLY = 1, // Open a file as read only
|
||||
LFS_O_RDONLY = 1, // Open a file as read only
|
||||
#ifndef LFS_READONLY
|
||||
LFS_O_WRONLY = 2, // Open a file as write only
|
||||
LFS_O_RDWR = 3, // Open a file as read and write
|
||||
#endif
|
||||
|
||||
#ifndef LFS_READONLY
|
||||
LFS_O_CREAT = 0x0100, // Create a file if it does not exist
|
||||
LFS_O_EXCL = 0x0200, // Fail if a file already exists
|
||||
LFS_O_TRUNC = 0x0400, // Truncate the existing file to zero size
|
||||
LFS_O_APPEND = 0x0800, // Move to end of file on every write
|
||||
LFS_O_SNAPSHOT = 0x1000, // Open a temporary snapshot, ignore changes
|
||||
LFS_O_WRONLY = 2, // Open a file as write only
|
||||
LFS_O_RDWR = 3, // Open a file as read and write
|
||||
LFS_O_CREAT = 0x0100, // Create a file if it does not exist
|
||||
LFS_O_EXCL = 0x0200, // Fail if a file already exists
|
||||
LFS_O_TRUNC = 0x0400, // Truncate the existing file to zero size
|
||||
LFS_O_APPEND = 0x0800, // Move to end of file on every write
|
||||
#endif
|
||||
|
||||
// internally used flags
|
||||
#ifndef LFS_READONLY
|
||||
LFS_F_DIRTY = 0x010000, // File does not match storage
|
||||
LFS_F_DIRTY = 0x010000, // File does not match storage
|
||||
LFS_F_WRITING = 0x020000, // File has been written since last flush
|
||||
#endif
|
||||
LFS_F_READING = 0x020000, // File has been read since last flush
|
||||
LFS_F_READING = 0x040000, // File has been read since last flush
|
||||
#ifndef LFS_READONLY
|
||||
LFS_F_WRITING = 0x040000, // File has been written since last flush
|
||||
LFS_F_ZOMBIE = 0x080000, // An error occurred during write
|
||||
LFS_F_ERRED = 0x080000, // An error occurred during write
|
||||
#endif
|
||||
LFS_F_INLINE = 0x100000, // Currently inlined in directory entry
|
||||
LFS_F_INLINE = 0x100000, // Currently inlined in directory entry
|
||||
};
|
||||
|
||||
// File seek flags
|
||||
@@ -298,15 +294,16 @@ struct lfs_file_config {
|
||||
void *buffer;
|
||||
|
||||
// Optional list of custom attributes related to the file. If the file
|
||||
// is opened for reading, these attributes will be read from disk during
|
||||
// open. If the file is open for writing, these attribute will be atomically
|
||||
// written to disk when the file is written to disk. Note that these
|
||||
// attributes are not written unless the file is modified.
|
||||
// is opened with read access, these attributes will be read from disk
|
||||
// during the open call. If the file is opened with write access, the
|
||||
// attributes will be written to disk every file sync or close. This
|
||||
// write occurs atomically with update to the file's contents.
|
||||
//
|
||||
// Custom attributes are uniquely identified by an 8-bit type and limited
|
||||
// to LFS_ATTR_MAX bytes. If the stored attribute is larger than the
|
||||
// provided buffer, it will be silently truncated. If no attribute is
|
||||
// found, and the file is open for writing, it will be created implicitly.
|
||||
// to LFS_ATTR_MAX bytes. When read, if the stored attribute is smaller
|
||||
// than the buffer, it will be padded with zeros. If the stored attribute
|
||||
// is larger, then it will be silently truncated. If the attribute is not
|
||||
// found, it will be created implicitly.
|
||||
struct lfs_attr *attrs;
|
||||
|
||||
// Number of custom attributes in the list
|
||||
@@ -474,9 +471,10 @@ int lfs_stat(lfs_t *lfs, const char *path, struct lfs_info *info);
|
||||
// Get a custom attribute
|
||||
//
|
||||
// Custom attributes are uniquely identified by an 8-bit type and limited
|
||||
// to LFS_ATTR_MAX bytes. If the stored attribute is larger than the
|
||||
// provided buffer, it will be silently truncated. If no attribute is found,
|
||||
// the error LFS_ERR_NOATTR is returned and the buffer is filled with zeros.
|
||||
// to LFS_ATTR_MAX bytes. When read, if the stored attribute is smaller than
|
||||
// the buffer, it will be padded with zeros. If the stored attribute is larger,
|
||||
// then it will be silently truncated. If no attribute is found, the error
|
||||
// LFS_ERR_NOATTR is returned and the buffer is filled with zeros.
|
||||
//
|
||||
// Returns the size of the attribute, or a negative error code on failure.
|
||||
// Note, the returned size is the size of the attribute on disk, irrespective
|
||||
@@ -621,8 +619,9 @@ int lfs_dir_close(lfs_t *lfs, lfs_dir_t *dir);
|
||||
// Read an entry in the directory
|
||||
//
|
||||
// Fills out the info structure, based on the specified file or directory.
|
||||
// Returns a positive value on success, 0 at the end of directory,
|
||||
// or a negative error code on failure.
|
||||
//
|
||||
// Returns 0 on success, LFS_ERR_NOENT if there are no more directry entries,
|
||||
// or another negative error code on failure.
|
||||
int lfs_dir_read(lfs_t *lfs, lfs_dir_t *dir, struct lfs_info *info);
|
||||
|
||||
// Change the position of the directory
|
||||
|
||||
@@ -16,39 +16,41 @@ code = '''
|
||||
lfs_getattr(&lfs, "hello", 'A', buffer, 4) => 4;
|
||||
lfs_getattr(&lfs, "hello", 'B', buffer+4, 6) => 6;
|
||||
lfs_getattr(&lfs, "hello", 'C', buffer+10, 5) => 5;
|
||||
assert(memcmp(buffer, "aaaa", 4) == 0);
|
||||
assert(memcmp(buffer+4, "bbbbbb", 6) == 0);
|
||||
assert(memcmp(buffer+10, "ccccc", 5) == 0);
|
||||
memcmp(buffer, "aaaa", 4) => 0;
|
||||
memcmp(buffer+4, "bbbbbb", 6) => 0;
|
||||
memcmp(buffer+10, "ccccc", 5) => 0;
|
||||
|
||||
lfs_setattr(&lfs, "hello", 'B', "", 0) => 0;
|
||||
lfs_getattr(&lfs, "hello", 'A', buffer, 4) => 4;
|
||||
lfs_getattr(&lfs, "hello", 'B', buffer+4, 6) => 0;
|
||||
lfs_getattr(&lfs, "hello", 'C', buffer+10, 5) => 5;
|
||||
assert(memcmp(buffer, "aaaa", 4) == 0);
|
||||
assert(memcmp(buffer+10, "ccccc", 5) == 0);
|
||||
memcmp(buffer, "aaaa", 4) => 0;
|
||||
memcmp(buffer+4, "\0\0\0\0\0\0", 6) => 0;
|
||||
memcmp(buffer+10, "ccccc", 5) => 0;
|
||||
|
||||
lfs_removeattr(&lfs, "hello", 'B') => 0;
|
||||
lfs_getattr(&lfs, "hello", 'A', buffer, 4) => 4;
|
||||
lfs_getattr(&lfs, "hello", 'B', buffer+4, 6) => LFS_ERR_NOATTR;
|
||||
lfs_getattr(&lfs, "hello", 'C', buffer+10, 5) => 5;
|
||||
assert(memcmp(buffer, "aaaa", 4) == 0);
|
||||
assert(memcmp(buffer+10, "ccccc", 5) == 0);
|
||||
memcmp(buffer, "aaaa", 4) => 0;
|
||||
memcmp(buffer+4, "\0\0\0\0\0\0", 6) => 0;
|
||||
memcmp(buffer+10, "ccccc", 5) => 0;
|
||||
|
||||
lfs_setattr(&lfs, "hello", 'B', "dddddd", 6) => 0;
|
||||
lfs_getattr(&lfs, "hello", 'A', buffer, 4) => 4;
|
||||
lfs_getattr(&lfs, "hello", 'B', buffer+4, 6) => 6;
|
||||
lfs_getattr(&lfs, "hello", 'C', buffer+10, 5) => 5;
|
||||
assert(memcmp(buffer, "aaaa", 4) == 0);
|
||||
assert(memcmp(buffer+4, "dddddd", 6) == 0);
|
||||
assert(memcmp(buffer+10, "ccccc", 5) == 0);
|
||||
memcmp(buffer, "aaaa", 4) => 0;
|
||||
memcmp(buffer+4, "dddddd", 6) => 0;
|
||||
memcmp(buffer+10, "ccccc", 5) => 0;
|
||||
|
||||
lfs_setattr(&lfs, "hello", 'B', "eee", 3) => 0;
|
||||
lfs_getattr(&lfs, "hello", 'A', buffer, 4) => 4;
|
||||
lfs_getattr(&lfs, "hello", 'B', buffer+4, 6) => 3;
|
||||
lfs_getattr(&lfs, "hello", 'C', buffer+10, 5) => 5;
|
||||
assert(memcmp(buffer, "aaaa", 4) == 0);
|
||||
assert(memcmp(buffer+4, "eee", 3) == 0);
|
||||
assert(memcmp(buffer+10, "ccccc", 5) == 0);
|
||||
memcmp(buffer, "aaaa", 4) => 0;
|
||||
memcmp(buffer+4, "eee\0\0\0", 6) => 0;
|
||||
memcmp(buffer+10, "ccccc", 5) => 0;
|
||||
|
||||
lfs_setattr(&lfs, "hello", 'A', buffer, LFS_ATTR_MAX+1) => LFS_ERR_NOSPC;
|
||||
lfs_setattr(&lfs, "hello", 'B', "fffffffff", 9) => 0;
|
||||
@@ -63,13 +65,13 @@ code = '''
|
||||
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;
|
||||
assert(memcmp(buffer, "aaaa", 4) == 0);
|
||||
assert(memcmp(buffer+4, "fffffffff", 9) == 0);
|
||||
assert(memcmp(buffer+13, "ccccc", 5) == 0);
|
||||
memcmp(buffer, "aaaa", 4) => 0;
|
||||
memcmp(buffer+4, "fffffffff", 9) => 0;
|
||||
memcmp(buffer+13, "ccccc", 5) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "hello/hello", LFS_O_RDONLY) => 0;
|
||||
lfs_file_read(&lfs, &file, buffer, sizeof(buffer)) => strlen("hello");
|
||||
assert(memcmp(buffer, "hello", strlen("hello")) == 0);
|
||||
memcmp(buffer, "hello", strlen("hello")) => 0;
|
||||
lfs_file_close(&lfs, &file);
|
||||
lfs_unmount(&lfs) => 0;
|
||||
'''
|
||||
@@ -92,39 +94,41 @@ code = '''
|
||||
lfs_getattr(&lfs, "/", 'A', buffer, 4) => 4;
|
||||
lfs_getattr(&lfs, "/", 'B', buffer+4, 6) => 6;
|
||||
lfs_getattr(&lfs, "/", 'C', buffer+10, 5) => 5;
|
||||
assert(memcmp(buffer, "aaaa", 4) == 0);
|
||||
assert(memcmp(buffer+4, "bbbbbb", 6) == 0);
|
||||
assert(memcmp(buffer+10, "ccccc", 5) == 0);
|
||||
memcmp(buffer, "aaaa", 4) => 0;
|
||||
memcmp(buffer+4, "bbbbbb", 6) => 0;
|
||||
memcmp(buffer+10, "ccccc", 5) => 0;
|
||||
|
||||
lfs_setattr(&lfs, "/", 'B', "", 0) => 0;
|
||||
lfs_getattr(&lfs, "/", 'A', buffer, 4) => 4;
|
||||
lfs_getattr(&lfs, "/", 'B', buffer+4, 6) => 0;
|
||||
lfs_getattr(&lfs, "/", 'C', buffer+10, 5) => 5;
|
||||
assert(memcmp(buffer, "aaaa", 4) == 0);
|
||||
assert(memcmp(buffer+10, "ccccc", 5) == 0);
|
||||
memcmp(buffer, "aaaa", 4) => 0;
|
||||
memcmp(buffer+4, "\0\0\0\0\0\0", 6) => 0;
|
||||
memcmp(buffer+10, "ccccc", 5) => 0;
|
||||
|
||||
lfs_removeattr(&lfs, "/", 'B') => 0;
|
||||
lfs_getattr(&lfs, "/", 'A', buffer, 4) => 4;
|
||||
lfs_getattr(&lfs, "/", 'B', buffer+4, 6) => LFS_ERR_NOATTR;
|
||||
lfs_getattr(&lfs, "/", 'C', buffer+10, 5) => 5;
|
||||
assert(memcmp(buffer, "aaaa", 4) == 0);
|
||||
assert(memcmp(buffer+10, "ccccc", 5) == 0);
|
||||
memcmp(buffer, "aaaa", 4) => 0;
|
||||
memcmp(buffer+4, "\0\0\0\0\0\0", 6) => 0;
|
||||
memcmp(buffer+10, "ccccc", 5) => 0;
|
||||
|
||||
lfs_setattr(&lfs, "/", 'B', "dddddd", 6) => 0;
|
||||
lfs_getattr(&lfs, "/", 'A', buffer, 4) => 4;
|
||||
lfs_getattr(&lfs, "/", 'B', buffer+4, 6) => 6;
|
||||
lfs_getattr(&lfs, "/", 'C', buffer+10, 5) => 5;
|
||||
assert(memcmp(buffer, "aaaa", 4) == 0);
|
||||
assert(memcmp(buffer+4, "dddddd", 6) == 0);
|
||||
assert(memcmp(buffer+10, "ccccc", 5) == 0);
|
||||
memcmp(buffer, "aaaa", 4) => 0;
|
||||
memcmp(buffer+4, "dddddd", 6) => 0;
|
||||
memcmp(buffer+10, "ccccc", 5) => 0;
|
||||
|
||||
lfs_setattr(&lfs, "/", 'B', "eee", 3) => 0;
|
||||
lfs_getattr(&lfs, "/", 'A', buffer, 4) => 4;
|
||||
lfs_getattr(&lfs, "/", 'B', buffer+4, 6) => 3;
|
||||
lfs_getattr(&lfs, "/", 'C', buffer+10, 5) => 5;
|
||||
assert(memcmp(buffer, "aaaa", 4) == 0);
|
||||
assert(memcmp(buffer+4, "eee", 3) == 0);
|
||||
assert(memcmp(buffer+10, "ccccc", 5) == 0);
|
||||
memcmp(buffer, "aaaa", 4) => 0;
|
||||
memcmp(buffer+4, "eee\0\0\0", 6) => 0;
|
||||
memcmp(buffer+10, "ccccc", 5) => 0;
|
||||
|
||||
lfs_setattr(&lfs, "/", 'A', buffer, LFS_ATTR_MAX+1) => LFS_ERR_NOSPC;
|
||||
lfs_setattr(&lfs, "/", 'B', "fffffffff", 9) => 0;
|
||||
@@ -138,13 +142,13 @@ code = '''
|
||||
lfs_getattr(&lfs, "/", 'A', buffer, 4) => 4;
|
||||
lfs_getattr(&lfs, "/", 'B', buffer+4, 9) => 9;
|
||||
lfs_getattr(&lfs, "/", 'C', buffer+13, 5) => 5;
|
||||
assert(memcmp(buffer, "aaaa", 4) == 0);
|
||||
assert(memcmp(buffer+4, "fffffffff", 9) == 0);
|
||||
assert(memcmp(buffer+13, "ccccc", 5) == 0);
|
||||
memcmp(buffer, "aaaa", 4) => 0;
|
||||
memcmp(buffer+4, "fffffffff", 9) => 0;
|
||||
memcmp(buffer+13, "ccccc", 5) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "hello/hello", LFS_O_RDONLY) => 0;
|
||||
lfs_file_read(&lfs, &file, buffer, sizeof(buffer)) => strlen("hello");
|
||||
assert(memcmp(buffer, "hello", strlen("hello")) == 0);
|
||||
memcmp(buffer, "hello", strlen("hello")) => 0;
|
||||
lfs_file_close(&lfs, &file);
|
||||
lfs_unmount(&lfs) => 0;
|
||||
'''
|
||||
@@ -172,55 +176,52 @@ code = '''
|
||||
memcpy(buffer, "aaaa", 4);
|
||||
memcpy(buffer+4, "bbbbbb", 6);
|
||||
memcpy(buffer+10, "ccccc", 5);
|
||||
lfs_file_write(&lfs, &file, "hi", 2) => 2;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
memset(buffer, 0, 15);
|
||||
lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
assert(memcmp(buffer, "aaaa", 4) == 0);
|
||||
assert(memcmp(buffer+4, "bbbbbb", 6) == 0);
|
||||
assert(memcmp(buffer+10, "ccccc", 5) == 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, "hello/hello", LFS_O_WRONLY, &cfg1) => 0;
|
||||
lfs_file_write(&lfs, &file, "hi", 2) => 2;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
memset(buffer, 0, 15);
|
||||
attrs1[1].size = 6;
|
||||
lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
assert(memcmp(buffer, "aaaa", 4) == 0);
|
||||
assert(memcmp(buffer+10, "ccccc", 5) == 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, "hello/hello", LFS_O_WRONLY, &cfg1) => 0;
|
||||
memcpy(buffer+4, "dddddd", 6);
|
||||
lfs_file_write(&lfs, &file, "hi", 2) => 2;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
memset(buffer, 0, 15);
|
||||
attrs1[1].size = 6;
|
||||
lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
assert(memcmp(buffer, "aaaa", 4) == 0);
|
||||
assert(memcmp(buffer+4, "dddddd", 6) == 0);
|
||||
assert(memcmp(buffer+10, "ccccc", 5) == 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, "hello/hello", LFS_O_WRONLY, &cfg1) => 0;
|
||||
memcpy(buffer+4, "eee", 3);
|
||||
lfs_file_write(&lfs, &file, "hi", 2) => 2;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
memset(buffer, 0, 15);
|
||||
attrs1[1].size = 6;
|
||||
lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
assert(memcmp(buffer, "aaaa", 4) == 0);
|
||||
assert(memcmp(buffer+4, "eee", 3) == 0);
|
||||
assert(memcmp(buffer+10, "ccccc", 5) == 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, "hello/hello2",
|
||||
LFS_O_WRONLY | LFS_O_CREAT, &cfg1) => LFS_ERR_NOSPC;
|
||||
lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_WRONLY, &cfg1)
|
||||
=> LFS_ERR_NOSPC;
|
||||
|
||||
struct lfs_attr attrs2[] = {
|
||||
{'A', buffer, 4},
|
||||
@@ -230,7 +231,6 @@ code = '''
|
||||
struct lfs_file_config cfg2 = {.attrs=attrs2, .attr_count=3};
|
||||
lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDWR, &cfg2) => 0;
|
||||
memcpy(buffer+4, "fffffffff", 9);
|
||||
lfs_file_write(&lfs, &file, "hi", 2) => 2;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
attrs1[0].size = 4;
|
||||
lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
|
||||
@@ -249,13 +249,13 @@ code = '''
|
||||
|
||||
lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg3) => 0;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
assert(memcmp(buffer, "aaaa", 4) == 0);
|
||||
assert(memcmp(buffer+4, "fffffffff", 9) == 0);
|
||||
assert(memcmp(buffer+13, "ccccc", 5) == 0);
|
||||
memcmp(buffer, "aaaa", 4) => 0;
|
||||
memcmp(buffer+4, "fffffffff", 9) => 0;
|
||||
memcmp(buffer+13, "ccccc", 5) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "hello/hello", LFS_O_RDONLY) => 0;
|
||||
lfs_file_read(&lfs, &file, buffer, sizeof(buffer)) => strlen("hello");
|
||||
assert(memcmp(buffer, "hillo", strlen("hello")) == 0);
|
||||
memcmp(buffer, "hello", strlen("hello")) => 0;
|
||||
lfs_file_close(&lfs, &file);
|
||||
lfs_unmount(&lfs) => 0;
|
||||
'''
|
||||
@@ -287,16 +287,17 @@ code = '''
|
||||
lfs_getattr(&lfs, "hello/hello", 'B', buffer, 9) => 9;
|
||||
lfs_getattr(&lfs, "hello/hello", 'C', buffer+9, 9) => 5;
|
||||
lfs_getattr(&lfs, "hello/hello", 'D', buffer+18, 9) => LFS_ERR_NOATTR;
|
||||
assert(memcmp(buffer, "fffffffff", 9) == 0);
|
||||
assert(memcmp(buffer+9, "ccccc", 5) == 0);
|
||||
memcmp(buffer, "fffffffff", 9) => 0;
|
||||
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_write(&lfs, &file, "hi", 2) => 2;
|
||||
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;
|
||||
assert(memcmp(buffer, "gggg", 4) == 0);
|
||||
assert(memcmp(buffer+18, "hhhh", 4) == 0);
|
||||
memcmp(buffer, "gggg\0\0\0\0\0", 9) => 0;
|
||||
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;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
|
||||
@@ -3,13 +3,13 @@ code = '''
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
'''
|
||||
@@ -28,19 +28,19 @@ code = '''
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
for (int i = 0; i < N; i++) {
|
||||
sprintf(path, "dir%03d", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, path) == 0);
|
||||
}
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
'''
|
||||
@@ -59,19 +59,19 @@ code = '''
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
for (int i = 0; i < N; i++) {
|
||||
sprintf(path, "removeme%03d", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, path) == 0);
|
||||
}
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_unmount(&lfs);
|
||||
|
||||
@@ -84,13 +84,13 @@ code = '''
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
'''
|
||||
@@ -109,19 +109,19 @@ code = '''
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
for (int i = 0; i < N; i++) {
|
||||
sprintf(path, "test%03d", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, path) == 0);
|
||||
}
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_unmount(&lfs);
|
||||
|
||||
@@ -137,19 +137,19 @@ code = '''
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
for (int i = 0; i < N; i++) {
|
||||
sprintf(path, "tedd%03d", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, path) == 0);
|
||||
}
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_unmount(&lfs);
|
||||
'''
|
||||
@@ -177,19 +177,19 @@ code = '''
|
||||
}
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
for (int i = 0; i < N; i++) {
|
||||
sprintf(path, "hi%03d", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, path) == 0);
|
||||
}
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
for (int i = 0; i < N; i++) {
|
||||
@@ -202,19 +202,19 @@ code = '''
|
||||
}
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
for (int i = 0; i < N; i++) {
|
||||
sprintf(path, "hello%03d", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, path) == 0);
|
||||
}
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
for (int i = 0; i < N; i++) {
|
||||
@@ -223,13 +223,13 @@ code = '''
|
||||
}
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
'''
|
||||
@@ -250,19 +250,19 @@ code = '''
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
for (int i = 0; i < N; i++) {
|
||||
sprintf(path, "file%03d", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(strcmp(info.name, path) == 0);
|
||||
}
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_unmount(&lfs);
|
||||
'''
|
||||
@@ -283,19 +283,19 @@ code = '''
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
for (int i = 0; i < N; i++) {
|
||||
sprintf(path, "removeme%03d", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(strcmp(info.name, path) == 0);
|
||||
}
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_unmount(&lfs);
|
||||
|
||||
@@ -308,13 +308,13 @@ code = '''
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
'''
|
||||
@@ -335,19 +335,19 @@ code = '''
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
for (int i = 0; i < N; i++) {
|
||||
sprintf(path, "test%03d", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(strcmp(info.name, path) == 0);
|
||||
}
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_unmount(&lfs);
|
||||
|
||||
@@ -363,19 +363,19 @@ code = '''
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
for (int i = 0; i < N; i++) {
|
||||
sprintf(path, "tedd%03d", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(strcmp(info.name, path) == 0);
|
||||
}
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_unmount(&lfs);
|
||||
'''
|
||||
@@ -403,19 +403,19 @@ code = '''
|
||||
}
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
for (int i = 0; i < N; i++) {
|
||||
sprintf(path, "hi%03d", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(strcmp(info.name, path) == 0);
|
||||
}
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
for (int i = 0; i < N; i++) {
|
||||
@@ -428,19 +428,19 @@ code = '''
|
||||
}
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
for (int i = 0; i < N; i++) {
|
||||
sprintf(path, "hello%03d", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(strcmp(info.name, path) == 0);
|
||||
}
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
for (int i = 0; i < N; i++) {
|
||||
@@ -449,13 +449,13 @@ code = '''
|
||||
}
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
'''
|
||||
@@ -478,22 +478,22 @@ code = '''
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "potato") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "baked") == 0);
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "fried") == 0);
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "sweet") == 0);
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
|
||||
@@ -538,22 +538,22 @@ code = '''
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "hotpotato") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "baked") == 0);
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "fried") == 0);
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "sweet") == 0);
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
|
||||
@@ -570,16 +570,16 @@ code = '''
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
info.type => LFS_TYPE_DIR;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "burito") == 0);
|
||||
info.type => LFS_TYPE_REG;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
'''
|
||||
@@ -595,19 +595,19 @@ code = '''
|
||||
lfs_mkdir(&lfs, path) => 0;
|
||||
}
|
||||
lfs_dir_open(&lfs, &dir, "prickly-pear") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
for (int i = 0; i < N; i++) {
|
||||
sprintf(path, "cactus%03d", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, path) == 0);
|
||||
}
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_unmount(&lfs);
|
||||
|
||||
@@ -615,21 +615,21 @@ code = '''
|
||||
lfs_remove(&lfs, "prickly-pear") => LFS_ERR_NOTEMPTY;
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "prickly-pear") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
for (int i = 0; i < N; i++) {
|
||||
sprintf(path, "cactus%03d", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, path) == 0);
|
||||
sprintf(path, "prickly-pear/%s", info.name);
|
||||
lfs_remove(&lfs, path) => 0;
|
||||
}
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_remove(&lfs, "prickly-pear") => 0;
|
||||
@@ -678,19 +678,19 @@ code = '''
|
||||
|
||||
// check that errors did not corrupt directory
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(strcmp(info.name, "burito") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, "potato") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_unmount(&lfs) => 0;
|
||||
@@ -698,19 +698,19 @@ code = '''
|
||||
// or on disk
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(strcmp(info.name, "burito") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, "potato") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
'''
|
||||
@@ -730,17 +730,17 @@ code = '''
|
||||
for (int j = 2; j < COUNT; j++) {
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "hello") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
|
||||
lfs_soff_t pos;
|
||||
for (int i = 0; i < j; i++) {
|
||||
sprintf(path, "kitty%03d", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, path) == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
pos = lfs_dir_tell(&lfs, &dir);
|
||||
@@ -749,25 +749,25 @@ code = '''
|
||||
|
||||
lfs_dir_seek(&lfs, &dir, pos) => 0;
|
||||
sprintf(path, "kitty%03d", j);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, path) == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
|
||||
lfs_dir_rewind(&lfs, &dir) => 0;
|
||||
sprintf(path, "kitty%03d", 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, path) == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
|
||||
lfs_dir_seek(&lfs, &dir, pos) => 0;
|
||||
sprintf(path, "kitty%03d", j);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, path) == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
|
||||
@@ -790,17 +790,17 @@ code = '''
|
||||
for (int j = 2; j < COUNT; j++) {
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
|
||||
lfs_soff_t pos;
|
||||
for (int i = 0; i < j; i++) {
|
||||
sprintf(path, "hi%03d", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, path) == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
pos = lfs_dir_tell(&lfs, &dir);
|
||||
@@ -809,25 +809,25 @@ code = '''
|
||||
|
||||
lfs_dir_seek(&lfs, &dir, pos) => 0;
|
||||
sprintf(path, "hi%03d", j);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, path) == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
|
||||
lfs_dir_rewind(&lfs, &dir) => 0;
|
||||
sprintf(path, "hi%03d", 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, path) == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
|
||||
lfs_dir_seek(&lfs, &dir, pos) => 0;
|
||||
sprintf(path, "hi%03d", j);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, path) == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
|
||||
[[case]] # interspersed file test
|
||||
define.SIZE = [10, 100]
|
||||
define.FILES = [4, 10, 26]
|
||||
define.FILES = [4, 10, 26]
|
||||
code = '''
|
||||
lfs_file_t files[FILES];
|
||||
const char alphas[] = "abcdefghijklmnopqrstuvwxyz";
|
||||
@@ -24,20 +24,20 @@ code = '''
|
||||
}
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
for (int j = 0; j < FILES; j++) {
|
||||
sprintf(path, "%c", alphas[j]);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, path) == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == SIZE);
|
||||
}
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
for (int j = 0; j < FILES; j++) {
|
||||
@@ -55,7 +55,7 @@ code = '''
|
||||
for (int j = 0; j < FILES; j++) {
|
||||
lfs_file_close(&lfs, &files[j]);
|
||||
}
|
||||
|
||||
|
||||
lfs_unmount(&lfs) => 0;
|
||||
'''
|
||||
|
||||
@@ -89,17 +89,17 @@ code = '''
|
||||
lfs_file_close(&lfs, &file);
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "zzz") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == FILES);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "zzz", LFS_O_RDONLY) => 0;
|
||||
@@ -108,7 +108,7 @@ code = '''
|
||||
assert(buffer[0] == '~');
|
||||
}
|
||||
lfs_file_close(&lfs, &file);
|
||||
|
||||
|
||||
lfs_unmount(&lfs) => 0;
|
||||
'''
|
||||
|
||||
@@ -141,21 +141,21 @@ code = '''
|
||||
lfs_file_close(&lfs, &files[2]);
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "e") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == SIZE);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "g") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == SIZE);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &files[0], "e", LFS_O_RDONLY) => 0;
|
||||
@@ -168,13 +168,13 @@ code = '''
|
||||
}
|
||||
lfs_file_close(&lfs, &files[0]);
|
||||
lfs_file_close(&lfs, &files[1]);
|
||||
|
||||
|
||||
lfs_unmount(&lfs) => 0;
|
||||
'''
|
||||
|
||||
[[case]] # reentrant interspersed file test
|
||||
define.SIZE = [10, 100]
|
||||
define.FILES = [4, 10, 26]
|
||||
define.FILES = [4, 10, 26]
|
||||
reentrant = true
|
||||
code = '''
|
||||
lfs_file_t files[FILES];
|
||||
@@ -208,20 +208,20 @@ code = '''
|
||||
}
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
for (int j = 0; j < FILES; j++) {
|
||||
sprintf(path, "%c", alphas[j]);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, path) == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == SIZE);
|
||||
}
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
for (int j = 0; j < FILES; j++) {
|
||||
@@ -239,698 +239,6 @@ code = '''
|
||||
for (int j = 0; j < FILES; j++) {
|
||||
lfs_file_close(&lfs, &files[j]);
|
||||
}
|
||||
|
||||
lfs_unmount(&lfs) => 0;
|
||||
'''
|
||||
|
||||
[[case]] # open same file reading from separate file handles
|
||||
define.READERS = 3
|
||||
define.SIZE = [10, 100, 1000, 10000]
|
||||
define.RDMODE = ['LFS_O_RDONLY', 'LFS_O_RDWR']
|
||||
code = '''
|
||||
const char alphas[] = "abcdefghijklmnopqrstuvwxyz";
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "shared", LFS_O_CREAT | LFS_O_WRONLY) => 0;
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_write(&lfs, &file, &alphas[j % 26], 1) => 1;
|
||||
}
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
|
||||
// open all files
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_t readers[READERS];
|
||||
for (int i = 0; i < READERS; i++) {
|
||||
lfs_file_open(&lfs, &readers[i], "shared", RDMODE) => 0;
|
||||
}
|
||||
|
||||
// perform operations while all readers are open
|
||||
for (int i = 0; i < READERS; i++) {
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_read(&lfs, &readers[i], buffer, 1) => 1;
|
||||
assert(buffer[0] == alphas[j % 26]);
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i < READERS; i++) {
|
||||
lfs_file_close(&lfs, &readers[i]) => 0;
|
||||
}
|
||||
lfs_unmount(&lfs) => 0;
|
||||
'''
|
||||
|
||||
[[case]] # open same file reading and writing from separate file handles
|
||||
define.READERS = 3
|
||||
define.SIZE = [10, 100, 1000, 10000]
|
||||
define.RDMODE = ['LFS_O_RDONLY', 'LFS_O_RDWR']
|
||||
define.WRMODE = ['LFS_O_WRONLY', 'LFS_O_RDWR']
|
||||
code = '''
|
||||
const char alphas[] = "abcdefghijklmnopqrstuvwxyz";
|
||||
const char nums[] = "0123456789";
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, "shared", LFS_O_CREAT | LFS_O_WRONLY) => 0;
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_write(&lfs, &file, &alphas[j % 26], 1) => 1;
|
||||
}
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
|
||||
// open all files
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_t writer;
|
||||
lfs_file_t readers[READERS];
|
||||
lfs_file_open(&lfs, &writer, "shared", WRMODE) => 0;
|
||||
for (int i = 0; i < READERS; i++) {
|
||||
lfs_file_open(&lfs, &readers[i], "shared", RDMODE) => 0;
|
||||
}
|
||||
|
||||
// perform operations while all readers are open
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_write(&lfs, &writer, &nums[j % 10], 1) => 1;
|
||||
}
|
||||
|
||||
for (int i = 0; i < READERS; i++) {
|
||||
for (int j = 0; j < SIZE/2; j++) {
|
||||
lfs_file_read(&lfs, &readers[i], buffer, 1) => 1;
|
||||
assert(buffer[0] == alphas[j % 26]);
|
||||
}
|
||||
}
|
||||
|
||||
// sync, now write should reflect in all open files
|
||||
lfs_file_sync(&lfs, &writer) => 0;
|
||||
|
||||
for (int i = 0; i < READERS; i++) {
|
||||
for (int j = SIZE/2; j < SIZE; j++) {
|
||||
lfs_file_read(&lfs, &readers[i], buffer, 1) => 1;
|
||||
assert(buffer[0] == nums[j % 10]);
|
||||
}
|
||||
}
|
||||
|
||||
// double check our writer reflects its own changes
|
||||
if (WRMODE == LFS_O_RDWR) {
|
||||
lfs_file_rewind(&lfs, &writer) => 0;
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_read(&lfs, &writer, buffer, 1) => 1;
|
||||
assert(buffer[0] == nums[j % 10]);
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = 0; i < READERS; i++) {
|
||||
lfs_file_close(&lfs, &readers[i]) => 0;
|
||||
}
|
||||
lfs_unmount(&lfs) => 0;
|
||||
'''
|
||||
|
||||
[[case]] # check that attributes are updated in open files
|
||||
define.READERS = 3
|
||||
define.SIZE = 10
|
||||
define.RDMODE = ['LFS_O_RDONLY', 'LFS_O_RDWR']
|
||||
define.WRMODE = ['LFS_O_WRONLY', 'LFS_O_RDWR']
|
||||
code = '''
|
||||
const char alphas[] = "abcdefghijklmnopqrstuvwxyz";
|
||||
const char nums[] = "0123456789";
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
const struct lfs_file_config filecfg = {
|
||||
.attr_count = 3,
|
||||
.attrs = (struct lfs_attr[]){
|
||||
{'A', "a", 1},
|
||||
{'B', "bb", 2},
|
||||
{'C', "ccc", 3},
|
||||
},
|
||||
};
|
||||
lfs_file_opencfg(&lfs, &file, "shared",
|
||||
LFS_O_CREAT | LFS_O_WRONLY, &filecfg) => 0;
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_write(&lfs, &file, &alphas[j % 26], 1) => 1;
|
||||
}
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
|
||||
// open all files
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_t writer;
|
||||
const struct lfs_file_config writercfg = {
|
||||
.attr_count = 3,
|
||||
.attrs = (struct lfs_attr[]){
|
||||
{'A', &(uint8_t[1]){0}, 1},
|
||||
{'B', &(uint8_t[2]){0}, 2},
|
||||
{'C', &(uint8_t[3]){0}, 3}}};
|
||||
lfs_file_t readers[READERS];
|
||||
const struct lfs_file_config readercfgs[READERS] = {
|
||||
{ .attr_count = 3,
|
||||
.attrs = (struct lfs_attr[]){
|
||||
{'A', &(uint8_t[1]){0}, 1},
|
||||
{'B', &(uint8_t[2]){0}, 2},
|
||||
{'C', &(uint8_t[3]){0}, 3}}},
|
||||
{ .attr_count = 3,
|
||||
.attrs = (struct lfs_attr[]){
|
||||
{'A', &(uint8_t[1]){0}, 1},
|
||||
{'B', &(uint8_t[2]){0}, 2},
|
||||
{'C', &(uint8_t[3]){0}, 3}}},
|
||||
{ .attr_count = 3,
|
||||
.attrs = (struct lfs_attr[]){
|
||||
{'A', &(uint8_t[1]){0}, 1},
|
||||
{'B', &(uint8_t[2]){0}, 2},
|
||||
{'C', &(uint8_t[3]){0}, 3}}}};
|
||||
lfs_file_opencfg(&lfs, &writer, "shared",
|
||||
WRMODE, &writercfg) => 0;
|
||||
for (int i = 0; i < READERS; i++) {
|
||||
lfs_file_opencfg(&lfs, &readers[i], "shared",
|
||||
RDMODE, &readercfgs[i]) => 0;
|
||||
}
|
||||
|
||||
// perform operations while all readers are open
|
||||
writercfg.attrs[0].size = 1;
|
||||
memcpy(writercfg.attrs[0].buffer, "0", 1);
|
||||
writercfg.attrs[1].size = 2;
|
||||
memcpy(writercfg.attrs[1].buffer, "11", 2);
|
||||
writercfg.attrs[2].size = 3;
|
||||
memcpy(writercfg.attrs[2].buffer, "222", 3);
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_write(&lfs, &writer, &nums[j % 10], 1) => 1;
|
||||
}
|
||||
|
||||
for (int i = 0; i < READERS; i++) {
|
||||
assert(readercfgs[i].attrs[0].size == 1);
|
||||
assert(memcmp(readercfgs[i].attrs[0].buffer, "a", 1) == 0);
|
||||
assert(readercfgs[i].attrs[1].size == 2);
|
||||
assert(memcmp(readercfgs[i].attrs[1].buffer, "bb", 2) == 0);
|
||||
assert(readercfgs[i].attrs[2].size == 3);
|
||||
assert(memcmp(readercfgs[i].attrs[2].buffer, "ccc", 3) == 0);
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_read(&lfs, &readers[i], buffer, 1) => 1;
|
||||
assert(buffer[0] == alphas[j % 26]);
|
||||
}
|
||||
}
|
||||
|
||||
// sync, now write should reflect in all open files
|
||||
lfs_file_sync(&lfs, &writer) => 0;
|
||||
|
||||
for (int i = 0; i < READERS; i++) {
|
||||
assert(readercfgs[i].attrs[0].size == 1);
|
||||
assert(memcmp(readercfgs[i].attrs[0].buffer, "0", 1) == 0);
|
||||
assert(readercfgs[i].attrs[1].size == 2);
|
||||
assert(memcmp(readercfgs[i].attrs[1].buffer, "11", 2) == 0);
|
||||
assert(readercfgs[i].attrs[2].size == 3);
|
||||
assert(memcmp(readercfgs[i].attrs[2].buffer, "222", 3) == 0);
|
||||
lfs_file_rewind(&lfs, &readers[i]) => 0;
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_read(&lfs, &readers[i], buffer, 1) => 1;
|
||||
assert(buffer[0] == nums[j % 10]);
|
||||
}
|
||||
}
|
||||
|
||||
// double check our writer reflects its own changes
|
||||
if (WRMODE == LFS_O_RDWR) {
|
||||
assert(writercfg.attrs[0].size == 1);
|
||||
assert(memcmp(writercfg.attrs[0].buffer, "0", 1) == 0);
|
||||
assert(writercfg.attrs[1].size == 2);
|
||||
assert(memcmp(writercfg.attrs[1].buffer, "11", 2) == 0);
|
||||
assert(writercfg.attrs[2].size == 3);
|
||||
assert(memcmp(writercfg.attrs[2].buffer, "222", 3) == 0);
|
||||
lfs_file_rewind(&lfs, &writer) => 0;
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_read(&lfs, &writer, buffer, 1) => 1;
|
||||
assert(buffer[0] == nums[j % 10]);
|
||||
}
|
||||
}
|
||||
|
||||
// now try explicit lfs_setattr calls, this should still update open files
|
||||
lfs_setattr(&lfs, "shared", 'A', "A", 1) => 0;
|
||||
lfs_setattr(&lfs, "shared", 'B', "BB", 2) => 0;
|
||||
lfs_setattr(&lfs, "shared", 'C', "CCC", 3) => 0;
|
||||
|
||||
for (int i = 0; i < READERS; i++) {
|
||||
assert(readercfgs[i].attrs[0].size == 1);
|
||||
assert(memcmp(readercfgs[i].attrs[0].buffer, "A", 1) == 0);
|
||||
assert(readercfgs[i].attrs[1].size == 2);
|
||||
assert(memcmp(readercfgs[i].attrs[1].buffer, "BB", 2) == 0);
|
||||
assert(readercfgs[i].attrs[2].size == 3);
|
||||
assert(memcmp(readercfgs[i].attrs[2].buffer, "CCC", 3) == 0);
|
||||
lfs_file_rewind(&lfs, &readers[i]) => 0;
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_read(&lfs, &readers[i], buffer, 1) => 1;
|
||||
assert(buffer[0] == nums[j % 10]);
|
||||
}
|
||||
}
|
||||
|
||||
if (WRMODE == LFS_O_RDWR) {
|
||||
assert(writercfg.attrs[0].size == 1);
|
||||
assert(memcmp(writercfg.attrs[0].buffer, "A", 1) == 0);
|
||||
assert(writercfg.attrs[1].size == 2);
|
||||
assert(memcmp(writercfg.attrs[1].buffer, "BB", 2) == 0);
|
||||
assert(writercfg.attrs[2].size == 3);
|
||||
assert(memcmp(writercfg.attrs[2].buffer, "CCC", 3) == 0);
|
||||
lfs_file_rewind(&lfs, &writer) => 0;
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_read(&lfs, &writer, buffer, 1) => 1;
|
||||
assert(buffer[0] == nums[j % 10]);
|
||||
}
|
||||
} else if (WRMODE == LFS_O_WRONLY) {
|
||||
// this should NOT update wronly attributes, these may be
|
||||
// stored in read-only memory
|
||||
assert(writercfg.attrs[0].size == 1);
|
||||
assert(memcmp(writercfg.attrs[0].buffer, "0", 1) == 0);
|
||||
assert(writercfg.attrs[1].size == 2);
|
||||
assert(memcmp(writercfg.attrs[1].buffer, "11", 2) == 0);
|
||||
assert(writercfg.attrs[2].size == 3);
|
||||
assert(memcmp(writercfg.attrs[2].buffer, "222", 3) == 0);
|
||||
}
|
||||
|
||||
for (int i = 0; i < READERS; i++) {
|
||||
lfs_file_close(&lfs, &readers[i]) => 0;
|
||||
}
|
||||
lfs_unmount(&lfs) => 0;
|
||||
'''
|
||||
|
||||
[[case]] # simple snapshot for reading
|
||||
define.SIZE = [10, 100, 1000, 10000]
|
||||
code = '''
|
||||
const char alphas[] = "abcdefghijklmnopqrstuvwxyz";
|
||||
const char nums[] = "0123456789";
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
const struct lfs_file_config filecfg = {
|
||||
.attr_count = 1,
|
||||
.attrs = (struct lfs_attr[]){
|
||||
{'A', "abcd", 4},
|
||||
},
|
||||
};
|
||||
lfs_file_opencfg(&lfs, &file, "open_me",
|
||||
LFS_O_CREAT | LFS_O_WRONLY, &filecfg) => 0;
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_write(&lfs, &file, &alphas[j % 26], 1) => 1;
|
||||
}
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
|
||||
// open reader/writer/snapshot
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_t reader;
|
||||
const struct lfs_file_config readercfg = {
|
||||
.attr_count = 1,
|
||||
.attrs = (struct lfs_attr[]){
|
||||
{'A', &(uint8_t[4]){0}, 4}
|
||||
},
|
||||
};
|
||||
lfs_file_t writer;
|
||||
const struct lfs_file_config writercfg = {
|
||||
.attr_count = 1,
|
||||
.attrs = (struct lfs_attr[]){
|
||||
{'A', &(uint8_t[4]){0}, 4}
|
||||
},
|
||||
};
|
||||
lfs_file_t snapshot;
|
||||
const struct lfs_file_config snapshotcfg = {
|
||||
.attr_count = 1,
|
||||
.attrs = (struct lfs_attr[]){
|
||||
{'A', &(uint8_t[4]){0}, 4}
|
||||
},
|
||||
};
|
||||
lfs_file_opencfg(&lfs, &reader, "open_me",
|
||||
LFS_O_RDONLY, &readercfg) => 0;
|
||||
lfs_file_opencfg(&lfs, &writer, "open_me",
|
||||
LFS_O_WRONLY, &writercfg) => 0;
|
||||
lfs_file_opencfg(&lfs, &snapshot, "open_me",
|
||||
LFS_O_RDONLY | LFS_O_SNAPSHOT, &snapshotcfg) => 0;
|
||||
|
||||
assert(memcmp(readercfg.attrs[0].buffer, "abcd", 4) == 0);
|
||||
for (int j = 0; j < SIZE/2; j++) {
|
||||
lfs_file_read(&lfs, &reader, buffer, 1) => 1;
|
||||
assert(buffer[0] == alphas[j % 26]);
|
||||
}
|
||||
|
||||
assert(memcmp(snapshotcfg.attrs[0].buffer, "abcd", 4) == 0);
|
||||
for (int j = 0; j < SIZE/2; j++) {
|
||||
lfs_file_read(&lfs, &snapshot, buffer, 1) => 1;
|
||||
assert(buffer[0] == alphas[j % 26]);
|
||||
}
|
||||
|
||||
// write file
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_write(&lfs, &writer, &nums[j % 10], 1) => 1;
|
||||
}
|
||||
memcpy(writercfg.attrs[0].buffer, "0123", 4);
|
||||
lfs_file_sync(&lfs, &writer) => 0;
|
||||
|
||||
// reader should change
|
||||
assert(memcmp(readercfg.attrs[0].buffer, "0123", 4) == 0);
|
||||
for (int j = SIZE/2; j < SIZE; j++) {
|
||||
lfs_file_read(&lfs, &reader, buffer, 1) => 1;
|
||||
assert(buffer[0] == nums[j % 10]);
|
||||
}
|
||||
|
||||
// snapshot should remain unchanged
|
||||
assert(memcmp(snapshotcfg.attrs[0].buffer, "abcd", 4) == 0);
|
||||
for (int j = SIZE/2; j < SIZE; j++) {
|
||||
lfs_file_read(&lfs, &snapshot, buffer, 1) => 1;
|
||||
assert(buffer[0] == alphas[j % 26]);
|
||||
}
|
||||
|
||||
lfs_file_close(&lfs, &reader) => 0;
|
||||
lfs_file_close(&lfs, &writer) => 0;
|
||||
lfs_file_close(&lfs, &snapshot) => 0;
|
||||
|
||||
// disk should change
|
||||
lfs_file_opencfg(&lfs, &reader, "open_me",
|
||||
LFS_O_RDONLY, &readercfg) => 0;
|
||||
assert(memcmp(readercfg.attrs[0].buffer, "0123", 4) == 0);
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_read(&lfs, &reader, buffer, 1) => 1;
|
||||
assert(buffer[0] == nums[j % 10]);
|
||||
}
|
||||
lfs_file_close(&lfs, &reader) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_opencfg(&lfs, &reader, "open_me",
|
||||
LFS_O_RDONLY, &readercfg) => 0;
|
||||
assert(memcmp(readercfg.attrs[0].buffer, "0123", 4) == 0);
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_read(&lfs, &reader, buffer, 1) => 1;
|
||||
assert(buffer[0] == nums[j % 10]);
|
||||
}
|
||||
lfs_file_close(&lfs, &reader) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
'''
|
||||
|
||||
[[case]] # simple snapshot for writing
|
||||
define.SIZE = [10, 100, 1000, 10000]
|
||||
code = '''
|
||||
const char alphas[] = "abcdefghijklmnopqrstuvwxyz";
|
||||
const char nums[] = "0123456789";
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
const struct lfs_file_config filecfg = {
|
||||
.attr_count = 1,
|
||||
.attrs = (struct lfs_attr[]){
|
||||
{'A', "abcd", 4},
|
||||
},
|
||||
};
|
||||
lfs_file_opencfg(&lfs, &file, "open_me",
|
||||
LFS_O_CREAT | LFS_O_WRONLY, &filecfg) => 0;
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_write(&lfs, &file, &alphas[j % 26], 1) => 1;
|
||||
}
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
|
||||
// open reader/snapshot
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_t reader;
|
||||
const struct lfs_file_config readercfg = {
|
||||
.attr_count = 1,
|
||||
.attrs = (struct lfs_attr[]){
|
||||
{'A', &(uint8_t[4]){0}, 4}
|
||||
},
|
||||
};
|
||||
lfs_file_t snapshot;
|
||||
const struct lfs_file_config snapshotcfg = {
|
||||
.attr_count = 1,
|
||||
.attrs = (struct lfs_attr[]){
|
||||
{'A', &(uint8_t[4]){0}, 4}
|
||||
},
|
||||
};
|
||||
lfs_file_opencfg(&lfs, &reader, "open_me",
|
||||
LFS_O_RDONLY, &readercfg) => 0;
|
||||
lfs_file_opencfg(&lfs, &snapshot, "open_me",
|
||||
LFS_O_RDWR | LFS_O_SNAPSHOT, &snapshotcfg) => 0;
|
||||
|
||||
assert(memcmp(readercfg.attrs[0].buffer, "abcd", 4) == 0);
|
||||
for (int j = 0; j < SIZE/2; j++) {
|
||||
lfs_file_read(&lfs, &reader, buffer, 1) => 1;
|
||||
assert(buffer[0] == alphas[j % 26]);
|
||||
}
|
||||
|
||||
assert(memcmp(snapshotcfg.attrs[0].buffer, "abcd", 4) == 0);
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_read(&lfs, &snapshot, buffer, 1) => 1;
|
||||
assert(buffer[0] == alphas[j % 26]);
|
||||
}
|
||||
|
||||
// modify snapshot
|
||||
lfs_file_rewind(&lfs, &snapshot) => 0;
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_write(&lfs, &snapshot, &nums[j % 10], 1) => 1;
|
||||
}
|
||||
memcpy(snapshotcfg.attrs[0].buffer, "0123", 4);
|
||||
|
||||
lfs_file_rewind(&lfs, &snapshot) => 0;
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_read(&lfs, &snapshot, buffer, 1) => 1;
|
||||
assert(buffer[0] == nums[j % 10]);
|
||||
}
|
||||
|
||||
lfs_file_sync(&lfs, &snapshot) => 0;
|
||||
|
||||
// reader should not change
|
||||
assert(memcmp(readercfg.attrs[0].buffer, "abcd", 4) == 0);
|
||||
for (int j = SIZE/2; j < SIZE; j++) {
|
||||
lfs_file_read(&lfs, &reader, buffer, 1) => 1;
|
||||
assert(buffer[0] == alphas[j % 26]);
|
||||
}
|
||||
|
||||
// snapshot should changed
|
||||
assert(memcmp(snapshotcfg.attrs[0].buffer, "0123", 4) == 0);
|
||||
lfs_file_rewind(&lfs, &snapshot) => 0;
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_read(&lfs, &snapshot, buffer, 1) => 1;
|
||||
assert(buffer[0] == nums[j % 10]);
|
||||
}
|
||||
|
||||
lfs_file_close(&lfs, &reader) => 0;
|
||||
lfs_file_close(&lfs, &snapshot) => 0;
|
||||
|
||||
// disk should not change
|
||||
lfs_file_opencfg(&lfs, &reader, "open_me",
|
||||
LFS_O_RDONLY, &readercfg) => 0;
|
||||
assert(memcmp(readercfg.attrs[0].buffer, "abcd", 4) == 0);
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_read(&lfs, &reader, buffer, 1) => 1;
|
||||
assert(buffer[0] == alphas[j % 26]);
|
||||
}
|
||||
lfs_file_close(&lfs, &reader) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_opencfg(&lfs, &reader, "open_me",
|
||||
LFS_O_RDONLY, &readercfg) => 0;
|
||||
assert(memcmp(readercfg.attrs[0].buffer, "abcd", 4) == 0);
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_read(&lfs, &reader, buffer, 1) => 1;
|
||||
assert(buffer[0] == alphas[j % 26]);
|
||||
}
|
||||
lfs_file_close(&lfs, &reader) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
'''
|
||||
|
||||
[[case]] # temporary files
|
||||
define.SIZE = [10, 100, 1000, 10000]
|
||||
define.TMP_PATH = 'range(4)'
|
||||
code = '''
|
||||
const char alphas[] = "abcdefghijklmnopqrstuvwxyz";
|
||||
const char nums[] = "0123456789";
|
||||
const char caps[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
const struct lfs_file_config filecfg = {
|
||||
.attr_count = 1,
|
||||
.attrs = (struct lfs_attr[]){
|
||||
{'A', "abcd", 4},
|
||||
},
|
||||
};
|
||||
lfs_file_opencfg(&lfs, &file, "open_me",
|
||||
LFS_O_CREAT | LFS_O_WRONLY, &filecfg) => 0;
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_write(&lfs, &file, &alphas[j % 26], 1) => 1;
|
||||
}
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_file_opencfg(&lfs, &file, "dont_open_me",
|
||||
LFS_O_CREAT | LFS_O_WRONLY, &filecfg) => 0;
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_write(&lfs, &file, &alphas[j % 26], 1) => 1;
|
||||
}
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
|
||||
// open reader/writer/temp
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_t reader;
|
||||
const struct lfs_file_config readercfg = {
|
||||
.attr_count = 1,
|
||||
.attrs = (struct lfs_attr[]){
|
||||
{'A', &(uint8_t[4]){0}, 4}
|
||||
},
|
||||
};
|
||||
lfs_file_t writer;
|
||||
const struct lfs_file_config writercfg = {
|
||||
.attr_count = 1,
|
||||
.attrs = (struct lfs_attr[]){
|
||||
{'A', &(uint8_t[4]){0}, 4}
|
||||
},
|
||||
};
|
||||
lfs_file_t tmp;
|
||||
const struct lfs_file_config tmpcfg = {
|
||||
.attr_count = 1,
|
||||
.attrs = (struct lfs_attr[]){
|
||||
{'A', &(uint8_t[4]){0}, 4}
|
||||
},
|
||||
};
|
||||
lfs_file_opencfg(&lfs, &reader, "open_me",
|
||||
LFS_O_RDONLY, &readercfg) => 0;
|
||||
lfs_file_opencfg(&lfs, &writer, "open_me",
|
||||
LFS_O_WRONLY, &writercfg) => 0;
|
||||
const char *tmp_paths[] = {NULL, "/", "/tmp", "/open_me.tmp"};
|
||||
lfs_file_opencfg(&lfs, &tmp, tmp_paths[TMP_PATH],
|
||||
LFS_O_RDWR | LFS_O_CREAT | LFS_O_SNAPSHOT, &tmpcfg) => 0;
|
||||
|
||||
assert(memcmp(readercfg.attrs[0].buffer, "abcd", 4) == 0);
|
||||
for (int j = 0; j < SIZE/3; j++) {
|
||||
lfs_file_read(&lfs, &reader, buffer, 1) => 1;
|
||||
assert(buffer[0] == alphas[j % 26]);
|
||||
}
|
||||
|
||||
assert(memcmp(tmpcfg.attrs[0].buffer, "\0\0\0\0", 4) == 0);
|
||||
assert(lfs_file_size(&lfs, &tmp) == 0);
|
||||
|
||||
// write to tmp
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_write(&lfs, &tmp, &nums[j % 10], 1) => 1;
|
||||
}
|
||||
memcpy(tmpcfg.attrs[0].buffer, "0123", 4);
|
||||
|
||||
lfs_file_rewind(&lfs, &tmp) => 0;
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_read(&lfs, &tmp, buffer, 1) => 1;
|
||||
assert(buffer[0] == nums[j % 10]);
|
||||
}
|
||||
|
||||
lfs_file_sync(&lfs, &tmp) => 0;
|
||||
|
||||
// reader should not change
|
||||
assert(memcmp(readercfg.attrs[0].buffer, "abcd", 4) == 0);
|
||||
for (int j = SIZE/3; j < 2*SIZE/3; j++) {
|
||||
lfs_file_read(&lfs, &reader, buffer, 1) => 1;
|
||||
assert(buffer[0] == alphas[j % 26]);
|
||||
}
|
||||
|
||||
// tmp should change
|
||||
assert(memcmp(tmpcfg.attrs[0].buffer, "0123", 4) == 0);
|
||||
lfs_file_rewind(&lfs, &tmp) => 0;
|
||||
for (int j = 0; j < SIZE/2; j++) {
|
||||
lfs_file_read(&lfs, &tmp, buffer, 1) => 1;
|
||||
assert(buffer[0] == nums[j % 10]);
|
||||
}
|
||||
|
||||
// write to file
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_write(&lfs, &writer, &caps[j % 26], 1) => 1;
|
||||
}
|
||||
memcpy(writercfg.attrs[0].buffer, "ABCD", 4);
|
||||
lfs_file_sync(&lfs, &writer) => 0;
|
||||
|
||||
// reader should change
|
||||
assert(memcmp(readercfg.attrs[0].buffer, "ABCD", 4) == 0);
|
||||
for (int j = 2*SIZE/3; j < SIZE; j++) {
|
||||
lfs_file_read(&lfs, &reader, buffer, 1) => 1;
|
||||
assert(buffer[0] == caps[j % 26]);
|
||||
}
|
||||
|
||||
// tmp should not change
|
||||
assert(memcmp(tmpcfg.attrs[0].buffer, "0123", 4) == 0);
|
||||
for (int j = SIZE/2; j < SIZE; j++) {
|
||||
lfs_file_read(&lfs, &tmp, buffer, 1) => 1;
|
||||
assert(buffer[0] == nums[j % 10]);
|
||||
}
|
||||
|
||||
lfs_file_close(&lfs, &reader) => 0;
|
||||
lfs_file_close(&lfs, &writer) => 0;
|
||||
lfs_file_close(&lfs, &tmp) => 0;
|
||||
|
||||
// tmp should not appear on disk
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(strcmp(info.name, "dont_open_me") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(strcmp(info.name, "open_me") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_file_opencfg(&lfs, &reader, "open_me",
|
||||
LFS_O_RDONLY, &readercfg) => 0;
|
||||
assert(memcmp(readercfg.attrs[0].buffer, "ABCD", 4) == 0);
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_read(&lfs, &reader, buffer, 1) => 1;
|
||||
assert(buffer[0] == caps[j % 26]);
|
||||
}
|
||||
lfs_file_close(&lfs, &reader) => 0;
|
||||
lfs_file_opencfg(&lfs, &reader, "dont_open_me",
|
||||
LFS_O_RDONLY, &readercfg) => 0;
|
||||
assert(memcmp(readercfg.attrs[0].buffer, "abcd", 4) == 0);
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_read(&lfs, &reader, buffer, 1) => 1;
|
||||
assert(buffer[0] == alphas[j % 26]);
|
||||
}
|
||||
lfs_file_close(&lfs, &reader) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(strcmp(info.name, "dont_open_me") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(strcmp(info.name, "open_me") == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_file_opencfg(&lfs, &reader, "open_me",
|
||||
LFS_O_RDONLY, &readercfg) => 0;
|
||||
assert(memcmp(readercfg.attrs[0].buffer, "ABCD", 4) == 0);
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_read(&lfs, &reader, buffer, 1) => 1;
|
||||
assert(buffer[0] == caps[j % 26]);
|
||||
}
|
||||
lfs_file_close(&lfs, &reader) => 0;
|
||||
lfs_file_opencfg(&lfs, &reader, "dont_open_me",
|
||||
LFS_O_RDONLY, &readercfg) => 0;
|
||||
assert(memcmp(readercfg.attrs[0].buffer, "abcd", 4) == 0);
|
||||
for (int j = 0; j < SIZE; j++) {
|
||||
lfs_file_read(&lfs, &reader, buffer, 1) => 1;
|
||||
assert(buffer[0] == alphas[j % 26]);
|
||||
}
|
||||
lfs_file_close(&lfs, &reader) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
'''
|
||||
|
||||
[[case]] # test snapshot open errors
|
||||
code = '''
|
||||
lfs_format(&lfs, &cfg) => 0;
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_file_open(&lfs, &file, NULL,
|
||||
LFS_O_RDWR | LFS_O_SNAPSHOT) => LFS_ERR_ISDIR;
|
||||
lfs_file_open(&lfs, &file, "/",
|
||||
LFS_O_RDWR | LFS_O_SNAPSHOT) => LFS_ERR_ISDIR;
|
||||
lfs_file_open(&lfs, &file, "/tmp",
|
||||
LFS_O_RDWR | LFS_O_SNAPSHOT) => LFS_ERR_NOENT;
|
||||
lfs_file_open(&lfs, &file, "/tmp/",
|
||||
LFS_O_RDWR | LFS_O_CREAT | LFS_O_SNAPSHOT) => LFS_ERR_NOENT;
|
||||
lfs_file_open(&lfs, &file, "/tmp/tmp",
|
||||
LFS_O_RDWR | LFS_O_CREAT | LFS_O_SNAPSHOT) => LFS_ERR_NOENT;
|
||||
|
||||
lfs_unmount(&lfs) => 0;
|
||||
'''
|
||||
|
||||
@@ -19,26 +19,26 @@ code = '''
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "a") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "c") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "c") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
assert(strcmp(info.name, "hello") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 5+8+6);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "a/hello", LFS_O_RDONLY) => LFS_ERR_NOENT;
|
||||
@@ -110,26 +110,26 @@ code = '''
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "a") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "c") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "c") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
assert(strcmp(info.name, "hello") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 5+8+6);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "a/hello", LFS_O_RDONLY) => LFS_ERR_NOENT;
|
||||
@@ -202,26 +202,26 @@ code = '''
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "a") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "hello") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 5+8+6);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "c") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "a/hello", LFS_O_RDONLY) => 0;
|
||||
@@ -299,26 +299,26 @@ code = '''
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "a") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "c") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "c") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
assert(strcmp(info.name, "hello") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 5+8+6);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "a/hello", LFS_O_RDONLY) => LFS_ERR_NOENT;
|
||||
@@ -409,26 +409,26 @@ code = '''
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "a") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "d") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "d") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
assert(strcmp(info.name, "hello") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 5+8+6);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "a/hello", LFS_O_RDONLY) => LFS_ERR_NOENT;
|
||||
@@ -465,46 +465,46 @@ code = '''
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "a") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "c") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "hi") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "a/hi") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir, "b/hi") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir, "c/hi") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "bonjour") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "hola") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "ohayo") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "d/hi") => LFS_ERR_NOENT;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
@@ -548,46 +548,46 @@ code = '''
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "a") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "c") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "hi") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "a/hi") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir, "b/hi") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir, "c/hi") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "bonjour") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "hola") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "ohayo") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "d/hi") => LFS_ERR_NOENT;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
@@ -648,44 +648,44 @@ code = '''
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "a") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "hi") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "c") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "a/hi") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "bonjour") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "hola") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "ohayo") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "b/hi") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir, "c/hi") => LFS_ERR_NOENT;
|
||||
@@ -753,46 +753,46 @@ code = '''
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "a") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "c") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "hi") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "a/hi") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir, "b/hi") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir, "c/hi") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "bonjour") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "hola") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "ohayo") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "d/hi") => LFS_ERR_NOENT;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
@@ -870,47 +870,47 @@ code = '''
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "a") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "d") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "hi") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "a/hi") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir, "b/hi") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir, "c/hi") => LFS_ERR_NOENT;
|
||||
lfs_dir_open(&lfs, &dir, "d/hi") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "bonjour") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "hola") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "ohayo") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
'''
|
||||
@@ -1025,29 +1025,29 @@ code = '''
|
||||
|
||||
// check that nothing was corrupted
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "0.before") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "2.in_between") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "3.move_me") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "4.after") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "/0.before", LFS_O_RDONLY) => 0;
|
||||
@@ -1084,29 +1084,29 @@ code = '''
|
||||
|
||||
// and check that nothing was corrupted again
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "0.before") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "1.move_me") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "2.in_between") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "4.after") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "/0.before", LFS_O_RDONLY) => 0;
|
||||
@@ -1176,29 +1176,29 @@ code = '''
|
||||
|
||||
// check that nothing was corrupted
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "0.before") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "2.in_between") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "3.move_me") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "4.after") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "/0.before", LFS_O_RDONLY) => 0;
|
||||
@@ -1241,29 +1241,29 @@ code = '''
|
||||
|
||||
// and check that nothing was corrupted again
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "0.before") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "1.move_me") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "2.in_between") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "4.after") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "/0.before", LFS_O_RDONLY) => 0;
|
||||
@@ -1341,59 +1341,59 @@ code = '''
|
||||
|
||||
// check that nothing was corrupted
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "dir.1") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "dir.2") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "/dir.1") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "0.before") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "2.after") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "/dir.2") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "0.before") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "1.move_me") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "2.after") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "/dir.1/0.before", LFS_O_RDONLY) => 0;
|
||||
@@ -1444,59 +1444,59 @@ code = '''
|
||||
|
||||
// and check that nothing was corrupted again
|
||||
lfs_dir_open(&lfs, &dir, "/") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "dir.1") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "dir.2") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "/dir.1") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "0.before") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "1.move_me") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 0);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "2.after") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "/dir.2") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "0.before") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "2.after") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "/dir.1/0.before", LFS_O_RDONLY) => 0;
|
||||
@@ -1594,46 +1594,46 @@ code = '''
|
||||
|
||||
// check that nothing was corrupted
|
||||
lfs_dir_open(&lfs, &dir, "/parent") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "0.before") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "2.after") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "child") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "/parent/child") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "0.before") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "1.move_me") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == sizeof("move me"));
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "2.after") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "/parent/0.before", LFS_O_RDONLY) => 0;
|
||||
@@ -1740,59 +1740,59 @@ code = '''
|
||||
|
||||
// check that nothing was corrupted
|
||||
lfs_dir_open(&lfs, &dir, "/parent") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "child") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "sibling") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "/parent/sibling") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "0.before") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "2.after") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "/parent/child") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, ".") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "..") == 0);
|
||||
assert(info.type == LFS_TYPE_DIR);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "0.before") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "1.move_me") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == sizeof("move me"));
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
assert(strcmp(info.name, "2.after") == 0);
|
||||
assert(info.type == LFS_TYPE_REG);
|
||||
assert(info.size == 7);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
lfs_file_open(&lfs, &file, "/parent/sibling/0.before", LFS_O_RDONLY) => 0;
|
||||
|
||||
@@ -95,9 +95,9 @@ code = '''
|
||||
|
||||
lfs_mkdir(&lfs, "coffee/../milk") => 0;
|
||||
lfs_stat(&lfs, "coffee/../milk", &info) => 0;
|
||||
assert(strcmp(info.name, "milk") == 0);
|
||||
strcmp(info.name, "milk") => 0;
|
||||
lfs_stat(&lfs, "milk", &info) => 0;
|
||||
assert(strcmp(info.name, "milk") == 0);
|
||||
strcmp(info.name, "milk") => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
'''
|
||||
|
||||
@@ -129,9 +129,9 @@ code = '''
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_mkdir(&lfs, ".milk") => 0;
|
||||
lfs_stat(&lfs, ".milk", &info) => 0;
|
||||
assert(strcmp(info.name, ".milk") == 0);
|
||||
strcmp(info.name, ".milk") => 0;
|
||||
lfs_stat(&lfs, "tea/.././.milk", &info) => 0;
|
||||
assert(strcmp(info.name, ".milk") == 0);
|
||||
strcmp(info.name, ".milk") => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
'''
|
||||
|
||||
@@ -149,13 +149,13 @@ code = '''
|
||||
lfs_mkdir(&lfs, "coffee/coldcoffee") => 0;
|
||||
|
||||
lfs_stat(&lfs, "coffee/../../../../../../tea/hottea", &info) => 0;
|
||||
assert(strcmp(info.name, "hottea") == 0);
|
||||
strcmp(info.name, "hottea") => 0;
|
||||
|
||||
lfs_mkdir(&lfs, "coffee/../../../../../../milk") => 0;
|
||||
lfs_stat(&lfs, "coffee/../../../../../../milk", &info) => 0;
|
||||
assert(strcmp(info.name, "milk") == 0);
|
||||
strcmp(info.name, "milk") => 0;
|
||||
lfs_stat(&lfs, "milk", &info) => 0;
|
||||
assert(strcmp(info.name, "milk") == 0);
|
||||
strcmp(info.name, "milk") => 0;
|
||||
lfs_unmount(&lfs) => 0;
|
||||
'''
|
||||
|
||||
|
||||
@@ -26,14 +26,14 @@ code = '''
|
||||
}
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "child") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
for (int i = 0; i < COUNT; i++) {
|
||||
sprintf(path, "test%03d_loooooooooooooooooong_name", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
strcmp(info.name, path) => 0;
|
||||
}
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
if (j == ITERATIONS-1) {
|
||||
@@ -49,14 +49,14 @@ code = '''
|
||||
|
||||
lfs_mount(&lfs, &cfg) => 0;
|
||||
lfs_dir_open(&lfs, &dir, "child") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
for (int i = 0; i < COUNT; i++) {
|
||||
sprintf(path, "test%03d_loooooooooooooooooong_name", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
strcmp(info.name, path) => 0;
|
||||
}
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
for (int i = 0; i < COUNT; i++) {
|
||||
sprintf(path, "child/test%03d_loooooooooooooooooong_name", i);
|
||||
@@ -92,11 +92,11 @@ code = '''
|
||||
}
|
||||
|
||||
lfs_dir_open(&lfs, &dir, "child") => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
for (int i = 0; i < COUNT; i++) {
|
||||
sprintf(path, "test%03d_loooooooooooooooooong_name", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
strcmp(info.name, path) => 0;
|
||||
info.size => 0;
|
||||
|
||||
@@ -105,14 +105,14 @@ code = '''
|
||||
lfs_file_write(&lfs, &file, "hi", 2) => 2;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
}
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
|
||||
lfs_dir_rewind(&lfs, &dir) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
for (int i = 0; i < COUNT; i++) {
|
||||
sprintf(path, "test%03d_loooooooooooooooooong_name", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
strcmp(info.name, path) => 0;
|
||||
info.size => 2;
|
||||
|
||||
@@ -121,18 +121,18 @@ code = '''
|
||||
lfs_file_write(&lfs, &file, "hi", 2) => 2;
|
||||
lfs_file_close(&lfs, &file) => 0;
|
||||
}
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
|
||||
lfs_dir_rewind(&lfs, &dir) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
for (int i = 0; i < COUNT; i++) {
|
||||
sprintf(path, "test%03d_loooooooooooooooooong_name", i);
|
||||
lfs_dir_read(&lfs, &dir, &info) => 1;
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
strcmp(info.name, path) => 0;
|
||||
info.size => 2;
|
||||
}
|
||||
lfs_dir_read(&lfs, &dir, &info) => 0;
|
||||
lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
|
||||
lfs_dir_close(&lfs, &dir) => 0;
|
||||
|
||||
for (int i = 0; i < COUNT; i++) {
|
||||
|
||||
Reference in New Issue
Block a user