diff --git a/lfs.c b/lfs.c
index 637c1715..dc077267 100644
--- a/lfs.c
+++ b/lfs.c
@@ -8813,6 +8813,7 @@ int lfsr_stat(lfs_t *lfs, const char *path, struct lfs_info *info) {
     if (err == LFS_ERR_INVAL) {
         strcpy(info->name, "/");
         info->type = LFS_TYPE_DIR;
+        info->size = 0;
         return 0;
     }
 
@@ -8901,13 +8902,15 @@ int lfsr_dir_read(lfs_t *lfs, lfsr_dir_t *dir, struct lfs_info *info) {
 
     // handle dots specially
     if (dir->pos == 0) {
-        info->type = LFS_TYPE_DIR;
         strcpy(info->name, ".");
+        info->type = LFS_TYPE_DIR;
+        info->size = 0;
         dir->pos += 1;
         return 0;
     } else if (dir->pos == 1) {
-        info->type = LFS_TYPE_DIR;
         strcpy(info->name, "..");
+        info->type = LFS_TYPE_DIR;
+        info->size = 0;
         dir->pos += 1;
         return 0;
     }
diff --git a/tests/test_alloc.toml b/tests/test_alloc.toml
index fa6869f1..478e753b 100644
--- a/tests/test_alloc.toml
+++ b/tests/test_alloc.toml
@@ -129,6 +129,7 @@ code = '''
         lfsr_stat(&lfs, name, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     lfsr_dir_t dir;
@@ -137,15 +138,18 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         sprintf(name, "dir%04d", i);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -220,21 +224,25 @@ code = '''
         lfsr_stat(&lfs, name, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         sprintf(name, "dir%04d", i);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -617,6 +625,7 @@ code = '''
         lfsr_stat(&lfs, name, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     lfsr_dir_t dir;
@@ -625,15 +634,18 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < n; i++) {
         char name[256];
         sprintf(name, "dir%08d", i);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
diff --git a/tests/test_dirs.toml b/tests/test_dirs.toml
index 0998a503..196cda72 100644
--- a/tests/test_dirs.toml
+++ b/tests/test_dirs.toml
@@ -32,6 +32,7 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // and with dir_read
     lfsr_dir_t dir;
@@ -39,12 +40,15 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -81,17 +85,21 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -114,6 +122,7 @@ code = '''
     lfsr_stat(&lfs, "/", &info) => 0;
     assert(strcmp(info.name, "/") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // remount?
     if (REMOUNT) {
@@ -127,18 +136,22 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_t dir;
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -178,18 +191,22 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_t dir;
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -221,13 +238,16 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     if (exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "ardvark") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -249,18 +269,22 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // and with dir_read
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -303,18 +327,22 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_t dir;
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -357,18 +385,22 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_t dir;
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -404,23 +436,28 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     if (a_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "ardvark") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (b_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "banana") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (c_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "cat") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -448,29 +485,37 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "banana", &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "cat", &info) => 0;
     assert(strcmp(info.name, "cat") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "cat") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -506,13 +551,16 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     if (a_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "ardvark") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -524,13 +572,16 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         if (b_exists) {
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, "banana") == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
@@ -543,13 +594,16 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         if (c_exists) {
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, "cat") == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
@@ -578,23 +632,29 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "ardvark/banana", &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "ardvark/banana/cat", &info) => 0;
     assert(strcmp(info.name, "cat") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -602,12 +662,15 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -615,12 +678,15 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "cat") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -666,6 +732,7 @@ code = '''
         lfsr_stat(&lfs, name, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     lfsr_dir_t dir;
@@ -674,15 +741,18 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         sprintf(name, "dir%04d", i);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -729,6 +799,7 @@ code = '''
         lfsr_stat(&lfs, name, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     lfsr_dir_t dir;
@@ -737,15 +808,18 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         sprintf(name, "dir%04d", i);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -799,6 +873,7 @@ code = '''
         lfsr_stat(&lfs, name, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
 
         for (lfs_size_t j = 0; j < N; j++) {
             char name[256];
@@ -808,6 +883,7 @@ code = '''
             sprintf(name, "child%04d", j);
             assert(strcmp(info.name, name) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
     }
 
@@ -817,15 +893,18 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         sprintf(name, "dir%04d", i);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -837,15 +916,18 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         for (lfs_size_t j = 0; j < N; j++) {
             char name[256];
             sprintf(name, "child%04d", j);
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, name) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
@@ -907,6 +989,7 @@ code = '''
         lfsr_stat(&lfs, name, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
 
         for (lfs_size_t j = 0; j < N; j++) {
             char name[256];
@@ -916,6 +999,7 @@ code = '''
             sprintf(name, "child%04d", j);
             assert(strcmp(info.name, name) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
 
             for (lfs_size_t k = 0; k < N; k++) {
                 char name[256];
@@ -925,6 +1009,7 @@ code = '''
                 sprintf(name, "grandchild%04d", k);
                 assert(strcmp(info.name, name) == 0);
                 assert(info.type == LFS_TYPE_DIR);
+                assert(info.size == 0);
             }
         }
     }
@@ -935,15 +1020,18 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         sprintf(name, "dir%04d", i);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -955,15 +1043,18 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         for (lfs_size_t j = 0; j < N; j++) {
             char name[256];
             sprintf(name, "child%04d", j);
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, name) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
@@ -975,15 +1066,18 @@ code = '''
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, ".") == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, "..") == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
             for (lfs_size_t k = 0; k < N; k++) {
                 char name[256];
                 sprintf(name, "grandchild%04d", k);
                 lfsr_dir_read(&lfs, &dir, &info) => 0;
                 assert(strcmp(info.name, name) == 0);
                 assert(info.type == LFS_TYPE_DIR);
+                assert(info.size == 0);
             }
             lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
             lfsr_dir_close(&lfs, &dir) => 0;
@@ -1035,6 +1129,7 @@ code = '''
         sprintf(name2, "dir%04d", i);
         assert(strcmp(info.name, name2) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     memset(name, 0, sizeof(name));
@@ -1046,15 +1141,18 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         if (i < N-1) {
             char name2[256];
             sprintf(name2, "dir%04d", i+1);
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, name2) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
@@ -1136,6 +1234,7 @@ code = '''
         sprintf(name2, "dir%04d", sim[j]);
         assert(strcmp(info.name, name2) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     lfsr_dir_t dir;
@@ -1144,15 +1243,18 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t j = 0; j < sim_size; j++) {
         char name[256];
         sprintf(name, "dir%04d", sim[j]);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -1209,38 +1311,46 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     if (a_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "a_SNmwMTHH") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (b_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "b_skvjpWJH") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (c_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "c_OnOQhVPH") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (d_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "d_puMpPjRH") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (e_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "e_LptKHkHH") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (f_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "f_lUoVuhJH") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -1277,47 +1387,61 @@ code = '''
     lfsr_stat(&lfs, "a_SNmwMTHH", &info) => 0;
     assert(strcmp(info.name, "a_SNmwMTHH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "b_skvjpWJH", &info) => 0;
     assert(strcmp(info.name, "b_skvjpWJH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "c_OnOQhVPH", &info) => 0;
     assert(strcmp(info.name, "c_OnOQhVPH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "d_puMpPjRH", &info) => 0;
     assert(strcmp(info.name, "d_puMpPjRH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "e_LptKHkHH", &info) => 0;
     assert(strcmp(info.name, "e_LptKHkHH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "f_lUoVuhJH", &info) => 0;
     assert(strcmp(info.name, "f_lUoVuhJH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "a_SNmwMTHH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "b_skvjpWJH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "c_OnOQhVPH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "d_puMpPjRH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "e_LptKHkHH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "f_lUoVuhJH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -1370,38 +1494,46 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     if (a_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "a_IplRNrPH") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (b_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "b_iUwOsqRH") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (c_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "c_UPNtkpHH") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (d_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "d_jKLUSLJH") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (e_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "e_VNunKMPH") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (f_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "f_vknsvNRH") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -1438,47 +1570,61 @@ code = '''
     lfsr_stat(&lfs, "a_IplRNrPH", &info) => 0;
     assert(strcmp(info.name, "a_IplRNrPH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "b_iUwOsqRH", &info) => 0;
     assert(strcmp(info.name, "b_iUwOsqRH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "c_UPNtkpHH", &info) => 0;
     assert(strcmp(info.name, "c_UPNtkpHH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "d_jKLUSLJH", &info) => 0;
     assert(strcmp(info.name, "d_jKLUSLJH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "e_VNunKMPH", &info) => 0;
     assert(strcmp(info.name, "e_VNunKMPH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "f_vknsvNRH", &info) => 0;
     assert(strcmp(info.name, "f_vknsvNRH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "a_IplRNrPH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "b_iUwOsqRH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "c_UPNtkpHH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "d_jKLUSLJH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "e_VNunKMPH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "f_vknsvNRH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -1533,38 +1679,46 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     if (a_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "a_iomlVKPH") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (b_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "b_IJvqkHRH") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (c_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "c_uOOJsIHH") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (d_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "d_JTMkKuJH") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (e_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "e_vQtPStPH") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (f_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "f_VtoMnwRH") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -1601,47 +1755,61 @@ code = '''
     lfsr_stat(&lfs, "a_iomlVKPH", &info) => 0;
     assert(strcmp(info.name, "a_iomlVKPH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "b_IJvqkHRH", &info) => 0;
     assert(strcmp(info.name, "b_IJvqkHRH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "c_uOOJsIHH", &info) => 0;
     assert(strcmp(info.name, "c_uOOJsIHH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "d_JTMkKuJH", &info) => 0;
     assert(strcmp(info.name, "d_JTMkKuJH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "e_vQtPStPH", &info) => 0;
     assert(strcmp(info.name, "e_vQtPStPH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "f_VtoMnwRH", &info) => 0;
     assert(strcmp(info.name, "f_VtoMnwRH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "a_iomlVKPH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "b_IJvqkHRH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "c_uOOJsIHH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "d_JTMkKuJH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "e_vQtPStPH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "f_VtoMnwRH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -1696,38 +1864,46 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     if (a_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "a_IOtUptRH") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (b_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "b_nquQsKHH") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (c_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "c_vwQtKjHH") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (d_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "d_sVrvrWHH") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (e_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "e_thrRIsRH") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (f_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "f_pNtQTPJH") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -1764,47 +1940,61 @@ code = '''
     lfsr_stat(&lfs, "a_IOtUptRH", &info) => 0;
     assert(strcmp(info.name, "a_IOtUptRH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "b_nquQsKHH", &info) => 0;
     assert(strcmp(info.name, "b_nquQsKHH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "c_vwQtKjHH", &info) => 0;
     assert(strcmp(info.name, "c_vwQtKjHH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "d_sVrvrWHH", &info) => 0;
     assert(strcmp(info.name, "d_sVrvrWHH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "e_thrRIsRH", &info) => 0;
     assert(strcmp(info.name, "e_thrRIsRH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "f_pNtQTPJH", &info) => 0;
     assert(strcmp(info.name, "f_pNtQTPJH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "a_IOtUptRH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "b_nquQsKHH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "c_vwQtKjHH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "d_sVrvrWHH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "e_thrRIsRH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "f_pNtQTPJH") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -1843,6 +2033,7 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // and with dir_read
     lfsr_dir_t dir;
@@ -1850,12 +2041,15 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -1878,9 +2072,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -1926,18 +2122,22 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_t dir;
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -1981,21 +2181,26 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "ardvark/banana", &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_t dir;
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -2003,12 +2208,15 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -2040,13 +2248,16 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     if (exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "ardvark") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -2068,18 +2279,22 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // and with dir_read
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -2102,9 +2317,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -2150,18 +2367,22 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_t dir;
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -2197,23 +2418,28 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     if (a_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "ardvark") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (b_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "banana") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (c_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "cat") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -2241,29 +2467,37 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "banana", &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "cat", &info) => 0;
     assert(strcmp(info.name, "cat") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "cat") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -2283,23 +2517,29 @@ code = '''
     lfsr_stat(&lfs, "banana", &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "cat", &info) => 0;
     assert(strcmp(info.name, "cat") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "cat") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -2320,17 +2560,21 @@ code = '''
     lfsr_stat(&lfs, "cat", &info) => 0;
     assert(strcmp(info.name, "cat") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "cat") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -2354,9 +2598,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -2392,13 +2638,16 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     if (a_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "ardvark") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -2410,13 +2659,16 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         if (b_exists) {
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, "banana") == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
@@ -2429,13 +2681,16 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         if (c_exists) {
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, "cat") == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
@@ -2464,23 +2719,29 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "ardvark/banana", &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "ardvark/banana/cat", &info) => 0;
     assert(strcmp(info.name, "cat") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -2488,12 +2749,15 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -2501,12 +2765,15 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "cat") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -2525,21 +2792,26 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "ardvark/banana", &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "ardvark/banana/cat", &info) => LFS_ERR_NOENT;
 
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -2547,12 +2819,15 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -2560,9 +2835,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -2581,6 +2858,7 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "ardvark/banana", &info) => LFS_ERR_NOENT;
     lfsr_stat(&lfs, "ardvark/banana/cat", &info) => LFS_ERR_NOENT;
 
@@ -2588,12 +2866,15 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -2601,9 +2882,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -2627,9 +2910,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -2679,6 +2964,7 @@ code = '''
         lfsr_stat(&lfs, name, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     lfsr_dir_t dir;
@@ -2687,15 +2973,18 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         sprintf(name, "dir%04d", i);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -2729,21 +3018,25 @@ code = '''
         lfsr_stat(&lfs, name, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < REMAINING; i++) {
         char name[256];
         sprintf(name, "dir%04d", (int)(N-REMAINING + i));
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -2794,6 +3087,7 @@ code = '''
         lfsr_stat(&lfs, name, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     lfsr_dir_t dir;
@@ -2802,15 +3096,18 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         sprintf(name, "dir%04d", i);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -2844,21 +3141,25 @@ code = '''
         lfsr_stat(&lfs, name, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < REMAINING; i++) {
         char name[256];
         sprintf(name, "dir%04d", i);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -2920,6 +3221,7 @@ code = '''
         lfsr_stat(&lfs, name, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
 
         for (lfs_size_t j = 0; j < N; j++) {
             char name[256];
@@ -2929,6 +3231,7 @@ code = '''
             sprintf(name, "child%04d", j);
             assert(strcmp(info.name, name) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
     }
 
@@ -2938,15 +3241,18 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         sprintf(name, "dir%04d", i);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -2958,15 +3264,18 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         for (lfs_size_t j = 0; j < N; j++) {
             char name[256];
             sprintf(name, "child%04d", j);
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, name) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
@@ -3016,6 +3325,7 @@ code = '''
             lfsr_stat(&lfs, name, &info) => 0;
             assert(strcmp(info.name, name) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
 
             for (lfs_size_t j = 0; j < N; j++) {
                 char name[256];
@@ -3028,6 +3338,7 @@ code = '''
                     sprintf(name, "child%04d", j);
                     assert(strcmp(info.name, name) == 0);
                     assert(info.type == LFS_TYPE_DIR);
+                    assert(info.size == 0);
                 }
             }
         }
@@ -3037,15 +3348,18 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < REMAINING; i++) {
         char name[256];
         sprintf(name, "dir%04d", (int)(N-REMAINING + i));
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -3057,15 +3371,18 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         for (lfs_size_t j = 0; j < REMAINING; j++) {
             char name[256];
             sprintf(name, "child%04d", (int)(N-REMAINING + j));
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, name) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
@@ -3131,6 +3448,7 @@ code = '''
         lfsr_stat(&lfs, name, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
 
         for (lfs_size_t j = 0; j < N; j++) {
             char name[256];
@@ -3140,6 +3458,7 @@ code = '''
             sprintf(name, "child%04d", j);
             assert(strcmp(info.name, name) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
 
             for (lfs_size_t k = 0; k < N; k++) {
                 char name[256];
@@ -3149,6 +3468,7 @@ code = '''
                 sprintf(name, "grandchild%04d", k);
                 assert(strcmp(info.name, name) == 0);
                 assert(info.type == LFS_TYPE_DIR);
+                assert(info.size == 0);
             }
         }
     }
@@ -3159,15 +3479,18 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         sprintf(name, "dir%04d", i);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -3179,15 +3502,18 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         for (lfs_size_t j = 0; j < N; j++) {
             char name[256];
             sprintf(name, "child%04d", j);
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, name) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
@@ -3199,15 +3525,18 @@ code = '''
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, ".") == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, "..") == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
             for (lfs_size_t k = 0; k < N; k++) {
                 char name[256];
                 sprintf(name, "grandchild%04d", k);
                 lfsr_dir_read(&lfs, &dir, &info) => 0;
                 assert(strcmp(info.name, name) == 0);
                 assert(info.type == LFS_TYPE_DIR);
+                assert(info.size == 0);
             }
             lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
             lfsr_dir_close(&lfs, &dir) => 0;
@@ -3274,6 +3603,7 @@ code = '''
             lfsr_stat(&lfs, name, &info) => 0;
             assert(strcmp(info.name, name) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
 
             for (lfs_size_t j = 0; j < N; j++) {
                 char name[256];
@@ -3286,6 +3616,7 @@ code = '''
                     sprintf(name, "child%04d", j);
                     assert(strcmp(info.name, name) == 0);
                     assert(info.type == LFS_TYPE_DIR);
+                    assert(info.size == 0);
 
                     for (lfs_size_t k = 0; k < N; k++) {
                         char name[256];
@@ -3299,6 +3630,7 @@ code = '''
                             sprintf(name, "grandchild%04d", k);
                             assert(strcmp(info.name, name) == 0);
                             assert(info.type == LFS_TYPE_DIR);
+                            assert(info.size == 0);
                         }
                     }
                 }
@@ -3310,15 +3642,18 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < REMAINING; i++) {
         char name[256];
         sprintf(name, "dir%04d", (int)(N-REMAINING + i));
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -3330,15 +3665,18 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         for (lfs_size_t j = 0; j < REMAINING; j++) {
             char name[256];
             sprintf(name, "child%04d", (int)(N-REMAINING + j));
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, name) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
@@ -3354,15 +3692,18 @@ code = '''
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, ".") == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, "..") == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
             for (lfs_size_t k = 0; k < REMAINING; k++) {
                 char name[256];
                 sprintf(name, "grandchild%04d", (int)(N-REMAINING + k));
                 lfsr_dir_read(&lfs, &dir, &info) => 0;
                 assert(strcmp(info.name, name) == 0);
                 assert(info.type == LFS_TYPE_DIR);
+                assert(info.size == 0);
             }
             lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
             lfsr_dir_close(&lfs, &dir) => 0;
@@ -3418,6 +3759,7 @@ code = '''
         sprintf(name2, "dir%04d", i);
         assert(strcmp(info.name, name2) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     memset(name, 0, sizeof(name));
@@ -3429,15 +3771,18 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         if (i < N-1) {
             char name2[256];
             sprintf(name2, "dir%04d", i+1);
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, name2) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
@@ -3467,6 +3812,7 @@ code = '''
         sprintf(name2, "dir%04d", i);
         assert(strcmp(info.name, name2) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     memset(name, 0, sizeof(name));
@@ -3478,15 +3824,18 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         if (i < REMAINING-1) {
             char name2[256];
             sprintf(name2, "dir%04d", i+1);
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, name2) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
@@ -3586,6 +3935,7 @@ code = '''
         sprintf(name2, "dir%04d", sim[j]);
         assert(strcmp(info.name, name2) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     lfsr_dir_t dir;
@@ -3594,15 +3944,18 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t j = 0; j < sim_size; j++) {
         char name[256];
         sprintf(name, "dir%04d", sim[j]);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -3650,6 +4003,7 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // and with dir_read
     lfsr_dir_t dir;
@@ -3657,12 +4011,15 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -3682,18 +4039,22 @@ code = '''
     lfsr_stat(&lfs, "banana", &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // and with dir_read
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -3732,6 +4093,7 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // and with dir_read
     lfsr_dir_t dir;
@@ -3739,15 +4101,19 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -3767,18 +4133,22 @@ code = '''
     lfsr_stat(&lfs, "banana", &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // and with dir_read
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -3815,6 +4185,7 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // and with dir_read
     lfsr_dir_t dir;
@@ -3822,12 +4193,15 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -3846,18 +4220,22 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // and with dir_read
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -3906,18 +4284,22 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_t dir;
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -3962,27 +4344,34 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "banana", &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "banana/cat", &info) => 0;
     assert(strcmp(info.name, "cat") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_t dir;
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -3990,12 +4379,15 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "cat") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -4030,18 +4422,22 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     if (a_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "ardvark") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (b_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "banana") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -4070,18 +4466,22 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // and with dir_read
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -4101,18 +4501,22 @@ code = '''
     lfsr_stat(&lfs, "banana", &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // and with dir_read
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -4155,18 +4559,22 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_t dir;
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -4211,38 +4619,46 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     if (a_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "ardvark") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (b_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "banana") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (c_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "cat") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (d_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "disco") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (e_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "eggplant") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (f_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "fish") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -4283,29 +4699,37 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "banana", &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "cat", &info) => 0;
     assert(strcmp(info.name, "cat") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "cat") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -4324,29 +4748,37 @@ code = '''
     lfsr_stat(&lfs, "banana", &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "cat", &info) => 0;
     assert(strcmp(info.name, "cat") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "disco", &info) => 0;
     assert(strcmp(info.name, "disco") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "cat") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "disco") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -4365,29 +4797,37 @@ code = '''
     lfsr_stat(&lfs, "cat", &info) => 0;
     assert(strcmp(info.name, "cat") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "disco", &info) => 0;
     assert(strcmp(info.name, "disco") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "eggplant", &info) => 0;
     assert(strcmp(info.name, "eggplant") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "cat") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "disco") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "eggplant") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -4406,29 +4846,37 @@ code = '''
     lfsr_stat(&lfs, "disco", &info) => 0;
     assert(strcmp(info.name, "disco") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "eggplant", &info) => 0;
     assert(strcmp(info.name, "eggplant") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "fish", &info) => 0;
     assert(strcmp(info.name, "fish") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "disco") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "eggplant") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "fish") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -4482,18 +4930,22 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     if (a_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "ardvark") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     if (d_exists) {
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "disco") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -4505,13 +4957,16 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         if (b_exists) {
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, "banana") == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
@@ -4524,13 +4979,16 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         if (c_exists) {
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, "cat") == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
@@ -4543,18 +5001,22 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         if (db_exists) {
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, "banana") == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         if (e_exists) {
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, "eggplant") == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
@@ -4567,18 +5029,22 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         if (dec_exists) {
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, "cat") == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         if (f_exists) {
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, "fish") == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
@@ -4629,23 +5095,29 @@ code = '''
     lfsr_stat(&lfs, "ardvark", &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "ardvark/banana", &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "ardvark/banana/cat", &info) => 0;
     assert(strcmp(info.name, "cat") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -4653,12 +5125,15 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -4666,12 +5141,15 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "cat") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -4690,23 +5168,29 @@ code = '''
     lfsr_stat(&lfs, "disco", &info) => 0;
     assert(strcmp(info.name, "disco") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "disco/banana", &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "disco/banana/cat", &info) => 0;
     assert(strcmp(info.name, "cat") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "disco") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -4714,12 +5198,15 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "banana") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -4727,12 +5214,15 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "cat") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -4751,23 +5241,29 @@ code = '''
     lfsr_stat(&lfs, "disco", &info) => 0;
     assert(strcmp(info.name, "disco") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "disco/eggplant", &info) => 0;
     assert(strcmp(info.name, "eggplant") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "disco/eggplant/cat", &info) => 0;
     assert(strcmp(info.name, "cat") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "disco") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -4775,12 +5271,15 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "eggplant") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -4788,12 +5287,15 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "cat") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -4812,23 +5314,29 @@ code = '''
     lfsr_stat(&lfs, "disco", &info) => 0;
     assert(strcmp(info.name, "disco") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "disco/eggplant", &info) => 0;
     assert(strcmp(info.name, "eggplant") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_stat(&lfs, "disco/eggplant/fish", &info) => 0;
     assert(strcmp(info.name, "fish") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "disco") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -4836,12 +5344,15 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "eggplant") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -4849,12 +5360,15 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "fish") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -4905,6 +5419,7 @@ code = '''
             lfsr_stat(&lfs, name, &info) => 0;
             assert(strcmp(info.name, name) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
 
         lfsr_dir_t dir;
@@ -4913,15 +5428,18 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         for (lfs_size_t i = 0; i < N; i++) {
             char name[256];
             sprintf(name, "dir%04d", i);
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, name) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
@@ -4953,6 +5471,7 @@ code = '''
         lfsr_stat(&lfs, name, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     lfsr_dir_t dir;
@@ -4960,15 +5479,18 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         sprintf(name, "%smved%04d", (BEFORE ? "0" : ""), i);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -5020,6 +5542,7 @@ code = '''
             lfsr_stat(&lfs, name, &info) => 0;
             assert(strcmp(info.name, name) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
 
         lfsr_dir_t dir;
@@ -5028,15 +5551,18 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         for (lfs_size_t i = 0; i < N; i++) {
             char name[256];
             sprintf(name, "dir%04d", i);
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, name) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
@@ -5068,6 +5594,7 @@ code = '''
         lfsr_stat(&lfs, name, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     lfsr_dir_t dir;
@@ -5075,15 +5602,18 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         sprintf(name, "%smved%04d", (BEFORE ? "0" : ""), i);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -5142,6 +5672,7 @@ code = '''
             lfsr_stat(&lfs, name, &info) => 0;
             assert(strcmp(info.name, name) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
 
             for (lfs_size_t j = 0; j < N; j++) {
                 char name[256];
@@ -5151,6 +5682,7 @@ code = '''
                 sprintf(name, "child%04d", j);
                 assert(strcmp(info.name, name) == 0);
                 assert(info.type == LFS_TYPE_DIR);
+                assert(info.size == 0);
             }
         }
 
@@ -5160,15 +5692,18 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         for (lfs_size_t i = 0; i < N; i++) {
             char name[256];
             sprintf(name, "dir%04d", i);
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, name) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
@@ -5180,15 +5715,18 @@ code = '''
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, ".") == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, "..") == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
             for (lfs_size_t j = 0; j < N; j++) {
                 char name[256];
                 sprintf(name, "child%04d", j);
                 lfsr_dir_read(&lfs, &dir, &info) => 0;
                 assert(strcmp(info.name, name) == 0);
                 assert(info.type == LFS_TYPE_DIR);
+                assert(info.size == 0);
             }
             lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
             lfsr_dir_close(&lfs, &dir) => 0;
@@ -5241,6 +5779,7 @@ code = '''
         lfsr_stat(&lfs, name, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
 
         for (lfs_size_t j = 0; j < N; j++) {
             char name[256];
@@ -5251,6 +5790,7 @@ code = '''
             sprintf(name, "%schmved%04d", (BEFORE ? "0" : ""), j);
             assert(strcmp(info.name, name) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
     }
 
@@ -5259,15 +5799,18 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         sprintf(name, "%smved%04d", (BEFORE ? "0" : ""), i);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -5279,15 +5822,18 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         for (lfs_size_t j = 0; j < N; j++) {
             char name[256];
             sprintf(name, "%schmved%04d", (BEFORE ? "0" : ""), j);
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, name) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
@@ -5354,6 +5900,7 @@ code = '''
             lfsr_stat(&lfs, name, &info) => 0;
             assert(strcmp(info.name, name) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
 
             for (lfs_size_t j = 0; j < N; j++) {
                 char name[256];
@@ -5363,6 +5910,7 @@ code = '''
                 sprintf(name, "child%04d", j);
                 assert(strcmp(info.name, name) == 0);
                 assert(info.type == LFS_TYPE_DIR);
+                assert(info.size == 0);
 
                 for (lfs_size_t k = 0; k < N; k++) {
                     char name[256];
@@ -5372,6 +5920,7 @@ code = '''
                     sprintf(name, "grandchild%04d", k);
                     assert(strcmp(info.name, name) == 0);
                     assert(info.type == LFS_TYPE_DIR);
+                    assert(info.size == 0);
                 }
             }
         }
@@ -5382,15 +5931,18 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         for (lfs_size_t i = 0; i < N; i++) {
             char name[256];
             sprintf(name, "dir%04d", i);
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, name) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
@@ -5402,15 +5954,18 @@ code = '''
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, ".") == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, "..") == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
             for (lfs_size_t j = 0; j < N; j++) {
                 char name[256];
                 sprintf(name, "child%04d", j);
                 lfsr_dir_read(&lfs, &dir, &info) => 0;
                 assert(strcmp(info.name, name) == 0);
                 assert(info.type == LFS_TYPE_DIR);
+                assert(info.size == 0);
             }
             lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
             lfsr_dir_close(&lfs, &dir) => 0;
@@ -5422,15 +5977,18 @@ code = '''
                 lfsr_dir_read(&lfs, &dir, &info) => 0;
                 assert(strcmp(info.name, ".") == 0);
                 assert(info.type == LFS_TYPE_DIR);
+                assert(info.size == 0);
                 lfsr_dir_read(&lfs, &dir, &info) => 0;
                 assert(strcmp(info.name, "..") == 0);
                 assert(info.type == LFS_TYPE_DIR);
+                assert(info.size == 0);
                 for (lfs_size_t k = 0; k < N; k++) {
                     char name[256];
                     sprintf(name, "grandchild%04d", k);
                     lfsr_dir_read(&lfs, &dir, &info) => 0;
                     assert(strcmp(info.name, name) == 0);
                     assert(info.type == LFS_TYPE_DIR);
+                    assert(info.size == 0);
                 }
                 lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
                 lfsr_dir_close(&lfs, &dir) => 0;
@@ -5506,6 +6064,7 @@ code = '''
         lfsr_stat(&lfs, name, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
 
         for (lfs_size_t j = 0; j < N; j++) {
             char name[256];
@@ -5517,6 +6076,7 @@ code = '''
             sprintf(name, "%schmved%04d", (BEFORE ? "0" : ""), j);
             assert(strcmp(info.name, name) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
 
             for (lfs_size_t k = 0; k < N; k++) {
                 char name[256];
@@ -5529,6 +6089,7 @@ code = '''
                 sprintf(name, "%sgrmved%04d", (BEFORE ? "0" : ""), k);
                 assert(strcmp(info.name, name) == 0);
                 assert(info.type == LFS_TYPE_DIR);
+                assert(info.size == 0);
             }
         }
     }
@@ -5538,15 +6099,18 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         sprintf(name, "%smved%04d", (BEFORE ? "0" : ""), i);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -5558,15 +6122,18 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         for (lfs_size_t j = 0; j < N; j++) {
             char name[256];
             sprintf(name, "%schmved%04d", (BEFORE ? "0" : ""), j);
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, name) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
@@ -5580,15 +6147,18 @@ code = '''
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, ".") == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, "..") == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
             for (lfs_size_t k = 0; k < N; k++) {
                 char name[256];
                 sprintf(name, "%sgrmved%04d", (BEFORE ? "0" : ""), k);
                 lfsr_dir_read(&lfs, &dir, &info) => 0;
                 assert(strcmp(info.name, name) == 0);
                 assert(info.type == LFS_TYPE_DIR);
+                assert(info.size == 0);
             }
             lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
             lfsr_dir_close(&lfs, &dir) => 0;
@@ -5645,6 +6215,7 @@ code = '''
             sprintf(name2, "dir%04d", i);
             assert(strcmp(info.name, name2) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
 
         memset(name, 0, sizeof(name));
@@ -5656,15 +6227,18 @@ code = '''
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, ".") == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, "..") == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
             if (i < N-1) {
                 char name2[256];
                 sprintf(name2, "dir%04d", i+1);
                 lfsr_dir_read(&lfs, &dir, &info) => 0;
                 assert(strcmp(info.name, name2) == 0);
                 assert(info.type == LFS_TYPE_DIR);
+                assert(info.size == 0);
             }
             lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
             lfsr_dir_close(&lfs, &dir) => 0;
@@ -5706,6 +6280,7 @@ code = '''
         sprintf(name2, "%smved%04d", (BEFORE ? "0" : ""), i);
         assert(strcmp(info.name, name2) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     memset(name, 0, sizeof(name));
@@ -5717,15 +6292,18 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         if (i < N-1) {
             char name2[256];
             sprintf(name2, "%smved%04d", (BEFORE ? "0" : ""), i+1);
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, name2) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
@@ -5848,6 +6426,7 @@ code = '''
         sprintf(name2, "dir%04d", sim[j]);
         assert(strcmp(info.name, name2) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     lfsr_dir_t dir;
@@ -5856,15 +6435,18 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t j = 0; j < sim_size; j++) {
         char name[256];
         sprintf(name, "dir%04d", sim[j]);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -6003,6 +6585,7 @@ code = '''
         sprintf(name2, "dir%04d", sim[j]);
         assert(strcmp(info.name, name2) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     lfsr_dir_t dir;
@@ -6011,15 +6594,18 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t j = 0; j < sim_size; j++) {
         char name[256];
         sprintf(name, "dir%04d", sim[j]);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
diff --git a/tests/test_dread.toml b/tests/test_dread.toml
index 2d98ddba..9e886c7c 100644
--- a/tests/test_dread.toml
+++ b/tests/test_dread.toml
@@ -38,10 +38,12 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_tell(&lfs, &dir) => 1;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < N; i++) {
         lfsr_dir_tell(&lfs, &dir) => 2 + i;
         char name[256];
@@ -49,6 +51,7 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_tell(&lfs, &dir) => 2 + N;
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
@@ -86,10 +89,12 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_tell(&lfs, &dir) => 1;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < N; i++) {
         lfsr_dir_tell(&lfs, &dir) => 2 + i;
         char name[256];
@@ -97,6 +102,7 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_tell(&lfs, &dir) => 2 + N;
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
@@ -108,10 +114,12 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_tell(&lfs, &dir) => 1;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < N; i++) {
         lfsr_dir_tell(&lfs, &dir) => 2 + i;
         char name[256];
@@ -119,6 +127,7 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_tell(&lfs, &dir) => 2 + N;
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
@@ -157,10 +166,12 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_tell(&lfs, &dir) => 1;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < N; i++) {
         lfsr_dir_tell(&lfs, &dir) => 2 + i;
         char name[256];
@@ -168,6 +179,7 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_tell(&lfs, &dir) => 2 + N;
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
@@ -178,10 +190,12 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_seek(&lfs, &dir, 1) => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < N; i++) {
         lfsr_dir_seek(&lfs, &dir, 2 + i) => 0;
         char name[256];
@@ -189,6 +203,7 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_seek(&lfs, &dir, 2 + N) => 0;
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
@@ -242,12 +257,15 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_tell(&lfs, &dir) => 3;
 
@@ -275,12 +293,15 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ardvark") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
 
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -341,9 +362,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // read until I
     for (lfs_size_t i = 0; i < I; i++) {
@@ -352,6 +375,7 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     // since modification is unrelated, the dir position should go unchanged
@@ -402,6 +426,7 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
@@ -472,9 +497,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // read until I
     for (lfs_size_t i = 0; i < I; i++) {
@@ -483,6 +510,7 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     // since modification is unrelated, the dir position should go unchanged
@@ -533,6 +561,7 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
@@ -603,9 +632,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // read until I
     for (lfs_size_t i = 0; i < I; i++) {
@@ -614,6 +645,7 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     // since modification is unrelated, the dir position should go unchanged
@@ -668,6 +700,7 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
@@ -728,9 +761,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // read until I
     for (lfs_size_t i = 0; i < I; i++) {
@@ -739,6 +774,7 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     // make a dir at J
@@ -764,6 +800,7 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
@@ -823,9 +860,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // read until I
     for (lfs_size_t i = 0; i < I; i++) {
@@ -834,6 +873,7 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     // remove the dir at J
@@ -863,6 +903,7 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
@@ -930,9 +971,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // read until I
     for (lfs_size_t i = 0; i < I; i++) {
@@ -941,6 +984,7 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     // rename the dir at J
@@ -977,6 +1021,7 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     int err = lfsr_dir_read(&lfs, &dir, &info);
@@ -1042,9 +1087,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // read until I
     for (lfs_size_t i = 0; i < I; i++) {
@@ -1053,6 +1100,7 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     // make a dir at J
@@ -1086,6 +1134,7 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
@@ -1149,9 +1198,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // read until I
     for (lfs_size_t i = 0; i < I; i++) {
@@ -1160,6 +1211,7 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     // remove the dir at J
@@ -1193,6 +1245,7 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
@@ -1264,9 +1317,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // read until I
     for (lfs_size_t i = 0; i < I; i++) {
@@ -1275,6 +1330,7 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     // rename the dir at J
@@ -1321,6 +1377,7 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     int err = lfsr_dir_read(&lfs, &dir, &info);
@@ -1375,9 +1432,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // read until I
     for (lfs_size_t i = 0; i < I; i++) {
@@ -1386,6 +1445,7 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     // remove the directory
@@ -1466,6 +1526,7 @@ code = '''
         sprintf(name2, "dir%04d", i);
         assert(strcmp(info.name, name2) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     lfsr_dir_t dir;
@@ -1474,15 +1535,18 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         sprintf(name, "dir%04d", i);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
@@ -1492,15 +1556,18 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         sprintf(name, "dir%04d", i);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
 
         char path[1024];
         sprintf(path, "%s/%s", (PARENT ? "pricklypear" : ""), info.name);
@@ -1532,9 +1599,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -1609,6 +1678,7 @@ code = '''
             sprintf(name2, "dir%04d", i);
             assert(strcmp(info.name, name2) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
 
         lfsr_dir_t dir;
@@ -1617,15 +1687,18 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         for (lfs_size_t i = 0; i < N; i++) {
             char name[256];
             sprintf(name, "dir%04d", i);
             lfsr_dir_read(&lfs, &dir, &info) => 0;
             assert(strcmp(info.name, name) == 0);
             assert(info.type == LFS_TYPE_DIR);
+            assert(info.size == 0);
         }
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
@@ -1637,9 +1710,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0;; i++) {
         int err = lfsr_dir_read(&lfs, &dir, &info);
         assert(!err || err == LFS_ERR_NOENT);
@@ -1653,6 +1728,7 @@ code = '''
         }
         assert(i < 2*N);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
 
         char old_path[1024];
         sprintf(old_path, "%s/%s", (PARENT ? "pricklypear" : ""), info.name);
@@ -1697,6 +1773,7 @@ code = '''
         sprintf(name2, "%smved%04d", (BEFORE ? "0" : ""), i);
         assert(strcmp(info.name, name2) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
 
     lfsr_dir_open(&lfs, &dir,
@@ -1706,15 +1783,18 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < N; i++) {
         char name[256];
         sprintf(name, "%smved%04d", (BEFORE ? "0" : ""), i);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, name) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
diff --git a/tests/test_files.toml b/tests/test_files.toml
index bb821510..c57f86eb 100644
--- a/tests/test_files.toml
+++ b/tests/test_files.toml
@@ -34,9 +34,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -92,9 +94,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -161,9 +165,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -231,9 +237,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -308,9 +316,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -318,6 +328,7 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "not_hello") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -381,6 +392,7 @@ code = '''
     lfsr_stat(&lfs, "hello", &info) => 0;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // and with dir read
     lfsr_dir_t dir;
@@ -388,12 +400,15 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "not_hello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -459,6 +474,7 @@ code = '''
     lfsr_stat(&lfs, "/", &info) => 0;
     assert(strcmp(info.name, "/") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // and with dir read
     lfsr_dir_t dir;
@@ -466,9 +482,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "not_hello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -534,6 +552,7 @@ code = '''
     lfsr_stat(&lfs, "/", &info) => 0;
     assert(strcmp(info.name, "/") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // and with dir read
     lfsr_dir_t dir;
@@ -541,9 +560,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "not_hello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -620,9 +641,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -827,9 +850,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t j = 0; j < sim_size; j++) {
         char name[256];
         sprintf(name, "amethyst%04d", sim[j]);
@@ -925,9 +950,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -1196,9 +1223,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t j = 0; j < sim_size; j++) {
         char name[256];
         sprintf(name, "amethyst%04d", sim[j]);
@@ -1300,15 +1329,18 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < N; i++) {
         char path[256];
         sprintf(path, "basalt%04d", i);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, path) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "calcite") == 0);
@@ -1406,15 +1438,18 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t i = 0; i < N; i++) {
         char path[256];
         sprintf(path, "basalt%04d", i);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, path) == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     }
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "calcite") == 0);
@@ -1494,9 +1529,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "amethyst") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -1574,6 +1611,7 @@ code = '''
     lfsr_stat(&lfs, "basalt", &info) => 0;
     assert(strcmp(info.name, "basalt") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // and with dir read
     lfsr_dir_t dir;
@@ -1581,9 +1619,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "amethyst") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -1591,6 +1631,7 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "basalt") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -1664,6 +1705,7 @@ code = '''
     lfsr_stat(&lfs, "basalt", &info) => 0;
     assert(strcmp(info.name, "basalt") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
 
     // and with dir read
     lfsr_dir_t dir;
@@ -1671,9 +1713,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "amethyst") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -1681,6 +1725,7 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "basalt") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -1755,9 +1800,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "amethyst") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -1836,9 +1883,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "amethyst") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -2147,9 +2196,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t j = 0; j < sim_size; j++) {
         char name[256];
         sprintf(name, "amethyst%04d", sim[j]);
@@ -2356,9 +2407,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     for (lfs_size_t j = 0; j < sim_size; j++) {
         char name[256];
         sprintf(name, "amethyst%04d", sim[j]);
diff --git a/tests/test_forphan.toml b/tests/test_forphan.toml
index 51a91dd1..ca647c58 100644
--- a/tests/test_forphan.toml
+++ b/tests/test_forphan.toml
@@ -36,9 +36,11 @@ code = '''
     lfsr_dir_read(&lfs_, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs_, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs_, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs_, &dir) => 0;
     // via open
@@ -64,9 +66,11 @@ code = '''
         lfsr_dir_read(&lfs_, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs_, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs_, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs_, &dir) => 0;
         // via open
@@ -90,9 +94,11 @@ code = '''
         lfsr_dir_read(&lfs_, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs_, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs_, &dir, &info) => 0;
         assert(strcmp(info.name, "gello") == 0);
         assert(info.type == LFS_TYPE_REG);
@@ -130,9 +136,11 @@ code = '''
     lfsr_dir_read(&lfs_, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs_, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs_, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -168,9 +176,11 @@ code = '''
     lfsr_dir_read(&lfs_, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs_, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs_, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -388,9 +398,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
     // rdonly rejected
@@ -417,9 +429,11 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
         // rdonly rejected
@@ -449,9 +463,11 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "gello") == 0);
         assert(info.type == LFS_TYPE_REG);
@@ -500,9 +516,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -574,9 +592,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
     // rdonly rejected
@@ -603,9 +623,11 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
         // rdonly rejected
@@ -630,9 +652,11 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "gello") == 0);
         assert(info.type == LFS_TYPE_REG);
@@ -681,9 +705,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -768,9 +794,11 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
         // rdonly rejected
@@ -800,9 +828,11 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
         // rdonly rejected
@@ -830,9 +860,11 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "gello") == 0);
         assert(info.type == LFS_TYPE_REG);
@@ -884,9 +916,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -935,9 +969,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -986,9 +1022,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -1065,9 +1103,11 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
         // rdonly rejected
@@ -1091,9 +1131,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
     // rdonly rejected
@@ -1115,9 +1157,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
     // rdonly rejected
@@ -1179,9 +1223,11 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
         // rdonly rejected
@@ -1211,9 +1257,11 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfsr_dir_close(&lfs, &dir) => 0;
         // rdonly rejected
@@ -1241,9 +1289,11 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "gello") == 0);
         assert(info.type == LFS_TYPE_REG);
@@ -1300,9 +1350,11 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "gello") == 0);
         assert(info.type == LFS_TYPE_REG);
@@ -1354,9 +1406,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -1458,9 +1512,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
     // via open
@@ -1554,9 +1610,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -1675,9 +1733,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -1754,18 +1814,22 @@ code = '''
     lfsr_stat(&lfs, "gello", &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     // via readdir
     lfsr_dir_t dir;
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -1835,9 +1899,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -1937,6 +2003,7 @@ code = '''
     assert(strcmp(info.name, "gello") == 0);
     if (DIR) {
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     } else {
         assert(info.type == LFS_TYPE_REG);
         assert(info.size == strlen("hello!"));
@@ -1948,13 +2015,16 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     if (DIR) {
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     } else {
         assert(info.type == LFS_TYPE_REG);
         assert(info.size == strlen("hello!"));
@@ -2053,9 +2123,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -2108,9 +2180,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
     // rdonly rejected
@@ -2147,9 +2221,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
     // rdonly rejected
@@ -2169,9 +2245,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
     // rdonly rejected
@@ -2229,9 +2307,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
     // rdonly rejected
@@ -2268,9 +2348,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
     // rdonly rejected
@@ -2290,9 +2372,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
     // rdonly rejected
@@ -2366,9 +2450,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
     // rdonly rejected
@@ -2394,9 +2480,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -2458,9 +2546,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -2496,9 +2586,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -2584,9 +2676,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
     // rdonly rejected
@@ -2612,9 +2706,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -2676,9 +2772,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -2714,9 +2812,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -2823,9 +2923,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
     // rdonly rejected
@@ -2852,9 +2954,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -2929,9 +3033,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -2967,9 +3073,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -3076,9 +3184,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
     // rdonly rejected
@@ -3105,9 +3215,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -3182,9 +3294,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -3220,9 +3334,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -3326,9 +3442,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -3417,18 +3535,22 @@ code = '''
     lfsr_stat(&lfs, "gello", &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     // via readdir
     lfsr_dir_t dir;
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -3510,9 +3632,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -3623,6 +3747,7 @@ code = '''
     assert(strcmp(info.name, "gello") == 0);
     if (DIR) {
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     } else {
         assert(info.type == LFS_TYPE_REG);
         assert(info.size == strlen("hello!"));
@@ -3634,13 +3759,16 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     if (DIR) {
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     } else {
         assert(info.type == LFS_TYPE_REG);
         assert(info.size == strlen("hello!"));
@@ -3751,9 +3879,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -3815,18 +3945,22 @@ code = '''
     lfsr_stat(&lfs, "gello", &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     // via readdir
     lfsr_dir_t dir;
     lfsr_dir_open(&lfs, &dir, "/") => 0;
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -3928,6 +4062,7 @@ code = '''
     assert(strcmp(info.name, "gello") == 0);
     if (DIR) {
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     } else {
         assert(info.type == LFS_TYPE_REG);
         assert(info.size == strlen("hello!"));
@@ -3939,13 +4074,16 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     if (DIR) {
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     } else {
         assert(info.type == LFS_TYPE_REG);
         assert(info.size == strlen("hello!"));
@@ -4068,9 +4206,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfsr_dir_close(&lfs, &dir) => 0;
 
@@ -4193,6 +4333,7 @@ code = '''
     assert(strcmp(info.name, "gello") == 0);
     if (DIR) {
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     } else {
         assert(info.type == LFS_TYPE_REG);
         assert(info.size == strlen("hello!"));
@@ -4204,13 +4345,16 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     if (DIR) {
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     } else {
         assert(info.type == LFS_TYPE_REG);
         assert(info.size == strlen("hello!"));
@@ -4330,9 +4474,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -4393,9 +4539,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -4443,9 +4591,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -4561,9 +4711,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -4618,9 +4770,11 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "gello") == 0);
         assert(info.type == LFS_TYPE_REG);
@@ -4681,9 +4835,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -4731,9 +4887,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -4864,9 +5022,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -4942,9 +5102,11 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "gello") == 0);
         assert(info.type == LFS_TYPE_REG);
@@ -5018,9 +5180,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -5068,9 +5232,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -5201,9 +5367,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -5271,9 +5439,11 @@ code = '''
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
         lfsr_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "gello") == 0);
         assert(info.type == LFS_TYPE_REG);
@@ -5347,9 +5517,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -5397,9 +5569,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -5550,9 +5724,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -5708,6 +5884,7 @@ code = '''
     assert(strcmp(info.name, "gello") == 0);
     if (DIR) {
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     } else {
         assert(info.type == LFS_TYPE_REG);
         assert(info.size == strlen("hello!"));
@@ -5719,13 +5896,16 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "gello") == 0);
     if (DIR) {
         assert(info.type == LFS_TYPE_DIR);
+        assert(info.size == 0);
     } else {
         assert(info.type == LFS_TYPE_REG);
         assert(info.size == strlen("hello!"));
diff --git a/tests/test_fwrite.toml b/tests/test_fwrite.toml
index 5988e76b..7407f0e1 100644
--- a/tests/test_fwrite.toml
+++ b/tests/test_fwrite.toml
@@ -85,9 +85,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -262,9 +264,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -441,9 +445,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -552,9 +558,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -692,9 +700,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -806,9 +816,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -954,9 +966,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -1079,9 +1093,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -1266,9 +1282,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -1454,9 +1472,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -1592,9 +1612,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -1737,9 +1759,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -1954,9 +1978,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -2116,9 +2142,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -2214,9 +2242,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
@@ -2416,9 +2446,11 @@ code = '''
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
+    assert(info.size == 0);
     lfsr_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);