Changed lfs_dir_read to return 0 on success

Before:
If an entry is found, lfs_dir_read returns 1
If at end of directory, lfs_dir_read returns 0

After:
If an entry is found, lfs_dir_read returns 0
If at end of directory, lfs_dir_read returns LFS_ERR_NOENT

---

lfs_dir_read is a bit of an odd function. It's supposed to match
lfs_file_read, but instead of reading bytes, it reads directory
entries.

Its POSIX equivalent, readdir, indicates whether or not we reached
the end of the directory by returning a NULL pointer:

struct dirent *readdir(DIR *dirp);

But this API needed to change for littlefs, since we don't use errno,
instead returning errors as signed integers through all API functions,
including lfs_dir_read.  So, in an effort to match lfs_file_read,
lfs_dir_read returned the "number" of directory entries read, limited
to either 0 or 1.

Perhaps unsurprisingly, this turned out to be confusing to users,
and a better API was proposed hathach to instead return either 0
or LFS_ERR_NOENT, an error which can't occur for other reasons in
lfs_dir_read.

Suggested by hathach

lfs.c

@@ -2160,18 +2160,19 @@ 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 true;
+        return 0;
     } else if (dir->pos == 1) {
         info->type = LFS_TYPE_DIR;
         strcpy(info->name, "..");
         dir->pos += 1;
-        return true;
+        return 0;
     }
 
     while (true) {
         if (dir->id == dir->m.count) {
             if (!dir->m.split) {
-                return false;
+                // reached end of traversal
+                return LFS_ERR_NOENT;
             }
 
             int err = lfs_dir_fetch(lfs, &dir->m, dir->m.tail);
@@ -2194,7 +2195,7 @@ static int lfs_dir_rawread(lfs_t *lfs, lfs_dir_t *dir, struct lfs_info *info) {
     }
 
     dir->pos += 1;
-    return true;
+    return 0;
 }
 
 static int lfs_dir_rawseek(lfs_t *lfs, lfs_dir_t *dir, lfs_off_t off) {

lfs.h

@@ -619,8 +619,9 @@ 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 a positive value on success, 0 at the end of directory,
-// or a negative error code on failure.
+//
+// Returns 0 on success, LFS_ERR_NOENT if there are no more directry entries,
+// or another 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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     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) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         assert(info.type == LFS_TYPE_DIR);
         assert(strcmp(info.name, path) == 0);
     }
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     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) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         assert(info.type == LFS_TYPE_DIR);
         assert(strcmp(info.name, path) == 0);
     }
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     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) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         assert(info.type == LFS_TYPE_DIR);
         assert(strcmp(info.name, path) == 0);
     }
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     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) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         assert(info.type == LFS_TYPE_DIR);
         assert(strcmp(info.name, path) == 0);
     }
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     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) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         assert(info.type == LFS_TYPE_DIR);
         assert(strcmp(info.name, path) == 0);
     }
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     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) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         assert(info.type == LFS_TYPE_DIR);
         assert(strcmp(info.name, path) == 0);
     }
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     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) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         assert(info.type == LFS_TYPE_REG);
         assert(strcmp(info.name, path) == 0);
     }
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     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) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         assert(info.type == LFS_TYPE_REG);
         assert(strcmp(info.name, path) == 0);
     }
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     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) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         assert(info.type == LFS_TYPE_REG);
         assert(strcmp(info.name, path) == 0);
     }
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     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) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         assert(info.type == LFS_TYPE_REG);
         assert(strcmp(info.name, path) == 0);
     }
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     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) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         assert(info.type == LFS_TYPE_REG);
         assert(strcmp(info.name, path) == 0);
     }
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     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) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         assert(info.type == LFS_TYPE_REG);
         assert(strcmp(info.name, path) == 0);
     }
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "baked") == 0);
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "fried") == 0);
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "sweet") == 0);
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "baked") == 0);
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "fried") == 0);
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "sweet") == 0);
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     info.type => LFS_TYPE_DIR;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "burito") == 0);
     info.type => LFS_TYPE_REG;
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     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) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         assert(info.type == LFS_TYPE_DIR);
         assert(strcmp(info.name, path) == 0);
     }
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     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) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         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) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_REG);
     assert(strcmp(info.name, "burito") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "potato") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "..") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_REG);
     assert(strcmp(info.name, "burito") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(info.type == LFS_TYPE_DIR);
     assert(strcmp(info.name, "potato") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
-        lfs_dir_read(&lfs, &dir, &info) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         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) => 1;
+            lfs_dir_read(&lfs, &dir, &info) => 0;
             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) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         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) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
-        lfs_dir_read(&lfs, &dir, &info) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
-        lfs_dir_read(&lfs, &dir, &info) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         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) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         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) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
-        lfs_dir_read(&lfs, &dir, &info) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         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) => 1;
+            lfs_dir_read(&lfs, &dir, &info) => 0;
             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) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         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) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, ".") == 0);
         assert(info.type == LFS_TYPE_DIR);
-        lfs_dir_read(&lfs, &dir, &info) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, "..") == 0);
         assert(info.type == LFS_TYPE_DIR);
-        lfs_dir_read(&lfs, &dir, &info) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         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) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     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) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, path) == 0);
         assert(info.type == LFS_TYPE_REG);
         assert(info.size == SIZE);
     }
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "zzz") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == FILES);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "e") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == SIZE);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "g") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == SIZE);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     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) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         assert(strcmp(info.name, path) == 0);
         assert(info.type == LFS_TYPE_REG);
         assert(info.size == SIZE);
     }
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
+    assert(strcmp(info.name, "..") == 0);
+    assert(info.type == LFS_TYPE_DIR);
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_close(&lfs, &dir) => 0;
+    lfs_dir_open(&lfs, &dir, "c") => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
+    assert(strcmp(info.name, ".") == 0);
+    assert(info.type == LFS_TYPE_DIR);
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
     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) => 1;
-    assert(strcmp(info.name, ".") == 0);
-    assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(strcmp(info.name, "..") == 0);
-    assert(info.type == LFS_TYPE_DIR);
-    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) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
+    assert(strcmp(info.name, "..") == 0);
+    assert(info.type == LFS_TYPE_DIR);
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_close(&lfs, &dir) => 0;
+    lfs_dir_open(&lfs, &dir, "c") => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
+    assert(strcmp(info.name, ".") == 0);
+    assert(info.type == LFS_TYPE_DIR);
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
     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) => 1;
-    assert(strcmp(info.name, ".") == 0);
-    assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(strcmp(info.name, "..") == 0);
-    assert(info.type == LFS_TYPE_DIR);
-    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) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hello") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 5+8+6);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_dir_open(&lfs, &dir, "c") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
+    assert(strcmp(info.name, "..") == 0);
+    assert(info.type == LFS_TYPE_DIR);
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_close(&lfs, &dir) => 0;
+    lfs_dir_open(&lfs, &dir, "c") => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
+    assert(strcmp(info.name, ".") == 0);
+    assert(info.type == LFS_TYPE_DIR);
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
     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) => 1;
-    assert(strcmp(info.name, ".") == 0);
-    assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(strcmp(info.name, "..") == 0);
-    assert(info.type == LFS_TYPE_DIR);
-    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) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
+    assert(strcmp(info.name, "..") == 0);
+    assert(info.type == LFS_TYPE_DIR);
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
+    lfs_dir_close(&lfs, &dir) => 0;
+    lfs_dir_open(&lfs, &dir, "d") => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
+    assert(strcmp(info.name, ".") == 0);
+    assert(info.type == LFS_TYPE_DIR);
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
     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) => 1;
-    assert(strcmp(info.name, ".") == 0);
-    assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(strcmp(info.name, "..") == 0);
-    assert(info.type == LFS_TYPE_DIR);
-    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) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_dir_open(&lfs, &dir, "c") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hi") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "bonjour") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hola") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ohayo") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_dir_open(&lfs, &dir, "c") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hi") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "bonjour") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hola") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ohayo") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hi") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_dir_open(&lfs, &dir, "c") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_dir_open(&lfs, &dir, "a/hi") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "bonjour") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hola") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ohayo") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_dir_open(&lfs, &dir, "c") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hi") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "bonjour") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hola") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ohayo") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfs_dir_close(&lfs, &dir) => 0;
     lfs_dir_open(&lfs, &dir, "d") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hi") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "bonjour") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "hola") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "ohayo") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "0.before") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "2.in_between") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "3.move_me") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "4.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) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "0.before") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "1.move_me") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "2.in_between") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "4.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) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "0.before") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "2.in_between") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "3.move_me") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "4.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) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "0.before") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "1.move_me") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "2.in_between") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "4.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) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "dir.1") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "dir.2") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_dir_open(&lfs, &dir, "/dir.1") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "0.before") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     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) => LFS_ERR_NOENT;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_dir_open(&lfs, &dir, "/dir.2") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "0.before") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "1.move_me") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     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) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "dir.1") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "dir.2") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_dir_open(&lfs, &dir, "/dir.1") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "0.before") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "1.move_me") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     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) => LFS_ERR_NOENT;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_dir_open(&lfs, &dir, "/dir.2") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "0.before") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     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) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "0.before") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "2.after") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     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) => LFS_ERR_NOENT;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_dir_open(&lfs, &dir, "/parent/child") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "0.before") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     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) => LFS_ERR_NOENT;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "child") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "sibling") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_dir_open(&lfs, &dir, "/parent/sibling") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "0.before") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     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) => LFS_ERR_NOENT;
     lfs_dir_close(&lfs, &dir) => 0;
 
     lfs_dir_open(&lfs, &dir, "/parent/child") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, ".") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "..") == 0);
     assert(info.type == LFS_TYPE_DIR);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     assert(strcmp(info.name, "0.before") == 0);
     assert(info.type == LFS_TYPE_REG);
     assert(info.size == 7);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     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) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     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) => LFS_ERR_NOENT;
     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) => 1;
-        lfs_dir_read(&lfs, &dir, &info) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         for (int i = 0; i < COUNT; i++) {
             sprintf(path, "test%03d_loooooooooooooooooong_name", i);
-            lfs_dir_read(&lfs, &dir, &info) => 1;
+            lfs_dir_read(&lfs, &dir, &info) => 0;
             strcmp(info.name, path) => 0;
         }
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         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) => 1;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => 0;
     for (int i = 0; i < COUNT; i++) {
         sprintf(path, "test%03d_loooooooooooooooooong_name", i);
-        lfs_dir_read(&lfs, &dir, &info) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         strcmp(info.name, path) => 0;
     }
-    lfs_dir_read(&lfs, &dir, &info) => 0;
+    lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
     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) => 1;
-        lfs_dir_read(&lfs, &dir, &info) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         for (int i = 0; i < COUNT; i++) {
             sprintf(path, "test%03d_loooooooooooooooooong_name", i);
-            lfs_dir_read(&lfs, &dir, &info) => 1;
+            lfs_dir_read(&lfs, &dir, &info) => 0;
             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) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
 
         lfs_dir_rewind(&lfs, &dir) => 0;
-        lfs_dir_read(&lfs, &dir, &info) => 1;
-        lfs_dir_read(&lfs, &dir, &info) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         for (int i = 0; i < COUNT; i++) {
             sprintf(path, "test%03d_loooooooooooooooooong_name", i);
-            lfs_dir_read(&lfs, &dir, &info) => 1;
+            lfs_dir_read(&lfs, &dir, &info) => 0;
             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) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
 
         lfs_dir_rewind(&lfs, &dir) => 0;
-        lfs_dir_read(&lfs, &dir, &info) => 1;
-        lfs_dir_read(&lfs, &dir, &info) => 1;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => 0;
         for (int i = 0; i < COUNT; i++) {
             sprintf(path, "test%03d_loooooooooooooooooong_name", i);
-            lfs_dir_read(&lfs, &dir, &info) => 1;
+            lfs_dir_read(&lfs, &dir, &info) => 0;
             strcmp(info.name, path) => 0;
             info.size => 2;
         }
-        lfs_dir_read(&lfs, &dir, &info) => 0;
+        lfs_dir_read(&lfs, &dir, &info) => LFS_ERR_NOENT;
         lfs_dir_close(&lfs, &dir) => 0;
 
         for (int i = 0; i < COUNT; i++) {