github-mirrors/thirdparty-littlefs
1
0
Fork 0
mirror of https://github.com/eledio-devices/thirdparty-littlefs.git synced 2025-11-01 00:38:29 +01:00
Code Issues Packages Projects Releases Wiki Activity

Renamed all prefixes to include the major version

Browse Source 
This is needed to allow compilation of multiple versions in the same
binary. Also note that the FUSE testing was removed because of related
name issues.

./scripts/prefix.py lfs1
This commit is contained in:
Christopher Haster
2019-01-30 13:25:53 -06:00
parent 43f95b2882
commit daa6577060
25 changed files with 3973 additions and 4006 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
tests/template.fmt
View File

@@ -1,6 +1,6 @@
/// AUTOGENERATED TEST ///
#include "lfs.h"
#include "emubd/lfs_emubd.h"
#include "lfs1.h"
#include "emubd/lfs1_emubd.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
@@ -37,7 +37,7 @@ static void test_assert(const char *file, unsigned line,
// utility functions for traversals
static int __attribute__((used)) test_count(void *p, lfs_block_t b) {{
static int __attribute__((used)) test_count(void *p, lfs1_block_t b) {{
(void)b;
unsigned *u = (unsigned*)p;
*u += 1;
@@ -45,62 +45,62 @@ static int __attribute__((used)) test_count(void *p, lfs_block_t b) {{
}}
// lfs declarations
lfs_t lfs;
lfs_emubd_t bd;
lfs_file_t file[4];
lfs_dir_t dir[4];
struct lfs_info info;
// lfs1 declarations
lfs1_t lfs1;
lfs1_emubd_t bd;
lfs1_file_t file[4];
lfs1_dir_t dir[4];
struct lfs1_info info;
uint8_t buffer[1024];
uint8_t wbuffer[1024];
uint8_t rbuffer[1024];
lfs_size_t size;
lfs_size_t wsize;
lfs_size_t rsize;
lfs1_size_t size;
lfs1_size_t wsize;
lfs1_size_t rsize;
uintmax_t test;
#ifndef LFS_READ_SIZE
#define LFS_READ_SIZE 16
#ifndef LFS1_READ_SIZE
#define LFS1_READ_SIZE 16
#endif
#ifndef LFS_PROG_SIZE
#define LFS_PROG_SIZE 16
#ifndef LFS1_PROG_SIZE
#define LFS1_PROG_SIZE 16
#endif
#ifndef LFS_BLOCK_SIZE
#define LFS_BLOCK_SIZE 512
#ifndef LFS1_BLOCK_SIZE
#define LFS1_BLOCK_SIZE 512
#endif
#ifndef LFS_BLOCK_COUNT
#define LFS_BLOCK_COUNT 1024
#ifndef LFS1_BLOCK_COUNT
#define LFS1_BLOCK_COUNT 1024
#endif
#ifndef LFS_LOOKAHEAD
#define LFS_LOOKAHEAD 128
#ifndef LFS1_LOOKAHEAD
#define LFS1_LOOKAHEAD 128
#endif
const struct lfs_config cfg = {{
const struct lfs1_config cfg = {{
.context = &bd,
.read = &lfs_emubd_read,
.prog = &lfs_emubd_prog,
.erase = &lfs_emubd_erase,
.sync = &lfs_emubd_sync,
.read = &lfs1_emubd_read,
.prog = &lfs1_emubd_prog,
.erase = &lfs1_emubd_erase,
.sync = &lfs1_emubd_sync,
.read_size = LFS_READ_SIZE,
.prog_size = LFS_PROG_SIZE,
.block_size = LFS_BLOCK_SIZE,
.block_count = LFS_BLOCK_COUNT,
.lookahead = LFS_LOOKAHEAD,
.read_size = LFS1_READ_SIZE,
.prog_size = LFS1_PROG_SIZE,
.block_size = LFS1_BLOCK_SIZE,
.block_count = LFS1_BLOCK_COUNT,
.lookahead = LFS1_LOOKAHEAD,
}};
// Entry point
int main(void) {{
lfs_emubd_create(&cfg, "blocks");
lfs1_emubd_create(&cfg, "blocks");
{tests}
lfs_emubd_destroy(&cfg);
lfs1_emubd_destroy(&cfg);
}}

6
tests/test.py
View File

@@ -28,7 +28,7 @@ def generate(test):
# Remove build artifacts to force rebuild
try:
os.remove('test.o')
os.remove('lfs')
os.remove('lfs1')
except OSError:
pass
@@ -39,9 +39,9 @@ def compile():
def execute():
if 'EXEC' in os.environ:
subprocess.check_call([os.environ['EXEC'], "./lfs"])
subprocess.check_call([os.environ['EXEC'], "./lfs1"])
else:
subprocess.check_call(["./lfs"])
subprocess.check_call(["./lfs1"])
def main(test=None):
if test and not test.startswith('-'):

366
tests/test_alloc.sh
View File

@@ -4,424 +4,424 @@ set -eu
echo "=== Allocator tests ==="
rm -rf blocks
tests/test.py << TEST
lfs_format(&lfs, &cfg) => 0;
lfs1_format(&lfs1, &cfg) => 0;
TEST
SIZE=15000
lfs_mkdir() {
lfs1_mkdir() {
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_mkdir(&lfs, "$1") => 0;
lfs_unmount(&lfs) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_mkdir(&lfs1, "$1") => 0;
lfs1_unmount(&lfs1) => 0;
TEST
}
lfs_remove() {
lfs1_remove() {
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_remove(&lfs, "$1/eggs") => 0;
lfs_remove(&lfs, "$1/bacon") => 0;
lfs_remove(&lfs, "$1/pancakes") => 0;
lfs_remove(&lfs, "$1") => 0;
lfs_unmount(&lfs) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_remove(&lfs1, "$1/eggs") => 0;
lfs1_remove(&lfs1, "$1/bacon") => 0;
lfs1_remove(&lfs1, "$1/pancakes") => 0;
lfs1_remove(&lfs1, "$1") => 0;
lfs1_unmount(&lfs1) => 0;
TEST
}
lfs_alloc_singleproc() {
lfs1_alloc_singleproc() {
tests/test.py << TEST
const char *names[] = {"bacon", "eggs", "pancakes"};
lfs_mount(&lfs, &cfg) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
for (unsigned n = 0; n < sizeof(names)/sizeof(names[0]); n++) {
sprintf((char*)buffer, "$1/%s", names[n]);
lfs_file_open(&lfs, &file[n], (char*)buffer,
LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0;
lfs1_file_open(&lfs1, &file[n], (char*)buffer,
LFS1_O_WRONLY | LFS1_O_CREAT | LFS1_O_APPEND) => 0;
}
for (unsigned n = 0; n < sizeof(names)/sizeof(names[0]); n++) {
size = strlen(names[n]);
for (int i = 0; i < $SIZE; i++) {
lfs_file_write(&lfs, &file[n], names[n], size) => size;
lfs1_file_write(&lfs1, &file[n], names[n], size) => size;
}
}
for (unsigned n = 0; n < sizeof(names)/sizeof(names[0]); n++) {
lfs_file_close(&lfs, &file[n]) => 0;
lfs1_file_close(&lfs1, &file[n]) => 0;
}
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
}
lfs_alloc_multiproc() {
lfs1_alloc_multiproc() {
for name in bacon eggs pancakes
do
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_file_open(&lfs, &file[0], "$1/$name",
LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_file_open(&lfs1, &file[0], "$1/$name",
LFS1_O_WRONLY | LFS1_O_CREAT | LFS1_O_APPEND) => 0;
size = strlen("$name");
memcpy(buffer, "$name", size);
for (int i = 0; i < $SIZE; i++) {
lfs_file_write(&lfs, &file[0], buffer, size) => size;
lfs1_file_write(&lfs1, &file[0], buffer, size) => size;
}
lfs_file_close(&lfs, &file[0]) => 0;
lfs_unmount(&lfs) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
done
}
lfs_verify() {
lfs1_verify() {
for name in bacon eggs pancakes
do
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_file_open(&lfs, &file[0], "$1/$name", LFS_O_RDONLY) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_file_open(&lfs1, &file[0], "$1/$name", LFS1_O_RDONLY) => 0;
size = strlen("$name");
for (int i = 0; i < $SIZE; i++) {
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "$name", size) => 0;
}
lfs_file_close(&lfs, &file[0]) => 0;
lfs_unmount(&lfs) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
done
}
echo "--- Single-process allocation test ---"
lfs_mkdir singleproc
lfs_alloc_singleproc singleproc
lfs_verify singleproc
lfs1_mkdir singleproc
lfs1_alloc_singleproc singleproc
lfs1_verify singleproc
echo "--- Multi-process allocation test ---"
lfs_mkdir multiproc
lfs_alloc_multiproc multiproc
lfs_verify multiproc
lfs_verify singleproc
lfs1_mkdir multiproc
lfs1_alloc_multiproc multiproc
lfs1_verify multiproc
lfs1_verify singleproc
echo "--- Single-process reuse test ---"
lfs_remove singleproc
lfs_mkdir singleprocreuse
lfs_alloc_singleproc singleprocreuse
lfs_verify singleprocreuse
lfs_verify multiproc
lfs1_remove singleproc
lfs1_mkdir singleprocreuse
lfs1_alloc_singleproc singleprocreuse
lfs1_verify singleprocreuse
lfs1_verify multiproc
echo "--- Multi-process reuse test ---"
lfs_remove multiproc
lfs_mkdir multiprocreuse
lfs_alloc_singleproc multiprocreuse
lfs_verify multiprocreuse
lfs_verify singleprocreuse
lfs1_remove multiproc
lfs1_mkdir multiprocreuse
lfs1_alloc_singleproc multiprocreuse
lfs1_verify multiprocreuse
lfs1_verify singleprocreuse
echo "--- Cleanup ---"
lfs_remove multiprocreuse
lfs_remove singleprocreuse
lfs1_remove multiprocreuse
lfs1_remove singleprocreuse
echo "--- Exhaustion test ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_file_open(&lfs1, &file[0], "exhaustion", LFS1_O_WRONLY | LFS1_O_CREAT);
size = strlen("exhaustion");
memcpy(buffer, "exhaustion", size);
lfs_file_write(&lfs, &file[0], buffer, size) => size;
lfs_file_sync(&lfs, &file[0]) => 0;
lfs1_file_write(&lfs1, &file[0], buffer, size) => size;
lfs1_file_sync(&lfs1, &file[0]) => 0;
size = strlen("blahblahblahblah");
memcpy(buffer, "blahblahblahblah", size);
lfs_ssize_t res;
lfs1_ssize_t res;
while (true) {
res = lfs_file_write(&lfs, &file[0], buffer, size);
res = lfs1_file_write(&lfs1, &file[0], buffer, size);
if (res < 0) {
break;
}
res => size;
}
res => LFS_ERR_NOSPC;
res => LFS1_ERR_NOSPC;
lfs_file_close(&lfs, &file[0]) => 0;
lfs_unmount(&lfs) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_RDONLY);
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_file_open(&lfs1, &file[0], "exhaustion", LFS1_O_RDONLY);
size = strlen("exhaustion");
lfs_file_size(&lfs, &file[0]) => size;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_size(&lfs1, &file[0]) => size;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "exhaustion", size) => 0;
lfs_file_close(&lfs, &file[0]) => 0;
lfs_unmount(&lfs) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Exhaustion wraparound test ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_remove(&lfs, "exhaustion") => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_remove(&lfs1, "exhaustion") => 0;
lfs_file_open(&lfs, &file[0], "padding", LFS_O_WRONLY | LFS_O_CREAT);
lfs1_file_open(&lfs1, &file[0], "padding", LFS1_O_WRONLY | LFS1_O_CREAT);
size = strlen("buffering");
memcpy(buffer, "buffering", size);
for (int i = 0; i < $SIZE; i++) {
lfs_file_write(&lfs, &file[0], buffer, size) => size;
lfs1_file_write(&lfs1, &file[0], buffer, size) => size;
}
lfs_file_close(&lfs, &file[0]) => 0;
lfs_remove(&lfs, "padding") => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs1_remove(&lfs1, "padding") => 0;
lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
lfs1_file_open(&lfs1, &file[0], "exhaustion", LFS1_O_WRONLY | LFS1_O_CREAT);
size = strlen("exhaustion");
memcpy(buffer, "exhaustion", size);
lfs_file_write(&lfs, &file[0], buffer, size) => size;
lfs_file_sync(&lfs, &file[0]) => 0;
lfs1_file_write(&lfs1, &file[0], buffer, size) => size;
lfs1_file_sync(&lfs1, &file[0]) => 0;
size = strlen("blahblahblahblah");
memcpy(buffer, "blahblahblahblah", size);
lfs_ssize_t res;
lfs1_ssize_t res;
while (true) {
res = lfs_file_write(&lfs, &file[0], buffer, size);
res = lfs1_file_write(&lfs1, &file[0], buffer, size);
if (res < 0) {
break;
}
res => size;
}
res => LFS_ERR_NOSPC;
res => LFS1_ERR_NOSPC;
lfs_file_close(&lfs, &file[0]) => 0;
lfs_unmount(&lfs) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_RDONLY);
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_file_open(&lfs1, &file[0], "exhaustion", LFS1_O_RDONLY);
size = strlen("exhaustion");
lfs_file_size(&lfs, &file[0]) => size;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_size(&lfs1, &file[0]) => size;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "exhaustion", size) => 0;
lfs_file_close(&lfs, &file[0]) => 0;
lfs_unmount(&lfs) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Dir exhaustion test ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_remove(&lfs, "exhaustion") => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_remove(&lfs1, "exhaustion") => 0;
lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
lfs1_file_open(&lfs1, &file[0], "exhaustion", LFS1_O_WRONLY | LFS1_O_CREAT);
size = strlen("blahblahblahblah");
memcpy(buffer, "blahblahblahblah", size);
for (lfs_size_t i = 0;
for (lfs1_size_t i = 0;
i < (cfg.block_count-6)*(cfg.block_size-8);
i += size) {
lfs_file_write(&lfs, &file[0], buffer, size) => size;
lfs1_file_write(&lfs1, &file[0], buffer, size) => size;
}
lfs_file_close(&lfs, &file[0]) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs_mkdir(&lfs, "exhaustiondir") => 0;
lfs_remove(&lfs, "exhaustiondir") => 0;
lfs1_mkdir(&lfs1, "exhaustiondir") => 0;
lfs1_remove(&lfs1, "exhaustiondir") => 0;
lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_APPEND);
lfs1_file_open(&lfs1, &file[0], "exhaustion", LFS1_O_WRONLY | LFS1_O_APPEND);
size = strlen("blahblahblahblah");
memcpy(buffer, "blahblahblahblah", size);
for (lfs_size_t i = 0;
for (lfs1_size_t i = 0;
i < (cfg.block_size-8);
i += size) {
lfs_file_write(&lfs, &file[0], buffer, size) => size;
lfs1_file_write(&lfs1, &file[0], buffer, size) => size;
}
lfs_file_close(&lfs, &file[0]) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs_mkdir(&lfs, "exhaustiondir") => LFS_ERR_NOSPC;
lfs_unmount(&lfs) => 0;
lfs1_mkdir(&lfs1, "exhaustiondir") => LFS1_ERR_NOSPC;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Chained dir exhaustion test ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_remove(&lfs, "exhaustion") => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_remove(&lfs1, "exhaustion") => 0;
lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
lfs1_file_open(&lfs1, &file[0], "exhaustion", LFS1_O_WRONLY | LFS1_O_CREAT);
size = strlen("blahblahblahblah");
memcpy(buffer, "blahblahblahblah", size);
for (lfs_size_t i = 0;
for (lfs1_size_t i = 0;
i < (cfg.block_count-24)*(cfg.block_size-8);
i += size) {
lfs_file_write(&lfs, &file[0], buffer, size) => size;
lfs1_file_write(&lfs1, &file[0], buffer, size) => size;
}
lfs_file_close(&lfs, &file[0]) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
for (int i = 0; i < 9; i++) {
sprintf((char*)buffer, "dirwithanexhaustivelylongnameforpadding%d", i);
lfs_mkdir(&lfs, (char*)buffer) => 0;
lfs1_mkdir(&lfs1, (char*)buffer) => 0;
}
lfs_mkdir(&lfs, "exhaustiondir") => LFS_ERR_NOSPC;
lfs1_mkdir(&lfs1, "exhaustiondir") => LFS1_ERR_NOSPC;
lfs_remove(&lfs, "exhaustion") => 0;
lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
lfs1_remove(&lfs1, "exhaustion") => 0;
lfs1_file_open(&lfs1, &file[0], "exhaustion", LFS1_O_WRONLY | LFS1_O_CREAT);
size = strlen("blahblahblahblah");
memcpy(buffer, "blahblahblahblah", size);
for (lfs_size_t i = 0;
for (lfs1_size_t i = 0;
i < (cfg.block_count-26)*(cfg.block_size-8);
i += size) {
lfs_file_write(&lfs, &file[0], buffer, size) => size;
lfs1_file_write(&lfs1, &file[0], buffer, size) => size;
}
lfs_file_close(&lfs, &file[0]) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs_mkdir(&lfs, "exhaustiondir") => 0;
lfs_mkdir(&lfs, "exhaustiondir2") => LFS_ERR_NOSPC;
lfs1_mkdir(&lfs1, "exhaustiondir") => 0;
lfs1_mkdir(&lfs1, "exhaustiondir2") => LFS1_ERR_NOSPC;
TEST
echo "--- Split dir test ---"
rm -rf blocks
tests/test.py << TEST
lfs_format(&lfs, &cfg) => 0;
lfs1_format(&lfs1, &cfg) => 0;
TEST
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
// create one block whole for half a directory
lfs_file_open(&lfs, &file[0], "bump", LFS_O_WRONLY | LFS_O_CREAT) => 0;
lfs_file_write(&lfs, &file[0], (void*)"hi", 2) => 2;
lfs_file_close(&lfs, &file[0]) => 0;
lfs1_file_open(&lfs1, &file[0], "bump", LFS1_O_WRONLY | LFS1_O_CREAT) => 0;
lfs1_file_write(&lfs1, &file[0], (void*)"hi", 2) => 2;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
lfs1_file_open(&lfs1, &file[0], "exhaustion", LFS1_O_WRONLY | LFS1_O_CREAT);
size = strlen("blahblahblahblah");
memcpy(buffer, "blahblahblahblah", size);
for (lfs_size_t i = 0;
for (lfs1_size_t i = 0;
i < (cfg.block_count-6)*(cfg.block_size-8);
i += size) {
lfs_file_write(&lfs, &file[0], buffer, size) => size;
lfs1_file_write(&lfs1, &file[0], buffer, size) => size;
}
lfs_file_close(&lfs, &file[0]) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
// open hole
lfs_remove(&lfs, "bump") => 0;
lfs1_remove(&lfs1, "bump") => 0;
lfs_mkdir(&lfs, "splitdir") => 0;
lfs_file_open(&lfs, &file[0], "splitdir/bump",
LFS_O_WRONLY | LFS_O_CREAT) => 0;
lfs_file_write(&lfs, &file[0], buffer, size) => LFS_ERR_NOSPC;
lfs_file_close(&lfs, &file[0]) => 0;
lfs1_mkdir(&lfs1, "splitdir") => 0;
lfs1_file_open(&lfs1, &file[0], "splitdir/bump",
LFS1_O_WRONLY | LFS1_O_CREAT) => 0;
lfs1_file_write(&lfs1, &file[0], buffer, size) => LFS1_ERR_NOSPC;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Outdated lookahead test ---"
rm -rf blocks
tests/test.py << TEST
lfs_format(&lfs, &cfg) => 0;
lfs1_format(&lfs1, &cfg) => 0;
lfs_mount(&lfs, &cfg) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
// fill completely with two files
lfs_file_open(&lfs, &file[0], "exhaustion1",
LFS_O_WRONLY | LFS_O_CREAT) => 0;
lfs1_file_open(&lfs1, &file[0], "exhaustion1",
LFS1_O_WRONLY | LFS1_O_CREAT) => 0;
size = strlen("blahblahblahblah");
memcpy(buffer, "blahblahblahblah", size);
for (lfs_size_t i = 0;
for (lfs1_size_t i = 0;
i < ((cfg.block_count-4)/2)*(cfg.block_size-8);
i += size) {
lfs_file_write(&lfs, &file[0], buffer, size) => size;
lfs1_file_write(&lfs1, &file[0], buffer, size) => size;
}
lfs_file_close(&lfs, &file[0]) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs_file_open(&lfs, &file[0], "exhaustion2",
LFS_O_WRONLY | LFS_O_CREAT) => 0;
lfs1_file_open(&lfs1, &file[0], "exhaustion2",
LFS1_O_WRONLY | LFS1_O_CREAT) => 0;
size = strlen("blahblahblahblah");
memcpy(buffer, "blahblahblahblah", size);
for (lfs_size_t i = 0;
for (lfs1_size_t i = 0;
i < ((cfg.block_count-4+1)/2)*(cfg.block_size-8);
i += size) {
lfs_file_write(&lfs, &file[0], buffer, size) => size;
lfs1_file_write(&lfs1, &file[0], buffer, size) => size;
}
lfs_file_close(&lfs, &file[0]) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
// remount to force reset of lookahead
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
lfs_mount(&lfs, &cfg) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
// rewrite one file
lfs_file_open(&lfs, &file[0], "exhaustion1",
LFS_O_WRONLY | LFS_O_TRUNC) => 0;
lfs_file_sync(&lfs, &file[0]) => 0;
lfs1_file_open(&lfs1, &file[0], "exhaustion1",
LFS1_O_WRONLY | LFS1_O_TRUNC) => 0;
lfs1_file_sync(&lfs1, &file[0]) => 0;
size = strlen("blahblahblahblah");
memcpy(buffer, "blahblahblahblah", size);
for (lfs_size_t i = 0;
for (lfs1_size_t i = 0;
i < ((cfg.block_count-4)/2)*(cfg.block_size-8);
i += size) {
lfs_file_write(&lfs, &file[0], buffer, size) => size;
lfs1_file_write(&lfs1, &file[0], buffer, size) => size;
}
lfs_file_close(&lfs, &file[0]) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
// rewrite second file, this requires lookahead does not
// use old population
lfs_file_open(&lfs, &file[0], "exhaustion2",
LFS_O_WRONLY | LFS_O_TRUNC) => 0;
lfs_file_sync(&lfs, &file[0]) => 0;
lfs1_file_open(&lfs1, &file[0], "exhaustion2",
LFS1_O_WRONLY | LFS1_O_TRUNC) => 0;
lfs1_file_sync(&lfs1, &file[0]) => 0;
size = strlen("blahblahblahblah");
memcpy(buffer, "blahblahblahblah", size);
for (lfs_size_t i = 0;
for (lfs1_size_t i = 0;
i < ((cfg.block_count-4+1)/2)*(cfg.block_size-8);
i += size) {
lfs_file_write(&lfs, &file[0], buffer, size) => size;
lfs1_file_write(&lfs1, &file[0], buffer, size) => size;
}
lfs_file_close(&lfs, &file[0]) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
TEST
echo "--- Outdated lookahead and split dir test ---"
rm -rf blocks
tests/test.py << TEST
lfs_format(&lfs, &cfg) => 0;
lfs1_format(&lfs1, &cfg) => 0;
lfs_mount(&lfs, &cfg) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
// fill completely with two files
lfs_file_open(&lfs, &file[0], "exhaustion1",
LFS_O_WRONLY | LFS_O_CREAT) => 0;
lfs1_file_open(&lfs1, &file[0], "exhaustion1",
LFS1_O_WRONLY | LFS1_O_CREAT) => 0;
size = strlen("blahblahblahblah");
memcpy(buffer, "blahblahblahblah", size);
for (lfs_size_t i = 0;
for (lfs1_size_t i = 0;
i < ((cfg.block_count-4)/2)*(cfg.block_size-8);
i += size) {
lfs_file_write(&lfs, &file[0], buffer, size) => size;
lfs1_file_write(&lfs1, &file[0], buffer, size) => size;
}
lfs_file_close(&lfs, &file[0]) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs_file_open(&lfs, &file[0], "exhaustion2",
LFS_O_WRONLY | LFS_O_CREAT) => 0;
lfs1_file_open(&lfs1, &file[0], "exhaustion2",
LFS1_O_WRONLY | LFS1_O_CREAT) => 0;
size = strlen("blahblahblahblah");
memcpy(buffer, "blahblahblahblah", size);
for (lfs_size_t i = 0;
for (lfs1_size_t i = 0;
i < ((cfg.block_count-4+1)/2)*(cfg.block_size-8);
i += size) {
lfs_file_write(&lfs, &file[0], buffer, size) => size;
lfs1_file_write(&lfs1, &file[0], buffer, size) => size;
}
lfs_file_close(&lfs, &file[0]) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
// remount to force reset of lookahead
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
lfs_mount(&lfs, &cfg) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
// rewrite one file with a hole of one block
lfs_file_open(&lfs, &file[0], "exhaustion1",
LFS_O_WRONLY | LFS_O_TRUNC) => 0;
lfs_file_sync(&lfs, &file[0]) => 0;
lfs1_file_open(&lfs1, &file[0], "exhaustion1",
LFS1_O_WRONLY | LFS1_O_TRUNC) => 0;
lfs1_file_sync(&lfs1, &file[0]) => 0;
size = strlen("blahblahblahblah");
memcpy(buffer, "blahblahblahblah", size);
for (lfs_size_t i = 0;
for (lfs1_size_t i = 0;
i < ((cfg.block_count-4)/2 - 1)*(cfg.block_size-8);
i += size) {
lfs_file_write(&lfs, &file[0], buffer, size) => size;
lfs1_file_write(&lfs1, &file[0], buffer, size) => size;
}
lfs_file_close(&lfs, &file[0]) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
// try to allocate a directory, should fail!
lfs_mkdir(&lfs, "split") => LFS_ERR_NOSPC;
lfs1_mkdir(&lfs1, "split") => LFS1_ERR_NOSPC;
// file should not fail
lfs_file_open(&lfs, &file[0], "notasplit",
LFS_O_WRONLY | LFS_O_CREAT) => 0;
lfs_file_write(&lfs, &file[0], "hi", 2) => 2;
lfs_file_close(&lfs, &file[0]) => 0;
lfs1_file_open(&lfs1, &file[0], "notasplit",
LFS1_O_WRONLY | LFS1_O_CREAT) => 0;
lfs1_file_write(&lfs1, &file[0], "hi", 2) => 2;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Results ---"

56
tests/test_corrupt.sh
View File

@@ -6,71 +6,71 @@ echo "=== Corrupt tests ==="
NAMEMULT=64
FILEMULT=1
lfs_mktree() {
lfs1_mktree() {
tests/test.py ${1:-} << TEST
lfs_format(&lfs, &cfg) => 0;
lfs1_format(&lfs1, &cfg) => 0;
lfs_mount(&lfs, &cfg) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
for (int i = 1; i < 10; i++) {
for (int j = 0; j < $NAMEMULT; j++) {
buffer[j] = '0'+i;
}
buffer[$NAMEMULT] = '\0';
lfs_mkdir(&lfs, (char*)buffer) => 0;
lfs1_mkdir(&lfs1, (char*)buffer) => 0;
buffer[$NAMEMULT] = '/';
for (int j = 0; j < $NAMEMULT; j++) {
buffer[j+$NAMEMULT+1] = '0'+i;
}
buffer[2*$NAMEMULT+1] = '\0';
lfs_file_open(&lfs, &file[0], (char*)buffer,
LFS_O_WRONLY | LFS_O_CREAT) => 0;
lfs1_file_open(&lfs1, &file[0], (char*)buffer,
LFS1_O_WRONLY | LFS1_O_CREAT) => 0;
size = $NAMEMULT;
for (int j = 0; j < i*$FILEMULT; j++) {
lfs_file_write(&lfs, &file[0], buffer, size) => size;
lfs1_file_write(&lfs1, &file[0], buffer, size) => size;
}
lfs_file_close(&lfs, &file[0]) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
}
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
}
lfs_chktree() {
lfs1_chktree() {
tests/test.py ${1:-} << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
for (int i = 1; i < 10; i++) {
for (int j = 0; j < $NAMEMULT; j++) {
buffer[j] = '0'+i;
}
buffer[$NAMEMULT] = '\0';
lfs_stat(&lfs, (char*)buffer, &info) => 0;
info.type => LFS_TYPE_DIR;
lfs1_stat(&lfs1, (char*)buffer, &info) => 0;
info.type => LFS1_TYPE_DIR;
buffer[$NAMEMULT] = '/';
for (int j = 0; j < $NAMEMULT; j++) {
buffer[j+$NAMEMULT+1] = '0'+i;
}
buffer[2*$NAMEMULT+1] = '\0';
lfs_file_open(&lfs, &file[0], (char*)buffer, LFS_O_RDONLY) => 0;
lfs1_file_open(&lfs1, &file[0], (char*)buffer, LFS1_O_RDONLY) => 0;
size = $NAMEMULT;
for (int j = 0; j < i*$FILEMULT; j++) {
lfs_file_read(&lfs, &file[0], rbuffer, size) => size;
lfs1_file_read(&lfs1, &file[0], rbuffer, size) => size;
memcmp(buffer, rbuffer, size) => 0;
}
lfs_file_close(&lfs, &file[0]) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
}
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
}
echo "--- Sanity check ---"
rm -rf blocks
lfs_mktree
lfs_chktree
lfs1_mktree
lfs1_chktree
echo "--- Block corruption ---"
for i in {0..33}
@@ -78,8 +78,8 @@ do
rm -rf blocks
mkdir blocks
ln -s /dev/zero blocks/$(printf '%x' $i)
lfs_mktree
lfs_chktree
lfs1_mktree
lfs1_chktree
done
echo "--- Block persistance ---"
@@ -87,10 +87,10 @@ for i in {0..33}
do
rm -rf blocks
mkdir blocks
lfs_mktree
lfs1_mktree
chmod a-w blocks/$(printf '%x' $i)
lfs_mktree
lfs_chktree
lfs1_mktree
lfs1_chktree
done
echo "--- Big region corruption ---"
@@ -100,8 +100,8 @@ for i in {2..255}
do
ln -s /dev/zero blocks/$(printf '%x' $i)
done
lfs_mktree
lfs_chktree
lfs1_mktree
lfs1_chktree
echo "--- Alternating corruption ---"
rm -rf blocks
@@ -110,8 +110,8 @@ for i in {2..511..2}
do
ln -s /dev/zero blocks/$(printf '%x' $i)
done
lfs_mktree
lfs_chktree
lfs1_mktree
lfs1_chktree
echo "--- Results ---"
tests/stats.py

538
tests/test_dirs.sh
View File

@@ -6,294 +6,294 @@ LARGESIZE=128
echo "=== Directory tests ==="
rm -rf blocks
tests/test.py << TEST
lfs_format(&lfs, &cfg) => 0;
lfs1_format(&lfs1, &cfg) => 0;
TEST
echo "--- Root directory ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_dir_open(&lfs, &dir[0], "/") => 0;
lfs_dir_close(&lfs, &dir[0]) => 0;
lfs_unmount(&lfs) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_dir_open(&lfs1, &dir[0], "/") => 0;
lfs1_dir_close(&lfs1, &dir[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Directory creation ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_mkdir(&lfs, "potato") => 0;
lfs_unmount(&lfs) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_mkdir(&lfs1, "potato") => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- File creation ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_file_open(&lfs, &file[0], "burito", LFS_O_CREAT | LFS_O_WRONLY) => 0;
lfs_file_close(&lfs, &file[0]) => 0;
lfs_unmount(&lfs) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_file_open(&lfs1, &file[0], "burito", LFS1_O_CREAT | LFS1_O_WRONLY) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Directory iteration ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_dir_open(&lfs, &dir[0], "/") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_dir_open(&lfs1, &dir[0], "/") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "potato") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "burito") => 0;
info.type => LFS_TYPE_REG;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_dir_close(&lfs, &dir[0]) => 0;
lfs_unmount(&lfs) => 0;
info.type => LFS1_TYPE_REG;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_dir_close(&lfs1, &dir[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Directory failures ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_mkdir(&lfs, "potato") => LFS_ERR_EXIST;
lfs_dir_open(&lfs, &dir[0], "tomato") => LFS_ERR_NOENT;
lfs_dir_open(&lfs, &dir[0], "burito") => LFS_ERR_NOTDIR;
lfs_file_open(&lfs, &file[0], "tomato", LFS_O_RDONLY) => LFS_ERR_NOENT;
lfs_file_open(&lfs, &file[0], "potato", LFS_O_RDONLY) => LFS_ERR_ISDIR;
lfs_unmount(&lfs) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_mkdir(&lfs1, "potato") => LFS1_ERR_EXIST;
lfs1_dir_open(&lfs1, &dir[0], "tomato") => LFS1_ERR_NOENT;
lfs1_dir_open(&lfs1, &dir[0], "burito") => LFS1_ERR_NOTDIR;
lfs1_file_open(&lfs1, &file[0], "tomato", LFS1_O_RDONLY) => LFS1_ERR_NOENT;
lfs1_file_open(&lfs1, &file[0], "potato", LFS1_O_RDONLY) => LFS1_ERR_ISDIR;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Nested directories ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_mkdir(&lfs, "potato/baked") => 0;
lfs_mkdir(&lfs, "potato/sweet") => 0;
lfs_mkdir(&lfs, "potato/fried") => 0;
lfs_unmount(&lfs) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_mkdir(&lfs1, "potato/baked") => 0;
lfs1_mkdir(&lfs1, "potato/sweet") => 0;
lfs1_mkdir(&lfs1, "potato/fried") => 0;
lfs1_unmount(&lfs1) => 0;
TEST
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_dir_open(&lfs, &dir[0], "potato") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_dir_open(&lfs1, &dir[0], "potato") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "baked") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "sweet") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "fried") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_dir_close(&lfs, &dir[0]) => 0;
lfs_unmount(&lfs) => 0;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_dir_close(&lfs1, &dir[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Multi-block directory ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_mkdir(&lfs, "cactus") => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_mkdir(&lfs1, "cactus") => 0;
for (int i = 0; i < $LARGESIZE; i++) {
sprintf((char*)buffer, "cactus/test%d", i);
lfs_mkdir(&lfs, (char*)buffer) => 0;
lfs1_mkdir(&lfs1, (char*)buffer) => 0;
}
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_dir_open(&lfs, &dir[0], "cactus") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_dir_open(&lfs1, &dir[0], "cactus") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS_TYPE_DIR;
info.type => LFS1_TYPE_DIR;
for (int i = 0; i < $LARGESIZE; i++) {
sprintf((char*)buffer, "test%d", i);
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, (char*)buffer) => 0;
info.type => LFS_TYPE_DIR;
info.type => LFS1_TYPE_DIR;
}
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_unmount(&lfs) => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Directory remove ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_remove(&lfs, "potato") => LFS_ERR_NOTEMPTY;
lfs_remove(&lfs, "potato/sweet") => 0;
lfs_remove(&lfs, "potato/baked") => 0;
lfs_remove(&lfs, "potato/fried") => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_remove(&lfs1, "potato") => LFS1_ERR_NOTEMPTY;
lfs1_remove(&lfs1, "potato/sweet") => 0;
lfs1_remove(&lfs1, "potato/baked") => 0;
lfs1_remove(&lfs1, "potato/fried") => 0;
lfs_dir_open(&lfs, &dir[0], "potato") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_open(&lfs1, &dir[0], "potato") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_dir_close(&lfs, &dir[0]) => 0;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_dir_close(&lfs1, &dir[0]) => 0;
lfs_remove(&lfs, "potato") => 0;
lfs1_remove(&lfs1, "potato") => 0;
lfs_dir_open(&lfs, &dir[0], "/") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_open(&lfs1, &dir[0], "/") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "burito") => 0;
info.type => LFS_TYPE_REG;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_REG;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "cactus") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_dir_close(&lfs, &dir[0]) => 0;
lfs_unmount(&lfs) => 0;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_dir_close(&lfs1, &dir[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_dir_open(&lfs, &dir[0], "/") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_dir_open(&lfs1, &dir[0], "/") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "burito") => 0;
info.type => LFS_TYPE_REG;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_REG;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "cactus") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_dir_close(&lfs, &dir[0]) => 0;
lfs_unmount(&lfs) => 0;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_dir_close(&lfs1, &dir[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Directory rename ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_mkdir(&lfs, "coldpotato") => 0;
lfs_mkdir(&lfs, "coldpotato/baked") => 0;
lfs_mkdir(&lfs, "coldpotato/sweet") => 0;
lfs_mkdir(&lfs, "coldpotato/fried") => 0;
lfs_unmount(&lfs) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_mkdir(&lfs1, "coldpotato") => 0;
lfs1_mkdir(&lfs1, "coldpotato/baked") => 0;
lfs1_mkdir(&lfs1, "coldpotato/sweet") => 0;
lfs1_mkdir(&lfs1, "coldpotato/fried") => 0;
lfs1_unmount(&lfs1) => 0;
TEST
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_rename(&lfs, "coldpotato", "hotpotato") => 0;
lfs_unmount(&lfs) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_rename(&lfs1, "coldpotato", "hotpotato") => 0;
lfs1_unmount(&lfs1) => 0;
TEST
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_dir_open(&lfs, &dir[0], "hotpotato") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_dir_open(&lfs1, &dir[0], "hotpotato") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "baked") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "sweet") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "fried") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_dir_close(&lfs, &dir[0]) => 0;
lfs_unmount(&lfs) => 0;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_dir_close(&lfs1, &dir[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_mkdir(&lfs, "warmpotato") => 0;
lfs_mkdir(&lfs, "warmpotato/mushy") => 0;
lfs_rename(&lfs, "hotpotato", "warmpotato") => LFS_ERR_NOTEMPTY;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_mkdir(&lfs1, "warmpotato") => 0;
lfs1_mkdir(&lfs1, "warmpotato/mushy") => 0;
lfs1_rename(&lfs1, "hotpotato", "warmpotato") => LFS1_ERR_NOTEMPTY;
lfs_remove(&lfs, "warmpotato/mushy") => 0;
lfs_rename(&lfs, "hotpotato", "warmpotato") => 0;
lfs1_remove(&lfs1, "warmpotato/mushy") => 0;
lfs1_rename(&lfs1, "hotpotato", "warmpotato") => 0;
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_dir_open(&lfs, &dir[0], "warmpotato") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_dir_open(&lfs1, &dir[0], "warmpotato") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "baked") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "sweet") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "fried") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_dir_close(&lfs, &dir[0]) => 0;
lfs_unmount(&lfs) => 0;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_dir_close(&lfs1, &dir[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_mkdir(&lfs, "coldpotato") => 0;
lfs_rename(&lfs, "warmpotato/baked", "coldpotato/baked") => 0;
lfs_rename(&lfs, "warmpotato/sweet", "coldpotato/sweet") => 0;
lfs_rename(&lfs, "warmpotato/fried", "coldpotato/fried") => 0;
lfs_remove(&lfs, "coldpotato") => LFS_ERR_NOTEMPTY;
lfs_remove(&lfs, "warmpotato") => 0;
lfs_unmount(&lfs) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_mkdir(&lfs1, "coldpotato") => 0;
lfs1_rename(&lfs1, "warmpotato/baked", "coldpotato/baked") => 0;
lfs1_rename(&lfs1, "warmpotato/sweet", "coldpotato/sweet") => 0;
lfs1_rename(&lfs1, "warmpotato/fried", "coldpotato/fried") => 0;
lfs1_remove(&lfs1, "coldpotato") => LFS1_ERR_NOTEMPTY;
lfs1_remove(&lfs1, "warmpotato") => 0;
lfs1_unmount(&lfs1) => 0;
TEST
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_dir_open(&lfs, &dir[0], "coldpotato") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_dir_open(&lfs1, &dir[0], "coldpotato") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "baked") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "sweet") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "fried") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_dir_close(&lfs, &dir[0]) => 0;
lfs_unmount(&lfs) => 0;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_dir_close(&lfs1, &dir[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Recursive remove ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_remove(&lfs, "coldpotato") => LFS_ERR_NOTEMPTY;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_remove(&lfs1, "coldpotato") => LFS1_ERR_NOTEMPTY;
lfs_dir_open(&lfs, &dir[0], "coldpotato") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_open(&lfs1, &dir[0], "coldpotato") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
while (true) {
int err = lfs_dir_read(&lfs, &dir[0], &info);
int err = lfs1_dir_read(&lfs1, &dir[0], &info);
err >= 0 => 1;
if (err == 0) {
break;
@@ -301,183 +301,183 @@ tests/test.py << TEST
strcpy((char*)buffer, "coldpotato/");
strcat((char*)buffer, info.name);
lfs_remove(&lfs, (char*)buffer) => 0;
lfs1_remove(&lfs1, (char*)buffer) => 0;
}
lfs_remove(&lfs, "coldpotato") => 0;
lfs1_remove(&lfs1, "coldpotato") => 0;
TEST
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_dir_open(&lfs, &dir[0], "/") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_dir_open(&lfs1, &dir[0], "/") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "burito") => 0;
info.type => LFS_TYPE_REG;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_REG;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "cactus") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_dir_close(&lfs, &dir[0]) => 0;
lfs_unmount(&lfs) => 0;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_dir_close(&lfs1, &dir[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Multi-block rename ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
for (int i = 0; i < $LARGESIZE; i++) {
sprintf((char*)buffer, "cactus/test%d", i);
sprintf((char*)wbuffer, "cactus/tedd%d", i);
lfs_rename(&lfs, (char*)buffer, (char*)wbuffer) => 0;
lfs1_rename(&lfs1, (char*)buffer, (char*)wbuffer) => 0;
}
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_dir_open(&lfs, &dir[0], "cactus") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_dir_open(&lfs1, &dir[0], "cactus") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS_TYPE_DIR;
info.type => LFS1_TYPE_DIR;
for (int i = 0; i < $LARGESIZE; i++) {
sprintf((char*)buffer, "tedd%d", i);
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, (char*)buffer) => 0;
info.type => LFS_TYPE_DIR;
info.type => LFS1_TYPE_DIR;
}
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_unmount(&lfs) => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Multi-block remove ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_remove(&lfs, "cactus") => LFS_ERR_NOTEMPTY;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_remove(&lfs1, "cactus") => LFS1_ERR_NOTEMPTY;
for (int i = 0; i < $LARGESIZE; i++) {
sprintf((char*)buffer, "cactus/tedd%d", i);
lfs_remove(&lfs, (char*)buffer) => 0;
lfs1_remove(&lfs1, (char*)buffer) => 0;
}
lfs_remove(&lfs, "cactus") => 0;
lfs_unmount(&lfs) => 0;
lfs1_remove(&lfs1, "cactus") => 0;
lfs1_unmount(&lfs1) => 0;
TEST
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_dir_open(&lfs, &dir[0], "/") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_dir_open(&lfs1, &dir[0], "/") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "burito") => 0;
info.type => LFS_TYPE_REG;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_dir_close(&lfs, &dir[0]) => 0;
lfs_unmount(&lfs) => 0;
info.type => LFS1_TYPE_REG;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_dir_close(&lfs1, &dir[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Multi-block directory with files ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_mkdir(&lfs, "prickly-pear") => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_mkdir(&lfs1, "prickly-pear") => 0;
for (int i = 0; i < $LARGESIZE; i++) {
sprintf((char*)buffer, "prickly-pear/test%d", i);
lfs_file_open(&lfs, &file[0], (char*)buffer,
LFS_O_WRONLY | LFS_O_CREAT) => 0;
lfs1_file_open(&lfs1, &file[0], (char*)buffer,
LFS1_O_WRONLY | LFS1_O_CREAT) => 0;
size = 6;
memcpy(wbuffer, "Hello", size);
lfs_file_write(&lfs, &file[0], wbuffer, size) => size;
lfs_file_close(&lfs, &file[0]) => 0;
lfs1_file_write(&lfs1, &file[0], wbuffer, size) => size;
lfs1_file_close(&lfs1, &file[0]) => 0;
}
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_dir_open(&lfs, &dir[0], "prickly-pear") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_dir_open(&lfs1, &dir[0], "prickly-pear") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS_TYPE_DIR;
info.type => LFS1_TYPE_DIR;
for (int i = 0; i < $LARGESIZE; i++) {
sprintf((char*)buffer, "test%d", i);
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, (char*)buffer) => 0;
info.type => LFS_TYPE_REG;
info.type => LFS1_TYPE_REG;
info.size => 6;
}
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_unmount(&lfs) => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Multi-block rename with files ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
for (int i = 0; i < $LARGESIZE; i++) {
sprintf((char*)buffer, "prickly-pear/test%d", i);
sprintf((char*)wbuffer, "prickly-pear/tedd%d", i);
lfs_rename(&lfs, (char*)buffer, (char*)wbuffer) => 0;
lfs1_rename(&lfs1, (char*)buffer, (char*)wbuffer) => 0;
}
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_dir_open(&lfs, &dir[0], "prickly-pear") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_dir_open(&lfs1, &dir[0], "prickly-pear") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS_TYPE_DIR;
info.type => LFS1_TYPE_DIR;
for (int i = 0; i < $LARGESIZE; i++) {
sprintf((char*)buffer, "tedd%d", i);
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, (char*)buffer) => 0;
info.type => LFS_TYPE_REG;
info.type => LFS1_TYPE_REG;
info.size => 6;
}
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_unmount(&lfs) => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Multi-block remove with files ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_remove(&lfs, "prickly-pear") => LFS_ERR_NOTEMPTY;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_remove(&lfs1, "prickly-pear") => LFS1_ERR_NOTEMPTY;
for (int i = 0; i < $LARGESIZE; i++) {
sprintf((char*)buffer, "prickly-pear/tedd%d", i);
lfs_remove(&lfs, (char*)buffer) => 0;
lfs1_remove(&lfs1, (char*)buffer) => 0;
}
lfs_remove(&lfs, "prickly-pear") => 0;
lfs_unmount(&lfs) => 0;
lfs1_remove(&lfs1, "prickly-pear") => 0;
lfs1_unmount(&lfs1) => 0;
TEST
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_dir_open(&lfs, &dir[0], "/") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_dir_open(&lfs1, &dir[0], "/") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "burito") => 0;
info.type => LFS_TYPE_REG;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_dir_close(&lfs, &dir[0]) => 0;
lfs_unmount(&lfs) => 0;
info.type => LFS1_TYPE_REG;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_dir_close(&lfs1, &dir[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Results ---"

104
tests/test_files.sh
View File

@@ -8,65 +8,65 @@ LARGESIZE=262144
echo "=== File tests ==="
rm -rf blocks
tests/test.py << TEST
lfs_format(&lfs, &cfg) => 0;
lfs1_format(&lfs1, &cfg) => 0;
TEST
echo "--- Simple file test ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_file_open(&lfs, &file[0], "hello", LFS_O_WRONLY | LFS_O_CREAT) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_file_open(&lfs1, &file[0], "hello", LFS1_O_WRONLY | LFS1_O_CREAT) => 0;
size = strlen("Hello World!\n");
memcpy(wbuffer, "Hello World!\n", size);
lfs_file_write(&lfs, &file[0], wbuffer, size) => size;
lfs_file_close(&lfs, &file[0]) => 0;
lfs1_file_write(&lfs1, &file[0], wbuffer, size) => size;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs_file_open(&lfs, &file[0], "hello", LFS_O_RDONLY) => 0;
lfs1_file_open(&lfs1, &file[0], "hello", LFS1_O_RDONLY) => 0;
size = strlen("Hello World!\n");
lfs_file_read(&lfs, &file[0], rbuffer, size) => size;
lfs1_file_read(&lfs1, &file[0], rbuffer, size) => size;
memcmp(rbuffer, wbuffer, size) => 0;
lfs_file_close(&lfs, &file[0]) => 0;
lfs_unmount(&lfs) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
w_test() {
tests/test.py << TEST
size = $1;
lfs_size_t chunk = 31;
lfs1_size_t chunk = 31;
srand(0);
lfs_mount(&lfs, &cfg) => 0;
lfs_file_open(&lfs, &file[0], "$2",
${3:-LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC}) => 0;
for (lfs_size_t i = 0; i < size; i += chunk) {
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_file_open(&lfs1, &file[0], "$2",
${3:-LFS1_O_WRONLY | LFS1_O_CREAT | LFS1_O_TRUNC}) => 0;
for (lfs1_size_t i = 0; i < size; i += chunk) {
chunk = (chunk < size - i) ? chunk : size - i;
for (lfs_size_t b = 0; b < chunk; b++) {
for (lfs1_size_t b = 0; b < chunk; b++) {
buffer[b] = rand() & 0xff;
}
lfs_file_write(&lfs, &file[0], buffer, chunk) => chunk;
lfs1_file_write(&lfs1, &file[0], buffer, chunk) => chunk;
}
lfs_file_close(&lfs, &file[0]) => 0;
lfs_unmount(&lfs) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
}
r_test() {
tests/test.py << TEST
size = $1;
lfs_size_t chunk = 29;
lfs1_size_t chunk = 29;
srand(0);
lfs_mount(&lfs, &cfg) => 0;
lfs_stat(&lfs, "$2", &info) => 0;
info.type => LFS_TYPE_REG;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_stat(&lfs1, "$2", &info) => 0;
info.type => LFS1_TYPE_REG;
info.size => size;
lfs_file_open(&lfs, &file[0], "$2", ${3:-LFS_O_RDONLY}) => 0;
for (lfs_size_t i = 0; i < size; i += chunk) {
lfs1_file_open(&lfs1, &file[0], "$2", ${3:-LFS1_O_RDONLY}) => 0;
for (lfs1_size_t i = 0; i < size; i += chunk) {
chunk = (chunk < size - i) ? chunk : size - i;
lfs_file_read(&lfs, &file[0], buffer, chunk) => chunk;
for (lfs_size_t b = 0; b < chunk && i+b < size; b++) {
lfs1_file_read(&lfs1, &file[0], buffer, chunk) => chunk;
for (lfs1_size_t b = 0; b < chunk && i+b < size; b++) {
buffer[b] => rand() & 0xff;
}
}
lfs_file_close(&lfs, &file[0]) => 0;
lfs_unmount(&lfs) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
}
@@ -106,52 +106,52 @@ r_test 0 noavacado
echo "--- Dir check ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_dir_open(&lfs, &dir[0], "/") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_dir_open(&lfs1, &dir[0], "/") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "hello") => 0;
info.type => LFS_TYPE_REG;
info.type => LFS1_TYPE_REG;
info.size => strlen("Hello World!\n");
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "smallavacado") => 0;
info.type => LFS_TYPE_REG;
info.type => LFS1_TYPE_REG;
info.size => $SMALLSIZE;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "mediumavacado") => 0;
info.type => LFS_TYPE_REG;
info.type => LFS1_TYPE_REG;
info.size => $MEDIUMSIZE;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "largeavacado") => 0;
info.type => LFS_TYPE_REG;
info.type => LFS1_TYPE_REG;
info.size => $LARGESIZE;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "noavacado") => 0;
info.type => LFS_TYPE_REG;
info.type => LFS1_TYPE_REG;
info.size => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_dir_close(&lfs, &dir[0]) => 0;
lfs_unmount(&lfs) => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_dir_close(&lfs1, &dir[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Many file test ---"
tests/test.py << TEST
lfs_format(&lfs, &cfg) => 0;
lfs1_format(&lfs1, &cfg) => 0;
TEST
tests/test.py << TEST
// Create 300 files of 6 bytes
lfs_mount(&lfs, &cfg) => 0;
lfs_mkdir(&lfs, "directory") => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_mkdir(&lfs1, "directory") => 0;
for (unsigned i = 0; i < 300; i++) {
snprintf((char*)buffer, sizeof(buffer), "file_%03d", i);
lfs_file_open(&lfs, &file[0], (char*)buffer, LFS_O_WRONLY | LFS_O_CREAT) => 0;
lfs1_file_open(&lfs1, &file[0], (char*)buffer, LFS1_O_WRONLY | LFS1_O_CREAT) => 0;
size = 6;
memcpy(wbuffer, "Hello", size);
lfs_file_write(&lfs, &file[0], wbuffer, size) => size;
lfs_file_close(&lfs, &file[0]) => 0;
lfs1_file_write(&lfs1, &file[0], wbuffer, size) => size;
lfs1_file_close(&lfs1, &file[0]) => 0;
}
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Results ---"

20
tests/test_format.sh
View File

@@ -6,43 +6,43 @@ rm -rf blocks
echo "--- Basic formatting ---"
tests/test.py << TEST
lfs_format(&lfs, &cfg) => 0;
lfs1_format(&lfs1, &cfg) => 0;
TEST
echo "--- Invalid superblocks ---"
ln -f -s /dev/zero blocks/0
ln -f -s /dev/zero blocks/1
tests/test.py << TEST
lfs_format(&lfs, &cfg) => LFS_ERR_CORRUPT;
lfs1_format(&lfs1, &cfg) => LFS1_ERR_CORRUPT;
TEST
rm blocks/0 blocks/1
echo "--- Basic mounting ---"
tests/test.py << TEST
lfs_format(&lfs, &cfg) => 0;
lfs1_format(&lfs1, &cfg) => 0;
TEST
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_unmount(&lfs) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Invalid mount ---"
tests/test.py << TEST
lfs_format(&lfs, &cfg) => 0;
lfs1_format(&lfs1, &cfg) => 0;
TEST
rm blocks/0 blocks/1
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => LFS_ERR_CORRUPT;
lfs1_mount(&lfs1, &cfg) => LFS1_ERR_CORRUPT;
TEST
echo "--- Valid corrupt mount ---"
tests/test.py << TEST
lfs_format(&lfs, &cfg) => 0;
lfs1_format(&lfs1, &cfg) => 0;
TEST
rm blocks/0
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_unmount(&lfs) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Results ---"

192
tests/test_interspersed.sh
View File

@@ -4,182 +4,182 @@ set -eu
echo "=== Interspersed tests ==="
rm -rf blocks
tests/test.py << TEST
lfs_format(&lfs, &cfg) => 0;
lfs1_format(&lfs1, &cfg) => 0;
TEST
echo "--- Interspersed file test ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_file_open(&lfs, &file[0], "a", LFS_O_WRONLY | LFS_O_CREAT) => 0;
lfs_file_open(&lfs, &file[1], "b", LFS_O_WRONLY | LFS_O_CREAT) => 0;
lfs_file_open(&lfs, &file[2], "c", LFS_O_WRONLY | LFS_O_CREAT) => 0;
lfs_file_open(&lfs, &file[3], "d", LFS_O_WRONLY | LFS_O_CREAT) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_file_open(&lfs1, &file[0], "a", LFS1_O_WRONLY | LFS1_O_CREAT) => 0;
lfs1_file_open(&lfs1, &file[1], "b", LFS1_O_WRONLY | LFS1_O_CREAT) => 0;
lfs1_file_open(&lfs1, &file[2], "c", LFS1_O_WRONLY | LFS1_O_CREAT) => 0;
lfs1_file_open(&lfs1, &file[3], "d", LFS1_O_WRONLY | LFS1_O_CREAT) => 0;
for (int i = 0; i < 10; i++) {
lfs_file_write(&lfs, &file[0], (const void*)"a", 1) => 1;
lfs_file_write(&lfs, &file[1], (const void*)"b", 1) => 1;
lfs_file_write(&lfs, &file[2], (const void*)"c", 1) => 1;
lfs_file_write(&lfs, &file[3], (const void*)"d", 1) => 1;
lfs1_file_write(&lfs1, &file[0], (const void*)"a", 1) => 1;
lfs1_file_write(&lfs1, &file[1], (const void*)"b", 1) => 1;
lfs1_file_write(&lfs1, &file[2], (const void*)"c", 1) => 1;
lfs1_file_write(&lfs1, &file[3], (const void*)"d", 1) => 1;
}
lfs_file_close(&lfs, &file[0]);
lfs_file_close(&lfs, &file[1]);
lfs_file_close(&lfs, &file[2]);
lfs_file_close(&lfs, &file[3]);
lfs1_file_close(&lfs1, &file[0]);
lfs1_file_close(&lfs1, &file[1]);
lfs1_file_close(&lfs1, &file[2]);
lfs1_file_close(&lfs1, &file[3]);
lfs_dir_open(&lfs, &dir[0], "/") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_open(&lfs1, &dir[0], "/") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "a") => 0;
info.type => LFS_TYPE_REG;
info.type => LFS1_TYPE_REG;
info.size => 10;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "b") => 0;
info.type => LFS_TYPE_REG;
info.type => LFS1_TYPE_REG;
info.size => 10;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "c") => 0;
info.type => LFS_TYPE_REG;
info.type => LFS1_TYPE_REG;
info.size => 10;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "d") => 0;
info.type => LFS_TYPE_REG;
info.type => LFS1_TYPE_REG;
info.size => 10;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_dir_close(&lfs, &dir[0]) => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_dir_close(&lfs1, &dir[0]) => 0;
lfs_file_open(&lfs, &file[0], "a", LFS_O_RDONLY) => 0;
lfs_file_open(&lfs, &file[1], "b", LFS_O_RDONLY) => 0;
lfs_file_open(&lfs, &file[2], "c", LFS_O_RDONLY) => 0;
lfs_file_open(&lfs, &file[3], "d", LFS_O_RDONLY) => 0;
lfs1_file_open(&lfs1, &file[0], "a", LFS1_O_RDONLY) => 0;
lfs1_file_open(&lfs1, &file[1], "b", LFS1_O_RDONLY) => 0;
lfs1_file_open(&lfs1, &file[2], "c", LFS1_O_RDONLY) => 0;
lfs1_file_open(&lfs1, &file[3], "d", LFS1_O_RDONLY) => 0;
for (int i = 0; i < 10; i++) {
lfs_file_read(&lfs, &file[0], buffer, 1) => 1;
lfs1_file_read(&lfs1, &file[0], buffer, 1) => 1;
buffer[0] => 'a';
lfs_file_read(&lfs, &file[1], buffer, 1) => 1;
lfs1_file_read(&lfs1, &file[1], buffer, 1) => 1;
buffer[0] => 'b';
lfs_file_read(&lfs, &file[2], buffer, 1) => 1;
lfs1_file_read(&lfs1, &file[2], buffer, 1) => 1;
buffer[0] => 'c';
lfs_file_read(&lfs, &file[3], buffer, 1) => 1;
lfs1_file_read(&lfs1, &file[3], buffer, 1) => 1;
buffer[0] => 'd';
}
lfs_file_close(&lfs, &file[0]);
lfs_file_close(&lfs, &file[1]);
lfs_file_close(&lfs, &file[2]);
lfs_file_close(&lfs, &file[3]);
lfs1_file_close(&lfs1, &file[0]);
lfs1_file_close(&lfs1, &file[1]);
lfs1_file_close(&lfs1, &file[2]);
lfs1_file_close(&lfs1, &file[3]);
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Interspersed remove file test ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_file_open(&lfs, &file[0], "e", LFS_O_WRONLY | LFS_O_CREAT) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_file_open(&lfs1, &file[0], "e", LFS1_O_WRONLY | LFS1_O_CREAT) => 0;
for (int i = 0; i < 5; i++) {
lfs_file_write(&lfs, &file[0], (const void*)"e", 1) => 1;
lfs1_file_write(&lfs1, &file[0], (const void*)"e", 1) => 1;
}
lfs_remove(&lfs, "a") => 0;
lfs_remove(&lfs, "b") => 0;
lfs_remove(&lfs, "c") => 0;
lfs_remove(&lfs, "d") => 0;
lfs1_remove(&lfs1, "a") => 0;
lfs1_remove(&lfs1, "b") => 0;
lfs1_remove(&lfs1, "c") => 0;
lfs1_remove(&lfs1, "d") => 0;
for (int i = 0; i < 5; i++) {
lfs_file_write(&lfs, &file[0], (const void*)"e", 1) => 1;
lfs1_file_write(&lfs1, &file[0], (const void*)"e", 1) => 1;
}
lfs_file_close(&lfs, &file[0]);
lfs1_file_close(&lfs1, &file[0]);
lfs_dir_open(&lfs, &dir[0], "/") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_open(&lfs1, &dir[0], "/") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "e") => 0;
info.type => LFS_TYPE_REG;
info.type => LFS1_TYPE_REG;
info.size => 10;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_dir_close(&lfs, &dir[0]) => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_dir_close(&lfs1, &dir[0]) => 0;
lfs_file_open(&lfs, &file[0], "e", LFS_O_RDONLY) => 0;
lfs1_file_open(&lfs1, &file[0], "e", LFS1_O_RDONLY) => 0;
for (int i = 0; i < 10; i++) {
lfs_file_read(&lfs, &file[0], buffer, 1) => 1;
lfs1_file_read(&lfs1, &file[0], buffer, 1) => 1;
buffer[0] => 'e';
}
lfs_file_close(&lfs, &file[0]);
lfs1_file_close(&lfs1, &file[0]);
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Remove inconveniently test ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_file_open(&lfs, &file[0], "e", LFS_O_WRONLY | LFS_O_TRUNC) => 0;
lfs_file_open(&lfs, &file[1], "f", LFS_O_WRONLY | LFS_O_CREAT) => 0;
lfs_file_open(&lfs, &file[2], "g", LFS_O_WRONLY | LFS_O_CREAT) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_file_open(&lfs1, &file[0], "e", LFS1_O_WRONLY | LFS1_O_TRUNC) => 0;
lfs1_file_open(&lfs1, &file[1], "f", LFS1_O_WRONLY | LFS1_O_CREAT) => 0;
lfs1_file_open(&lfs1, &file[2], "g", LFS1_O_WRONLY | LFS1_O_CREAT) => 0;
for (int i = 0; i < 5; i++) {
lfs_file_write(&lfs, &file[0], (const void*)"e", 1) => 1;
lfs_file_write(&lfs, &file[1], (const void*)"f", 1) => 1;
lfs_file_write(&lfs, &file[2], (const void*)"g", 1) => 1;
lfs1_file_write(&lfs1, &file[0], (const void*)"e", 1) => 1;
lfs1_file_write(&lfs1, &file[1], (const void*)"f", 1) => 1;
lfs1_file_write(&lfs1, &file[2], (const void*)"g", 1) => 1;
}
lfs_remove(&lfs, "f") => 0;
lfs1_remove(&lfs1, "f") => 0;
for (int i = 0; i < 5; i++) {
lfs_file_write(&lfs, &file[0], (const void*)"e", 1) => 1;
lfs_file_write(&lfs, &file[1], (const void*)"f", 1) => 1;
lfs_file_write(&lfs, &file[2], (const void*)"g", 1) => 1;
lfs1_file_write(&lfs1, &file[0], (const void*)"e", 1) => 1;
lfs1_file_write(&lfs1, &file[1], (const void*)"f", 1) => 1;
lfs1_file_write(&lfs1, &file[2], (const void*)"g", 1) => 1;
}
lfs_file_close(&lfs, &file[0]);
lfs_file_close(&lfs, &file[1]);
lfs_file_close(&lfs, &file[2]);
lfs1_file_close(&lfs1, &file[0]);
lfs1_file_close(&lfs1, &file[1]);
lfs1_file_close(&lfs1, &file[2]);
lfs_dir_open(&lfs, &dir[0], "/") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_open(&lfs1, &dir[0], "/") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS_TYPE_DIR;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
info.type => LFS1_TYPE_DIR;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "e") => 0;
info.type => LFS_TYPE_REG;
info.type => LFS1_TYPE_REG;
info.size => 10;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "g") => 0;
info.type => LFS_TYPE_REG;
info.type => LFS1_TYPE_REG;
info.size => 10;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_dir_close(&lfs, &dir[0]) => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_dir_close(&lfs1, &dir[0]) => 0;
lfs_file_open(&lfs, &file[0], "e", LFS_O_RDONLY) => 0;
lfs_file_open(&lfs, &file[1], "g", LFS_O_RDONLY) => 0;
lfs1_file_open(&lfs1, &file[0], "e", LFS1_O_RDONLY) => 0;
lfs1_file_open(&lfs1, &file[1], "g", LFS1_O_RDONLY) => 0;
for (int i = 0; i < 10; i++) {
lfs_file_read(&lfs, &file[0], buffer, 1) => 1;
lfs1_file_read(&lfs1, &file[0], buffer, 1) => 1;
buffer[0] => 'e';
lfs_file_read(&lfs, &file[1], buffer, 1) => 1;
lfs1_file_read(&lfs1, &file[1], buffer, 1) => 1;
buffer[0] => 'g';
}
lfs_file_close(&lfs, &file[0]);
lfs_file_close(&lfs, &file[1]);
lfs1_file_close(&lfs1, &file[0]);
lfs1_file_close(&lfs1, &file[1]);
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Results ---"

260
tests/test_move.sh
View File

@@ -4,231 +4,231 @@ set -eu
echo "=== Move tests ==="
rm -rf blocks
tests/test.py << TEST
lfs_format(&lfs, &cfg) => 0;
lfs1_format(&lfs1, &cfg) => 0;
lfs_mount(&lfs, &cfg) => 0;
lfs_mkdir(&lfs, "a") => 0;
lfs_mkdir(&lfs, "b") => 0;
lfs_mkdir(&lfs, "c") => 0;
lfs_mkdir(&lfs, "d") => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_mkdir(&lfs1, "a") => 0;
lfs1_mkdir(&lfs1, "b") => 0;
lfs1_mkdir(&lfs1, "c") => 0;
lfs1_mkdir(&lfs1, "d") => 0;
lfs_mkdir(&lfs, "a/hi") => 0;
lfs_mkdir(&lfs, "a/hi/hola") => 0;
lfs_mkdir(&lfs, "a/hi/bonjour") => 0;
lfs_mkdir(&lfs, "a/hi/ohayo") => 0;
lfs1_mkdir(&lfs1, "a/hi") => 0;
lfs1_mkdir(&lfs1, "a/hi/hola") => 0;
lfs1_mkdir(&lfs1, "a/hi/bonjour") => 0;
lfs1_mkdir(&lfs1, "a/hi/ohayo") => 0;
lfs_file_open(&lfs, &file[0], "a/hello", LFS_O_CREAT | LFS_O_WRONLY) => 0;
lfs_file_write(&lfs, &file[0], "hola\n", 5) => 5;
lfs_file_write(&lfs, &file[0], "bonjour\n", 8) => 8;
lfs_file_write(&lfs, &file[0], "ohayo\n", 6) => 6;
lfs_file_close(&lfs, &file[0]) => 0;
lfs_unmount(&lfs) => 0;
lfs1_file_open(&lfs1, &file[0], "a/hello", LFS1_O_CREAT | LFS1_O_WRONLY) => 0;
lfs1_file_write(&lfs1, &file[0], "hola\n", 5) => 5;
lfs1_file_write(&lfs1, &file[0], "bonjour\n", 8) => 8;
lfs1_file_write(&lfs1, &file[0], "ohayo\n", 6) => 6;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Move file ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_rename(&lfs, "a/hello", "b/hello") => 0;
lfs_unmount(&lfs) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_rename(&lfs1, "a/hello", "b/hello") => 0;
lfs1_unmount(&lfs1) => 0;
TEST
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_dir_open(&lfs, &dir[0], "a") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_dir_open(&lfs1, &dir[0], "a") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "hi") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_dir_close(&lfs, &dir[0]) => 0;
lfs_dir_open(&lfs, &dir[0], "b") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_dir_close(&lfs1, &dir[0]) => 0;
lfs1_dir_open(&lfs1, &dir[0], "b") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "hello") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_unmount(&lfs) => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Move file corrupt source ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_rename(&lfs, "b/hello", "c/hello") => 0;
lfs_unmount(&lfs) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_rename(&lfs1, "b/hello", "c/hello") => 0;
lfs1_unmount(&lfs1) => 0;
TEST
rm -v blocks/7
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_dir_open(&lfs, &dir[0], "b") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_dir_open(&lfs1, &dir[0], "b") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_dir_close(&lfs, &dir[0]) => 0;
lfs_dir_open(&lfs, &dir[0], "c") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_dir_close(&lfs1, &dir[0]) => 0;
lfs1_dir_open(&lfs1, &dir[0], "c") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "hello") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_unmount(&lfs) => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Move file corrupt source and dest ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_rename(&lfs, "c/hello", "d/hello") => 0;
lfs_unmount(&lfs) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_rename(&lfs1, "c/hello", "d/hello") => 0;
lfs1_unmount(&lfs1) => 0;
TEST
rm -v blocks/8
rm -v blocks/a
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_dir_open(&lfs, &dir[0], "c") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_dir_open(&lfs1, &dir[0], "c") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "hello") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_dir_close(&lfs, &dir[0]) => 0;
lfs_dir_open(&lfs, &dir[0], "d") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_dir_close(&lfs1, &dir[0]) => 0;
lfs1_dir_open(&lfs1, &dir[0], "d") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_unmount(&lfs) => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Move dir ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_rename(&lfs, "a/hi", "b/hi") => 0;
lfs_unmount(&lfs) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_rename(&lfs1, "a/hi", "b/hi") => 0;
lfs1_unmount(&lfs1) => 0;
TEST
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_dir_open(&lfs, &dir[0], "a") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_dir_open(&lfs1, &dir[0], "a") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_dir_close(&lfs, &dir[0]) => 0;
lfs_dir_open(&lfs, &dir[0], "b") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_dir_close(&lfs1, &dir[0]) => 0;
lfs1_dir_open(&lfs1, &dir[0], "b") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "hi") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_unmount(&lfs) => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Move dir corrupt source ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_rename(&lfs, "b/hi", "c/hi") => 0;
lfs_unmount(&lfs) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_rename(&lfs1, "b/hi", "c/hi") => 0;
lfs1_unmount(&lfs1) => 0;
TEST
rm -v blocks/7
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_dir_open(&lfs, &dir[0], "b") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_dir_open(&lfs1, &dir[0], "b") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_dir_close(&lfs, &dir[0]) => 0;
lfs_dir_open(&lfs, &dir[0], "c") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_dir_close(&lfs1, &dir[0]) => 0;
lfs1_dir_open(&lfs1, &dir[0], "c") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "hello") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "hi") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_unmount(&lfs) => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Move dir corrupt source and dest ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_rename(&lfs, "c/hi", "d/hi") => 0;
lfs_unmount(&lfs) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_rename(&lfs1, "c/hi", "d/hi") => 0;
lfs1_unmount(&lfs1) => 0;
TEST
rm -v blocks/9
rm -v blocks/a
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_dir_open(&lfs, &dir[0], "c") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_dir_open(&lfs1, &dir[0], "c") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "hello") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "hi") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_dir_close(&lfs, &dir[0]) => 0;
lfs_dir_open(&lfs, &dir[0], "d") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_dir_close(&lfs1, &dir[0]) => 0;
lfs1_dir_open(&lfs1, &dir[0], "d") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_unmount(&lfs) => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Move check ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs_dir_open(&lfs, &dir[0], "a/hi") => LFS_ERR_NOENT;
lfs_dir_open(&lfs, &dir[0], "b/hi") => LFS_ERR_NOENT;
lfs_dir_open(&lfs, &dir[0], "d/hi") => LFS_ERR_NOENT;
lfs1_dir_open(&lfs1, &dir[0], "a/hi") => LFS1_ERR_NOENT;
lfs1_dir_open(&lfs1, &dir[0], "b/hi") => LFS1_ERR_NOENT;
lfs1_dir_open(&lfs1, &dir[0], "d/hi") => LFS1_ERR_NOENT;
lfs_dir_open(&lfs, &dir[0], "c/hi") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_open(&lfs1, &dir[0], "c/hi") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "hola") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "bonjour") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "ohayo") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 0;
lfs_dir_close(&lfs, &dir[0]) => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 0;
lfs1_dir_close(&lfs1, &dir[0]) => 0;
lfs_dir_open(&lfs, &dir[0], "a/hello") => LFS_ERR_NOENT;
lfs_dir_open(&lfs, &dir[0], "b/hello") => LFS_ERR_NOENT;
lfs_dir_open(&lfs, &dir[0], "d/hello") => LFS_ERR_NOENT;
lfs1_dir_open(&lfs1, &dir[0], "a/hello") => LFS1_ERR_NOENT;
lfs1_dir_open(&lfs1, &dir[0], "b/hello") => LFS1_ERR_NOENT;
lfs1_dir_open(&lfs1, &dir[0], "d/hello") => LFS1_ERR_NOENT;
lfs_file_open(&lfs, &file[0], "c/hello", LFS_O_RDONLY) => 0;
lfs_file_read(&lfs, &file[0], buffer, 5) => 5;
lfs1_file_open(&lfs1, &file[0], "c/hello", LFS1_O_RDONLY) => 0;
lfs1_file_read(&lfs1, &file[0], buffer, 5) => 5;
memcmp(buffer, "hola\n", 5) => 0;
lfs_file_read(&lfs, &file[0], buffer, 8) => 8;
lfs1_file_read(&lfs1, &file[0], buffer, 8) => 8;
memcmp(buffer, "bonjour\n", 8) => 0;
lfs_file_read(&lfs, &file[0], buffer, 6) => 6;
lfs1_file_read(&lfs1, &file[0], buffer, 6) => 6;
memcmp(buffer, "ohayo\n", 6) => 0;
lfs_file_close(&lfs, &file[0]) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
TEST

26
tests/test_orphan.sh
View File

@@ -4,37 +4,37 @@ set -eu
echo "=== Orphan tests ==="
rm -rf blocks
tests/test.py << TEST
lfs_format(&lfs, &cfg) => 0;
lfs1_format(&lfs1, &cfg) => 0;
TEST
echo "--- Orphan test ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_mkdir(&lfs, "parent") => 0;
lfs_mkdir(&lfs, "parent/orphan") => 0;
lfs_mkdir(&lfs, "parent/child") => 0;
lfs_remove(&lfs, "parent/orphan") => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_mkdir(&lfs1, "parent") => 0;
lfs1_mkdir(&lfs1, "parent/orphan") => 0;
lfs1_mkdir(&lfs1, "parent/child") => 0;
lfs1_remove(&lfs1, "parent/orphan") => 0;
TEST
# remove most recent file, this should be the update to the previous
# linked-list entry and should orphan the child
rm -v blocks/8
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_stat(&lfs, "parent/orphan", &info) => LFS_ERR_NOENT;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_stat(&lfs1, "parent/orphan", &info) => LFS1_ERR_NOENT;
unsigned before = 0;
lfs_traverse(&lfs, test_count, &before) => 0;
lfs1_traverse(&lfs1, test_count, &before) => 0;
test_log("before", before);
lfs_deorphan(&lfs) => 0;
lfs1_deorphan(&lfs1) => 0;
lfs_stat(&lfs, "parent/orphan", &info) => LFS_ERR_NOENT;
lfs1_stat(&lfs1, "parent/orphan", &info) => LFS1_ERR_NOENT;
unsigned after = 0;
lfs_traverse(&lfs, test_count, &after) => 0;
lfs1_traverse(&lfs1, test_count, &after) => 0;
test_log("after", after);
int diff = before - after;
diff => 2;
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Results ---"

134
tests/test_paths.sh
View File

@@ -4,139 +4,139 @@ set -eu
echo "=== Path tests ==="
rm -rf blocks
tests/test.py << TEST
lfs_format(&lfs, &cfg) => 0;
lfs1_format(&lfs1, &cfg) => 0;
TEST
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_mkdir(&lfs, "tea") => 0;
lfs_mkdir(&lfs, "coffee") => 0;
lfs_mkdir(&lfs, "soda") => 0;
lfs_mkdir(&lfs, "tea/hottea") => 0;
lfs_mkdir(&lfs, "tea/warmtea") => 0;
lfs_mkdir(&lfs, "tea/coldtea") => 0;
lfs_mkdir(&lfs, "coffee/hotcoffee") => 0;
lfs_mkdir(&lfs, "coffee/warmcoffee") => 0;
lfs_mkdir(&lfs, "coffee/coldcoffee") => 0;
lfs_mkdir(&lfs, "soda/hotsoda") => 0;
lfs_mkdir(&lfs, "soda/warmsoda") => 0;
lfs_mkdir(&lfs, "soda/coldsoda") => 0;
lfs_unmount(&lfs) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_mkdir(&lfs1, "tea") => 0;
lfs1_mkdir(&lfs1, "coffee") => 0;
lfs1_mkdir(&lfs1, "soda") => 0;
lfs1_mkdir(&lfs1, "tea/hottea") => 0;
lfs1_mkdir(&lfs1, "tea/warmtea") => 0;
lfs1_mkdir(&lfs1, "tea/coldtea") => 0;
lfs1_mkdir(&lfs1, "coffee/hotcoffee") => 0;
lfs1_mkdir(&lfs1, "coffee/warmcoffee") => 0;
lfs1_mkdir(&lfs1, "coffee/coldcoffee") => 0;
lfs1_mkdir(&lfs1, "soda/hotsoda") => 0;
lfs1_mkdir(&lfs1, "soda/warmsoda") => 0;
lfs1_mkdir(&lfs1, "soda/coldsoda") => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Root path tests ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_stat(&lfs, "tea/hottea", &info) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_stat(&lfs1, "tea/hottea", &info) => 0;
strcmp(info.name, "hottea") => 0;
lfs_stat(&lfs, "/tea/hottea", &info) => 0;
lfs1_stat(&lfs1, "/tea/hottea", &info) => 0;
strcmp(info.name, "hottea") => 0;
lfs_mkdir(&lfs, "/milk1") => 0;
lfs_stat(&lfs, "/milk1", &info) => 0;
lfs1_mkdir(&lfs1, "/milk1") => 0;
lfs1_stat(&lfs1, "/milk1", &info) => 0;
strcmp(info.name, "milk1") => 0;
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Redundant slash path tests ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_stat(&lfs, "/tea/hottea", &info) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_stat(&lfs1, "/tea/hottea", &info) => 0;
strcmp(info.name, "hottea") => 0;
lfs_stat(&lfs, "//tea//hottea", &info) => 0;
lfs1_stat(&lfs1, "//tea//hottea", &info) => 0;
strcmp(info.name, "hottea") => 0;
lfs_stat(&lfs, "///tea///hottea", &info) => 0;
lfs1_stat(&lfs1, "///tea///hottea", &info) => 0;
strcmp(info.name, "hottea") => 0;
lfs_mkdir(&lfs, "///milk2") => 0;
lfs_stat(&lfs, "///milk2", &info) => 0;
lfs1_mkdir(&lfs1, "///milk2") => 0;
lfs1_stat(&lfs1, "///milk2", &info) => 0;
strcmp(info.name, "milk2") => 0;
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Dot path tests ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_stat(&lfs, "./tea/hottea", &info) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_stat(&lfs1, "./tea/hottea", &info) => 0;
strcmp(info.name, "hottea") => 0;
lfs_stat(&lfs, "/./tea/hottea", &info) => 0;
lfs1_stat(&lfs1, "/./tea/hottea", &info) => 0;
strcmp(info.name, "hottea") => 0;
lfs_stat(&lfs, "/././tea/hottea", &info) => 0;
lfs1_stat(&lfs1, "/././tea/hottea", &info) => 0;
strcmp(info.name, "hottea") => 0;
lfs_stat(&lfs, "/./tea/./hottea", &info) => 0;
lfs1_stat(&lfs1, "/./tea/./hottea", &info) => 0;
strcmp(info.name, "hottea") => 0;
lfs_mkdir(&lfs, "/./milk3") => 0;
lfs_stat(&lfs, "/./milk3", &info) => 0;
lfs1_mkdir(&lfs1, "/./milk3") => 0;
lfs1_stat(&lfs1, "/./milk3", &info) => 0;
strcmp(info.name, "milk3") => 0;
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Dot dot path tests ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_stat(&lfs, "coffee/../tea/hottea", &info) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_stat(&lfs1, "coffee/../tea/hottea", &info) => 0;
strcmp(info.name, "hottea") => 0;
lfs_stat(&lfs, "tea/coldtea/../hottea", &info) => 0;
lfs1_stat(&lfs1, "tea/coldtea/../hottea", &info) => 0;
strcmp(info.name, "hottea") => 0;
lfs_stat(&lfs, "coffee/coldcoffee/../../tea/hottea", &info) => 0;
lfs1_stat(&lfs1, "coffee/coldcoffee/../../tea/hottea", &info) => 0;
strcmp(info.name, "hottea") => 0;
lfs_stat(&lfs, "coffee/../soda/../tea/hottea", &info) => 0;
lfs1_stat(&lfs1, "coffee/../soda/../tea/hottea", &info) => 0;
strcmp(info.name, "hottea") => 0;
lfs_mkdir(&lfs, "coffee/../milk4") => 0;
lfs_stat(&lfs, "coffee/../milk4", &info) => 0;
lfs1_mkdir(&lfs1, "coffee/../milk4") => 0;
lfs1_stat(&lfs1, "coffee/../milk4", &info) => 0;
strcmp(info.name, "milk4") => 0;
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Trailing dot path tests ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_stat(&lfs, "tea/hottea/", &info) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_stat(&lfs1, "tea/hottea/", &info) => 0;
strcmp(info.name, "hottea") => 0;
lfs_stat(&lfs, "tea/hottea/.", &info) => 0;
lfs1_stat(&lfs1, "tea/hottea/.", &info) => 0;
strcmp(info.name, "hottea") => 0;
lfs_stat(&lfs, "tea/hottea/./.", &info) => 0;
lfs1_stat(&lfs1, "tea/hottea/./.", &info) => 0;
strcmp(info.name, "hottea") => 0;
lfs_stat(&lfs, "tea/hottea/..", &info) => 0;
lfs1_stat(&lfs1, "tea/hottea/..", &info) => 0;
strcmp(info.name, "tea") => 0;
lfs_stat(&lfs, "tea/hottea/../.", &info) => 0;
lfs1_stat(&lfs1, "tea/hottea/../.", &info) => 0;
strcmp(info.name, "tea") => 0;
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Root dot dot path tests ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_stat(&lfs, "coffee/../../../../../../tea/hottea", &info) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_stat(&lfs1, "coffee/../../../../../../tea/hottea", &info) => 0;
strcmp(info.name, "hottea") => 0;
lfs_mkdir(&lfs, "coffee/../../../../../../milk5") => 0;
lfs_stat(&lfs, "coffee/../../../../../../milk5", &info) => 0;
lfs1_mkdir(&lfs1, "coffee/../../../../../../milk5") => 0;
lfs1_stat(&lfs1, "coffee/../../../../../../milk5", &info) => 0;
strcmp(info.name, "milk5") => 0;
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Root tests ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_stat(&lfs, "/", &info) => 0;
info.type => LFS_TYPE_DIR;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_stat(&lfs1, "/", &info) => 0;
info.type => LFS1_TYPE_DIR;
strcmp(info.name, "/") => 0;
lfs_mkdir(&lfs, "/") => LFS_ERR_EXIST;
lfs_file_open(&lfs, &file[0], "/", LFS_O_WRONLY | LFS_O_CREAT)
=> LFS_ERR_ISDIR;
lfs_unmount(&lfs) => 0;
lfs1_mkdir(&lfs1, "/") => LFS1_ERR_EXIST;
lfs1_file_open(&lfs1, &file[0], "/", LFS1_O_WRONLY | LFS1_O_CREAT)
=> LFS1_ERR_ISDIR;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Sketchy path tests ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_mkdir(&lfs, "dirt/ground") => LFS_ERR_NOENT;
lfs_mkdir(&lfs, "dirt/ground/earth") => LFS_ERR_NOENT;
lfs_unmount(&lfs) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_mkdir(&lfs1, "dirt/ground") => LFS1_ERR_NOENT;
lfs1_mkdir(&lfs1, "dirt/ground/earth") => LFS1_ERR_NOENT;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Results ---"

320
tests/test_seek.sh
View File

@@ -8,353 +8,353 @@ LARGESIZE=132
echo "=== Seek tests ==="
rm -rf blocks
tests/test.py << TEST
lfs_format(&lfs, &cfg) => 0;
lfs_mount(&lfs, &cfg) => 0;
lfs_mkdir(&lfs, "hello") => 0;
lfs1_format(&lfs1, &cfg) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_mkdir(&lfs1, "hello") => 0;
for (int i = 0; i < $LARGESIZE; i++) {
sprintf((char*)buffer, "hello/kitty%d", i);
lfs_file_open(&lfs, &file[0], (char*)buffer,
LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0;
lfs1_file_open(&lfs1, &file[0], (char*)buffer,
LFS1_O_WRONLY | LFS1_O_CREAT | LFS1_O_APPEND) => 0;
size = strlen("kittycatcat");
memcpy(buffer, "kittycatcat", size);
for (int j = 0; j < $LARGESIZE; j++) {
lfs_file_write(&lfs, &file[0], buffer, size);
lfs1_file_write(&lfs1, &file[0], buffer, size);
}
lfs_file_close(&lfs, &file[0]) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
}
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Simple dir seek ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_dir_open(&lfs, &dir[0], "hello") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_dir_open(&lfs1, &dir[0], "hello") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
lfs_soff_t pos;
lfs1_soff_t pos;
int i;
for (i = 0; i < $SMALLSIZE; i++) {
sprintf((char*)buffer, "kitty%d", i);
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, (char*)buffer) => 0;
pos = lfs_dir_tell(&lfs, &dir[0]);
pos = lfs1_dir_tell(&lfs1, &dir[0]);
}
pos >= 0 => 1;
lfs_dir_seek(&lfs, &dir[0], pos) => 0;
lfs1_dir_seek(&lfs1, &dir[0], pos) => 0;
sprintf((char*)buffer, "kitty%d", i);
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, (char*)buffer) => 0;
lfs_dir_rewind(&lfs, &dir[0]) => 0;
lfs1_dir_rewind(&lfs1, &dir[0]) => 0;
sprintf((char*)buffer, "kitty%d", 0);
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, (char*)buffer) => 0;
lfs_dir_seek(&lfs, &dir[0], pos) => 0;
lfs1_dir_seek(&lfs1, &dir[0], pos) => 0;
sprintf((char*)buffer, "kitty%d", i);
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, (char*)buffer) => 0;
lfs_dir_close(&lfs, &dir[0]) => 0;
lfs_unmount(&lfs) => 0;
lfs1_dir_close(&lfs1, &dir[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Large dir seek ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_dir_open(&lfs, &dir[0], "hello") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_dir_open(&lfs1, &dir[0], "hello") => 0;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
lfs_soff_t pos;
lfs1_soff_t pos;
int i;
for (i = 0; i < $MEDIUMSIZE; i++) {
sprintf((char*)buffer, "kitty%d", i);
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, (char*)buffer) => 0;
pos = lfs_dir_tell(&lfs, &dir[0]);
pos = lfs1_dir_tell(&lfs1, &dir[0]);
}
pos >= 0 => 1;
lfs_dir_seek(&lfs, &dir[0], pos) => 0;
lfs1_dir_seek(&lfs1, &dir[0], pos) => 0;
sprintf((char*)buffer, "kitty%d", i);
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, (char*)buffer) => 0;
lfs_dir_rewind(&lfs, &dir[0]) => 0;
lfs1_dir_rewind(&lfs1, &dir[0]) => 0;
sprintf((char*)buffer, "kitty%d", 0);
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, ".") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, "..") => 0;
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, (char*)buffer) => 0;
lfs_dir_seek(&lfs, &dir[0], pos) => 0;
lfs1_dir_seek(&lfs1, &dir[0], pos) => 0;
sprintf((char*)buffer, "kitty%d", i);
lfs_dir_read(&lfs, &dir[0], &info) => 1;
lfs1_dir_read(&lfs1, &dir[0], &info) => 1;
strcmp(info.name, (char*)buffer) => 0;
lfs_dir_close(&lfs, &dir[0]) => 0;
lfs_unmount(&lfs) => 0;
lfs1_dir_close(&lfs1, &dir[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Simple file seek ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_file_open(&lfs, &file[0], "hello/kitty42", LFS_O_RDONLY) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_file_open(&lfs1, &file[0], "hello/kitty42", LFS1_O_RDONLY) => 0;
lfs_soff_t pos;
lfs1_soff_t pos;
size = strlen("kittycatcat");
for (int i = 0; i < $SMALLSIZE; i++) {
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
pos = lfs_file_tell(&lfs, &file[0]);
pos = lfs1_file_tell(&lfs1, &file[0]);
}
pos >= 0 => 1;
lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_seek(&lfs1, &file[0], pos, LFS1_SEEK_SET) => pos;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs_file_rewind(&lfs, &file[0]) => 0;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_rewind(&lfs1, &file[0]) => 0;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_CUR) => size;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_seek(&lfs1, &file[0], 0, LFS1_SEEK_CUR) => size;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs_file_seek(&lfs, &file[0], size, LFS_SEEK_CUR) => 3*size;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_seek(&lfs1, &file[0], size, LFS1_SEEK_CUR) => 3*size;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_seek(&lfs1, &file[0], pos, LFS1_SEEK_SET) => pos;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs_file_seek(&lfs, &file[0], -size, LFS_SEEK_CUR) => pos;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_seek(&lfs1, &file[0], -size, LFS1_SEEK_CUR) => pos;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs_file_seek(&lfs, &file[0], -size, LFS_SEEK_END) >= 0 => 1;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_seek(&lfs1, &file[0], -size, LFS1_SEEK_END) >= 0 => 1;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
size = lfs_file_size(&lfs, &file[0]);
lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_CUR) => size;
size = lfs1_file_size(&lfs1, &file[0]);
lfs1_file_seek(&lfs1, &file[0], 0, LFS1_SEEK_CUR) => size;
lfs_file_close(&lfs, &file[0]) => 0;
lfs_unmount(&lfs) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Large file seek ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_file_open(&lfs, &file[0], "hello/kitty42", LFS_O_RDONLY) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_file_open(&lfs1, &file[0], "hello/kitty42", LFS1_O_RDONLY) => 0;
lfs_soff_t pos;
lfs1_soff_t pos;
size = strlen("kittycatcat");
for (int i = 0; i < $MEDIUMSIZE; i++) {
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
pos = lfs_file_tell(&lfs, &file[0]);
pos = lfs1_file_tell(&lfs1, &file[0]);
}
pos >= 0 => 1;
lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_seek(&lfs1, &file[0], pos, LFS1_SEEK_SET) => pos;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs_file_rewind(&lfs, &file[0]) => 0;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_rewind(&lfs1, &file[0]) => 0;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_CUR) => size;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_seek(&lfs1, &file[0], 0, LFS1_SEEK_CUR) => size;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs_file_seek(&lfs, &file[0], size, LFS_SEEK_CUR) => 3*size;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_seek(&lfs1, &file[0], size, LFS1_SEEK_CUR) => 3*size;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_seek(&lfs1, &file[0], pos, LFS1_SEEK_SET) => pos;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs_file_seek(&lfs, &file[0], -size, LFS_SEEK_CUR) => pos;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_seek(&lfs1, &file[0], -size, LFS1_SEEK_CUR) => pos;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs_file_seek(&lfs, &file[0], -size, LFS_SEEK_END) >= 0 => 1;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_seek(&lfs1, &file[0], -size, LFS1_SEEK_END) >= 0 => 1;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
size = lfs_file_size(&lfs, &file[0]);
lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_CUR) => size;
size = lfs1_file_size(&lfs1, &file[0]);
lfs1_file_seek(&lfs1, &file[0], 0, LFS1_SEEK_CUR) => size;
lfs_file_close(&lfs, &file[0]) => 0;
lfs_unmount(&lfs) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Simple file seek and write ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_file_open(&lfs, &file[0], "hello/kitty42", LFS_O_RDWR) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_file_open(&lfs1, &file[0], "hello/kitty42", LFS1_O_RDWR) => 0;
lfs_soff_t pos;
lfs1_soff_t pos;
size = strlen("kittycatcat");
for (int i = 0; i < $SMALLSIZE; i++) {
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
pos = lfs_file_tell(&lfs, &file[0]);
pos = lfs1_file_tell(&lfs1, &file[0]);
}
pos >= 0 => 1;
memcpy(buffer, "doggodogdog", size);
lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
lfs_file_write(&lfs, &file[0], buffer, size) => size;
lfs1_file_seek(&lfs1, &file[0], pos, LFS1_SEEK_SET) => pos;
lfs1_file_write(&lfs1, &file[0], buffer, size) => size;
lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_seek(&lfs1, &file[0], pos, LFS1_SEEK_SET) => pos;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "doggodogdog", size) => 0;
lfs_file_rewind(&lfs, &file[0]) => 0;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_rewind(&lfs1, &file[0]) => 0;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_seek(&lfs1, &file[0], pos, LFS1_SEEK_SET) => pos;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "doggodogdog", size) => 0;
lfs_file_seek(&lfs, &file[0], -size, LFS_SEEK_END) >= 0 => 1;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_seek(&lfs1, &file[0], -size, LFS1_SEEK_END) >= 0 => 1;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
size = lfs_file_size(&lfs, &file[0]);
lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_CUR) => size;
size = lfs1_file_size(&lfs1, &file[0]);
lfs1_file_seek(&lfs1, &file[0], 0, LFS1_SEEK_CUR) => size;
lfs_file_close(&lfs, &file[0]) => 0;
lfs_unmount(&lfs) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Large file seek and write ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_file_open(&lfs, &file[0], "hello/kitty42", LFS_O_RDWR) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_file_open(&lfs1, &file[0], "hello/kitty42", LFS1_O_RDWR) => 0;
lfs_soff_t pos;
lfs1_soff_t pos;
size = strlen("kittycatcat");
for (int i = 0; i < $MEDIUMSIZE; i++) {
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
if (i != $SMALLSIZE) {
memcmp(buffer, "kittycatcat", size) => 0;
}
pos = lfs_file_tell(&lfs, &file[0]);
pos = lfs1_file_tell(&lfs1, &file[0]);
}
pos >= 0 => 1;
memcpy(buffer, "doggodogdog", size);
lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
lfs_file_write(&lfs, &file[0], buffer, size) => size;
lfs1_file_seek(&lfs1, &file[0], pos, LFS1_SEEK_SET) => pos;
lfs1_file_write(&lfs1, &file[0], buffer, size) => size;
lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_seek(&lfs1, &file[0], pos, LFS1_SEEK_SET) => pos;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "doggodogdog", size) => 0;
lfs_file_rewind(&lfs, &file[0]) => 0;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_rewind(&lfs1, &file[0]) => 0;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_seek(&lfs1, &file[0], pos, LFS1_SEEK_SET) => pos;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "doggodogdog", size) => 0;
lfs_file_seek(&lfs, &file[0], -size, LFS_SEEK_END) >= 0 => 1;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_seek(&lfs1, &file[0], -size, LFS1_SEEK_END) >= 0 => 1;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
size = lfs_file_size(&lfs, &file[0]);
lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_CUR) => size;
size = lfs1_file_size(&lfs1, &file[0]);
lfs1_file_seek(&lfs1, &file[0], 0, LFS1_SEEK_CUR) => size;
lfs_file_close(&lfs, &file[0]) => 0;
lfs_unmount(&lfs) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Boundary seek and write ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_file_open(&lfs, &file[0], "hello/kitty42", LFS_O_RDWR) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_file_open(&lfs1, &file[0], "hello/kitty42", LFS1_O_RDWR) => 0;
size = strlen("hedgehoghog");
const lfs_soff_t offsets[] = {512, 1020, 513, 1021, 511, 1019};
const lfs1_soff_t offsets[] = {512, 1020, 513, 1021, 511, 1019};
for (unsigned i = 0; i < sizeof(offsets) / sizeof(offsets[0]); i++) {
lfs_soff_t off = offsets[i];
lfs1_soff_t off = offsets[i];
memcpy(buffer, "hedgehoghog", size);
lfs_file_seek(&lfs, &file[0], off, LFS_SEEK_SET) => off;
lfs_file_write(&lfs, &file[0], buffer, size) => size;
lfs_file_seek(&lfs, &file[0], off, LFS_SEEK_SET) => off;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_seek(&lfs1, &file[0], off, LFS1_SEEK_SET) => off;
lfs1_file_write(&lfs1, &file[0], buffer, size) => size;
lfs1_file_seek(&lfs1, &file[0], off, LFS1_SEEK_SET) => off;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "hedgehoghog", size) => 0;
lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_SET) => 0;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_seek(&lfs1, &file[0], 0, LFS1_SEEK_SET) => 0;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs_file_sync(&lfs, &file[0]) => 0;
lfs1_file_sync(&lfs1, &file[0]) => 0;
}
lfs_file_close(&lfs, &file[0]) => 0;
lfs_unmount(&lfs) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Out-of-bounds seek ---"
tests/test.py << TEST
lfs_mount(&lfs, &cfg) => 0;
lfs_file_open(&lfs, &file[0], "hello/kitty42", LFS_O_RDWR) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
lfs1_file_open(&lfs1, &file[0], "hello/kitty42", LFS1_O_RDWR) => 0;
size = strlen("kittycatcat");
lfs_file_size(&lfs, &file[0]) => $LARGESIZE*size;
lfs_file_seek(&lfs, &file[0], ($LARGESIZE+$SMALLSIZE)*size,
LFS_SEEK_SET) => ($LARGESIZE+$SMALLSIZE)*size;
lfs_file_read(&lfs, &file[0], buffer, size) => 0;
lfs1_file_size(&lfs1, &file[0]) => $LARGESIZE*size;
lfs1_file_seek(&lfs1, &file[0], ($LARGESIZE+$SMALLSIZE)*size,
LFS1_SEEK_SET) => ($LARGESIZE+$SMALLSIZE)*size;
lfs1_file_read(&lfs1, &file[0], buffer, size) => 0;
memcpy(buffer, "porcupineee", size);
lfs_file_write(&lfs, &file[0], buffer, size) => size;
lfs1_file_write(&lfs1, &file[0], buffer, size) => size;
lfs_file_seek(&lfs, &file[0], ($LARGESIZE+$SMALLSIZE)*size,
LFS_SEEK_SET) => ($LARGESIZE+$SMALLSIZE)*size;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_seek(&lfs1, &file[0], ($LARGESIZE+$SMALLSIZE)*size,
LFS1_SEEK_SET) => ($LARGESIZE+$SMALLSIZE)*size;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "porcupineee", size) => 0;
lfs_file_seek(&lfs, &file[0], $LARGESIZE*size,
LFS_SEEK_SET) => $LARGESIZE*size;
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_seek(&lfs1, &file[0], $LARGESIZE*size,
LFS1_SEEK_SET) => $LARGESIZE*size;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "\0\0\0\0\0\0\0\0\0\0\0", size) => 0;
lfs_file_seek(&lfs, &file[0], -(($LARGESIZE+$SMALLSIZE)*size),
LFS_SEEK_CUR) => LFS_ERR_INVAL;
lfs_file_tell(&lfs, &file[0]) => ($LARGESIZE+1)*size;
lfs1_file_seek(&lfs1, &file[0], -(($LARGESIZE+$SMALLSIZE)*size),
LFS1_SEEK_CUR) => LFS1_ERR_INVAL;
lfs1_file_tell(&lfs1, &file[0]) => ($LARGESIZE+1)*size;
lfs_file_seek(&lfs, &file[0], -(($LARGESIZE+2*$SMALLSIZE)*size),
LFS_SEEK_END) => LFS_ERR_INVAL;
lfs_file_tell(&lfs, &file[0]) => ($LARGESIZE+1)*size;
lfs1_file_seek(&lfs1, &file[0], -(($LARGESIZE+2*$SMALLSIZE)*size),
LFS1_SEEK_END) => LFS1_ERR_INVAL;
lfs1_file_tell(&lfs1, &file[0]) => ($LARGESIZE+1)*size;
lfs_file_close(&lfs, &file[0]) => 0;
lfs_unmount(&lfs) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
echo "--- Results ---"

80
tests/test_truncate.sh
View File

@@ -8,7 +8,7 @@ LARGESIZE=8192
echo "=== Truncate tests ==="
rm -rf blocks
tests/test.py << TEST
lfs_format(&lfs, &cfg) => 0;
lfs1_format(&lfs1, &cfg) => 0;
TEST
truncate_test() {
@@ -17,98 +17,98 @@ STARTSEEKS="$2"
HOTSIZES="$3"
COLDSIZES="$4"
tests/test.py << TEST
static const lfs_off_t startsizes[] = {$STARTSIZES};
static const lfs_off_t startseeks[] = {$STARTSEEKS};
static const lfs_off_t hotsizes[] = {$HOTSIZES};
static const lfs1_off_t startsizes[] = {$STARTSIZES};
static const lfs1_off_t startseeks[] = {$STARTSEEKS};
static const lfs1_off_t hotsizes[] = {$HOTSIZES};
lfs_mount(&lfs, &cfg) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
for (unsigned i = 0; i < sizeof(startsizes)/sizeof(startsizes[0]); i++) {
sprintf((char*)buffer, "hairyhead%d", i);
lfs_file_open(&lfs, &file[0], (const char*)buffer,
LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0;
lfs1_file_open(&lfs1, &file[0], (const char*)buffer,
LFS1_O_WRONLY | LFS1_O_CREAT | LFS1_O_TRUNC) => 0;
strcpy((char*)buffer, "hair");
size = strlen((char*)buffer);
for (lfs_off_t j = 0; j < startsizes[i]; j += size) {
lfs_file_write(&lfs, &file[0], buffer, size) => size;
for (lfs1_off_t j = 0; j < startsizes[i]; j += size) {
lfs1_file_write(&lfs1, &file[0], buffer, size) => size;
}
lfs_file_size(&lfs, &file[0]) => startsizes[i];
lfs1_file_size(&lfs1, &file[0]) => startsizes[i];
if (startseeks[i] != startsizes[i]) {
lfs_file_seek(&lfs, &file[0],
startseeks[i], LFS_SEEK_SET) => startseeks[i];
lfs1_file_seek(&lfs1, &file[0],
startseeks[i], LFS1_SEEK_SET) => startseeks[i];
}
lfs_file_truncate(&lfs, &file[0], hotsizes[i]) => 0;
lfs_file_size(&lfs, &file[0]) => hotsizes[i];
lfs1_file_truncate(&lfs1, &file[0], hotsizes[i]) => 0;
lfs1_file_size(&lfs1, &file[0]) => hotsizes[i];
lfs_file_close(&lfs, &file[0]) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
}
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
tests/test.py << TEST
static const lfs_off_t startsizes[] = {$STARTSIZES};
static const lfs_off_t hotsizes[] = {$HOTSIZES};
static const lfs_off_t coldsizes[] = {$COLDSIZES};
static const lfs1_off_t startsizes[] = {$STARTSIZES};
static const lfs1_off_t hotsizes[] = {$HOTSIZES};
static const lfs1_off_t coldsizes[] = {$COLDSIZES};
lfs_mount(&lfs, &cfg) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
for (unsigned i = 0; i < sizeof(startsizes)/sizeof(startsizes[0]); i++) {
sprintf((char*)buffer, "hairyhead%d", i);
lfs_file_open(&lfs, &file[0], (const char*)buffer, LFS_O_RDWR) => 0;
lfs_file_size(&lfs, &file[0]) => hotsizes[i];
lfs1_file_open(&lfs1, &file[0], (const char*)buffer, LFS1_O_RDWR) => 0;
lfs1_file_size(&lfs1, &file[0]) => hotsizes[i];
size = strlen("hair");
lfs_off_t j = 0;
lfs1_off_t j = 0;
for (; j < startsizes[i] && j < hotsizes[i]; j += size) {
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "hair", size) => 0;
}
for (; j < hotsizes[i]; j += size) {
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "\0\0\0\0", size) => 0;
}
lfs_file_truncate(&lfs, &file[0], coldsizes[i]) => 0;
lfs_file_size(&lfs, &file[0]) => coldsizes[i];
lfs1_file_truncate(&lfs1, &file[0], coldsizes[i]) => 0;
lfs1_file_size(&lfs1, &file[0]) => coldsizes[i];
lfs_file_close(&lfs, &file[0]) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
}
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
tests/test.py << TEST
static const lfs_off_t startsizes[] = {$STARTSIZES};
static const lfs_off_t hotsizes[] = {$HOTSIZES};
static const lfs_off_t coldsizes[] = {$COLDSIZES};
static const lfs1_off_t startsizes[] = {$STARTSIZES};
static const lfs1_off_t hotsizes[] = {$HOTSIZES};
static const lfs1_off_t coldsizes[] = {$COLDSIZES};
lfs_mount(&lfs, &cfg) => 0;
lfs1_mount(&lfs1, &cfg) => 0;
for (unsigned i = 0; i < sizeof(startsizes)/sizeof(startsizes[0]); i++) {
sprintf((char*)buffer, "hairyhead%d", i);
lfs_file_open(&lfs, &file[0], (const char*)buffer, LFS_O_RDONLY) => 0;
lfs_file_size(&lfs, &file[0]) => coldsizes[i];
lfs1_file_open(&lfs1, &file[0], (const char*)buffer, LFS1_O_RDONLY) => 0;
lfs1_file_size(&lfs1, &file[0]) => coldsizes[i];
size = strlen("hair");
lfs_off_t j = 0;
lfs1_off_t j = 0;
for (; j < startsizes[i] && j < hotsizes[i] && j < coldsizes[i];
j += size) {
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "hair", size) => 0;
}
for (; j < coldsizes[i]; j += size) {
lfs_file_read(&lfs, &file[0], buffer, size) => size;
lfs1_file_read(&lfs1, &file[0], buffer, size) => size;
memcmp(buffer, "\0\0\0\0", size) => 0;
}
lfs_file_close(&lfs, &file[0]) => 0;
lfs1_file_close(&lfs1, &file[0]) => 0;
}
lfs_unmount(&lfs) => 0;
lfs1_unmount(&lfs1) => 0;
TEST
}