Merge pull request #232 from ARMmbed/debug-improvements

Debug improvements

Makefile

@@ -24,6 +24,9 @@ endif
 ifdef WORD
 override CFLAGS += -m$(WORD)
 endif
+ifdef TRACE
+override CFLAGS += -DLFS_YES_TRACE
+endif
 override CFLAGS += -I.
 override CFLAGS += -std=c99 -Wall -pedantic
 override CFLAGS += -Wextra -Wshadow -Wjump-misses-init
@@ -39,9 +42,20 @@ size: $(OBJ)
 	$(SIZE) -t $^
 
 .SUFFIXES:
-test: test_format test_dirs test_files test_seek test_truncate \
+test: \
-	test_entries test_interspersed test_alloc test_paths test_attrs \
+	test_format \
-	test_move test_orphan test_corrupt
+	test_dirs \
+	test_files \
+	test_seek \
+	test_truncate \
+	test_entries \
+	test_interspersed \
+	test_alloc \
+	test_paths \
+	test_attrs \
+	test_move \
+	test_orphan \
+	test_corrupt
 	@rm test.c
 test_%: tests/test_%.sh
 

emubd/lfs_emubd.c

@@ -54,6 +54,15 @@ static inline void lfs_emubd_fromle32(lfs_emubd_t *emu) {
 
 // Block device emulated on existing filesystem
 int lfs_emubd_create(const struct lfs_config *cfg, const char *path) {
+    LFS_TRACE("lfs_emubd_create(%p {.context=%p, "
+                ".read=%p, .prog=%p, .erase=%p, .sync=%p, "
+                ".read_size=%"PRIu32", .prog_size=%"PRIu32", "
+                ".block_size=%"PRIu32", .block_count=%"PRIu32"}, \"%s\")",
+            (void*)cfg, cfg->context,
+            (void*)(uintptr_t)cfg->read, (void*)(uintptr_t)cfg->prog,
+            (void*)(uintptr_t)cfg->erase, (void*)(uintptr_t)cfg->sync,
+            cfg->read_size, cfg->prog_size, cfg->block_size, cfg->block_count,
+            path);
     lfs_emubd_t *emu = cfg->context;
     emu->cfg.read_size   = cfg->read_size;
     emu->cfg.prog_size   = cfg->prog_size;
@@ -64,7 +73,9 @@ int lfs_emubd_create(const struct lfs_config *cfg, const char *path) {
     size_t pathlen = strlen(path);
     emu->path = malloc(pathlen + 1 + LFS_NAME_MAX + 1);
     if (!emu->path) {
-        return -ENOMEM;
+        int err = -ENOMEM;
+        LFS_TRACE("lfs_emubd_create -> %"PRId32, err);
+        return err;
     }
 
     strcpy(emu->path, path);
@@ -75,7 +86,9 @@ int lfs_emubd_create(const struct lfs_config *cfg, const char *path) {
     // Create directory if it doesn't exist
     int err = mkdir(path, 0777);
     if (err && errno != EEXIST) {
-        return -errno;
+        err = -errno;
+        LFS_TRACE("lfs_emubd_create -> %"PRId32, err);
+        return err;
     }
 
     // Load stats to continue incrementing
@@ -87,12 +100,16 @@ int lfs_emubd_create(const struct lfs_config *cfg, const char *path) {
         size_t res = fread(&emu->stats, sizeof(emu->stats), 1, f);
         lfs_emubd_fromle32(emu);
         if (res < 1) {
-            return -errno;
+            err = -errno;
+            LFS_TRACE("lfs_emubd_create -> %"PRId32, err);
+            return err;
         }
 
         err = fclose(f);
         if (err) {
-            return -errno;
+            err = -errno;
+            LFS_TRACE("lfs_emubd_create -> %"PRId32, err);
+            return err;
         }
     }
 
@@ -105,27 +122,36 @@ int lfs_emubd_create(const struct lfs_config *cfg, const char *path) {
         size_t res = fread(&emu->history, sizeof(emu->history), 1, f);
         lfs_emubd_fromle32(emu);
         if (res < 1) {
-            return -errno;
+            err = -errno;
+            LFS_TRACE("lfs_emubd_create -> %"PRId32, err);
+            return err;
         }
 
         err = fclose(f);
         if (err) {
-            return -errno;
+            err = -errno;
+            LFS_TRACE("lfs_emubd_create -> %"PRId32, err);
+            return err;
         }
     }
 
+    LFS_TRACE("lfs_emubd_create -> %"PRId32, 0);
     return 0;
 }
 
 void lfs_emubd_destroy(const struct lfs_config *cfg) {
+    LFS_TRACE("lfs_emubd_destroy(%p)", (void*)cfg);
     lfs_emubd_sync(cfg);
 
     lfs_emubd_t *emu = cfg->context;
     free(emu->path);
+    LFS_TRACE("lfs_emubd_destroy -> %s", "void");
 }
 
 int lfs_emubd_read(const struct lfs_config *cfg, lfs_block_t block,
         lfs_off_t off, void *buffer, lfs_size_t size) {
+    LFS_TRACE("lfs_emubd_read(%p, 0x%"PRIx32", %"PRIu32", %p, %"PRIu32")",
+            (void*)cfg, block, off, buffer, size);
     lfs_emubd_t *emu = cfg->context;
     uint8_t *data = buffer;
 
@@ -142,32 +168,43 @@ int lfs_emubd_read(const struct lfs_config *cfg, lfs_block_t block,
 
     FILE *f = fopen(emu->path, "rb");
     if (!f && errno != ENOENT) {
-        return -errno;
+        int err = -errno;
+        LFS_TRACE("lfs_emubd_read -> %d", err);
+        return err;
     }
 
     if (f) {
         int err = fseek(f, off, SEEK_SET);
         if (err) {
-            return -errno;
+            err = -errno;
+            LFS_TRACE("lfs_emubd_read -> %d", err);
+            return err;
         }
 
         size_t res = fread(data, 1, size, f);
         if (res < size && !feof(f)) {
-            return -errno;
+            err = -errno;
+            LFS_TRACE("lfs_emubd_read -> %d", err);
+            return err;
         }
 
         err = fclose(f);
         if (err) {
-            return -errno;
+            err = -errno;
+            LFS_TRACE("lfs_emubd_read -> %d", err);
+            return err;
         }
     }
 
-    emu->stats.read_count += 1;
+    emu->stats.read_count += size;
+    LFS_TRACE("lfs_emubd_read -> %d", 0);
     return 0;
 }
 
 int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block,
         lfs_off_t off, const void *buffer, lfs_size_t size) {
+    LFS_TRACE("lfs_emubd_prog(%p, 0x%"PRIx32", %"PRIu32", %p, %"PRIu32")",
+            (void*)cfg, block, off, buffer, size);
     lfs_emubd_t *emu = cfg->context;
     const uint8_t *data = buffer;
 
@@ -181,7 +218,9 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block,
 
     FILE *f = fopen(emu->path, "r+b");
     if (!f) {
-        return (errno == EACCES) ? 0 : -errno;
+        int err = (errno == EACCES) ? 0 : -errno;
+        LFS_TRACE("lfs_emubd_prog -> %d", err);
+        return err;
     }
 
     // Check that file was erased
@@ -189,28 +228,38 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block,
 
     int err = fseek(f, off, SEEK_SET);
     if (err) {
-        return -errno;
+        err = -errno;
+        LFS_TRACE("lfs_emubd_prog -> %d", err);
+        return err;
     }
 
     size_t res = fwrite(data, 1, size, f);
     if (res < size) {
-        return -errno;
+        err = -errno;
+        LFS_TRACE("lfs_emubd_prog -> %d", err);
+        return err;
     }
 
     err = fseek(f, off, SEEK_SET);
     if (err) {
-        return -errno;
+        err = -errno;
+        LFS_TRACE("lfs_emubd_prog -> %d", err);
+        return err;
     }
 
     uint8_t dat;
     res = fread(&dat, 1, 1, f);
     if (res < 1) {
-        return -errno;
+        err = -errno;
+        LFS_TRACE("lfs_emubd_prog -> %d", err);
+        return err;
     }
 
     err = fclose(f);
     if (err) {
-        return -errno;
+        err = -errno;
+        LFS_TRACE("lfs_emubd_prog -> %d", err);
+        return err;
     }
 
     // update history and stats
@@ -220,11 +269,13 @@ int lfs_emubd_prog(const struct lfs_config *cfg, lfs_block_t block,
         emu->history.blocks[0] = block;
     }
 
-    emu->stats.prog_count += 1;
+    emu->stats.prog_count += size;
+    LFS_TRACE("lfs_emubd_prog -> %d", 0);
     return 0;
 }
 
 int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) {
+    LFS_TRACE("lfs_emubd_erase(%p, 0x%"PRIx32")", (void*)cfg, block);
     lfs_emubd_t *emu = cfg->context;
 
     // Check if erase is valid
@@ -235,89 +286,118 @@ int lfs_emubd_erase(const struct lfs_config *cfg, lfs_block_t block) {
     struct stat st;
     int err = stat(emu->path, &st);
     if (err && errno != ENOENT) {
-        return -errno;
+        err = -errno;
+        LFS_TRACE("lfs_emubd_erase -> %d", err);
+        return err;
     }
 
     if (!err && S_ISREG(st.st_mode) && (S_IWUSR & st.st_mode)) {
         err = unlink(emu->path);
         if (err) {
-            return -errno;
+            err = -errno;
+            LFS_TRACE("lfs_emubd_erase -> %d", err);
+            return err;
         }
     }
 
     if (err || (S_ISREG(st.st_mode) && (S_IWUSR & st.st_mode))) {
         FILE *f = fopen(emu->path, "w");
         if (!f) {
-            return -errno;
+            err = -errno;
+            LFS_TRACE("lfs_emubd_erase -> %d", err);
+            return err;
         }
 
         err = fclose(f);
         if (err) {
-            return -errno;
+            err = -errno;
+            LFS_TRACE("lfs_emubd_erase -> %d", err);
+            return err;
         }
     }
 
-    emu->stats.erase_count += 1;
+    emu->stats.erase_count += cfg->block_size;
+    LFS_TRACE("lfs_emubd_erase -> %d", 0);
     return 0;
 }
 
 int lfs_emubd_sync(const struct lfs_config *cfg) {
+    LFS_TRACE("lfs_emubd_sync(%p)", (void*)cfg);
     lfs_emubd_t *emu = cfg->context;
 
     // Just write out info/stats for later lookup
     snprintf(emu->child, LFS_NAME_MAX, ".config");
     FILE *f = fopen(emu->path, "w");
     if (!f) {
-        return -errno;
+        int err = -errno;
+        LFS_TRACE("lfs_emubd_sync -> %d", err);
+        return err;
     }
 
     lfs_emubd_tole32(emu);
     size_t res = fwrite(&emu->cfg, sizeof(emu->cfg), 1, f);
     lfs_emubd_fromle32(emu);
     if (res < 1) {
-        return -errno;
+        int err = -errno;
+        LFS_TRACE("lfs_emubd_sync -> %d", err);
+        return err;
     }
 
     int err = fclose(f);
     if (err) {
-        return -errno;
+        err = -errno;
+        LFS_TRACE("lfs_emubd_sync -> %d", err);
+        return err;
     }
 
     snprintf(emu->child, LFS_NAME_MAX, ".stats");
     f = fopen(emu->path, "w");
     if (!f) {
-        return -errno;
+        err = -errno;
+        LFS_TRACE("lfs_emubd_sync -> %d", err);
+        return err;
     }
 
     lfs_emubd_tole32(emu);
     res = fwrite(&emu->stats, sizeof(emu->stats), 1, f);
     lfs_emubd_fromle32(emu);
     if (res < 1) {
-        return -errno;
+        err = -errno;
+        LFS_TRACE("lfs_emubd_sync -> %d", err);
+        return err;
     }
 
     err = fclose(f);
     if (err) {
-        return -errno;
+        err = -errno;
+        LFS_TRACE("lfs_emubd_sync -> %d", err);
+        return err;
     }
 
     snprintf(emu->child, LFS_NAME_MAX, ".history");
     f = fopen(emu->path, "w");
     if (!f) {
-        return -errno;
+        err = -errno;
+        LFS_TRACE("lfs_emubd_sync -> %d", err);
+        return err;
     }
 
     lfs_emubd_tole32(emu);
     res = fwrite(&emu->history, sizeof(emu->history), 1, f);
     lfs_emubd_fromle32(emu);
     if (res < 1) {
-        return -errno;
+        err = -errno;
+        LFS_TRACE("lfs_emubd_sync -> %d", err);
+        return err;
     }
 
     err = fclose(f);
     if (err) {
-        return -errno;
+        err = -errno;
+        LFS_TRACE("lfs_emubd_sync -> %d", err);
+        return err;
     }
 
+    LFS_TRACE("lfs_emubd_sync -> %d", 0);
     return 0;
 }

lfs_util.h

@@ -31,7 +31,10 @@
 #ifndef LFS_NO_ASSERT
 #include <assert.h>
 #endif
-#if !defined(LFS_NO_DEBUG) || !defined(LFS_NO_WARN) || !defined(LFS_NO_ERROR)
+#if !defined(LFS_NO_DEBUG) || \
+        !defined(LFS_NO_WARN) || \
+        !defined(LFS_NO_ERROR) || \
+        defined(LFS_YES_TRACE)
 #include <stdio.h>
 #endif
 
@@ -46,23 +49,30 @@ extern "C"
 // code footprint
 
 // Logging functions
+#ifdef LFS_YES_TRACE
+#define LFS_TRACE(fmt, ...) \
+    printf("lfs_trace:%d: " fmt "\n", __LINE__, __VA_ARGS__)
+#else
+#define LFS_TRACE(fmt, ...)
+#endif
+
 #ifndef LFS_NO_DEBUG
 #define LFS_DEBUG(fmt, ...) \
-    printf("lfs debug:%d: " fmt "\n", __LINE__, __VA_ARGS__)
+    printf("lfs_debug:%d: " fmt "\n", __LINE__, __VA_ARGS__)
 #else
 #define LFS_DEBUG(fmt, ...)
 #endif
 
 #ifndef LFS_NO_WARN
 #define LFS_WARN(fmt, ...) \
-    printf("lfs warn:%d: " fmt "\n", __LINE__, __VA_ARGS__)
+    printf("lfs_warn:%d: " fmt "\n", __LINE__, __VA_ARGS__)
 #else
 #define LFS_WARN(fmt, ...)
 #endif
 
 #ifndef LFS_NO_ERROR
 #define LFS_ERROR(fmt, ...) \
-    printf("lfs error:%d: " fmt "\n", __LINE__, __VA_ARGS__)
+    printf("lfs_error:%d: " fmt "\n", __LINE__, __VA_ARGS__)
 #else
 #define LFS_ERROR(fmt, ...)
 #endif

scripts/debug.py

@@ -95,7 +95,7 @@ def main(*blocks):
         print '%04x: %08x  %-15s %3s %4s  %-23s  %-8s' % (
             off, tag,
             typeof(type) + (' bad!' if iscrc and ~crc else ''),
-            id if id != 0x3ff else '.',
+            hex(id)[2:] if id != 0x3ff else '.',
             size if size != 0x3ff else 'x',
             ' '.join('%02x' % ord(c) for c in data[:8]),
             ''.join(c if c >= ' ' and c <= '~' else '.' for c in data[:8]))

scripts/results.py

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

scripts/template.fmt

@@ -7,34 +7,21 @@
 
 
 // test stuff
-static void test_log(const char *s, uintmax_t v) {{
-    printf("%s: %jd\n", s, v);
-}}
-
 static void test_assert(const char *file, unsigned line,
         const char *s, uintmax_t v, uintmax_t e) {{
-    static const char *last[6] = {{0, 0}};
-    if (v != e || !(last[0] == s || last[1] == s ||
-            last[2] == s || last[3] == s ||
-            last[4] == s || last[5] == s)) {{
-        test_log(s, v);
-        last[0] = last[1];
-        last[1] = last[2];
-        last[2] = last[3];
-        last[3] = last[4];
-        last[4] = last[5];
-        last[5] = s;
-    }}
-
     if (v != e) {{
-        fprintf(stderr, "\033[31m%s:%u: assert %s failed with %jd, "
+        fprintf(stderr, "\033[97m%s:%u: \033[91m"
-                "expected %jd\033[0m\n", file, line, s, v, e);
+                "assert failed with %jd, expected %jd\033[0m\n"
+                "    %s\n\n", file, line, v, e, s);
         exit(-2);
     }}
 }}
 
-#define test_assert(s, v, e) test_assert(__FILE__, __LINE__, s, v, e)
+#define test_assert(v, e) \
+        test_assert(__FILE__, __LINE__, #v " => " #e, v, e)
 
+// implicit variable for asserts
+uintmax_t test;
 
 // utility functions for traversals
 static int __attribute__((used)) test_count(void *p, lfs_block_t b) {{
@@ -44,23 +31,17 @@ static int __attribute__((used)) test_count(void *p, lfs_block_t b) {{
     return 0;
 }}
 
-
 // lfs declarations
 lfs_t lfs;
 lfs_emubd_t bd;
-lfs_file_t file[4];
+// other declarations for convenience
-lfs_dir_t dir[4];
+lfs_file_t file;
+lfs_dir_t dir;
 struct lfs_info info;
-
 uint8_t buffer[1024];
-uint8_t wbuffer[1024];
+char path[1024];
-uint8_t rbuffer[1024];
-lfs_size_t size;
-lfs_size_t wsize;
-lfs_size_t rsize;
-
-uintmax_t test;
 
+// test configuration options
 #ifndef LFS_READ_SIZE
 #define LFS_READ_SIZE 16
 #endif
@@ -111,6 +92,5 @@ int main(void) {{
     lfs_emubd_create(&cfg, "blocks");
 
 {tests}
-
     lfs_emubd_destroy(&cfg);
 }}

scripts/test.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python2
+
+import re
+import sys
+import subprocess
+import os
+
+
+def generate(test):
+    with open("scripts/template.fmt") as file:
+        template = file.read()
+
+    haslines = 'TEST_LINE' in os.environ and 'TEST_FILE' in os.environ
+
+    lines = []
+    for offset, line in enumerate(
+            re.split('(?<=(?:.;| [{}]))\n', test.read())):
+        match = re.match('((?: *\n)*)( *)(.*)=>(.*);',
+                line, re.DOTALL | re.MULTILINE)
+        if match:
+            preface, tab, test, expect = match.groups()
+            lines.extend(['']*preface.count('\n'))
+            lines.append(tab+'test_assert({test}, {expect});'.format(
+                test=test.strip(), expect=expect.strip()))
+        else:
+            lines.append(line)
+
+    # Create test file
+    with open('test.c', 'w') as file:
+        if 'TEST_LINE' in os.environ and 'TEST_FILE' in os.environ:
+            lines.insert(0, '#line %d "%s"' % (
+                    int(os.environ['TEST_LINE']) + 1,
+                    os.environ['TEST_FILE']))
+            lines.append('#line %d "test.c"' % (
+                    template[:template.find('{tests}')].count('\n')
+                    + len(lines) + 2))
+
+        file.write(template.format(tests='\n'.join(lines)))
+
+    # Remove build artifacts to force rebuild
+    try:
+        os.remove('test.o')
+        os.remove('lfs')
+    except OSError:
+        pass
+
+def compile():
+    subprocess.check_call([
+            os.environ.get('MAKE', 'make'),
+            '--no-print-directory', '-s'])
+
+def execute():
+    if 'EXEC' in os.environ:
+        subprocess.check_call([os.environ['EXEC'], "./lfs"])
+    else:
+        subprocess.check_call(["./lfs"])
+
+def main(test=None):
+    try:
+        if test and not test.startswith('-'):
+            with open(test) as file:
+                generate(file)
+        else:
+            generate(sys.stdin)
+
+        compile()
+
+        if test == '-s':
+            sys.exit(1)
+
+        execute()
+
+    except subprocess.CalledProcessError:
+        # Python stack trace is counterproductive, just exit
+        sys.exit(2)
+    except KeyboardInterrupt:
+        # Python stack trace is counterproductive, just exit
+        sys.exit(3)
+
+if __name__ == "__main__":
+    main(*sys.argv[1:])

tests/stats.py

@@ -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:])

tests/test.py

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

tests/test_alloc.sh

@@ -1,16 +1,18 @@
 #!/bin/bash
-set -eu
+set -euE
+export TEST_FILE=$0
+trap 'export TEST_LINE=$LINENO' DEBUG
 
 echo "=== Allocator tests ==="
 rm -rf blocks
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_format(&lfs, &cfg) => 0;
 TEST
 
 SIZE=15000
 
 lfs_mkdir() {
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_mkdir(&lfs, "$1") => 0;
     lfs_unmount(&lfs) => 0;
@@ -18,7 +20,7 @@ TEST
 }
 
 lfs_remove() {
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_remove(&lfs, "$1/eggs") => 0;
     lfs_remove(&lfs, "$1/bacon") => 0;
@@ -29,22 +31,23 @@ TEST
 }
 
 lfs_alloc_singleproc() {
-tests/test.py << TEST
+scripts/test.py << TEST
     const char *names[] = {"bacon", "eggs", "pancakes"};
+    lfs_file_t files[sizeof(names)/sizeof(names[0])];
     lfs_mount(&lfs, &cfg) => 0;
     for (unsigned n = 0; n < sizeof(names)/sizeof(names[0]); n++) {
-        sprintf((char*)buffer, "$1/%s", names[n]);
+        sprintf(path, "$1/%s", names[n]);
-        lfs_file_open(&lfs, &file[n], (char*)buffer,
+        lfs_file_open(&lfs, &files[n], path,
                 LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0;
     }
     for (unsigned n = 0; n < sizeof(names)/sizeof(names[0]); n++) {
-        size = strlen(names[n]);
+        lfs_size_t size = strlen(names[n]);
         for (int i = 0; i < $SIZE; i++) {
-            lfs_file_write(&lfs, &file[n], names[n], size) => size;
+            lfs_file_write(&lfs, &files[n], names[n], size) => size;
         }
     }
     for (unsigned n = 0; n < sizeof(names)/sizeof(names[0]); n++) {
-        lfs_file_close(&lfs, &file[n]) => 0;
+        lfs_file_close(&lfs, &files[n]) => 0;
     }
     lfs_unmount(&lfs) => 0;
 TEST
@@ -53,16 +56,16 @@ TEST
 lfs_alloc_multiproc() {
 for name in bacon eggs pancakes
 do
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "$1/$name",
+    lfs_file_open(&lfs, &file, "$1/$name",
             LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0;
-    size = strlen("$name");
+    lfs_size_t size = strlen("$name");
     memcpy(buffer, "$name", size);
     for (int i = 0; i < $SIZE; i++) {
-        lfs_file_write(&lfs, &file[0], buffer, size) => size;
+        lfs_file_write(&lfs, &file, buffer, size) => size;
     }
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 done
@@ -71,15 +74,15 @@ done
 lfs_verify() {
 for name in bacon eggs pancakes
 do
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "$1/$name", LFS_O_RDONLY) => 0;
+    lfs_file_open(&lfs, &file, "$1/$name", LFS_O_RDONLY) => 0;
-    size = strlen("$name");
+    lfs_size_t size = strlen("$name");
     for (int i = 0; i < $SIZE; i++) {
-        lfs_file_read(&lfs, &file[0], buffer, size) => size;
+        lfs_file_read(&lfs, &file, buffer, size) => size;
         memcmp(buffer, "$name", size) => 0;
     }
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 done
@@ -115,19 +118,19 @@ lfs_remove multiprocreuse
 lfs_remove singleprocreuse
 
 echo "--- Exhaustion test ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
+    lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
-    size = strlen("exhaustion");
+    lfs_size_t size = strlen("exhaustion");
     memcpy(buffer, "exhaustion", size);
-    lfs_file_write(&lfs, &file[0], buffer, size) => size;
+    lfs_file_write(&lfs, &file, buffer, size) => size;
-    lfs_file_sync(&lfs, &file[0]) => 0;
+    lfs_file_sync(&lfs, &file) => 0;
 
     size = strlen("blahblahblahblah");
     memcpy(buffer, "blahblahblahblah", size);
     lfs_ssize_t res;
     while (true) {
-        res = lfs_file_write(&lfs, &file[0], buffer, size);
+        res = lfs_file_write(&lfs, &file, buffer, size);
         if (res < 0) {
             break;
         }
@@ -136,45 +139,45 @@ tests/test.py << TEST
     }
     res => LFS_ERR_NOSPC;
 
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_RDONLY);
+    lfs_file_open(&lfs, &file, "exhaustion", LFS_O_RDONLY);
-    size = strlen("exhaustion");
+    lfs_size_t size = strlen("exhaustion");
-    lfs_file_size(&lfs, &file[0]) => size;
+    lfs_file_size(&lfs, &file) => size;
-    lfs_file_read(&lfs, &file[0], buffer, size) => size;
+    lfs_file_read(&lfs, &file, buffer, size) => size;
     memcmp(buffer, "exhaustion", size) => 0;
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Exhaustion wraparound test ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_remove(&lfs, "exhaustion") => 0;
 
-    lfs_file_open(&lfs, &file[0], "padding", LFS_O_WRONLY | LFS_O_CREAT);
+    lfs_file_open(&lfs, &file, "padding", LFS_O_WRONLY | LFS_O_CREAT);
-    size = strlen("buffering");
+    lfs_size_t size = strlen("buffering");
     memcpy(buffer, "buffering", size);
     for (int i = 0; i < $SIZE; i++) {
-        lfs_file_write(&lfs, &file[0], buffer, size) => size;
+        lfs_file_write(&lfs, &file, buffer, size) => size;
     }
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_remove(&lfs, "padding") => 0;
 
-    lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
+    lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
     size = strlen("exhaustion");
     memcpy(buffer, "exhaustion", size);
-    lfs_file_write(&lfs, &file[0], buffer, size) => size;
+    lfs_file_write(&lfs, &file, buffer, size) => size;
-    lfs_file_sync(&lfs, &file[0]) => 0;
+    lfs_file_sync(&lfs, &file) => 0;
 
     size = strlen("blahblahblahblah");
     memcpy(buffer, "blahblahblahblah", size);
     lfs_ssize_t res;
     while (true) {
-        res = lfs_file_write(&lfs, &file[0], buffer, size);
+        res = lfs_file_write(&lfs, &file, buffer, size);
         if (res < 0) {
             break;
         }
@@ -183,34 +186,34 @@ tests/test.py << TEST
     }
     res => LFS_ERR_NOSPC;
 
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_RDONLY);
+    lfs_file_open(&lfs, &file, "exhaustion", LFS_O_RDONLY);
-    size = strlen("exhaustion");
+    lfs_size_t size = strlen("exhaustion");
-    lfs_file_size(&lfs, &file[0]) => size;
+    lfs_file_size(&lfs, &file) => size;
-    lfs_file_read(&lfs, &file[0], buffer, size) => size;
+    lfs_file_read(&lfs, &file, buffer, size) => size;
     memcmp(buffer, "exhaustion", size) => 0;
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_remove(&lfs, "exhaustion") => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Dir exhaustion test ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
 
     // find out max file size
     lfs_mkdir(&lfs, "exhaustiondir") => 0;
-    size = strlen("blahblahblahblah");
+    lfs_size_t size = strlen("blahblahblahblah");
     memcpy(buffer, "blahblahblahblah", size);
-    lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
+    lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
     int count = 0;
     int err;
     while (true) {
-        err = lfs_file_write(&lfs, &file[0], buffer, size);
+        err = lfs_file_write(&lfs, &file, buffer, size);
         if (err < 0) {
             break;
         }
@@ -218,28 +221,28 @@ tests/test.py << TEST
         count += 1;
     }
     err => LFS_ERR_NOSPC;
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
 
     lfs_remove(&lfs, "exhaustion") => 0;
     lfs_remove(&lfs, "exhaustiondir") => 0;
 
     // see if dir fits with max file size
-    lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
+    lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
     for (int i = 0; i < count; i++) {
-        lfs_file_write(&lfs, &file[0], buffer, size) => size;
+        lfs_file_write(&lfs, &file, buffer, size) => size;
     }
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
 
     lfs_mkdir(&lfs, "exhaustiondir") => 0;
     lfs_remove(&lfs, "exhaustiondir") => 0;
     lfs_remove(&lfs, "exhaustion") => 0;
 
     // see if dir fits with > max file size
-    lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
+    lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
     for (int i = 0; i < count+1; i++) {
-        lfs_file_write(&lfs, &file[0], buffer, size) => size;
+        lfs_file_write(&lfs, &file, buffer, size) => size;
     }
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
 
     lfs_mkdir(&lfs, "exhaustiondir") => LFS_ERR_NOSPC;
 
@@ -248,22 +251,22 @@ tests/test.py << TEST
 TEST
 
 echo "--- Chained dir exhaustion test ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
 
     // find out max file size
     lfs_mkdir(&lfs, "exhaustiondir") => 0;
     for (int i = 0; i < 10; i++) {
-        sprintf((char*)buffer, "dirwithanexhaustivelylongnameforpadding%d", i);
+        sprintf(path, "dirwithanexhaustivelylongnameforpadding%d", i);
-        lfs_mkdir(&lfs, (char*)buffer) => 0;
+        lfs_mkdir(&lfs, path) => 0;
     }
-    size = strlen("blahblahblahblah");
+    lfs_size_t size = strlen("blahblahblahblah");
     memcpy(buffer, "blahblahblahblah", size);
-    lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
+    lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
     int count = 0;
     int err;
     while (true) {
-        err = lfs_file_write(&lfs, &file[0], buffer, size);
+        err = lfs_file_write(&lfs, &file, buffer, size);
         if (err < 0) {
             break;
         }
@@ -271,25 +274,25 @@ tests/test.py << TEST
         count += 1;
     }
     err => LFS_ERR_NOSPC;
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
 
     lfs_remove(&lfs, "exhaustion") => 0;
     lfs_remove(&lfs, "exhaustiondir") => 0;
     for (int i = 0; i < 10; i++) {
-        sprintf((char*)buffer, "dirwithanexhaustivelylongnameforpadding%d", i);
+        sprintf(path, "dirwithanexhaustivelylongnameforpadding%d", i);
-        lfs_remove(&lfs, (char*)buffer) => 0;
+        lfs_remove(&lfs, path) => 0;
     }
 
     // see that chained dir fails
-    lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
+    lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
     for (int i = 0; i < count+1; i++) {
-        lfs_file_write(&lfs, &file[0], buffer, size) => size;
+        lfs_file_write(&lfs, &file, buffer, size) => size;
     }
-    lfs_file_sync(&lfs, &file[0]) => 0;
+    lfs_file_sync(&lfs, &file) => 0;
 
     for (int i = 0; i < 10; i++) {
-        sprintf((char*)buffer, "dirwithanexhaustivelylongnameforpadding%d", i);
+        sprintf(path, "dirwithanexhaustivelylongnameforpadding%d", i);
-        lfs_mkdir(&lfs, (char*)buffer) => 0;
+        lfs_mkdir(&lfs, path) => 0;
     }
 
     lfs_mkdir(&lfs, "exhaustiondir") => LFS_ERR_NOSPC;
@@ -301,45 +304,44 @@ tests/test.py << TEST
             break;
         }
 
-        lfs_ssize_t filesize = lfs_file_size(&lfs, &file[0]);
+        lfs_ssize_t filesize = lfs_file_size(&lfs, &file);
         filesize > 0 => true;
 
-        lfs_file_truncate(&lfs, &file[0], filesize - size) => 0;
+        lfs_file_truncate(&lfs, &file, filesize - size) => 0;
-        lfs_file_sync(&lfs, &file[0]) => 0;
+        lfs_file_sync(&lfs, &file) => 0;
     }
     err => 0;
 
     lfs_mkdir(&lfs, "exhaustiondir2") => LFS_ERR_NOSPC;
 
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Split dir test ---"
-rm -rf blocks
+scripts/test.py << TEST
-tests/test.py << TEST
     lfs_format(&lfs, &cfg) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
 
     // create one block hole for half a directory
-    lfs_file_open(&lfs, &file[0], "bump", LFS_O_WRONLY | LFS_O_CREAT) => 0;
+    lfs_file_open(&lfs, &file, "bump", LFS_O_WRONLY | LFS_O_CREAT) => 0;
     for (lfs_size_t i = 0; i < cfg.block_size; i += 2) {
         memcpy(&buffer[i], "hi", 2);
     }
-    lfs_file_write(&lfs, &file[0], buffer, cfg.block_size) => cfg.block_size;
+    lfs_file_write(&lfs, &file, buffer, cfg.block_size) => cfg.block_size;
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
 
-    lfs_file_open(&lfs, &file[0], "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
+    lfs_file_open(&lfs, &file, "exhaustion", LFS_O_WRONLY | LFS_O_CREAT);
-    size = strlen("blahblahblahblah");
+    lfs_size_t size = strlen("blahblahblahblah");
     memcpy(buffer, "blahblahblahblah", size);
     for (lfs_size_t i = 0;
             i < (cfg.block_count-4)*(cfg.block_size-8);
             i += size) {
-        lfs_file_write(&lfs, &file[0], buffer, size) => size;
+        lfs_file_write(&lfs, &file, buffer, size) => size;
     }
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
 
     // remount to force reset of lookahead
     lfs_unmount(&lfs) => 0;
@@ -349,137 +351,134 @@ tests/test.py << TEST
     lfs_remove(&lfs, "bump") => 0;
 
     lfs_mkdir(&lfs, "splitdir") => 0;
-    lfs_file_open(&lfs, &file[0], "splitdir/bump",
+    lfs_file_open(&lfs, &file, "splitdir/bump",
             LFS_O_WRONLY | LFS_O_CREAT) => 0;
     for (lfs_size_t i = 0; i < cfg.block_size; i += 2) {
         memcpy(&buffer[i], "hi", 2);
     }
-    lfs_file_write(&lfs, &file[0], buffer, 2*cfg.block_size) => LFS_ERR_NOSPC;
+    lfs_file_write(&lfs, &file, buffer, 2*cfg.block_size) => LFS_ERR_NOSPC;
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
 
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Outdated lookahead test ---"
-rm -rf blocks
+scripts/test.py << TEST
-tests/test.py << TEST
     lfs_format(&lfs, &cfg) => 0;
 
     lfs_mount(&lfs, &cfg) => 0;
 
     // fill completely with two files
-    lfs_file_open(&lfs, &file[0], "exhaustion1",
+    lfs_file_open(&lfs, &file, "exhaustion1",
             LFS_O_WRONLY | LFS_O_CREAT) => 0;
-    size = strlen("blahblahblahblah");
+    lfs_size_t size = strlen("blahblahblahblah");
     memcpy(buffer, "blahblahblahblah", size);
     for (lfs_size_t i = 0;
             i < ((cfg.block_count-2)/2)*(cfg.block_size-8);
             i += size) {
-        lfs_file_write(&lfs, &file[0], buffer, size) => size;
+        lfs_file_write(&lfs, &file, buffer, size) => size;
     }
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
 
-    lfs_file_open(&lfs, &file[0], "exhaustion2",
+    lfs_file_open(&lfs, &file, "exhaustion2",
             LFS_O_WRONLY | LFS_O_CREAT) => 0;
     size = strlen("blahblahblahblah");
     memcpy(buffer, "blahblahblahblah", size);
     for (lfs_size_t i = 0;
             i < ((cfg.block_count-2+1)/2)*(cfg.block_size-8);
             i += size) {
-        lfs_file_write(&lfs, &file[0], buffer, size) => size;
+        lfs_file_write(&lfs, &file, buffer, size) => size;
     }
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
 
     // remount to force reset of lookahead
     lfs_unmount(&lfs) => 0;
     lfs_mount(&lfs, &cfg) => 0;
 
     // rewrite one file
-    lfs_file_open(&lfs, &file[0], "exhaustion1",
+    lfs_file_open(&lfs, &file, "exhaustion1",
             LFS_O_WRONLY | LFS_O_TRUNC) => 0;
-    lfs_file_sync(&lfs, &file[0]) => 0;
+    lfs_file_sync(&lfs, &file) => 0;
     size = strlen("blahblahblahblah");
     memcpy(buffer, "blahblahblahblah", size);
     for (lfs_size_t i = 0;
             i < ((cfg.block_count-2)/2)*(cfg.block_size-8);
             i += size) {
-        lfs_file_write(&lfs, &file[0], buffer, size) => size;
+        lfs_file_write(&lfs, &file, buffer, size) => size;
     }
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
 
     // rewrite second file, this requires lookahead does not
     // use old population
-    lfs_file_open(&lfs, &file[0], "exhaustion2",
+    lfs_file_open(&lfs, &file, "exhaustion2",
             LFS_O_WRONLY | LFS_O_TRUNC) => 0;
-    lfs_file_sync(&lfs, &file[0]) => 0;
+    lfs_file_sync(&lfs, &file) => 0;
     size = strlen("blahblahblahblah");
     memcpy(buffer, "blahblahblahblah", size);
     for (lfs_size_t i = 0;
             i < ((cfg.block_count-2+1)/2)*(cfg.block_size-8);
             i += size) {
-        lfs_file_write(&lfs, &file[0], buffer, size) => size;
+        lfs_file_write(&lfs, &file, buffer, size) => size;
     }
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
 TEST
 
 echo "--- Outdated lookahead and split dir test ---"
-rm -rf blocks
+scripts/test.py << TEST
-tests/test.py << TEST
     lfs_format(&lfs, &cfg) => 0;
 
     lfs_mount(&lfs, &cfg) => 0;
 
     // fill completely with two files
-    lfs_file_open(&lfs, &file[0], "exhaustion1",
+    lfs_file_open(&lfs, &file, "exhaustion1",
             LFS_O_WRONLY | LFS_O_CREAT) => 0;
-    size = strlen("blahblahblahblah");
+    lfs_size_t size = strlen("blahblahblahblah");
     memcpy(buffer, "blahblahblahblah", size);
     for (lfs_size_t i = 0;
             i < ((cfg.block_count-2)/2)*(cfg.block_size-8);
             i += size) {
-        lfs_file_write(&lfs, &file[0], buffer, size) => size;
+        lfs_file_write(&lfs, &file, buffer, size) => size;
     }
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
 
-    lfs_file_open(&lfs, &file[0], "exhaustion2",
+    lfs_file_open(&lfs, &file, "exhaustion2",
             LFS_O_WRONLY | LFS_O_CREAT) => 0;
     size = strlen("blahblahblahblah");
     memcpy(buffer, "blahblahblahblah", size);
     for (lfs_size_t i = 0;
             i < ((cfg.block_count-2+1)/2)*(cfg.block_size-8);
             i += size) {
-        lfs_file_write(&lfs, &file[0], buffer, size) => size;
+        lfs_file_write(&lfs, &file, buffer, size) => size;
     }
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
 
     // remount to force reset of lookahead
     lfs_unmount(&lfs) => 0;
     lfs_mount(&lfs, &cfg) => 0;
 
     // rewrite one file with a hole of one block
-    lfs_file_open(&lfs, &file[0], "exhaustion1",
+    lfs_file_open(&lfs, &file, "exhaustion1",
             LFS_O_WRONLY | LFS_O_TRUNC) => 0;
-    lfs_file_sync(&lfs, &file[0]) => 0;
+    lfs_file_sync(&lfs, &file) => 0;
     size = strlen("blahblahblahblah");
     memcpy(buffer, "blahblahblahblah", size);
     for (lfs_size_t i = 0;
             i < ((cfg.block_count-2)/2 - 1)*(cfg.block_size-8);
             i += size) {
-        lfs_file_write(&lfs, &file[0], buffer, size) => size;
+        lfs_file_write(&lfs, &file, buffer, size) => size;
     }
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
 
     // try to allocate a directory, should fail!
     lfs_mkdir(&lfs, "split") => LFS_ERR_NOSPC;
 
     // file should not fail
-    lfs_file_open(&lfs, &file[0], "notasplit",
+    lfs_file_open(&lfs, &file, "notasplit",
             LFS_O_WRONLY | LFS_O_CREAT) => 0;
-    lfs_file_write(&lfs, &file[0], "hi", 2) => 2;
+    lfs_file_write(&lfs, &file, "hi", 2) => 2;
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
 
     lfs_unmount(&lfs) => 0;
 TEST
 
-echo "--- Results ---"
+scripts/results.py
-tests/stats.py

tests/test_attrs.sh

@@ -1,24 +1,27 @@
 #!/bin/bash
 set -eu
+export TEST_FILE=$0
+trap 'export TEST_LINE=$LINENO' DEBUG
 
 echo "=== Attr tests ==="
 rm -rf blocks
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_format(&lfs, &cfg) => 0;
 
     lfs_mount(&lfs, &cfg) => 0;
     lfs_mkdir(&lfs, "hello") => 0;
-    lfs_file_open(&lfs, &file[0], "hello/hello",
+    lfs_file_open(&lfs, &file, "hello/hello",
             LFS_O_WRONLY | LFS_O_CREAT) => 0;
-    lfs_file_write(&lfs, &file[0], "hello", strlen("hello"))
+    lfs_file_write(&lfs, &file, "hello", strlen("hello"))
             => strlen("hello");
-    lfs_file_close(&lfs, &file[0]);
+    lfs_file_close(&lfs, &file);
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Set/get attribute ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
+    memset(buffer, 0, sizeof(buffer));
     lfs_setattr(&lfs, "hello", 'A', "aaaa",   4) => 0;
     lfs_setattr(&lfs, "hello", 'B', "bbbbbb", 6) => 0;
     lfs_setattr(&lfs, "hello", 'C', "ccccc",  5) => 0;
@@ -69,8 +72,9 @@ tests/test.py << TEST
 
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
+    memset(buffer, 0, sizeof(buffer));
     lfs_getattr(&lfs, "hello", 'A', buffer,    4) => 4;
     lfs_getattr(&lfs, "hello", 'B', buffer+4,  9) => 9;
     lfs_getattr(&lfs, "hello", 'C', buffer+13, 5) => 5;
@@ -78,16 +82,17 @@ tests/test.py << TEST
     memcmp(buffer+4,  "fffffffff", 9) => 0;
     memcmp(buffer+13, "ccccc",     5) => 0;
 
-    lfs_file_open(&lfs, &file[0], "hello/hello", LFS_O_RDONLY) => 0;
+    lfs_file_open(&lfs, &file, "hello/hello", LFS_O_RDONLY) => 0;
-    lfs_file_read(&lfs, &file[0], buffer, sizeof(buffer)) => strlen("hello");
+    lfs_file_read(&lfs, &file, buffer, sizeof(buffer)) => strlen("hello");
     memcmp(buffer, "hello", strlen("hello")) => 0;
-    lfs_file_close(&lfs, &file[0]);
+    lfs_file_close(&lfs, &file);
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Set/get root attribute ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
+    memset(buffer, 0, sizeof(buffer));
     lfs_setattr(&lfs, "/", 'A', "aaaa",   4) => 0;
     lfs_setattr(&lfs, "/", 'B', "bbbbbb", 6) => 0;
     lfs_setattr(&lfs, "/", 'C', "ccccc",  5) => 0;
@@ -137,8 +142,9 @@ tests/test.py << TEST
     lfs_getattr(&lfs, "/", 'C', buffer+10, 5) => 5;
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
+    memset(buffer, 0, sizeof(buffer));
     lfs_getattr(&lfs, "/", 'A', buffer,    4) => 4;
     lfs_getattr(&lfs, "/", 'B', buffer+4,  9) => 9;
     lfs_getattr(&lfs, "/", 'C', buffer+13, 5) => 5;
@@ -146,16 +152,17 @@ tests/test.py << TEST
     memcmp(buffer+4,  "fffffffff", 9) => 0;
     memcmp(buffer+13, "ccccc",     5) => 0;
 
-    lfs_file_open(&lfs, &file[0], "hello/hello", LFS_O_RDONLY) => 0;
+    lfs_file_open(&lfs, &file, "hello/hello", LFS_O_RDONLY) => 0;
-    lfs_file_read(&lfs, &file[0], buffer, sizeof(buffer)) => strlen("hello");
+    lfs_file_read(&lfs, &file, buffer, sizeof(buffer)) => strlen("hello");
     memcmp(buffer, "hello", strlen("hello")) => 0;
-    lfs_file_close(&lfs, &file[0]);
+    lfs_file_close(&lfs, &file);
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Set/get file attribute ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
+    memset(buffer, 0, sizeof(buffer));
     struct lfs_attr attrs1[] = {
         {'A', buffer,    4},
         {'B', buffer+4,  6},
@@ -163,55 +170,55 @@ tests/test.py << TEST
     };
     struct lfs_file_config cfg1 = {.attrs=attrs1, .attr_count=3};
 
-    lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_WRONLY, &cfg1) => 0;
+    lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_WRONLY, &cfg1) => 0;
     memcpy(buffer,    "aaaa",   4);
     memcpy(buffer+4,  "bbbbbb", 6);
     memcpy(buffer+10, "ccccc",  5);
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     memset(buffer, 0, 15);
-    lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
+    lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     memcmp(buffer,    "aaaa",   4) => 0;
     memcmp(buffer+4,  "bbbbbb", 6) => 0;
     memcmp(buffer+10, "ccccc",  5) => 0;
 
     attrs1[1].size = 0;
-    lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_WRONLY, &cfg1) => 0;
+    lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_WRONLY, &cfg1) => 0;
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     memset(buffer, 0, 15);
     attrs1[1].size = 6;
-    lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
+    lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     memcmp(buffer,    "aaaa",         4) => 0;
     memcmp(buffer+4,  "\0\0\0\0\0\0", 6) => 0;
     memcmp(buffer+10, "ccccc",        5) => 0;
 
     attrs1[1].size = 6;
-    lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_WRONLY, &cfg1) => 0;
+    lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_WRONLY, &cfg1) => 0;
     memcpy(buffer+4,  "dddddd", 6);
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     memset(buffer, 0, 15);
     attrs1[1].size = 6;
-    lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
+    lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     memcmp(buffer,    "aaaa",   4) => 0;
     memcmp(buffer+4,  "dddddd", 6) => 0;
     memcmp(buffer+10, "ccccc",  5) => 0;
 
     attrs1[1].size = 3;
-    lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_WRONLY, &cfg1) => 0;
+    lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_WRONLY, &cfg1) => 0;
     memcpy(buffer+4,  "eee", 3);
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     memset(buffer, 0, 15);
     attrs1[1].size = 6;
-    lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
+    lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     memcmp(buffer,    "aaaa",      4) => 0;
     memcmp(buffer+4,  "eee\0\0\0", 6) => 0;
     memcmp(buffer+10, "ccccc",     5) => 0;
 
     attrs1[0].size = LFS_ATTR_MAX+1;
-    lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_WRONLY, &cfg1)
+    lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_WRONLY, &cfg1)
         => LFS_ERR_NOSPC;
 
     struct lfs_attr attrs2[] = {
@@ -220,17 +227,18 @@ tests/test.py << TEST
         {'C', buffer+13, 5},
     };
     struct lfs_file_config cfg2 = {.attrs=attrs2, .attr_count=3};
-    lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_RDWR, &cfg2) => 0;
+    lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDWR, &cfg2) => 0;
     memcpy(buffer+4,  "fffffffff", 9);
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     attrs1[0].size = 4;
-    lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
+    lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
 
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
+    memset(buffer, 0, sizeof(buffer));
     struct lfs_attr attrs2[] = {
         {'A', buffer,    4},
         {'B', buffer+4,  9},
@@ -238,22 +246,23 @@ tests/test.py << TEST
     };
     struct lfs_file_config cfg2 = {.attrs=attrs2, .attr_count=3};
 
-    lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_RDONLY, &cfg2) => 0;
+    lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg2) => 0;
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     memcmp(buffer,    "aaaa",      4) => 0;
     memcmp(buffer+4,  "fffffffff", 9) => 0;
     memcmp(buffer+13, "ccccc",     5) => 0;
 
-    lfs_file_open(&lfs, &file[0], "hello/hello", LFS_O_RDONLY) => 0;
+    lfs_file_open(&lfs, &file, "hello/hello", LFS_O_RDONLY) => 0;
-    lfs_file_read(&lfs, &file[0], buffer, sizeof(buffer)) => strlen("hello");
+    lfs_file_read(&lfs, &file, buffer, sizeof(buffer)) => strlen("hello");
     memcmp(buffer, "hello", strlen("hello")) => 0;
-    lfs_file_close(&lfs, &file[0]);
+    lfs_file_close(&lfs, &file);
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Deferred file attributes ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
+    memset(buffer, 0, sizeof(buffer));
     struct lfs_attr attrs1[] = {
         {'B', "gggg", 4},
         {'C', "",     0},
@@ -261,7 +270,7 @@ tests/test.py << TEST
     };
     struct lfs_file_config cfg1 = {.attrs=attrs1, .attr_count=3};
 
-    lfs_file_opencfg(&lfs, &file[0], "hello/hello", LFS_O_WRONLY, &cfg1) => 0;
+    lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_WRONLY, &cfg1) => 0;
 
     lfs_getattr(&lfs, "hello/hello", 'B', buffer,    9) => 9;
     lfs_getattr(&lfs, "hello/hello", 'C', buffer+9,  9) => 5;
@@ -270,7 +279,7 @@ tests/test.py << TEST
     memcmp(buffer+9,  "ccccc\0\0\0\0",      9) => 0;
     memcmp(buffer+18, "\0\0\0\0\0\0\0\0\0", 9) => 0;
 
-    lfs_file_sync(&lfs, &file[0]) => 0;
+    lfs_file_sync(&lfs, &file) => 0;
     lfs_getattr(&lfs, "hello/hello", 'B', buffer,    9) => 4;
     lfs_getattr(&lfs, "hello/hello", 'C', buffer+9,  9) => 0;
     lfs_getattr(&lfs, "hello/hello", 'D', buffer+18, 9) => 4;
@@ -278,9 +287,8 @@ tests/test.py << TEST
     memcmp(buffer+9,  "\0\0\0\0\0\0\0\0\0", 9) => 0;
     memcmp(buffer+18, "hhhh\0\0\0\0\0",     9) => 0;
 
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
-echo "--- Results ---"
+scripts/results.py
-tests/stats.py

tests/test_corrupt.sh

@@ -1,5 +1,7 @@
 #!/bin/bash
 set -eu
+export TEST_FILE=$0
+trap 'export TEST_LINE=$LINENO' DEBUG
 
 echo "=== Corrupt tests ==="
 
@@ -7,7 +9,7 @@ NAMEMULT=64
 FILEMULT=1
 
 lfs_mktree() {
-tests/test.py ${1:-} << TEST
+scripts/test.py ${1:-} << TEST
     lfs_format(&lfs, &cfg) => 0;
 
     lfs_mount(&lfs, &cfg) => 0;
@@ -23,22 +25,22 @@ tests/test.py ${1:-} << TEST
             buffer[j+$NAMEMULT+1] = '0'+i;
         }
         buffer[2*$NAMEMULT+1] = '\0';
-        lfs_file_open(&lfs, &file[0], (char*)buffer,
+        lfs_file_open(&lfs, &file, (char*)buffer,
                 LFS_O_WRONLY | LFS_O_CREAT) => 0;
         
-        size = $NAMEMULT;
+        lfs_size_t size = $NAMEMULT;
         for (int j = 0; j < i*$FILEMULT; j++) {
-            lfs_file_write(&lfs, &file[0], buffer, size) => size;
+            lfs_file_write(&lfs, &file, buffer, size) => size;
         }
 
-        lfs_file_close(&lfs, &file[0]) => 0;
+        lfs_file_close(&lfs, &file) => 0;
     }
     lfs_unmount(&lfs) => 0;
 TEST
 }
 
 lfs_chktree() {
-tests/test.py ${1:-} << TEST
+scripts/test.py ${1:-} << TEST
     lfs_mount(&lfs, &cfg) => 0;
     for (int i = 1; i < 10; i++) {
         for (int j = 0; j < $NAMEMULT; j++) {
@@ -53,15 +55,16 @@ tests/test.py ${1:-} << TEST
             buffer[j+$NAMEMULT+1] = '0'+i;
         }
         buffer[2*$NAMEMULT+1] = '\0';
-        lfs_file_open(&lfs, &file[0], (char*)buffer, LFS_O_RDONLY) => 0;
+        lfs_file_open(&lfs, &file, (char*)buffer, LFS_O_RDONLY) => 0;
         
-        size = $NAMEMULT;
+        lfs_size_t size = $NAMEMULT;
         for (int j = 0; j < i*$FILEMULT; j++) {
-            lfs_file_read(&lfs, &file[0], rbuffer, size) => size;
+            uint8_t rbuffer[1024];
+            lfs_file_read(&lfs, &file, rbuffer, size) => size;
             memcmp(buffer, rbuffer, size) => 0;
         }
 
-        lfs_file_close(&lfs, &file[0]) => 0;
+        lfs_file_close(&lfs, &file) => 0;
     }
     lfs_unmount(&lfs) => 0;
 TEST
@@ -114,5 +117,4 @@ done
 lfs_mktree
 lfs_chktree
 
-echo "--- Results ---"
+scripts/results.py
-tests/stats.py

tests/test_dirs.sh

@@ -1,188 +1,191 @@
 #!/bin/bash
 set -eu
+export TEST_FILE=$0
+trap 'export TEST_LINE=$LINENO' DEBUG
+
+echo "=== Directory tests ==="
 
 LARGESIZE=128
 
-echo "=== Directory tests ==="
 rm -rf blocks
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_format(&lfs, &cfg) => 0;
 TEST
 
 echo "--- Root directory ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir[0], "/") => 0;
+    lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Directory creation ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_mkdir(&lfs, "potato") => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- File creation ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "burito", LFS_O_CREAT | LFS_O_WRONLY) => 0;
+    lfs_file_open(&lfs, &file, "burito", LFS_O_CREAT | LFS_O_WRONLY) => 0;
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Directory iteration ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir[0], "/") => 0;
+    lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "burito") => 0;
     info.type => LFS_TYPE_REG;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "potato") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Directory failures ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_mkdir(&lfs, "potato") => LFS_ERR_EXIST;
-    lfs_dir_open(&lfs, &dir[0], "tomato") => LFS_ERR_NOENT;
+    lfs_dir_open(&lfs, &dir, "tomato") => LFS_ERR_NOENT;
-    lfs_dir_open(&lfs, &dir[0], "burito") => LFS_ERR_NOTDIR;
+    lfs_dir_open(&lfs, &dir, "burito") => LFS_ERR_NOTDIR;
-    lfs_file_open(&lfs, &file[0], "tomato", LFS_O_RDONLY) => LFS_ERR_NOENT;
+    lfs_file_open(&lfs, &file, "tomato", LFS_O_RDONLY) => LFS_ERR_NOENT;
-    lfs_file_open(&lfs, &file[0], "potato", LFS_O_RDONLY) => LFS_ERR_ISDIR;
+    lfs_file_open(&lfs, &file, "potato", LFS_O_RDONLY) => LFS_ERR_ISDIR;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Nested directories ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_mkdir(&lfs, "potato/baked") => 0;
     lfs_mkdir(&lfs, "potato/sweet") => 0;
     lfs_mkdir(&lfs, "potato/fried") => 0;
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir[0], "potato") => 0;
+    lfs_dir_open(&lfs, &dir, "potato") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "baked") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "fried") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "sweet") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Multi-block directory ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_mkdir(&lfs, "cactus") => 0;
     for (int i = 0; i < $LARGESIZE; i++) {
-        sprintf((char*)buffer, "cactus/test%03d", i);
+        sprintf(path, "cactus/test%03d", i);
-        lfs_mkdir(&lfs, (char*)buffer) => 0;
+        lfs_mkdir(&lfs, path) => 0;
     }
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir[0], "cactus") => 0;
+    lfs_dir_open(&lfs, &dir, "cactus") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
     info.type => LFS_TYPE_DIR;
     for (int i = 0; i < $LARGESIZE; i++) {
-        sprintf((char*)buffer, "test%03d", i);
+        sprintf(path, "test%03d", i);
-        lfs_dir_read(&lfs, &dir[0], &info) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
-        strcmp(info.name, (char*)buffer) => 0;
+        strcmp(info.name, path) => 0;
         info.type => LFS_TYPE_DIR;
     }
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Directory remove ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_remove(&lfs, "potato") => LFS_ERR_NOTEMPTY;
     lfs_remove(&lfs, "potato/sweet") => 0;
     lfs_remove(&lfs, "potato/baked") => 0;
     lfs_remove(&lfs, "potato/fried") => 0;
 
-    lfs_dir_open(&lfs, &dir[0], "potato") => 0;
+    lfs_dir_open(&lfs, &dir, "potato") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_remove(&lfs, "potato") => 0;
 
-    lfs_dir_open(&lfs, &dir[0], "/") => 0;
+    lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "burito") => 0;
     info.type => LFS_TYPE_REG;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "cactus") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir[0], "/") => 0;
+    lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "burito") => 0;
     info.type => LFS_TYPE_REG;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "cactus") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Directory rename ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_mkdir(&lfs, "coldpotato") => 0;
     lfs_mkdir(&lfs, "coldpotato/baked") => 0;
@@ -190,34 +193,34 @@ tests/test.py << TEST
     lfs_mkdir(&lfs, "coldpotato/fried") => 0;
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_rename(&lfs, "coldpotato", "hotpotato") => 0;
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir[0], "hotpotato") => 0;
+    lfs_dir_open(&lfs, &dir, "hotpotato") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "baked") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "fried") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "sweet") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_mkdir(&lfs, "warmpotato") => 0;
     lfs_mkdir(&lfs, "warmpotato/mushy") => 0;
@@ -228,29 +231,29 @@ tests/test.py << TEST
 
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir[0], "warmpotato") => 0;
+    lfs_dir_open(&lfs, &dir, "warmpotato") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "baked") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "fried") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "sweet") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_mkdir(&lfs, "coldpotato") => 0;
     lfs_rename(&lfs, "warmpotato/baked", "coldpotato/baked") => 0;
@@ -260,225 +263,227 @@ tests/test.py << TEST
     lfs_remove(&lfs, "warmpotato") => 0;
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir[0], "coldpotato") => 0;
+    lfs_dir_open(&lfs, &dir, "coldpotato") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "baked") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "fried") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "sweet") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Recursive remove ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_remove(&lfs, "coldpotato") => LFS_ERR_NOTEMPTY;
 
-    lfs_dir_open(&lfs, &dir[0], "coldpotato") => 0;
+    lfs_dir_open(&lfs, &dir, "coldpotato") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
 
     while (true) {
-        int err = lfs_dir_read(&lfs, &dir[0], &info);
+        int err = lfs_dir_read(&lfs, &dir, &info);
         err >= 0 => 1;
         if (err == 0) {
             break;
         }
 
-        strcpy((char*)buffer, "coldpotato/");
+        strcpy(path, "coldpotato/");
-        strcat((char*)buffer, info.name);
+        strcat(path, info.name);
-        lfs_remove(&lfs, (char*)buffer) => 0;
+        lfs_remove(&lfs, path) => 0;
     }
 
     lfs_remove(&lfs, "coldpotato") => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir[0], "/") => 0;
+    lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "burito") => 0;
     info.type => LFS_TYPE_REG;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "cactus") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Multi-block rename ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     for (int i = 0; i < $LARGESIZE; i++) {
-        sprintf((char*)buffer, "cactus/test%03d", i);
+        char oldpath[1024];
-        sprintf((char*)wbuffer, "cactus/tedd%03d", i);
+        char newpath[1024];
-        lfs_rename(&lfs, (char*)buffer, (char*)wbuffer) => 0;
+        sprintf(oldpath, "cactus/test%03d", i);
+        sprintf(newpath, "cactus/tedd%03d", i);
+        lfs_rename(&lfs, oldpath, newpath) => 0;
     }
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir[0], "cactus") => 0;
+    lfs_dir_open(&lfs, &dir, "cactus") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
     info.type => LFS_TYPE_DIR;
     for (int i = 0; i < $LARGESIZE; i++) {
-        sprintf((char*)buffer, "tedd%03d", i);
+        sprintf(path, "tedd%03d", i);
-        lfs_dir_read(&lfs, &dir[0], &info) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
-        strcmp(info.name, (char*)buffer) => 0;
+        strcmp(info.name, path) => 0;
         info.type => LFS_TYPE_DIR;
     }
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Multi-block remove ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_remove(&lfs, "cactus") => LFS_ERR_NOTEMPTY;
 
     for (int i = 0; i < $LARGESIZE; i++) {
-        sprintf((char*)buffer, "cactus/tedd%03d", i);
+        sprintf(path, "cactus/tedd%03d", i);
-        lfs_remove(&lfs, (char*)buffer) => 0;
+        lfs_remove(&lfs, path) => 0;
     }
 
     lfs_remove(&lfs, "cactus") => 0;
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir[0], "/") => 0;
+    lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "burito") => 0;
     info.type => LFS_TYPE_REG;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Multi-block directory with files ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_mkdir(&lfs, "prickly-pear") => 0;
     for (int i = 0; i < $LARGESIZE; i++) {
-        sprintf((char*)buffer, "prickly-pear/test%03d", i);
+        sprintf(path, "prickly-pear/test%03d", i);
-        lfs_file_open(&lfs, &file[0], (char*)buffer,
+        lfs_file_open(&lfs, &file, path, LFS_O_WRONLY | LFS_O_CREAT) => 0;
-                LFS_O_WRONLY | LFS_O_CREAT) => 0;
+        lfs_size_t size = 6;
-        size = 6;
+        memcpy(buffer, "Hello", size);
-        memcpy(wbuffer, "Hello", size);
+        lfs_file_write(&lfs, &file, buffer, size) => size;
-        lfs_file_write(&lfs, &file[0], wbuffer, size) => size;
+        lfs_file_close(&lfs, &file) => 0;
-        lfs_file_close(&lfs, &file[0]) => 0;
     }
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir[0], "prickly-pear") => 0;
+    lfs_dir_open(&lfs, &dir, "prickly-pear") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
     info.type => LFS_TYPE_DIR;
     for (int i = 0; i < $LARGESIZE; i++) {
-        sprintf((char*)buffer, "test%03d", i);
+        sprintf(path, "test%03d", i);
-        lfs_dir_read(&lfs, &dir[0], &info) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
-        strcmp(info.name, (char*)buffer) => 0;
+        strcmp(info.name, path) => 0;
         info.type => LFS_TYPE_REG;
         info.size => 6;
     }
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Multi-block rename with files ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     for (int i = 0; i < $LARGESIZE; i++) {
-        sprintf((char*)buffer, "prickly-pear/test%03d", i);
+        char oldpath[1024];
-        sprintf((char*)wbuffer, "prickly-pear/tedd%03d", i);
+        char newpath[1024];
-        lfs_rename(&lfs, (char*)buffer, (char*)wbuffer) => 0;
+        sprintf(oldpath, "prickly-pear/test%03d", i);
+        sprintf(newpath, "prickly-pear/tedd%03d", i);
+        lfs_rename(&lfs, oldpath, newpath) => 0;
     }
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir[0], "prickly-pear") => 0;
+    lfs_dir_open(&lfs, &dir, "prickly-pear") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
     info.type => LFS_TYPE_DIR;
     for (int i = 0; i < $LARGESIZE; i++) {
-        sprintf((char*)buffer, "tedd%03d", i);
+        sprintf(path, "tedd%03d", i);
-        lfs_dir_read(&lfs, &dir[0], &info) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
-        strcmp(info.name, (char*)buffer) => 0;
+        strcmp(info.name, path) => 0;
         info.type => LFS_TYPE_REG;
         info.size => 6;
     }
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Multi-block remove with files ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_remove(&lfs, "prickly-pear") => LFS_ERR_NOTEMPTY;
 
     for (int i = 0; i < $LARGESIZE; i++) {
-        sprintf((char*)buffer, "prickly-pear/tedd%03d", i);
+        sprintf(path, "prickly-pear/tedd%03d", i);
-        lfs_remove(&lfs, (char*)buffer) => 0;
+        lfs_remove(&lfs, path) => 0;
     }
 
     lfs_remove(&lfs, "prickly-pear") => 0;
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir[0], "/") => 0;
+    lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "burito") => 0;
     info.type => LFS_TYPE_REG;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
-echo "--- Results ---"
+scripts/results.py
-tests/stats.py

tests/test_entries.sh

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

tests/test_files.sh

@@ -1,71 +1,76 @@
 #!/bin/bash
 set -eu
+export TEST_FILE=$0
+trap 'export TEST_LINE=$LINENO' DEBUG
+
+echo "=== File tests ==="
 
 SMALLSIZE=32
 MEDIUMSIZE=8192
 LARGESIZE=262144
 
-echo "=== File tests ==="
 rm -rf blocks
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_format(&lfs, &cfg) => 0;
 TEST
 
 echo "--- Simple file test ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "hello", LFS_O_WRONLY | LFS_O_CREAT) => 0;
+    lfs_file_open(&lfs, &file, "hello", LFS_O_WRONLY | LFS_O_CREAT) => 0;
-    size = strlen("Hello World!\n");
+    lfs_size_t size = strlen("Hello World!\n");
+    uint8_t wbuffer[1024];
     memcpy(wbuffer, "Hello World!\n", size);
-    lfs_file_write(&lfs, &file[0], wbuffer, size) => size;
+    lfs_file_write(&lfs, &file, wbuffer, size) => size;
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
 
-    lfs_file_open(&lfs, &file[0], "hello", LFS_O_RDONLY) => 0;
+    lfs_file_open(&lfs, &file, "hello", LFS_O_RDONLY) => 0;
     size = strlen("Hello World!\n");
-    lfs_file_read(&lfs, &file[0], rbuffer, size) => size;
+    uint8_t rbuffer[1024];
+    lfs_file_read(&lfs, &file, rbuffer, size) => size;
     memcmp(rbuffer, wbuffer, size) => 0;
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 w_test() {
-tests/test.py ${4:-} << TEST
+scripts/test.py ${4:-} << TEST
-    size = $1;
+    lfs_size_t size = $1;
     lfs_size_t chunk = 31;
     srand(0);
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "$2",
+    lfs_file_open(&lfs, &file, "$2",
         ${3:-LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC}) => 0;
     for (lfs_size_t i = 0; i < size; i += chunk) {
         chunk = (chunk < size - i) ? chunk : size - i;
         for (lfs_size_t b = 0; b < chunk; b++) {
             buffer[b] = rand() & 0xff;
         }
-        lfs_file_write(&lfs, &file[0], buffer, chunk) => chunk;
+        lfs_file_write(&lfs, &file, buffer, chunk) => chunk;
     }
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 }
 
 r_test() {
-tests/test.py << TEST
+scripts/test.py << TEST
-    size = $1;
+    lfs_size_t size = $1;
     lfs_size_t chunk = 29;
     srand(0);
     lfs_mount(&lfs, &cfg) => 0;
     lfs_stat(&lfs, "$2", &info) => 0;
     info.type => LFS_TYPE_REG;
     info.size => size;
-    lfs_file_open(&lfs, &file[0], "$2", ${3:-LFS_O_RDONLY}) => 0;
+    lfs_file_open(&lfs, &file, "$2", ${3:-LFS_O_RDONLY}) => 0;
     for (lfs_size_t i = 0; i < size; i += chunk) {
         chunk = (chunk < size - i) ? chunk : size - i;
-        lfs_file_read(&lfs, &file[0], buffer, chunk) => chunk;
+        lfs_file_read(&lfs, &file, buffer, chunk) => chunk;
         for (lfs_size_t b = 0; b < chunk && i+b < size; b++) {
             buffer[b] => rand() & 0xff;
         }
     }
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 }
@@ -105,113 +110,112 @@ r_test $LARGESIZE largeavacado
 r_test 0 noavacado
 
 echo "--- Dir check ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir[0], "/") => 0;
+    lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "hello") => 0;
     info.type => LFS_TYPE_REG;
     info.size => strlen("Hello World!\n");
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "largeavacado") => 0;
     info.type => LFS_TYPE_REG;
     info.size => $LARGESIZE;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "mediumavacado") => 0;
     info.type => LFS_TYPE_REG;
     info.size => $MEDIUMSIZE;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "noavacado") => 0;
     info.type => LFS_TYPE_REG;
     info.size => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "smallavacado") => 0;
     info.type => LFS_TYPE_REG;
     info.size => $SMALLSIZE;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Many files test ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_format(&lfs, &cfg) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     // Create 300 files of 7 bytes
     lfs_mount(&lfs, &cfg) => 0;
     for (unsigned i = 0; i < 300; i++) {
-        snprintf((char*)buffer, sizeof(buffer), "file_%03d", i);
+        sprintf(path, "file_%03d", i);
-        lfs_file_open(&lfs, &file[0], (char*)buffer,
+        lfs_file_open(&lfs, &file, path,
                 LFS_O_RDWR | LFS_O_CREAT | LFS_O_EXCL) => 0;
-        size = 7;
+        lfs_size_t size = 7;
+        uint8_t wbuffer[1024];
+        uint8_t rbuffer[1024];
         snprintf((char*)wbuffer, size, "Hi %03d", i);
-        lfs_file_write(&lfs, &file[0], wbuffer, size) => size;
+        lfs_file_write(&lfs, &file, wbuffer, size) => size;
-        lfs_file_rewind(&lfs, &file[0]) => 0;
+        lfs_file_rewind(&lfs, &file) => 0;
-        lfs_file_read(&lfs, &file[0], rbuffer, size) => size;
+        lfs_file_read(&lfs, &file, rbuffer, size) => size;
         memcmp(wbuffer, rbuffer, size) => 0;
-        lfs_file_close(&lfs, &file[0]) => 0;
+        lfs_file_close(&lfs, &file) => 0;
     }
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Many files with flush test ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_format(&lfs, &cfg) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     // Create 300 files of 7 bytes
     lfs_mount(&lfs, &cfg) => 0;
     for (unsigned i = 0; i < 300; i++) {
-        snprintf((char*)buffer, sizeof(buffer), "file_%03d", i);
+        sprintf(path, "file_%03d", i);
-        lfs_file_open(&lfs, &file[0], (char*)buffer,
+        lfs_file_open(&lfs, &file, path,
                 LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0;
-        size = 7;
+        lfs_size_t size = 7;
+        uint8_t wbuffer[1024];
+        uint8_t rbuffer[1024];
         snprintf((char*)wbuffer, size, "Hi %03d", i);
-        lfs_file_write(&lfs, &file[0], wbuffer, size) => size;
+        lfs_file_write(&lfs, &file, wbuffer, size) => size;
-        lfs_file_close(&lfs, &file[0]) => 0;
+        lfs_file_close(&lfs, &file) => 0;
 
-        snprintf((char*)buffer, sizeof(buffer), "file_%03d", i);
+        lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0;
-        lfs_file_open(&lfs, &file[0], (char*)buffer, LFS_O_RDONLY) => 0;
+        lfs_file_read(&lfs, &file, rbuffer, size) => size;
-        size = 7;
-        snprintf((char*)wbuffer, size, "Hi %03d", i);
-        lfs_file_read(&lfs, &file[0], rbuffer, size) => size;
         memcmp(wbuffer, rbuffer, size) => 0;
-        lfs_file_close(&lfs, &file[0]) => 0;
+        lfs_file_close(&lfs, &file) => 0;
     }
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Many files with power cycle test ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_format(&lfs, &cfg) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     // Create 300 files of 7 bytes
     lfs_mount(&lfs, &cfg) => 0;
     for (unsigned i = 0; i < 300; i++) {
-        snprintf((char*)buffer, sizeof(buffer), "file_%03d", i);
+        sprintf(path, "file_%03d", i);
-        lfs_file_open(&lfs, &file[0], (char*)buffer,
+        lfs_file_open(&lfs, &file, path,
                 LFS_O_WRONLY | LFS_O_CREAT | LFS_O_EXCL) => 0;
-        size = 7;
+        lfs_size_t size = 7;
+        uint8_t wbuffer[1024];
+        uint8_t rbuffer[1024];
         snprintf((char*)wbuffer, size, "Hi %03d", i);
-        lfs_file_write(&lfs, &file[0], wbuffer, size) => size;
+        lfs_file_write(&lfs, &file, wbuffer, size) => size;
-        lfs_file_close(&lfs, &file[0]) => 0;
+        lfs_file_close(&lfs, &file) => 0;
         lfs_unmount(&lfs) => 0;
 
         lfs_mount(&lfs, &cfg) => 0;
-        snprintf((char*)buffer, sizeof(buffer), "file_%03d", i);
+        lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0;
-        lfs_file_open(&lfs, &file[0], (char*)buffer, LFS_O_RDONLY) => 0;
+        lfs_file_read(&lfs, &file, rbuffer, size) => size;
-        size = 7;
-        snprintf((char*)wbuffer, size, "Hi %03d", i);
-        lfs_file_read(&lfs, &file[0], rbuffer, size) => size;
         memcmp(wbuffer, rbuffer, size) => 0;
-        lfs_file_close(&lfs, &file[0]) => 0;
+        lfs_file_close(&lfs, &file) => 0;
     }
     lfs_unmount(&lfs) => 0;
 TEST
 
-echo "--- Results ---"
+scripts/results.py
-tests/stats.py

tests/test_format.sh

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

tests/test_interspersed.sh

@@ -1,89 +1,93 @@
 #!/bin/bash
 set -eu
+export TEST_FILE=$0
+trap 'export TEST_LINE=$LINENO' DEBUG
 
 echo "=== Interspersed tests ==="
 rm -rf blocks
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_format(&lfs, &cfg) => 0;
 TEST
 
 echo "--- Interspersed file test ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "a", LFS_O_WRONLY | LFS_O_CREAT) => 0;
+    lfs_file_t files[4];
-    lfs_file_open(&lfs, &file[1], "b", LFS_O_WRONLY | LFS_O_CREAT) => 0;
+    lfs_file_open(&lfs, &files[0], "a", LFS_O_WRONLY | LFS_O_CREAT) => 0;
-    lfs_file_open(&lfs, &file[2], "c", LFS_O_WRONLY | LFS_O_CREAT) => 0;
+    lfs_file_open(&lfs, &files[1], "b", LFS_O_WRONLY | LFS_O_CREAT) => 0;
-    lfs_file_open(&lfs, &file[3], "d", LFS_O_WRONLY | LFS_O_CREAT) => 0;
+    lfs_file_open(&lfs, &files[2], "c", LFS_O_WRONLY | LFS_O_CREAT) => 0;
+    lfs_file_open(&lfs, &files[3], "d", LFS_O_WRONLY | LFS_O_CREAT) => 0;
 
     for (int i = 0; i < 10; i++) {
-        lfs_file_write(&lfs, &file[0], (const void*)"a", 1) => 1;
+        lfs_file_write(&lfs, &files[0], (const void*)"a", 1) => 1;
-        lfs_file_write(&lfs, &file[1], (const void*)"b", 1) => 1;
+        lfs_file_write(&lfs, &files[1], (const void*)"b", 1) => 1;
-        lfs_file_write(&lfs, &file[2], (const void*)"c", 1) => 1;
+        lfs_file_write(&lfs, &files[2], (const void*)"c", 1) => 1;
-        lfs_file_write(&lfs, &file[3], (const void*)"d", 1) => 1;
+        lfs_file_write(&lfs, &files[3], (const void*)"d", 1) => 1;
     }
 
-    lfs_file_close(&lfs, &file[0]);
+    lfs_file_close(&lfs, &files[0]);
-    lfs_file_close(&lfs, &file[1]);
+    lfs_file_close(&lfs, &files[1]);
-    lfs_file_close(&lfs, &file[2]);
+    lfs_file_close(&lfs, &files[2]);
-    lfs_file_close(&lfs, &file[3]);
+    lfs_file_close(&lfs, &files[3]);
 
-    lfs_dir_open(&lfs, &dir[0], "/") => 0;
+    lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "a") => 0;
     info.type => LFS_TYPE_REG;
     info.size => 10;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "b") => 0;
     info.type => LFS_TYPE_REG;
     info.size => 10;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "c") => 0;
     info.type => LFS_TYPE_REG;
     info.size => 10;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "d") => 0;
     info.type => LFS_TYPE_REG;
     info.size => 10;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
 
-    lfs_file_open(&lfs, &file[0], "a", LFS_O_RDONLY) => 0;
+    lfs_file_open(&lfs, &files[0], "a", LFS_O_RDONLY) => 0;
-    lfs_file_open(&lfs, &file[1], "b", LFS_O_RDONLY) => 0;
+    lfs_file_open(&lfs, &files[1], "b", LFS_O_RDONLY) => 0;
-    lfs_file_open(&lfs, &file[2], "c", LFS_O_RDONLY) => 0;
+    lfs_file_open(&lfs, &files[2], "c", LFS_O_RDONLY) => 0;
-    lfs_file_open(&lfs, &file[3], "d", LFS_O_RDONLY) => 0;
+    lfs_file_open(&lfs, &files[3], "d", LFS_O_RDONLY) => 0;
 
     for (int i = 0; i < 10; i++) {
-        lfs_file_read(&lfs, &file[0], buffer, 1) => 1;
+        lfs_file_read(&lfs, &files[0], buffer, 1) => 1;
         buffer[0] => 'a';
-        lfs_file_read(&lfs, &file[1], buffer, 1) => 1;
+        lfs_file_read(&lfs, &files[1], buffer, 1) => 1;
         buffer[0] => 'b';
-        lfs_file_read(&lfs, &file[2], buffer, 1) => 1;
+        lfs_file_read(&lfs, &files[2], buffer, 1) => 1;
         buffer[0] => 'c';
-        lfs_file_read(&lfs, &file[3], buffer, 1) => 1;
+        lfs_file_read(&lfs, &files[3], buffer, 1) => 1;
         buffer[0] => 'd';
     }
 
-    lfs_file_close(&lfs, &file[0]);
+    lfs_file_close(&lfs, &files[0]);
-    lfs_file_close(&lfs, &file[1]);
+    lfs_file_close(&lfs, &files[1]);
-    lfs_file_close(&lfs, &file[2]);
+    lfs_file_close(&lfs, &files[2]);
-    lfs_file_close(&lfs, &file[3]);
+    lfs_file_close(&lfs, &files[3]);
     
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Interspersed remove file test ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "e", LFS_O_WRONLY | LFS_O_CREAT) => 0;
+    lfs_file_t files[4];
+    lfs_file_open(&lfs, &files[0], "e", LFS_O_WRONLY | LFS_O_CREAT) => 0;
 
     for (int i = 0; i < 5; i++) {
-        lfs_file_write(&lfs, &file[0], (const void*)"e", 1) => 1;
+        lfs_file_write(&lfs, &files[0], (const void*)"e", 1) => 1;
     }
 
     lfs_remove(&lfs, "a") => 0;
@@ -92,95 +96,95 @@ tests/test.py << TEST
     lfs_remove(&lfs, "d") => 0;
 
     for (int i = 0; i < 5; i++) {
-        lfs_file_write(&lfs, &file[0], (const void*)"e", 1) => 1;
+        lfs_file_write(&lfs, &files[0], (const void*)"e", 1) => 1;
     }
 
-    lfs_file_close(&lfs, &file[0]);
+    lfs_file_close(&lfs, &files[0]);
 
-    lfs_dir_open(&lfs, &dir[0], "/") => 0;
+    lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "e") => 0;
     info.type => LFS_TYPE_REG;
     info.size => 10;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
 
-    lfs_file_open(&lfs, &file[0], "e", LFS_O_RDONLY) => 0;
+    lfs_file_open(&lfs, &files[0], "e", LFS_O_RDONLY) => 0;
 
     for (int i = 0; i < 10; i++) {
-        lfs_file_read(&lfs, &file[0], buffer, 1) => 1;
+        lfs_file_read(&lfs, &files[0], buffer, 1) => 1;
         buffer[0] => 'e';
     }
 
-    lfs_file_close(&lfs, &file[0]);
+    lfs_file_close(&lfs, &files[0]);
     
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Remove inconveniently test ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "e", LFS_O_WRONLY | LFS_O_TRUNC) => 0;
+    lfs_file_t files[4];
-    lfs_file_open(&lfs, &file[1], "f", LFS_O_WRONLY | LFS_O_CREAT) => 0;
+    lfs_file_open(&lfs, &files[0], "e", LFS_O_WRONLY | LFS_O_TRUNC) => 0;
-    lfs_file_open(&lfs, &file[2], "g", LFS_O_WRONLY | LFS_O_CREAT) => 0;
+    lfs_file_open(&lfs, &files[1], "f", LFS_O_WRONLY | LFS_O_CREAT) => 0;
+    lfs_file_open(&lfs, &files[2], "g", LFS_O_WRONLY | LFS_O_CREAT) => 0;
 
     for (int i = 0; i < 5; i++) {
-        lfs_file_write(&lfs, &file[0], (const void*)"e", 1) => 1;
+        lfs_file_write(&lfs, &files[0], (const void*)"e", 1) => 1;
-        lfs_file_write(&lfs, &file[1], (const void*)"f", 1) => 1;
+        lfs_file_write(&lfs, &files[1], (const void*)"f", 1) => 1;
-        lfs_file_write(&lfs, &file[2], (const void*)"g", 1) => 1;
+        lfs_file_write(&lfs, &files[2], (const void*)"g", 1) => 1;
     }
 
     lfs_remove(&lfs, "f") => 0;
 
     for (int i = 0; i < 5; i++) {
-        lfs_file_write(&lfs, &file[0], (const void*)"e", 1) => 1;
+        lfs_file_write(&lfs, &files[0], (const void*)"e", 1) => 1;
-        lfs_file_write(&lfs, &file[1], (const void*)"f", 1) => 1;
+        lfs_file_write(&lfs, &files[1], (const void*)"f", 1) => 1;
-        lfs_file_write(&lfs, &file[2], (const void*)"g", 1) => 1;
+        lfs_file_write(&lfs, &files[2], (const void*)"g", 1) => 1;
     }
 
-    lfs_file_close(&lfs, &file[0]);
+    lfs_file_close(&lfs, &files[0]);
-    lfs_file_close(&lfs, &file[1]);
+    lfs_file_close(&lfs, &files[1]);
-    lfs_file_close(&lfs, &file[2]);
+    lfs_file_close(&lfs, &files[2]);
 
-    lfs_dir_open(&lfs, &dir[0], "/") => 0;
+    lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "e") => 0;
     info.type => LFS_TYPE_REG;
     info.size => 10;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "g") => 0;
     info.type => LFS_TYPE_REG;
     info.size => 10;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
 
-    lfs_file_open(&lfs, &file[0], "e", LFS_O_RDONLY) => 0;
+    lfs_file_open(&lfs, &files[0], "e", LFS_O_RDONLY) => 0;
-    lfs_file_open(&lfs, &file[1], "g", LFS_O_RDONLY) => 0;
+    lfs_file_open(&lfs, &files[1], "g", LFS_O_RDONLY) => 0;
 
     for (int i = 0; i < 10; i++) {
-        lfs_file_read(&lfs, &file[0], buffer, 1) => 1;
+        lfs_file_read(&lfs, &files[0], buffer, 1) => 1;
         buffer[0] => 'e';
-        lfs_file_read(&lfs, &file[1], buffer, 1) => 1;
+        lfs_file_read(&lfs, &files[1], buffer, 1) => 1;
         buffer[0] => 'g';
     }
 
-    lfs_file_close(&lfs, &file[0]);
+    lfs_file_close(&lfs, &files[0]);
-    lfs_file_close(&lfs, &file[1]);
+    lfs_file_close(&lfs, &files[1]);
     
     lfs_unmount(&lfs) => 0;
 TEST
 
-echo "--- Results ---"
+scripts/results.py
-tests/stats.py

tests/test_move.sh

@@ -1,9 +1,11 @@
 #!/bin/bash
 set -eu
+export TEST_FILE=$0
+trap 'export TEST_LINE=$LINENO' DEBUG
 
 echo "=== Move tests ==="
 rm -rf blocks
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_format(&lfs, &cfg) => 0;
 
     lfs_mount(&lfs, &cfg) => 0;
@@ -17,272 +19,272 @@ tests/test.py << TEST
     lfs_mkdir(&lfs, "a/hi/bonjour") => 0;
     lfs_mkdir(&lfs, "a/hi/ohayo") => 0;
 
-    lfs_file_open(&lfs, &file[0], "a/hello", LFS_O_CREAT | LFS_O_WRONLY) => 0;
+    lfs_file_open(&lfs, &file, "a/hello", LFS_O_CREAT | LFS_O_WRONLY) => 0;
-    lfs_file_write(&lfs, &file[0], "hola\n", 5) => 5;
+    lfs_file_write(&lfs, &file, "hola\n", 5) => 5;
-    lfs_file_write(&lfs, &file[0], "bonjour\n", 8) => 8;
+    lfs_file_write(&lfs, &file, "bonjour\n", 8) => 8;
-    lfs_file_write(&lfs, &file[0], "ohayo\n", 6) => 6;
+    lfs_file_write(&lfs, &file, "ohayo\n", 6) => 6;
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Move file ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_rename(&lfs, "a/hello", "b/hello") => 0;
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir[0], "a") => 0;
+    lfs_dir_open(&lfs, &dir, "a") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "hi") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
-    lfs_dir_open(&lfs, &dir[0], "b") => 0;
+    lfs_dir_open(&lfs, &dir, "b") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "hello") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Move file corrupt source ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_rename(&lfs, "b/hello", "c/hello") => 0;
     lfs_unmount(&lfs) => 0;
 TEST
-tests/corrupt.py -n 1
+scripts/corrupt.py -n 1
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir[0], "b") => 0;
+    lfs_dir_open(&lfs, &dir, "b") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
-    lfs_dir_open(&lfs, &dir[0], "c") => 0;
+    lfs_dir_open(&lfs, &dir, "c") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "hello") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Move file corrupt source and dest ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_rename(&lfs, "c/hello", "d/hello") => 0;
     lfs_unmount(&lfs) => 0;
 TEST
-tests/corrupt.py -n 2
+scripts/corrupt.py -n 2
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir[0], "c") => 0;
+    lfs_dir_open(&lfs, &dir, "c") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "hello") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
-    lfs_dir_open(&lfs, &dir[0], "d") => 0;
+    lfs_dir_open(&lfs, &dir, "d") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Move file after corrupt ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_rename(&lfs, "c/hello", "d/hello") => 0;
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir[0], "c") => 0;
+    lfs_dir_open(&lfs, &dir, "c") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
-    lfs_dir_open(&lfs, &dir[0], "d") => 0;
+    lfs_dir_open(&lfs, &dir, "d") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "hello") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Move dir ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_rename(&lfs, "a/hi", "b/hi") => 0;
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir[0], "a") => 0;
+    lfs_dir_open(&lfs, &dir, "a") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
-    lfs_dir_open(&lfs, &dir[0], "b") => 0;
+    lfs_dir_open(&lfs, &dir, "b") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "hi") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Move dir corrupt source ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_rename(&lfs, "b/hi", "c/hi") => 0;
     lfs_unmount(&lfs) => 0;
 TEST
-tests/corrupt.py -n 1
+scripts/corrupt.py -n 1
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir[0], "b") => 0;
+    lfs_dir_open(&lfs, &dir, "b") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
-    lfs_dir_open(&lfs, &dir[0], "c") => 0;
+    lfs_dir_open(&lfs, &dir, "c") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "hi") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Move dir corrupt source and dest ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_rename(&lfs, "c/hi", "d/hi") => 0;
     lfs_unmount(&lfs) => 0;
 TEST
-tests/corrupt.py -n 2
+scripts/corrupt.py -n 2
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir[0], "c") => 0;
+    lfs_dir_open(&lfs, &dir, "c") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "hi") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
-    lfs_dir_open(&lfs, &dir[0], "d") => 0;
+    lfs_dir_open(&lfs, &dir, "d") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "hello") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Move dir after corrupt ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_rename(&lfs, "c/hi", "d/hi") => 0;
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir[0], "c") => 0;
+    lfs_dir_open(&lfs, &dir, "c") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
-    lfs_dir_open(&lfs, &dir[0], "d") => 0;
+    lfs_dir_open(&lfs, &dir, "d") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "hello") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "hi") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Move check ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
 
-    lfs_dir_open(&lfs, &dir[0], "a/hi") => LFS_ERR_NOENT;
+    lfs_dir_open(&lfs, &dir, "a/hi") => LFS_ERR_NOENT;
-    lfs_dir_open(&lfs, &dir[0], "b/hi") => LFS_ERR_NOENT;
+    lfs_dir_open(&lfs, &dir, "b/hi") => LFS_ERR_NOENT;
-    lfs_dir_open(&lfs, &dir[0], "c/hi") => LFS_ERR_NOENT;
+    lfs_dir_open(&lfs, &dir, "c/hi") => LFS_ERR_NOENT;
 
-    lfs_dir_open(&lfs, &dir[0], "d/hi") => 0;
+    lfs_dir_open(&lfs, &dir, "d/hi") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "bonjour") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "hola") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "ohayo") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
 
-    lfs_dir_open(&lfs, &dir[0], "a/hello") => LFS_ERR_NOENT;
+    lfs_dir_open(&lfs, &dir, "a/hello") => LFS_ERR_NOENT;
-    lfs_dir_open(&lfs, &dir[0], "b/hello") => LFS_ERR_NOENT;
+    lfs_dir_open(&lfs, &dir, "b/hello") => LFS_ERR_NOENT;
-    lfs_dir_open(&lfs, &dir[0], "c/hello") => LFS_ERR_NOENT;
+    lfs_dir_open(&lfs, &dir, "c/hello") => LFS_ERR_NOENT;
 
-    lfs_file_open(&lfs, &file[0], "d/hello", LFS_O_RDONLY) => 0;
+    lfs_file_open(&lfs, &file, "d/hello", LFS_O_RDONLY) => 0;
-    lfs_file_read(&lfs, &file[0], buffer, 5) => 5;
+    lfs_file_read(&lfs, &file, buffer, 5) => 5;
     memcmp(buffer, "hola\n", 5) => 0;
-    lfs_file_read(&lfs, &file[0], buffer, 8) => 8;
+    lfs_file_read(&lfs, &file, buffer, 8) => 8;
     memcmp(buffer, "bonjour\n", 8) => 0;
-    lfs_file_read(&lfs, &file[0], buffer, 6) => 6;
+    lfs_file_read(&lfs, &file, buffer, 6) => 6;
     memcmp(buffer, "ohayo\n", 6) => 0;
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
 
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Move state stealing ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
 
     lfs_remove(&lfs, "b") => 0;
@@ -290,43 +292,42 @@ tests/test.py << TEST
 
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
 
-    lfs_dir_open(&lfs, &dir[0], "a/hi") => LFS_ERR_NOENT;
+    lfs_dir_open(&lfs, &dir, "a/hi") => LFS_ERR_NOENT;
-    lfs_dir_open(&lfs, &dir[0], "b") => LFS_ERR_NOENT;
+    lfs_dir_open(&lfs, &dir, "b") => LFS_ERR_NOENT;
-    lfs_dir_open(&lfs, &dir[0], "c") => LFS_ERR_NOENT;
+    lfs_dir_open(&lfs, &dir, "c") => LFS_ERR_NOENT;
 
-    lfs_dir_open(&lfs, &dir[0], "d/hi") => 0;
+    lfs_dir_open(&lfs, &dir, "d/hi") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "bonjour") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "hola") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "ohayo") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
 
-    lfs_dir_open(&lfs, &dir[0], "a/hello") => LFS_ERR_NOENT;
+    lfs_dir_open(&lfs, &dir, "a/hello") => LFS_ERR_NOENT;
-    lfs_dir_open(&lfs, &dir[0], "b") => LFS_ERR_NOENT;
+    lfs_dir_open(&lfs, &dir, "b") => LFS_ERR_NOENT;
-    lfs_dir_open(&lfs, &dir[0], "c") => LFS_ERR_NOENT;
+    lfs_dir_open(&lfs, &dir, "c") => LFS_ERR_NOENT;
 
-    lfs_file_open(&lfs, &file[0], "d/hello", LFS_O_RDONLY) => 0;
+    lfs_file_open(&lfs, &file, "d/hello", LFS_O_RDONLY) => 0;
-    lfs_file_read(&lfs, &file[0], buffer, 5) => 5;
+    lfs_file_read(&lfs, &file, buffer, 5) => 5;
     memcmp(buffer, "hola\n", 5) => 0;
-    lfs_file_read(&lfs, &file[0], buffer, 8) => 8;
+    lfs_file_read(&lfs, &file, buffer, 8) => 8;
     memcmp(buffer, "bonjour\n", 8) => 0;
-    lfs_file_read(&lfs, &file[0], buffer, 6) => 6;
+    lfs_file_read(&lfs, &file, buffer, 6) => 6;
     memcmp(buffer, "ohayo\n", 6) => 0;
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
 
     lfs_unmount(&lfs) => 0;
 TEST
 
 
-echo "--- Results ---"
+scripts/results.py
-tests/stats.py

tests/test_orphan.sh

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

tests/test_paths.sh

@@ -1,13 +1,15 @@
 #!/bin/bash
 set -eu
+export TEST_FILE=$0
+trap 'export TEST_LINE=$LINENO' DEBUG
 
 echo "=== Path tests ==="
 rm -rf blocks
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_format(&lfs, &cfg) => 0;
 TEST
 
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_mkdir(&lfs, "tea") => 0;
     lfs_mkdir(&lfs, "coffee") => 0;
@@ -25,7 +27,7 @@ tests/test.py << TEST
 TEST
 
 echo "--- Root path tests ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_stat(&lfs, "tea/hottea", &info) => 0;
     strcmp(info.name, "hottea") => 0;
@@ -39,7 +41,7 @@ tests/test.py << TEST
 TEST
 
 echo "--- Redundant slash path tests ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_stat(&lfs, "/tea/hottea", &info) => 0;
     strcmp(info.name, "hottea") => 0;
@@ -55,7 +57,7 @@ tests/test.py << TEST
 TEST
 
 echo "--- Dot path tests ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_stat(&lfs, "./tea/hottea", &info) => 0;
     strcmp(info.name, "hottea") => 0;
@@ -73,7 +75,7 @@ tests/test.py << TEST
 TEST
 
 echo "--- Dot dot path tests ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_stat(&lfs, "coffee/../tea/hottea", &info) => 0;
     strcmp(info.name, "hottea") => 0;
@@ -91,7 +93,7 @@ tests/test.py << TEST
 TEST
 
 echo "--- Trailing dot path tests ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_stat(&lfs, "tea/hottea/", &info) => 0;
     strcmp(info.name, "hottea") => 0;
@@ -107,7 +109,7 @@ tests/test.py << TEST
 TEST
 
 echo "--- Root dot dot path tests ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_stat(&lfs, "coffee/../../../../../../tea/hottea", &info) => 0;
     strcmp(info.name, "hottea") => 0;
@@ -119,14 +121,14 @@ tests/test.py << TEST
 TEST
 
 echo "--- Root tests ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_stat(&lfs, "/", &info) => 0;
     info.type => LFS_TYPE_DIR;
     strcmp(info.name, "/") => 0;
 
     lfs_mkdir(&lfs, "/") => LFS_ERR_EXIST;
-    lfs_file_open(&lfs, &file[0], "/", LFS_O_WRONLY | LFS_O_CREAT)
+    lfs_file_open(&lfs, &file, "/", LFS_O_WRONLY | LFS_O_CREAT)
         => LFS_ERR_ISDIR;
 
     // more corner cases
@@ -140,7 +142,7 @@ tests/test.py << TEST
 TEST
 
 echo "--- Sketchy path tests ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_mkdir(&lfs, "dirt/ground") => LFS_ERR_NOENT;
     lfs_mkdir(&lfs, "dirt/ground/earth") => LFS_ERR_NOENT;
@@ -148,7 +150,7 @@ tests/test.py << TEST
 TEST
 
 echo "--- Superblock conflict test ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
     lfs_mkdir(&lfs, "littlefs") => 0;
     lfs_remove(&lfs, "littlefs") => 0;
@@ -156,46 +158,45 @@ tests/test.py << TEST
 TEST
 
 echo "--- Max path test ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    memset(buffer, 'w', LFS_NAME_MAX+1);
+    memset(path, 'w', LFS_NAME_MAX+1);
-    buffer[LFS_NAME_MAX+2] = '\0';
+    path[LFS_NAME_MAX+2] = '\0';
-    lfs_mkdir(&lfs, (char*)buffer) => LFS_ERR_NAMETOOLONG;
+    lfs_mkdir(&lfs, path) => LFS_ERR_NAMETOOLONG;
-    lfs_file_open(&lfs, &file[0], (char*)buffer,
+    lfs_file_open(&lfs, &file, path,
             LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NAMETOOLONG;
 
-    memcpy(buffer, "coffee/", strlen("coffee/"));
+    memcpy(path, "coffee/", strlen("coffee/"));
-    memset(buffer+strlen("coffee/"), 'w', LFS_NAME_MAX+1);
+    memset(path+strlen("coffee/"), 'w', LFS_NAME_MAX+1);
-    buffer[strlen("coffee/")+LFS_NAME_MAX+2] = '\0';
+    path[strlen("coffee/")+LFS_NAME_MAX+2] = '\0';
-    lfs_mkdir(&lfs, (char*)buffer) => LFS_ERR_NAMETOOLONG;
+    lfs_mkdir(&lfs, path) => LFS_ERR_NAMETOOLONG;
-    lfs_file_open(&lfs, &file[0], (char*)buffer,
+    lfs_file_open(&lfs, &file, path,
             LFS_O_WRONLY | LFS_O_CREAT) => LFS_ERR_NAMETOOLONG;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Really big path test ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    memset(buffer, 'w', LFS_NAME_MAX);
+    memset(path, 'w', LFS_NAME_MAX);
-    buffer[LFS_NAME_MAX+1] = '\0';
+    path[LFS_NAME_MAX+1] = '\0';
-    lfs_mkdir(&lfs, (char*)buffer) => 0;
+    lfs_mkdir(&lfs, path) => 0;
-    lfs_remove(&lfs, (char*)buffer) => 0;
+    lfs_remove(&lfs, path) => 0;
-    lfs_file_open(&lfs, &file[0], (char*)buffer,
+    lfs_file_open(&lfs, &file, path,
             LFS_O_WRONLY | LFS_O_CREAT) => 0;
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
-    lfs_remove(&lfs, (char*)buffer) => 0;
+    lfs_remove(&lfs, path) => 0;
 
-    memcpy(buffer, "coffee/", strlen("coffee/"));
+    memcpy(path, "coffee/", strlen("coffee/"));
-    memset(buffer+strlen("coffee/"), 'w', LFS_NAME_MAX);
+    memset(path+strlen("coffee/"), 'w', LFS_NAME_MAX);
-    buffer[strlen("coffee/")+LFS_NAME_MAX+1] = '\0';
+    path[strlen("coffee/")+LFS_NAME_MAX+1] = '\0';
-    lfs_mkdir(&lfs, (char*)buffer) => 0;
+    lfs_mkdir(&lfs, path) => 0;
-    lfs_remove(&lfs, (char*)buffer) => 0;
+    lfs_remove(&lfs, path) => 0;
-    lfs_file_open(&lfs, &file[0], (char*)buffer,
+    lfs_file_open(&lfs, &file, path,
             LFS_O_WRONLY | LFS_O_CREAT) => 0;
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
-    lfs_remove(&lfs, (char*)buffer) => 0;
+    lfs_remove(&lfs, path) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
-echo "--- Results ---"
+scripts/results.py
-tests/stats.py

tests/test_seek.sh

@@ -1,429 +1,431 @@
 #!/bin/bash
 set -eu
+export TEST_FILE=$0
+trap 'export TEST_LINE=$LINENO' DEBUG
+
+echo "=== Seek tests ==="
 
 SMALLSIZE=4
 MEDIUMSIZE=128
 LARGESIZE=132
 
-echo "=== Seek tests ==="
 rm -rf blocks
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_format(&lfs, &cfg) => 0;
     lfs_mount(&lfs, &cfg) => 0;
     lfs_mkdir(&lfs, "hello") => 0;
     for (int i = 0; i < $LARGESIZE; i++) {
-        sprintf((char*)buffer, "hello/kitty%03d", i);
+        sprintf(path, "hello/kitty%03d", i);
-        lfs_file_open(&lfs, &file[0], (char*)buffer,
+        lfs_file_open(&lfs, &file, path,
                 LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0;
 
-        size = strlen("kittycatcat");
+        lfs_size_t size = strlen("kittycatcat");
         memcpy(buffer, "kittycatcat", size);
         for (int j = 0; j < $LARGESIZE; j++) {
-            lfs_file_write(&lfs, &file[0], buffer, size);
+            lfs_file_write(&lfs, &file, buffer, size);
         }
 
-        lfs_file_close(&lfs, &file[0]) => 0;
+        lfs_file_close(&lfs, &file) => 0;
     }
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Simple dir seek ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir[0], "hello") => 0;
+    lfs_dir_open(&lfs, &dir, "hello") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
 
     lfs_soff_t pos;
     int i;
     for (i = 0; i < $SMALLSIZE; i++) {
-        sprintf((char*)buffer, "kitty%03d", i);
+        sprintf(path, "kitty%03d", i);
-        lfs_dir_read(&lfs, &dir[0], &info) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
-        strcmp(info.name, (char*)buffer) => 0;
+        strcmp(info.name, path) => 0;
-        pos = lfs_dir_tell(&lfs, &dir[0]);
+        pos = lfs_dir_tell(&lfs, &dir);
     }
     pos >= 0 => 1;
 
-    lfs_dir_seek(&lfs, &dir[0], pos) => 0;
+    lfs_dir_seek(&lfs, &dir, pos) => 0;
-    sprintf((char*)buffer, "kitty%03d", i);
+    sprintf(path, "kitty%03d", i);
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
-    strcmp(info.name, (char*)buffer) => 0;
+    strcmp(info.name, path) => 0;
 
-    lfs_dir_rewind(&lfs, &dir[0]) => 0;
+    lfs_dir_rewind(&lfs, &dir) => 0;
-    sprintf((char*)buffer, "kitty%03d", 0);
+    sprintf(path, "kitty%03d", 0);
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
-    strcmp(info.name, (char*)buffer) => 0;
+    strcmp(info.name, path) => 0;
 
-    lfs_dir_seek(&lfs, &dir[0], pos) => 0;
+    lfs_dir_seek(&lfs, &dir, pos) => 0;
-    sprintf((char*)buffer, "kitty%03d", i);
+    sprintf(path, "kitty%03d", i);
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
-    strcmp(info.name, (char*)buffer) => 0;
+    strcmp(info.name, path) => 0;
 
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Large dir seek ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir[0], "hello") => 0;
+    lfs_dir_open(&lfs, &dir, "hello") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
 
     lfs_soff_t pos;
     int i;
     for (i = 0; i < $MEDIUMSIZE; i++) {
-        sprintf((char*)buffer, "kitty%03d", i);
+        sprintf(path, "kitty%03d", i);
-        lfs_dir_read(&lfs, &dir[0], &info) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
-        strcmp(info.name, (char*)buffer) => 0;
+        strcmp(info.name, path) => 0;
-        pos = lfs_dir_tell(&lfs, &dir[0]);
+        pos = lfs_dir_tell(&lfs, &dir);
     }
     pos >= 0 => 1;
 
-    lfs_dir_seek(&lfs, &dir[0], pos) => 0;
+    lfs_dir_seek(&lfs, &dir, pos) => 0;
-    sprintf((char*)buffer, "kitty%03d", i);
+    sprintf(path, "kitty%03d", i);
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
-    strcmp(info.name, (char*)buffer) => 0;
+    strcmp(info.name, path) => 0;
 
-    lfs_dir_rewind(&lfs, &dir[0]) => 0;
+    lfs_dir_rewind(&lfs, &dir) => 0;
-    sprintf((char*)buffer, "kitty%03d", 0);
+    sprintf(path, "kitty%03d", 0);
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, ".") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     strcmp(info.name, "..") => 0;
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
-    strcmp(info.name, (char*)buffer) => 0;
+    strcmp(info.name, path) => 0;
 
-    lfs_dir_seek(&lfs, &dir[0], pos) => 0;
+    lfs_dir_seek(&lfs, &dir, pos) => 0;
-    sprintf((char*)buffer, "kitty%03d", i);
+    sprintf(path, "kitty%03d", i);
-    lfs_dir_read(&lfs, &dir[0], &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
-    strcmp(info.name, (char*)buffer) => 0;
+    strcmp(info.name, path) => 0;
 
-    lfs_dir_close(&lfs, &dir[0]) => 0;
+    lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Simple file seek ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "hello/kitty042", LFS_O_RDONLY) => 0;
+    lfs_file_open(&lfs, &file, "hello/kitty042", LFS_O_RDONLY) => 0;
 
     lfs_soff_t pos;
-    size = strlen("kittycatcat");
+    lfs_size_t size = strlen("kittycatcat");
     for (int i = 0; i < $SMALLSIZE; i++) {
-        lfs_file_read(&lfs, &file[0], buffer, size) => size;
+        lfs_file_read(&lfs, &file, buffer, size) => size;
         memcmp(buffer, "kittycatcat", size) => 0;
-        pos = lfs_file_tell(&lfs, &file[0]);
+        pos = lfs_file_tell(&lfs, &file);
     }
     pos >= 0 => 1;
 
-    lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
+    lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos;
-    lfs_file_read(&lfs, &file[0], buffer, size) => size;
+    lfs_file_read(&lfs, &file, buffer, size) => size;
     memcmp(buffer, "kittycatcat", size) => 0;
 
-    lfs_file_rewind(&lfs, &file[0]) => 0;
+    lfs_file_rewind(&lfs, &file) => 0;
-    lfs_file_read(&lfs, &file[0], buffer, size) => size;
+    lfs_file_read(&lfs, &file, buffer, size) => size;
     memcmp(buffer, "kittycatcat", size) => 0;
 
-    lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_CUR) => size;
+    lfs_file_seek(&lfs, &file, 0, LFS_SEEK_CUR) => size;
-    lfs_file_read(&lfs, &file[0], buffer, size) => size;
+    lfs_file_read(&lfs, &file, buffer, size) => size;
     memcmp(buffer, "kittycatcat", size) => 0;
 
-    lfs_file_seek(&lfs, &file[0], size, LFS_SEEK_CUR) => 3*size;
+    lfs_file_seek(&lfs, &file, size, LFS_SEEK_CUR) => 3*size;
-    lfs_file_read(&lfs, &file[0], buffer, size) => size;
+    lfs_file_read(&lfs, &file, buffer, size) => size;
     memcmp(buffer, "kittycatcat", size) => 0;
 
-    lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
+    lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos;
-    lfs_file_read(&lfs, &file[0], buffer, size) => size;
+    lfs_file_read(&lfs, &file, buffer, size) => size;
     memcmp(buffer, "kittycatcat", size) => 0;
 
-    lfs_file_seek(&lfs, &file[0], -size, LFS_SEEK_CUR) => pos;
+    lfs_file_seek(&lfs, &file, -size, LFS_SEEK_CUR) => pos;
-    lfs_file_read(&lfs, &file[0], buffer, size) => size;
+    lfs_file_read(&lfs, &file, buffer, size) => size;
     memcmp(buffer, "kittycatcat", size) => 0;
 
-    lfs_file_seek(&lfs, &file[0], -size, LFS_SEEK_END) >= 0 => 1;
+    lfs_file_seek(&lfs, &file, -size, LFS_SEEK_END) >= 0 => 1;
-    lfs_file_read(&lfs, &file[0], buffer, size) => size;
+    lfs_file_read(&lfs, &file, buffer, size) => size;
     memcmp(buffer, "kittycatcat", size) => 0;
 
-    size = lfs_file_size(&lfs, &file[0]);
+    size = lfs_file_size(&lfs, &file);
-    lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_CUR) => size;
+    lfs_file_seek(&lfs, &file, 0, LFS_SEEK_CUR) => size;
 
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Large file seek ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "hello/kitty042", LFS_O_RDONLY) => 0;
+    lfs_file_open(&lfs, &file, "hello/kitty042", LFS_O_RDONLY) => 0;
 
     lfs_soff_t pos;
-    size = strlen("kittycatcat");
+    lfs_size_t size = strlen("kittycatcat");
     for (int i = 0; i < $MEDIUMSIZE; i++) {
-        lfs_file_read(&lfs, &file[0], buffer, size) => size;
+        lfs_file_read(&lfs, &file, buffer, size) => size;
         memcmp(buffer, "kittycatcat", size) => 0;
-        pos = lfs_file_tell(&lfs, &file[0]);
+        pos = lfs_file_tell(&lfs, &file);
     }
     pos >= 0 => 1;
 
-    lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
+    lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos;
-    lfs_file_read(&lfs, &file[0], buffer, size) => size;
+    lfs_file_read(&lfs, &file, buffer, size) => size;
     memcmp(buffer, "kittycatcat", size) => 0;
 
-    lfs_file_rewind(&lfs, &file[0]) => 0;
+    lfs_file_rewind(&lfs, &file) => 0;
-    lfs_file_read(&lfs, &file[0], buffer, size) => size;
+    lfs_file_read(&lfs, &file, buffer, size) => size;
     memcmp(buffer, "kittycatcat", size) => 0;
 
-    lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_CUR) => size;
+    lfs_file_seek(&lfs, &file, 0, LFS_SEEK_CUR) => size;
-    lfs_file_read(&lfs, &file[0], buffer, size) => size;
+    lfs_file_read(&lfs, &file, buffer, size) => size;
     memcmp(buffer, "kittycatcat", size) => 0;
 
-    lfs_file_seek(&lfs, &file[0], size, LFS_SEEK_CUR) => 3*size;
+    lfs_file_seek(&lfs, &file, size, LFS_SEEK_CUR) => 3*size;
-    lfs_file_read(&lfs, &file[0], buffer, size) => size;
+    lfs_file_read(&lfs, &file, buffer, size) => size;
     memcmp(buffer, "kittycatcat", size) => 0;
 
-    lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
+    lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos;
-    lfs_file_read(&lfs, &file[0], buffer, size) => size;
+    lfs_file_read(&lfs, &file, buffer, size) => size;
     memcmp(buffer, "kittycatcat", size) => 0;
 
-    lfs_file_seek(&lfs, &file[0], -size, LFS_SEEK_CUR) => pos;
+    lfs_file_seek(&lfs, &file, -size, LFS_SEEK_CUR) => pos;
-    lfs_file_read(&lfs, &file[0], buffer, size) => size;
+    lfs_file_read(&lfs, &file, buffer, size) => size;
     memcmp(buffer, "kittycatcat", size) => 0;
 
-    lfs_file_seek(&lfs, &file[0], -size, LFS_SEEK_END) >= 0 => 1;
+    lfs_file_seek(&lfs, &file, -size, LFS_SEEK_END) >= 0 => 1;
-    lfs_file_read(&lfs, &file[0], buffer, size) => size;
+    lfs_file_read(&lfs, &file, buffer, size) => size;
     memcmp(buffer, "kittycatcat", size) => 0;
 
-    size = lfs_file_size(&lfs, &file[0]);
+    size = lfs_file_size(&lfs, &file);
-    lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_CUR) => size;
+    lfs_file_seek(&lfs, &file, 0, LFS_SEEK_CUR) => size;
 
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Simple file seek and write ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "hello/kitty042", LFS_O_RDWR) => 0;
+    lfs_file_open(&lfs, &file, "hello/kitty042", LFS_O_RDWR) => 0;
 
     lfs_soff_t pos;
-    size = strlen("kittycatcat");
+    lfs_size_t size = strlen("kittycatcat");
     for (int i = 0; i < $SMALLSIZE; i++) {
-        lfs_file_read(&lfs, &file[0], buffer, size) => size;
+        lfs_file_read(&lfs, &file, buffer, size) => size;
         memcmp(buffer, "kittycatcat", size) => 0;
-        pos = lfs_file_tell(&lfs, &file[0]);
+        pos = lfs_file_tell(&lfs, &file);
     }
     pos >= 0 => 1;
 
     memcpy(buffer, "doggodogdog", size);
-    lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
+    lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos;
-    lfs_file_write(&lfs, &file[0], buffer, size) => size;
+    lfs_file_write(&lfs, &file, buffer, size) => size;
 
-    lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
+    lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos;
-    lfs_file_read(&lfs, &file[0], buffer, size) => size;
+    lfs_file_read(&lfs, &file, buffer, size) => size;
     memcmp(buffer, "doggodogdog", size) => 0;
 
-    lfs_file_rewind(&lfs, &file[0]) => 0;
+    lfs_file_rewind(&lfs, &file) => 0;
-    lfs_file_read(&lfs, &file[0], buffer, size) => size;
+    lfs_file_read(&lfs, &file, buffer, size) => size;
     memcmp(buffer, "kittycatcat", size) => 0;
 
-    lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
+    lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos;
-    lfs_file_read(&lfs, &file[0], buffer, size) => size;
+    lfs_file_read(&lfs, &file, buffer, size) => size;
     memcmp(buffer, "doggodogdog", size) => 0;
 
-    lfs_file_seek(&lfs, &file[0], -size, LFS_SEEK_END) >= 0 => 1;
+    lfs_file_seek(&lfs, &file, -size, LFS_SEEK_END) >= 0 => 1;
-    lfs_file_read(&lfs, &file[0], buffer, size) => size;
+    lfs_file_read(&lfs, &file, buffer, size) => size;
     memcmp(buffer, "kittycatcat", size) => 0;
 
-    size = lfs_file_size(&lfs, &file[0]);
+    size = lfs_file_size(&lfs, &file);
-    lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_CUR) => size;
+    lfs_file_seek(&lfs, &file, 0, LFS_SEEK_CUR) => size;
 
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Large file seek and write ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "hello/kitty042", LFS_O_RDWR) => 0;
+    lfs_file_open(&lfs, &file, "hello/kitty042", LFS_O_RDWR) => 0;
 
     lfs_soff_t pos;
-    size = strlen("kittycatcat");
+    lfs_size_t size = strlen("kittycatcat");
     for (int i = 0; i < $MEDIUMSIZE; i++) {
-        lfs_file_read(&lfs, &file[0], buffer, size) => size;
+        lfs_file_read(&lfs, &file, buffer, size) => size;
         if (i != $SMALLSIZE) {
             memcmp(buffer, "kittycatcat", size) => 0;
         }
-        pos = lfs_file_tell(&lfs, &file[0]);
+        pos = lfs_file_tell(&lfs, &file);
     }
     pos >= 0 => 1;
 
     memcpy(buffer, "doggodogdog", size);
-    lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
+    lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos;
-    lfs_file_write(&lfs, &file[0], buffer, size) => size;
+    lfs_file_write(&lfs, &file, buffer, size) => size;
 
-    lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
+    lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos;
-    lfs_file_read(&lfs, &file[0], buffer, size) => size;
+    lfs_file_read(&lfs, &file, buffer, size) => size;
     memcmp(buffer, "doggodogdog", size) => 0;
 
-    lfs_file_rewind(&lfs, &file[0]) => 0;
+    lfs_file_rewind(&lfs, &file) => 0;
-    lfs_file_read(&lfs, &file[0], buffer, size) => size;
+    lfs_file_read(&lfs, &file, buffer, size) => size;
     memcmp(buffer, "kittycatcat", size) => 0;
 
-    lfs_file_seek(&lfs, &file[0], pos, LFS_SEEK_SET) => pos;
+    lfs_file_seek(&lfs, &file, pos, LFS_SEEK_SET) => pos;
-    lfs_file_read(&lfs, &file[0], buffer, size) => size;
+    lfs_file_read(&lfs, &file, buffer, size) => size;
     memcmp(buffer, "doggodogdog", size) => 0;
 
-    lfs_file_seek(&lfs, &file[0], -size, LFS_SEEK_END) >= 0 => 1;
+    lfs_file_seek(&lfs, &file, -size, LFS_SEEK_END) >= 0 => 1;
-    lfs_file_read(&lfs, &file[0], buffer, size) => size;
+    lfs_file_read(&lfs, &file, buffer, size) => size;
     memcmp(buffer, "kittycatcat", size) => 0;
 
-    size = lfs_file_size(&lfs, &file[0]);
+    size = lfs_file_size(&lfs, &file);
-    lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_CUR) => size;
+    lfs_file_seek(&lfs, &file, 0, LFS_SEEK_CUR) => size;
 
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Boundary seek and write ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "hello/kitty042", LFS_O_RDWR) => 0;
+    lfs_file_open(&lfs, &file, "hello/kitty042", LFS_O_RDWR) => 0;
 
-    size = strlen("hedgehoghog");
+    lfs_size_t size = strlen("hedgehoghog");
     const lfs_soff_t offsets[] = {512, 1020, 513, 1021, 511, 1019};
 
     for (unsigned i = 0; i < sizeof(offsets) / sizeof(offsets[0]); i++) {
         lfs_soff_t off = offsets[i];
         memcpy(buffer, "hedgehoghog", size);
-        lfs_file_seek(&lfs, &file[0], off, LFS_SEEK_SET) => off;
+        lfs_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off;
-        lfs_file_write(&lfs, &file[0], buffer, size) => size;
+        lfs_file_write(&lfs, &file, buffer, size) => size;
-        lfs_file_seek(&lfs, &file[0], off, LFS_SEEK_SET) => off;
+        lfs_file_seek(&lfs, &file, off, LFS_SEEK_SET) => off;
-        lfs_file_read(&lfs, &file[0], buffer, size) => size;
+        lfs_file_read(&lfs, &file, buffer, size) => size;
         memcmp(buffer, "hedgehoghog", size) => 0;
 
-        lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_SET) => 0;
+        lfs_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0;
-        lfs_file_read(&lfs, &file[0], buffer, size) => size;
+        lfs_file_read(&lfs, &file, buffer, size) => size;
         memcmp(buffer, "kittycatcat", size) => 0;
 
-        lfs_file_sync(&lfs, &file[0]) => 0;
+        lfs_file_sync(&lfs, &file) => 0;
     }
 
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Out-of-bounds seek ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "hello/kitty042", LFS_O_RDWR) => 0;
+    lfs_file_open(&lfs, &file, "hello/kitty042", LFS_O_RDWR) => 0;
 
-    size = strlen("kittycatcat");
+    lfs_size_t size = strlen("kittycatcat");
-    lfs_file_size(&lfs, &file[0]) => $LARGESIZE*size;
+    lfs_file_size(&lfs, &file) => $LARGESIZE*size;
-    lfs_file_seek(&lfs, &file[0], ($LARGESIZE+$SMALLSIZE)*size,
+    lfs_file_seek(&lfs, &file, ($LARGESIZE+$SMALLSIZE)*size,
             LFS_SEEK_SET) => ($LARGESIZE+$SMALLSIZE)*size;
-    lfs_file_read(&lfs, &file[0], buffer, size) => 0;
+    lfs_file_read(&lfs, &file, buffer, size) => 0;
 
     memcpy(buffer, "porcupineee", size);
-    lfs_file_write(&lfs, &file[0], buffer, size) => size;
+    lfs_file_write(&lfs, &file, buffer, size) => size;
 
-    lfs_file_seek(&lfs, &file[0], ($LARGESIZE+$SMALLSIZE)*size,
+    lfs_file_seek(&lfs, &file, ($LARGESIZE+$SMALLSIZE)*size,
             LFS_SEEK_SET) => ($LARGESIZE+$SMALLSIZE)*size;
-    lfs_file_read(&lfs, &file[0], buffer, size) => size;
+    lfs_file_read(&lfs, &file, buffer, size) => size;
     memcmp(buffer, "porcupineee", size) => 0;
 
-    lfs_file_seek(&lfs, &file[0], $LARGESIZE*size,
+    lfs_file_seek(&lfs, &file, $LARGESIZE*size,
             LFS_SEEK_SET) => $LARGESIZE*size;
-    lfs_file_read(&lfs, &file[0], buffer, size) => size;
+    lfs_file_read(&lfs, &file, buffer, size) => size;
     memcmp(buffer, "\0\0\0\0\0\0\0\0\0\0\0", size) => 0;
 
-    lfs_file_seek(&lfs, &file[0], -(($LARGESIZE+$SMALLSIZE)*size),
+    lfs_file_seek(&lfs, &file, -(($LARGESIZE+$SMALLSIZE)*size),
             LFS_SEEK_CUR) => LFS_ERR_INVAL;
-    lfs_file_tell(&lfs, &file[0]) => ($LARGESIZE+1)*size;
+    lfs_file_tell(&lfs, &file) => ($LARGESIZE+1)*size;
 
-    lfs_file_seek(&lfs, &file[0], -(($LARGESIZE+2*$SMALLSIZE)*size),
+    lfs_file_seek(&lfs, &file, -(($LARGESIZE+2*$SMALLSIZE)*size),
             LFS_SEEK_END) => LFS_ERR_INVAL;
-    lfs_file_tell(&lfs, &file[0]) => ($LARGESIZE+1)*size;
+    lfs_file_tell(&lfs, &file) => ($LARGESIZE+1)*size;
 
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Inline write and seek ---"
 for SIZE in $SMALLSIZE $MEDIUMSIZE $LARGESIZE
 do
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "hello/tinykitty$SIZE",
+    lfs_file_open(&lfs, &file, "hello/tinykitty$SIZE",
             LFS_O_RDWR | LFS_O_CREAT) => 0;
     int j = 0;
     int k = 0;
 
     memcpy(buffer, "abcdefghijklmnopqrstuvwxyz", 26);
     for (unsigned i = 0; i < $SIZE; i++) {
-        lfs_file_write(&lfs, &file[0], &buffer[j++ % 26], 1) => 1;
+        lfs_file_write(&lfs, &file, &buffer[j++ % 26], 1) => 1;
-        lfs_file_tell(&lfs, &file[0]) => i+1;
+        lfs_file_tell(&lfs, &file) => i+1;
-        lfs_file_size(&lfs, &file[0]) => i+1;
+        lfs_file_size(&lfs, &file) => i+1;
     }
 
-    lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_SET) => 0;
+    lfs_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0;
-    lfs_file_tell(&lfs, &file[0]) => 0;
+    lfs_file_tell(&lfs, &file) => 0;
-    lfs_file_size(&lfs, &file[0]) => $SIZE;
+    lfs_file_size(&lfs, &file) => $SIZE;
     for (unsigned i = 0; i < $SIZE; i++) {
         uint8_t c;
-        lfs_file_read(&lfs, &file[0], &c, 1) => 1;
+        lfs_file_read(&lfs, &file, &c, 1) => 1;
         c => buffer[k++ % 26];
     }
 
-    lfs_file_sync(&lfs, &file[0]) => 0;
+    lfs_file_sync(&lfs, &file) => 0;
-    lfs_file_tell(&lfs, &file[0]) => $SIZE;
+    lfs_file_tell(&lfs, &file) => $SIZE;
-    lfs_file_size(&lfs, &file[0]) => $SIZE;
+    lfs_file_size(&lfs, &file) => $SIZE;
 
-    lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_SET) => 0;
+    lfs_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0;
     for (unsigned i = 0; i < $SIZE; i++) {
-        lfs_file_write(&lfs, &file[0], &buffer[j++ % 26], 1) => 1;
+        lfs_file_write(&lfs, &file, &buffer[j++ % 26], 1) => 1;
-        lfs_file_tell(&lfs, &file[0]) => i+1;
+        lfs_file_tell(&lfs, &file) => i+1;
-        lfs_file_size(&lfs, &file[0]) => $SIZE;
+        lfs_file_size(&lfs, &file) => $SIZE;
-        lfs_file_sync(&lfs, &file[0]) => 0;
+        lfs_file_sync(&lfs, &file) => 0;
-        lfs_file_tell(&lfs, &file[0]) => i+1;
+        lfs_file_tell(&lfs, &file) => i+1;
-        lfs_file_size(&lfs, &file[0]) => $SIZE;
+        lfs_file_size(&lfs, &file) => $SIZE;
         if (i < $SIZE-2) {
             uint8_t c[3];
-            lfs_file_seek(&lfs, &file[0], -1, LFS_SEEK_CUR) => i;
+            lfs_file_seek(&lfs, &file, -1, LFS_SEEK_CUR) => i;
-            lfs_file_read(&lfs, &file[0], &c, 3) => 3;
+            lfs_file_read(&lfs, &file, &c, 3) => 3;
-            lfs_file_tell(&lfs, &file[0]) => i+3;
+            lfs_file_tell(&lfs, &file) => i+3;
-            lfs_file_size(&lfs, &file[0]) => $SIZE;
+            lfs_file_size(&lfs, &file) => $SIZE;
-            lfs_file_seek(&lfs, &file[0], i+1, LFS_SEEK_SET) => i+1;
+            lfs_file_seek(&lfs, &file, i+1, LFS_SEEK_SET) => i+1;
-            lfs_file_tell(&lfs, &file[0]) => i+1;
+            lfs_file_tell(&lfs, &file) => i+1;
-            lfs_file_size(&lfs, &file[0]) => $SIZE;
+            lfs_file_size(&lfs, &file) => $SIZE;
         }
     }
 
-    lfs_file_seek(&lfs, &file[0], 0, LFS_SEEK_SET) => 0;
+    lfs_file_seek(&lfs, &file, 0, LFS_SEEK_SET) => 0;
-    lfs_file_tell(&lfs, &file[0]) => 0;
+    lfs_file_tell(&lfs, &file) => 0;
-    lfs_file_size(&lfs, &file[0]) => $SIZE;
+    lfs_file_size(&lfs, &file) => $SIZE;
     for (unsigned i = 0; i < $SIZE; i++) {
         uint8_t c;
-        lfs_file_read(&lfs, &file[0], &c, 1) => 1;
+        lfs_file_read(&lfs, &file, &c, 1) => 1;
         c => buffer[k++ % 26];
     }
 
-    lfs_file_sync(&lfs, &file[0]) => 0;
+    lfs_file_sync(&lfs, &file) => 0;
-    lfs_file_tell(&lfs, &file[0]) => $SIZE;
+    lfs_file_tell(&lfs, &file) => $SIZE;
-    lfs_file_size(&lfs, &file[0]) => $SIZE;
+    lfs_file_size(&lfs, &file) => $SIZE;
 
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 done
 
-echo "--- Results ---"
+scripts/results.py
-tests/stats.py

tests/test_truncate.sh

@@ -1,156 +1,159 @@
 #!/bin/bash
 set -eu
+export TEST_FILE=$0
+trap 'export TEST_LINE=$LINENO' DEBUG
+
+echo "=== Truncate tests ==="
 
 SMALLSIZE=32
 MEDIUMSIZE=2048
 LARGESIZE=8192
 
-echo "=== Truncate tests ==="
 rm -rf blocks
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_format(&lfs, &cfg) => 0;
 TEST
 
 echo "--- Simple truncate ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "baldynoop",
+    lfs_file_open(&lfs, &file, "baldynoop",
             LFS_O_WRONLY | LFS_O_CREAT) => 0;
 
     strcpy((char*)buffer, "hair");
-    size = strlen((char*)buffer);
+    lfs_size_t size = strlen((char*)buffer);
     for (lfs_off_t j = 0; j < $LARGESIZE; j += size) {
-        lfs_file_write(&lfs, &file[0], buffer, size) => size;
+        lfs_file_write(&lfs, &file, buffer, size) => size;
     }
-    lfs_file_size(&lfs, &file[0]) => $LARGESIZE;
+    lfs_file_size(&lfs, &file) => $LARGESIZE;
 
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "baldynoop", LFS_O_RDWR) => 0;
+    lfs_file_open(&lfs, &file, "baldynoop", LFS_O_RDWR) => 0;
-    lfs_file_size(&lfs, &file[0]) => $LARGESIZE;
+    lfs_file_size(&lfs, &file) => $LARGESIZE;
 
-    lfs_file_truncate(&lfs, &file[0], $MEDIUMSIZE) => 0;
+    lfs_file_truncate(&lfs, &file, $MEDIUMSIZE) => 0;
-    lfs_file_size(&lfs, &file[0]) => $MEDIUMSIZE;
+    lfs_file_size(&lfs, &file) => $MEDIUMSIZE;
 
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "baldynoop", LFS_O_RDONLY) => 0;
+    lfs_file_open(&lfs, &file, "baldynoop", LFS_O_RDONLY) => 0;
-    lfs_file_size(&lfs, &file[0]) => $MEDIUMSIZE;
+    lfs_file_size(&lfs, &file) => $MEDIUMSIZE;
 
-    size = strlen("hair");
+    lfs_size_t size = strlen("hair");
     for (lfs_off_t j = 0; j < $MEDIUMSIZE; j += size) {
-        lfs_file_read(&lfs, &file[0], buffer, size) => size;
+        lfs_file_read(&lfs, &file, buffer, size) => size;
         memcmp(buffer, "hair", size) => 0;
     }
-    lfs_file_read(&lfs, &file[0], buffer, size) => 0;
+    lfs_file_read(&lfs, &file, buffer, size) => 0;
 
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Truncate and read ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "baldyread",
+    lfs_file_open(&lfs, &file, "baldyread",
             LFS_O_WRONLY | LFS_O_CREAT) => 0;
 
     strcpy((char*)buffer, "hair");
-    size = strlen((char*)buffer);
+    lfs_size_t size = strlen((char*)buffer);
     for (lfs_off_t j = 0; j < $LARGESIZE; j += size) {
-        lfs_file_write(&lfs, &file[0], buffer, size) => size;
+        lfs_file_write(&lfs, &file, buffer, size) => size;
     }
-    lfs_file_size(&lfs, &file[0]) => $LARGESIZE;
+    lfs_file_size(&lfs, &file) => $LARGESIZE;
 
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "baldyread", LFS_O_RDWR) => 0;
+    lfs_file_open(&lfs, &file, "baldyread", LFS_O_RDWR) => 0;
-    lfs_file_size(&lfs, &file[0]) => $LARGESIZE;
+    lfs_file_size(&lfs, &file) => $LARGESIZE;
 
-    lfs_file_truncate(&lfs, &file[0], $MEDIUMSIZE) => 0;
+    lfs_file_truncate(&lfs, &file, $MEDIUMSIZE) => 0;
-    lfs_file_size(&lfs, &file[0]) => $MEDIUMSIZE;
+    lfs_file_size(&lfs, &file) => $MEDIUMSIZE;
 
-    size = strlen("hair");
+    lfs_size_t size = strlen("hair");
     for (lfs_off_t j = 0; j < $MEDIUMSIZE; j += size) {
-        lfs_file_read(&lfs, &file[0], buffer, size) => size;
+        lfs_file_read(&lfs, &file, buffer, size) => size;
         memcmp(buffer, "hair", size) => 0;
     }
-    lfs_file_read(&lfs, &file[0], buffer, size) => 0;
+    lfs_file_read(&lfs, &file, buffer, size) => 0;
 
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "baldyread", LFS_O_RDONLY) => 0;
+    lfs_file_open(&lfs, &file, "baldyread", LFS_O_RDONLY) => 0;
-    lfs_file_size(&lfs, &file[0]) => $MEDIUMSIZE;
+    lfs_file_size(&lfs, &file) => $MEDIUMSIZE;
 
-    size = strlen("hair");
+    lfs_size_t size = strlen("hair");
     for (lfs_off_t j = 0; j < $MEDIUMSIZE; j += size) {
-        lfs_file_read(&lfs, &file[0], buffer, size) => size;
+        lfs_file_read(&lfs, &file, buffer, size) => size;
         memcmp(buffer, "hair", size) => 0;
     }
-    lfs_file_read(&lfs, &file[0], buffer, size) => 0;
+    lfs_file_read(&lfs, &file, buffer, size) => 0;
 
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
 echo "--- Truncate and write ---"
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "baldywrite",
+    lfs_file_open(&lfs, &file, "baldywrite",
             LFS_O_WRONLY | LFS_O_CREAT) => 0;
 
     strcpy((char*)buffer, "hair");
-    size = strlen((char*)buffer);
+    lfs_size_t size = strlen((char*)buffer);
     for (lfs_off_t j = 0; j < $LARGESIZE; j += size) {
-        lfs_file_write(&lfs, &file[0], buffer, size) => size;
+        lfs_file_write(&lfs, &file, buffer, size) => size;
     }
-    lfs_file_size(&lfs, &file[0]) => $LARGESIZE;
+    lfs_file_size(&lfs, &file) => $LARGESIZE;
 
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "baldywrite", LFS_O_RDWR) => 0;
+    lfs_file_open(&lfs, &file, "baldywrite", LFS_O_RDWR) => 0;
-    lfs_file_size(&lfs, &file[0]) => $LARGESIZE;
+    lfs_file_size(&lfs, &file) => $LARGESIZE;
 
-    lfs_file_truncate(&lfs, &file[0], $MEDIUMSIZE) => 0;
+    lfs_file_truncate(&lfs, &file, $MEDIUMSIZE) => 0;
-    lfs_file_size(&lfs, &file[0]) => $MEDIUMSIZE;
+    lfs_file_size(&lfs, &file) => $MEDIUMSIZE;
 
     strcpy((char*)buffer, "bald");
-    size = strlen((char*)buffer);
+    lfs_size_t size = strlen((char*)buffer);
     for (lfs_off_t j = 0; j < $MEDIUMSIZE; j += size) {
-        lfs_file_write(&lfs, &file[0], buffer, size) => size;
+        lfs_file_write(&lfs, &file, buffer, size) => size;
     }
-    lfs_file_size(&lfs, &file[0]) => $MEDIUMSIZE;
+    lfs_file_size(&lfs, &file) => $MEDIUMSIZE;
 
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file[0], "baldywrite", LFS_O_RDONLY) => 0;
+    lfs_file_open(&lfs, &file, "baldywrite", LFS_O_RDONLY) => 0;
-    lfs_file_size(&lfs, &file[0]) => $MEDIUMSIZE;
+    lfs_file_size(&lfs, &file) => $MEDIUMSIZE;
 
-    size = strlen("bald");
+    lfs_size_t size = strlen("bald");
     for (lfs_off_t j = 0; j < $MEDIUMSIZE; j += size) {
-        lfs_file_read(&lfs, &file[0], buffer, size) => size;
+        lfs_file_read(&lfs, &file, buffer, size) => size;
         memcmp(buffer, "bald", size) => 0;
     }
-    lfs_file_read(&lfs, &file[0], buffer, size) => 0;
+    lfs_file_read(&lfs, &file, buffer, size) => 0;
 
-    lfs_file_close(&lfs, &file[0]) => 0;
+    lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;
 TEST
 
@@ -160,7 +163,7 @@ STARTSIZES="$1"
 STARTSEEKS="$2"
 HOTSIZES="$3"
 COLDSIZES="$4"
-tests/test.py << TEST
+scripts/test.py << TEST
     static const lfs_off_t startsizes[] = {$STARTSIZES};
     static const lfs_off_t startseeks[] = {$STARTSEEKS};
     static const lfs_off_t hotsizes[]   = {$HOTSIZES};
@@ -168,31 +171,31 @@ tests/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
 
     for (unsigned i = 0; i < sizeof(startsizes)/sizeof(startsizes[0]); i++) {
-        sprintf((char*)buffer, "hairyhead%d", i);
+        sprintf(path, "hairyhead%d", i);
-        lfs_file_open(&lfs, &file[0], (const char*)buffer,
+        lfs_file_open(&lfs, &file, path,
                 LFS_O_WRONLY | LFS_O_CREAT | LFS_O_TRUNC) => 0;
 
         strcpy((char*)buffer, "hair");
-        size = strlen((char*)buffer);
+        lfs_size_t size = strlen((char*)buffer);
         for (lfs_off_t j = 0; j < startsizes[i]; j += size) {
-            lfs_file_write(&lfs, &file[0], buffer, size) => size;
+            lfs_file_write(&lfs, &file, buffer, size) => size;
         }
-        lfs_file_size(&lfs, &file[0]) => startsizes[i];
+        lfs_file_size(&lfs, &file) => startsizes[i];
 
         if (startseeks[i] != startsizes[i]) {
-            lfs_file_seek(&lfs, &file[0],
+            lfs_file_seek(&lfs, &file,
                     startseeks[i], LFS_SEEK_SET) => startseeks[i];
         }
 
-        lfs_file_truncate(&lfs, &file[0], hotsizes[i]) => 0;
+        lfs_file_truncate(&lfs, &file, hotsizes[i]) => 0;
-        lfs_file_size(&lfs, &file[0]) => hotsizes[i];
+        lfs_file_size(&lfs, &file) => hotsizes[i];
 
-        lfs_file_close(&lfs, &file[0]) => 0;
+        lfs_file_close(&lfs, &file) => 0;
     }
 
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     static const lfs_off_t startsizes[] = {$STARTSIZES};
     static const lfs_off_t hotsizes[]   = {$HOTSIZES};
     static const lfs_off_t coldsizes[]  = {$COLDSIZES};
@@ -200,31 +203,31 @@ tests/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
 
     for (unsigned i = 0; i < sizeof(startsizes)/sizeof(startsizes[0]); i++) {
-        sprintf((char*)buffer, "hairyhead%d", i);
+        sprintf(path, "hairyhead%d", i);
-        lfs_file_open(&lfs, &file[0], (const char*)buffer, LFS_O_RDWR) => 0;
+        lfs_file_open(&lfs, &file, path, LFS_O_RDWR) => 0;
-        lfs_file_size(&lfs, &file[0]) => hotsizes[i];
+        lfs_file_size(&lfs, &file) => hotsizes[i];
 
-        size = strlen("hair");
+        lfs_size_t size = strlen("hair");
         lfs_off_t j = 0;
         for (; j < startsizes[i] && j < hotsizes[i]; j += size) {
-            lfs_file_read(&lfs, &file[0], buffer, size) => size;
+            lfs_file_read(&lfs, &file, buffer, size) => size;
             memcmp(buffer, "hair", size) => 0;
         }
 
         for (; j < hotsizes[i]; j += size) {
-            lfs_file_read(&lfs, &file[0], buffer, size) => size;
+            lfs_file_read(&lfs, &file, buffer, size) => size;
             memcmp(buffer, "\0\0\0\0", size) => 0;
         }
 
-        lfs_file_truncate(&lfs, &file[0], coldsizes[i]) => 0;
+        lfs_file_truncate(&lfs, &file, coldsizes[i]) => 0;
-        lfs_file_size(&lfs, &file[0]) => coldsizes[i];
+        lfs_file_size(&lfs, &file) => coldsizes[i];
 
-        lfs_file_close(&lfs, &file[0]) => 0;
+        lfs_file_close(&lfs, &file) => 0;
     }
 
     lfs_unmount(&lfs) => 0;
 TEST
-tests/test.py << TEST
+scripts/test.py << TEST
     static const lfs_off_t startsizes[] = {$STARTSIZES};
     static const lfs_off_t hotsizes[]   = {$HOTSIZES};
     static const lfs_off_t coldsizes[]  = {$COLDSIZES};
@@ -232,24 +235,24 @@ tests/test.py << TEST
     lfs_mount(&lfs, &cfg) => 0;
 
     for (unsigned i = 0; i < sizeof(startsizes)/sizeof(startsizes[0]); i++) {
-        sprintf((char*)buffer, "hairyhead%d", i);
+        sprintf(path, "hairyhead%d", i);
-        lfs_file_open(&lfs, &file[0], (const char*)buffer, LFS_O_RDONLY) => 0;
+        lfs_file_open(&lfs, &file, path, LFS_O_RDONLY) => 0;
-        lfs_file_size(&lfs, &file[0]) => coldsizes[i];
+        lfs_file_size(&lfs, &file) => coldsizes[i];
 
-        size = strlen("hair");
+        lfs_size_t size = strlen("hair");
         lfs_off_t j = 0;
         for (; j < startsizes[i] && j < hotsizes[i] && j < coldsizes[i];
                 j += size) {
-            lfs_file_read(&lfs, &file[0], buffer, size) => size;
+            lfs_file_read(&lfs, &file, buffer, size) => size;
             memcmp(buffer, "hair", size) => 0;
         }
 
         for (; j < coldsizes[i]; j += size) {
-            lfs_file_read(&lfs, &file[0], buffer, size) => size;
+            lfs_file_read(&lfs, &file, buffer, size) => size;
             memcmp(buffer, "\0\0\0\0", size) => 0;
         }
 
-        lfs_file_close(&lfs, &file[0]) => 0;
+        lfs_file_close(&lfs, &file) => 0;
     }
 
     lfs_unmount(&lfs) => 0;
@@ -298,5 +301,4 @@ truncate_test \
     "2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE" \
     "2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE, 2*$LARGESIZE"
 
-echo "--- Results ---"
+scripts/results.py
-tests/stats.py