This is mock-fs.info, produced by makeinfo version 7.3 from
mock-fs.texi.

Copyright (C) 2025-2026 Aldric Giacomoni <trevoke@gmail.com>

   You can redistribute this document and/or modify it under the terms
of the GNU General Public License as published by the Free Software
Foundation, either version 3 of the License, or (at your option) any
later version.

   This document is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.
INFO-DIR-SECTION Misc
START-INFO-DIR-ENTRY
* (mock-fs).            Mock-FS User Guide.
END-INFO-DIR-ENTRY


File: mock-fs.info,  Node: Top,  Next: What is Mock-FS?,  Up: (dir)

Mock-FS User Guide
******************

* Menu:

* What is Mock-FS?::
* Your First Mock Filesystem (2 minutes)::
* Understanding the /mock Prefix::
* Tutorial Testing File Operations::
* Tutorial Testing with Temporary Files::
* Two Ways to Set Up the Filesystem::
* Symbolic Links::
* What Operations Are Supported?::
* Common Patterns::
* Reference::

-- The Detailed Node Listing --

Tutorial: Testing File Operations

* Scenario Testing a Config Reader::
* Scenario Testing File Writers::
* Scenario Testing Directory Operations::

Tutorial: Testing with Temporary Files

* How Temp Files Work::
* Creating Temp Directories::

Two Ways to Set Up the Filesystem

* Declarative (Simple Cases)::
* Builder (Complex Cases)::

Symbolic Links

* Symlink Behavior::
* Testing with Symlinks::

Common Patterns

* Pattern Test Fixture Files::
* Pattern Verify Side Effects::
* Pattern Test Error Handling::
* Pattern Isolate Tests::

Reference

* with-mock-fs::
* mock-fs-create::
* mock-fs-add-file::
* mock-fs-add-directory::
* mock-fs-add-symlink::
* mock-fs-path::
* Error Signals::
* Limitations::
* Native Compilation and Trampolines::

Native Compilation and Trampolines

* Subprocesses cannot run from a virtual directory::



File: mock-fs.info,  Node: What is Mock-FS?,  Next: Your First Mock Filesystem (2 minutes),  Prev: Top,  Up: Top

What is Mock-FS?
****************

Mock-FS lets your Emacs Lisp tests pretend to read and write files
without touching the real filesystem.

   *Why this matters:* Tests that hit the disk are slow, can fail from
permission issues, and leave behind garbage files.  Mock-FS keeps your
tests fast, isolated, and repeatable.

   *Who needs this:* Emacs package authors who test code that reads,
writes, or manipulates files.


File: mock-fs.info,  Node: Your First Mock Filesystem (2 minutes),  Next: Understanding the /mock Prefix,  Prev: What is Mock-FS?,  Up: Top

Your First Mock Filesystem (2 minutes)
**************************************

Let's test a function that reads a config file.  Normally you'd need to
create a real file, but with Mock-FS:

     (require 'mock-fs)

     ;; Create a virtual filesystem with one file
     (with-mock-fs '(("/config.json" . "{\"debug\": true}"))

       ;; This reads from the VIRTUAL file, not your disk
       (with-temp-buffer
         (insert-file-contents "/mock:/config.json")
         (buffer-string)))  ; => "{\"debug\": true}"

   That's it.  The file ‘/config.json’ exists only in memory, only
during the test.

   Try it yourself:

  1. Open a scratch buffer
  2. Paste the code above
  3. Evaluate it with ‘C-x C-e’
  4. See the result: ‘"{\"debug\": true}"’

   No file was created on your disk.


File: mock-fs.info,  Node: Understanding the /mock Prefix,  Next: Tutorial Testing File Operations,  Prev: Your First Mock Filesystem (2 minutes),  Up: Top

Understanding the /mock: Prefix
*******************************

Every path in the virtual filesystem starts with ‘/mock:’.

   Think of it like a separate drive letter on Windows, or a mounted
filesystem on Unix.  When Emacs sees ‘/mock:/some/path’, it routes the
operation to Mock-FS instead of the real filesystem.

You write                     Emacs reads from
---------------------------------------------------
‘/home/user/file.txt’         Real disk
‘/mock:/home/user/file.txt’   Virtual filesystem

   *Why the prefix?*  It makes the boundary explicit.  You always know
whether code is touching real files or mock files.  No surprises.


File: mock-fs.info,  Node: Tutorial Testing File Operations,  Next: Tutorial Testing with Temporary Files,  Prev: Understanding the /mock Prefix,  Up: Top

Tutorial: Testing File Operations
*********************************

* Menu:

* Scenario Testing a Config Reader::
* Scenario Testing File Writers::
* Scenario Testing Directory Operations::


File: mock-fs.info,  Node: Scenario Testing a Config Reader,  Next: Scenario Testing File Writers,  Up: Tutorial Testing File Operations

Scenario: Testing a Config Reader
=================================

Suppose you have a function that reads user preferences:

     (defun my-read-preferences (path)
       "Read JSON preferences from PATH."
       (with-temp-buffer
         (insert-file-contents path)
         (json-read-from-string (buffer-string))))

   Without Mock-FS, testing this requires creating real files.  With
Mock-FS:

     (require 'e-unit)  ; or ert, or your test framework
     (require 'mock-fs)

     (deftest test-read-preferences-parses-json ()
       "my-read-preferences correctly parses JSON config."
       (with-mock-fs '(("/home/user/.prefs" . "{\"theme\": \"dark\"}"))
         (let ((prefs (my-read-preferences "/mock:/home/user/.prefs")))
           (assert-equal "dark" (alist-get 'theme prefs)))))


File: mock-fs.info,  Node: Scenario Testing File Writers,  Next: Scenario Testing Directory Operations,  Prev: Scenario Testing a Config Reader,  Up: Tutorial Testing File Operations

Scenario: Testing File Writers
==============================

Test code that writes files without leaving garbage:

     (defun my-save-data (path data)
       "Save DATA as JSON to PATH."
       (with-temp-buffer
         (insert (json-encode data))
         (write-region (point-min) (point-max) path)))

     (deftest test-save-data-writes-json ()
       "my-save-data writes valid JSON."
       (with-mock-fs '()  ; start with empty filesystem
         (my-save-data "/mock:/output.json" '((name . "test")))

         ;; Verify file was created
         (assert-true (file-exists-p "/mock:/output.json"))

         ;; Verify contents
         (with-temp-buffer
           (insert-file-contents "/mock:/output.json")
           (assert-equal "{\"name\":\"test\"}" (buffer-string)))))


File: mock-fs.info,  Node: Scenario Testing Directory Operations,  Prev: Scenario Testing File Writers,  Up: Tutorial Testing File Operations

Scenario: Testing Directory Operations
======================================

Mock-FS supports directories too:

     (deftest test-creates-nested-directories ()
       "Can create and navigate directory structures."
       (with-mock-fs '()
         ;; Create nested directories
         (make-directory "/mock:/a/b/c" t)  ; t = create parents

         ;; All three levels exist
         (assert-true (file-directory-p "/mock:/a"))
         (assert-true (file-directory-p "/mock:/a/b"))
         (assert-true (file-directory-p "/mock:/a/b/c"))

         ;; Create a file inside
         (with-temp-buffer
           (insert "content")
           (write-region (point-min) (point-max) "/mock:/a/b/c/file.txt"))

         ;; List directory contents
         (let ((files (directory-files "/mock:/a/b/c")))
           (assert-true (member "file.txt" files)))))


File: mock-fs.info,  Node: Tutorial Testing with Temporary Files,  Next: Two Ways to Set Up the Filesystem,  Prev: Tutorial Testing File Operations,  Up: Top

Tutorial: Testing with Temporary Files
**************************************

Many Emacs packages use ‘make-temp-file’ to create temporary files.
Mock-FS works seamlessly with this pattern.

* Menu:

* How Temp Files Work::
* Creating Temp Directories::


File: mock-fs.info,  Node: How Temp Files Work,  Next: Creating Temp Directories,  Up: Tutorial Testing with Temporary Files

How Temp Files Work
===================

Emacs creates temp files in ‘temporary-file-directory’ (usually
‘/tmp/’).  To redirect them to the mock filesystem, bind this variable:

     (deftest test-with-temp-files ()
       "Temp files go to mock filesystem."
       (with-mock-fs '(("/tmp/" . nil))  ; nil = directory
         (let ((temporary-file-directory "/mock:/tmp/"))

           ;; make-temp-file now creates in mock filesystem
           (let ((temp-path (make-temp-file "mytest-")))
             ;; Path is in mock filesystem
             (assert-true (string-prefix-p "/mock:/tmp/mytest-" temp-path))

             ;; File exists virtually, not on disk
             (assert-true (file-exists-p temp-path))

             ;; Write to it
             (with-temp-buffer
               (insert "temp content")
               (write-region (point-min) (point-max) temp-path))

             ;; Read it back
             (with-temp-buffer
               (insert-file-contents temp-path)
               (assert-equal "temp content" (buffer-string)))))))


File: mock-fs.info,  Node: Creating Temp Directories,  Prev: How Temp Files Work,  Up: Tutorial Testing with Temporary Files

Creating Temp Directories
=========================

Pass ‘t’ as the second argument to ‘make-temp-file’ to create a
directory:

     (with-mock-fs '(("/tmp/" . nil))
       (let ((temporary-file-directory "/mock:/tmp/"))
         (let ((temp-dir (make-temp-file "mydir-" t)))
           (file-directory-p temp-dir))))  ; => t


File: mock-fs.info,  Node: Two Ways to Set Up the Filesystem,  Next: Symbolic Links,  Prev: Tutorial Testing with Temporary Files,  Up: Top

Two Ways to Set Up the Filesystem
*********************************

* Menu:

* Declarative (Simple Cases)::
* Builder (Complex Cases)::


File: mock-fs.info,  Node: Declarative (Simple Cases),  Next: Builder (Complex Cases),  Up: Two Ways to Set Up the Filesystem

Declarative (Simple Cases)
==========================

Pass an alist to ‘with-mock-fs’:

     (with-mock-fs '(("/file.txt" . "content")      ; file with content
                     ("/empty.txt" . "")             ; empty file
                     ("/dir/" . nil)                 ; directory (trailing slash or nil)
                     ("/dir/nested.txt" . "nested")  ; file in directory
                     ("/link.txt" . (:symlink . "/file.txt"))) ; symbolic link
       ;; test code here
       )

   Rules:
   • String value = file with that content
   • ‘nil’ value or trailing slash = directory
   • ‘(:symlink . target)’ = symbolic link pointing to target


File: mock-fs.info,  Node: Builder (Complex Cases),  Prev: Declarative (Simple Cases),  Up: Two Ways to Set Up the Filesystem

Builder (Complex Cases)
=======================

For dynamic setup, use the builder API:

     (let ((fs (mock-fs-create)))
       ;; Programmatically build filesystem
       (mock-fs-add-file fs "/config.json" (json-encode my-config))
       (mock-fs-add-directory fs "/data/")
       (mock-fs-add-symlink fs "/config-link" "/config.json")

       ;; Can add many files in a loop
       (dolist (name '("a" "b" "c"))
         (mock-fs-add-file fs (format "/data/%s.txt" name) name))

       (with-mock-fs fs
         ;; test code here
         ))


File: mock-fs.info,  Node: Symbolic Links,  Next: What Operations Are Supported?,  Prev: Two Ways to Set Up the Filesystem,  Up: Top

Symbolic Links
**************

Mock-FS fully supports symbolic links:

     ;; Declarative syntax
     (with-mock-fs '(("/target.txt" . "content")
                     ("/link.txt" . (:symlink . "/target.txt")))
       (file-symlink-p "/mock:/link.txt"))  ; => "/target.txt"

     ;; Builder API
     (let ((fs (mock-fs-create)))
       (mock-fs-add-file fs "/target.txt" "content")
       (mock-fs-add-symlink fs "/link.txt" "/target.txt")
       (with-mock-fs fs
         (insert-file-contents "/mock:/link.txt")))  ; reads "content"

* Menu:

* Symlink Behavior::
* Testing with Symlinks::


File: mock-fs.info,  Node: Symlink Behavior,  Next: Testing with Symlinks,  Up: Symbolic Links

Symlink Behavior
================

   • ‘file-exists-p’, ‘file-directory-p’, ‘file-regular-p’ follow
     symlinks
   • ‘file-symlink-p’ returns the target path (or nil for non-symlinks)
   • ‘file-truename’ resolves symlink chains
   • Circular symlinks are detected (max 40 levels, then signals
     ‘file-error’)
   • Broken symlinks (pointing to nonexistent targets) return nil from
     existence checks
   • ‘file-modes’ and ‘set-file-modes’ accept ‘'nofollow’ flag to
     operate on the link itself


File: mock-fs.info,  Node: Testing with Symlinks,  Prev: Symlink Behavior,  Up: Symbolic Links

Testing with Symlinks
=====================

     (deftest test-config-symlink ()
       "App follows config symlinks."
       (with-mock-fs '(("/etc/myapp/config.json" . "{\"env\": \"prod\"}")
                       ("/home/user/.myapp" . (:symlink . "/etc/myapp")))
         ;; Reading through symlink works transparently
         (with-temp-buffer
           (insert-file-contents "/mock:/home/user/.myapp/config.json")
           (assert-equal "{\"env\": \"prod\"}" (buffer-string)))))

     (deftest test-handles-broken-symlink ()
       "App gracefully handles broken symlinks."
       (with-mock-fs '(("/broken" . (:symlink . "/nonexistent")))
         (assert-nil (file-exists-p "/mock:/broken"))
         (assert-equal "/nonexistent" (file-symlink-p "/mock:/broken"))))


File: mock-fs.info,  Node: What Operations Are Supported?,  Next: Common Patterns,  Prev: Symbolic Links,  Up: Top

What Operations Are Supported?
******************************

Mock-FS intercepts these standard Emacs file operations:

Operation                       What it does
------------------------------------------------------------------
‘file-exists-p’                 Check if file/directory exists
‘file-directory-p’              Check if path is a directory
‘file-accessible-directory-p’   Check if dir is accessible
‘file-regular-p’                Check if path is a regular file
‘file-symlink-p’                Check if path is a symlink
‘file-readable-p’               Check if file is readable
‘file-writable-p’               Check if file/location writable
‘file-attributes’               Get file metadata (size, times)
‘file-modes’                    Get file permission bits
‘set-file-modes’                Set file permission bits
‘file-truename’                 Resolve path and symlinks
‘expand-file-name’              Expand relative paths
‘directory-file-name’           Remove trailing slash
‘insert-file-contents’          Read file into buffer
‘write-region’                  Write buffer region to file
‘delete-file’                   Remove a file
‘directory-files’               List directory contents
‘insert-directory’              Insert directory listing
‘make-directory’                Create directory
‘delete-directory’              Remove directory
‘copy-file’                     Copy file to new location
‘rename-file’                   Move/rename file
‘make-symbolic-link’            Create symbolic link

   Higher-level operations that use these (like ‘make-temp-file’,
‘with-temp-file’, JSON/YAML readers) work automatically.

   Process-related operations (‘process-file’, ‘start-file-process’) are
redirected to use a real directory when ‘default-directory’ is a mock
path, so shell commands work correctly.


File: mock-fs.info,  Node: Common Patterns,  Next: Reference,  Prev: What Operations Are Supported?,  Up: Top

Common Patterns
***************

* Menu:

* Pattern Test Fixture Files::
* Pattern Verify Side Effects::
* Pattern Test Error Handling::
* Pattern Isolate Tests::


File: mock-fs.info,  Node: Pattern Test Fixture Files,  Next: Pattern Verify Side Effects,  Up: Common Patterns

Pattern: Test Fixture Files
===========================

Pre-populate files that your code expects:

     (deftest test-loads-user-config ()
       (with-mock-fs '(("~/.myapp/config" . "setting=value"))
         ;; Code that calls (expand-file-name "~/.myapp/config") will find it
         ;; Note: expand-file-name still works, just prefix with /mock:
         (my-load-config "/mock:~/.myapp/config")))


File: mock-fs.info,  Node: Pattern Verify Side Effects,  Next: Pattern Test Error Handling,  Prev: Pattern Test Fixture Files,  Up: Common Patterns

Pattern: Verify Side Effects
============================

Confirm your code created expected files:

     (deftest test-creates-output-files ()
       (with-mock-fs '(("/input/" . nil))
         (my-process-directory "/mock:/input/" "/mock:/output/")

         ;; Verify output was created
         (assert-true (file-exists-p "/mock:/output/"))
         (assert-true (file-exists-p "/mock:/output/results.txt"))))


File: mock-fs.info,  Node: Pattern Test Error Handling,  Next: Pattern Isolate Tests,  Prev: Pattern Verify Side Effects,  Up: Common Patterns

Pattern: Test Error Handling
============================

Verify your code handles missing files gracefully:

     (deftest test-handles-missing-config ()
       (with-mock-fs '()  ; empty filesystem
         ;; Should return default, not crash
         (assert-equal 'default
           (my-load-config-or-default "/mock:/nonexistent"))))


File: mock-fs.info,  Node: Pattern Isolate Tests,  Prev: Pattern Test Error Handling,  Up: Common Patterns

Pattern: Isolate Tests
======================

Each ‘with-mock-fs’ is independent:

     (deftest test-one ()
       (with-mock-fs '(("/a.txt" . "a"))
         ;; Only /a.txt exists here
         ))

     (deftest test-two ()
       (with-mock-fs '(("/b.txt" . "b"))
         ;; Only /b.txt exists here
         ;; /a.txt from test-one doesn't leak
         ))


File: mock-fs.info,  Node: Reference,  Prev: Common Patterns,  Up: Top

Reference
*********

* Menu:

* with-mock-fs::
* mock-fs-create::
* mock-fs-add-file::
* mock-fs-add-directory::
* mock-fs-add-symlink::
* mock-fs-path::
* Error Signals::
* Limitations::
* Native Compilation and Trampolines::


File: mock-fs.info,  Node: with-mock-fs,  Next: mock-fs-create,  Up: Reference

‘with-mock-fs’
==============

     (with-mock-fs INIT &rest BODY)

   Execute BODY with a mock filesystem.

   INIT can be:
   • An alist of ‘(path . content)’ pairs
   • A hash-table from ‘mock-fs-create’

   Within BODY, file operations on ‘/mock:’ paths use the virtual
filesystem.


File: mock-fs.info,  Node: mock-fs-create,  Next: mock-fs-add-file,  Prev: with-mock-fs,  Up: Reference

‘mock-fs-create’
================

     (mock-fs-create) => hash-table

   Create an empty filesystem for the builder pattern.  Returns a
hash-table.


File: mock-fs.info,  Node: mock-fs-add-file,  Next: mock-fs-add-directory,  Prev: mock-fs-create,  Up: Reference

‘mock-fs-add-file’
==================

     (mock-fs-add-file FS PATH CONTENT)

   Add a file to FS at PATH with string CONTENT.


File: mock-fs.info,  Node: mock-fs-add-directory,  Next: mock-fs-add-symlink,  Prev: mock-fs-add-file,  Up: Reference

‘mock-fs-add-directory’
=======================

     (mock-fs-add-directory FS PATH)

   Add a directory to FS at PATH.


File: mock-fs.info,  Node: mock-fs-add-symlink,  Next: mock-fs-path,  Prev: mock-fs-add-directory,  Up: Reference

‘mock-fs-add-symlink’
=====================

     (mock-fs-add-symlink FS PATH TARGET)

   Add a symbolic link to FS at PATH pointing to TARGET.  TARGET can be
absolute or relative.


File: mock-fs.info,  Node: mock-fs-path,  Next: Error Signals,  Prev: mock-fs-add-symlink,  Up: Reference

‘mock-fs-path’
==============

     (mock-fs-path PATH) => string

   Return PATH prefixed for the mock filesystem.  A convenience helper
to avoid repeating the ‘/mock:’ prefix in tests:

     (mock-fs-path "/foo/bar")  ; => "/mock:/foo/bar"

     ;; Instead of:
     (file-exists-p "/mock:/home/user/file.txt")

     ;; You can write:
     (file-exists-p (mock-fs-path "/home/user/file.txt"))


File: mock-fs.info,  Node: Error Signals,  Next: Limitations,  Prev: mock-fs-path,  Up: Reference

Error Signals
=============

Mock-FS signals standard Emacs file errors:

Signal           When
-----------------------------------------------------
‘file-missing’   Reading/deleting nonexistent file


File: mock-fs.info,  Node: Limitations,  Next: Native Compilation and Trampolines,  Prev: Error Signals,  Up: Reference

Limitations
===========

   • Paths must start with ‘/mock:’ to be intercepted
   • No file permission enforcement (yet)


File: mock-fs.info,  Node: Native Compilation and Trampolines,  Prev: Limitations,  Up: Reference

Native Compilation and Trampolines
==================================

If you use Emacs with native compilation (Emacs 28+) and mock ‘/tmp/’ or
your eln-cache directory, you may encounter issues with shell commands
or other operations that rely on advised primitives.

   *The problem:* Mock-FS uses advice to intercept functions like
‘call-process’.  Native compilation generates "trampoline" ‘.eln’ files
to make advice work with compiled code.  These trampolines are written
to ‘/tmp/’ or the eln-cache.  If Mock-FS intercepts those paths,
trampoline generation can fail.

   *The solution:* Redirect trampolines to a non-mocked directory in
your test setup:

     ;; In your test setup, BEFORE using with-mock-fs:
     (when (boundp 'native-comp-enable-subr-trampolines)
       (setq native-comp-enable-subr-trampolines
             "/path/to/real/trampoline-cache/"))

   Alternatively, if you don't need shell commands in your tests, you
can disable trampolines entirely:

     (when (boundp 'native-comp-enable-subr-trampolines)
       (setq native-comp-enable-subr-trampolines nil))

   Note: Disabling trampolines means advice on primitives won't work
from natively-compiled code.  Functions like ‘shell-command-to-string’
may fail when ‘default-directory’ is a mock path.

* Menu:

* Subprocesses cannot run from a virtual directory::


File: mock-fs.info,  Node: Subprocesses cannot run from a virtual directory,  Up: Native Compilation and Trampolines

Subprocesses cannot run from a virtual directory
------------------------------------------------

There is a deeper, structural limitation here that Mock-FS cannot fully
solve.  A real operating-system subprocess must ‘chdir’ into a *real*
directory before it launches; it cannot ‘chdir’ into a virtual ‘/mock:’
directory that exists only inside Emacs.  So any process primitive
(‘call-process’, ‘call-process-region’, ‘process-file’, ‘start-process’,
‘shell-command-to-string’, ...) launched while ‘default-directory’ is
under ‘/mock:’ is fundamentally at odds with a mock filesystem.

   Mock-FS mitigates this for ‘call-process’ and ‘call-process-region’
by advising them (see ‘mock-fs--call-process-advice’) to rebind
‘default-directory’ to a real directory for the duration of the call.
This works - *but only when subr trampolines are enabled*.  Every
process primitive is a C subr in Emacs 30, and symbol-level advice on a
C subr is bypassed by native-compiled callers when
‘native-comp-enable-subr-trampolines’ is nil.

   Therefore, if you disable ‘native-comp-enable-subr-trampolines’ (a
common workaround for the eln-cache issue described above), or if a
natively-compiled caller reaches a process primitive that Mock-FS does
not advise, a subprocess launched while ‘default-directory’ is under
‘/mock:’ will fail with an error such as:

     file-missing "Setting current directory" "/mock:/some/dir"

   *The remedy* is the consumer's responsibility: ensure a *real*
‘default-directory’ around any code that shells out.  For example,
‘let’-bind ‘default-directory’ to a real directory:

     (let ((default-directory "/tmp/"))
       (shell-command-to-string "echo hello"))

   or advise the specific Lisp function that shells out so it rebinds
‘default-directory’ to a real directory before invoking the subprocess.


Tag Table:
Node: Top706
Node: What is Mock-FS?2005
Node: Your First Mock Filesystem (2 minutes)2543
Node: Understanding the /mock Prefix3488
Node: Tutorial Testing File Operations4309
Node: Scenario Testing a Config Reader4659
Node: Scenario Testing File Writers5598
Node: Scenario Testing Directory Operations6573
Node: Tutorial Testing with Temporary Files7580
Node: How Temp Files Work8001
Node: Creating Temp Directories9194
Node: Two Ways to Set Up the Filesystem9658
Node: Declarative (Simple Cases)9939
Node: Builder (Complex Cases)10752
Node: Symbolic Links11430
Node: Symlink Behavior12160
Node: Testing with Symlinks12814
Node: What Operations Are Supported?13692
Node: Common Patterns15767
Node: Pattern Test Fixture Files16044
Node: Pattern Verify Side Effects16565
Node: Pattern Test Error Handling17133
Node: Pattern Isolate Tests17621
Node: Reference18097
Node: with-mock-fs18399
Node: mock-fs-create18788
Node: mock-fs-add-file19050
Node: mock-fs-add-directory19300
Node: mock-fs-add-symlink19547
Node: mock-fs-path19851
Node: Error Signals20363
Node: Limitations20670
Node: Native Compilation and Trampolines20923
Node: Subprocesses cannot run from a virtual directory22394

End Tag Table


Local Variables:
coding: utf-8
Info-documentlanguage: en
End:
