Add a test for IDBFS auto persistence

Author: handlerug

test/fs/test_idbfs_autopersist.c

@@ -0,0 +1,237 @@
+/*
+ * Copyright 2025 The Emscripten Authors.  All rights reserved.
+ * Emscripten is available under two separate licenses, the MIT license and the
+ * University of Illinois/NCSA Open Source License.  Both these licenses can be
+ * found in the LICENSE file.
+ */
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <emscripten.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <errno.h>
+
+EM_JS_DEPS(deps, "$callUserCallback");
+
+enum {
+  TEST_CASE_open,
+  TEST_CASE_close,
+  TEST_CASE_symlink,
+  TEST_CASE_unlink,
+  TEST_CASE_rename,
+  TEST_CASE_mkdir,
+};
+
+static void test_case_open() {
+  switch (TEST_PHASE) {
+    case 1: {
+      int fd = open("/working1/file", O_RDWR | O_CREAT | O_EXCL, 0777);
+      assert(fd != -1);
+      break;
+    }
+    case 2: {
+      struct stat st;
+      int res = lstat("/working1/file", &st);
+      assert(res == 0);
+      assert(st.st_size == 0);
+      break;
+    }
+    default:
+      assert(false);
+  }
+}
+
+static void test_case_close() {
+  switch (TEST_PHASE) {
+    case 1: {
+      int fd = open("/working1/file", O_RDWR | O_CREAT | O_EXCL, 0777);
+      assert(fd != -1);
+      break;
+    }
+    case 2: {
+      int fd = open("/working1/file", O_RDWR | O_CREAT, 0777);
+      assert(fd != -1);
+      ssize_t bytes_written = write(fd, "foo", 3);
+      assert(bytes_written == 3);
+      int res = close(fd);
+      assert(res == 0);
+      break;
+    }
+    case 3: {
+      struct stat st;
+      int res = lstat("/working1/file", &st);
+      assert(res == 0);
+      assert(st.st_size == 3);
+      break;
+    }
+    default:
+      assert(false);
+  }
+}
+
+static void test_case_symlink() {
+  switch (TEST_PHASE) {
+    case 1: {
+      int fd = open("/working1/file", O_RDWR | O_CREAT | O_EXCL, 0777);
+      assert(fd != -1);
+      break;
+    }
+    case 2: {
+      int res = symlink("/working1/file", "/working1/symlink");
+      assert(res == 0);
+      break;
+    }
+    case 3: {
+      struct stat st;
+      int res = lstat("/working1/symlink", &st);
+      assert(res == 0);
+      break;
+    }
+    default:
+      assert(false);
+  }
+}
+
+static void test_case_unlink() {
+  switch (TEST_PHASE) {
+    case 1: {
+      int fd = open("/working1/file", O_RDWR | O_CREAT | O_EXCL, 0777);
+      assert(fd != -1);
+      break;
+    }
+    case 2: {
+      int res = unlink("/working1/file");
+      assert(res == 0);
+      break;
+    }
+    case 3: {
+      struct stat st;
+      int res = lstat("/working1/file", &st);
+      assert(res == -1);
+      assert(errno == ENOENT);
+      break;
+    }
+    default:
+      assert(false);
+  }
+}
+
+static void test_case_rename() {
+  switch (TEST_PHASE) {
+    case 1: {
+      int fd = open("/working1/file", O_RDWR | O_CREAT | O_EXCL, 0777);
+      assert(fd != -1);
+      break;
+    }
+    case 2: {
+      int res = rename("/working1/file", "/working1/file_renamed");
+      assert(res == 0);
+      break;
+    }
+    case 3: {
+      struct stat st;
+      int res = lstat("/working1/file_renamed", &st);
+      assert(res == 0);
+      res = lstat("/working1/file", &st);
+      assert(res == -1);
+      assert(errno == ENOENT);
+      break;
+    }
+    default:
+      assert(false);
+  }
+}
+
+static void test_case_mkdir() {
+  switch (TEST_PHASE) {
+    case 1: {
+      int res = mkdir("/working1/dir", 0777);
+      assert(res == 0);
+      break;
+    }
+    case 2: {
+      struct stat st;
+      int res = lstat("/working1/dir", &st);
+      assert(res == 0);
+      break;
+    }
+    default:
+      assert(false);
+  }
+}
+
+void finish() {
+  emscripten_force_exit(0);
+}
+
+void test() {
+  switch (TEST_CASE) {
+    case TEST_CASE_open: test_case_open(); break;
+    case TEST_CASE_close: test_case_close(); break;
+    case TEST_CASE_symlink: test_case_symlink(); break;
+    case TEST_CASE_unlink: test_case_unlink(); break;
+    case TEST_CASE_rename: test_case_rename(); break;
+    case TEST_CASE_mkdir: test_case_mkdir(); break;
+    default: assert(false);
+  }
+
+  EM_ASM({
+    // Wait until IDBFS has persisted before exiting
+    runOnceIDBFSIdle(() => {
+      callUserCallback(_finish);
+    });
+  });
+}
+
+int main() {
+  EM_ASM({
+    globalThis.runOnceIDBFSIdle = (callback) => {
+      const { mount } = FS.lookupPath('/working1').node;
+      assert('idbPersistState' in mount, 'mount object must have idbPersistState');
+      if (mount.idbPersistState !== 0) {
+        // IDBFS hasn't finished persisting. Check again after all pending tasks have executed
+        setTimeout(() => runOnceIDBFSIdle(callback), 0);
+        return;
+      }
+      callback();
+    };
+
+    FS.mkdir('/working1');
+    FS.mount(IDBFS, {
+      autoPersist: true
+    }, '/working1');
+  });
+
+  if (TEST_PHASE == 1) {
+    EM_ASM({
+      // Erase persisted state
+      FS.syncfs(false, (err) => {
+        assert(!err);
+        callUserCallback(_test);
+      });
+    });
+  } else if (TEST_PHASE > 1) {
+    EM_ASM({
+      // Sync from persisted state into memory
+      FS.syncfs(true, (err) => {
+        assert(!err);
+
+        // The resulting filesystem modifications might trigger IDBFS.queuePersist()
+        // calls which will interfere with the shutdown code. Wait until all such
+        // calls have completed.
+        runOnceIDBFSIdle(() => {
+          callUserCallback(_test);
+        });
+      });
+    });
+  } else {
+    assert(false);
+  }
+
+  emscripten_exit_with_live_runtime();
+  return 0;
+}

test/test_browser.py

@@ -1353,6 +1353,19 @@ def test_fs_idbfs_sync(self, args):
     print('done first half')
     self.btest_exit('fs/test_idbfs_sync.c', cflags=['-lidbfs.js', f'-DSECRET="{secret}"', '-sEXPORTED_FUNCTIONS=_main,_test,_finish', '-lidbfs.js'] + args)
 
+  @parameterized({
+    'open': ('open', 2),
+    'close': ('close', 3),
+    'symlink': ('symlink', 3),
+    'unlink': ('unlink', 3),
+    'rename': ('rename', 3),
+    'mkdir': ('mkdir', 2),
+  })
+  def test_fs_idbfs_autopersist(self, test_case, phase_count):
+    self.cflags += ['-lidbfs.js', '-sEXPORTED_FUNCTIONS=_main,_test,_finish', f'-DTEST_CASE=TEST_CASE_{test_case}']
+    for phase in range(phase_count):
+      self.btest_exit('fs/test_idbfs_autopersist.c', cflags=[f'-DTEST_PHASE={phase+1}'])
+
   def test_fs_idbfs_fsync(self):
     # sync from persisted state into memory before main()
     self.set_setting('DEFAULT_LIBRARY_FUNCS_TO_INCLUDE', '$ccall')