Moved lfs_mdir_isopen behind LFS_NO_ASSERT

lfs_mdir_isopen goes unused if asserts are disabled, and this caused an
"unused function" warning on Clang (curiously not on GCC since the
function was static inline, commonly used for header-only functions).

Also removed "inline" from the lfs_mdir_* functions as these involve
linked-list operations and really shouldn't be inlined. And since they
are static, inlining should occur automatically if there is a benefit.

Found by dpgeorge

lfs.c

@@ -425,7 +425,8 @@ static inline void lfs_superblock_tole32(lfs_superblock_t *superblock) {
     superblock->attr_max    = lfs_tole32(superblock->attr_max);
 }
 
-static inline bool lfs_mlist_isopen(struct lfs_mlist *head,
+#ifndef LFS_NO_ASSERT
+static bool lfs_mlist_isopen(struct lfs_mlist *head,
         struct lfs_mlist *node) {
     for (struct lfs_mlist **p = &head; *p; p = &(*p)->next) {
         if (*p == (struct lfs_mlist*)node) {
@@ -435,8 +436,9 @@ static inline bool lfs_mlist_isopen(struct lfs_mlist *head,
 
     return false;
 }
+#endif
 
-static inline void lfs_mlist_remove(lfs_t *lfs, struct lfs_mlist *mlist) {
+static void lfs_mlist_remove(lfs_t *lfs, struct lfs_mlist *mlist) {
     for (struct lfs_mlist **p = &lfs->mlist; *p; p = &(*p)->next) {
         if (*p == mlist) {
             *p = (*p)->next;
@@ -445,7 +447,7 @@ static inline void lfs_mlist_remove(lfs_t *lfs, struct lfs_mlist *mlist) {
     }
 }
 
-static inline void lfs_mlist_append(lfs_t *lfs, struct lfs_mlist *mlist) {
+static void lfs_mlist_append(lfs_t *lfs, struct lfs_mlist *mlist) {
     mlist->next = lfs->mlist;
     lfs->mlist = mlist;
 }
@@ -2160,19 +2162,18 @@ static int lfs_dir_rawread(lfs_t *lfs, lfs_dir_t *dir, struct lfs_info *info) {
         info->type = LFS_TYPE_DIR;
         strcpy(info->name, ".");
         dir->pos += 1;
-        return 0;
+        return true;
     } else if (dir->pos == 1) {
         info->type = LFS_TYPE_DIR;
         strcpy(info->name, "..");
         dir->pos += 1;
-        return 0;
+        return true;
     }
 
     while (true) {
         if (dir->id == dir->m.count) {
             if (!dir->m.split) {
-                // reached end of traversal
-                return LFS_ERR_NOENT;
+                return false;
             }
 
             int err = lfs_dir_fetch(lfs, &dir->m, dir->m.tail);
@@ -2195,7 +2196,7 @@ static int lfs_dir_rawread(lfs_t *lfs, lfs_dir_t *dir, struct lfs_info *info) {
     }
 
     dir->pos += 1;
-    return 0;
+    return true;
 }
 
 static int lfs_dir_rawseek(lfs_t *lfs, lfs_dir_t *dir, lfs_off_t off) {

lfs.h

@@ -619,9 +619,8 @@ int lfs_dir_close(lfs_t *lfs, lfs_dir_t *dir);
 // Read an entry in the directory
 //
 // Fills out the info structure, based on the specified file or directory.
-//
-// Returns 0 on success, LFS_ERR_NOENT if there are no more directry entries,
-// or another negative error code on failure.
+// Returns a positive value on success, 0 at the end of directory,
+// or a negative error code on failure.
 int lfs_dir_read(lfs_t *lfs, lfs_dir_t *dir, struct lfs_info *info);
 
 // Change the position of the directory

tests/test_dirs.toml

@@ -3,13 +3,13 @@ code = '''
     lfs_format(&lfs, &cfg) => 0;
     lfs_mount(&lfs, &cfg) => 0;
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs) => 0;
 '''
@@ -28,19 +28,19 @@ code = '''
 
     lfs_mount(&lfs, &cfg) => 0;
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
     for (int i = 0; i < N; i++) {
         sprintf(path, "dir%03d", i);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(info.type == LFS_TYPE_DIR);
         assert(strcmp(info.name, path) == 0);
     }
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs) => 0;
 '''
@@ -59,19 +59,19 @@ code = '''
 
     lfs_mount(&lfs, &cfg) => 0;
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
     for (int i = 0; i < N; i++) {
         sprintf(path, "removeme%03d", i);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(info.type == LFS_TYPE_DIR);
         assert(strcmp(info.name, path) == 0);
     }
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs);
 
@@ -84,13 +84,13 @@ code = '''
 
     lfs_mount(&lfs, &cfg) => 0;
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs) => 0;
 '''
@@ -109,19 +109,19 @@ code = '''
 
     lfs_mount(&lfs, &cfg) => 0;
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
     for (int i = 0; i < N; i++) {
         sprintf(path, "test%03d", i);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(info.type == LFS_TYPE_DIR);
         assert(strcmp(info.name, path) == 0);
     }
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs);
 
@@ -137,19 +137,19 @@ code = '''
 
     lfs_mount(&lfs, &cfg) => 0;
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
     for (int i = 0; i < N; i++) {
         sprintf(path, "tedd%03d", i);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(info.type == LFS_TYPE_DIR);
         assert(strcmp(info.name, path) == 0);
     }
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs);
 '''
@@ -177,19 +177,19 @@ code = '''
     }
 
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
     for (int i = 0; i < N; i++) {
         sprintf(path, "hi%03d", i);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(info.type == LFS_TYPE_DIR);
         assert(strcmp(info.name, path) == 0);
     }
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     for (int i = 0; i < N; i++) {
@@ -202,19 +202,19 @@ code = '''
     }
 
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
     for (int i = 0; i < N; i++) {
         sprintf(path, "hello%03d", i);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(info.type == LFS_TYPE_DIR);
         assert(strcmp(info.name, path) == 0);
     }
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     for (int i = 0; i < N; i++) {
@@ -223,13 +223,13 @@ code = '''
     }
 
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs) => 0;
 '''
@@ -250,19 +250,19 @@ code = '''
 
     lfs_mount(&lfs, &cfg) => 0;
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
     for (int i = 0; i < N; i++) {
         sprintf(path, "file%03d", i);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(info.type == LFS_TYPE_REG);
         assert(strcmp(info.name, path) == 0);
     }
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs);
 '''
@@ -283,19 +283,19 @@ code = '''
 
     lfs_mount(&lfs, &cfg) => 0;
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
     for (int i = 0; i < N; i++) {
         sprintf(path, "removeme%03d", i);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(info.type == LFS_TYPE_REG);
         assert(strcmp(info.name, path) == 0);
     }
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs);
 
@@ -308,13 +308,13 @@ code = '''
 
     lfs_mount(&lfs, &cfg) => 0;
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs) => 0;
 '''
@@ -335,19 +335,19 @@ code = '''
 
     lfs_mount(&lfs, &cfg) => 0;
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
     for (int i = 0; i < N; i++) {
         sprintf(path, "test%03d", i);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(info.type == LFS_TYPE_REG);
         assert(strcmp(info.name, path) == 0);
     }
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs);
 
@@ -363,19 +363,19 @@ code = '''
 
     lfs_mount(&lfs, &cfg) => 0;
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
     for (int i = 0; i < N; i++) {
         sprintf(path, "tedd%03d", i);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(info.type == LFS_TYPE_REG);
         assert(strcmp(info.name, path) == 0);
     }
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs);
 '''
@@ -403,19 +403,19 @@ code = '''
     }
 
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
     for (int i = 0; i < N; i++) {
         sprintf(path, "hi%03d", i);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(info.type == LFS_TYPE_REG);
         assert(strcmp(info.name, path) == 0);
     }
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     for (int i = 0; i < N; i++) {
@@ -428,19 +428,19 @@ code = '''
     }
 
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
     for (int i = 0; i < N; i++) {
         sprintf(path, "hello%03d", i);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(info.type == LFS_TYPE_REG);
         assert(strcmp(info.name, path) == 0);
     }
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     for (int i = 0; i < N; i++) {
@@ -449,13 +449,13 @@ code = '''
     }
 
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs) => 0;
 '''
@@ -478,22 +478,22 @@ code = '''
 
     lfs_mount(&lfs, &cfg) => 0;
     lfs_dir_open(&lfs, &dir, "potato") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "baked") == 0);
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "fried") == 0);
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "sweet") == 0);
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs) => 0;
 
@@ -538,22 +538,22 @@ code = '''
 
     lfs_mount(&lfs, &cfg) => 0;
     lfs_dir_open(&lfs, &dir, "hotpotato") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "baked") == 0);
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "fried") == 0);
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "sweet") == 0);
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs) => 0;
     
@@ -570,16 +570,16 @@ code = '''
 
     lfs_mount(&lfs, &cfg) => 0;
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "burito") == 0);
     info.type => LFS_TYPE_REG;
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs) => 0;
 '''
@@ -595,19 +595,19 @@ code = '''
         lfs_mkdir(&lfs, path) => 0;
     }
     lfs_dir_open(&lfs, &dir, "prickly-pear") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
     for (int i = 0; i < N; i++) {
         sprintf(path, "cactus%03d", i);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(info.type == LFS_TYPE_DIR);
         assert(strcmp(info.name, path) == 0);
     }
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs);
 
@@ -615,21 +615,21 @@ code = '''
     lfs_remove(&lfs, "prickly-pear") => LFS_ERR_NOTEMPTY;
 
     lfs_dir_open(&lfs, &dir, "prickly-pear") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
     for (int i = 0; i < N; i++) {
         sprintf(path, "cactus%03d", i);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(info.type == LFS_TYPE_DIR);
         assert(strcmp(info.name, path) == 0);
         sprintf(path, "prickly-pear/%s", info.name);
         lfs_remove(&lfs, path) => 0;
     }
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_remove(&lfs, "prickly-pear") => 0;
@@ -678,19 +678,19 @@ code = '''
 
     // check that errors did not corrupt directory
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_REG);
     assert(strcmp(info.name, "burito") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "potato") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_unmount(&lfs) => 0;
@@ -698,19 +698,19 @@ code = '''
     // or on disk
     lfs_mount(&lfs, &cfg) => 0;
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_REG);
     assert(strcmp(info.name, "burito") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "potato") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs) => 0;
 '''
@@ -730,17 +730,17 @@ code = '''
     for (int j = 2; j < COUNT; j++) {
         lfs_mount(&lfs, &cfg) => 0;
         lfs_dir_open(&lfs, &dir, "hello") => 0;
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
 
         lfs_soff_t pos;
         for (int i = 0; i < j; i++) {
             sprintf(path, "kitty%03d", i);
-            lfs_dir_read(&lfs, &dir, &info) => 0;
+            lfs_dir_read(&lfs, &dir, &info) => 1;
             assert(strcmp(info.name, path) == 0);
             assert(info.type == LFS_TYPE_DIR);
             pos = lfs_dir_tell(&lfs, &dir);
@@ -749,25 +749,25 @@ code = '''
 
         lfs_dir_seek(&lfs, &dir, pos) => 0;
         sprintf(path, "kitty%03d", j);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(strcmp(info.name, path) == 0);
         assert(info.type == LFS_TYPE_DIR);
 
         lfs_dir_rewind(&lfs, &dir) => 0;
         sprintf(path, "kitty%03d", 0);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(strcmp(info.name, path) == 0);
         assert(info.type == LFS_TYPE_DIR);
 
         lfs_dir_seek(&lfs, &dir, pos) => 0;
         sprintf(path, "kitty%03d", j);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(strcmp(info.name, path) == 0);
         assert(info.type == LFS_TYPE_DIR);
 
@@ -790,17 +790,17 @@ code = '''
     for (int j = 2; j < COUNT; j++) {
         lfs_mount(&lfs, &cfg) => 0;
         lfs_dir_open(&lfs, &dir, "/") => 0;
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
 
         lfs_soff_t pos;
         for (int i = 0; i < j; i++) {
             sprintf(path, "hi%03d", i);
-            lfs_dir_read(&lfs, &dir, &info) => 0;
+            lfs_dir_read(&lfs, &dir, &info) => 1;
             assert(strcmp(info.name, path) == 0);
             assert(info.type == LFS_TYPE_DIR);
             pos = lfs_dir_tell(&lfs, &dir);
@@ -809,25 +809,25 @@ code = '''
 
         lfs_dir_seek(&lfs, &dir, pos) => 0;
         sprintf(path, "hi%03d", j);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(strcmp(info.name, path) == 0);
         assert(info.type == LFS_TYPE_DIR);
 
         lfs_dir_rewind(&lfs, &dir) => 0;
         sprintf(path, "hi%03d", 0);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(strcmp(info.name, path) == 0);
         assert(info.type == LFS_TYPE_DIR);
 
         lfs_dir_seek(&lfs, &dir, pos) => 0;
         sprintf(path, "hi%03d", j);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(strcmp(info.name, path) == 0);
         assert(info.type == LFS_TYPE_DIR);
 

tests/test_interspersed.toml

@@ -24,20 +24,20 @@ code = '''
     }
 
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
     for (int j = 0; j < FILES; j++) {
         sprintf(path, "%c", alphas[j]);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(strcmp(info.name, path) == 0);
         assert(info.type == LFS_TYPE_REG);
         assert(info.size == SIZE);
     }
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     for (int j = 0; j < FILES; j++) {
@@ -89,17 +89,17 @@ code = '''
     lfs_file_close(&lfs, &file);
 
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "zzz") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == FILES);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_file_open(&lfs, &file, "zzz", LFS_O_RDONLY) => 0;
@@ -141,21 +141,21 @@ code = '''
     lfs_file_close(&lfs, &files[2]);
 
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "e") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == SIZE);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "g") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == SIZE);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_file_open(&lfs, &files[0], "e", LFS_O_RDONLY) => 0;
@@ -208,20 +208,20 @@ code = '''
     }
 
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
     for (int j = 0; j < FILES; j++) {
         sprintf(path, "%c", alphas[j]);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         assert(strcmp(info.name, path) == 0);
         assert(info.type == LFS_TYPE_REG);
         assert(info.size == SIZE);
     }
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     for (int j = 0; j < FILES; j++) {

tests/test_move.toml

@@ -19,26 +19,26 @@ code = '''
 
     lfs_mount(&lfs, &cfg) => 0;
     lfs_dir_open(&lfs, &dir, "a") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_dir_open(&lfs, &dir, "c") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 5+8+6);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_file_open(&lfs, &file, "a/hello", LFS_O_RDONLY) => LFS_ERR_NOENT;
@@ -110,26 +110,26 @@ code = '''
 
     lfs_mount(&lfs, &cfg) => 0;
     lfs_dir_open(&lfs, &dir, "a") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_dir_open(&lfs, &dir, "c") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 5+8+6);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_file_open(&lfs, &file, "a/hello", LFS_O_RDONLY) => LFS_ERR_NOENT;
@@ -202,26 +202,26 @@ code = '''
 
     lfs_mount(&lfs, &cfg) => 0;
     lfs_dir_open(&lfs, &dir, "a") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 5+8+6);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_dir_open(&lfs, &dir, "c") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_file_open(&lfs, &file, "a/hello", LFS_O_RDONLY) => 0;
@@ -299,26 +299,26 @@ code = '''
 
     lfs_mount(&lfs, &cfg) => 0;
     lfs_dir_open(&lfs, &dir, "a") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_dir_open(&lfs, &dir, "c") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 5+8+6);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_file_open(&lfs, &file, "a/hello", LFS_O_RDONLY) => LFS_ERR_NOENT;
@@ -409,26 +409,26 @@ code = '''
 
     lfs_mount(&lfs, &cfg) => 0;
     lfs_dir_open(&lfs, &dir, "a") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_dir_open(&lfs, &dir, "d") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 5+8+6);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_file_open(&lfs, &file, "a/hello", LFS_O_RDONLY) => LFS_ERR_NOENT;
@@ -465,46 +465,46 @@ code = '''
 
     lfs_mount(&lfs, &cfg) => 0;
     lfs_dir_open(&lfs, &dir, "a") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_dir_open(&lfs, &dir, "c") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "hi") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_dir_open(&lfs, &dir, "a/hi") => LFS_ERR_NOENT;
     lfs_dir_open(&lfs, &dir, "b/hi") => LFS_ERR_NOENT;
     lfs_dir_open(&lfs, &dir, "c/hi") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "bonjour") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "hola") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "ohayo") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_dir_open(&lfs, &dir, "d/hi") => LFS_ERR_NOENT;
     lfs_unmount(&lfs) => 0;
@@ -548,46 +548,46 @@ code = '''
 
     lfs_mount(&lfs, &cfg) => 0;
     lfs_dir_open(&lfs, &dir, "a") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_dir_open(&lfs, &dir, "c") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "hi") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_dir_open(&lfs, &dir, "a/hi") => LFS_ERR_NOENT;
     lfs_dir_open(&lfs, &dir, "b/hi") => LFS_ERR_NOENT;
     lfs_dir_open(&lfs, &dir, "c/hi") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "bonjour") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "hola") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "ohayo") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_dir_open(&lfs, &dir, "d/hi") => LFS_ERR_NOENT;
     lfs_unmount(&lfs) => 0;
@@ -648,44 +648,44 @@ code = '''
 
     lfs_mount(&lfs, &cfg) => 0;
     lfs_dir_open(&lfs, &dir, "a") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "hi") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_dir_open(&lfs, &dir, "c") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_dir_open(&lfs, &dir, "a/hi") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "bonjour") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "hola") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "ohayo") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_dir_open(&lfs, &dir, "b/hi") => LFS_ERR_NOENT;
     lfs_dir_open(&lfs, &dir, "c/hi") => LFS_ERR_NOENT;
@@ -753,46 +753,46 @@ code = '''
 
     lfs_mount(&lfs, &cfg) => 0;
     lfs_dir_open(&lfs, &dir, "a") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_dir_open(&lfs, &dir, "c") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "hi") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_dir_open(&lfs, &dir, "a/hi") => LFS_ERR_NOENT;
     lfs_dir_open(&lfs, &dir, "b/hi") => LFS_ERR_NOENT;
     lfs_dir_open(&lfs, &dir, "c/hi") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "bonjour") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "hola") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "ohayo") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_dir_open(&lfs, &dir, "d/hi") => LFS_ERR_NOENT;
     lfs_unmount(&lfs) => 0;
@@ -870,47 +870,47 @@ code = '''
 
     lfs_mount(&lfs, &cfg) => 0;
     lfs_dir_open(&lfs, &dir, "a") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_dir_open(&lfs, &dir, "d") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "hi") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_dir_open(&lfs, &dir, "a/hi") => LFS_ERR_NOENT;
     lfs_dir_open(&lfs, &dir, "b/hi") => LFS_ERR_NOENT;
     lfs_dir_open(&lfs, &dir, "c/hi") => LFS_ERR_NOENT;
     lfs_dir_open(&lfs, &dir, "d/hi") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "bonjour") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "hola") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "ohayo") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_unmount(&lfs) => 0;
 '''
@@ -1025,29 +1025,29 @@ code = '''
 
     // check that nothing was corrupted
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "0.before") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "2.in_between") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "3.move_me") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "4.after") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_file_open(&lfs, &file, "/0.before", LFS_O_RDONLY) => 0;
@@ -1084,29 +1084,29 @@ code = '''
 
     // and check that nothing was corrupted again
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "0.before") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "1.move_me") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "2.in_between") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "4.after") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_file_open(&lfs, &file, "/0.before", LFS_O_RDONLY) => 0;
@@ -1176,29 +1176,29 @@ code = '''
 
     // check that nothing was corrupted
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "0.before") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "2.in_between") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "3.move_me") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "4.after") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_file_open(&lfs, &file, "/0.before", LFS_O_RDONLY) => 0;
@@ -1241,29 +1241,29 @@ code = '''
 
     // and check that nothing was corrupted again
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "0.before") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "1.move_me") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "2.in_between") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "4.after") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_file_open(&lfs, &file, "/0.before", LFS_O_RDONLY) => 0;
@@ -1341,59 +1341,59 @@ code = '''
 
     // check that nothing was corrupted
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "dir.1") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "dir.2") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_dir_open(&lfs, &dir, "/dir.1") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "0.before") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "2.after") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_dir_open(&lfs, &dir, "/dir.2") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "0.before") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "1.move_me") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "2.after") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_file_open(&lfs, &file, "/dir.1/0.before", LFS_O_RDONLY) => 0;
@@ -1444,59 +1444,59 @@ code = '''
 
     // and check that nothing was corrupted again
     lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "dir.1") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "dir.2") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_dir_open(&lfs, &dir, "/dir.1") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "0.before") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "1.move_me") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "2.after") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_dir_open(&lfs, &dir, "/dir.2") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "0.before") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "2.after") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_file_open(&lfs, &file, "/dir.1/0.before", LFS_O_RDONLY) => 0;
@@ -1594,46 +1594,46 @@ code = '''
 
     // check that nothing was corrupted
     lfs_dir_open(&lfs, &dir, "/parent") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "0.before") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "2.after") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "child") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_dir_open(&lfs, &dir, "/parent/child") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "0.before") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "1.move_me") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == sizeof("move me"));
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "2.after") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_file_open(&lfs, &file, "/parent/0.before", LFS_O_RDONLY) => 0;
@@ -1740,59 +1740,59 @@ code = '''
 
     // check that nothing was corrupted
     lfs_dir_open(&lfs, &dir, "/parent") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "child") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "sibling") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_dir_open(&lfs, &dir, "/parent/sibling") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "0.before") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "2.after") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_dir_open(&lfs, &dir, "/parent/child") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "0.before") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "1.move_me") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == sizeof("move me"));
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     assert(strcmp(info.name, "2.after") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_file_open(&lfs, &file, "/parent/sibling/0.before", LFS_O_RDONLY) => 0;

tests/test_relocations.toml

@@ -26,14 +26,14 @@ code = '''
         }
 
         lfs_dir_open(&lfs, &dir, "child") => 0;
-        lfs_dir_read(&lfs, &dir, &info) => 0;
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         for (int i = 0; i < COUNT; i++) {
             sprintf(path, "test%03d_loooooooooooooooooong_name", i);
-            lfs_dir_read(&lfs, &dir, &info) => 0;
+            lfs_dir_read(&lfs, &dir, &info) => 1;
             strcmp(info.name, path) => 0;
         }
-        lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         lfs_dir_close(&lfs, &dir) => 0;
 
         if (j == ITERATIONS-1) {
@@ -49,14 +49,14 @@ code = '''
 
     lfs_mount(&lfs, &cfg) => 0;
     lfs_dir_open(&lfs, &dir, "child") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 1;
     for (int i = 0; i < COUNT; i++) {
         sprintf(path, "test%03d_loooooooooooooooooong_name", i);
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         strcmp(info.name, path) => 0;
     }
-    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     lfs_dir_close(&lfs, &dir) => 0;
     for (int i = 0; i < COUNT; i++) {
         sprintf(path, "child/test%03d_loooooooooooooooooong_name", i);
@@ -92,11 +92,11 @@ code = '''
         }
 
         lfs_dir_open(&lfs, &dir, "child") => 0;
-        lfs_dir_read(&lfs, &dir, &info) => 0;
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         for (int i = 0; i < COUNT; i++) {
             sprintf(path, "test%03d_loooooooooooooooooong_name", i);
-            lfs_dir_read(&lfs, &dir, &info) => 0;
+            lfs_dir_read(&lfs, &dir, &info) => 1;
             strcmp(info.name, path) => 0;
             info.size => 0;
 
@@ -105,14 +105,14 @@ code = '''
             lfs_file_write(&lfs, &file, "hi", 2) => 2;
             lfs_file_close(&lfs, &file) => 0;
         }
-        lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
 
         lfs_dir_rewind(&lfs, &dir) => 0;
-        lfs_dir_read(&lfs, &dir, &info) => 0;
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         for (int i = 0; i < COUNT; i++) {
             sprintf(path, "test%03d_loooooooooooooooooong_name", i);
-            lfs_dir_read(&lfs, &dir, &info) => 0;
+            lfs_dir_read(&lfs, &dir, &info) => 1;
             strcmp(info.name, path) => 0;
             info.size => 2;
 
@@ -121,18 +121,18 @@ code = '''
             lfs_file_write(&lfs, &file, "hi", 2) => 2;
             lfs_file_close(&lfs, &file) => 0;
         }
-        lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
 
         lfs_dir_rewind(&lfs, &dir) => 0;
-        lfs_dir_read(&lfs, &dir, &info) => 0;
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 1;
         for (int i = 0; i < COUNT; i++) {
             sprintf(path, "test%03d_loooooooooooooooooong_name", i);
-            lfs_dir_read(&lfs, &dir, &info) => 0;
+            lfs_dir_read(&lfs, &dir, &info) => 1;
             strcmp(info.name, path) => 0;
             info.size => 2;
         }
-        lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         lfs_dir_close(&lfs, &dir) => 0;
 
         for (int i = 0; i < COUNT; i++) {