tests: Use vfs module instead of os.

Signed-off-by: Damien George <damien@micropython.org>

tests/extmod/vfs_basic.py

@@ -1,10 +1,8 @@
 # test VFS functionality without any particular filesystem type
 
 try:
-    import os
+    import os, vfs
-
+except ImportError:
-    os.mount
-except (ImportError, AttributeError):
     print("SKIP")
     raise SystemExit
 
@@ -59,11 +57,11 @@ class Filesystem:
 
 # first we umount any existing mount points the target may have
 try:
-    os.umount("/")
+    vfs.umount("/")
 except OSError:
     pass
 for path in os.listdir("/"):
-    os.umount("/" + path)
+    vfs.umount("/" + path)
 
 # stat root dir
 print(os.stat("/"))
@@ -83,7 +81,7 @@ for func in ("chdir", "listdir", "mkdir", "remove", "rmdir", "stat"):
             print(func, arg, "OSError")
 
 # basic mounting and listdir
-os.mount(Filesystem(1), "/test_mnt")
+vfs.mount(Filesystem(1), "/test_mnt")
 print(os.listdir())
 
 # ilistdir
@@ -103,13 +101,13 @@ print(os.listdir("test_mnt"))
 print(os.listdir("/test_mnt"))
 
 # mounting another filesystem
-os.mount(Filesystem(2), "/test_mnt2", readonly=True)
+vfs.mount(Filesystem(2), "/test_mnt2", readonly=True)
 print(os.listdir())
 print(os.listdir("/test_mnt2"))
 
 # mounting over an existing mount point
 try:
-    os.mount(Filesystem(3), "/test_mnt2")
+    vfs.mount(Filesystem(3), "/test_mnt2")
 except OSError:
     print("OSError")
 
@@ -139,23 +137,23 @@ open("test_file")
 open("test_file", "wb")
 
 # umount
-os.umount("/test_mnt")
+vfs.umount("/test_mnt")
-os.umount("/test_mnt2")
+vfs.umount("/test_mnt2")
 
 # umount a non-existent mount point
 try:
-    os.umount("/test_mnt")
+    vfs.umount("/test_mnt")
 except OSError:
     print("OSError")
 
 # root dir
-os.mount(Filesystem(3), "/")
+vfs.mount(Filesystem(3), "/")
 print(os.stat("/"))
 print(os.statvfs("/"))
 print(os.listdir())
 open("test")
 
-os.mount(Filesystem(4), "/mnt")
+vfs.mount(Filesystem(4), "/mnt")
 print(os.listdir())
 print(os.listdir("/mnt"))
 os.chdir("/mnt")
@@ -166,9 +164,9 @@ os.chdir("/subdir")
 print(os.listdir())
 os.chdir("/")
 
-os.umount("/")
+vfs.umount("/")
 print(os.listdir("/"))
-os.umount("/mnt")
+vfs.umount("/mnt")
 
 # chdir to a non-existent mount point (current directory should remain unchanged)
 try:
@@ -178,7 +176,7 @@ except OSError:
 print(os.getcwd())
 
 # chdir to a non-existent subdirectory in a mounted filesystem
-os.mount(Filesystem(5, 1), "/mnt")
+vfs.mount(Filesystem(5, 1), "/mnt")
 try:
     os.chdir("/mnt/subdir")
 except OSError:

tests/extmod/vfs_blockdev.py

@@ -1,10 +1,10 @@
 # Test for behaviour of combined standard and extended block device
 
 try:
-    import os
+    import vfs
 
-    os.VfsFat
+    vfs.VfsFat
-    os.VfsLfs2
+    vfs.VfsLfs2
 except (ImportError, AttributeError):
     print("SKIP")
     raise SystemExit
@@ -65,12 +65,10 @@ def test(bdev, vfs_class):
 
 
 try:
-    import os
-
     bdev = RAMBlockDevice(50)
 except MemoryError:
     print("SKIP")
     raise SystemExit
 
-test(bdev, os.VfsFat)
+test(bdev, vfs.VfsFat)
-test(bdev, os.VfsLfs2)
+test(bdev, vfs.VfsLfs2)

tests/extmod/vfs_fat_fileio1.py

@@ -1,13 +1,8 @@
 try:
-    import errno
+    import errno, os, vfs
-    import os
-except ImportError:
-    print("SKIP")
-    raise SystemExit
 
-try:
+    vfs.VfsFat
-    os.VfsFat
+except (ImportError, AttributeError):
-except AttributeError:
     print("SKIP")
     raise SystemExit
 
@@ -38,13 +33,13 @@ class RAMFS:
 
 try:
     bdev = RAMFS(50)
-    os.VfsFat.mkfs(bdev)
+    vfs.VfsFat.mkfs(bdev)
 except MemoryError:
     print("SKIP")
     raise SystemExit
 
-vfs = os.VfsFat(bdev)
+fs = vfs.VfsFat(bdev)
-os.mount(vfs, "/ramdisk")
+vfs.mount(fs, "/ramdisk")
 os.chdir("/ramdisk")
 
 # file IO
@@ -99,12 +94,12 @@ with open("foo_file.txt") as f2:
 #    print(f.read())
 
 # dirs
-vfs.mkdir("foo_dir")
+fs.mkdir("foo_dir")
 
 try:
-    vfs.rmdir("foo_file.txt")
+    fs.rmdir("foo_file.txt")
 except OSError as e:
     print(e.errno == 20)  # errno.ENOTDIR
 
-vfs.remove("foo_file.txt")
+fs.remove("foo_file.txt")
-print(list(vfs.ilistdir()))
+print(list(fs.ilistdir()))

tests/extmod/vfs_fat_fileio2.py

@@ -1,13 +1,8 @@
 try:
-    import errno
+    import errno, os, vfs
-    import os
-except ImportError:
-    print("SKIP")
-    raise SystemExit
 
-try:
+    vfs.VfsFat
-    os.VfsFat
+except (ImportError, AttributeError):
-except AttributeError:
     print("SKIP")
     raise SystemExit
 
@@ -38,32 +33,32 @@ class RAMFS:
 
 try:
     bdev = RAMFS(50)
-    os.VfsFat.mkfs(bdev)
+    vfs.VfsFat.mkfs(bdev)
 except MemoryError:
     print("SKIP")
     raise SystemExit
 
-vfs = os.VfsFat(bdev)
+fs = vfs.VfsFat(bdev)
-os.mount(vfs, "/ramdisk")
+vfs.mount(fs, "/ramdisk")
 os.chdir("/ramdisk")
 
 try:
-    vfs.mkdir("foo_dir")
+    fs.mkdir("foo_dir")
 except OSError as e:
     print(e.errno == errno.EEXIST)
 
 try:
-    vfs.remove("foo_dir")
+    fs.remove("foo_dir")
 except OSError as e:
     print(e.errno == errno.EISDIR)
 
 try:
-    vfs.remove("no_file.txt")
+    fs.remove("no_file.txt")
 except OSError as e:
     print(e.errno == errno.ENOENT)
 
 try:
-    vfs.rename("foo_dir", "/null/file")
+    fs.rename("foo_dir", "/null/file")
 except OSError as e:
     print(e.errno == errno.ENOENT)
 
@@ -79,34 +74,34 @@ with open("foo_dir/sub_file.txt", "w") as f:
 
 # directory not empty
 try:
-    vfs.rmdir("foo_dir")
+    fs.rmdir("foo_dir")
 except OSError as e:
     print(e.errno == errno.EACCES)
 
 # trim full path
-vfs.rename("foo_dir/file-in-dir.txt", "foo_dir/file.txt")
+fs.rename("foo_dir/file-in-dir.txt", "foo_dir/file.txt")
-print(list(vfs.ilistdir("foo_dir")))
+print(list(fs.ilistdir("foo_dir")))
 
-vfs.rename("foo_dir/file.txt", "moved-to-root.txt")
+fs.rename("foo_dir/file.txt", "moved-to-root.txt")
-print(list(vfs.ilistdir()))
+print(list(fs.ilistdir()))
 
 # check that renaming to existing file will overwrite it
 with open("temp", "w") as f:
     f.write("new text")
-vfs.rename("temp", "moved-to-root.txt")
+fs.rename("temp", "moved-to-root.txt")
-print(list(vfs.ilistdir()))
+print(list(fs.ilistdir()))
 with open("moved-to-root.txt") as f:
     print(f.read())
 
 # valid removes
-vfs.remove("foo_dir/sub_file.txt")
+fs.remove("foo_dir/sub_file.txt")
-vfs.rmdir("foo_dir")
+fs.rmdir("foo_dir")
-print(list(vfs.ilistdir()))
+print(list(fs.ilistdir()))
 
 # disk full
 try:
-    bsize = vfs.statvfs("/ramdisk")[0]
+    bsize = fs.statvfs("/ramdisk")[0]
-    free = vfs.statvfs("/ramdisk")[2] + 1
+    free = fs.statvfs("/ramdisk")[2] + 1
     f = open("large_file.txt", "wb")
     f.write(bytearray(bsize * free))
 except OSError as e:

tests/extmod/vfs_fat_finaliser.py

@@ -1,9 +1,9 @@
 # Test VfsFat class and its finaliser
 
 try:
-    import errno, os
+    import errno, os, vfs
 
-    os.VfsFat
+    vfs.VfsFat
 except (ImportError, AttributeError):
     print("SKIP")
     raise SystemExit
@@ -39,8 +39,8 @@ except MemoryError:
     raise SystemExit
 
 # Format block device and create VFS object
-os.VfsFat.mkfs(bdev)
+vfs.VfsFat.mkfs(bdev)
-vfs = os.VfsFat(bdev)
+fs = vfs.VfsFat(bdev)
 
 # Here we test that opening a file with the heap locked fails correctly.  This
 # is a special case because file objects use a finaliser and allocating with a
@@ -52,7 +52,7 @@ micropython.heap_lock()
 try:
     import errno, os
 
-    vfs.open("x", "r")
+    fs.open("x", "r")
 except MemoryError:
     print("MemoryError")
 micropython.heap_unlock()
@@ -77,10 +77,10 @@ for i in range(1024):
 # Only read back N-1 files because the last one may not be finalised due to
 # references to it being left on the C stack.
 for n in names:
-    f = vfs.open(n, "w")
+    f = fs.open(n, "w")
     f.write(n)
     f = None  # release f without closing
 gc.collect()  # should finalise at least the first N-1 files by closing them
 for n in names[:-1]:
-    with vfs.open(n, "r") as f:
+    with fs.open(n, "r") as f:
         print(f.read())

tests/extmod/vfs_fat_ilistdir_del.py

@@ -2,9 +2,9 @@
 import gc
 
 try:
-    import os
+    import os, vfs
 
-    os.VfsFat
+    vfs.VfsFat
 except (ImportError, AttributeError):
     print("SKIP")
     raise SystemExit
@@ -37,29 +37,29 @@ class RAMBlockDevice:
 
 def test(bdev, vfs_class):
     vfs_class.mkfs(bdev)
-    vfs = vfs_class(bdev)
+    fs = vfs_class(bdev)
-    vfs.mkdir("/test_d1")
+    fs.mkdir("/test_d1")
-    vfs.mkdir("/test_d2")
+    fs.mkdir("/test_d2")
-    vfs.mkdir("/test_d3")
+    fs.mkdir("/test_d3")
 
     for i in range(10):
         print(i)
 
         # We want to partially iterate the ilistdir iterator to leave it in an
         # open state, which will then test the finaliser when it's garbage collected.
-        idir = vfs.ilistdir("/")
+        idir = fs.ilistdir("/")
         print(any(idir))
 
         # Alternate way of partially iterating the ilistdir object, modifying the
         # filesystem while it's open.
-        for dname, *_ in vfs.ilistdir("/"):
+        for dname, *_ in fs.ilistdir("/"):
-            vfs.rmdir(dname)
+            fs.rmdir(dname)
             break
-        vfs.mkdir(dname)
+        fs.mkdir(dname)
 
         # Also create a fully drained iterator and ensure trying to reuse it
         # throws the correct exception.
-        idir_emptied = vfs.ilistdir("/")
+        idir_emptied = fs.ilistdir("/")
         l = list(idir_emptied)
         print(len(l))
         try:
@@ -68,7 +68,7 @@ def test(bdev, vfs_class):
             pass
 
         gc.collect()
-        vfs.open("/test", "w").close()
+        fs.open("/test", "w").close()
 
 
 try:
@@ -77,4 +77,4 @@ except MemoryError:
     print("SKIP")
     raise SystemExit
 
-test(bdev, os.VfsFat)
+test(bdev, vfs.VfsFat)

tests/extmod/vfs_fat_more.py

@@ -1,12 +1,8 @@
 try:
-    import os
+    import os, vfs
-except ImportError:
-    print("SKIP")
-    raise SystemExit
 
-try:
+    vfs.VfsFat
-    os.VfsFat
+except (ImportError, AttributeError):
-except AttributeError:
     print("SKIP")
     raise SystemExit
 
@@ -44,14 +40,14 @@ except MemoryError:
 
 # first we umount any existing mount points the target may have
 try:
-    os.umount("/")
+    vfs.umount("/")
 except OSError:
     pass
 for path in os.listdir("/"):
-    os.umount("/" + path)
+    vfs.umount("/" + path)
 
-os.VfsFat.mkfs(bdev)
+vfs.VfsFat.mkfs(bdev)
-os.mount(bdev, "/")
+vfs.mount(bdev, "/")
 
 print(os.getcwd())
 
@@ -94,8 +90,8 @@ for exist in ("", "/", "dir", "/dir", "dir/subdir"):
 os.chdir("/")
 print(os.stat("test5.txt")[:-3])
 
-os.VfsFat.mkfs(bdev2)
+vfs.VfsFat.mkfs(bdev2)
-os.mount(bdev2, "/sys")
+vfs.mount(bdev2, "/sys")
 print(os.listdir())
 print(os.listdir("sys"))
 print(os.listdir("/sys"))
@@ -104,7 +100,7 @@ os.rmdir("dir2")
 os.remove("test5.txt")
 print(os.listdir())
 
-os.umount("/")
+vfs.umount("/")
 print(os.getcwd())
 print(os.listdir())
 print(os.listdir("sys"))

tests/extmod/vfs_fat_mtime.py

@@ -1,11 +1,11 @@
 # Test for VfsFat using a RAM device, mtime feature
 
 try:
-    import time, os
+    import time, os, vfs
 
     time.time
     time.sleep
-    os.VfsFat
+    vfs.VfsFat
 except (ImportError, AttributeError):
     print("SKIP")
     raise SystemExit
@@ -41,21 +41,21 @@ def test(bdev, vfs_class):
     vfs_class.mkfs(bdev)
 
     # construction
-    vfs = vfs_class(bdev)
+    fs = vfs_class(bdev)
 
     # Create an empty file, should have a timestamp.
     current_time = int(time.time())
-    vfs.open("test1", "wt").close()
+    fs.open("test1", "wt").close()
 
     # Wait 2 seconds so mtime will increase (FAT has 2 second resolution).
     time.sleep(2)
 
     # Create another empty file, should have a timestamp.
-    vfs.open("test2", "wt").close()
+    fs.open("test2", "wt").close()
 
     # Stat the files and check mtime is non-zero.
-    stat1 = vfs.stat("test1")
+    stat1 = fs.stat("test1")
-    stat2 = vfs.stat("test2")
+    stat2 = fs.stat("test2")
     print(stat1[8] != 0, stat2[8] != 0)
 
     # Check that test1 has mtime which matches time.time() at point of creation.
@@ -67,8 +67,8 @@ def test(bdev, vfs_class):
     print(stat1[8] < stat2[8])
 
     # Unmount.
-    vfs.umount()
+    fs.umount()
 
 
 bdev = RAMBlockDevice(50)
-test(bdev, os.VfsFat)
+test(bdev, vfs.VfsFat)

tests/extmod/vfs_fat_oldproto.py

@@ -1,13 +1,8 @@
 try:
-    import errno
+    import errno, os, vfs
-    import os
-except ImportError:
-    print("SKIP")
-    raise SystemExit
 
-try:
+    vfs.VfsFat
-    os.VfsFat
+except (ImportError, AttributeError):
-except AttributeError:
     print("SKIP")
     raise SystemExit
 
@@ -41,18 +36,18 @@ except MemoryError:
     print("SKIP")
     raise SystemExit
 
-os.VfsFat.mkfs(bdev)
+vfs.VfsFat.mkfs(bdev)
-vfs = os.VfsFat(bdev)
+fs = vfs.VfsFat(bdev)
-os.mount(vfs, "/ramdisk")
+vfs.mount(fs, "/ramdisk")
 
 # file io
-with vfs.open("file.txt", "w") as f:
+with fs.open("file.txt", "w") as f:
     f.write("hello!")
 
-print(list(vfs.ilistdir()))
+print(list(fs.ilistdir()))
 
-with vfs.open("file.txt", "r") as f:
+with fs.open("file.txt", "r") as f:
     print(f.read())
 
-vfs.remove("file.txt")
+fs.remove("file.txt")
-print(list(vfs.ilistdir()))
+print(list(fs.ilistdir()))

tests/extmod/vfs_fat_ramdisk.py

@@ -1,13 +1,8 @@
 try:
-    import errno
+    import errno, os, vfs
-    import os
-except ImportError:
-    print("SKIP")
-    raise SystemExit
 
-try:
+    vfs.VfsFat
-    os.VfsFat
+except (ImportError, AttributeError):
-except AttributeError:
     print("SKIP")
     raise SystemExit
 
@@ -38,7 +33,7 @@ class RAMFS:
 
 try:
     bdev = RAMFS(50)
-    os.VfsFat.mkfs(bdev)
+    vfs.VfsFat.mkfs(bdev)
 except MemoryError:
     print("SKIP")
     raise SystemExit
@@ -46,50 +41,50 @@ except MemoryError:
 print(b"FOO_FILETXT" not in bdev.data)
 print(b"hello!" not in bdev.data)
 
-vfs = os.VfsFat(bdev)
+fs = vfs.VfsFat(bdev)
-os.mount(vfs, "/ramdisk")
+vfs.mount(fs, "/ramdisk")
 
-print("statvfs:", vfs.statvfs("/ramdisk"))
+print("statvfs:", fs.statvfs("/ramdisk"))
-print("getcwd:", vfs.getcwd())
+print("getcwd:", fs.getcwd())
 
 try:
-    vfs.stat("no_file.txt")
+    fs.stat("no_file.txt")
 except OSError as e:
     print(e.errno == errno.ENOENT)
 
-with vfs.open("foo_file.txt", "w") as f:
+with fs.open("foo_file.txt", "w") as f:
     f.write("hello!")
-print(list(vfs.ilistdir()))
+print(list(fs.ilistdir()))
 
-print("stat root:", vfs.stat("/")[:-3])  # timestamps differ across runs
+print("stat root:", fs.stat("/")[:-3])  # timestamps differ across runs
-print("stat file:", vfs.stat("foo_file.txt")[:-3])  # timestamps differ across runs
+print("stat file:", fs.stat("foo_file.txt")[:-3])  # timestamps differ across runs
 
 print(b"FOO_FILETXT" in bdev.data)
 print(b"hello!" in bdev.data)
 
-vfs.mkdir("foo_dir")
+fs.mkdir("foo_dir")
-vfs.chdir("foo_dir")
+fs.chdir("foo_dir")
-print("getcwd:", vfs.getcwd())
+print("getcwd:", fs.getcwd())
-print(list(vfs.ilistdir()))
+print(list(fs.ilistdir()))
 
-with vfs.open("sub_file.txt", "w") as f:
+with fs.open("sub_file.txt", "w") as f:
     f.write("subdir file")
 
 try:
-    vfs.chdir("sub_file.txt")
+    fs.chdir("sub_file.txt")
 except OSError as e:
     print(e.errno == errno.ENOENT)
 
-vfs.chdir("..")
+fs.chdir("..")
-print("getcwd:", vfs.getcwd())
+print("getcwd:", fs.getcwd())
 
-os.umount(vfs)
+vfs.umount(fs)
 
-vfs = os.VfsFat(bdev)
+fs = vfs.VfsFat(bdev)
-print(list(vfs.ilistdir(b"")))
+print(list(fs.ilistdir(b"")))
 
 # list a non-existent directory
 try:
-    vfs.ilistdir(b"no_exist")
+    fs.ilistdir(b"no_exist")
 except OSError as e:
     print("ENOENT:", e.errno == errno.ENOENT)

tests/extmod/vfs_fat_ramdisklarge.py

@@ -1,14 +1,10 @@
 # test making a FAT filesystem on a very large block device
 
 try:
-    import os
+    import os, vfs
-except ImportError:
-    print("SKIP")
-    raise SystemExit
 
-try:
+    vfs.VfsFat
-    os.VfsFat
+except (ImportError, AttributeError):
-except AttributeError:
     print("SKIP")
     raise SystemExit
 
@@ -46,24 +42,24 @@ class RAMBDevSparse:
 
 try:
     bdev = RAMBDevSparse(4 * 1024 * 1024 * 1024 // RAMBDevSparse.SEC_SIZE)
-    os.VfsFat.mkfs(bdev)
+    vfs.VfsFat.mkfs(bdev)
 except MemoryError:
     print("SKIP")
     raise SystemExit
 
-vfs = os.VfsFat(bdev)
+fs = vfs.VfsFat(bdev)
-os.mount(vfs, "/ramdisk")
+vfs.mount(fs, "/ramdisk")
 
-print("statvfs:", vfs.statvfs("/ramdisk"))
+print("statvfs:", fs.statvfs("/ramdisk"))
 
 f = open("/ramdisk/test.txt", "w")
 f.write("test file")
 f.close()
 
-print("statvfs:", vfs.statvfs("/ramdisk"))
+print("statvfs:", fs.statvfs("/ramdisk"))
 
 f = open("/ramdisk/test.txt")
 print(f.read())
 f.close()
 
-os.umount(vfs)
+vfs.umount(fs)

tests/extmod/vfs_lfs.py

@@ -1,10 +1,10 @@
 # Test for VfsLittle using a RAM device
 
 try:
-    import os
+    import os, vfs
 
-    os.VfsLfs1
+    vfs.VfsLfs1
-    os.VfsLfs2
+    vfs.VfsLfs2
 except (ImportError, AttributeError):
     print("SKIP")
     raise SystemExit
@@ -47,44 +47,44 @@ def test(bdev, vfs_class):
     vfs_class.mkfs(bdev)
 
     # construction
-    vfs = vfs_class(bdev)
+    fs = vfs_class(bdev)
 
     # statvfs
-    print(vfs.statvfs("/"))
+    print(fs.statvfs("/"))
 
     # open, write close
-    f = vfs.open("test", "w")
+    f = fs.open("test", "w")
     f.write("littlefs")
     f.close()
 
     # statvfs after creating a file
-    print(vfs.statvfs("/"))
+    print(fs.statvfs("/"))
 
     # ilistdir
-    print(list(vfs.ilistdir()))
+    print(list(fs.ilistdir()))
-    print(list(vfs.ilistdir("/")))
+    print(list(fs.ilistdir("/")))
-    print(list(vfs.ilistdir(b"/")))
+    print(list(fs.ilistdir(b"/")))
 
     # mkdir, rmdir
-    vfs.mkdir("testdir")
+    fs.mkdir("testdir")
-    print(list(vfs.ilistdir()))
+    print(list(fs.ilistdir()))
-    print(sorted(list(vfs.ilistdir("testdir"))))
+    print(sorted(list(fs.ilistdir("testdir"))))
-    vfs.rmdir("testdir")
+    fs.rmdir("testdir")
-    print(list(vfs.ilistdir()))
+    print(list(fs.ilistdir()))
-    vfs.mkdir("testdir")
+    fs.mkdir("testdir")
 
     # stat a file
-    print_stat(vfs.stat("test"))
+    print_stat(fs.stat("test"))
 
     # stat a dir (size seems to vary on LFS2 so don't print that)
-    print_stat(vfs.stat("testdir"), False)
+    print_stat(fs.stat("testdir"), False)
 
     # read
-    with vfs.open("test", "r") as f:
+    with fs.open("test", "r") as f:
         print(f.read())
 
     # create large file
-    with vfs.open("testbig", "w") as f:
+    with fs.open("testbig", "w") as f:
         data = "large012" * 32 * 16
         print("data length:", len(data))
         for i in range(4):
@@ -92,63 +92,63 @@ def test(bdev, vfs_class):
             f.write(data)
 
     # stat after creating large file
-    print(vfs.statvfs("/"))
+    print(fs.statvfs("/"))
 
     # rename
-    vfs.rename("testbig", "testbig2")
+    fs.rename("testbig", "testbig2")
-    print(sorted(list(vfs.ilistdir())))
+    print(sorted(list(fs.ilistdir())))
-    vfs.chdir("testdir")
+    fs.chdir("testdir")
-    vfs.rename("/testbig2", "testbig2")
+    fs.rename("/testbig2", "testbig2")
-    print(sorted(list(vfs.ilistdir())))
+    print(sorted(list(fs.ilistdir())))
-    vfs.rename("testbig2", "/testbig2")
+    fs.rename("testbig2", "/testbig2")
-    vfs.chdir("/")
+    fs.chdir("/")
-    print(sorted(list(vfs.ilistdir())))
+    print(sorted(list(fs.ilistdir())))
 
     # remove
-    vfs.remove("testbig2")
+    fs.remove("testbig2")
-    print(sorted(list(vfs.ilistdir())))
+    print(sorted(list(fs.ilistdir())))
 
     # getcwd, chdir
-    vfs.mkdir("/testdir2")
+    fs.mkdir("/testdir2")
-    vfs.mkdir("/testdir/subdir")
+    fs.mkdir("/testdir/subdir")
-    print(vfs.getcwd())
+    print(fs.getcwd())
-    vfs.chdir("/testdir")
+    fs.chdir("/testdir")
-    print(vfs.getcwd())
+    print(fs.getcwd())
 
     # create file in directory to make sure paths are relative
-    vfs.open("test2", "w").close()
+    fs.open("test2", "w").close()
-    print_stat(vfs.stat("test2"))
+    print_stat(fs.stat("test2"))
-    print_stat(vfs.stat("/testdir/test2"))
+    print_stat(fs.stat("/testdir/test2"))
-    vfs.remove("test2")
+    fs.remove("test2")
 
     # chdir back to root and remove testdir
-    vfs.chdir("/")
+    fs.chdir("/")
-    print(vfs.getcwd())
+    print(fs.getcwd())
-    vfs.chdir("testdir")
+    fs.chdir("testdir")
-    print(vfs.getcwd())
+    print(fs.getcwd())
-    vfs.chdir("..")
+    fs.chdir("..")
-    print(vfs.getcwd())
+    print(fs.getcwd())
-    vfs.chdir("testdir/subdir")
+    fs.chdir("testdir/subdir")
-    print(vfs.getcwd())
+    print(fs.getcwd())
-    vfs.chdir("../..")
+    fs.chdir("../..")
-    print(vfs.getcwd())
+    print(fs.getcwd())
-    vfs.chdir("/./testdir2")
+    fs.chdir("/./testdir2")
-    print(vfs.getcwd())
+    print(fs.getcwd())
-    vfs.chdir("../testdir")
+    fs.chdir("../testdir")
-    print(vfs.getcwd())
+    print(fs.getcwd())
-    vfs.chdir("../..")
+    fs.chdir("../..")
-    print(vfs.getcwd())
+    print(fs.getcwd())
-    vfs.chdir(".//testdir")
+    fs.chdir(".//testdir")
-    print(vfs.getcwd())
+    print(fs.getcwd())
-    vfs.chdir("subdir/./")
+    fs.chdir("subdir/./")
-    print(vfs.getcwd())
+    print(fs.getcwd())
-    vfs.chdir("/")
+    fs.chdir("/")
-    print(vfs.getcwd())
+    print(fs.getcwd())
-    vfs.rmdir("testdir/subdir")
+    fs.rmdir("testdir/subdir")
-    vfs.rmdir("testdir")
+    fs.rmdir("testdir")
-    vfs.rmdir("testdir2")
+    fs.rmdir("testdir2")
 
 
 bdev = RAMBlockDevice(30)
-test(bdev, os.VfsLfs1)
+test(bdev, vfs.VfsLfs1)
-test(bdev, os.VfsLfs2)
+test(bdev, vfs.VfsLfs2)

tests/extmod/vfs_lfs_corrupt.py

@@ -1,10 +1,10 @@
 # Test for VfsLittle using a RAM device, testing error handling from corrupt block device
 
 try:
-    import os
+    import vfs
 
-    os.VfsLfs1
+    vfs.VfsLfs1
-    os.VfsLfs2
+    vfs.VfsLfs2
 except (ImportError, AttributeError):
     print("SKIP")
     raise SystemExit
@@ -47,28 +47,28 @@ def corrupt(bdev, block):
 def create_vfs(bdev, vfs_class):
     bdev.ret = 0
     vfs_class.mkfs(bdev)
-    vfs = vfs_class(bdev)
+    fs = vfs_class(bdev)
-    with vfs.open("f", "w") as f:
+    with fs.open("f", "w") as f:
         for i in range(100):
             f.write("test")
-    return vfs
+    return fs
 
 
 def test(bdev, vfs_class):
     print("test", vfs_class)
 
     # statvfs
-    vfs = create_vfs(bdev, vfs_class)
+    fs = create_vfs(bdev, vfs_class)
     corrupt(bdev, 0)
     corrupt(bdev, 1)
     try:
-        print(vfs.statvfs(""))
+        print(fs.statvfs(""))
     except OSError:
         print("statvfs OSError")
 
     # error during read
-    vfs = create_vfs(bdev, vfs_class)
+    fs = create_vfs(bdev, vfs_class)
-    f = vfs.open("f", "r")
+    f = fs.open("f", "r")
     bdev.ret = -5  # EIO
     try:
         f.read(10)
@@ -76,8 +76,8 @@ def test(bdev, vfs_class):
         print("read OSError")
 
     # error during write
-    vfs = create_vfs(bdev, vfs_class)
+    fs = create_vfs(bdev, vfs_class)
-    f = vfs.open("f", "a")
+    f = fs.open("f", "a")
     bdev.ret = -5  # EIO
     try:
         f.write("test")
@@ -85,8 +85,8 @@ def test(bdev, vfs_class):
         print("write OSError")
 
     # error during close
-    vfs = create_vfs(bdev, vfs_class)
+    fs = create_vfs(bdev, vfs_class)
-    f = vfs.open("f", "w")
+    f = fs.open("f", "w")
     f.write("test")
     bdev.ret = -5  # EIO
     try:
@@ -95,8 +95,8 @@ def test(bdev, vfs_class):
         print("close OSError")
 
     # error during flush
-    vfs = create_vfs(bdev, vfs_class)
+    fs = create_vfs(bdev, vfs_class)
-    f = vfs.open("f", "w")
+    f = fs.open("f", "w")
     f.write("test")
     bdev.ret = -5  # EIO
     try:
@@ -108,5 +108,5 @@ def test(bdev, vfs_class):
 
 
 bdev = RAMBlockDevice(30)
-test(bdev, os.VfsLfs1)
+test(bdev, vfs.VfsLfs1)
-test(bdev, os.VfsLfs2)
+test(bdev, vfs.VfsLfs2)

tests/extmod/vfs_lfs_error.py

@@ -1,10 +1,10 @@
 # Test for VfsLittle using a RAM device, testing error handling
 
 try:
-    import os
+    import vfs
 
-    os.VfsLfs1
+    vfs.VfsLfs1
-    os.VfsLfs2
+    vfs.VfsLfs2
 except (ImportError, AttributeError):
     print("SKIP")
     raise SystemExit
@@ -52,63 +52,63 @@ def test(bdev, vfs_class):
 
     # set up for following tests
     vfs_class.mkfs(bdev)
-    vfs = vfs_class(bdev)
+    fs = vfs_class(bdev)
-    with vfs.open("testfile", "w") as f:
+    with fs.open("testfile", "w") as f:
         f.write("test")
-    vfs.mkdir("testdir")
+    fs.mkdir("testdir")
 
     # ilistdir
     try:
-        vfs.ilistdir("noexist")
+        fs.ilistdir("noexist")
     except OSError:
         print("ilistdir OSError")
 
     # remove
     try:
-        vfs.remove("noexist")
+        fs.remove("noexist")
     except OSError:
         print("remove OSError")
 
     # rmdir
     try:
-        vfs.rmdir("noexist")
+        fs.rmdir("noexist")
     except OSError:
         print("rmdir OSError")
 
     # rename
     try:
-        vfs.rename("noexist", "somethingelse")
+        fs.rename("noexist", "somethingelse")
     except OSError:
         print("rename OSError")
 
     # mkdir
     try:
-        vfs.mkdir("testdir")
+        fs.mkdir("testdir")
     except OSError:
         print("mkdir OSError")
 
     # chdir to nonexistent
     try:
-        vfs.chdir("noexist")
+        fs.chdir("noexist")
     except OSError:
         print("chdir OSError")
-    print(vfs.getcwd())  # check still at root
+    print(fs.getcwd())  # check still at root
 
     # chdir to file
     try:
-        vfs.chdir("testfile")
+        fs.chdir("testfile")
     except OSError:
         print("chdir OSError")
-    print(vfs.getcwd())  # check still at root
+    print(fs.getcwd())  # check still at root
 
     # stat
     try:
-        vfs.stat("noexist")
+        fs.stat("noexist")
     except OSError:
         print("stat OSError")
 
     # error during seek
-    with vfs.open("testfile", "r") as f:
+    with fs.open("testfile", "r") as f:
         f.seek(1 << 30)  # SEEK_SET
         try:
             f.seek(1 << 30, 1)  # SEEK_CUR
@@ -117,5 +117,5 @@ def test(bdev, vfs_class):
 
 
 bdev = RAMBlockDevice(30)
-test(bdev, os.VfsLfs1)
+test(bdev, vfs.VfsLfs1)
-test(bdev, os.VfsLfs2)
+test(bdev, vfs.VfsLfs2)

tests/extmod/vfs_lfs_file.py

@@ -1,10 +1,10 @@
 # Test for VfsLittle using a RAM device, file IO
 
 try:
-    import os
+    import vfs
 
-    os.VfsLfs1
+    vfs.VfsLfs1
-    os.VfsLfs2
+    vfs.VfsLfs2
 except (ImportError, AttributeError):
     print("SKIP")
     raise SystemExit
@@ -42,10 +42,10 @@ def test(bdev, vfs_class):
     vfs_class.mkfs(bdev)
 
     # construction
-    vfs = vfs_class(bdev)
+    fs = vfs_class(bdev)
 
     # create text, print, write, close
-    f = vfs.open("test.txt", "wt")
+    f = fs.open("test.txt", "wt")
     print(f)
     f.write("littlefs")
     f.close()
@@ -54,48 +54,48 @@ def test(bdev, vfs_class):
     f.close()
 
     # create binary, print, write, flush, close
-    f = vfs.open("test.bin", "wb")
+    f = fs.open("test.bin", "wb")
     print(f)
     f.write("littlefs")
     f.flush()
     f.close()
 
     # create for append
-    f = vfs.open("test.bin", "ab")
+    f = fs.open("test.bin", "ab")
     f.write("more")
     f.close()
 
     # create exclusive
-    f = vfs.open("test2.bin", "xb")
+    f = fs.open("test2.bin", "xb")
     f.close()
 
     # create exclusive with error
     try:
-        vfs.open("test2.bin", "x")
+        fs.open("test2.bin", "x")
     except OSError:
         print("open OSError")
 
     # read default
-    with vfs.open("test.txt", "") as f:
+    with fs.open("test.txt", "") as f:
         print(f.read())
 
     # read text
-    with vfs.open("test.txt", "rt") as f:
+    with fs.open("test.txt", "rt") as f:
         print(f.read())
 
     # read binary
-    with vfs.open("test.bin", "rb") as f:
+    with fs.open("test.bin", "rb") as f:
         print(f.read())
 
     # create read and write
-    with vfs.open("test.bin", "r+b") as f:
+    with fs.open("test.bin", "r+b") as f:
         print(f.read(8))
         f.write("MORE")
-    with vfs.open("test.bin", "rb") as f:
+    with fs.open("test.bin", "rb") as f:
         print(f.read())
 
     # seek and tell
-    f = vfs.open("test.txt", "r")
+    f = fs.open("test.txt", "r")
     print(f.tell())
     f.seek(3, 0)
     print(f.tell())
@@ -103,13 +103,13 @@ def test(bdev, vfs_class):
 
     # open nonexistent
     try:
-        vfs.open("noexist", "r")
+        fs.open("noexist", "r")
     except OSError:
         print("open OSError")
 
     # open multiple files at the same time
-    f1 = vfs.open("test.txt", "")
+    f1 = fs.open("test.txt", "")
-    f2 = vfs.open("test.bin", "b")
+    f2 = fs.open("test.bin", "b")
     print(f1.read())
     print(f2.read())
     f1.close()
@@ -117,5 +117,5 @@ def test(bdev, vfs_class):
 
 
 bdev = RAMBlockDevice(30)
-test(bdev, os.VfsLfs1)
+test(bdev, vfs.VfsLfs1)
-test(bdev, os.VfsLfs2)
+test(bdev, vfs.VfsLfs2)

tests/extmod/vfs_lfs_ilistdir_del.py

@@ -2,9 +2,9 @@
 import gc
 
 try:
-    import os
+    import vfs
 
-    os.VfsLfs2
+    vfs.VfsLfs2
 except (ImportError, AttributeError):
     print("SKIP")
     raise SystemExit
@@ -37,29 +37,29 @@ class RAMBlockDevice:
 
 def test(bdev, vfs_class):
     vfs_class.mkfs(bdev)
-    vfs = vfs_class(bdev)
+    fs = vfs_class(bdev)
-    vfs.mkdir("/test_d1")
+    fs.mkdir("/test_d1")
-    vfs.mkdir("/test_d2")
+    fs.mkdir("/test_d2")
-    vfs.mkdir("/test_d3")
+    fs.mkdir("/test_d3")
 
     for i in range(10):
         print(i)
 
         # We want to partially iterate the ilistdir iterator to leave it in an
         # open state, which will then test the finaliser when it's garbage collected.
-        idir = vfs.ilistdir("/")
+        idir = fs.ilistdir("/")
         print(any(idir))
 
         # Alternate way of partially iterating the ilistdir object, modifying the
         # filesystem while it's open.
-        for dname, *_ in vfs.ilistdir("/"):
+        for dname, *_ in fs.ilistdir("/"):
-            vfs.rmdir(dname)
+            fs.rmdir(dname)
             break
-        vfs.mkdir(dname)
+        fs.mkdir(dname)
 
         # Also create a fully drained iterator and ensure trying to reuse it
         # throws the correct exception.
-        idir_emptied = vfs.ilistdir("/")
+        idir_emptied = fs.ilistdir("/")
         l = list(idir_emptied)
         print(len(l))
         try:
@@ -68,8 +68,8 @@ def test(bdev, vfs_class):
             pass
 
         gc.collect()
-        vfs.open("/test", "w").close()
+        fs.open("/test", "w").close()
 
 
 bdev = RAMBlockDevice(30)
-test(bdev, os.VfsLfs2)
+test(bdev, vfs.VfsLfs2)

tests/extmod/vfs_lfs_mount.py

@@ -1,10 +1,10 @@
 # Test for VfsLittle using a RAM device, with mount/umount
 
 try:
-    import os
+    import os, vfs
 
-    os.VfsLfs1
+    vfs.VfsLfs1
-    os.VfsLfs2
+    vfs.VfsLfs2
 except (ImportError, AttributeError):
     print("SKIP")
     raise SystemExit
@@ -42,7 +42,7 @@ def test(vfs_class):
 
     # mount bdev unformatted
     try:
-        os.mount(bdev, "/lfs")
+        vfs.mount(bdev, "/lfs")
     except Exception as er:
         print(repr(er))
 
@@ -50,10 +50,10 @@ def test(vfs_class):
     vfs_class.mkfs(bdev)
 
     # construction
-    vfs = vfs_class(bdev)
+    fs = vfs_class(bdev)
 
     # mount
-    os.mount(vfs, "/lfs")
+    vfs.mount(fs, "/lfs")
 
     # import
     with open("/lfs/lfsmod.py", "w") as f:
@@ -73,11 +73,11 @@ def test(vfs_class):
     import lfsmod2
 
     # umount
-    os.umount("/lfs")
+    vfs.umount("/lfs")
 
     # mount read-only
-    vfs = vfs_class(bdev)
+    fs = vfs_class(bdev)
-    os.mount(vfs, "/lfs", readonly=True)
+    vfs.mount(fs, "/lfs", readonly=True)
 
     # test reading works
     with open("/lfs/subdir/lfsmod2.py") as f:
@@ -90,13 +90,13 @@ def test(vfs_class):
         print(repr(er))
 
     # umount
-    os.umount("/lfs")
+    vfs.umount("/lfs")
 
     # mount bdev again
-    os.mount(bdev, "/lfs")
+    vfs.mount(bdev, "/lfs")
 
     # umount
-    os.umount("/lfs")
+    vfs.umount("/lfs")
 
     # clear imported modules
     sys.modules.clear()
@@ -110,5 +110,5 @@ sys.path.append("/lfs")
 sys.path.append("")
 
 # run tests
-test(os.VfsLfs1)
+test(vfs.VfsLfs1)
-test(os.VfsLfs2)
+test(vfs.VfsLfs2)

tests/extmod/vfs_lfs_mtime.py

@@ -1,11 +1,11 @@
 # Test for VfsLfs using a RAM device, mtime feature
 
 try:
-    import time, os
+    import time, vfs
 
     time.time
     time.sleep
-    os.VfsLfs2
+    vfs.VfsLfs2
 except (ImportError, AttributeError):
     print("SKIP")
     raise SystemExit
@@ -44,21 +44,21 @@ def test(bdev, vfs_class):
 
     # construction
     print("mtime=True")
-    vfs = vfs_class(bdev, mtime=True)
+    fs = vfs_class(bdev, mtime=True)
 
     # Create an empty file, should have a timestamp.
     current_time = int(time.time())
-    vfs.open("test1", "wt").close()
+    fs.open("test1", "wt").close()
 
     # Wait 1 second so mtime will increase by at least 1.
     time.sleep(1)
 
     # Create another empty file, should have a timestamp.
-    vfs.open("test2", "wt").close()
+    fs.open("test2", "wt").close()
 
     # Stat the files and check mtime is non-zero.
-    stat1 = vfs.stat("test1")
+    stat1 = fs.stat("test1")
-    stat2 = vfs.stat("test2")
+    stat2 = fs.stat("test2")
     print(stat1[8] != 0, stat2[8] != 0)
 
     # Check that test1 has mtime which matches time.time() at point of creation.
@@ -71,34 +71,34 @@ def test(bdev, vfs_class):
     time.sleep(1)
 
     # Open test1 for reading and ensure mtime did not change.
-    vfs.open("test1", "rt").close()
+    fs.open("test1", "rt").close()
-    print(vfs.stat("test1") == stat1)
+    print(fs.stat("test1") == stat1)
 
     # Open test1 for writing and ensure mtime increased from the previous value.
-    vfs.open("test1", "wt").close()
+    fs.open("test1", "wt").close()
     stat1_old = stat1
-    stat1 = vfs.stat("test1")
+    stat1 = fs.stat("test1")
     print(stat1_old[8] < stat1[8])
 
     # Unmount.
-    vfs.umount()
+    fs.umount()
 
     # Check that remounting with mtime=False can read the timestamps.
     print("mtime=False")
-    vfs = vfs_class(bdev, mtime=False)
+    fs = vfs_class(bdev, mtime=False)
-    print(vfs.stat("test1") == stat1)
+    print(fs.stat("test1") == stat1)
-    print(vfs.stat("test2") == stat2)
+    print(fs.stat("test2") == stat2)
-    f = vfs.open("test1", "wt")
+    f = fs.open("test1", "wt")
     f.close()
-    print(vfs.stat("test1") == stat1)
+    print(fs.stat("test1") == stat1)
-    vfs.umount()
+    fs.umount()
 
     # Check that remounting with mtime=True still has the timestamps.
     print("mtime=True")
-    vfs = vfs_class(bdev, mtime=True)
+    fs = vfs_class(bdev, mtime=True)
-    print(vfs.stat("test1") == stat1)
+    print(fs.stat("test1") == stat1)
-    print(vfs.stat("test2") == stat2)
+    print(fs.stat("test2") == stat2)
-    vfs.umount()
+    fs.umount()
 
 
 try:
@@ -107,4 +107,4 @@ except MemoryError:
     print("SKIP")
     raise SystemExit
 
-test(bdev, os.VfsLfs2)
+test(bdev, vfs.VfsLfs2)

tests/extmod/vfs_lfs_superblock.py

@@ -1,9 +1,9 @@
 # Test for VfsLfs using a RAM device, when the first superblock does not exist
 
 try:
-    import os
+    import os, vfs
 
-    os.VfsLfs2
+    vfs.VfsLfs2
 except (ImportError, AttributeError):
     print("SKIP")
     raise SystemExit
@@ -36,12 +36,12 @@ lfs2_data = b"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x
 bdev = RAMBlockDevice(64, lfs2_data)
 
 # Create the VFS explicitly, no auto-detection is needed for this.
-vfs = os.VfsLfs2(bdev)
+fs = vfs.VfsLfs2(bdev)
-print(list(vfs.ilistdir()))
+print(list(fs.ilistdir()))
 
 # Mount the block device directly; this relies on auto-detection.
-os.mount(bdev, "/userfs")
+vfs.mount(bdev, "/userfs")
 print(os.listdir("/userfs"))
 
 # Clean up.
-os.umount("/userfs")
+vfs.umount("/userfs")

tests/extmod/vfs_posix.py

@@ -1,10 +1,9 @@
 # Test for VfsPosix
 
 try:
-    import gc
+    import gc, os, vfs
-    import os
 
-    os.VfsPosix
+    vfs.VfsPosix
 except (ImportError, AttributeError):
     print("SKIP")
     raise SystemExit
@@ -13,8 +12,6 @@ except (ImportError, AttributeError):
 # Skip the test if it does exist.
 temp_dir = "micropy_test_dir"
 try:
-    import os
-
     os.stat(temp_dir)
     print("SKIP")
     raise SystemExit
@@ -87,35 +84,35 @@ os.rename(temp_dir + "/test", temp_dir + "/test2")
 print(os.listdir(temp_dir))
 
 # construct new VfsPosix with path argument
-vfs = os.VfsPosix(temp_dir)
+fs = vfs.VfsPosix(temp_dir)
-# when VfsPosix is used the intended way via os.mount(), it can only be called
+# when VfsPosix is used the intended way via vfs.mount(), it can only be called
 # with relative paths when the CWD is inside or at its root, so simulate that
 os.chdir(temp_dir)
-print(list(i[0] for i in vfs.ilistdir(".")))
+print(list(i[0] for i in fs.ilistdir(".")))
 
 # stat, statvfs (statvfs may not exist)
-print(type(vfs.stat(".")))
+print(type(fs.stat(".")))
-if hasattr(vfs, "statvfs"):
+if hasattr(fs, "statvfs"):
-    assert type(vfs.statvfs(".")) is tuple
+    assert type(fs.statvfs(".")) is tuple
 
 # check types of ilistdir with str/bytes arguments
-print(type(list(vfs.ilistdir("."))[0][0]))
+print(type(list(fs.ilistdir("."))[0][0]))
-print(type(list(vfs.ilistdir(b"."))[0][0]))
+print(type(list(fs.ilistdir(b"."))[0][0]))
 
 # chdir should not affect absolute paths (regression test)
-vfs.mkdir("/subdir")
+fs.mkdir("/subdir")
-vfs.mkdir("/subdir/micropy_test_dir")
+fs.mkdir("/subdir/micropy_test_dir")
-with vfs.open("/subdir/micropy_test_dir/test2", "w") as f:
+with fs.open("/subdir/micropy_test_dir/test2", "w") as f:
     f.write("wrong")
-vfs.chdir("/subdir")
+fs.chdir("/subdir")
-with vfs.open("/test2", "r") as f:
+with fs.open("/test2", "r") as f:
     print(f.read())
 os.chdir(curdir)
-vfs.remove("/subdir/micropy_test_dir/test2")
+fs.remove("/subdir/micropy_test_dir/test2")
-vfs.rmdir("/subdir/micropy_test_dir")
+fs.rmdir("/subdir/micropy_test_dir")
-vfs.rmdir("/subdir")
+fs.rmdir("/subdir")
 
-# done with vfs, restore CWD
+# done with fs, restore CWD
 os.chdir(curdir)
 
 # remove

tests/extmod/vfs_posix_enoent.py

@@ -1,10 +1,9 @@
 # Test for VfsPosix error conditions
 
 try:
-    import os
+    import os, sys, vfs
-    import sys
 
-    os.VfsPosix
+    vfs.VfsPosix
 except (ImportError, AttributeError):
     print("SKIP")
     raise SystemExit
@@ -36,7 +35,7 @@ except OSError as e:
     print("getcwd():", repr(e))
 
 try:
-    print("VfsPosix():", os.VfsPosix("something"))
+    print("VfsPosix():", vfs.VfsPosix("something"))
 except OSError as e:
     # expecting ENOENT = 2
     print("VfsPosix():", repr(e))

tests/extmod/vfs_posix_ilistdir_del.py

@@ -2,9 +2,9 @@
 import gc
 
 try:
-    import os
+    import os, vfs
 
-    os.VfsPosix
+    vfs.VfsPosix
 except (ImportError, AttributeError):
     print("SKIP")
     raise SystemExit
@@ -12,34 +12,34 @@ except (ImportError, AttributeError):
 
 def test(testdir):
     curdir = os.getcwd()
-    vfs = os.VfsPosix(testdir)
+    fs = vfs.VfsPosix(testdir)
-    # When VfsPosix is used the intended way via os.mount(), it can only be called
+    # When VfsPosix is used the intended way via vfs.mount(), it can only be called
     # with relative paths when the CWD is inside or at its root, so simulate that.
     # (Although perhaps calling with a relative path was an oversight in this case
-    # and the respective line below was meant to read `vfs.rmdir("/" + dname)`.)
+    # and the respective line below was meant to read `fs.rmdir("/" + dname)`.)
     os.chdir(testdir)
-    vfs.mkdir("/test_d1")
+    fs.mkdir("/test_d1")
-    vfs.mkdir("/test_d2")
+    fs.mkdir("/test_d2")
-    vfs.mkdir("/test_d3")
+    fs.mkdir("/test_d3")
 
     for i in range(10):
         print(i)
 
         # We want to partially iterate the ilistdir iterator to leave it in an
         # open state, which will then test the finaliser when it's garbage collected.
-        idir = vfs.ilistdir("/")
+        idir = fs.ilistdir("/")
         print(any(idir))
 
         # Alternate way of partially iterating the ilistdir object, modifying the
         # filesystem while it's open.
-        for dname, *_ in vfs.ilistdir("/"):
+        for dname, *_ in fs.ilistdir("/"):
-            vfs.rmdir(dname)
+            fs.rmdir(dname)
             break
-        vfs.mkdir(dname)
+        fs.mkdir(dname)
 
         # Also create a fully drained iterator and ensure trying to reuse it
         # throws the correct exception.
-        idir_emptied = vfs.ilistdir("/")
+        idir_emptied = fs.ilistdir("/")
         l = list(idir_emptied)
         print(len(l))
         try:
@@ -51,10 +51,10 @@ def test(testdir):
 
         # Create and delete a file, try to flush out any filesystem
         # corruption that may be caused over the loops.
-        vfs.open("/test", "w").close()
+        fs.open("/test", "w").close()
-        vfs.remove("/test")
+        fs.remove("/test")
 
-    # Done with vfs, restore CWD.
+    # Done with fs, restore CWD.
     os.chdir(curdir)
 
 

tests/extmod/vfs_posix_ilistdir_filter.py

@@ -1,9 +1,9 @@
 # Test ilistdir filter of . and .. for VfsPosix.
 
 try:
-    import os
+    import os, vfs
 
-    os.VfsPosix
+    vfs.VfsPosix
 except (ImportError, AttributeError):
     print("SKIP")
     raise SystemExit
@@ -11,24 +11,24 @@ except (ImportError, AttributeError):
 
 def test(testdir):
     curdir = os.getcwd()
-    vfs = os.VfsPosix(testdir)
+    fs = vfs.VfsPosix(testdir)
-    # When VfsPosix is used the intended way via os.mount(), it can only be called
+    # When VfsPosix is used the intended way via vfs.mount(), it can only be called
     # with relative paths when the CWD is inside or at its root, so simulate that.
     os.chdir(testdir)
 
     dirs = [".a", "..a", "...a", "a.b", "a..b"]
 
     for dir in dirs:
-        vfs.mkdir(dir)
+        fs.mkdir(dir)
 
     dirs = []
-    for entry in vfs.ilistdir("/"):
+    for entry in fs.ilistdir("/"):
         dirs.append(entry[0])
     dirs.sort()
 
     print(dirs)
 
-    # Done with vfs, restore CWD.
+    # Done with fs, restore CWD.
     os.chdir(curdir)
 
 

tests/extmod/vfs_posix_paths.py

@@ -1,9 +1,9 @@
 # Test for VfsPosix with relative paths
 
 try:
-    import os
+    import os, vfs
 
-    os.VfsPosix
+    vfs.VfsPosix
 except (ImportError, AttributeError):
     print("SKIP")
     raise SystemExit
@@ -12,8 +12,6 @@ except (ImportError, AttributeError):
 # Skip the test if it does exist.
 temp_dir = "vfs_posix_paths_test_dir"
 try:
-    import os
-
     os.stat(temp_dir)
     print("SKIP")
     raise SystemExit
@@ -25,26 +23,26 @@ os.mkdir(temp_dir)
 
 # construct new VfsPosix with absolute path argument
 temp_dir_abs = os.getcwd() + os.sep + temp_dir
-vfs = os.VfsPosix(temp_dir_abs)
+fs = vfs.VfsPosix(temp_dir_abs)
-# when VfsPosix is used the intended way via os.mount(), it can only be called
+# when VfsPosix is used the intended way via vfs.mount(), it can only be called
 # with relative paths when the CWD is inside or at its root, so simulate that
 os.chdir(temp_dir_abs)
-vfs.mkdir("subdir")
+fs.mkdir("subdir")
-vfs.mkdir("subdir/one")
+fs.mkdir("subdir/one")
-print('listdir("/"):', sorted(i[0] for i in vfs.ilistdir("/")))
+print('listdir("/"):', sorted(i[0] for i in fs.ilistdir("/")))
-print('listdir("."):', sorted(i[0] for i in vfs.ilistdir(".")))
+print('listdir("."):', sorted(i[0] for i in fs.ilistdir(".")))
-print('getcwd() in {"", "/"}:', vfs.getcwd() in {"", "/"})
+print('getcwd() in {"", "/"}:', fs.getcwd() in {"", "/"})
-print('chdir("subdir"):', vfs.chdir("subdir"))
+print('chdir("subdir"):', fs.chdir("subdir"))
-print("getcwd():", vfs.getcwd())
+print("getcwd():", fs.getcwd())
-print('mkdir("two"):', vfs.mkdir("two"))
+print('mkdir("two"):', fs.mkdir("two"))
-f = vfs.open("file.py", "w")
+f = fs.open("file.py", "w")
 f.write("print('hello')")
 f.close()
-print('listdir("/"):', sorted(i[0] for i in vfs.ilistdir("/")))
+print('listdir("/"):', sorted(i[0] for i in fs.ilistdir("/")))
-print('listdir("/subdir"):', sorted(i[0] for i in vfs.ilistdir("/subdir")))
+print('listdir("/subdir"):', sorted(i[0] for i in fs.ilistdir("/subdir")))
-print('listdir("."):', sorted(i[0] for i in vfs.ilistdir(".")))
+print('listdir("."):', sorted(i[0] for i in fs.ilistdir(".")))
 try:
-    f = vfs.open("/subdir/file.py", "r")
+    f = fs.open("/subdir/file.py", "r")
     print(f.read())
     f.close()
 except Exception as e:
@@ -59,17 +57,17 @@ try:
 except Exception as e:
     print(e)
 del sys.path[0]
-vfs.remove("file.py")
+fs.remove("file.py")
-vfs.rmdir("two")
+fs.rmdir("two")
-vfs.rmdir("/subdir/one")
+fs.rmdir("/subdir/one")
-vfs.chdir("/")
+fs.chdir("/")
-vfs.rmdir("/subdir")
+fs.rmdir("/subdir")
 
-# done with vfs, restore CWD
+# done with fs, restore CWD
 os.chdir(curdir)
 
 # some integration tests with a mounted VFS
-os.mount(os.VfsPosix(temp_dir_abs), "/mnt")
+vfs.mount(vfs.VfsPosix(temp_dir_abs), "/mnt")
 os.mkdir("/mnt/dir")
 print('chdir("/mnt/dir"):', os.chdir("/mnt/dir"))
 print("getcwd():", os.getcwd())
@@ -82,7 +80,7 @@ print("getcwd():", os.getcwd())
 print('chdir(".."):', os.chdir(".."))
 print("getcwd():", os.getcwd())
 os.rmdir("/mnt/dir")
-os.umount("/mnt")
+vfs.umount("/mnt")
 
 # restore CWD
 os.chdir(curdir)

tests/extmod/vfs_userfs.py

@@ -4,12 +4,9 @@
 import sys
 
 try:
-    import io
+    import io, vfs
 
     io.IOBase
-    import os
-
-    os.mount
 except (ImportError, AttributeError):
     print("SKIP")
     raise SystemExit
@@ -79,7 +76,7 @@ user_files = {
     "/usermod5.py": b"print('in usermod5')",
     "/usermod6.py": b"print('in usermod6')",
 }
-os.mount(UserFS(user_files), "/userfs")
+vfs.mount(UserFS(user_files), "/userfs")
 
 # open and read a file
 f = open("/userfs/data.txt")
@@ -110,5 +107,5 @@ UserFile.buffer_size = 1024
 import usermod6
 
 # unmount and undo path addition
-os.umount("/userfs")
+vfs.umount("/userfs")
 sys.path.pop()

tests/micropython/builtin_execfile.py

@@ -1,11 +1,10 @@
 # Test builtin execfile function using VFS.
 
 try:
-    import io, os
+    import io, os, vfs
 
     execfile
     io.IOBase
-    os.mount
 except (ImportError, NameError, AttributeError):
     print("SKIP")
     raise SystemExit
@@ -44,25 +43,21 @@ class Filesystem:
 
 # First umount any existing mount points the target may have.
 try:
-    import io, os
+    vfs.umount("/")
-
-    os.umount("/")
 except OSError:
     pass
 for path in os.listdir("/"):
-    os.umount("/" + path)
+    vfs.umount("/" + path)
 
 # Create and mount the VFS object.
 files = {
     "/test.py": "print(123)",
 }
 fs = Filesystem(files)
-os.mount(fs, "/test_mnt")
+vfs.mount(fs, "/test_mnt")
 
 # Test execfile with a file that doesn't exist.
 try:
-    import io, os
-
     execfile("/test_mnt/noexist.py")
 except OSError:
     print("OSError")
@@ -77,4 +72,4 @@ except TypeError:
     print("TypeError")
 
 # Unmount the VFS object.
-os.umount(fs)
+vfs.umount(fs)

tests/micropython/import_mpy_invalid.py

@@ -1,10 +1,9 @@
 # test importing of invalid .mpy files
 
 try:
-    import sys, io, os
+    import sys, io, vfs
 
     io.IOBase
-    os.mount
 except (ImportError, AttributeError):
     print("SKIP")
     raise SystemExit
@@ -52,7 +51,7 @@ user_files = {
 }
 
 # create and mount a user filesystem
-os.mount(UserFS(user_files), "/userfs")
+vfs.mount(UserFS(user_files), "/userfs")
 sys.path.append("/userfs")
 
 # import .mpy files from the user filesystem
@@ -64,5 +63,5 @@ for i in range(len(user_files)):
         print(mod, "ValueError", er)
 
 # unmount and undo path addition
-os.umount("/userfs")
+vfs.umount("/userfs")
 sys.path.pop()

tests/micropython/import_mpy_native.py

@@ -1,11 +1,10 @@
 # test importing of .mpy files with native code
 
 try:
-    import sys, io, os
+    import sys, io, vfs
 
     sys.implementation._mpy
     io.IOBase
-    os.mount
 except (ImportError, AttributeError):
     print("SKIP")
     raise SystemExit
@@ -110,7 +109,7 @@ user_files = {
 # fmt: on
 
 # create and mount a user filesystem
-os.mount(UserFS(user_files), "/userfs")
+vfs.mount(UserFS(user_files), "/userfs")
 sys.path.append("/userfs")
 
 # import .mpy files from the user filesystem
@@ -123,5 +122,5 @@ for i in range(len(user_files)):
         print(mod, "ValueError", er)
 
 # unmount and undo path addition
-os.umount("/userfs")
+vfs.umount("/userfs")
 sys.path.pop()

tests/micropython/import_mpy_native_gc.py

@@ -1,11 +1,10 @@
 # Test that native code loaded from a .mpy file is retained after a GC.
 
 try:
-    import gc, sys, io, os
+    import gc, sys, io, vfs
 
     sys.implementation._mpy
     io.IOBase
-    os.mount
 except (ImportError, AttributeError):
     print("SKIP")
     raise SystemExit
@@ -72,7 +71,7 @@ if sys_implementation_mpy not in features0_file_contents:
 user_files = {"/features0.mpy": features0_file_contents[sys_implementation_mpy]}
 
 # Create and mount a user filesystem.
-os.mount(UserFS(user_files), "/userfs")
+vfs.mount(UserFS(user_files), "/userfs")
 sys.path.append("/userfs")
 
 # Import the native function.
@@ -93,5 +92,5 @@ for i in range(1000):
 print(factorial(10))
 
 # Unmount and undo path addition.
-os.umount("/userfs")
+vfs.umount("/userfs")
 sys.path.pop()

tests/perf_bench/core_import_mpy_multi.py

@@ -1,8 +1,8 @@
 # Test performance of importing an .mpy file many times.
 
-import sys, io, os
+import sys, io, vfs
 
-if not (hasattr(io, "IOBase") and hasattr(os, "mount")):
+if not hasattr(io, "IOBase"):
     print("SKIP")
     raise SystemExit
 
@@ -57,7 +57,7 @@ class FS:
 
 
 def mount():
-    os.mount(FS(), "/__remote")
+    vfs.mount(FS(), "/__remote")
     sys.path.insert(0, "/__remote")
 
 

tests/perf_bench/core_import_mpy_single.py

@@ -2,9 +2,9 @@
 # The first import of a module will intern strings that don't already exist, and
 # this test should be representative of what happens in a real application.
 
-import io, os, sys
+import sys, io, vfs
 
-if not (hasattr(io, "IOBase") and hasattr(os, "mount")):
+if not hasattr(io, "IOBase"):
     print("SKIP")
     raise SystemExit
 
@@ -112,7 +112,7 @@ class FS:
 
 
 def mount():
-    os.mount(FS(), "/__remote")
+    vfs.mount(FS(), "/__remote")
     sys.path.insert(0, "/__remote")
 
 

tests/ports/cc3200/os.py

@@ -3,7 +3,7 @@ os module test for the CC3200 based boards
 """
 
 from machine import SD
-import os
+import os, vfs
 
 mch = os.uname().machine
 if "LaunchPad" in mch:
@@ -15,7 +15,7 @@ else:
 
 sd = SD(pins=sd_pins)
 
-os.mount(sd, "/sd")
+vfs.mount(sd, "/sd")
 os.mkfs("/sd")
 os.chdir("/flash")
 print(os.listdir())
@@ -88,7 +88,7 @@ print(os.listdir("/"))
 os.unmount("/sd")
 print(os.listdir("/"))
 os.mkfs(sd)
-os.mount(sd, "/sd")
+vfs.mount(sd, "/sd")
 print(os.listdir("/"))
 os.chdir("/flash")
 
@@ -104,12 +104,12 @@ sd.init()
 print(os.listdir("/sd"))
 
 try:
-    os.mount(sd, "/sd")
+    vfs.mount(sd, "/sd")
 except:
     print("Exception")
 
 try:
-    os.mount(sd, "/sd2")
+    vfs.mount(sd, "/sd2")
 except:
     print("Exception")
 
@@ -159,6 +159,6 @@ try:
 except:
     print("Exception")
 
-os.mount(sd, "/sd")
+vfs.mount(sd, "/sd")
 print(os.listdir("/"))
 os.unmount("/sd")

tests/run-natmodtests.py

@@ -30,7 +30,7 @@ TEST_MAPPINGS = {
 
 # Code to allow a target MicroPython to import an .mpy from RAM
 injected_import_hook_code = """\
-import sys, os, io
+import sys, io, vfs
 class __File(io.IOBase):
   def __init__(self):
     self.off = 0
@@ -52,7 +52,7 @@ class __FS:
       raise OSError(-2) # ENOENT
   def open(self, path, mode):
     return __File()
-os.mount(__FS(), '/__remote')
+vfs.mount(__FS(), '/__remote')
 sys.path.insert(0, '/__remote')
 sys.modules['{}'] = __import__('__injected')
 """

tests/run-tests.py

@@ -59,7 +59,7 @@ os.environ["PYTHONIOENCODING"] = "utf-8"
 
 # Code to allow a target MicroPython to import an .mpy from RAM
 injected_import_hook_code = """\
-import sys, os, io
+import sys, os, io, vfs
 class __File(io.IOBase):
   def __init__(self):
     self.off = 0
@@ -83,7 +83,7 @@ class __FS:
       raise OSError(-2) # ENOENT
   def open(self, path, mode):
     return __File()
-os.mount(__FS(), '/__vfstest')
+vfs.mount(__FS(), '/__vfstest')
 os.chdir('/__vfstest')
 __import__('__injected_test')
 """