github-mirrors/thirdparty-littlefs
1
0
Fork 0
mirror of https://github.com/eledio-devices/thirdparty-littlefs.git synced 2025-10-31 08:42:40 +01:00
Code Issues Packages Projects Releases Wiki Activity

Generated v2 prefixes

Browse Source
This commit is contained in:
geky bot
2019-07-29 07:12:22 +00:00
parent bc7be77625 db054684a6
commit c08e977799
27 changed files with 1818 additions and 1331 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
tests/corrupt.py
View File

@@ -1,44 +0,0 @@
#!/usr/bin/env python2
import struct
import sys
import os
import argparse
def corrupt(block):
with open(block, 'r+b') as file:
# skip rev
file.read(4)
# go to last commit
tag = 0xffffffff
while True:
try:
ntag, = struct.unpack('>I', file.read(4))
except struct.error:
break
tag ^= ntag
size = (tag & 0x3ff) if (tag & 0x3ff) != 0x3ff else 0
file.seek(size, os.SEEK_CUR)
# lob off last 3 bytes
file.seek(-(size + 3), os.SEEK_CUR)
file.truncate()
def main(args):
if args.n or not args.blocks:
with open('blocks/.history', 'rb') as file:
for i in range(int(args.n or 1)):
last, = struct.unpack('<I', file.read(4))
args.blocks.append('blocks/%x' % last)
for block in args.blocks:
print 'corrupting %s' % block
corrupt(block)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument('-n')
parser.add_argument('blocks', nargs='*')
main(parser.parse_args())

112
tests/debug.py
View File

@@ -1,112 +0,0 @@
#!/usr/bin/env python2
import struct
import binascii
TYPES = {
(0x700, 0x400): 'splice',
(0x7ff, 0x401): 'create',
(0x7ff, 0x4ff): 'delete',
(0x700, 0x000): 'name',
(0x7ff, 0x001): 'name reg',
(0x7ff, 0x002): 'name dir',
(0x7ff, 0x0ff): 'name superblock',
(0x700, 0x200): 'struct',
(0x7ff, 0x200): 'struct dir',
(0x7ff, 0x202): 'struct ctz',
(0x7ff, 0x201): 'struct inline',
(0x700, 0x300): 'userattr',
(0x700, 0x600): 'tail',
(0x7ff, 0x600): 'tail soft',
(0x7ff, 0x601): 'tail hard',
(0x700, 0x700): 'gstate',
(0x7ff, 0x7ff): 'gstate move',
(0x700, 0x500): 'crc',
}
def typeof(type):
for prefix in range(12):
mask = 0x7ff & ~((1 << prefix)-1)
if (mask, type & mask) in TYPES:
return TYPES[mask, type & mask] + (
' %0*x' % (prefix/4, type & ((1 << prefix)-1))
if prefix else '')
else:
return '%02x' % type
def main(*blocks):
# find most recent block
file = None
rev = None
crc = None
versions = []
for block in blocks:
try:
nfile = open(block, 'rb')
ndata = nfile.read(4)
ncrc = binascii.crc32(ndata)
nrev, = struct.unpack('<I', ndata)
assert rev != nrev
if not file or ((rev - nrev) & 0x80000000):
file = nfile
rev = nrev
crc = ncrc
versions.append((nrev, '%s (rev %d)' % (block, nrev)))
except (IOError, struct.error):
pass
if not file:
print 'Bad metadata pair {%s}' % ', '.join(blocks)
return 1
print "--- %s ---" % ', '.join(v for _,v in sorted(versions, reverse=True))
# go through each tag, print useful information
print "%-4s %-8s %-14s %3s %4s %s" % (
'off', 'tag', 'type', 'id', 'len', 'dump')
tag = 0xffffffff
off = 4
while True:
try:
data = file.read(4)
crc = binascii.crc32(data, crc)
ntag, = struct.unpack('>I', data)
except struct.error:
break
tag ^= ntag
off += 4
type = (tag & 0x7ff00000) >> 20
id = (tag & 0x000ffc00) >> 10
size = (tag & 0x000003ff) >> 0
iscrc = (type & 0x700) == 0x500
data = file.read(size if size != 0x3ff else 0)
if iscrc:
crc = binascii.crc32(data[:4], crc)
else:
crc = binascii.crc32(data, crc)
print '%04x: %08x %-15s %3s %4s %-23s %-8s' % (
off, tag,
typeof(type) + (' bad!' if iscrc and ~crc else ''),
id if id != 0x3ff else '.',
size if size != 0x3ff else 'x',
' '.join('%02x' % ord(c) for c in data[:8]),
''.join(c if c >= ' ' and c <= '~' else '.' for c in data[:8]))
off += size if size != 0x3ff else 0
if iscrc:
crc = 0
tag ^= (type & 1) << 31
return 0
if __name__ == "__main__":
import sys
sys.exit(main(*sys.argv[1:]))

30
tests/stats.py
View File

@@ -1,30 +0,0 @@
#!/usr/bin/env python2
import struct
import sys
import time
import os
import re
def main():
with open('blocks/.config') as file:
s = struct.unpack('<LLLL', file.read())
print 'read_size: %d' % s[0]
print 'prog_size: %d' % s[1]
print 'block_size: %d' % s[2]
print 'block_size: %d' % s[3]
print 'real_size: %d' % sum(
os.path.getsize(os.path.join('blocks', f))
for f in os.listdir('blocks') if re.match('\d+', f))
with open('blocks/.stats') as file:
s = struct.unpack('<QQQ', file.read())
print 'read_count: %d' % s[0]
print 'prog_count: %d' % s[1]
print 'erase_count: %d' % s[2]
print 'runtime: %.3f' % (time.time() - os.stat('blocks').st_ctime)
if __name__ == "__main__":
main(*sys.argv[1:])

116
tests/template.fmt
View File

@@ -1,116 +0,0 @@
/// AUTOGENERATED TEST ///
#include "lfs2.h"
#include "emubd/lfs2_emubd.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
// test stuff
static void test_log(const char *s, uintmax_t v) {{
printf("%s: %jd\n", s, v);
}}
static void test_assert(const char *file, unsigned line,
const char *s, uintmax_t v, uintmax_t e) {{
static const char *last[6] = {{0, 0}};
if (v != e || !(last[0] == s || last[1] == s ||
last[2] == s || last[3] == s ||
last[4] == s || last[5] == s)) {{
test_log(s, v);
last[0] = last[1];
last[1] = last[2];
last[2] = last[3];
last[3] = last[4];
last[4] = last[5];
last[5] = s;
}}
if (v != e) {{
fprintf(stderr, "\033[31m%s:%u: assert %s failed with %jd, "
"expected %jd\033[0m\n", file, line, s, v, e);
exit(-2);
}}
}}
#define test_assert(s, v, e) test_assert(__FILE__, __LINE__, s, v, e)
// utility functions for traversals
static int __attribute__((used)) test_count(void *p, lfs2_block_t b) {{
(void)b;
unsigned *u = (unsigned*)p;
*u += 1;
return 0;
}}
// lfs2 declarations
lfs2_t lfs2;
lfs2_emubd_t bd;
lfs2_file_t file[4];
lfs2_dir_t dir[4];
struct lfs2_info info;
uint8_t buffer[1024];
uint8_t wbuffer[1024];
uint8_t rbuffer[1024];
lfs2_size_t size;
lfs2_size_t wsize;
lfs2_size_t rsize;
uintmax_t test;
#ifndef LFS2_READ_SIZE
#define LFS2_READ_SIZE 16
#endif
#ifndef LFS2_PROG_SIZE
#define LFS2_PROG_SIZE LFS2_READ_SIZE
#endif
#ifndef LFS2_BLOCK_SIZE
#define LFS2_BLOCK_SIZE 512
#endif
#ifndef LFS2_BLOCK_COUNT
#define LFS2_BLOCK_COUNT 1024
#endif
#ifndef LFS2_BLOCK_CYCLES
#define LFS2_BLOCK_CYCLES 1024
#endif
#ifndef LFS2_CACHE_SIZE
#define LFS2_CACHE_SIZE 64
#endif
#ifndef LFS2_LOOKAHEAD_SIZE
#define LFS2_LOOKAHEAD_SIZE 16
#endif
const struct lfs2_config cfg = {{
.context = &bd,
.read = &lfs2_emubd_read,
.prog = &lfs2_emubd_prog,
.erase = &lfs2_emubd_erase,
.sync = &lfs2_emubd_sync,
.read_size = LFS2_READ_SIZE,
.prog_size = LFS2_PROG_SIZE,
.block_size = LFS2_BLOCK_SIZE,
.block_count = LFS2_BLOCK_COUNT,
.block_cycles = LFS2_BLOCK_CYCLES,
.cache_size = LFS2_CACHE_SIZE,
.lookahead_size = LFS2_LOOKAHEAD_SIZE,
}};
// Entry point
int main(void) {{
lfs2_emubd_create(&cfg, "blocks");
{tests}
lfs2_emubd_destroy(&cfg);
}}

61
tests/test.py
View File

@@ -1,61 +0,0 @@
#!/usr/bin/env python2
import re
import sys
import subprocess
import os
def generate(test):
with open("tests/template.fmt") as file:
template = file.read()
lines = []
for line in re.split('(?<=(?:.;| [{}]))\n', test.read()):
match = re.match('(?: *\n)*( *)(.*)=>(.*);', line, re.DOTALL | re.MULTILINE)
if match:
tab, test, expect = match.groups()
lines.append(tab+'test = {test};'.format(test=test.strip()))
lines.append(tab+'test_assert("{name}", test, {expect});'.format(
name = re.match('\w*', test.strip()).group(),
expect = expect.strip()))
else:
lines.append(line)
# Create test file
with open('test.c', 'w') as file:
file.write(template.format(tests='\n'.join(lines)))
# Remove build artifacts to force rebuild
try:
os.remove('test.o')
os.remove('lfs2')
except OSError:
pass
def compile():
subprocess.check_call([
os.environ.get('MAKE', 'make'),
'--no-print-directory', '-s'])
def execute():
if 'EXEC' in os.environ:
subprocess.check_call([os.environ['EXEC'], "./lfs2"])
else:
subprocess.check_call(["./lfs2"])
def main(test=None):
if test and not test.startswith('-'):
with open(test) as file:
generate(file)
else:
generate(sys.stdin)
compile()
if test == '-s':
sys.exit(1)
execute()
if __name__ == "__main__":
main(*sys.argv[1:])

251
tests/test_alloc.sh
View File

@@ -1,16 +1,18 @@
#!/bin/bash
set -eu
set -euE
export TEST_FILE=$0
trap 'export TEST_LINE=$LINENO' DEBUG
echo "=== Allocator tests ==="
rm -rf blocks
tests/test.py << TEST
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
TEST
SIZE=15000
lfs2_mkdir() {
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_mkdir(&lfs2, "$1") => 0;
lfs2_unmount(&lfs2) => 0;
@@ -18,7 +20,7 @@ TEST
}
lfs2_remove() {
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_remove(&lfs2, "$1/eggs") => 0;
lfs2_remove(&lfs2, "$1/bacon") => 0;
@@ -29,22 +31,23 @@ TEST
}
lfs2_alloc_singleproc() {
tests/test.py << TEST
scripts/test.py << TEST
const char *names[] = {"bacon", "eggs", "pancakes"};
lfs2_file_t files[sizeof(names)/sizeof(names[0])];
lfs2_mount(&lfs2, &cfg) => 0;
for (unsigned n = 0; n < sizeof(names)/sizeof(names[0]); n++) {
sprintf((char*)buffer, "$1/%s", names[n]);
lfs2_file_open(&lfs2, &file[n], (char*)buffer,
sprintf(path, "$1/%s", names[n]);
lfs2_file_open(&lfs2, &files[n], path,
LFS2_O_WRONLY | LFS2_O_CREAT | LFS2_O_APPEND) => 0;
}
for (unsigned n = 0; n < sizeof(names)/sizeof(names[0]); n++) {
size = strlen(names[n]);
lfs2_size_t size = strlen(names[n]);
for (int i = 0; i < $SIZE; i++) {
lfs2_file_write(&lfs2, &file[n], names[n], size) => size;
lfs2_file_write(&lfs2, &files[n], names[n], size) => size;
}
}
for (unsigned n = 0; n < sizeof(names)/sizeof(names[0]); n++) {
lfs2_file_close(&lfs2, &file[n]) => 0;
lfs2_file_close(&lfs2, &files[n]) => 0;
}
lfs2_unmount(&lfs2) => 0;
TEST
@@ -53,16 +56,16 @@ TEST
lfs2_alloc_multiproc() {
for name in bacon eggs pancakes
do
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "$1/$name",
lfs2_file_open(&lfs2, &file, "$1/$name",
LFS2_O_WRONLY | LFS2_O_CREAT | LFS2_O_APPEND) => 0;
size = strlen("$name");
lfs2_size_t size = strlen("$name");
memcpy(buffer, "$name", size);
for (int i = 0; i < $SIZE; i++) {
lfs2_file_write(&lfs2, &file[0], buffer, size) => size;
lfs2_file_write(&lfs2, &file, buffer, size) => size;
}
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
done
@@ -71,15 +74,15 @@ done
lfs2_verify() {
for name in bacon eggs pancakes
do
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "$1/$name", LFS2_O_RDONLY) => 0;
size = strlen("$name");
lfs2_file_open(&lfs2, &file, "$1/$name", LFS2_O_RDONLY) => 0;
lfs2_size_t size = strlen("$name");
for (int i = 0; i < $SIZE; i++) {
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "$name", size) => 0;
}
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
done
@@ -115,19 +118,19 @@ lfs2_remove multiprocreuse
lfs2_remove singleprocreuse
echo "--- Exhaustion test ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "exhaustion", LFS2_O_WRONLY | LFS2_O_CREAT);
size = strlen("exhaustion");
lfs2_file_open(&lfs2, &file, "exhaustion", LFS2_O_WRONLY | LFS2_O_CREAT);
lfs2_size_t size = strlen("exhaustion");
memcpy(buffer, "exhaustion", size);
lfs2_file_write(&lfs2, &file[0], buffer, size) => size;
lfs2_file_sync(&lfs2, &file[0]) => 0;
lfs2_file_write(&lfs2, &file, buffer, size) => size;
lfs2_file_sync(&lfs2, &file) => 0;
size = strlen("blahblahblahblah");
memcpy(buffer, "blahblahblahblah", size);
lfs2_ssize_t res;
while (true) {
res = lfs2_file_write(&lfs2, &file[0], buffer, size);
res = lfs2_file_write(&lfs2, &file, buffer, size);
if (res < 0) {
break;
}
@@ -136,45 +139,45 @@ tests/test.py << TEST
}
res => LFS2_ERR_NOSPC;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "exhaustion", LFS2_O_RDONLY);
size = strlen("exhaustion");
lfs2_file_size(&lfs2, &file[0]) => size;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_open(&lfs2, &file, "exhaustion", LFS2_O_RDONLY);
lfs2_size_t size = strlen("exhaustion");
lfs2_file_size(&lfs2, &file) => size;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "exhaustion", size) => 0;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Exhaustion wraparound test ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_remove(&lfs2, "exhaustion") => 0;
lfs2_file_open(&lfs2, &file[0], "padding", LFS2_O_WRONLY | LFS2_O_CREAT);
size = strlen("buffering");
lfs2_file_open(&lfs2, &file, "padding", LFS2_O_WRONLY | LFS2_O_CREAT);
lfs2_size_t size = strlen("buffering");
memcpy(buffer, "buffering", size);
for (int i = 0; i < $SIZE; i++) {
lfs2_file_write(&lfs2, &file[0], buffer, size) => size;
lfs2_file_write(&lfs2, &file, buffer, size) => size;
}
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_remove(&lfs2, "padding") => 0;
lfs2_file_open(&lfs2, &file[0], "exhaustion", LFS2_O_WRONLY | LFS2_O_CREAT);
lfs2_file_open(&lfs2, &file, "exhaustion", LFS2_O_WRONLY | LFS2_O_CREAT);
size = strlen("exhaustion");
memcpy(buffer, "exhaustion", size);
lfs2_file_write(&lfs2, &file[0], buffer, size) => size;
lfs2_file_sync(&lfs2, &file[0]) => 0;
lfs2_file_write(&lfs2, &file, buffer, size) => size;
lfs2_file_sync(&lfs2, &file) => 0;
size = strlen("blahblahblahblah");
memcpy(buffer, "blahblahblahblah", size);
lfs2_ssize_t res;
while (true) {
res = lfs2_file_write(&lfs2, &file[0], buffer, size);
res = lfs2_file_write(&lfs2, &file, buffer, size);
if (res < 0) {
break;
}
@@ -183,34 +186,34 @@ tests/test.py << TEST
}
res => LFS2_ERR_NOSPC;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "exhaustion", LFS2_O_RDONLY);
size = strlen("exhaustion");
lfs2_file_size(&lfs2, &file[0]) => size;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_open(&lfs2, &file, "exhaustion", LFS2_O_RDONLY);
lfs2_size_t size = strlen("exhaustion");
lfs2_file_size(&lfs2, &file) => size;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "exhaustion", size) => 0;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_remove(&lfs2, "exhaustion") => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Dir exhaustion test ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
// find out max file size
lfs2_mkdir(&lfs2, "exhaustiondir") => 0;
size = strlen("blahblahblahblah");
lfs2_size_t size = strlen("blahblahblahblah");
memcpy(buffer, "blahblahblahblah", size);
lfs2_file_open(&lfs2, &file[0], "exhaustion", LFS2_O_WRONLY | LFS2_O_CREAT);
lfs2_file_open(&lfs2, &file, "exhaustion", LFS2_O_WRONLY | LFS2_O_CREAT);
int count = 0;
int err;
while (true) {
err = lfs2_file_write(&lfs2, &file[0], buffer, size);
err = lfs2_file_write(&lfs2, &file, buffer, size);
if (err < 0) {
break;
}
@@ -218,28 +221,28 @@ tests/test.py << TEST
count += 1;
}
err => LFS2_ERR_NOSPC;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_remove(&lfs2, "exhaustion") => 0;
lfs2_remove(&lfs2, "exhaustiondir") => 0;
// see if dir fits with max file size
lfs2_file_open(&lfs2, &file[0], "exhaustion", LFS2_O_WRONLY | LFS2_O_CREAT);
lfs2_file_open(&lfs2, &file, "exhaustion", LFS2_O_WRONLY | LFS2_O_CREAT);
for (int i = 0; i < count; i++) {
lfs2_file_write(&lfs2, &file[0], buffer, size) => size;
lfs2_file_write(&lfs2, &file, buffer, size) => size;
}
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_mkdir(&lfs2, "exhaustiondir") => 0;
lfs2_remove(&lfs2, "exhaustiondir") => 0;
lfs2_remove(&lfs2, "exhaustion") => 0;
// see if dir fits with > max file size
lfs2_file_open(&lfs2, &file[0], "exhaustion", LFS2_O_WRONLY | LFS2_O_CREAT);
lfs2_file_open(&lfs2, &file, "exhaustion", LFS2_O_WRONLY | LFS2_O_CREAT);
for (int i = 0; i < count+1; i++) {
lfs2_file_write(&lfs2, &file[0], buffer, size) => size;
lfs2_file_write(&lfs2, &file, buffer, size) => size;
}
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_mkdir(&lfs2, "exhaustiondir") => LFS2_ERR_NOSPC;
@@ -248,22 +251,22 @@ tests/test.py << TEST
TEST
echo "--- Chained dir exhaustion test ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
// find out max file size
lfs2_mkdir(&lfs2, "exhaustiondir") => 0;
for (int i = 0; i < 10; i++) {
sprintf((char*)buffer, "dirwithanexhaustivelylongnameforpadding%d", i);
lfs2_mkdir(&lfs2, (char*)buffer) => 0;
sprintf(path, "dirwithanexhaustivelylongnameforpadding%d", i);
lfs2_mkdir(&lfs2, path) => 0;
}
size = strlen("blahblahblahblah");
lfs2_size_t size = strlen("blahblahblahblah");
memcpy(buffer, "blahblahblahblah", size);
lfs2_file_open(&lfs2, &file[0], "exhaustion", LFS2_O_WRONLY | LFS2_O_CREAT);
lfs2_file_open(&lfs2, &file, "exhaustion", LFS2_O_WRONLY | LFS2_O_CREAT);
int count = 0;
int err;
while (true) {
err = lfs2_file_write(&lfs2, &file[0], buffer, size);
err = lfs2_file_write(&lfs2, &file, buffer, size);
if (err < 0) {
break;
}
@@ -271,25 +274,25 @@ tests/test.py << TEST
count += 1;
}
err => LFS2_ERR_NOSPC;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_remove(&lfs2, "exhaustion") => 0;
lfs2_remove(&lfs2, "exhaustiondir") => 0;
for (int i = 0; i < 10; i++) {
sprintf((char*)buffer, "dirwithanexhaustivelylongnameforpadding%d", i);
lfs2_remove(&lfs2, (char*)buffer) => 0;
sprintf(path, "dirwithanexhaustivelylongnameforpadding%d", i);
lfs2_remove(&lfs2, path) => 0;
}
// see that chained dir fails
lfs2_file_open(&lfs2, &file[0], "exhaustion", LFS2_O_WRONLY | LFS2_O_CREAT);
lfs2_file_open(&lfs2, &file, "exhaustion", LFS2_O_WRONLY | LFS2_O_CREAT);
for (int i = 0; i < count+1; i++) {
lfs2_file_write(&lfs2, &file[0], buffer, size) => size;
lfs2_file_write(&lfs2, &file, buffer, size) => size;
}
lfs2_file_sync(&lfs2, &file[0]) => 0;
lfs2_file_sync(&lfs2, &file) => 0;
for (int i = 0; i < 10; i++) {
sprintf((char*)buffer, "dirwithanexhaustivelylongnameforpadding%d", i);
lfs2_mkdir(&lfs2, (char*)buffer) => 0;
sprintf(path, "dirwithanexhaustivelylongnameforpadding%d", i);
lfs2_mkdir(&lfs2, path) => 0;
}
lfs2_mkdir(&lfs2, "exhaustiondir") => LFS2_ERR_NOSPC;
@@ -301,45 +304,44 @@ tests/test.py << TEST
break;
}
lfs2_ssize_t filesize = lfs2_file_size(&lfs2, &file[0]);
lfs2_ssize_t filesize = lfs2_file_size(&lfs2, &file);
filesize > 0 => true;
lfs2_file_truncate(&lfs2, &file[0], filesize - size) => 0;
lfs2_file_sync(&lfs2, &file[0]) => 0;
lfs2_file_truncate(&lfs2, &file, filesize - size) => 0;
lfs2_file_sync(&lfs2, &file) => 0;
}
err => 0;
lfs2_mkdir(&lfs2, "exhaustiondir2") => LFS2_ERR_NOSPC;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Split dir test ---"
rm -rf blocks
tests/test.py << TEST
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
// create one block hole for half a directory
lfs2_file_open(&lfs2, &file[0], "bump", LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
lfs2_file_open(&lfs2, &file, "bump", LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
for (lfs2_size_t i = 0; i < cfg.block_size; i += 2) {
memcpy(&buffer[i], "hi", 2);
}
lfs2_file_write(&lfs2, &file[0], buffer, cfg.block_size) => cfg.block_size;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_write(&lfs2, &file, buffer, cfg.block_size) => cfg.block_size;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_file_open(&lfs2, &file[0], "exhaustion", LFS2_O_WRONLY | LFS2_O_CREAT);
size = strlen("blahblahblahblah");
lfs2_file_open(&lfs2, &file, "exhaustion", LFS2_O_WRONLY | LFS2_O_CREAT);
lfs2_size_t size = strlen("blahblahblahblah");
memcpy(buffer, "blahblahblahblah", size);
for (lfs2_size_t i = 0;
i < (cfg.block_count-4)*(cfg.block_size-8);
i += size) {
lfs2_file_write(&lfs2, &file[0], buffer, size) => size;
lfs2_file_write(&lfs2, &file, buffer, size) => size;
}
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
// remount to force reset of lookahead
lfs2_unmount(&lfs2) => 0;
@@ -349,137 +351,134 @@ tests/test.py << TEST
lfs2_remove(&lfs2, "bump") => 0;
lfs2_mkdir(&lfs2, "splitdir") => 0;
lfs2_file_open(&lfs2, &file[0], "splitdir/bump",
lfs2_file_open(&lfs2, &file, "splitdir/bump",
LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
for (lfs2_size_t i = 0; i < cfg.block_size; i += 2) {
memcpy(&buffer[i], "hi", 2);
}
lfs2_file_write(&lfs2, &file[0], buffer, 2*cfg.block_size) => LFS2_ERR_NOSPC;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_write(&lfs2, &file, buffer, 2*cfg.block_size) => LFS2_ERR_NOSPC;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Outdated lookahead test ---"
rm -rf blocks
tests/test.py << TEST
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
lfs2_mount(&lfs2, &cfg) => 0;
// fill completely with two files
lfs2_file_open(&lfs2, &file[0], "exhaustion1",
lfs2_file_open(&lfs2, &file, "exhaustion1",
LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
size = strlen("blahblahblahblah");
lfs2_size_t size = strlen("blahblahblahblah");
memcpy(buffer, "blahblahblahblah", size);
for (lfs2_size_t i = 0;
i < ((cfg.block_count-2)/2)*(cfg.block_size-8);
i += size) {
lfs2_file_write(&lfs2, &file[0], buffer, size) => size;
lfs2_file_write(&lfs2, &file, buffer, size) => size;
}
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_file_open(&lfs2, &file[0], "exhaustion2",
lfs2_file_open(&lfs2, &file, "exhaustion2",
LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
size = strlen("blahblahblahblah");
memcpy(buffer, "blahblahblahblah", size);
for (lfs2_size_t i = 0;
i < ((cfg.block_count-2+1)/2)*(cfg.block_size-8);
i += size) {
lfs2_file_write(&lfs2, &file[0], buffer, size) => size;
lfs2_file_write(&lfs2, &file, buffer, size) => size;
}
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
// remount to force reset of lookahead
lfs2_unmount(&lfs2) => 0;
lfs2_mount(&lfs2, &cfg) => 0;
// rewrite one file
lfs2_file_open(&lfs2, &file[0], "exhaustion1",
lfs2_file_open(&lfs2, &file, "exhaustion1",
LFS2_O_WRONLY | LFS2_O_TRUNC) => 0;
lfs2_file_sync(&lfs2, &file[0]) => 0;
lfs2_file_sync(&lfs2, &file) => 0;
size = strlen("blahblahblahblah");
memcpy(buffer, "blahblahblahblah", size);
for (lfs2_size_t i = 0;
i < ((cfg.block_count-2)/2)*(cfg.block_size-8);
i += size) {
lfs2_file_write(&lfs2, &file[0], buffer, size) => size;
lfs2_file_write(&lfs2, &file, buffer, size) => size;
}
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
// rewrite second file, this requires lookahead does not
// use old population
lfs2_file_open(&lfs2, &file[0], "exhaustion2",
lfs2_file_open(&lfs2, &file, "exhaustion2",
LFS2_O_WRONLY | LFS2_O_TRUNC) => 0;
lfs2_file_sync(&lfs2, &file[0]) => 0;
lfs2_file_sync(&lfs2, &file) => 0;
size = strlen("blahblahblahblah");
memcpy(buffer, "blahblahblahblah", size);
for (lfs2_size_t i = 0;
i < ((cfg.block_count-2+1)/2)*(cfg.block_size-8);
i += size) {
lfs2_file_write(&lfs2, &file[0], buffer, size) => size;
lfs2_file_write(&lfs2, &file, buffer, size) => size;
}
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
TEST
echo "--- Outdated lookahead and split dir test ---"
rm -rf blocks
tests/test.py << TEST
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
lfs2_mount(&lfs2, &cfg) => 0;
// fill completely with two files
lfs2_file_open(&lfs2, &file[0], "exhaustion1",
lfs2_file_open(&lfs2, &file, "exhaustion1",
LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
size = strlen("blahblahblahblah");
lfs2_size_t size = strlen("blahblahblahblah");
memcpy(buffer, "blahblahblahblah", size);
for (lfs2_size_t i = 0;
i < ((cfg.block_count-2)/2)*(cfg.block_size-8);
i += size) {
lfs2_file_write(&lfs2, &file[0], buffer, size) => size;
lfs2_file_write(&lfs2, &file, buffer, size) => size;
}
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_file_open(&lfs2, &file[0], "exhaustion2",
lfs2_file_open(&lfs2, &file, "exhaustion2",
LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
size = strlen("blahblahblahblah");
memcpy(buffer, "blahblahblahblah", size);
for (lfs2_size_t i = 0;
i < ((cfg.block_count-2+1)/2)*(cfg.block_size-8);
i += size) {
lfs2_file_write(&lfs2, &file[0], buffer, size) => size;
lfs2_file_write(&lfs2, &file, buffer, size) => size;
}
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
// remount to force reset of lookahead
lfs2_unmount(&lfs2) => 0;
lfs2_mount(&lfs2, &cfg) => 0;
// rewrite one file with a hole of one block
lfs2_file_open(&lfs2, &file[0], "exhaustion1",
lfs2_file_open(&lfs2, &file, "exhaustion1",
LFS2_O_WRONLY | LFS2_O_TRUNC) => 0;
lfs2_file_sync(&lfs2, &file[0]) => 0;
lfs2_file_sync(&lfs2, &file) => 0;
size = strlen("blahblahblahblah");
memcpy(buffer, "blahblahblahblah", size);
for (lfs2_size_t i = 0;
i < ((cfg.block_count-2)/2 - 1)*(cfg.block_size-8);
i += size) {
lfs2_file_write(&lfs2, &file[0], buffer, size) => size;
lfs2_file_write(&lfs2, &file, buffer, size) => size;
}
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
// try to allocate a directory, should fail!
lfs2_mkdir(&lfs2, "split") => LFS2_ERR_NOSPC;
// file should not fail
lfs2_file_open(&lfs2, &file[0], "notasplit",
lfs2_file_open(&lfs2, &file, "notasplit",
LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
lfs2_file_write(&lfs2, &file[0], "hi", 2) => 2;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_write(&lfs2, &file, "hi", 2) => 2;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Results ---"
tests/stats.py
scripts/results.py

104
tests/test_attrs.sh
View File

@@ -1,24 +1,27 @@
#!/bin/bash
set -eu
export TEST_FILE=$0
trap 'export TEST_LINE=$LINENO' DEBUG
echo "=== Attr tests ==="
rm -rf blocks
tests/test.py << TEST
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_mkdir(&lfs2, "hello") => 0;
lfs2_file_open(&lfs2, &file[0], "hello/hello",
lfs2_file_open(&lfs2, &file, "hello/hello",
LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
lfs2_file_write(&lfs2, &file[0], "hello", strlen("hello"))
lfs2_file_write(&lfs2, &file, "hello", strlen("hello"))
=> strlen("hello");
lfs2_file_close(&lfs2, &file[0]);
lfs2_file_close(&lfs2, &file);
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Set/get attribute ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
memset(buffer, 0, sizeof(buffer));
lfs2_setattr(&lfs2, "hello", 'A', "aaaa", 4) => 0;
lfs2_setattr(&lfs2, "hello", 'B', "bbbbbb", 6) => 0;
lfs2_setattr(&lfs2, "hello", 'C', "ccccc", 5) => 0;
@@ -69,8 +72,9 @@ tests/test.py << TEST
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
memset(buffer, 0, sizeof(buffer));
lfs2_getattr(&lfs2, "hello", 'A', buffer, 4) => 4;
lfs2_getattr(&lfs2, "hello", 'B', buffer+4, 9) => 9;
lfs2_getattr(&lfs2, "hello", 'C', buffer+13, 5) => 5;
@@ -78,16 +82,17 @@ tests/test.py << TEST
memcmp(buffer+4, "fffffffff", 9) => 0;
memcmp(buffer+13, "ccccc", 5) => 0;
lfs2_file_open(&lfs2, &file[0], "hello/hello", LFS2_O_RDONLY) => 0;
lfs2_file_read(&lfs2, &file[0], buffer, sizeof(buffer)) => strlen("hello");
lfs2_file_open(&lfs2, &file, "hello/hello", LFS2_O_RDONLY) => 0;
lfs2_file_read(&lfs2, &file, buffer, sizeof(buffer)) => strlen("hello");
memcmp(buffer, "hello", strlen("hello")) => 0;
lfs2_file_close(&lfs2, &file[0]);
lfs2_file_close(&lfs2, &file);
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Set/get root attribute ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
memset(buffer, 0, sizeof(buffer));
lfs2_setattr(&lfs2, "/", 'A', "aaaa", 4) => 0;
lfs2_setattr(&lfs2, "/", 'B', "bbbbbb", 6) => 0;
lfs2_setattr(&lfs2, "/", 'C', "ccccc", 5) => 0;
@@ -137,8 +142,9 @@ tests/test.py << TEST
lfs2_getattr(&lfs2, "/", 'C', buffer+10, 5) => 5;
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
memset(buffer, 0, sizeof(buffer));
lfs2_getattr(&lfs2, "/", 'A', buffer, 4) => 4;
lfs2_getattr(&lfs2, "/", 'B', buffer+4, 9) => 9;
lfs2_getattr(&lfs2, "/", 'C', buffer+13, 5) => 5;
@@ -146,16 +152,17 @@ tests/test.py << TEST
memcmp(buffer+4, "fffffffff", 9) => 0;
memcmp(buffer+13, "ccccc", 5) => 0;
lfs2_file_open(&lfs2, &file[0], "hello/hello", LFS2_O_RDONLY) => 0;
lfs2_file_read(&lfs2, &file[0], buffer, sizeof(buffer)) => strlen("hello");
lfs2_file_open(&lfs2, &file, "hello/hello", LFS2_O_RDONLY) => 0;
lfs2_file_read(&lfs2, &file, buffer, sizeof(buffer)) => strlen("hello");
memcmp(buffer, "hello", strlen("hello")) => 0;
lfs2_file_close(&lfs2, &file[0]);
lfs2_file_close(&lfs2, &file);
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Set/get file attribute ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
memset(buffer, 0, sizeof(buffer));
struct lfs2_attr attrs1[] = {
{'A', buffer, 4},
{'B', buffer+4, 6},
@@ -163,55 +170,55 @@ tests/test.py << TEST
};
struct lfs2_file_config cfg1 = {.attrs=attrs1, .attr_count=3};
lfs2_file_opencfg(&lfs2, &file[0], "hello/hello", LFS2_O_WRONLY, &cfg1) => 0;
lfs2_file_opencfg(&lfs2, &file, "hello/hello", LFS2_O_WRONLY, &cfg1) => 0;
memcpy(buffer, "aaaa", 4);
memcpy(buffer+4, "bbbbbb", 6);
memcpy(buffer+10, "ccccc", 5);
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
memset(buffer, 0, 15);
lfs2_file_opencfg(&lfs2, &file[0], "hello/hello", LFS2_O_RDONLY, &cfg1) => 0;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_opencfg(&lfs2, &file, "hello/hello", LFS2_O_RDONLY, &cfg1) => 0;
lfs2_file_close(&lfs2, &file) => 0;
memcmp(buffer, "aaaa", 4) => 0;
memcmp(buffer+4, "bbbbbb", 6) => 0;
memcmp(buffer+10, "ccccc", 5) => 0;
attrs1[1].size = 0;
lfs2_file_opencfg(&lfs2, &file[0], "hello/hello", LFS2_O_WRONLY, &cfg1) => 0;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_opencfg(&lfs2, &file, "hello/hello", LFS2_O_WRONLY, &cfg1) => 0;
lfs2_file_close(&lfs2, &file) => 0;
memset(buffer, 0, 15);
attrs1[1].size = 6;
lfs2_file_opencfg(&lfs2, &file[0], "hello/hello", LFS2_O_RDONLY, &cfg1) => 0;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_opencfg(&lfs2, &file, "hello/hello", LFS2_O_RDONLY, &cfg1) => 0;
lfs2_file_close(&lfs2, &file) => 0;
memcmp(buffer, "aaaa", 4) => 0;
memcmp(buffer+4, "\0\0\0\0\0\0", 6) => 0;
memcmp(buffer+10, "ccccc", 5) => 0;
attrs1[1].size = 6;
lfs2_file_opencfg(&lfs2, &file[0], "hello/hello", LFS2_O_WRONLY, &cfg1) => 0;
lfs2_file_opencfg(&lfs2, &file, "hello/hello", LFS2_O_WRONLY, &cfg1) => 0;
memcpy(buffer+4, "dddddd", 6);
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
memset(buffer, 0, 15);
attrs1[1].size = 6;
lfs2_file_opencfg(&lfs2, &file[0], "hello/hello", LFS2_O_RDONLY, &cfg1) => 0;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_opencfg(&lfs2, &file, "hello/hello", LFS2_O_RDONLY, &cfg1) => 0;
lfs2_file_close(&lfs2, &file) => 0;
memcmp(buffer, "aaaa", 4) => 0;
memcmp(buffer+4, "dddddd", 6) => 0;
memcmp(buffer+10, "ccccc", 5) => 0;
attrs1[1].size = 3;
lfs2_file_opencfg(&lfs2, &file[0], "hello/hello", LFS2_O_WRONLY, &cfg1) => 0;
lfs2_file_opencfg(&lfs2, &file, "hello/hello", LFS2_O_WRONLY, &cfg1) => 0;
memcpy(buffer+4, "eee", 3);
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
memset(buffer, 0, 15);
attrs1[1].size = 6;
lfs2_file_opencfg(&lfs2, &file[0], "hello/hello", LFS2_O_RDONLY, &cfg1) => 0;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_opencfg(&lfs2, &file, "hello/hello", LFS2_O_RDONLY, &cfg1) => 0;
lfs2_file_close(&lfs2, &file) => 0;
memcmp(buffer, "aaaa", 4) => 0;
memcmp(buffer+4, "eee\0\0\0", 6) => 0;
memcmp(buffer+10, "ccccc", 5) => 0;
attrs1[0].size = LFS2_ATTR_MAX+1;
lfs2_file_opencfg(&lfs2, &file[0], "hello/hello", LFS2_O_WRONLY, &cfg1)
lfs2_file_opencfg(&lfs2, &file, "hello/hello", LFS2_O_WRONLY, &cfg1)
=> LFS2_ERR_NOSPC;
struct lfs2_attr attrs2[] = {
@@ -220,17 +227,18 @@ tests/test.py << TEST
{'C', buffer+13, 5},
};
struct lfs2_file_config cfg2 = {.attrs=attrs2, .attr_count=3};
lfs2_file_opencfg(&lfs2, &file[0], "hello/hello", LFS2_O_RDWR, &cfg2) => 0;
lfs2_file_opencfg(&lfs2, &file, "hello/hello", LFS2_O_RDWR, &cfg2) => 0;
memcpy(buffer+4, "fffffffff", 9);
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
attrs1[0].size = 4;
lfs2_file_opencfg(&lfs2, &file[0], "hello/hello", LFS2_O_RDONLY, &cfg1) => 0;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_opencfg(&lfs2, &file, "hello/hello", LFS2_O_RDONLY, &cfg1) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
memset(buffer, 0, sizeof(buffer));
struct lfs2_attr attrs2[] = {
{'A', buffer, 4},
{'B', buffer+4, 9},
@@ -238,22 +246,23 @@ tests/test.py << TEST
};
struct lfs2_file_config cfg2 = {.attrs=attrs2, .attr_count=3};
lfs2_file_opencfg(&lfs2, &file[0], "hello/hello", LFS2_O_RDONLY, &cfg2) => 0;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_opencfg(&lfs2, &file, "hello/hello", LFS2_O_RDONLY, &cfg2) => 0;
lfs2_file_close(&lfs2, &file) => 0;
memcmp(buffer, "aaaa", 4) => 0;
memcmp(buffer+4, "fffffffff", 9) => 0;
memcmp(buffer+13, "ccccc", 5) => 0;
lfs2_file_open(&lfs2, &file[0], "hello/hello", LFS2_O_RDONLY) => 0;
lfs2_file_read(&lfs2, &file[0], buffer, sizeof(buffer)) => strlen("hello");
lfs2_file_open(&lfs2, &file, "hello/hello", LFS2_O_RDONLY) => 0;
lfs2_file_read(&lfs2, &file, buffer, sizeof(buffer)) => strlen("hello");
memcmp(buffer, "hello", strlen("hello")) => 0;
lfs2_file_close(&lfs2, &file[0]);
lfs2_file_close(&lfs2, &file);
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Deferred file attributes ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
memset(buffer, 0, sizeof(buffer));
struct lfs2_attr attrs1[] = {
{'B', "gggg", 4},
{'C', "", 0},
@@ -261,7 +270,7 @@ tests/test.py << TEST
};
struct lfs2_file_config cfg1 = {.attrs=attrs1, .attr_count=3};
lfs2_file_opencfg(&lfs2, &file[0], "hello/hello", LFS2_O_WRONLY, &cfg1) => 0;
lfs2_file_opencfg(&lfs2, &file, "hello/hello", LFS2_O_WRONLY, &cfg1) => 0;
lfs2_getattr(&lfs2, "hello/hello", 'B', buffer, 9) => 9;
lfs2_getattr(&lfs2, "hello/hello", 'C', buffer+9, 9) => 5;
@@ -270,7 +279,7 @@ tests/test.py << TEST
memcmp(buffer+9, "ccccc\0\0\0\0", 9) => 0;
memcmp(buffer+18, "\0\0\0\0\0\0\0\0\0", 9) => 0;
lfs2_file_sync(&lfs2, &file[0]) => 0;
lfs2_file_sync(&lfs2, &file) => 0;
lfs2_getattr(&lfs2, "hello/hello", 'B', buffer, 9) => 4;
lfs2_getattr(&lfs2, "hello/hello", 'C', buffer+9, 9) => 0;
lfs2_getattr(&lfs2, "hello/hello", 'D', buffer+18, 9) => 4;
@@ -278,9 +287,8 @@ tests/test.py << TEST
memcmp(buffer+9, "\0\0\0\0\0\0\0\0\0", 9) => 0;
memcmp(buffer+18, "hhhh\0\0\0\0\0", 9) => 0;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Results ---"
tests/stats.py
scripts/results.py

26
tests/test_corrupt.sh
View File

@@ -1,5 +1,7 @@
#!/bin/bash
set -eu
export TEST_FILE=$0
trap 'export TEST_LINE=$LINENO' DEBUG
echo "=== Corrupt tests ==="
@@ -7,7 +9,7 @@ NAMEMULT=64
FILEMULT=1
lfs2_mktree() {
tests/test.py ${1:-} << TEST
scripts/test.py ${1:-} << TEST
lfs2_format(&lfs2, &cfg) => 0;
lfs2_mount(&lfs2, &cfg) => 0;
@@ -23,22 +25,22 @@ tests/test.py ${1:-} << TEST
buffer[j+$NAMEMULT+1] = '0'+i;
}
buffer[2*$NAMEMULT+1] = '\0';
lfs2_file_open(&lfs2, &file[0], (char*)buffer,
lfs2_file_open(&lfs2, &file, (char*)buffer,
LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
size = $NAMEMULT;
lfs2_size_t size = $NAMEMULT;
for (int j = 0; j < i*$FILEMULT; j++) {
lfs2_file_write(&lfs2, &file[0], buffer, size) => size;
lfs2_file_write(&lfs2, &file, buffer, size) => size;
}
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
}
lfs2_unmount(&lfs2) => 0;
TEST
}
lfs2_chktree() {
tests/test.py ${1:-} << TEST
scripts/test.py ${1:-} << TEST
lfs2_mount(&lfs2, &cfg) => 0;
for (int i = 1; i < 10; i++) {
for (int j = 0; j < $NAMEMULT; j++) {
@@ -53,15 +55,16 @@ tests/test.py ${1:-} << TEST
buffer[j+$NAMEMULT+1] = '0'+i;
}
buffer[2*$NAMEMULT+1] = '\0';
lfs2_file_open(&lfs2, &file[0], (char*)buffer, LFS2_O_RDONLY) => 0;
lfs2_file_open(&lfs2, &file, (char*)buffer, LFS2_O_RDONLY) => 0;
size = $NAMEMULT;
lfs2_size_t size = $NAMEMULT;
for (int j = 0; j < i*$FILEMULT; j++) {
lfs2_file_read(&lfs2, &file[0], rbuffer, size) => size;
uint8_t rbuffer[1024];
lfs2_file_read(&lfs2, &file, rbuffer, size) => size;
memcmp(buffer, rbuffer, size) => 0;
}
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
}
lfs2_unmount(&lfs2) => 0;
TEST
@@ -114,5 +117,4 @@ done
lfs2_mktree
lfs2_chktree
echo "--- Results ---"
tests/stats.py
scripts/results.py

351
tests/test_dirs.sh
View File

@@ -1,188 +1,191 @@
#!/bin/bash
set -eu
export TEST_FILE=$0
trap 'export TEST_LINE=$LINENO' DEBUG
echo "=== Directory tests ==="
LARGESIZE=128
echo "=== Directory tests ==="
rm -rf blocks
tests/test.py << TEST
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
TEST
echo "--- Root directory ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "/") => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_open(&lfs2, &dir, "/") => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Directory creation ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_mkdir(&lfs2, "potato") => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- File creation ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "burito", LFS2_O_CREAT | LFS2_O_WRONLY) => 0;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_open(&lfs2, &file, "burito", LFS2_O_CREAT | LFS2_O_WRONLY) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Directory iteration ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "/") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "/") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "burito") => 0;
info.type => LFS2_TYPE_REG;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "potato") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Directory failures ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_mkdir(&lfs2, "potato") => LFS2_ERR_EXIST;
lfs2_dir_open(&lfs2, &dir[0], "tomato") => LFS2_ERR_NOENT;
lfs2_dir_open(&lfs2, &dir[0], "burito") => LFS2_ERR_NOTDIR;
lfs2_file_open(&lfs2, &file[0], "tomato", LFS2_O_RDONLY) => LFS2_ERR_NOENT;
lfs2_file_open(&lfs2, &file[0], "potato", LFS2_O_RDONLY) => LFS2_ERR_ISDIR;
lfs2_dir_open(&lfs2, &dir, "tomato") => LFS2_ERR_NOENT;
lfs2_dir_open(&lfs2, &dir, "burito") => LFS2_ERR_NOTDIR;
lfs2_file_open(&lfs2, &file, "tomato", LFS2_O_RDONLY) => LFS2_ERR_NOENT;
lfs2_file_open(&lfs2, &file, "potato", LFS2_O_RDONLY) => LFS2_ERR_ISDIR;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Nested directories ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_mkdir(&lfs2, "potato/baked") => 0;
lfs2_mkdir(&lfs2, "potato/sweet") => 0;
lfs2_mkdir(&lfs2, "potato/fried") => 0;
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "potato") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "potato") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "baked") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "fried") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "sweet") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Multi-block directory ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_mkdir(&lfs2, "cactus") => 0;
for (int i = 0; i < $LARGESIZE; i++) {
sprintf((char*)buffer, "cactus/test%03d", i);
lfs2_mkdir(&lfs2, (char*)buffer) => 0;
sprintf(path, "cactus/test%03d", i);
lfs2_mkdir(&lfs2, path) => 0;
}
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "cactus") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "cactus") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS2_TYPE_DIR;
for (int i = 0; i < $LARGESIZE; i++) {
sprintf((char*)buffer, "test%03d", i);
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
strcmp(info.name, (char*)buffer) => 0;
sprintf(path, "test%03d", i);
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, path) => 0;
info.type => LFS2_TYPE_DIR;
}
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Directory remove ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_remove(&lfs2, "potato") => LFS2_ERR_NOTEMPTY;
lfs2_remove(&lfs2, "potato/sweet") => 0;
lfs2_remove(&lfs2, "potato/baked") => 0;
lfs2_remove(&lfs2, "potato/fried") => 0;
lfs2_dir_open(&lfs2, &dir[0], "potato") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "potato") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_remove(&lfs2, "potato") => 0;
lfs2_dir_open(&lfs2, &dir[0], "/") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "/") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "burito") => 0;
info.type => LFS2_TYPE_REG;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "cactus") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "/") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "/") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "burito") => 0;
info.type => LFS2_TYPE_REG;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "cactus") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Directory rename ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_mkdir(&lfs2, "coldpotato") => 0;
lfs2_mkdir(&lfs2, "coldpotato/baked") => 0;
@@ -190,34 +193,34 @@ tests/test.py << TEST
lfs2_mkdir(&lfs2, "coldpotato/fried") => 0;
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_rename(&lfs2, "coldpotato", "hotpotato") => 0;
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "hotpotato") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "hotpotato") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "baked") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "fried") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "sweet") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_mkdir(&lfs2, "warmpotato") => 0;
lfs2_mkdir(&lfs2, "warmpotato/mushy") => 0;
@@ -228,29 +231,29 @@ tests/test.py << TEST
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "warmpotato") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "warmpotato") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "baked") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "fried") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "sweet") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_mkdir(&lfs2, "coldpotato") => 0;
lfs2_rename(&lfs2, "warmpotato/baked", "coldpotato/baked") => 0;
@@ -260,225 +263,227 @@ tests/test.py << TEST
lfs2_remove(&lfs2, "warmpotato") => 0;
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "coldpotato") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "coldpotato") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "baked") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "fried") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "sweet") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Recursive remove ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_remove(&lfs2, "coldpotato") => LFS2_ERR_NOTEMPTY;
lfs2_dir_open(&lfs2, &dir[0], "coldpotato") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "coldpotato") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
while (true) {
int err = lfs2_dir_read(&lfs2, &dir[0], &info);
int err = lfs2_dir_read(&lfs2, &dir, &info);
err >= 0 => 1;
if (err == 0) {
break;
}
strcpy((char*)buffer, "coldpotato/");
strcat((char*)buffer, info.name);
lfs2_remove(&lfs2, (char*)buffer) => 0;
strcpy(path, "coldpotato/");
strcat(path, info.name);
lfs2_remove(&lfs2, path) => 0;
}
lfs2_remove(&lfs2, "coldpotato") => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "/") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "/") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "burito") => 0;
info.type => LFS2_TYPE_REG;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "cactus") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Multi-block rename ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
for (int i = 0; i < $LARGESIZE; i++) {
sprintf((char*)buffer, "cactus/test%03d", i);
sprintf((char*)wbuffer, "cactus/tedd%03d", i);
lfs2_rename(&lfs2, (char*)buffer, (char*)wbuffer) => 0;
char oldpath[1024];
char newpath[1024];
sprintf(oldpath, "cactus/test%03d", i);
sprintf(newpath, "cactus/tedd%03d", i);
lfs2_rename(&lfs2, oldpath, newpath) => 0;
}
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "cactus") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "cactus") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS2_TYPE_DIR;
for (int i = 0; i < $LARGESIZE; i++) {
sprintf((char*)buffer, "tedd%03d", i);
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
strcmp(info.name, (char*)buffer) => 0;
sprintf(path, "tedd%03d", i);
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, path) => 0;
info.type => LFS2_TYPE_DIR;
}
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Multi-block remove ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_remove(&lfs2, "cactus") => LFS2_ERR_NOTEMPTY;
for (int i = 0; i < $LARGESIZE; i++) {
sprintf((char*)buffer, "cactus/tedd%03d", i);
lfs2_remove(&lfs2, (char*)buffer) => 0;
sprintf(path, "cactus/tedd%03d", i);
lfs2_remove(&lfs2, path) => 0;
}
lfs2_remove(&lfs2, "cactus") => 0;
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "/") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "/") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "burito") => 0;
info.type => LFS2_TYPE_REG;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Multi-block directory with files ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_mkdir(&lfs2, "prickly-pear") => 0;
for (int i = 0; i < $LARGESIZE; i++) {
sprintf((char*)buffer, "prickly-pear/test%03d", i);
lfs2_file_open(&lfs2, &file[0], (char*)buffer,
LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
size = 6;
memcpy(wbuffer, "Hello", size);
lfs2_file_write(&lfs2, &file[0], wbuffer, size) => size;
lfs2_file_close(&lfs2, &file[0]) => 0;
sprintf(path, "prickly-pear/test%03d", i);
lfs2_file_open(&lfs2, &file, path, LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
lfs2_size_t size = 6;
memcpy(buffer, "Hello", size);
lfs2_file_write(&lfs2, &file, buffer, size) => size;
lfs2_file_close(&lfs2, &file) => 0;
}
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "prickly-pear") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "prickly-pear") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS2_TYPE_DIR;
for (int i = 0; i < $LARGESIZE; i++) {
sprintf((char*)buffer, "test%03d", i);
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
strcmp(info.name, (char*)buffer) => 0;
sprintf(path, "test%03d", i);
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, path) => 0;
info.type => LFS2_TYPE_REG;
info.size => 6;
}
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Multi-block rename with files ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
for (int i = 0; i < $LARGESIZE; i++) {
sprintf((char*)buffer, "prickly-pear/test%03d", i);
sprintf((char*)wbuffer, "prickly-pear/tedd%03d", i);
lfs2_rename(&lfs2, (char*)buffer, (char*)wbuffer) => 0;
char oldpath[1024];
char newpath[1024];
sprintf(oldpath, "prickly-pear/test%03d", i);
sprintf(newpath, "prickly-pear/tedd%03d", i);
lfs2_rename(&lfs2, oldpath, newpath) => 0;
}
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "prickly-pear") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "prickly-pear") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS2_TYPE_DIR;
for (int i = 0; i < $LARGESIZE; i++) {
sprintf((char*)buffer, "tedd%03d", i);
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
strcmp(info.name, (char*)buffer) => 0;
sprintf(path, "tedd%03d", i);
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, path) => 0;
info.type => LFS2_TYPE_REG;
info.size => 6;
}
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Multi-block remove with files ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_remove(&lfs2, "prickly-pear") => LFS2_ERR_NOTEMPTY;
for (int i = 0; i < $LARGESIZE; i++) {
sprintf((char*)buffer, "prickly-pear/tedd%03d", i);
lfs2_remove(&lfs2, (char*)buffer) => 0;
sprintf(path, "prickly-pear/tedd%03d", i);
lfs2_remove(&lfs2, path) => 0;
}
lfs2_remove(&lfs2, "prickly-pear") => 0;
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "/") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "/") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "burito") => 0;
info.type => LFS2_TYPE_REG;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Results ---"
tests/stats.py
scripts/results.py

118
tests/test_entries.sh
View File

@@ -1,19 +1,22 @@
#!/bin/bash
set -eu
export TEST_FILE=$0
trap 'export TEST_LINE=$LINENO' DEBUG
echo "=== Entry tests ==="
# Note: These tests are intended for 512 byte inline size at different
# inline sizes they should still pass, but won't be testing anything
echo "=== Entry tests ==="
rm -rf blocks
function read_file {
cat << TEST
size = $2;
lfs2_file_open(&lfs2, &file[0], "$1", LFS2_O_RDONLY) => 0;
lfs2_file_read(&lfs2, &file[0], rbuffer, size) => size;
lfs2_file_open(&lfs2, &file, "$1", LFS2_O_RDONLY) => 0;
lfs2_file_read(&lfs2, &file, rbuffer, size) => size;
memcmp(rbuffer, wbuffer, size) => 0;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
TEST
}
@@ -21,18 +24,22 @@ function write_file {
cat << TEST
size = $2;
lfs2_file_open(&lfs2, &file[0], "$1",
lfs2_file_open(&lfs2, &file, "$1",
LFS2_O_WRONLY | LFS2_O_CREAT | LFS2_O_TRUNC) => 0;
memset(wbuffer, 'c', size);
lfs2_file_write(&lfs2, &file[0], wbuffer, size) => size;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_write(&lfs2, &file, wbuffer, size) => size;
lfs2_file_close(&lfs2, &file) => 0;
TEST
}
echo "--- Entry grow test ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
uint8_t wbuffer[1024];
uint8_t rbuffer[1024];
lfs2_size_t size;
lfs2_mount(&lfs2, &cfg) => 0;
$(write_file "hi0" 20)
$(write_file "hi1" 20)
@@ -50,9 +57,13 @@ tests/test.py << TEST
TEST
echo "--- Entry shrink test ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
uint8_t wbuffer[1024];
uint8_t rbuffer[1024];
lfs2_size_t size;
lfs2_mount(&lfs2, &cfg) => 0;
$(write_file "hi0" 20)
$(write_file "hi1" 200)
@@ -70,9 +81,13 @@ tests/test.py << TEST
TEST
echo "--- Entry spill test ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
uint8_t wbuffer[1024];
uint8_t rbuffer[1024];
lfs2_size_t size;
lfs2_mount(&lfs2, &cfg) => 0;
$(write_file "hi0" 200)
$(write_file "hi1" 200)
@@ -87,9 +102,13 @@ tests/test.py << TEST
TEST
echo "--- Entry push spill test ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
uint8_t wbuffer[1024];
uint8_t rbuffer[1024];
lfs2_size_t size;
lfs2_mount(&lfs2, &cfg) => 0;
$(write_file "hi0" 200)
$(write_file "hi1" 20)
@@ -107,9 +126,13 @@ tests/test.py << TEST
TEST
echo "--- Entry push spill two test ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
uint8_t wbuffer[1024];
uint8_t rbuffer[1024];
lfs2_size_t size;
lfs2_mount(&lfs2, &cfg) => 0;
$(write_file "hi0" 200)
$(write_file "hi1" 20)
@@ -129,9 +152,13 @@ tests/test.py << TEST
TEST
echo "--- Entry drop test ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
uint8_t wbuffer[1024];
uint8_t rbuffer[1024];
lfs2_size_t size;
lfs2_mount(&lfs2, &cfg) => 0;
$(write_file "hi0" 200)
$(write_file "hi1" 200)
@@ -159,63 +186,66 @@ tests/test.py << TEST
TEST
echo "--- Create too big ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
lfs2_mount(&lfs2, &cfg) => 0;
memset(buffer, 'm', 200);
buffer[200] = '\0';
memset(path, 'm', 200);
path[200] = '\0';
size = 400;
lfs2_file_open(&lfs2, &file[0], (char*)buffer,
lfs2_size_t size = 400;
lfs2_file_open(&lfs2, &file, path,
LFS2_O_WRONLY | LFS2_O_CREAT | LFS2_O_TRUNC) => 0;
uint8_t wbuffer[1024];
memset(wbuffer, 'c', size);
lfs2_file_write(&lfs2, &file[0], wbuffer, size) => size;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_write(&lfs2, &file, wbuffer, size) => size;
lfs2_file_close(&lfs2, &file) => 0;
size = 400;
lfs2_file_open(&lfs2, &file[0], (char*)buffer, LFS2_O_RDONLY) => 0;
lfs2_file_read(&lfs2, &file[0], rbuffer, size) => size;
lfs2_file_open(&lfs2, &file, path, LFS2_O_RDONLY) => 0;
uint8_t rbuffer[1024];
lfs2_file_read(&lfs2, &file, rbuffer, size) => size;
memcmp(rbuffer, wbuffer, size) => 0;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Resize too big ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
lfs2_mount(&lfs2, &cfg) => 0;
memset(buffer, 'm', 200);
buffer[200] = '\0';
memset(path, 'm', 200);
path[200] = '\0';
lfs2_size_t size = 40;
lfs2_file_open(&lfs2, &file, path,
LFS2_O_WRONLY | LFS2_O_CREAT | LFS2_O_TRUNC) => 0;
uint8_t wbuffer[1024];
memset(wbuffer, 'c', size);
lfs2_file_write(&lfs2, &file, wbuffer, size) => size;
lfs2_file_close(&lfs2, &file) => 0;
size = 40;
lfs2_file_open(&lfs2, &file[0], (char*)buffer,
LFS2_O_WRONLY | LFS2_O_CREAT | LFS2_O_TRUNC) => 0;
memset(wbuffer, 'c', size);
lfs2_file_write(&lfs2, &file[0], wbuffer, size) => size;
lfs2_file_close(&lfs2, &file[0]) => 0;
size = 40;
lfs2_file_open(&lfs2, &file[0], (char*)buffer, LFS2_O_RDONLY) => 0;
lfs2_file_read(&lfs2, &file[0], rbuffer, size) => size;
lfs2_file_open(&lfs2, &file, path, LFS2_O_RDONLY) => 0;
uint8_t rbuffer[1024];
lfs2_file_read(&lfs2, &file, rbuffer, size) => size;
memcmp(rbuffer, wbuffer, size) => 0;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
size = 400;
lfs2_file_open(&lfs2, &file[0], (char*)buffer,
lfs2_file_open(&lfs2, &file, path,
LFS2_O_WRONLY | LFS2_O_CREAT | LFS2_O_TRUNC) => 0;
memset(wbuffer, 'c', size);
lfs2_file_write(&lfs2, &file[0], wbuffer, size) => size;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_write(&lfs2, &file, wbuffer, size) => size;
lfs2_file_close(&lfs2, &file) => 0;
size = 400;
lfs2_file_open(&lfs2, &file[0], (char*)buffer, LFS2_O_RDONLY) => 0;
lfs2_file_read(&lfs2, &file[0], rbuffer, size) => size;
lfs2_file_open(&lfs2, &file, path, LFS2_O_RDONLY) => 0;
lfs2_file_read(&lfs2, &file, rbuffer, size) => size;
memcmp(rbuffer, wbuffer, size) => 0;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Results ---"
tests/stats.py
scripts/results.py

151
tests/test_files.sh
View File

@@ -1,71 +1,76 @@
#!/bin/bash
set -eu
export TEST_FILE=$0
trap 'export TEST_LINE=$LINENO' DEBUG
echo "=== File tests ==="
SMALLSIZE=32
MEDIUMSIZE=8192
LARGESIZE=262144
echo "=== File tests ==="
rm -rf blocks
tests/test.py << TEST
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
TEST
echo "--- Simple file test ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "hello", LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
size = strlen("Hello World!\n");
lfs2_file_open(&lfs2, &file, "hello", LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
lfs2_size_t size = strlen("Hello World!\n");
uint8_t wbuffer[1024];
memcpy(wbuffer, "Hello World!\n", size);
lfs2_file_write(&lfs2, &file[0], wbuffer, size) => size;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_write(&lfs2, &file, wbuffer, size) => size;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_file_open(&lfs2, &file[0], "hello", LFS2_O_RDONLY) => 0;
lfs2_file_open(&lfs2, &file, "hello", LFS2_O_RDONLY) => 0;
size = strlen("Hello World!\n");
lfs2_file_read(&lfs2, &file[0], rbuffer, size) => size;
uint8_t rbuffer[1024];
lfs2_file_read(&lfs2, &file, rbuffer, size) => size;
memcmp(rbuffer, wbuffer, size) => 0;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
w_test() {
tests/test.py ${4:-} << TEST
size = $1;
scripts/test.py ${4:-} << TEST
lfs2_size_t size = $1;
lfs2_size_t chunk = 31;
srand(0);
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "$2",
lfs2_file_open(&lfs2, &file, "$2",
${3:-LFS2_O_WRONLY | LFS2_O_CREAT | LFS2_O_TRUNC}) => 0;
for (lfs2_size_t i = 0; i < size; i += chunk) {
chunk = (chunk < size - i) ? chunk : size - i;
for (lfs2_size_t b = 0; b < chunk; b++) {
buffer[b] = rand() & 0xff;
}
lfs2_file_write(&lfs2, &file[0], buffer, chunk) => chunk;
lfs2_file_write(&lfs2, &file, buffer, chunk) => chunk;
}
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
}
r_test() {
tests/test.py << TEST
size = $1;
scripts/test.py << TEST
lfs2_size_t size = $1;
lfs2_size_t chunk = 29;
srand(0);
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_stat(&lfs2, "$2", &info) => 0;
info.type => LFS2_TYPE_REG;
info.size => size;
lfs2_file_open(&lfs2, &file[0], "$2", ${3:-LFS2_O_RDONLY}) => 0;
lfs2_file_open(&lfs2, &file, "$2", ${3:-LFS2_O_RDONLY}) => 0;
for (lfs2_size_t i = 0; i < size; i += chunk) {
chunk = (chunk < size - i) ? chunk : size - i;
lfs2_file_read(&lfs2, &file[0], buffer, chunk) => chunk;
lfs2_file_read(&lfs2, &file, buffer, chunk) => chunk;
for (lfs2_size_t b = 0; b < chunk && i+b < size; b++) {
buffer[b] => rand() & 0xff;
}
}
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
}
@@ -105,54 +110,112 @@ r_test $LARGESIZE largeavacado
r_test 0 noavacado
echo "--- Dir check ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "/") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "/") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "hello") => 0;
info.type => LFS2_TYPE_REG;
info.size => strlen("Hello World!\n");
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "largeavacado") => 0;
info.type => LFS2_TYPE_REG;
info.size => $LARGESIZE;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "mediumavacado") => 0;
info.type => LFS2_TYPE_REG;
info.size => $MEDIUMSIZE;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "noavacado") => 0;
info.type => LFS2_TYPE_REG;
info.size => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "smallavacado") => 0;
info.type => LFS2_TYPE_REG;
info.size => $SMALLSIZE;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Many file test ---"
tests/test.py << TEST
echo "--- Many files test ---"
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
TEST
tests/test.py << TEST
// Create 300 files of 6 bytes
scripts/test.py << TEST
// Create 300 files of 7 bytes
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_mkdir(&lfs2, "directory") => 0;
for (unsigned i = 0; i < 300; i++) {
snprintf((char*)buffer, sizeof(buffer), "file_%03d", i);
lfs2_file_open(&lfs2, &file[0], (char*)buffer, LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
size = 6;
memcpy(wbuffer, "Hello", size);
lfs2_file_write(&lfs2, &file[0], wbuffer, size) => size;
lfs2_file_close(&lfs2, &file[0]) => 0;
sprintf(path, "file_%03d", i);
lfs2_file_open(&lfs2, &file, path,
LFS2_O_RDWR | LFS2_O_CREAT | LFS2_O_EXCL) => 0;
lfs2_size_t size = 7;
uint8_t wbuffer[1024];
uint8_t rbuffer[1024];
snprintf((char*)wbuffer, size, "Hi %03d", i);
lfs2_file_write(&lfs2, &file, wbuffer, size) => size;
lfs2_file_rewind(&lfs2, &file) => 0;
lfs2_file_read(&lfs2, &file, rbuffer, size) => size;
memcmp(wbuffer, rbuffer, size) => 0;
lfs2_file_close(&lfs2, &file) => 0;
}
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Results ---"
tests/stats.py
echo "--- Many files with flush test ---"
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
TEST
scripts/test.py << TEST
// Create 300 files of 7 bytes
lfs2_mount(&lfs2, &cfg) => 0;
for (unsigned i = 0; i < 300; i++) {
sprintf(path, "file_%03d", i);
lfs2_file_open(&lfs2, &file, path,
LFS2_O_WRONLY | LFS2_O_CREAT | LFS2_O_EXCL) => 0;
lfs2_size_t size = 7;
uint8_t wbuffer[1024];
uint8_t rbuffer[1024];
snprintf((char*)wbuffer, size, "Hi %03d", i);
lfs2_file_write(&lfs2, &file, wbuffer, size) => size;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_file_open(&lfs2, &file, path, LFS2_O_RDONLY) => 0;
lfs2_file_read(&lfs2, &file, rbuffer, size) => size;
memcmp(wbuffer, rbuffer, size) => 0;
lfs2_file_close(&lfs2, &file) => 0;
}
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Many files with power cycle test ---"
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
TEST
scripts/test.py << TEST
// Create 300 files of 7 bytes
lfs2_mount(&lfs2, &cfg) => 0;
for (unsigned i = 0; i < 300; i++) {
sprintf(path, "file_%03d", i);
lfs2_file_open(&lfs2, &file, path,
LFS2_O_WRONLY | LFS2_O_CREAT | LFS2_O_EXCL) => 0;
lfs2_size_t size = 7;
uint8_t wbuffer[1024];
uint8_t rbuffer[1024];
snprintf((char*)wbuffer, size, "Hi %03d", i);
lfs2_file_write(&lfs2, &file, wbuffer, size) => size;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file, path, LFS2_O_RDONLY) => 0;
lfs2_file_read(&lfs2, &file, rbuffer, size) => size;
memcmp(wbuffer, rbuffer, size) => 0;
lfs2_file_close(&lfs2, &file) => 0;
}
lfs2_unmount(&lfs2) => 0;
TEST
scripts/results.py

17
tests/test_format.sh
View File

@@ -1,16 +1,18 @@
#!/bin/bash
set -eu
export TEST_FILE=$0
trap 'export TEST_LINE=$LINENO' DEBUG
echo "=== Formatting tests ==="
rm -rf blocks
echo "--- Basic formatting ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
TEST
echo "--- Basic mounting ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
lfs2_mount(&lfs2, &cfg) => 0;
@@ -20,18 +22,18 @@ TEST
echo "--- Invalid superblocks ---"
ln -f -s /dev/zero blocks/0
ln -f -s /dev/zero blocks/1
tests/test.py << TEST
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => LFS2_ERR_NOSPC;
TEST
rm blocks/0 blocks/1
echo "--- Invalid mount ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => LFS2_ERR_CORRUPT;
TEST
echo "--- Expanding superblock ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
lfs2_mount(&lfs2, &cfg) => 0;
for (int i = 0; i < 100; i++) {
@@ -40,11 +42,10 @@ tests/test.py << TEST
}
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_mkdir(&lfs2, "dummy") => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Results ---"
tests/stats.py
scripts/results.py

158
tests/test_interspersed.sh
View File

@@ -1,89 +1,93 @@
#!/bin/bash
set -eu
export TEST_FILE=$0
trap 'export TEST_LINE=$LINENO' DEBUG
echo "=== Interspersed tests ==="
rm -rf blocks
tests/test.py << TEST
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
TEST
echo "--- Interspersed file test ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "a", LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
lfs2_file_open(&lfs2, &file[1], "b", LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
lfs2_file_open(&lfs2, &file[2], "c", LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
lfs2_file_open(&lfs2, &file[3], "d", LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
lfs2_file_t files[4];
lfs2_file_open(&lfs2, &files[0], "a", LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
lfs2_file_open(&lfs2, &files[1], "b", LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
lfs2_file_open(&lfs2, &files[2], "c", LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
lfs2_file_open(&lfs2, &files[3], "d", LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
for (int i = 0; i < 10; i++) {
lfs2_file_write(&lfs2, &file[0], (const void*)"a", 1) => 1;
lfs2_file_write(&lfs2, &file[1], (const void*)"b", 1) => 1;
lfs2_file_write(&lfs2, &file[2], (const void*)"c", 1) => 1;
lfs2_file_write(&lfs2, &file[3], (const void*)"d", 1) => 1;
lfs2_file_write(&lfs2, &files[0], (const void*)"a", 1) => 1;
lfs2_file_write(&lfs2, &files[1], (const void*)"b", 1) => 1;
lfs2_file_write(&lfs2, &files[2], (const void*)"c", 1) => 1;
lfs2_file_write(&lfs2, &files[3], (const void*)"d", 1) => 1;
}
lfs2_file_close(&lfs2, &file[0]);
lfs2_file_close(&lfs2, &file[1]);
lfs2_file_close(&lfs2, &file[2]);
lfs2_file_close(&lfs2, &file[3]);
lfs2_file_close(&lfs2, &files[0]);
lfs2_file_close(&lfs2, &files[1]);
lfs2_file_close(&lfs2, &files[2]);
lfs2_file_close(&lfs2, &files[3]);
lfs2_dir_open(&lfs2, &dir[0], "/") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "/") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "a") => 0;
info.type => LFS2_TYPE_REG;
info.size => 10;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "b") => 0;
info.type => LFS2_TYPE_REG;
info.size => 10;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "c") => 0;
info.type => LFS2_TYPE_REG;
info.size => 10;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "d") => 0;
info.type => LFS2_TYPE_REG;
info.size => 10;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_file_open(&lfs2, &file[0], "a", LFS2_O_RDONLY) => 0;
lfs2_file_open(&lfs2, &file[1], "b", LFS2_O_RDONLY) => 0;
lfs2_file_open(&lfs2, &file[2], "c", LFS2_O_RDONLY) => 0;
lfs2_file_open(&lfs2, &file[3], "d", LFS2_O_RDONLY) => 0;
lfs2_file_open(&lfs2, &files[0], "a", LFS2_O_RDONLY) => 0;
lfs2_file_open(&lfs2, &files[1], "b", LFS2_O_RDONLY) => 0;
lfs2_file_open(&lfs2, &files[2], "c", LFS2_O_RDONLY) => 0;
lfs2_file_open(&lfs2, &files[3], "d", LFS2_O_RDONLY) => 0;
for (int i = 0; i < 10; i++) {
lfs2_file_read(&lfs2, &file[0], buffer, 1) => 1;
lfs2_file_read(&lfs2, &files[0], buffer, 1) => 1;
buffer[0] => 'a';
lfs2_file_read(&lfs2, &file[1], buffer, 1) => 1;
lfs2_file_read(&lfs2, &files[1], buffer, 1) => 1;
buffer[0] => 'b';
lfs2_file_read(&lfs2, &file[2], buffer, 1) => 1;
lfs2_file_read(&lfs2, &files[2], buffer, 1) => 1;
buffer[0] => 'c';
lfs2_file_read(&lfs2, &file[3], buffer, 1) => 1;
lfs2_file_read(&lfs2, &files[3], buffer, 1) => 1;
buffer[0] => 'd';
}
lfs2_file_close(&lfs2, &file[0]);
lfs2_file_close(&lfs2, &file[1]);
lfs2_file_close(&lfs2, &file[2]);
lfs2_file_close(&lfs2, &file[3]);
lfs2_file_close(&lfs2, &files[0]);
lfs2_file_close(&lfs2, &files[1]);
lfs2_file_close(&lfs2, &files[2]);
lfs2_file_close(&lfs2, &files[3]);
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Interspersed remove file test ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "e", LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
lfs2_file_t files[4];
lfs2_file_open(&lfs2, &files[0], "e", LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
for (int i = 0; i < 5; i++) {
lfs2_file_write(&lfs2, &file[0], (const void*)"e", 1) => 1;
lfs2_file_write(&lfs2, &files[0], (const void*)"e", 1) => 1;
}
lfs2_remove(&lfs2, "a") => 0;
@@ -92,95 +96,95 @@ tests/test.py << TEST
lfs2_remove(&lfs2, "d") => 0;
for (int i = 0; i < 5; i++) {
lfs2_file_write(&lfs2, &file[0], (const void*)"e", 1) => 1;
lfs2_file_write(&lfs2, &files[0], (const void*)"e", 1) => 1;
}
lfs2_file_close(&lfs2, &file[0]);
lfs2_file_close(&lfs2, &files[0]);
lfs2_dir_open(&lfs2, &dir[0], "/") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "/") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "e") => 0;
info.type => LFS2_TYPE_REG;
info.size => 10;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_file_open(&lfs2, &file[0], "e", LFS2_O_RDONLY) => 0;
lfs2_file_open(&lfs2, &files[0], "e", LFS2_O_RDONLY) => 0;
for (int i = 0; i < 10; i++) {
lfs2_file_read(&lfs2, &file[0], buffer, 1) => 1;
lfs2_file_read(&lfs2, &files[0], buffer, 1) => 1;
buffer[0] => 'e';
}
lfs2_file_close(&lfs2, &file[0]);
lfs2_file_close(&lfs2, &files[0]);
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Remove inconveniently test ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "e", LFS2_O_WRONLY | LFS2_O_TRUNC) => 0;
lfs2_file_open(&lfs2, &file[1], "f", LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
lfs2_file_open(&lfs2, &file[2], "g", LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
lfs2_file_t files[4];
lfs2_file_open(&lfs2, &files[0], "e", LFS2_O_WRONLY | LFS2_O_TRUNC) => 0;
lfs2_file_open(&lfs2, &files[1], "f", LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
lfs2_file_open(&lfs2, &files[2], "g", LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
for (int i = 0; i < 5; i++) {
lfs2_file_write(&lfs2, &file[0], (const void*)"e", 1) => 1;
lfs2_file_write(&lfs2, &file[1], (const void*)"f", 1) => 1;
lfs2_file_write(&lfs2, &file[2], (const void*)"g", 1) => 1;
lfs2_file_write(&lfs2, &files[0], (const void*)"e", 1) => 1;
lfs2_file_write(&lfs2, &files[1], (const void*)"f", 1) => 1;
lfs2_file_write(&lfs2, &files[2], (const void*)"g", 1) => 1;
}
lfs2_remove(&lfs2, "f") => 0;
for (int i = 0; i < 5; i++) {
lfs2_file_write(&lfs2, &file[0], (const void*)"e", 1) => 1;
lfs2_file_write(&lfs2, &file[1], (const void*)"f", 1) => 1;
lfs2_file_write(&lfs2, &file[2], (const void*)"g", 1) => 1;
lfs2_file_write(&lfs2, &files[0], (const void*)"e", 1) => 1;
lfs2_file_write(&lfs2, &files[1], (const void*)"f", 1) => 1;
lfs2_file_write(&lfs2, &files[2], (const void*)"g", 1) => 1;
}
lfs2_file_close(&lfs2, &file[0]);
lfs2_file_close(&lfs2, &file[1]);
lfs2_file_close(&lfs2, &file[2]);
lfs2_file_close(&lfs2, &files[0]);
lfs2_file_close(&lfs2, &files[1]);
lfs2_file_close(&lfs2, &files[2]);
lfs2_dir_open(&lfs2, &dir[0], "/") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "/") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
info.type => LFS2_TYPE_DIR;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "e") => 0;
info.type => LFS2_TYPE_REG;
info.size => 10;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "g") => 0;
info.type => LFS2_TYPE_REG;
info.size => 10;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_file_open(&lfs2, &file[0], "e", LFS2_O_RDONLY) => 0;
lfs2_file_open(&lfs2, &file[1], "g", LFS2_O_RDONLY) => 0;
lfs2_file_open(&lfs2, &files[0], "e", LFS2_O_RDONLY) => 0;
lfs2_file_open(&lfs2, &files[1], "g", LFS2_O_RDONLY) => 0;
for (int i = 0; i < 10; i++) {
lfs2_file_read(&lfs2, &file[0], buffer, 1) => 1;
lfs2_file_read(&lfs2, &files[0], buffer, 1) => 1;
buffer[0] => 'e';
lfs2_file_read(&lfs2, &file[1], buffer, 1) => 1;
lfs2_file_read(&lfs2, &files[1], buffer, 1) => 1;
buffer[0] => 'g';
}
lfs2_file_close(&lfs2, &file[0]);
lfs2_file_close(&lfs2, &file[1]);
lfs2_file_close(&lfs2, &files[0]);
lfs2_file_close(&lfs2, &files[1]);
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Results ---"
tests/stats.py
scripts/results.py

305
tests/test_move.sh
View File

@@ -1,9 +1,11 @@
#!/bin/bash
set -eu
export TEST_FILE=$0
trap 'export TEST_LINE=$LINENO' DEBUG
echo "=== Move tests ==="
rm -rf blocks
tests/test.py << TEST
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
lfs2_mount(&lfs2, &cfg) => 0;
@@ -17,272 +19,272 @@ tests/test.py << TEST
lfs2_mkdir(&lfs2, "a/hi/bonjour") => 0;
lfs2_mkdir(&lfs2, "a/hi/ohayo") => 0;
lfs2_file_open(&lfs2, &file[0], "a/hello", LFS2_O_CREAT | LFS2_O_WRONLY) => 0;
lfs2_file_write(&lfs2, &file[0], "hola\n", 5) => 5;
lfs2_file_write(&lfs2, &file[0], "bonjour\n", 8) => 8;
lfs2_file_write(&lfs2, &file[0], "ohayo\n", 6) => 6;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_open(&lfs2, &file, "a/hello", LFS2_O_CREAT | LFS2_O_WRONLY) => 0;
lfs2_file_write(&lfs2, &file, "hola\n", 5) => 5;
lfs2_file_write(&lfs2, &file, "bonjour\n", 8) => 8;
lfs2_file_write(&lfs2, &file, "ohayo\n", 6) => 6;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Move file ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_rename(&lfs2, "a/hello", "b/hello") => 0;
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "a") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "a") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "hi") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_open(&lfs2, &dir[0], "b") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_dir_open(&lfs2, &dir, "b") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "hello") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Move file corrupt source ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_rename(&lfs2, "b/hello", "c/hello") => 0;
lfs2_unmount(&lfs2) => 0;
TEST
tests/corrupt.py -n 1
tests/test.py << TEST
scripts/corrupt.py -n 1
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "b") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "b") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_open(&lfs2, &dir[0], "c") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_dir_open(&lfs2, &dir, "c") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "hello") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Move file corrupt source and dest ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_rename(&lfs2, "c/hello", "d/hello") => 0;
lfs2_unmount(&lfs2) => 0;
TEST
tests/corrupt.py -n 2
tests/test.py << TEST
scripts/corrupt.py -n 2
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "c") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "c") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "hello") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_open(&lfs2, &dir[0], "d") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_dir_open(&lfs2, &dir, "d") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Move file after corrupt ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_rename(&lfs2, "c/hello", "d/hello") => 0;
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "c") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "c") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_open(&lfs2, &dir[0], "d") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_dir_open(&lfs2, &dir, "d") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "hello") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Move dir ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_rename(&lfs2, "a/hi", "b/hi") => 0;
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "a") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "a") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_open(&lfs2, &dir[0], "b") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_dir_open(&lfs2, &dir, "b") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "hi") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Move dir corrupt source ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_rename(&lfs2, "b/hi", "c/hi") => 0;
lfs2_unmount(&lfs2) => 0;
TEST
tests/corrupt.py -n 1
tests/test.py << TEST
scripts/corrupt.py -n 1
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "b") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "b") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_open(&lfs2, &dir[0], "c") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_dir_open(&lfs2, &dir, "c") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "hi") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Move dir corrupt source and dest ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_rename(&lfs2, "c/hi", "d/hi") => 0;
lfs2_unmount(&lfs2) => 0;
TEST
tests/corrupt.py -n 2
tests/test.py << TEST
scripts/corrupt.py -n 2
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "c") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "c") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "hi") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_open(&lfs2, &dir[0], "d") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_dir_open(&lfs2, &dir, "d") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "hello") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Move dir after corrupt ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_rename(&lfs2, "c/hi", "d/hi") => 0;
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "c") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "c") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_open(&lfs2, &dir[0], "d") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_dir_open(&lfs2, &dir, "d") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "hello") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "hi") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Move check ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "a/hi") => LFS2_ERR_NOENT;
lfs2_dir_open(&lfs2, &dir[0], "b/hi") => LFS2_ERR_NOENT;
lfs2_dir_open(&lfs2, &dir[0], "c/hi") => LFS2_ERR_NOENT;
lfs2_dir_open(&lfs2, &dir, "a/hi") => LFS2_ERR_NOENT;
lfs2_dir_open(&lfs2, &dir, "b/hi") => LFS2_ERR_NOENT;
lfs2_dir_open(&lfs2, &dir, "c/hi") => LFS2_ERR_NOENT;
lfs2_dir_open(&lfs2, &dir[0], "d/hi") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "d/hi") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "bonjour") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "hola") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "ohayo") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_dir_open(&lfs2, &dir[0], "a/hello") => LFS2_ERR_NOENT;
lfs2_dir_open(&lfs2, &dir[0], "b/hello") => LFS2_ERR_NOENT;
lfs2_dir_open(&lfs2, &dir[0], "c/hello") => LFS2_ERR_NOENT;
lfs2_dir_open(&lfs2, &dir, "a/hello") => LFS2_ERR_NOENT;
lfs2_dir_open(&lfs2, &dir, "b/hello") => LFS2_ERR_NOENT;
lfs2_dir_open(&lfs2, &dir, "c/hello") => LFS2_ERR_NOENT;
lfs2_file_open(&lfs2, &file[0], "d/hello", LFS2_O_RDONLY) => 0;
lfs2_file_read(&lfs2, &file[0], buffer, 5) => 5;
lfs2_file_open(&lfs2, &file, "d/hello", LFS2_O_RDONLY) => 0;
lfs2_file_read(&lfs2, &file, buffer, 5) => 5;
memcmp(buffer, "hola\n", 5) => 0;
lfs2_file_read(&lfs2, &file[0], buffer, 8) => 8;
lfs2_file_read(&lfs2, &file, buffer, 8) => 8;
memcmp(buffer, "bonjour\n", 8) => 0;
lfs2_file_read(&lfs2, &file[0], buffer, 6) => 6;
lfs2_file_read(&lfs2, &file, buffer, 6) => 6;
memcmp(buffer, "ohayo\n", 6) => 0;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Move state stealing ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_remove(&lfs2, "b") => 0;
@@ -290,43 +292,42 @@ tests/test.py << TEST
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "a/hi") => LFS2_ERR_NOENT;
lfs2_dir_open(&lfs2, &dir[0], "b") => LFS2_ERR_NOENT;
lfs2_dir_open(&lfs2, &dir[0], "c") => LFS2_ERR_NOENT;
lfs2_dir_open(&lfs2, &dir, "a/hi") => LFS2_ERR_NOENT;
lfs2_dir_open(&lfs2, &dir, "b") => LFS2_ERR_NOENT;
lfs2_dir_open(&lfs2, &dir, "c") => LFS2_ERR_NOENT;
lfs2_dir_open(&lfs2, &dir[0], "d/hi") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "d/hi") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "bonjour") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "hola") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "ohayo") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_dir_open(&lfs2, &dir[0], "a/hello") => LFS2_ERR_NOENT;
lfs2_dir_open(&lfs2, &dir[0], "b") => LFS2_ERR_NOENT;
lfs2_dir_open(&lfs2, &dir[0], "c") => LFS2_ERR_NOENT;
lfs2_dir_open(&lfs2, &dir, "a/hello") => LFS2_ERR_NOENT;
lfs2_dir_open(&lfs2, &dir, "b") => LFS2_ERR_NOENT;
lfs2_dir_open(&lfs2, &dir, "c") => LFS2_ERR_NOENT;
lfs2_file_open(&lfs2, &file[0], "d/hello", LFS2_O_RDONLY) => 0;
lfs2_file_read(&lfs2, &file[0], buffer, 5) => 5;
lfs2_file_open(&lfs2, &file, "d/hello", LFS2_O_RDONLY) => 0;
lfs2_file_read(&lfs2, &file, buffer, 5) => 5;
memcmp(buffer, "hola\n", 5) => 0;
lfs2_file_read(&lfs2, &file[0], buffer, 8) => 8;
lfs2_file_read(&lfs2, &file, buffer, 8) => 8;
memcmp(buffer, "bonjour\n", 8) => 0;
lfs2_file_read(&lfs2, &file[0], buffer, 6) => 6;
lfs2_file_read(&lfs2, &file, buffer, 6) => 6;
memcmp(buffer, "ohayo\n", 6) => 0;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Results ---"
tests/stats.py
scripts/results.py

13
tests/test_orphan.sh
View File

@@ -1,14 +1,16 @@
#!/bin/bash
set -eu
export TEST_FILE=$0
trap 'export TEST_LINE=$LINENO' DEBUG
echo "=== Orphan tests ==="
rm -rf blocks
tests/test.py << TEST
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
TEST
echo "--- Orphan test ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_mkdir(&lfs2, "parent") => 0;
lfs2_mkdir(&lfs2, "parent/orphan") => 0;
@@ -17,8 +19,8 @@ tests/test.py << TEST
TEST
# corrupt most recent commit, this should be the update to the previous
# linked-list entry and should orphan the child
tests/corrupt.py
tests/test.py << TEST
scripts/corrupt.py
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_stat(&lfs2, "parent/orphan", &info) => LFS2_ERR_NOENT;
@@ -41,5 +43,4 @@ tests/test.py << TEST
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Results ---"
tests/stats.py
scripts/results.py

81
tests/test_paths.sh
View File

@@ -1,13 +1,15 @@
#!/bin/bash
set -eu
export TEST_FILE=$0
trap 'export TEST_LINE=$LINENO' DEBUG
echo "=== Path tests ==="
rm -rf blocks
tests/test.py << TEST
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_mkdir(&lfs2, "tea") => 0;
lfs2_mkdir(&lfs2, "coffee") => 0;
@@ -25,7 +27,7 @@ tests/test.py << TEST
TEST
echo "--- Root path tests ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_stat(&lfs2, "tea/hottea", &info) => 0;
strcmp(info.name, "hottea") => 0;
@@ -39,7 +41,7 @@ tests/test.py << TEST
TEST
echo "--- Redundant slash path tests ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_stat(&lfs2, "/tea/hottea", &info) => 0;
strcmp(info.name, "hottea") => 0;
@@ -55,7 +57,7 @@ tests/test.py << TEST
TEST
echo "--- Dot path tests ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_stat(&lfs2, "./tea/hottea", &info) => 0;
strcmp(info.name, "hottea") => 0;
@@ -73,7 +75,7 @@ tests/test.py << TEST
TEST
echo "--- Dot dot path tests ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_stat(&lfs2, "coffee/../tea/hottea", &info) => 0;
strcmp(info.name, "hottea") => 0;
@@ -91,7 +93,7 @@ tests/test.py << TEST
TEST
echo "--- Trailing dot path tests ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_stat(&lfs2, "tea/hottea/", &info) => 0;
strcmp(info.name, "hottea") => 0;
@@ -107,7 +109,7 @@ tests/test.py << TEST
TEST
echo "--- Root dot dot path tests ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_stat(&lfs2, "coffee/../../../../../../tea/hottea", &info) => 0;
strcmp(info.name, "hottea") => 0;
@@ -119,14 +121,14 @@ tests/test.py << TEST
TEST
echo "--- Root tests ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_stat(&lfs2, "/", &info) => 0;
info.type => LFS2_TYPE_DIR;
strcmp(info.name, "/") => 0;
lfs2_mkdir(&lfs2, "/") => LFS2_ERR_EXIST;
lfs2_file_open(&lfs2, &file[0], "/", LFS2_O_WRONLY | LFS2_O_CREAT)
lfs2_file_open(&lfs2, &file, "/", LFS2_O_WRONLY | LFS2_O_CREAT)
=> LFS2_ERR_ISDIR;
// more corner cases
@@ -140,7 +142,7 @@ tests/test.py << TEST
TEST
echo "--- Sketchy path tests ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_mkdir(&lfs2, "dirt/ground") => LFS2_ERR_NOENT;
lfs2_mkdir(&lfs2, "dirt/ground/earth") => LFS2_ERR_NOENT;
@@ -148,7 +150,7 @@ tests/test.py << TEST
TEST
echo "--- Superblock conflict test ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_mkdir(&lfs2, "littlefs") => 0;
lfs2_remove(&lfs2, "littlefs") => 0;
@@ -156,46 +158,45 @@ tests/test.py << TEST
TEST
echo "--- Max path test ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
memset(buffer, 'w', LFS2_NAME_MAX+1);
buffer[LFS2_NAME_MAX+2] = '\0';
lfs2_mkdir(&lfs2, (char*)buffer) => LFS2_ERR_NAMETOOLONG;
lfs2_file_open(&lfs2, &file[0], (char*)buffer,
memset(path, 'w', LFS2_NAME_MAX+1);
path[LFS2_NAME_MAX+2] = '\0';
lfs2_mkdir(&lfs2, path) => LFS2_ERR_NAMETOOLONG;
lfs2_file_open(&lfs2, &file, path,
LFS2_O_WRONLY | LFS2_O_CREAT) => LFS2_ERR_NAMETOOLONG;
memcpy(buffer, "coffee/", strlen("coffee/"));
memset(buffer+strlen("coffee/"), 'w', LFS2_NAME_MAX+1);
buffer[strlen("coffee/")+LFS2_NAME_MAX+2] = '\0';
lfs2_mkdir(&lfs2, (char*)buffer) => LFS2_ERR_NAMETOOLONG;
lfs2_file_open(&lfs2, &file[0], (char*)buffer,
memcpy(path, "coffee/", strlen("coffee/"));
memset(path+strlen("coffee/"), 'w', LFS2_NAME_MAX+1);
path[strlen("coffee/")+LFS2_NAME_MAX+2] = '\0';
lfs2_mkdir(&lfs2, path) => LFS2_ERR_NAMETOOLONG;
lfs2_file_open(&lfs2, &file, path,
LFS2_O_WRONLY | LFS2_O_CREAT) => LFS2_ERR_NAMETOOLONG;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Really big path test ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
memset(buffer, 'w', LFS2_NAME_MAX);
buffer[LFS2_NAME_MAX+1] = '\0';
lfs2_mkdir(&lfs2, (char*)buffer) => 0;
lfs2_remove(&lfs2, (char*)buffer) => 0;
lfs2_file_open(&lfs2, &file[0], (char*)buffer,
memset(path, 'w', LFS2_NAME_MAX);
path[LFS2_NAME_MAX+1] = '\0';
lfs2_mkdir(&lfs2, path) => 0;
lfs2_remove(&lfs2, path) => 0;
lfs2_file_open(&lfs2, &file, path,
LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_remove(&lfs2, (char*)buffer) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_remove(&lfs2, path) => 0;
memcpy(buffer, "coffee/", strlen("coffee/"));
memset(buffer+strlen("coffee/"), 'w', LFS2_NAME_MAX);
buffer[strlen("coffee/")+LFS2_NAME_MAX+1] = '\0';
lfs2_mkdir(&lfs2, (char*)buffer) => 0;
lfs2_remove(&lfs2, (char*)buffer) => 0;
lfs2_file_open(&lfs2, &file[0], (char*)buffer,
memcpy(path, "coffee/", strlen("coffee/"));
memset(path+strlen("coffee/"), 'w', LFS2_NAME_MAX);
path[strlen("coffee/")+LFS2_NAME_MAX+1] = '\0';
lfs2_mkdir(&lfs2, path) => 0;
lfs2_remove(&lfs2, path) => 0;
lfs2_file_open(&lfs2, &file, path,
LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_remove(&lfs2, (char*)buffer) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_remove(&lfs2, path) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Results ---"
tests/stats.py
scripts/results.py

394
tests/test_seek.sh
View File

@@ -1,429 +1,431 @@
#!/bin/bash
set -eu
export TEST_FILE=$0
trap 'export TEST_LINE=$LINENO' DEBUG
echo "=== Seek tests ==="
SMALLSIZE=4
MEDIUMSIZE=128
LARGESIZE=132
echo "=== Seek tests ==="
rm -rf blocks
tests/test.py << TEST
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_mkdir(&lfs2, "hello") => 0;
for (int i = 0; i < $LARGESIZE; i++) {
sprintf((char*)buffer, "hello/kitty%03d", i);
lfs2_file_open(&lfs2, &file[0], (char*)buffer,
sprintf(path, "hello/kitty%03d", i);
lfs2_file_open(&lfs2, &file, path,
LFS2_O_WRONLY | LFS2_O_CREAT | LFS2_O_APPEND) => 0;
size = strlen("kittycatcat");
lfs2_size_t size = strlen("kittycatcat");
memcpy(buffer, "kittycatcat", size);
for (int j = 0; j < $LARGESIZE; j++) {
lfs2_file_write(&lfs2, &file[0], buffer, size);
lfs2_file_write(&lfs2, &file, buffer, size);
}
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
}
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Simple dir seek ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "hello") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "hello") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
lfs2_soff_t pos;
int i;
for (i = 0; i < $SMALLSIZE; i++) {
sprintf((char*)buffer, "kitty%03d", i);
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
strcmp(info.name, (char*)buffer) => 0;
pos = lfs2_dir_tell(&lfs2, &dir[0]);
sprintf(path, "kitty%03d", i);
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, path) => 0;
pos = lfs2_dir_tell(&lfs2, &dir);
}
pos >= 0 => 1;
lfs2_dir_seek(&lfs2, &dir[0], pos) => 0;
sprintf((char*)buffer, "kitty%03d", i);
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
strcmp(info.name, (char*)buffer) => 0;
lfs2_dir_seek(&lfs2, &dir, pos) => 0;
sprintf(path, "kitty%03d", i);
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, path) => 0;
lfs2_dir_rewind(&lfs2, &dir[0]) => 0;
sprintf((char*)buffer, "kitty%03d", 0);
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_rewind(&lfs2, &dir) => 0;
sprintf(path, "kitty%03d", 0);
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
strcmp(info.name, (char*)buffer) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, path) => 0;
lfs2_dir_seek(&lfs2, &dir[0], pos) => 0;
sprintf((char*)buffer, "kitty%03d", i);
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
strcmp(info.name, (char*)buffer) => 0;
lfs2_dir_seek(&lfs2, &dir, pos) => 0;
sprintf(path, "kitty%03d", i);
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, path) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Large dir seek ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_dir_open(&lfs2, &dir[0], "hello") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_open(&lfs2, &dir, "hello") => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
lfs2_soff_t pos;
int i;
for (i = 0; i < $MEDIUMSIZE; i++) {
sprintf((char*)buffer, "kitty%03d", i);
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
strcmp(info.name, (char*)buffer) => 0;
pos = lfs2_dir_tell(&lfs2, &dir[0]);
sprintf(path, "kitty%03d", i);
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, path) => 0;
pos = lfs2_dir_tell(&lfs2, &dir);
}
pos >= 0 => 1;
lfs2_dir_seek(&lfs2, &dir[0], pos) => 0;
sprintf((char*)buffer, "kitty%03d", i);
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
strcmp(info.name, (char*)buffer) => 0;
lfs2_dir_seek(&lfs2, &dir, pos) => 0;
sprintf(path, "kitty%03d", i);
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, path) => 0;
lfs2_dir_rewind(&lfs2, &dir[0]) => 0;
sprintf((char*)buffer, "kitty%03d", 0);
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_rewind(&lfs2, &dir) => 0;
sprintf(path, "kitty%03d", 0);
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, ".") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, "..") => 0;
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
strcmp(info.name, (char*)buffer) => 0;
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, path) => 0;
lfs2_dir_seek(&lfs2, &dir[0], pos) => 0;
sprintf((char*)buffer, "kitty%03d", i);
lfs2_dir_read(&lfs2, &dir[0], &info) => 1;
strcmp(info.name, (char*)buffer) => 0;
lfs2_dir_seek(&lfs2, &dir, pos) => 0;
sprintf(path, "kitty%03d", i);
lfs2_dir_read(&lfs2, &dir, &info) => 1;
strcmp(info.name, path) => 0;
lfs2_dir_close(&lfs2, &dir[0]) => 0;
lfs2_dir_close(&lfs2, &dir) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Simple file seek ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "hello/kitty042", LFS2_O_RDONLY) => 0;
lfs2_file_open(&lfs2, &file, "hello/kitty042", LFS2_O_RDONLY) => 0;
lfs2_soff_t pos;
size = strlen("kittycatcat");
lfs2_size_t size = strlen("kittycatcat");
for (int i = 0; i < $SMALLSIZE; i++) {
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
pos = lfs2_file_tell(&lfs2, &file[0]);
pos = lfs2_file_tell(&lfs2, &file);
}
pos >= 0 => 1;
lfs2_file_seek(&lfs2, &file[0], pos, LFS2_SEEK_SET) => pos;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_seek(&lfs2, &file, pos, LFS2_SEEK_SET) => pos;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs2_file_rewind(&lfs2, &file[0]) => 0;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_rewind(&lfs2, &file) => 0;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs2_file_seek(&lfs2, &file[0], 0, LFS2_SEEK_CUR) => size;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_seek(&lfs2, &file, 0, LFS2_SEEK_CUR) => size;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs2_file_seek(&lfs2, &file[0], size, LFS2_SEEK_CUR) => 3*size;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_seek(&lfs2, &file, size, LFS2_SEEK_CUR) => 3*size;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs2_file_seek(&lfs2, &file[0], pos, LFS2_SEEK_SET) => pos;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_seek(&lfs2, &file, pos, LFS2_SEEK_SET) => pos;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs2_file_seek(&lfs2, &file[0], -size, LFS2_SEEK_CUR) => pos;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_seek(&lfs2, &file, -size, LFS2_SEEK_CUR) => pos;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs2_file_seek(&lfs2, &file[0], -size, LFS2_SEEK_END) >= 0 => 1;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_seek(&lfs2, &file, -size, LFS2_SEEK_END) >= 0 => 1;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
size = lfs2_file_size(&lfs2, &file[0]);
lfs2_file_seek(&lfs2, &file[0], 0, LFS2_SEEK_CUR) => size;
size = lfs2_file_size(&lfs2, &file);
lfs2_file_seek(&lfs2, &file, 0, LFS2_SEEK_CUR) => size;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Large file seek ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "hello/kitty042", LFS2_O_RDONLY) => 0;
lfs2_file_open(&lfs2, &file, "hello/kitty042", LFS2_O_RDONLY) => 0;
lfs2_soff_t pos;
size = strlen("kittycatcat");
lfs2_size_t size = strlen("kittycatcat");
for (int i = 0; i < $MEDIUMSIZE; i++) {
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
pos = lfs2_file_tell(&lfs2, &file[0]);
pos = lfs2_file_tell(&lfs2, &file);
}
pos >= 0 => 1;
lfs2_file_seek(&lfs2, &file[0], pos, LFS2_SEEK_SET) => pos;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_seek(&lfs2, &file, pos, LFS2_SEEK_SET) => pos;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs2_file_rewind(&lfs2, &file[0]) => 0;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_rewind(&lfs2, &file) => 0;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs2_file_seek(&lfs2, &file[0], 0, LFS2_SEEK_CUR) => size;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_seek(&lfs2, &file, 0, LFS2_SEEK_CUR) => size;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs2_file_seek(&lfs2, &file[0], size, LFS2_SEEK_CUR) => 3*size;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_seek(&lfs2, &file, size, LFS2_SEEK_CUR) => 3*size;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs2_file_seek(&lfs2, &file[0], pos, LFS2_SEEK_SET) => pos;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_seek(&lfs2, &file, pos, LFS2_SEEK_SET) => pos;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs2_file_seek(&lfs2, &file[0], -size, LFS2_SEEK_CUR) => pos;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_seek(&lfs2, &file, -size, LFS2_SEEK_CUR) => pos;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs2_file_seek(&lfs2, &file[0], -size, LFS2_SEEK_END) >= 0 => 1;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_seek(&lfs2, &file, -size, LFS2_SEEK_END) >= 0 => 1;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
size = lfs2_file_size(&lfs2, &file[0]);
lfs2_file_seek(&lfs2, &file[0], 0, LFS2_SEEK_CUR) => size;
size = lfs2_file_size(&lfs2, &file);
lfs2_file_seek(&lfs2, &file, 0, LFS2_SEEK_CUR) => size;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Simple file seek and write ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "hello/kitty042", LFS2_O_RDWR) => 0;
lfs2_file_open(&lfs2, &file, "hello/kitty042", LFS2_O_RDWR) => 0;
lfs2_soff_t pos;
size = strlen("kittycatcat");
lfs2_size_t size = strlen("kittycatcat");
for (int i = 0; i < $SMALLSIZE; i++) {
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
pos = lfs2_file_tell(&lfs2, &file[0]);
pos = lfs2_file_tell(&lfs2, &file);
}
pos >= 0 => 1;
memcpy(buffer, "doggodogdog", size);
lfs2_file_seek(&lfs2, &file[0], pos, LFS2_SEEK_SET) => pos;
lfs2_file_write(&lfs2, &file[0], buffer, size) => size;
lfs2_file_seek(&lfs2, &file, pos, LFS2_SEEK_SET) => pos;
lfs2_file_write(&lfs2, &file, buffer, size) => size;
lfs2_file_seek(&lfs2, &file[0], pos, LFS2_SEEK_SET) => pos;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_seek(&lfs2, &file, pos, LFS2_SEEK_SET) => pos;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "doggodogdog", size) => 0;
lfs2_file_rewind(&lfs2, &file[0]) => 0;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_rewind(&lfs2, &file) => 0;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs2_file_seek(&lfs2, &file[0], pos, LFS2_SEEK_SET) => pos;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_seek(&lfs2, &file, pos, LFS2_SEEK_SET) => pos;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "doggodogdog", size) => 0;
lfs2_file_seek(&lfs2, &file[0], -size, LFS2_SEEK_END) >= 0 => 1;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_seek(&lfs2, &file, -size, LFS2_SEEK_END) >= 0 => 1;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
size = lfs2_file_size(&lfs2, &file[0]);
lfs2_file_seek(&lfs2, &file[0], 0, LFS2_SEEK_CUR) => size;
size = lfs2_file_size(&lfs2, &file);
lfs2_file_seek(&lfs2, &file, 0, LFS2_SEEK_CUR) => size;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Large file seek and write ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "hello/kitty042", LFS2_O_RDWR) => 0;
lfs2_file_open(&lfs2, &file, "hello/kitty042", LFS2_O_RDWR) => 0;
lfs2_soff_t pos;
size = strlen("kittycatcat");
lfs2_size_t size = strlen("kittycatcat");
for (int i = 0; i < $MEDIUMSIZE; i++) {
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
if (i != $SMALLSIZE) {
memcmp(buffer, "kittycatcat", size) => 0;
}
pos = lfs2_file_tell(&lfs2, &file[0]);
pos = lfs2_file_tell(&lfs2, &file);
}
pos >= 0 => 1;
memcpy(buffer, "doggodogdog", size);
lfs2_file_seek(&lfs2, &file[0], pos, LFS2_SEEK_SET) => pos;
lfs2_file_write(&lfs2, &file[0], buffer, size) => size;
lfs2_file_seek(&lfs2, &file, pos, LFS2_SEEK_SET) => pos;
lfs2_file_write(&lfs2, &file, buffer, size) => size;
lfs2_file_seek(&lfs2, &file[0], pos, LFS2_SEEK_SET) => pos;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_seek(&lfs2, &file, pos, LFS2_SEEK_SET) => pos;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "doggodogdog", size) => 0;
lfs2_file_rewind(&lfs2, &file[0]) => 0;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_rewind(&lfs2, &file) => 0;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs2_file_seek(&lfs2, &file[0], pos, LFS2_SEEK_SET) => pos;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_seek(&lfs2, &file, pos, LFS2_SEEK_SET) => pos;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "doggodogdog", size) => 0;
lfs2_file_seek(&lfs2, &file[0], -size, LFS2_SEEK_END) >= 0 => 1;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_seek(&lfs2, &file, -size, LFS2_SEEK_END) >= 0 => 1;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
size = lfs2_file_size(&lfs2, &file[0]);
lfs2_file_seek(&lfs2, &file[0], 0, LFS2_SEEK_CUR) => size;
size = lfs2_file_size(&lfs2, &file);
lfs2_file_seek(&lfs2, &file, 0, LFS2_SEEK_CUR) => size;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Boundary seek and write ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "hello/kitty042", LFS2_O_RDWR) => 0;
lfs2_file_open(&lfs2, &file, "hello/kitty042", LFS2_O_RDWR) => 0;
size = strlen("hedgehoghog");
lfs2_size_t size = strlen("hedgehoghog");
const lfs2_soff_t offsets[] = {512, 1020, 513, 1021, 511, 1019};
for (unsigned i = 0; i < sizeof(offsets) / sizeof(offsets[0]); i++) {
lfs2_soff_t off = offsets[i];
memcpy(buffer, "hedgehoghog", size);
lfs2_file_seek(&lfs2, &file[0], off, LFS2_SEEK_SET) => off;
lfs2_file_write(&lfs2, &file[0], buffer, size) => size;
lfs2_file_seek(&lfs2, &file[0], off, LFS2_SEEK_SET) => off;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_seek(&lfs2, &file, off, LFS2_SEEK_SET) => off;
lfs2_file_write(&lfs2, &file, buffer, size) => size;
lfs2_file_seek(&lfs2, &file, off, LFS2_SEEK_SET) => off;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "hedgehoghog", size) => 0;
lfs2_file_seek(&lfs2, &file[0], 0, LFS2_SEEK_SET) => 0;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_seek(&lfs2, &file, 0, LFS2_SEEK_SET) => 0;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "kittycatcat", size) => 0;
lfs2_file_sync(&lfs2, &file[0]) => 0;
lfs2_file_sync(&lfs2, &file) => 0;
}
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Out-of-bounds seek ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "hello/kitty042", LFS2_O_RDWR) => 0;
lfs2_file_open(&lfs2, &file, "hello/kitty042", LFS2_O_RDWR) => 0;
size = strlen("kittycatcat");
lfs2_file_size(&lfs2, &file[0]) => $LARGESIZE*size;
lfs2_file_seek(&lfs2, &file[0], ($LARGESIZE+$SMALLSIZE)*size,
lfs2_size_t size = strlen("kittycatcat");
lfs2_file_size(&lfs2, &file) => $LARGESIZE*size;
lfs2_file_seek(&lfs2, &file, ($LARGESIZE+$SMALLSIZE)*size,
LFS2_SEEK_SET) => ($LARGESIZE+$SMALLSIZE)*size;
lfs2_file_read(&lfs2, &file[0], buffer, size) => 0;
lfs2_file_read(&lfs2, &file, buffer, size) => 0;
memcpy(buffer, "porcupineee", size);
lfs2_file_write(&lfs2, &file[0], buffer, size) => size;
lfs2_file_write(&lfs2, &file, buffer, size) => size;
lfs2_file_seek(&lfs2, &file[0], ($LARGESIZE+$SMALLSIZE)*size,
lfs2_file_seek(&lfs2, &file, ($LARGESIZE+$SMALLSIZE)*size,
LFS2_SEEK_SET) => ($LARGESIZE+$SMALLSIZE)*size;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "porcupineee", size) => 0;
lfs2_file_seek(&lfs2, &file[0], $LARGESIZE*size,
lfs2_file_seek(&lfs2, &file, $LARGESIZE*size,
LFS2_SEEK_SET) => $LARGESIZE*size;
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "\0\0\0\0\0\0\0\0\0\0\0", size) => 0;
lfs2_file_seek(&lfs2, &file[0], -(($LARGESIZE+$SMALLSIZE)*size),
lfs2_file_seek(&lfs2, &file, -(($LARGESIZE+$SMALLSIZE)*size),
LFS2_SEEK_CUR) => LFS2_ERR_INVAL;
lfs2_file_tell(&lfs2, &file[0]) => ($LARGESIZE+1)*size;
lfs2_file_tell(&lfs2, &file) => ($LARGESIZE+1)*size;
lfs2_file_seek(&lfs2, &file[0], -(($LARGESIZE+2*$SMALLSIZE)*size),
lfs2_file_seek(&lfs2, &file, -(($LARGESIZE+2*$SMALLSIZE)*size),
LFS2_SEEK_END) => LFS2_ERR_INVAL;
lfs2_file_tell(&lfs2, &file[0]) => ($LARGESIZE+1)*size;
lfs2_file_tell(&lfs2, &file) => ($LARGESIZE+1)*size;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Inline write and seek ---"
for SIZE in $SMALLSIZE $MEDIUMSIZE $LARGESIZE
do
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "hello/tinykitty$SIZE",
lfs2_file_open(&lfs2, &file, "hello/tinykitty$SIZE",
LFS2_O_RDWR | LFS2_O_CREAT) => 0;
int j = 0;
int k = 0;
memcpy(buffer, "abcdefghijklmnopqrstuvwxyz", 26);
for (unsigned i = 0; i < $SIZE; i++) {
lfs2_file_write(&lfs2, &file[0], &buffer[j++ % 26], 1) => 1;
lfs2_file_tell(&lfs2, &file[0]) => i+1;
lfs2_file_size(&lfs2, &file[0]) => i+1;
lfs2_file_write(&lfs2, &file, &buffer[j++ % 26], 1) => 1;
lfs2_file_tell(&lfs2, &file) => i+1;
lfs2_file_size(&lfs2, &file) => i+1;
}
lfs2_file_seek(&lfs2, &file[0], 0, LFS2_SEEK_SET) => 0;
lfs2_file_tell(&lfs2, &file[0]) => 0;
lfs2_file_size(&lfs2, &file[0]) => $SIZE;
lfs2_file_seek(&lfs2, &file, 0, LFS2_SEEK_SET) => 0;
lfs2_file_tell(&lfs2, &file) => 0;
lfs2_file_size(&lfs2, &file) => $SIZE;
for (unsigned i = 0; i < $SIZE; i++) {
uint8_t c;
lfs2_file_read(&lfs2, &file[0], &c, 1) => 1;
lfs2_file_read(&lfs2, &file, &c, 1) => 1;
c => buffer[k++ % 26];
}
lfs2_file_sync(&lfs2, &file[0]) => 0;
lfs2_file_tell(&lfs2, &file[0]) => $SIZE;
lfs2_file_size(&lfs2, &file[0]) => $SIZE;
lfs2_file_sync(&lfs2, &file) => 0;
lfs2_file_tell(&lfs2, &file) => $SIZE;
lfs2_file_size(&lfs2, &file) => $SIZE;
lfs2_file_seek(&lfs2, &file[0], 0, LFS2_SEEK_SET) => 0;
lfs2_file_seek(&lfs2, &file, 0, LFS2_SEEK_SET) => 0;
for (unsigned i = 0; i < $SIZE; i++) {
lfs2_file_write(&lfs2, &file[0], &buffer[j++ % 26], 1) => 1;
lfs2_file_tell(&lfs2, &file[0]) => i+1;
lfs2_file_size(&lfs2, &file[0]) => $SIZE;
lfs2_file_sync(&lfs2, &file[0]) => 0;
lfs2_file_tell(&lfs2, &file[0]) => i+1;
lfs2_file_size(&lfs2, &file[0]) => $SIZE;
lfs2_file_write(&lfs2, &file, &buffer[j++ % 26], 1) => 1;
lfs2_file_tell(&lfs2, &file) => i+1;
lfs2_file_size(&lfs2, &file) => $SIZE;
lfs2_file_sync(&lfs2, &file) => 0;
lfs2_file_tell(&lfs2, &file) => i+1;
lfs2_file_size(&lfs2, &file) => $SIZE;
if (i < $SIZE-2) {
uint8_t c[3];
lfs2_file_seek(&lfs2, &file[0], -1, LFS2_SEEK_CUR) => i;
lfs2_file_read(&lfs2, &file[0], &c, 3) => 3;
lfs2_file_tell(&lfs2, &file[0]) => i+3;
lfs2_file_size(&lfs2, &file[0]) => $SIZE;
lfs2_file_seek(&lfs2, &file[0], i+1, LFS2_SEEK_SET) => i+1;
lfs2_file_tell(&lfs2, &file[0]) => i+1;
lfs2_file_size(&lfs2, &file[0]) => $SIZE;
lfs2_file_seek(&lfs2, &file, -1, LFS2_SEEK_CUR) => i;
lfs2_file_read(&lfs2, &file, &c, 3) => 3;
lfs2_file_tell(&lfs2, &file) => i+3;
lfs2_file_size(&lfs2, &file) => $SIZE;
lfs2_file_seek(&lfs2, &file, i+1, LFS2_SEEK_SET) => i+1;
lfs2_file_tell(&lfs2, &file) => i+1;
lfs2_file_size(&lfs2, &file) => $SIZE;
}
}
lfs2_file_seek(&lfs2, &file[0], 0, LFS2_SEEK_SET) => 0;
lfs2_file_tell(&lfs2, &file[0]) => 0;
lfs2_file_size(&lfs2, &file[0]) => $SIZE;
lfs2_file_seek(&lfs2, &file, 0, LFS2_SEEK_SET) => 0;
lfs2_file_tell(&lfs2, &file) => 0;
lfs2_file_size(&lfs2, &file) => $SIZE;
for (unsigned i = 0; i < $SIZE; i++) {
uint8_t c;
lfs2_file_read(&lfs2, &file[0], &c, 1) => 1;
lfs2_file_read(&lfs2, &file, &c, 1) => 1;
c => buffer[k++ % 26];
}
lfs2_file_sync(&lfs2, &file[0]) => 0;
lfs2_file_tell(&lfs2, &file[0]) => $SIZE;
lfs2_file_size(&lfs2, &file[0]) => $SIZE;
lfs2_file_sync(&lfs2, &file) => 0;
lfs2_file_tell(&lfs2, &file) => $SIZE;
lfs2_file_size(&lfs2, &file) => $SIZE;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
done
echo "--- Results ---"
tests/stats.py
scripts/results.py

192
tests/test_truncate.sh
View File

@@ -1,156 +1,159 @@
#!/bin/bash
set -eu
export TEST_FILE=$0
trap 'export TEST_LINE=$LINENO' DEBUG
echo "=== Truncate tests ==="
SMALLSIZE=32
MEDIUMSIZE=2048
LARGESIZE=8192
echo "=== Truncate tests ==="
rm -rf blocks
tests/test.py << TEST
scripts/test.py << TEST
lfs2_format(&lfs2, &cfg) => 0;
TEST
echo "--- Simple truncate ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "baldynoop",
lfs2_file_open(&lfs2, &file, "baldynoop",
LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
strcpy((char*)buffer, "hair");
size = strlen((char*)buffer);
lfs2_size_t size = strlen((char*)buffer);
for (lfs2_off_t j = 0; j < $LARGESIZE; j += size) {
lfs2_file_write(&lfs2, &file[0], buffer, size) => size;
lfs2_file_write(&lfs2, &file, buffer, size) => size;
}
lfs2_file_size(&lfs2, &file[0]) => $LARGESIZE;
lfs2_file_size(&lfs2, &file) => $LARGESIZE;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "baldynoop", LFS2_O_RDWR) => 0;
lfs2_file_size(&lfs2, &file[0]) => $LARGESIZE;
lfs2_file_open(&lfs2, &file, "baldynoop", LFS2_O_RDWR) => 0;
lfs2_file_size(&lfs2, &file) => $LARGESIZE;
lfs2_file_truncate(&lfs2, &file[0], $MEDIUMSIZE) => 0;
lfs2_file_size(&lfs2, &file[0]) => $MEDIUMSIZE;
lfs2_file_truncate(&lfs2, &file, $MEDIUMSIZE) => 0;
lfs2_file_size(&lfs2, &file) => $MEDIUMSIZE;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "baldynoop", LFS2_O_RDONLY) => 0;
lfs2_file_size(&lfs2, &file[0]) => $MEDIUMSIZE;
lfs2_file_open(&lfs2, &file, "baldynoop", LFS2_O_RDONLY) => 0;
lfs2_file_size(&lfs2, &file) => $MEDIUMSIZE;
size = strlen("hair");
lfs2_size_t size = strlen("hair");
for (lfs2_off_t j = 0; j < $MEDIUMSIZE; j += size) {
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "hair", size) => 0;
}
lfs2_file_read(&lfs2, &file[0], buffer, size) => 0;
lfs2_file_read(&lfs2, &file, buffer, size) => 0;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Truncate and read ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "baldyread",
lfs2_file_open(&lfs2, &file, "baldyread",
LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
strcpy((char*)buffer, "hair");
size = strlen((char*)buffer);
lfs2_size_t size = strlen((char*)buffer);
for (lfs2_off_t j = 0; j < $LARGESIZE; j += size) {
lfs2_file_write(&lfs2, &file[0], buffer, size) => size;
lfs2_file_write(&lfs2, &file, buffer, size) => size;
}
lfs2_file_size(&lfs2, &file[0]) => $LARGESIZE;
lfs2_file_size(&lfs2, &file) => $LARGESIZE;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "baldyread", LFS2_O_RDWR) => 0;
lfs2_file_size(&lfs2, &file[0]) => $LARGESIZE;
lfs2_file_open(&lfs2, &file, "baldyread", LFS2_O_RDWR) => 0;
lfs2_file_size(&lfs2, &file) => $LARGESIZE;
lfs2_file_truncate(&lfs2, &file[0], $MEDIUMSIZE) => 0;
lfs2_file_size(&lfs2, &file[0]) => $MEDIUMSIZE;
lfs2_file_truncate(&lfs2, &file, $MEDIUMSIZE) => 0;
lfs2_file_size(&lfs2, &file) => $MEDIUMSIZE;
size = strlen("hair");
lfs2_size_t size = strlen("hair");
for (lfs2_off_t j = 0; j < $MEDIUMSIZE; j += size) {
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "hair", size) => 0;
}
lfs2_file_read(&lfs2, &file[0], buffer, size) => 0;
lfs2_file_read(&lfs2, &file, buffer, size) => 0;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "baldyread", LFS2_O_RDONLY) => 0;
lfs2_file_size(&lfs2, &file[0]) => $MEDIUMSIZE;
lfs2_file_open(&lfs2, &file, "baldyread", LFS2_O_RDONLY) => 0;
lfs2_file_size(&lfs2, &file) => $MEDIUMSIZE;
size = strlen("hair");
lfs2_size_t size = strlen("hair");
for (lfs2_off_t j = 0; j < $MEDIUMSIZE; j += size) {
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "hair", size) => 0;
}
lfs2_file_read(&lfs2, &file[0], buffer, size) => 0;
lfs2_file_read(&lfs2, &file, buffer, size) => 0;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
echo "--- Truncate and write ---"
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "baldywrite",
lfs2_file_open(&lfs2, &file, "baldywrite",
LFS2_O_WRONLY | LFS2_O_CREAT) => 0;
strcpy((char*)buffer, "hair");
size = strlen((char*)buffer);
lfs2_size_t size = strlen((char*)buffer);
for (lfs2_off_t j = 0; j < $LARGESIZE; j += size) {
lfs2_file_write(&lfs2, &file[0], buffer, size) => size;
lfs2_file_write(&lfs2, &file, buffer, size) => size;
}
lfs2_file_size(&lfs2, &file[0]) => $LARGESIZE;
lfs2_file_size(&lfs2, &file) => $LARGESIZE;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "baldywrite", LFS2_O_RDWR) => 0;
lfs2_file_size(&lfs2, &file[0]) => $LARGESIZE;
lfs2_file_open(&lfs2, &file, "baldywrite", LFS2_O_RDWR) => 0;
lfs2_file_size(&lfs2, &file) => $LARGESIZE;
lfs2_file_truncate(&lfs2, &file[0], $MEDIUMSIZE) => 0;
lfs2_file_size(&lfs2, &file[0]) => $MEDIUMSIZE;
lfs2_file_truncate(&lfs2, &file, $MEDIUMSIZE) => 0;
lfs2_file_size(&lfs2, &file) => $MEDIUMSIZE;
strcpy((char*)buffer, "bald");
size = strlen((char*)buffer);
lfs2_size_t size = strlen((char*)buffer);
for (lfs2_off_t j = 0; j < $MEDIUMSIZE; j += size) {
lfs2_file_write(&lfs2, &file[0], buffer, size) => size;
lfs2_file_write(&lfs2, &file, buffer, size) => size;
}
lfs2_file_size(&lfs2, &file[0]) => $MEDIUMSIZE;
lfs2_file_size(&lfs2, &file) => $MEDIUMSIZE;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
lfs2_file_open(&lfs2, &file[0], "baldywrite", LFS2_O_RDONLY) => 0;
lfs2_file_size(&lfs2, &file[0]) => $MEDIUMSIZE;
lfs2_file_open(&lfs2, &file, "baldywrite", LFS2_O_RDONLY) => 0;
lfs2_file_size(&lfs2, &file) => $MEDIUMSIZE;
size = strlen("bald");
lfs2_size_t size = strlen("bald");
for (lfs2_off_t j = 0; j < $MEDIUMSIZE; j += size) {
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "bald", size) => 0;
}
lfs2_file_read(&lfs2, &file[0], buffer, size) => 0;
lfs2_file_read(&lfs2, &file, buffer, size) => 0;
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
lfs2_unmount(&lfs2) => 0;
TEST
@@ -160,7 +163,7 @@ STARTSIZES="$1"
STARTSEEKS="$2"
HOTSIZES="$3"
COLDSIZES="$4"
tests/test.py << TEST
scripts/test.py << TEST
static const lfs2_off_t startsizes[] = {$STARTSIZES};
static const lfs2_off_t startseeks[] = {$STARTSEEKS};
static const lfs2_off_t hotsizes[] = {$HOTSIZES};
@@ -168,31 +171,31 @@ tests/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
for (unsigned i = 0; i < sizeof(startsizes)/sizeof(startsizes[0]); i++) {
sprintf((char*)buffer, "hairyhead%d", i);
lfs2_file_open(&lfs2, &file[0], (const char*)buffer,
sprintf(path, "hairyhead%d", i);
lfs2_file_open(&lfs2, &file, path,
LFS2_O_WRONLY | LFS2_O_CREAT | LFS2_O_TRUNC) => 0;
strcpy((char*)buffer, "hair");
size = strlen((char*)buffer);
lfs2_size_t size = strlen((char*)buffer);
for (lfs2_off_t j = 0; j < startsizes[i]; j += size) {
lfs2_file_write(&lfs2, &file[0], buffer, size) => size;
lfs2_file_write(&lfs2, &file, buffer, size) => size;
}
lfs2_file_size(&lfs2, &file[0]) => startsizes[i];
lfs2_file_size(&lfs2, &file) => startsizes[i];
if (startseeks[i] != startsizes[i]) {
lfs2_file_seek(&lfs2, &file[0],
lfs2_file_seek(&lfs2, &file,
startseeks[i], LFS2_SEEK_SET) => startseeks[i];
}
lfs2_file_truncate(&lfs2, &file[0], hotsizes[i]) => 0;
lfs2_file_size(&lfs2, &file[0]) => hotsizes[i];
lfs2_file_truncate(&lfs2, &file, hotsizes[i]) => 0;
lfs2_file_size(&lfs2, &file) => hotsizes[i];
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
}
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
static const lfs2_off_t startsizes[] = {$STARTSIZES};
static const lfs2_off_t hotsizes[] = {$HOTSIZES};
static const lfs2_off_t coldsizes[] = {$COLDSIZES};
@@ -200,31 +203,31 @@ tests/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
for (unsigned i = 0; i < sizeof(startsizes)/sizeof(startsizes[0]); i++) {
sprintf((char*)buffer, "hairyhead%d", i);
lfs2_file_open(&lfs2, &file[0], (const char*)buffer, LFS2_O_RDWR) => 0;
lfs2_file_size(&lfs2, &file[0]) => hotsizes[i];
sprintf(path, "hairyhead%d", i);
lfs2_file_open(&lfs2, &file, path, LFS2_O_RDWR) => 0;
lfs2_file_size(&lfs2, &file) => hotsizes[i];
size = strlen("hair");
lfs2_size_t size = strlen("hair");
lfs2_off_t j = 0;
for (; j < startsizes[i] && j < hotsizes[i]; j += size) {
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "hair", size) => 0;
}
for (; j < hotsizes[i]; j += size) {
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "\0\0\0\0", size) => 0;
}
lfs2_file_truncate(&lfs2, &file[0], coldsizes[i]) => 0;
lfs2_file_size(&lfs2, &file[0]) => coldsizes[i];
lfs2_file_truncate(&lfs2, &file, coldsizes[i]) => 0;
lfs2_file_size(&lfs2, &file) => coldsizes[i];
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
}
lfs2_unmount(&lfs2) => 0;
TEST
tests/test.py << TEST
scripts/test.py << TEST
static const lfs2_off_t startsizes[] = {$STARTSIZES};
static const lfs2_off_t hotsizes[] = {$HOTSIZES};
static const lfs2_off_t coldsizes[] = {$COLDSIZES};
@@ -232,24 +235,24 @@ tests/test.py << TEST
lfs2_mount(&lfs2, &cfg) => 0;
for (unsigned i = 0; i < sizeof(startsizes)/sizeof(startsizes[0]); i++) {
sprintf((char*)buffer, "hairyhead%d", i);
lfs2_file_open(&lfs2, &file[0], (const char*)buffer, LFS2_O_RDONLY) => 0;
lfs2_file_size(&lfs2, &file[0]) => coldsizes[i];
sprintf(path, "hairyhead%d", i);
lfs2_file_open(&lfs2, &file, path, LFS2_O_RDONLY) => 0;
lfs2_file_size(&lfs2, &file) => coldsizes[i];
size = strlen("hair");
lfs2_size_t size = strlen("hair");
lfs2_off_t j = 0;
for (; j < startsizes[i] && j < hotsizes[i] && j < coldsizes[i];
j += size) {
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "hair", size) => 0;
}
for (; j < coldsizes[i]; j += size) {
lfs2_file_read(&lfs2, &file[0], buffer, size) => size;
lfs2_file_read(&lfs2, &file, buffer, size) => size;
memcmp(buffer, "\0\0\0\0", size) => 0;
}
lfs2_file_close(&lfs2, &file[0]) => 0;
lfs2_file_close(&lfs2, &file) => 0;
}
lfs2_unmount(&lfs2) => 0;
@@ -298,5 +301,4 @@ truncate_test \
"2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE" \
"2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE"
echo "--- Results ---"
tests/stats.py
scripts/results.py