diff --git a/src/client/common/platform/fileSystem.ts b/src/client/common/platform/fileSystem.ts
index fadeccaaf929..4e05655583f1 100644
--- a/src/client/common/platform/fileSystem.ts
+++ b/src/client/common/platform/fileSystem.ts
@@ -3,22 +3,25 @@
 'use strict';
 
 import { createHash } from 'crypto';
-import * as fileSystem from 'fs';
 import * as fs from 'fs-extra';
 import * as glob from 'glob';
 import { inject, injectable } from 'inversify';
 import { promisify } from 'util';
+import * as vscode from 'vscode';
 import { createDeferred } from '../utils/async';
 import { noop } from '../utils/misc';
+import { isFileNotFoundError } from './errors';
 import { FileSystemPaths, FileSystemPathUtils } from './fs-paths';
 import { TemporaryFileSystem } from './fs-temp';
 // prettier-ignore
 import {
     FileStat, FileType,
-    IFileSystem, IFileSystemPaths, IPlatformService,
-    TemporaryFile
+    IFileSystem, IFileSystemPaths, IPlatformService, IRawFileSystem,
+    ReadStream, TemporaryFile, WriteStream
 } from './types';
 
+const ENCODING: string = 'utf8';
+
 const globAsync = promisify(glob);
 
 // This helper function determines the file type of the given stats
@@ -38,36 +41,6 @@ function convertFileType(stat: fs.Stats): FileType {
     }
 }
 
-async function getFileType(filename: string): Promise<FileType> {
-    let stat: fs.Stats;
-    try {
-        // Note that we used to use stat() here instead of lstat().
-        // This shouldn't matter because the only consumers were
-        // internal methods that have been updated appropriately.
-        stat = await fs.lstat(filename);
-    } catch {
-        return FileType.Unknown;
-    }
-    if (!stat.isSymbolicLink()) {
-        return convertFileType(stat);
-    }
-
-    // For symlinks we emulate the behavior of the vscode.workspace.fs API.
-    // See: https://code.visualstudio.com/api/references/vscode-api#FileType
-    try {
-        stat = await fs.stat(filename);
-    } catch {
-        return FileType.SymbolicLink;
-    }
-    if (stat.isFile()) {
-        return FileType.SymbolicLink | FileType.File;
-    } else if (stat.isDirectory()) {
-        return FileType.SymbolicLink | FileType.Directory;
-    } else {
-        return FileType.SymbolicLink;
-    }
-}
-
 export function convertStat(old: fs.Stats, filetype: FileType): FileStat {
     return {
         type: filetype,
@@ -81,8 +54,231 @@ export function convertStat(old: fs.Stats, filetype: FileType): FileStat {
     };
 }
 
+// prettier-ignore
+function filterByFileType(
+    files: [string, FileType][],
+    fileType: FileType
+): [string, FileType][] {
+    // We preserve the pre-existing behavior of following symlinks.
+    if (fileType === FileType.Unknown) {
+        // FileType.Unknown == 0 so we can't just use bitwise
+        // operations blindly here.
+        return files.filter(([_file, ft]) => {
+            return ft === FileType.Unknown || ft === (FileType.SymbolicLink & FileType.Unknown);
+        });
+    } else {
+        return files.filter(([_file, ft]) => (ft & fileType) > 0);
+    }
+}
+
+//==========================================
+// "raw" filesystem
+
+// This is the parts of the vscode.workspace.fs API that we use here.
+// See: https://code.visualstudio.com/api/references/vscode-api#FileSystem
+// Note that we have used all the API functions *except* "rename()".
+interface IVSCodeFileSystemAPI {
+    stat(uri: vscode.Uri): Thenable<FileStat>;
+}
+
+// This is the parts of the 'fs-extra' module that we use in RawFileSystem.
+interface IRawFSExtra {
+    stat(filename: string): Promise<fs.Stats>;
+    lstat(filename: string): Promise<fs.Stats>;
+    readdir(dirname: string): Promise<string[]>;
+    readFile(filename: string): Promise<Buffer>;
+    readFile(filename: string, encoding: string): Promise<string>;
+    mkdirp(dirname: string): Promise<void>;
+    chmod(filePath: string, mode: string | number): Promise<void>;
+    rename(src: string, tgt: string): Promise<void>;
+    writeFile(filename: string, data: {}, options: {}): Promise<void>;
+    appendFile(filename: string, data: {}): Promise<void>;
+    unlink(filename: string): Promise<void>;
+    rmdir(dirname: string): Promise<void>;
+
+    // non-async
+    readFileSync(path: string, encoding: string): string;
+    createReadStream(filename: string): ReadStream;
+    createWriteStream(filename: string): WriteStream;
+}
+
+interface IRawPath {
+    join(...paths: string[]): string;
+}
+
+// Later we will drop "FileSystem", switching usage to
+// "FileSystemUtils" and then rename "RawFileSystem" to "FileSystem".
+
+// The low-level filesystem operations used by the extension.
+export class RawFileSystem implements IRawFileSystem {
+    // prettier-ignore
+    constructor(
+        protected readonly paths: IRawPath,
+        protected readonly vscfs: IVSCodeFileSystemAPI,
+        protected readonly fsExtra: IRawFSExtra
+    ) { }
+
+    // Create a new object using common-case default values.
+    // prettier-ignore
+    public static withDefaults(
+        paths?: IRawPath,
+        vscfs?: IVSCodeFileSystemAPI,
+        fsExtra?: IRawFSExtra
+    ): RawFileSystem{
+        // prettier-ignore
+        return new RawFileSystem(
+            paths || FileSystemPaths.withDefaults(),
+            vscfs || vscode.workspace.fs,
+            fsExtra || fs
+        );
+    }
+
+    public async stat(filename: string): Promise<FileStat> {
+        // Note that, prior to the November release of VS Code,
+        // stat.ctime was always 0.
+        // See: https://github.com/microsoft/vscode/issues/84525
+        const uri = vscode.Uri.file(filename);
+        return this.vscfs.stat(uri);
+    }
+
+    public async lstat(filename: string): Promise<FileStat> {
+        const stat = await this.fsExtra.lstat(filename);
+        // Note that, unlike stat(), lstat() does not include the type
+        // of the symlink's target.
+        const fileType = convertFileType(stat);
+        return convertStat(stat, fileType);
+    }
+
+    public async chmod(filename: string, mode: string | number): Promise<void> {
+        return this.fsExtra.chmod(filename, mode);
+    }
+
+    public async move(src: string, tgt: string) {
+        await this.fsExtra.rename(src, tgt);
+    }
+
+    public async readData(filename: string): Promise<Buffer> {
+        return this.fsExtra.readFile(filename);
+    }
+
+    public async readText(filename: string): Promise<string> {
+        return this.fsExtra.readFile(filename, ENCODING);
+    }
+
+    public async writeText(filename: string, text: string): Promise<void> {
+        await this.fsExtra.writeFile(filename, text, { encoding: ENCODING });
+    }
+
+    public async appendText(filename: string, text: string): Promise<void> {
+        return this.fsExtra.appendFile(filename, text);
+    }
+
+    public async copyFile(src: string, dest: string): Promise<void> {
+        const deferred = createDeferred<void>();
+        // prettier-ignore
+        const rs = this.fsExtra.createReadStream(src)
+            .on('error', err => {
+                deferred.reject(err);
+            });
+        // prettier-ignore
+        const ws = this.fsExtra.createWriteStream(dest)
+            .on('error', err => {
+                deferred.reject(err);
+            })
+            .on('close', () => {
+                deferred.resolve();
+            });
+        rs.pipe(ws);
+        return deferred.promise;
+    }
+
+    public async rmfile(filename: string): Promise<void> {
+        return this.fsExtra.unlink(filename);
+    }
+
+    public async rmtree(dirname: string): Promise<void> {
+        return this.fsExtra.rmdir(dirname);
+    }
+
+    public async mkdirp(dirname: string): Promise<void> {
+        return this.fsExtra.mkdirp(dirname);
+    }
+
+    public async listdir(dirname: string): Promise<[string, FileType][]> {
+        const files = await this.fsExtra.readdir(dirname);
+        const promises = files.map(async basename => {
+            const filename = this.paths.join(dirname, basename);
+            // Note that this follows symlinks (while still preserving
+            // the Symlink flag).
+            const fileType = await this.getFileType(filename);
+            return [filename, fileType] as [string, FileType];
+        });
+        return Promise.all(promises);
+    }
+
+    //****************************
+    // non-async
+
+    public readTextSync(filename: string): string {
+        return this.fsExtra.readFileSync(filename, ENCODING);
+    }
+
+    public createReadStream(filename: string): ReadStream {
+        return this.fsExtra.createReadStream(filename);
+    }
+
+    public createWriteStream(filename: string): WriteStream {
+        return this.fsExtra.createWriteStream(filename);
+    }
+
+    //****************************
+    // internal
+
+    private async getFileType(filename: string): Promise<FileType> {
+        let stat: fs.Stats;
+        try {
+            // Note that we used to use stat() here instead of lstat().
+            // This shouldn't matter because the only consumers were
+            // internal methods that have been updated appropriately.
+            stat = await this.fsExtra.lstat(filename);
+        } catch (err) {
+            if (isFileNotFoundError(err)) {
+                return FileType.Unknown;
+            }
+            throw err;
+        }
+        if (!stat.isSymbolicLink()) {
+            return convertFileType(stat);
+        }
+
+        // For symlinks we emulate the behavior of the vscode.workspace.fs API.
+        // See: https://code.visualstudio.com/api/references/vscode-api#FileType
+        try {
+            stat = await this.fsExtra.stat(filename);
+        } catch (err) {
+            if (isFileNotFoundError(err)) {
+                return FileType.SymbolicLink;
+            }
+            throw err;
+        }
+        if (stat.isFile()) {
+            return FileType.SymbolicLink | FileType.File;
+        } else if (stat.isDirectory()) {
+            return FileType.SymbolicLink | FileType.Directory;
+        } else {
+            return FileType.SymbolicLink;
+        }
+    }
+}
+
+//==========================================
+// filesystem "utils" (& legacy aliases)
+
 @injectable()
 export class FileSystem implements IFileSystem {
+    // We expose this for the sake of functional tests that do not have
+    // access to the actual "vscode" namespace.
+    protected raw: RawFileSystem;
     private readonly paths: IFileSystemPaths;
     private readonly pathUtils: FileSystemPathUtils;
     private readonly tmp: TemporaryFileSystem;
@@ -96,6 +292,7 @@ export class FileSystem implements IFileSystem {
         );
         this.pathUtils = FileSystemPathUtils.withDefaults(this.paths);
         this.tmp = TemporaryFileSystem.withDefaults();
+        this.raw = RawFileSystem.withDefaults(this.paths);
     }
 
     //=================================
@@ -112,183 +309,139 @@ export class FileSystem implements IFileSystem {
     //=================================
     // "raw" operations
 
-    public async stat(filePath: string): Promise<FileStat> {
-        // Do not import vscode directly, as this isn't available in the Debugger Context.
-        // If stat is used in debugger context, it will fail, however theres a separate PR that will resolve this.
-        // tslint:disable-next-line: no-require-imports
-        const vscode = require('vscode');
-        // Note that, prior to the November release of VS Code,
-        // stat.ctime was always 0.
-        // See: https://github.com/microsoft/vscode/issues/84525
-        return vscode.workspace.fs.stat(vscode.Uri.file(filePath));
+    public async stat(filename: string): Promise<FileStat> {
+        return this.raw.stat(filename);
     }
+
     public async lstat(filename: string): Promise<FileStat> {
-        const stat = await fs.lstat(filename);
-        // Note that, unlike stat(), lstat() does not include the type
-        // of the symlink's target.
-        const fileType = convertFileType(stat);
-        return convertStat(stat, fileType);
+        return this.raw.lstat(filename);
     }
 
-    // Return the UTF8-decoded text of the file.
-    public readFile(filePath: string): Promise<string> {
-        return fs.readFile(filePath, 'utf8');
+    public async readFile(filePath: string): Promise<string> {
+        return this.raw.readText(filePath);
     }
     public readFileSync(filePath: string): string {
-        return fs.readFileSync(filePath, 'utf8');
+        return this.raw.readTextSync(filePath);
     }
-    public readData(filePath: string): Promise<Buffer> {
-        return fs.readFile(filePath);
+    public async readData(filePath: string): Promise<Buffer> {
+        return this.raw.readData(filePath);
     }
 
-    public async writeFile(filePath: string, data: {}, options: string | fs.WriteFileOptions = { encoding: 'utf8' }): Promise<void> {
-        await fs.writeFile(filePath, data, options);
+    public async writeFile(filePath: string, text: string, _options: string | fs.WriteFileOptions = { encoding: 'utf8' }): Promise<void> {
+        // tslint:disable-next-line:no-suspicious-comment
+        // TODO (GH-8542) For now we ignore the options, since all call
+        // sites already match the defaults.  Later we will fix the call
+        // sites.
+        return this.raw.writeText(filePath, text);
     }
 
-    public createDirectory(directoryPath: string): Promise<void> {
-        return fs.mkdirp(directoryPath);
+    public async createDirectory(directoryPath: string): Promise<void> {
+        return this.raw.mkdirp(directoryPath);
     }
 
-    public deleteDirectory(directoryPath: string): Promise<void> {
-        const deferred = createDeferred<void>();
-        fs.rmdir(directoryPath, err => (err ? deferred.reject(err) : deferred.resolve()));
-        return deferred.promise;
+    public async deleteDirectory(directoryPath: string): Promise<void> {
+        return this.raw.rmtree(directoryPath);
     }
 
     public async listdir(dirname: string): Promise<[string, FileType][]> {
-        const files = await fs.readdir(dirname);
-        const promises = files.map(async basename => {
-            const filename = this.paths.join(dirname, basename);
-            const fileType = await getFileType(filename);
-            return [filename, fileType] as [string, FileType];
-        });
-        return Promise.all(promises);
+        // prettier-ignore
+        return this.raw.listdir(dirname)
+            .catch(async err => {
+                // We're only preserving pre-existng behavior here...
+                if (!(await this.pathExists(dirname))) {
+                    return [];
+                }
+                throw err; // re-throw
+            });
     }
 
-    public appendFile(filename: string, data: {}): Promise<void> {
-        return fs.appendFile(filename, data);
+    public async appendFile(filename: string, text: string): Promise<void> {
+        return this.raw.appendText(filename, text);
     }
 
-    public copyFile(src: string, dest: string): Promise<void> {
-        const deferred = createDeferred<void>();
-        const rs = fs.createReadStream(src).on('error', err => {
-            deferred.reject(err);
-        });
-        const ws = fs
-            .createWriteStream(dest)
-            .on('error', err => {
-                deferred.reject(err);
-            })
-            .on('close', () => {
-                deferred.resolve();
-            });
-        rs.pipe(ws);
-        return deferred.promise;
+    public async copyFile(src: string, dest: string): Promise<void> {
+        return this.raw.copyFile(src, dest);
     }
 
-    public deleteFile(filename: string): Promise<void> {
-        const deferred = createDeferred<void>();
-        fs.unlink(filename, err => (err ? deferred.reject(err) : deferred.resolve()));
-        return deferred.promise;
+    public async deleteFile(filename: string): Promise<void> {
+        return this.raw.rmfile(filename);
     }
 
-    public chmod(filePath: string, mode: string | number): Promise<void> {
-        return new Promise<void>((resolve, reject) => {
-            fileSystem.chmod(filePath, mode, (err: NodeJS.ErrnoException | null) => {
-                if (err) {
-                    return reject(err);
-                }
-                resolve();
-            });
-        });
+    public async chmod(filePath: string, mode: string | number): Promise<void> {
+        return this.raw.chmod(filePath, mode);
     }
 
     public async move(src: string, tgt: string) {
-        await fs.rename(src, tgt);
+        await this.raw.move(src, tgt);
     }
 
-    public createReadStream(filePath: string): fileSystem.ReadStream {
-        return fileSystem.createReadStream(filePath);
+    public createReadStream(filePath: string): ReadStream {
+        return this.raw.createReadStream(filePath);
     }
 
-    public createWriteStream(filePath: string): fileSystem.WriteStream {
-        return fileSystem.createWriteStream(filePath);
+    public createWriteStream(filePath: string): WriteStream {
+        return this.raw.createWriteStream(filePath);
     }
 
     //=================================
     // utils
 
-    public objectExists(filePath: string, statCheck: (s: fs.Stats) => boolean): Promise<boolean> {
-        return new Promise<boolean>(resolve => {
+    // prettier-ignore
+    public async pathExists(
+        filename: string,
+        fileType?: FileType
+    ): Promise<boolean> {
+        let stat: FileStat;
+        try {
             // Note that we are using stat() rather than lstat().  This
             // means that any symlinks are getting resolved.
-            fs.stat(filePath, (error, stats) => {
-                if (error) {
-                    return resolve(false);
-                }
-                return resolve(statCheck(stats));
-            });
-        });
+            stat = await this.raw.stat(filename);
+        } catch (err) {
+            if (isFileNotFoundError(err)) {
+                return false;
+            }
+            throw err;
+        }
+
+        if (fileType === undefined) {
+            return true;
+        }
+        if (fileType === FileType.Unknown) {
+            // FileType.Unknown == 0, hence do not use bitwise operations.
+            return stat.type === FileType.Unknown;
+        }
+        return (stat.type & fileType) === fileType;
     }
-    public fileExists(filePath: string): Promise<boolean> {
-        return this.objectExists(filePath, stats => stats.isFile());
+    public async fileExists(filename: string): Promise<boolean> {
+        return this.pathExists(filename, FileType.File);
     }
     public fileExistsSync(filePath: string): boolean {
         return fs.existsSync(filePath);
     }
-    public directoryExists(filePath: string): Promise<boolean> {
-        return this.objectExists(filePath, stats => stats.isDirectory());
+    public async directoryExists(dirname: string): Promise<boolean> {
+        return this.pathExists(dirname, FileType.Directory);
     }
 
     public async getSubDirectories(dirname: string): Promise<string[]> {
-        let files: [string, FileType][];
-        try {
-            files = await this.listdir(dirname);
-        } catch {
-            // We're only preserving pre-existng behavior here...
-            return [];
-        }
-        return files
-            .filter(([_file, fileType]) => {
-                // We preserve the pre-existing behavior of following
-                // symlinks.
-                return (fileType & FileType.Directory) > 0;
-            })
-            .map(([filename, _ft]) => filename);
+        // prettier-ignore
+        return filterByFileType(
+            (await this.listdir(dirname)),
+            FileType.Directory
+        ).map(([filename, _fileType]) => filename);
     }
     public async getFiles(dirname: string): Promise<string[]> {
-        let files: [string, FileType][];
-        try {
-            files = await this.listdir(dirname);
-        } catch (err) {
-            // This matches what getSubDirectories() does.
-            if (!(await fs.pathExists(dirname))) {
-                return [];
-            }
-            throw err; // re-throw
-        }
-        return files
-            .filter(([_file, fileType]) => {
-                // We preserve the pre-existing behavior of following
-                // symlinks.
-                return (fileType & FileType.File) > 0;
-            })
-            .map(([filename, _ft]) => filename);
-    }
-
-    public getFileHash(filePath: string): Promise<string> {
-        return new Promise<string>((resolve, reject) => {
-            fs.lstat(filePath, (err, stats) => {
-                if (err) {
-                    reject(err);
-                } else {
-                    const actual = createHash('sha512')
-                        .update(`${stats.ctimeMs}-${stats.mtimeMs}`)
-                        .digest('hex');
-                    resolve(actual);
-                }
-            });
-        });
+        // prettier-ignore
+        return filterByFileType(
+            (await this.listdir(dirname)),
+            FileType.File
+        ).map(([filename, _fileType]) => filename);
+    }
+
+    public async getFileHash(filename: string): Promise<string> {
+        // The reason for lstat rather than stat is not clear...
+        const stat = await this.raw.lstat(filename);
+        const data = `${stat.ctime}-${stat.mtime}`;
+        return getHashString(data);
     }
 
     public async search(globPattern: string, cwd?: string): Promise<string[]> {
@@ -322,3 +475,12 @@ export class FileSystem implements IFileSystem {
         });
     }
 }
+
+// We *could* use ICryptoUtils, but it's a bit overkill, issue tracked
+// in https://github.com/microsoft/vscode-python/issues/8438.
+function getHashString(data: string): string {
+    // prettier-ignore
+    const hash = createHash('sha512')
+        .update(data);
+    return hash.digest('hex');
+}
diff --git a/src/client/common/platform/types.ts b/src/client/common/platform/types.ts
index e014aaf9f2fd..3776253b182e 100644
--- a/src/client/common/platform/types.ts
+++ b/src/client/common/platform/types.ts
@@ -91,8 +91,57 @@ export interface IFileSystemPathUtils {
 
 export import FileType = vscode.FileType;
 export import FileStat = vscode.FileStat;
+export type ReadStream = fs.ReadStream;
 export type WriteStream = fs.WriteStream;
 
+// The low-level filesystem operations on which the extension depends.
+export interface IRawFileSystem {
+    // Get information about a file (resolve symlinks).
+    stat(filename: string): Promise<FileStat>;
+    // Get information about a file (do not resolve synlinks).
+    lstat(filename: string): Promise<FileStat>;
+    // Change a file's permissions.
+    chmod(filename: string, mode: string | number): Promise<void>;
+    // Move the file to a different location (and/or rename it).
+    move(src: string, tgt: string): Promise<void>;
+
+    //***********************
+    // files
+
+    // Return the raw bytes of the given file.
+    readData(filename: string): Promise<Buffer>;
+    // Return the text of the given file (decoded from UTF-8).
+    readText(filename: string): Promise<string>;
+    // Write the given text to the file (UTF-8 encoded).
+    writeText(filename: string, data: {}): Promise<void>;
+    // Write the given text to the end of the file (UTF-8 encoded).
+    appendText(filename: string, text: string): Promise<void>;
+    // Copy a file.
+    copyFile(src: string, dest: string): Promise<void>;
+    // Delete a file.
+    rmfile(filename: string): Promise<void>;
+
+    //***********************
+    // directories
+
+    // Create the directory and any missing parent directories.
+    mkdirp(dirname: string): Promise<void>;
+    // Delete the directory and everything in it.
+    rmtree(dirname: string): Promise<void>;
+    // Return the contents of the directory.
+    listdir(dirname: string): Promise<[string, FileType][]>;
+
+    //***********************
+    // not async
+
+    // Return the text of the given file (decoded from UTF-8).
+    readTextSync(filename: string): string;
+    // Create a streaming wrappr around an open file (for reading).
+    createReadStream(filename: string): ReadStream;
+    // Create a streaming wrappr around an open file (for writing).
+    createWriteStream(filename: string): WriteStream;
+}
+
 export const IFileSystem = Symbol('IFileSystem');
 export interface IFileSystem {
     // path-related
@@ -106,8 +155,8 @@ export interface IFileSystem {
     listdir(dirname: string): Promise<[string, FileType][]>;
     readFile(filePath: string): Promise<string>;
     readData(filePath: string): Promise<Buffer>;
-    writeFile(filePath: string, data: {}, options?: string | fsextra.WriteFileOptions): Promise<void>;
-    appendFile(filename: string, data: {}): Promise<void>;
+    writeFile(filePath: string, text: string | Buffer, options?: string | fsextra.WriteFileOptions): Promise<void>;
+    appendFile(filename: string, text: string | Buffer): Promise<void>;
     copyFile(src: string, dest: string): Promise<void>;
     deleteFile(filename: string): Promise<void>;
     chmod(path: string, mode: string | number): Promise<void>;
diff --git a/src/test/common/platform/filesystem.functional.test.ts b/src/test/common/platform/filesystem.functional.test.ts
index 463d052b34b0..27c101423384 100644
--- a/src/test/common/platform/filesystem.functional.test.ts
+++ b/src/test/common/platform/filesystem.functional.test.ts
@@ -6,7 +6,7 @@
 import { expect, use } from 'chai';
 import * as fs from 'fs-extra';
 import * as path from 'path';
-import { convertStat, FileSystem } from '../../../client/common/platform/fileSystem';
+import { convertStat, FileSystem, RawFileSystem } from '../../../client/common/platform/fileSystem';
 import { FileSystemPaths, FileSystemPathUtils } from '../../../client/common/platform/fs-paths';
 import { PlatformService } from '../../../client/common/platform/platformService';
 import { FileType } from '../../../client/common/platform/types';
@@ -23,6 +23,774 @@ const assertArrays = require('chai-arrays');
 use(require('chai-as-promised'));
 use(assertArrays);
 
+suite('FileSystem - raw', () => {
+    let fileSystem: RawFileSystem;
+    let fix: FSFixture;
+    setup(async () => {
+        fileSystem = RawFileSystem.withDefaults();
+        fix = new FSFixture();
+
+        await assertDoesNotExist(DOES_NOT_EXIST);
+    });
+    teardown(async () => {
+        await fix.cleanUp();
+        await fix.ensureDeleted(DOES_NOT_EXIST);
+    });
+
+    suite('lstat', () => {
+        test('for symlinks, gives the link info', async function() {
+            if (!SUPPORTS_SYMLINKS) {
+                // tslint:disable-next-line:no-invalid-this
+                this.skip();
+            }
+            const filename = await fix.createFile('x/y/z/spam.py', '...');
+            const symlink = await fix.createSymlink('x/y/z/eggs.py', filename);
+            // prettier-ignore
+            const expected = convertStat(
+                await fs.lstat(symlink),
+                FileType.SymbolicLink
+            );
+
+            const stat = await fileSystem.lstat(symlink);
+
+            expect(stat).to.deep.equal(expected);
+        });
+
+        test('for normal files, gives the file info', async () => {
+            const filename = await fix.createFile('x/y/z/spam.py', '...');
+            // Ideally we would compare to the result of
+            // fileSystem.stat().  However, we do not have access
+            // to the VS Code API here.
+            // prettier-ignore
+            const expected = convertStat(
+                await fs.lstat(filename),
+                FileType.File
+            );
+
+            const stat = await fileSystem.lstat(filename);
+
+            expect(stat).to.deep.equal(expected);
+        });
+
+        test('fails if the file does not exist', async () => {
+            const promise = fileSystem.lstat(DOES_NOT_EXIST);
+
+            await expect(promise).to.eventually.be.rejected;
+        });
+    });
+
+    suite('chmod (non-Windows)', () => {
+        suiteSetup(function() {
+            // On Windows, chmod won't have any effect on the file itself.
+            if (WINDOWS) {
+                // tslint:disable-next-line:no-invalid-this
+                this.skip();
+            }
+        });
+
+        async function checkMode(filename: string, expected: number) {
+            const stat = await fs.stat(filename);
+            expect(stat.mode & 0o777).to.equal(expected);
+        }
+
+        test('the file mode gets updated (string)', async () => {
+            const filename = await fix.createFile('spam.py', '...');
+            await fs.chmod(filename, 0o644);
+
+            await fileSystem.chmod(filename, '755');
+
+            await checkMode(filename, 0o755);
+        });
+
+        test('the file mode gets updated (number)', async () => {
+            const filename = await fix.createFile('spam.py', '...');
+            await fs.chmod(filename, 0o644);
+
+            await fileSystem.chmod(filename, 0o755);
+
+            await checkMode(filename, 0o755);
+        });
+
+        test('the file mode gets updated for a directory', async () => {
+            const dirname = await fix.createDirectory('spam');
+            await fs.chmod(dirname, 0o755);
+
+            await fileSystem.chmod(dirname, 0o700);
+
+            await checkMode(dirname, 0o700);
+        });
+
+        test('nothing happens if the file mode already matches', async () => {
+            const filename = await fix.createFile('spam.py', '...');
+            await fs.chmod(filename, 0o644);
+
+            await fileSystem.chmod(filename, 0o644);
+
+            await checkMode(filename, 0o644);
+        });
+
+        test('fails if the file does not exist', async () => {
+            const promise = fileSystem.chmod(DOES_NOT_EXIST, 0o755);
+
+            await expect(promise).to.eventually.be.rejected;
+        });
+    });
+
+    suite('move', () => {
+        test('rename file', async () => {
+            const source = await fix.createFile('spam.py', '<text>');
+            const target = await fix.resolve('eggs-txt');
+            await assertDoesNotExist(target);
+
+            await fileSystem.move(source, target);
+
+            await assertExists(target);
+            const text = await fs.readFile(target, 'utf8');
+            expect(text).to.equal('<text>');
+            await assertDoesNotExist(source);
+        });
+
+        test('rename directory', async () => {
+            const source = await fix.createDirectory('spam');
+            await fix.createFile('spam/data.json', '<text>');
+            const target = await fix.resolve('eggs');
+            const filename = await fix.resolve('eggs/data.json', false);
+            await assertDoesNotExist(target);
+
+            await fileSystem.move(source, target);
+
+            await assertExists(filename);
+            const text = await fs.readFile(filename, 'utf8');
+            expect(text).to.equal('<text>');
+            await assertDoesNotExist(source);
+        });
+
+        test('rename symlink', async function() {
+            if (!SUPPORTS_SYMLINKS) {
+                // tslint:disable-next-line:no-invalid-this
+                this.skip();
+            }
+            const filename = await fix.createFile('spam.py');
+            const symlink = await fix.createSymlink('spam.lnk', filename);
+            const target = await fix.resolve('eggs');
+            await assertDoesNotExist(target);
+
+            await fileSystem.move(symlink, target);
+
+            await assertExists(target);
+            const linked = await fs.readlink(target);
+            expect(linked).to.equal(filename);
+            await assertDoesNotExist(symlink);
+        });
+
+        test('move file', async () => {
+            const source = await fix.createFile('spam.py', '<text>');
+            await fix.createDirectory('eggs');
+            const target = await fix.resolve('eggs/spam.py');
+            await assertDoesNotExist(target);
+
+            await fileSystem.move(source, target);
+
+            await assertExists(target);
+            const text = await fs.readFile(target, 'utf8');
+            expect(text).to.equal('<text>');
+            await assertDoesNotExist(source);
+        });
+
+        test('move directory', async () => {
+            const source = await fix.createDirectory('spam/spam/spam/eggs/spam');
+            await fix.createFile('spam/spam/spam/eggs/spam/data.json', '<text>');
+            await fix.createDirectory('spam/spam/spam/hash');
+            const target = await fix.resolve('spam/spam/spam/hash/spam');
+            const filename = await fix.resolve('spam/spam/spam/hash/spam/data.json', false);
+            await assertDoesNotExist(target);
+
+            await fileSystem.move(source, target);
+
+            await assertExists(filename);
+            const text = await fs.readFile(filename, 'utf8');
+            expect(text).to.equal('<text>');
+            await assertDoesNotExist(source);
+        });
+
+        test('move symlink', async function() {
+            if (!SUPPORTS_SYMLINKS) {
+                // tslint:disable-next-line:no-invalid-this
+                this.skip();
+            }
+            const filename = await fix.createFile('spam.py');
+            const symlink = await fix.createSymlink('w/spam.lnk', filename);
+            const target = await fix.resolve('x/spam.lnk');
+            await assertDoesNotExist(target);
+
+            await fileSystem.move(symlink, target);
+
+            await assertExists(target);
+            const linked = await fs.readlink(target);
+            expect(linked).to.equal(filename);
+            await assertDoesNotExist(symlink);
+        });
+
+        test('file target already exists', async () => {
+            const source = await fix.createFile('spam.py', '<text>');
+            const target = await fix.createFile('eggs-txt', '<other>');
+
+            await fileSystem.move(source, target);
+
+            await assertDoesNotExist(source);
+            await assertExists(target);
+            const text2 = await fs.readFile(target, 'utf8');
+            expect(text2).to.equal('<text>');
+        });
+
+        test('directory target already exists', async () => {
+            const source = await fix.createDirectory('spam');
+            const file3 = await fix.createFile('spam/data.json', '<text>');
+            const target = await fix.createDirectory('eggs');
+            const file1 = await fix.createFile('eggs/spam.py', '<code>');
+            const file2 = await fix.createFile('eggs/data.json', '<other>');
+
+            const promise = fileSystem.move(source, target);
+
+            await expect(promise).to.eventually.be.rejected;
+            // Make sure nothing changed.
+            const text1 = await fs.readFile(file1, 'utf8');
+            expect(text1).to.equal('<code>');
+            const text2 = await fs.readFile(file2, 'utf8');
+            expect(text2).to.equal('<other>');
+            const text3 = await fs.readFile(file3, 'utf8');
+            expect(text3).to.equal('<text>');
+        });
+
+        test('fails if the file does not exist', async () => {
+            const source = await fix.resolve(DOES_NOT_EXIST);
+            const target = await fix.resolve('spam.py');
+
+            const promise = fileSystem.move(source, target);
+
+            await expect(promise).to.eventually.be.rejected;
+            // Make sure nothing changed.
+            await assertDoesNotExist(target);
+        });
+
+        test('fails if the target directory does not exist', async () => {
+            const source = await fix.createFile('x/spam.py', '<text>');
+            const target = await fix.resolve('w/spam.py', false);
+            await assertDoesNotExist(path.dirname(target));
+
+            const promise = fileSystem.move(source, target);
+
+            await expect(promise).to.eventually.be.rejected;
+            // Make sure nothing changed.
+            await assertExists(source);
+            await assertDoesNotExist(target);
+        });
+    });
+
+    suite('readData', () => {
+        test('returns contents of a file', async () => {
+            const text = '<some text>';
+            const expected = Buffer.from(text, 'utf8');
+            const filename = await fix.createFile('x/y/z/spam.py', text);
+
+            const content = await fileSystem.readData(filename);
+
+            expect(content).to.deep.equal(expected);
+        });
+
+        test('throws an exception if file does not exist', async () => {
+            const promise = fileSystem.readData(DOES_NOT_EXIST);
+
+            await expect(promise).to.eventually.be.rejected;
+        });
+    });
+
+    suite('readText', () => {
+        test('returns contents of a file', async () => {
+            const expected = '<some text>';
+            const filename = await fix.createFile('x/y/z/spam.py', expected);
+
+            const content = await fileSystem.readText(filename);
+
+            expect(content).to.be.equal(expected);
+        });
+
+        test('always UTF-8', async () => {
+            const expected = '... 😁 ...';
+            const filename = await fix.createFile('x/y/z/spam.py', expected);
+
+            const text = await fileSystem.readText(filename);
+
+            expect(text).to.equal(expected);
+        });
+
+        test('returns garbage if encoding is UCS-2', async () => {
+            const filename = await fix.resolve('spam.py');
+            // There are probably cases where this would fail too.
+            // However, the extension never has to deal with non-UTF8
+            // cases, so it doesn't matter too much.
+            const original = '... 😁 ...';
+            await fs.writeFile(filename, original, { encoding: 'ucs2' });
+
+            const text = await fileSystem.readText(filename);
+
+            expect(text).to.equal('.\u0000.\u0000.\u0000 \u0000=�\u0001� \u0000.\u0000.\u0000.\u0000');
+        });
+
+        test('throws an exception if file does not exist', async () => {
+            const promise = fileSystem.readText(DOES_NOT_EXIST);
+
+            await expect(promise).to.eventually.be.rejected;
+        });
+    });
+
+    suite('writeText', () => {
+        test('creates the file if missing', async () => {
+            const filename = await fix.resolve('x/y/z/spam.py');
+            await assertDoesNotExist(filename);
+            const data = 'line1\nline2\n';
+
+            await fileSystem.writeText(filename, data);
+
+            // prettier-ignore
+            const actual = await fs.readFile(filename)
+                .then(buffer => buffer.toString());
+            expect(actual).to.equal(data);
+        });
+
+        test('always UTF-8', async () => {
+            const filename = await fix.resolve('x/y/z/spam.py');
+            const data = '... 😁 ...';
+
+            await fileSystem.writeText(filename, data);
+
+            // prettier-ignore
+            const actual = await fs.readFile(filename)
+                .then(buffer => buffer.toString());
+            expect(actual).to.equal(data);
+        });
+
+        test('overwrites existing file', async () => {
+            const filename = await fix.createFile('x/y/z/spam.py', '...');
+            const data = 'line1\nline2\n';
+
+            await fileSystem.writeText(filename, data);
+
+            // prettier-ignore
+            const actual = await fs.readFile(filename)
+                .then(buffer => buffer.toString());
+            expect(actual).to.equal(data);
+        });
+    });
+
+    suite('appendText', () => {
+        test('existing file', async () => {
+            const orig = 'spamspamspam\n\n';
+            const dataToAppend = `Some Data\n${new Date().toString()}\nAnd another line`;
+            const filename = await fix.createFile('spam.txt', orig);
+            const expected = `${orig}${dataToAppend}`;
+
+            await fileSystem.appendText(filename, dataToAppend);
+
+            const actual = await fs.readFile(filename, 'utf8');
+            expect(actual).to.be.equal(expected);
+        });
+
+        test('existing empty file', async () => {
+            const filename = await fix.createFile('spam.txt');
+            const dataToAppend = `Some Data\n${new Date().toString()}\nAnd another line`;
+            const expected = dataToAppend;
+
+            await fileSystem.appendText(filename, dataToAppend);
+
+            const actual = await fs.readFile(filename, 'utf8');
+            expect(actual).to.be.equal(expected);
+        });
+
+        test('creates the file if it does not already exist', async () => {
+            await fileSystem.appendText(DOES_NOT_EXIST, 'spam');
+
+            const actual = await fs.readFile(DOES_NOT_EXIST, 'utf8');
+            expect(actual).to.be.equal('spam');
+        });
+
+        test('fails if not a file', async () => {
+            const dirname = await fix.createDirectory('spam');
+
+            const promise = fileSystem.appendText(dirname, 'spam');
+
+            await expect(promise).to.eventually.be.rejected;
+        });
+    });
+
+    suite('copyFile', () => {
+        test('the source file gets copied (same directory)', async () => {
+            const data = '<content>';
+            const src = await fix.createFile('x/y/z/spam.py', data);
+            const dest = await fix.resolve('x/y/z/spam.py.bak');
+            await assertDoesNotExist(dest);
+
+            await fileSystem.copyFile(src, dest);
+
+            // prettier-ignore
+            const actual = await fs.readFile(dest)
+                .then(buffer => buffer.toString());
+            expect(actual).to.equal(data);
+            // prettier-ignore
+            const original = await fs.readFile(src)
+                .then(buffer => buffer.toString());
+            expect(original).to.equal(data);
+        });
+
+        test('the source file gets copied (different directory)', async () => {
+            const data = '<content>';
+            const src = await fix.createFile('x/y/z/spam.py', data);
+            const dest = await fix.resolve('x/y/eggs.py');
+            await assertDoesNotExist(dest);
+
+            await fileSystem.copyFile(src, dest);
+
+            // prettier-ignore
+            const actual = await fs.readFile(dest)
+                .then(buffer => buffer.toString());
+            expect(actual).to.equal(data);
+            // prettier-ignore
+            const original = await fs.readFile(src)
+                .then(buffer => buffer.toString());
+            expect(original).to.equal(data);
+        });
+
+        test('fails if the source does not exist', async () => {
+            const dest = await fix.resolve('x/spam.py');
+
+            const promise = fileSystem.copyFile(DOES_NOT_EXIST, dest);
+
+            await expect(promise).to.eventually.be.rejected;
+        });
+
+        test('fails if the target parent directory does not exist', async () => {
+            const src = await fix.createFile('x/spam.py', '...');
+            const dest = await fix.resolve('y/eggs.py', false);
+            await assertDoesNotExist(path.dirname(dest));
+
+            const promise = fileSystem.copyFile(src, dest);
+
+            await expect(promise).to.eventually.be.rejected;
+        });
+    });
+
+    suite('rmfile', () => {
+        test('deletes the file', async () => {
+            const filename = await fix.createFile('x/y/z/spam.py', '...');
+            await assertExists(filename);
+
+            await fileSystem.rmfile(filename);
+
+            await assertDoesNotExist(filename);
+        });
+
+        test('fails if the file does not exist', async () => {
+            const promise = fileSystem.rmfile(DOES_NOT_EXIST);
+
+            await expect(promise).to.eventually.be.rejected;
+        });
+    });
+
+    suite('rmtree', () => {
+        test('deletes the directory if empty', async () => {
+            const dirname = await fix.createDirectory('x');
+            await assertExists(dirname);
+
+            await fileSystem.rmtree(dirname);
+
+            await assertDoesNotExist(dirname);
+        });
+
+        test('fails if the directory is not empty', async () => {
+            const dirname = await fix.createDirectory('x');
+            const filename = await fix.createFile('x/y/z/spam.py');
+            await assertExists(filename);
+
+            const promise = fileSystem.rmtree(dirname);
+
+            await expect(promise).to.eventually.be.rejected;
+        });
+
+        test('fails if the directory does not exist', async () => {
+            const promise = fileSystem.rmtree(DOES_NOT_EXIST);
+
+            await expect(promise).to.eventually.be.rejected;
+        });
+    });
+
+    suite('mkdirp', () => {
+        test('creates the directory and all missing parents', async () => {
+            await fix.createDirectory('x');
+            // x/y, x/y/z, and x/y/z/spam are all missing.
+            const dirname = await fix.resolve('x/y/z/spam', false);
+            await assertDoesNotExist(dirname);
+
+            await fileSystem.mkdirp(dirname);
+
+            await assertExists(dirname);
+        });
+
+        test('works if the directory already exists', async () => {
+            const dirname = await fix.createDirectory('spam');
+            await assertExists(dirname);
+
+            await fileSystem.mkdirp(dirname);
+
+            await assertExists(dirname);
+        });
+    });
+
+    suite('listdir', () => {
+        setup(function() {
+            if (WINDOWS) {
+                // tslint:disable-next-line:no-suspicious-comment
+                // TODO(GH-8995) These tests are failing on Windows,
+                // so we are // temporarily disabling it.
+                // tslint:disable-next-line:no-invalid-this
+                return this.skip();
+            }
+        });
+        if (SUPPORTS_SYMLINKS) {
+            test('mixed', async () => {
+                // Create the target directory and its contents.
+                const dirname = await fix.createDirectory('x/y/z');
+                const file1 = await fix.createFile('x/y/z/__init__.py', '');
+                const script = await fix.createFile('x/y/z/__main__.py', '<script here>');
+                const file2 = await fix.createFile('x/y/z/spam.py', '...');
+                const symlink1 = await fix.createSymlink(
+                    'x/y/z/info.py',
+                    // Link to an ignored file.
+                    await fix.createFile('x/_info.py', '<info here>') // source
+                );
+                const sock = await fix.createSocket('x/y/z/ipc.sock');
+                const file3 = await fix.createFile('x/y/z/eggs.py', '"""..."""');
+                const symlink2 = await fix.createSymlink(
+                    'x/y/z/broken',
+                    DOES_NOT_EXIST // source
+                );
+                const symlink3 = await fix.createSymlink(
+                    'x/y/z/ipc.sck',
+                    sock // source
+                );
+                const subdir = await fix.createDirectory('x/y/z/w');
+                const symlink4 = await fix.createSymlink(
+                    'x/y/z/static_files',
+                    await fix.resolve('x/y/z/w/data') // source
+                );
+                // Create other files and directories (should be ignored).
+                await fix.createSymlink(
+                    'my-script.py',
+                    // Link to a listed file.
+                    script // source (__main__.py)
+                );
+                const ignored1 = await fix.createFile('x/__init__.py', '');
+                await fix.createFile('x/y/__init__.py', '');
+                await fix.createSymlink(
+                    'x/y/z/w/__init__.py',
+                    ignored1 // source (x/__init__.py)
+                );
+                await fix.createDirectory('x/y/z/w/data');
+                await fix.createFile('x/y/z/w/data/v1.json');
+
+                const entries = await fileSystem.listdir(dirname);
+
+                expect(entries.sort()).to.deep.equal([
+                    [file1, FileType.File],
+                    [script, FileType.File],
+                    [symlink2, FileType.SymbolicLink],
+                    [file3, FileType.File],
+                    [symlink1, FileType.SymbolicLink | FileType.File],
+                    [symlink3, FileType.SymbolicLink],
+                    [sock, FileType.Unknown],
+                    [file2, FileType.File],
+                    [symlink4, FileType.SymbolicLink | FileType.Directory],
+                    [subdir, FileType.Directory]
+                ]);
+            });
+        } else if (SUPPORTS_SOCKETS) {
+            test('mixed', async () => {
+                // Create the target directory and its contents.
+                const dirname = await fix.createDirectory('x/y/z');
+                const file1 = await fix.createFile('x/y/z/__init__.py', '');
+                const script = await fix.createFile('x/y/z/__main__.py', '<script here>');
+                const file2 = await fix.createFile('x/y/z/spam.py', '...');
+                const sock = await fix.createSocket('x/y/z/ipc.sock');
+                const file3 = await fix.createFile('x/y/z/eggs.py', '"""..."""');
+                const subdir = await fix.createDirectory('x/y/z/w');
+                // Create other files and directories (should be ignored).
+                await fix.createFile('x/__init__.py', '');
+                await fix.createFile('x/y/__init__.py', '');
+                await fix.createDirectory('x/y/z/w/data');
+                await fix.createFile('x/y/z/w/data/v1.json');
+
+                const entries = await fileSystem.listdir(dirname);
+
+                expect(entries.sort()).to.deep.equal([
+                    [file1, FileType.File],
+                    [script, FileType.File],
+                    [file3, FileType.File],
+                    [sock, FileType.Unknown],
+                    [file2, FileType.File],
+                    [subdir, FileType.Directory]
+                ]);
+            });
+        } else {
+            test('mixed', async () => {
+                // Create the target directory and its contents.
+                const dirname = await fix.createDirectory('x/y/z');
+                const file1 = await fix.createFile('x/y/z/__init__.py', '');
+                const script = await fix.createFile('x/y/z/__main__.py', '<script here>');
+                const file2 = await fix.createFile('x/y/z/spam.py', '...');
+                const file3 = await fix.createFile('x/y/z/eggs.py', '"""..."""');
+                const subdir = await fix.createDirectory('x/y/z/w');
+                // Create other files and directories (should be ignored).
+                await fix.createFile('x/__init__.py', '');
+                await fix.createFile('x/y/__init__.py', '');
+                await fix.createDirectory('x/y/z/w/data');
+                await fix.createFile('x/y/z/w/data/v1.json');
+
+                const entries = await fileSystem.listdir(dirname);
+
+                expect(entries.sort()).to.deep.equal([
+                    [file1, FileType.File],
+                    [script, FileType.File],
+                    [file3, FileType.File],
+                    [file2, FileType.File],
+                    [subdir, FileType.Directory]
+                ]);
+            });
+        }
+
+        test('empty', async () => {
+            const dirname = await fix.createDirectory('x/y/z/eggs');
+
+            const entries = await fileSystem.listdir(dirname);
+
+            expect(entries).to.deep.equal([]);
+        });
+
+        test('fails if the directory does not exist', async () => {
+            const promise = fileSystem.listdir(DOES_NOT_EXIST);
+
+            await expect(promise).to.eventually.be.rejected;
+        });
+    });
+
+    // non-async
+
+    suite('readTextSync', () => {
+        test('returns contents of a file', async () => {
+            const expected = '<some text>';
+            const filename = await fix.createFile('x/y/z/spam.py', expected);
+
+            const text = fileSystem.readTextSync(filename);
+
+            expect(text).to.be.equal(expected);
+        });
+
+        test('always UTF-8', async () => {
+            const expected = '... 😁 ...';
+            const filename = await fix.createFile('x/y/z/spam.py', expected);
+
+            const text = fileSystem.readTextSync(filename);
+
+            expect(text).to.equal(expected);
+        });
+
+        test('throws an exception if file does not exist', () => {
+            expect(() => {
+                fileSystem.readTextSync(DOES_NOT_EXIST);
+            }).to.throw(Error);
+        });
+    });
+
+    suite('createReadStream', () => {
+        test('returns the correct ReadStream', async () => {
+            const filename = await fix.createFile('x/y/z/spam.py', '...');
+            const expected = fs.createReadStream(filename);
+            expected.destroy();
+
+            const stream = fileSystem.createReadStream(filename);
+            stream.destroy();
+
+            expect(stream.path).to.deep.equal(expected.path);
+        });
+
+        // Missing tests:
+        // * creation fails if the file does not exist
+        // * .read() works as expected
+        // * .pipe() works as expected
+    });
+
+    suite('createWriteStream', () => {
+        test('returns the correct WriteStream', async () => {
+            const filename = await fix.resolve('x/y/z/spam.py');
+            const expected = fs.createWriteStream(filename);
+            expected.destroy();
+
+            const stream = fileSystem.createWriteStream(filename);
+            stream.destroy();
+
+            expect(stream.path).to.deep.equal(expected.path);
+        });
+
+        test('creates the file if missing', async () => {
+            const filename = await fix.resolve('x/y/z/spam.py');
+            await assertDoesNotExist(filename);
+            const data = 'line1\nline2\n';
+
+            const stream = fileSystem.createWriteStream(filename);
+            stream.write(data);
+            stream.destroy();
+
+            // prettier-ignore
+            const actual = await fs.readFile(filename)
+                .then(buffer => buffer.toString());
+            expect(actual).to.equal(data);
+        });
+
+        test('always UTF-8', async () => {
+            const filename = await fix.resolve('x/y/z/spam.py');
+            const data = '... 😁 ...';
+
+            const stream = fileSystem.createWriteStream(filename);
+            stream.write(data);
+            stream.destroy();
+
+            // prettier-ignore
+            const actual = await fs.readFile(filename)
+                .then(buffer => buffer.toString());
+            expect(actual).to.equal(data);
+        });
+
+        test('overwrites existing file', async function() {
+            if (OSX) {
+                // tslint:disable-next-line:no-suspicious-comment
+                // TODO(GH-8995) This test is failing on Mac, so
+                // we are temporarily disabling it.
+                // tslint:disable-next-line:no-invalid-this
+                return this.skip();
+            }
+            const filename = await fix.createFile('x/y/z/spam.py', '...');
+            const data = 'line1\nline2\n';
+
+            const stream = fileSystem.createWriteStream(filename);
+            stream.write(data);
+            stream.destroy();
+
+            // prettier-ignore
+            const actual = await fs.readFile(filename)
+                .then(buffer => buffer.toString());
+            expect(actual).to.equal(data);
+        });
+    });
+});
+
 suite('FileSystem', () => {
     let fileSystem: FileSystem;
     let fix: FSFixture;
@@ -73,25 +841,7 @@ suite('FileSystem', () => {
 
     suite('raw', () => {
         suite('lstat', () => {
-            test('for symlinks, gives the link info', async function() {
-                if (!SUPPORTS_SYMLINKS) {
-                    // tslint:disable-next-line:no-invalid-this
-                    this.skip();
-                }
-                const filename = await fix.createFile('x/y/z/spam.py', '...');
-                const symlink = await fix.createSymlink('x/y/z/eggs.py', filename);
-                // prettier-ignore
-                const expected = convertStat(
-                    await fs.lstat(symlink),
-                    FileType.SymbolicLink
-                );
-
-                const stat = await fileSystem.lstat(symlink);
-
-                expect(stat).to.deep.equal(expected);
-            });
-
-            test('for normal files, gives the file info', async () => {
+            test('wraps the low-level impl', async () => {
                 const filename = await fix.createFile('x/y/z/spam.py', '...');
                 // Ideally we would compare to the result of
                 // fileSystem.stat().  However, we do not have access
@@ -106,38 +856,23 @@ suite('FileSystem', () => {
 
                 expect(stat).to.deep.equal(expected);
             });
-
-            test('fails if the file does not exist', async () => {
-                const promise = fileSystem.lstat(DOES_NOT_EXIST);
-
-                await expect(promise).to.eventually.be.rejected;
-            });
         });
 
         suite('createDirectory', () => {
-            test('creates the directory and all missing parents', async () => {
+            test('wraps the low-level impl', async () => {
                 await fix.createDirectory('x');
                 // x/y, x/y/z, and x/y/z/spam are all missing.
-                const dirname = await fix.resolve('x/y/z/spam', false);
+                const dirname = await fix.resolve('x/spam', false);
                 await assertDoesNotExist(dirname);
 
                 await fileSystem.createDirectory(dirname);
 
                 await assertExists(dirname);
             });
-
-            test('works if the directory already exists', async () => {
-                const dirname = await fix.createDirectory('spam');
-                await assertExists(dirname);
-
-                await fileSystem.createDirectory(dirname);
-
-                await assertExists(dirname);
-            });
         });
 
         suite('deleteDirectory', () => {
-            test('deletes the directory if empty', async () => {
+            test('wraps the low-level impl', async () => {
                 const dirname = await fix.createDirectory('x');
                 await assertExists(dirname);
 
@@ -145,162 +880,28 @@ suite('FileSystem', () => {
 
                 await assertDoesNotExist(dirname);
             });
-
-            test('fails if the directory is not empty', async () => {
-                const dirname = await fix.createDirectory('x');
-                const filename = await fix.createFile('x/y/z/spam.py');
-                await assertExists(filename);
-
-                const promise = fileSystem.deleteDirectory(dirname);
-
-                await expect(promise).to.eventually.be.rejected;
-            });
-
-            test('fails if the directory does not exist', async () => {
-                const promise = fileSystem.deleteDirectory(DOES_NOT_EXIST);
-
-                await expect(promise).to.eventually.be.rejected;
-            });
         });
 
         suite('listdir', () => {
-            setup(function() {
-                if (WINDOWS) {
-                    // tslint:disable-next-line:no-suspicious-comment
-                    // TODO(GH-8995) These tests are failing on Windows,
-                    // so we are // temporarily disabling it.
-                    // tslint:disable-next-line:no-invalid-this
-                    return this.skip();
-                }
-            });
-            if (SUPPORTS_SYMLINKS) {
-                test('mixed', async () => {
-                    // Create the target directory and its contents.
-                    const dirname = await fix.createDirectory('x/y/z');
-                    const file1 = await fix.createFile('x/y/z/__init__.py', '');
-                    const script = await fix.createFile('x/y/z/__main__.py', '<script here>');
-                    const file2 = await fix.createFile('x/y/z/spam.py', '...');
-                    const symlink1 = await fix.createSymlink(
-                        'x/y/z/info.py',
-                        // Link to an ignored file.
-                        await fix.createFile('x/_info.py', '<info here>') // source
-                    );
-                    const sock = await fix.createSocket('x/y/z/ipc.sock');
-                    const file3 = await fix.createFile('x/y/z/eggs.py', '"""..."""');
-                    const symlink2 = await fix.createSymlink(
-                        'x/y/z/broken',
-                        DOES_NOT_EXIST // source
-                    );
-                    const symlink3 = await fix.createSymlink(
-                        'x/y/z/ipc.sck',
-                        sock // source
-                    );
-                    const subdir = await fix.createDirectory('x/y/z/w');
-                    const symlink4 = await fix.createSymlink(
-                        'x/y/z/static_files',
-                        await fix.resolve('x/y/z/w/data') // source
-                    );
-                    // Create other files and directories (should be ignored).
-                    await fix.createSymlink(
-                        'my-script.py',
-                        // Link to a listed file.
-                        script // source (__main__.py)
-                    );
-                    const ignored1 = await fix.createFile('x/__init__.py', '');
-                    await fix.createFile('x/y/__init__.py', '');
-                    await fix.createSymlink(
-                        'x/y/z/w/__init__.py',
-                        ignored1 // source (x/__init__.py)
-                    );
-                    await fix.createDirectory('x/y/z/w/data');
-                    await fix.createFile('x/y/z/w/data/v1.json');
-
-                    const entries = await fileSystem.listdir(dirname);
-
-                    expect(entries.sort()).to.deep.equal([
-                        [file1, FileType.File],
-                        [script, FileType.File],
-                        [symlink2, FileType.SymbolicLink],
-                        [file3, FileType.File],
-                        [symlink1, FileType.SymbolicLink | FileType.File],
-                        [symlink3, FileType.SymbolicLink],
-                        [sock, FileType.Unknown],
-                        [file2, FileType.File],
-                        [symlink4, FileType.SymbolicLink | FileType.Directory],
-                        [subdir, FileType.Directory]
-                    ]);
-                });
-            } else if (SUPPORTS_SOCKETS) {
+            test('wraps the low-level impl', async () => {
                 test('mixed', async () => {
                     // Create the target directory and its contents.
                     const dirname = await fix.createDirectory('x/y/z');
-                    const file1 = await fix.createFile('x/y/z/__init__.py', '');
-                    const script = await fix.createFile('x/y/z/__main__.py', '<script here>');
-                    const file2 = await fix.createFile('x/y/z/spam.py', '...');
-                    const sock = await fix.createSocket('x/y/z/ipc.sock');
-                    const file3 = await fix.createFile('x/y/z/eggs.py', '"""..."""');
+                    const file = await fix.createFile('x/y/z/__init__.py', '');
                     const subdir = await fix.createDirectory('x/y/z/w');
-                    // Create other files and directories (should be ignored).
-                    await fix.createFile('x/__init__.py', '');
-                    await fix.createFile('x/y/__init__.py', '');
-                    await fix.createDirectory('x/y/z/w/data');
-                    await fix.createFile('x/y/z/w/data/v1.json');
 
                     const entries = await fileSystem.listdir(dirname);
 
                     expect(entries.sort()).to.deep.equal([
-                        [file1, FileType.File],
-                        [script, FileType.File],
-                        [file3, FileType.File],
-                        [sock, FileType.Unknown],
-                        [file2, FileType.File],
+                        [file, FileType.File],
                         [subdir, FileType.Directory]
                     ]);
                 });
-            } else {
-                test('mixed', async () => {
-                    // Create the target directory and its contents.
-                    const dirname = await fix.createDirectory('x/y/z');
-                    const file1 = await fix.createFile('x/y/z/__init__.py', '');
-                    const script = await fix.createFile('x/y/z/__main__.py', '<script here>');
-                    const file2 = await fix.createFile('x/y/z/spam.py', '...');
-                    const file3 = await fix.createFile('x/y/z/eggs.py', '"""..."""');
-                    const subdir = await fix.createDirectory('x/y/z/w');
-                    // Create other files and directories (should be ignored).
-                    await fix.createFile('x/__init__.py', '');
-                    await fix.createFile('x/y/__init__.py', '');
-                    await fix.createDirectory('x/y/z/w/data');
-                    await fix.createFile('x/y/z/w/data/v1.json');
-
-                    const entries = await fileSystem.listdir(dirname);
-
-                    expect(entries.sort()).to.deep.equal([
-                        [file1, FileType.File],
-                        [script, FileType.File],
-                        [file3, FileType.File],
-                        [file2, FileType.File],
-                        [subdir, FileType.Directory]
-                    ]);
-                });
-            }
-
-            test('empty', async () => {
-                const dirname = await fix.createDirectory('x/y/z/eggs');
-
-                const entries = await fileSystem.listdir(dirname);
-
-                expect(entries).to.deep.equal([]);
-            });
-
-            test('fails if the directory does not exist', async () => {
-                const promise = fileSystem.listdir(DOES_NOT_EXIST);
-
-                await expect(promise).to.eventually.be.rejected;
             });
         });
 
         suite('readFile', () => {
-            test('returns contents of a file', async () => {
+            test('wraps the low-level impl', async () => {
                 const expected = '<some text>';
                 const filename = await fix.createFile('x/y/z/spam.py', expected);
 
@@ -308,63 +909,22 @@ suite('FileSystem', () => {
 
                 expect(content).to.be.equal(expected);
             });
+        });
 
-            test('always UTF-8', async () => {
-                const expected = '... 😁 ...';
-                const filename = await fix.createFile('x/y/z/spam.py', expected);
-
-                const text = await fileSystem.readFile(filename);
-
-                expect(text).to.equal(expected);
-            });
-
-            test('returns garbage if encoding is UCS-2', async () => {
-                const filename = await fix.resolve('spam.py');
-                // There are probably cases where this would fail too.
-                // However, the extension never has to deal with non-UTF8
-                // cases, so it doesn't matter too much.
-                const original = '... 😁 ...';
-                await fs.writeFile(filename, original, { encoding: 'ucs2' });
-
-                const text = await fileSystem.readFile(filename);
-
-                expect(text).to.equal('.\u0000.\u0000.\u0000 \u0000=�\u0001� \u0000.\u0000.\u0000.\u0000');
-            });
+        suite('readData', () => {
+            test('wraps the low-level impl', async () => {
+                const text = '<some text>';
+                const expected = Buffer.from(text, 'utf8');
+                const filename = await fix.createFile('x/y/z/spam.py', text);
 
-            test('throws an exception if file does not exist', async () => {
-                const promise = fileSystem.readFile(DOES_NOT_EXIST);
+                const content = await fileSystem.readData(filename);
 
-                await expect(promise).to.eventually.be.rejected;
+                expect(content).to.deep.equal(expected);
             });
         });
 
         suite('writeFile', () => {
-            test('creates the file if missing', async () => {
-                const filename = await fix.resolve('x/y/z/spam.py');
-                await assertDoesNotExist(filename);
-                const data = 'line1\nline2\n';
-
-                await fileSystem.writeFile(filename, data);
-
-                // prettier-ignore
-                const actual = await fs.readFile(filename)
-                    .then(buffer => buffer.toString());
-                expect(actual).to.equal(data);
-            });
-
-            test('always UTF-8', async () => {
-                const filename = await fix.resolve('x/y/z/spam.py');
-                const data = '... 😁 ...';
-
-                await fileSystem.writeFile(filename, data);
-
-                // prettier-ignore
-                const actual = await fs.readFile(filename)
-                    .then(buffer => buffer.toString());
-                expect(actual).to.equal(data);
-            });
-
-            test('overwrites existing file', async () => {
+            test('wraps the low-level impl', async () => {
                 const filename = await fix.createFile('x/y/z/spam.py', '...');
                 const data = 'line1\nline2\n';
 
@@ -378,47 +938,20 @@ suite('FileSystem', () => {
         });
 
         suite('appendFile', () => {
-            test('existing file', async () => {
-                const orig = 'spamspamspam\n\n';
-                const dataToAppend = `Some Data\n${new Date().toString()}\nAnd another line`;
-                const filename = await fix.createFile('spam.txt', orig);
-                const expected = `${orig}${dataToAppend}`;
-
-                await fileSystem.appendFile(filename, dataToAppend);
-
-                const actual = await fs.readFile(filename, 'utf8');
-                expect(actual).to.be.equal(expected);
-            });
-
-            test('existing empty file', async () => {
+            test('wraps the low-level impl', async () => {
                 const filename = await fix.createFile('spam.txt');
                 const dataToAppend = `Some Data\n${new Date().toString()}\nAnd another line`;
-                const expected = dataToAppend;
-
-                await fileSystem.appendFile(filename, dataToAppend);
-
-                const actual = await fs.readFile(filename, 'utf8');
-                expect(actual).to.be.equal(expected);
-            });
-
-            test('creates the file if it does not already exist', async () => {
-                await fileSystem.appendFile(DOES_NOT_EXIST, 'spam');
-
-                const actual = await fs.readFile(DOES_NOT_EXIST, 'utf8');
-                expect(actual).to.be.equal('spam');
-            });
-
-            test('fails if not a file', async () => {
-                const dirname = await fix.createDirectory('spam');
+                const expected = dataToAppend;
 
-                const promise = fileSystem.appendFile(dirname, 'spam');
+                await fileSystem.appendFile(filename, dataToAppend);
 
-                await expect(promise).to.eventually.be.rejected;
+                const actual = await fs.readFile(filename, 'utf8');
+                expect(actual).to.be.equal(expected);
             });
         });
 
         suite('copyFile', () => {
-            test('the source file gets copied (same directory)', async () => {
+            test('wraps the low-level impl', async () => {
                 const data = '<content>';
                 const src = await fix.createFile('x/y/z/spam.py', data);
                 const dest = await fix.resolve('x/y/z/spam.py.bak');
@@ -435,46 +968,10 @@ suite('FileSystem', () => {
                     .then(buffer => buffer.toString());
                 expect(original).to.equal(data);
             });
-
-            test('the source file gets copied (different directory)', async () => {
-                const data = '<content>';
-                const src = await fix.createFile('x/y/z/spam.py', data);
-                const dest = await fix.resolve('x/y/eggs.py');
-                await assertDoesNotExist(dest);
-
-                await fileSystem.copyFile(src, dest);
-
-                // prettier-ignore
-                const actual = await fs.readFile(dest)
-                    .then(buffer => buffer.toString());
-                expect(actual).to.equal(data);
-                // prettier-ignore
-                const original = await fs.readFile(src)
-                    .then(buffer => buffer.toString());
-                expect(original).to.equal(data);
-            });
-
-            test('fails if the source does not exist', async () => {
-                const dest = await fix.resolve('x/spam.py');
-
-                const promise = fileSystem.copyFile(DOES_NOT_EXIST, dest);
-
-                await expect(promise).to.eventually.be.rejected;
-            });
-
-            test('fails if the target parent directory does not exist', async () => {
-                const src = await fix.createFile('x/spam.py', '...');
-                const dest = await fix.resolve('y/eggs.py', false);
-                await assertDoesNotExist(path.dirname(dest));
-
-                const promise = fileSystem.copyFile(src, dest);
-
-                await expect(promise).to.eventually.be.rejected;
-            });
         });
 
         suite('deleteFile', () => {
-            test('deletes the file', async () => {
+            test('wraps the low-level impl', async () => {
                 const filename = await fix.createFile('x/y/z/spam.py', '...');
                 await assertExists(filename);
 
@@ -482,12 +979,6 @@ suite('FileSystem', () => {
 
                 await assertDoesNotExist(filename);
             });
-
-            test('fails if the file does not exist', async () => {
-                const promise = fileSystem.deleteFile(DOES_NOT_EXIST);
-
-                await expect(promise).to.eventually.be.rejected;
-            });
         });
 
         suite('chmod (non-Windows)', () => {
@@ -499,56 +990,19 @@ suite('FileSystem', () => {
                 }
             });
 
-            async function checkMode(filename: string, expected: number) {
-                const stat = await fs.stat(filename);
-                expect(stat.mode & 0o777).to.equal(expected);
-            }
-
-            test('the file mode gets updated (string)', async () => {
+            test('wraps the low-level impl', async () => {
                 const filename = await fix.createFile('spam.py', '...');
                 await fs.chmod(filename, 0o644);
 
                 await fileSystem.chmod(filename, '755');
 
-                await checkMode(filename, 0o755);
-            });
-
-            test('the file mode gets updated (number)', async () => {
-                const filename = await fix.createFile('spam.py', '...');
-                await fs.chmod(filename, 0o644);
-
-                await fileSystem.chmod(filename, 0o755);
-
-                await checkMode(filename, 0o755);
-            });
-
-            test('the file mode gets updated for a directory', async () => {
-                const dirname = await fix.createDirectory('spam');
-                await fs.chmod(dirname, 0o755);
-
-                await fileSystem.chmod(dirname, 0o700);
-
-                await checkMode(dirname, 0o700);
-            });
-
-            test('nothing happens if the file mode already matches', async () => {
-                const filename = await fix.createFile('spam.py', '...');
-                await fs.chmod(filename, 0o644);
-
-                await fileSystem.chmod(filename, 0o644);
-
-                await checkMode(filename, 0o644);
-            });
-
-            test('fails if the file does not exist', async () => {
-                const promise = fileSystem.chmod(DOES_NOT_EXIST, 0o755);
-
-                await expect(promise).to.eventually.be.rejected;
+                const stat = await fs.stat(filename);
+                expect(stat.mode & 0o777).to.equal(0o755);
             });
         });
 
         suite('move', () => {
-            test('rename file', async () => {
+            test('wraps the low-level impl', async () => {
                 const source = await fix.createFile('spam.py', '<text>');
                 const target = await fix.resolve('eggs-txt');
                 await assertDoesNotExist(target);
@@ -560,149 +1014,13 @@ suite('FileSystem', () => {
                 expect(text).to.equal('<text>');
                 await assertDoesNotExist(source);
             });
-
-            test('rename directory', async () => {
-                const source = await fix.createDirectory('spam');
-                await fix.createFile('spam/data.json', '<text>');
-                const target = await fix.resolve('eggs');
-                const filename = await fix.resolve('eggs/data.json', false);
-                await assertDoesNotExist(target);
-
-                await fileSystem.move(source, target);
-
-                await assertExists(filename);
-                const text = await fs.readFile(filename, 'utf8');
-                expect(text).to.equal('<text>');
-                await assertDoesNotExist(source);
-            });
-
-            test('rename symlink', async function() {
-                if (!SUPPORTS_SYMLINKS) {
-                    // tslint:disable-next-line:no-invalid-this
-                    this.skip();
-                }
-                const filename = await fix.createFile('spam.py');
-                const symlink = await fix.createSymlink('spam.lnk', filename);
-                const target = await fix.resolve('eggs');
-                await assertDoesNotExist(target);
-
-                await fileSystem.move(symlink, target);
-
-                await assertExists(target);
-                const linked = await fs.readlink(target);
-                expect(linked).to.equal(filename);
-                await assertDoesNotExist(symlink);
-            });
-
-            test('move file', async () => {
-                const source = await fix.createFile('spam.py', '<text>');
-                await fix.createDirectory('eggs');
-                const target = await fix.resolve('eggs/spam.py');
-                await assertDoesNotExist(target);
-
-                await fileSystem.move(source, target);
-
-                await assertExists(target);
-                const text = await fs.readFile(target, 'utf8');
-                expect(text).to.equal('<text>');
-                await assertDoesNotExist(source);
-            });
-
-            test('move directory', async () => {
-                const source = await fix.createDirectory('spam/spam/spam/eggs/spam');
-                await fix.createFile('spam/spam/spam/eggs/spam/data.json', '<text>');
-                await fix.createDirectory('spam/spam/spam/hash');
-                const target = await fix.resolve('spam/spam/spam/hash/spam');
-                const filename = await fix.resolve('spam/spam/spam/hash/spam/data.json', false);
-                await assertDoesNotExist(target);
-
-                await fileSystem.move(source, target);
-
-                await assertExists(filename);
-                const text = await fs.readFile(filename, 'utf8');
-                expect(text).to.equal('<text>');
-                await assertDoesNotExist(source);
-            });
-
-            test('move symlink', async function() {
-                if (!SUPPORTS_SYMLINKS) {
-                    // tslint:disable-next-line:no-invalid-this
-                    this.skip();
-                }
-                const filename = await fix.createFile('spam.py');
-                const symlink = await fix.createSymlink('w/spam.lnk', filename);
-                const target = await fix.resolve('x/spam.lnk');
-                await assertDoesNotExist(target);
-
-                await fileSystem.move(symlink, target);
-
-                await assertExists(target);
-                const linked = await fs.readlink(target);
-                expect(linked).to.equal(filename);
-                await assertDoesNotExist(symlink);
-            });
-
-            test('file target already exists', async () => {
-                const source = await fix.createFile('spam.py', '<text>');
-                const target = await fix.createFile('eggs-txt', '<other>');
-
-                await fileSystem.move(source, target);
-
-                await assertDoesNotExist(source);
-                await assertExists(target);
-                const text2 = await fs.readFile(target, 'utf8');
-                expect(text2).to.equal('<text>');
-            });
-
-            test('directory target already exists', async () => {
-                const source = await fix.createDirectory('spam');
-                const file3 = await fix.createFile('spam/data.json', '<text>');
-                const target = await fix.createDirectory('eggs');
-                const file1 = await fix.createFile('eggs/spam.py', '<code>');
-                const file2 = await fix.createFile('eggs/data.json', '<other>');
-
-                const promise = fileSystem.move(source, target);
-
-                await expect(promise).to.eventually.be.rejected;
-                // Make sure nothing changed.
-                const text1 = await fs.readFile(file1, 'utf8');
-                expect(text1).to.equal('<code>');
-                const text2 = await fs.readFile(file2, 'utf8');
-                expect(text2).to.equal('<other>');
-                const text3 = await fs.readFile(file3, 'utf8');
-                expect(text3).to.equal('<text>');
-            });
-
-            test('fails if the file does not exist', async () => {
-                const source = await fix.resolve(DOES_NOT_EXIST);
-                const target = await fix.resolve('spam.py');
-
-                const promise = fileSystem.move(source, target);
-
-                await expect(promise).to.eventually.be.rejected;
-                // Make sure nothing changed.
-                await assertDoesNotExist(target);
-            });
-
-            test('fails if the target directory does not exist', async () => {
-                const source = await fix.createFile('x/spam.py', '<text>');
-                const target = await fix.resolve('w/spam.py', false);
-                await assertDoesNotExist(path.dirname(target));
-
-                const promise = fileSystem.move(source, target);
-
-                await expect(promise).to.eventually.be.rejected;
-                // Make sure nothing changed.
-                await assertExists(source);
-                await assertDoesNotExist(target);
-            });
         });
 
         //=============================
         // sync methods
 
         suite('readFileSync', () => {
-            test('returns contents of a file', async () => {
+            test('wraps the low-level impl', async () => {
                 const expected = '<some text>';
                 const filename = await fix.createFile('x/y/z/spam.py', expected);
 
@@ -710,25 +1028,10 @@ suite('FileSystem', () => {
 
                 expect(text).to.be.equal(expected);
             });
-
-            test('always UTF-8', async () => {
-                const expected = '... 😁 ...';
-                const filename = await fix.createFile('x/y/z/spam.py', expected);
-
-                const text = fileSystem.readFileSync(filename);
-
-                expect(text).to.equal(expected);
-            });
-
-            test('throws an exception if file does not exist', () => {
-                expect(() => {
-                    fileSystem.readFileSync(DOES_NOT_EXIST);
-                }).to.throw(Error);
-            });
         });
 
         suite('createReadStream', () => {
-            test('returns the correct ReadStream', async () => {
+            test('wraps the low-level impl', async () => {
                 const filename = await fix.createFile('x/y/z/spam.py', '...');
                 const expected = fs.createReadStream(filename);
                 expected.destroy();
@@ -738,15 +1041,10 @@ suite('FileSystem', () => {
 
                 expect(stream.path).to.deep.equal(expected.path);
             });
-
-            // Missing tests:
-            // * creation fails if the file does not exist
-            // * .read() works as expected
-            // * .pipe() works as expected
         });
 
         suite('createWriteStream', () => {
-            test('returns the correct WriteStream', async () => {
+            test('wraps the low-level impl', async () => {
                 const filename = await fix.resolve('x/y/z/spam.py');
                 const expected = fs.createWriteStream(filename);
                 expected.destroy();
@@ -756,144 +1054,10 @@ suite('FileSystem', () => {
 
                 expect(stream.path).to.deep.equal(expected.path);
             });
-
-            test('creates the file if missing', async () => {
-                const filename = await fix.resolve('x/y/z/spam.py');
-                await assertDoesNotExist(filename);
-                const data = 'line1\nline2\n';
-
-                const stream = fileSystem.createWriteStream(filename);
-                stream.write(data);
-                stream.destroy();
-
-                // prettier-ignore
-                const actual = await fs.readFile(filename)
-                    .then(buffer => buffer.toString());
-                expect(actual).to.equal(data);
-            });
-
-            test('always UTF-8', async () => {
-                const filename = await fix.resolve('x/y/z/spam.py');
-                const data = '... 😁 ...';
-
-                const stream = fileSystem.createWriteStream(filename);
-                stream.write(data);
-                stream.destroy();
-
-                // prettier-ignore
-                const actual = await fs.readFile(filename)
-                    .then(buffer => buffer.toString());
-                expect(actual).to.equal(data);
-            });
-
-            test('overwrites existing file', async function() {
-                if (OSX) {
-                    // tslint:disable-next-line:no-suspicious-comment
-                    // TODO(GH-8995) This test is failing on Mac, so
-                    // we are temporarily disabling it.
-                    // tslint:disable-next-line:no-invalid-this
-                    return this.skip();
-                }
-                const filename = await fix.createFile('x/y/z/spam.py', '...');
-                const data = 'line1\nline2\n';
-
-                const stream = fileSystem.createWriteStream(filename);
-                stream.write(data);
-                stream.destroy();
-
-                // prettier-ignore
-                const actual = await fs.readFile(filename)
-                    .then(buffer => buffer.toString());
-                expect(actual).to.equal(data);
-            });
         });
     });
 
     suite('utils', () => {
-        suite('fileExists', () => {
-            test('want file, got file', async () => {
-                const filename = await fix.createFile('x/y/z/spam.py');
-
-                const exists = await fileSystem.fileExists(filename);
-
-                expect(exists).to.equal(true);
-            });
-
-            test('want file, not file', async () => {
-                const filename = await fix.createDirectory('x/y/z/spam.py');
-
-                const exists = await fileSystem.fileExists(filename);
-
-                expect(exists).to.equal(false);
-            });
-
-            test('symlink', async function() {
-                if (!SUPPORTS_SYMLINKS) {
-                    // tslint:disable-next-line:no-invalid-this
-                    this.skip();
-                }
-                const filename = await fix.createFile('x/y/z/spam.py', '...');
-                const symlink = await fix.createSymlink('x/y/z/eggs.py', filename);
-
-                const exists = await fileSystem.fileExists(symlink);
-
-                // This is because we currently use stat() and not lstat().
-                expect(exists).to.equal(true);
-            });
-
-            test('unknown', async function() {
-                if (!SUPPORTS_SOCKETS) {
-                    // tslint:disable-next-line:no-invalid-this
-                    this.skip();
-                }
-                const sockFile = await fix.createSocket('x/y/z/ipc.sock');
-
-                const exists = await fileSystem.fileExists(sockFile);
-
-                expect(exists).to.equal(false);
-            });
-        });
-
-        suite('directoryExists', () => {
-            test('want directory, got directory', async () => {
-                const dirname = await fix.createDirectory('x/y/z/spam');
-
-                const exists = await fileSystem.directoryExists(dirname);
-
-                expect(exists).to.equal(true);
-            });
-
-            test('want directory, not directory', async () => {
-                const dirname = await fix.createFile('x/y/z/spam');
-
-                const exists = await fileSystem.directoryExists(dirname);
-
-                expect(exists).to.equal(false);
-            });
-
-            test('symlink', async () => {
-                const dirname = await fix.createDirectory('x/y/z/spam');
-                const symlink = await fix.createSymlink('x/y/z/eggs', dirname);
-
-                const exists = await fileSystem.directoryExists(symlink);
-
-                // This is because we currently use stat() and not lstat().
-                expect(exists).to.equal(true);
-            });
-
-            test('unknown', async function() {
-                if (!SUPPORTS_SOCKETS) {
-                    // tslint:disable-next-line:no-invalid-this
-                    this.skip();
-                }
-                const sockFile = await fix.createSocket('x/y/z/ipc.sock');
-
-                const exists = await fileSystem.directoryExists(sockFile);
-
-                expect(exists).to.equal(false);
-            });
-        });
-
         suite('getSubDirectories', () => {
             setup(function() {
                 if (WINDOWS) {
@@ -948,12 +1112,6 @@ suite('FileSystem', () => {
                     ]);
                 });
             }
-
-            test('empty if the directory does not exist', async () => {
-                const entries = await fileSystem.getSubDirectories(DOES_NOT_EXIST);
-
-                expect(entries).to.deep.equal([]);
-            });
         });
 
         suite('getFiles', () => {
@@ -1012,12 +1170,6 @@ suite('FileSystem', () => {
                     ]);
                 });
             }
-
-            test('empty if the directory does not exist', async () => {
-                const entries = await fileSystem.getFiles(DOES_NOT_EXIST);
-
-                expect(entries).to.deep.equal([]);
-            });
         });
 
         suite('getFileHash', () => {
@@ -1114,18 +1266,6 @@ suite('FileSystem', () => {
             });
         });
 
-        suite('createFile', () => {
-            // tested fully in the TemporaryFileSystem tests.
-
-            test('calls wrapped object', async () => {
-                const tempfile = await fileSystem.createTemporaryFile('.tmp');
-                fix.addFSCleanup(tempfile.filePath, tempfile.dispose);
-                await assertExists(tempfile.filePath);
-
-                expect(tempfile.filePath.endsWith('.tmp')).to.equal(true);
-            });
-        });
-
         suite('isDirReadonly', () => {
             suite('non-Windows', () => {
                 suiteSetup(function() {
diff --git a/src/test/common/platform/filesystem.test.ts b/src/test/common/platform/filesystem.test.ts
index 98ef6a2af080..5fab0c24d057 100644
--- a/src/test/common/platform/filesystem.test.ts
+++ b/src/test/common/platform/filesystem.test.ts
@@ -8,12 +8,12 @@ import { expect } from 'chai';
 import * as fsextra from 'fs-extra';
 // prettier-ignore
 import {
-    convertStat, FileSystem
+    convertStat, FileSystem, RawFileSystem
 } from '../../../client/common/platform/fileSystem';
 import { PlatformService } from '../../../client/common/platform/platformService';
 // prettier-ignore
 import {
-    FileType, IFileSystem
+    FileType, IFileSystem, IRawFileSystem
 } from '../../../client/common/platform/types';
 // prettier-ignore
 import {
@@ -24,14 +24,11 @@ import {
 // Note: all functional tests that do not trigger the VS Code "fs" API
 // are found in filesystem.functional.test.ts.
 
-suite('FileSystem', () => {
-    let filesystem: IFileSystem;
+suite('FileSystem - raw', () => {
+    let filesystem: IRawFileSystem;
     let fix: FSFixture;
     setup(async () => {
-        // prettier-ignore
-        filesystem = new FileSystem(
-            new PlatformService()
-        );
+        filesystem = RawFileSystem.withDefaults();
         fix = new FSFixture();
 
         await assertDoesNotExist(DOES_NOT_EXIST);
@@ -97,3 +94,181 @@ suite('FileSystem', () => {
         });
     });
 });
+
+suite('FileSystem', () => {
+    let filesystem: IFileSystem;
+    let fix: FSFixture;
+    setup(async () => {
+        // prettier-ignore
+        filesystem = new FileSystem(
+            new PlatformService()
+        );
+        fix = new FSFixture();
+
+        await assertDoesNotExist(DOES_NOT_EXIST);
+    });
+    teardown(async () => {
+        await fix.cleanUp();
+    });
+
+    suite('raw', () => {
+        suite('stat', () => {
+            test('gets the info for an existing file', async () => {
+                const filename = await fix.createFile('x/y/z/spam.py', '...');
+                const old = await fsextra.stat(filename);
+                const expected = convertStat(old, FileType.File);
+
+                const stat = await filesystem.stat(filename);
+
+                expect(stat).to.deep.equal(expected);
+            });
+
+            test('gets the info for an existing directory', async () => {
+                const dirname = await fix.createDirectory('x/y/z/spam');
+                const old = await fsextra.stat(dirname);
+                const expected = convertStat(old, FileType.Directory);
+
+                const stat = await filesystem.stat(dirname);
+
+                expect(stat).to.deep.equal(expected);
+            });
+
+            test('for symlinks, gets the info for the linked file', async function() {
+                if (!SUPPORTS_SYMLINKS) {
+                    // tslint:disable-next-line:no-invalid-this
+                    this.skip();
+                }
+                const filename = await fix.createFile('x/y/z/spam.py', '...');
+                const symlink = await fix.createSymlink('x/y/z/eggs.py', filename);
+                const old = await fsextra.stat(filename);
+                const expected = convertStat(old, FileType.SymbolicLink | FileType.File);
+
+                const stat = await filesystem.stat(symlink);
+
+                expect(stat).to.deep.equal(expected);
+            });
+
+            test('gets the info for a socket', async function() {
+                if (!SUPPORTS_SOCKETS) {
+                    // tslint:disable-next-line:no-invalid-this
+                    return this.skip();
+                }
+                const sock = await fix.createSocket('x/spam.sock');
+                const old = await fsextra.stat(sock);
+                const expected = convertStat(old, FileType.Unknown);
+
+                const stat = await filesystem.stat(sock);
+
+                expect(stat).to.deep.equal(expected);
+            });
+
+            test('fails if the file does not exist', async () => {
+                const promise = filesystem.stat(DOES_NOT_EXIST);
+
+                await expect(promise).to.eventually.be.rejected;
+            });
+        });
+    });
+
+    suite('utils', () => {
+        suite('fileExists', () => {
+            test('want file, got file', async () => {
+                const filename = await fix.createFile('x/y/z/spam.py');
+
+                const exists = await filesystem.fileExists(filename);
+
+                expect(exists).to.equal(true);
+            });
+
+            test('want file, not file', async () => {
+                const filename = await fix.createDirectory('x/y/z/spam.py');
+
+                const exists = await filesystem.fileExists(filename);
+
+                expect(exists).to.equal(false);
+            });
+
+            test('symlink', async function() {
+                if (!SUPPORTS_SYMLINKS) {
+                    // tslint:disable-next-line:no-invalid-this
+                    this.skip();
+                }
+                const filename = await fix.createFile('x/y/z/spam.py', '...');
+                const symlink = await fix.createSymlink('x/y/z/eggs.py', filename);
+
+                const exists = await filesystem.fileExists(symlink);
+
+                // This is because we currently use stat() and not lstat().
+                expect(exists).to.equal(true);
+            });
+
+            test('unknown', async function() {
+                if (!SUPPORTS_SOCKETS) {
+                    // tslint:disable-next-line:no-invalid-this
+                    this.skip();
+                }
+                const sockFile = await fix.createSocket('x/y/z/ipc.sock');
+
+                const exists = await filesystem.fileExists(sockFile);
+
+                expect(exists).to.equal(false);
+            });
+        });
+
+        suite('directoryExists', () => {
+            test('want directory, got directory', async () => {
+                const dirname = await fix.createDirectory('x/y/z/spam');
+
+                const exists = await filesystem.directoryExists(dirname);
+
+                expect(exists).to.equal(true);
+            });
+
+            test('want directory, not directory', async () => {
+                const dirname = await fix.createFile('x/y/z/spam');
+
+                const exists = await filesystem.directoryExists(dirname);
+
+                expect(exists).to.equal(false);
+            });
+
+            test('symlink', async () => {
+                const dirname = await fix.createDirectory('x/y/z/spam');
+                const symlink = await fix.createSymlink('x/y/z/eggs', dirname);
+
+                const exists = await filesystem.directoryExists(symlink);
+
+                // This is because we currently use stat() and not lstat().
+                expect(exists).to.equal(true);
+            });
+
+            test('unknown', async function() {
+                if (!SUPPORTS_SOCKETS) {
+                    // tslint:disable-next-line:no-invalid-this
+                    this.skip();
+                }
+                const sockFile = await fix.createSocket('x/y/z/ipc.sock');
+
+                const exists = await filesystem.directoryExists(sockFile);
+
+                expect(exists).to.equal(false);
+            });
+        });
+
+        suite('getSubDirectories', () => {
+            test('empty if the directory does not exist', async () => {
+                const entries = await filesystem.getSubDirectories(DOES_NOT_EXIST);
+
+                expect(entries).to.deep.equal([]);
+            });
+        });
+
+        suite('getFiles', () => {
+            test('empty if the directory does not exist', async () => {
+                const entries = await filesystem.getFiles(DOES_NOT_EXIST);
+
+                expect(entries).to.deep.equal([]);
+            });
+        });
+    });
+});
diff --git a/src/test/common/platform/filesystem.unit.test.ts b/src/test/common/platform/filesystem.unit.test.ts
new file mode 100644
index 000000000000..7939763a50ab
--- /dev/null
+++ b/src/test/common/platform/filesystem.unit.test.ts
@@ -0,0 +1,666 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { expect } from 'chai';
+import * as fs from 'fs';
+import * as fsextra from 'fs-extra';
+import * as TypeMoq from 'typemoq';
+import * as vscode from 'vscode';
+import { RawFileSystem } from '../../../client/common/platform/fileSystem';
+// prettier-ignore
+import {
+    FileStat, FileType, ReadStream, WriteStream
+} from '../../../client/common/platform/types';
+
+// tslint:disable:max-func-body-length chai-vague-errors
+
+function createDummyStat(filetype: FileType): FileStat {
+    //tslint:disable-next-line:no-any
+    return { type: filetype } as any;
+}
+
+interface IRawFS {
+    // vscode.workspace.fs
+    stat(uri: vscode.Uri): Thenable<FileStat>;
+
+    // "fs-extra"
+    stat(filename: string): Promise<fs.Stats>;
+    lstat(filename: string): Promise<fs.Stats>;
+    readdir(dirname: string): Promise<string[]>;
+    readFile(filename: string): Promise<Buffer>;
+    readFile(filename: string, encoding: string): Promise<string>;
+    mkdirp(dirname: string): Promise<void>;
+    chmod(filePath: string, mode: string | number): Promise<void>;
+    rename(src: string, tgt: string): Promise<void>;
+    writeFile(filename: string, data: {}, options: {}): Promise<void>;
+    appendFile(filename: string, data: {}): Promise<void>;
+    unlink(filename: string): Promise<void>;
+    rmdir(dirname: string): Promise<void>;
+    readFileSync(path: string, encoding: string): string;
+    createReadStream(filename: string): ReadStream;
+    createWriteStream(filename: string): WriteStream;
+
+    // fs paths (IFileSystemPaths)
+    join(...filenames: string[]): string;
+}
+
+suite('Raw FileSystem', () => {
+    let raw: TypeMoq.IMock<IRawFS>;
+    let oldStats: TypeMoq.IMock<fs.Stats>[];
+    let filesystem: RawFileSystem;
+    setup(() => {
+        raw = TypeMoq.Mock.ofType<IRawFS>(undefined, TypeMoq.MockBehavior.Strict);
+        oldStats = [];
+        filesystem = new RawFileSystem(
+            // Since it's a mock we can just use it for all 3 values.
+            raw.object,
+            raw.object,
+            raw.object
+        );
+    });
+    function verifyAll() {
+        raw.verifyAll();
+        oldStats.forEach(stat => {
+            stat.verifyAll();
+        });
+    }
+    function createMockLegacyStat(): TypeMoq.IMock<fsextra.Stats> {
+        const stat = TypeMoq.Mock.ofType<fsextra.Stats>(undefined, TypeMoq.MockBehavior.Strict);
+        // This is necessary because passing "mock.object" to
+        // Promise.resolve() triggers the lookup.
+        //tslint:disable-next-line:no-any
+        stat.setup((s: any) => s.then)
+            .returns(() => undefined)
+            .verifiable(TypeMoq.Times.atLeast(0));
+        oldStats.push(stat);
+        return stat;
+    }
+    function setupStatFileType(stat: TypeMoq.IMock<fs.Stats>, filetype: FileType) {
+        // This mirrors the logic in convertFileType().
+        if (filetype === FileType.File) {
+            stat.setup(s => s.isFile())
+                .returns(() => true)
+                .verifiable(TypeMoq.Times.atLeastOnce());
+        } else if (filetype === FileType.Directory) {
+            stat.setup(s => s.isFile())
+                .returns(() => false)
+                .verifiable(TypeMoq.Times.atLeastOnce());
+            stat.setup(s => s.isDirectory())
+                .returns(() => true)
+                .verifiable(TypeMoq.Times.atLeastOnce());
+        } else if ((filetype & FileType.SymbolicLink) > 0) {
+            stat.setup(s => s.isFile())
+                .returns(() => false)
+                .verifiable(TypeMoq.Times.atLeastOnce());
+            stat.setup(s => s.isDirectory())
+                .returns(() => false)
+                .verifiable(TypeMoq.Times.atLeastOnce());
+            stat.setup(s => s.isSymbolicLink())
+                .returns(() => true)
+                .verifiable(TypeMoq.Times.atLeastOnce());
+        } else if (filetype === FileType.Unknown) {
+            stat.setup(s => s.isFile())
+                .returns(() => false)
+                .verifiable(TypeMoq.Times.atLeastOnce());
+            stat.setup(s => s.isDirectory())
+                .returns(() => false)
+                .verifiable(TypeMoq.Times.atLeastOnce());
+            stat.setup(s => s.isSymbolicLink())
+                .returns(() => false)
+                .verifiable(TypeMoq.Times.atLeastOnce());
+        } else {
+            throw Error(`unsupported file type ${filetype}`);
+        }
+    }
+
+    suite('stat', () => {
+        test('wraps the low-level function', async () => {
+            const filename = 'x/y/z/spam.py';
+            const expected = createDummyStat(FileType.File);
+            raw.setup(r => r.stat(vscode.Uri.file(filename))) // expect the specific filename
+                .returns(() => Promise.resolve(expected));
+
+            const stat = await filesystem.stat(filename);
+
+            expect(stat).to.equal(expected);
+            verifyAll();
+        });
+
+        test('fails if the low-level call fails', async () => {
+            raw.setup(r => r.stat(TypeMoq.It.isAny())) // We don't care about the filename.
+                .throws(new Error('file not found'));
+
+            const promise = filesystem.stat('spam.py');
+
+            await expect(promise).to.eventually.be.rejected;
+            verifyAll();
+        });
+    });
+
+    suite('lstat', () => {
+        function copyStat(stat: FileStat, old: TypeMoq.IMock<fsextra.Stats>) {
+            old.setup(s => s.size) // plug in the original value
+                .returns(() => stat.size);
+            old.setup(s => s.ctimeMs) // plug in the original value
+                .returns(() => stat.ctime);
+            old.setup(s => s.mtimeMs) // plug in the original value
+                .returns(() => stat.mtime);
+        }
+
+        [
+            { kind: 'file', filetype: FileType.File },
+            { kind: 'dir', filetype: FileType.Directory },
+            { kind: 'symlink', filetype: FileType.SymbolicLink },
+            { kind: 'unknown', filetype: FileType.Unknown }
+        ].forEach(testData => {
+            test(`wraps the low-level function (filetype: ${testData.kind}`, async () => {
+                const filename = 'x/y/z/spam.py';
+                const expected: FileStat = {
+                    type: testData.filetype,
+                    size: 10,
+                    ctime: 101,
+                    mtime: 102
+                    //tslint:disable-next-line:no-any
+                } as any;
+                const old = createMockLegacyStat();
+                setupStatFileType(old, testData.filetype);
+                copyStat(expected, old);
+                raw.setup(r => r.lstat(filename)) // expect the specific filename
+                    .returns(() => Promise.resolve(old.object));
+
+                const stat = await filesystem.lstat(filename);
+
+                expect(stat).to.deep.equal(expected);
+                verifyAll();
+            });
+        });
+
+        test('fails if the low-level call fails', async () => {
+            raw.setup(r => r.lstat(TypeMoq.It.isAny())) // We don't care about the filename.
+                .throws(new Error('file not found'));
+
+            const promise = filesystem.lstat('spam.py');
+
+            await expect(promise).to.eventually.be.rejected;
+            verifyAll();
+        });
+    });
+
+    suite('chmod', () => {
+        test('passes through a string mode', async () => {
+            const filename = 'x/y/z/spam.py';
+            const mode = '755';
+            raw.setup(r => r.chmod(filename, mode)) // expect the specific filename
+                .returns(() => Promise.resolve());
+
+            await filesystem.chmod(filename, mode);
+
+            verifyAll();
+        });
+
+        test('passes through an int mode', async () => {
+            const filename = 'x/y/z/spam.py';
+            const mode = 0o755;
+            raw.setup(r => r.chmod(filename, mode)) // expect the specific filename
+                .returns(() => Promise.resolve());
+
+            await filesystem.chmod(filename, mode);
+
+            verifyAll();
+        });
+
+        test('fails if the low-level call fails', async () => {
+            raw.setup(r => r.chmod(TypeMoq.It.isAny(), TypeMoq.It.isAny())) // We don't care about the filename.
+                .throws(new Error('file not found'));
+
+            const promise = filesystem.chmod('spam.py', 755);
+
+            await expect(promise).to.eventually.be.rejected;
+            verifyAll();
+        });
+    });
+
+    suite('move', () => {
+        test('wraps the low-level function', async () => {
+            const src = 'x/y/z/spam.py';
+            const tgt = 'x/y/spam.py';
+            raw.setup(r => r.rename(src, tgt)) // expect the specific filename
+                .returns(() => Promise.resolve());
+
+            await filesystem.move(src, tgt);
+
+            verifyAll();
+        });
+
+        test('fails if the low-level call fails', async () => {
+            raw.setup(r => r.rename(TypeMoq.It.isAny(), TypeMoq.It.isAny())) // We don't care about the filename.
+                .throws(new Error('file not found'));
+
+            const promise = filesystem.move('spam', 'eggs');
+
+            await expect(promise).to.eventually.be.rejected;
+            verifyAll();
+        });
+    });
+
+    suite('readData', () => {
+        test('wraps the low-level function', async () => {
+            const filename = 'x/y/z/spam.py';
+            const expected = Buffer.from('<data>');
+            raw.setup(r => r.readFile(filename)) // expect the specific filename
+                .returns(() => Promise.resolve(expected));
+
+            const data = await filesystem.readData(filename);
+
+            expect(data).to.equal(expected);
+            verifyAll();
+        });
+
+        test('fails if the low-level call fails', async () => {
+            raw.setup(r => r.readFile(TypeMoq.It.isAny())) // We don't care about the filename.
+                .throws(new Error('file not found'));
+
+            const promise = filesystem.readData('spam.py');
+
+            await expect(promise).to.eventually.be.rejected;
+            verifyAll();
+        });
+    });
+
+    suite('readText', () => {
+        test('wraps the low-level function', async () => {
+            const filename = 'x/y/z/spam.py';
+            const expected = '<text>';
+            raw.setup(r => r.readFile(filename, 'utf8')) // expect the specific filename
+                .returns(() => Promise.resolve(expected));
+
+            const text = await filesystem.readText(filename);
+
+            expect(text).to.equal(expected);
+            verifyAll();
+        });
+
+        test('fails if the low-level call fails', async () => {
+            raw.setup(r => r.readFile(TypeMoq.It.isAny(), TypeMoq.It.isAny())) // We don't care about the filename.
+                .throws(new Error('file not found'));
+
+            const promise = filesystem.readText('spam.py');
+
+            await expect(promise).to.eventually.be.rejected;
+            verifyAll();
+        });
+    });
+
+    suite('writeText', () => {
+        test('wraps the low-level function', async () => {
+            const filename = 'x/y/z/spam.py';
+            const text = '<text>';
+            raw.setup(r => r.writeFile(filename, text, { encoding: 'utf8' })) // expect the specific filename
+                .returns(() => Promise.resolve());
+
+            await filesystem.writeText(filename, text);
+
+            verifyAll();
+        });
+
+        test('fails if the low-level call fails', async () => {
+            raw.setup(r => r.writeFile(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny())) // We don't care about the filename.
+                .throws(new Error('file not found'));
+
+            const promise = filesystem.writeText('spam.py', '<text>');
+
+            await expect(promise).to.eventually.be.rejected;
+            verifyAll();
+        });
+    });
+
+    suite('appendText', () => {
+        test('wraps the low-level function', async () => {
+            const filename = 'x/y/z/spam.py';
+            const text = '<text>';
+            raw.setup(r => r.appendFile(filename, text)) // expect the specific filename
+                .returns(() => Promise.resolve());
+
+            await filesystem.appendText(filename, text);
+
+            verifyAll();
+        });
+
+        test('fails if the low-level call fails', async () => {
+            raw.setup(r => r.appendFile(TypeMoq.It.isAny(), TypeMoq.It.isAny())) // We don't care about the filename.
+                .throws(new Error('file not found'));
+
+            const promise = filesystem.appendText('spam.py', '<text>');
+
+            await expect(promise).to.eventually.be.rejected;
+            verifyAll();
+        });
+    });
+
+    suite('copyFile', () => {
+        type StreamCallbacks = {
+            err(err: Error): void;
+            close(): void;
+        };
+        function setupMocks(src: string, tgt: string): { r: StreamCallbacks; w: StreamCallbacks } {
+            const callbacks = {
+                //tslint:disable-next-line:no-any
+                r: ({} as any) as StreamCallbacks,
+                //tslint:disable-next-line:no-any
+                w: ({} as any) as StreamCallbacks
+            };
+
+            const wstream = TypeMoq.Mock.ofType<fs.WriteStream>(undefined, TypeMoq.MockBehavior.Strict);
+            wstream
+                .setup(s => s.on('error', TypeMoq.It.isAny()))
+                .callback((_e, cb) => {
+                    callbacks.w.err = cb;
+                })
+                .returns(() => wstream.object);
+            wstream
+                .setup(s => s.on('close', TypeMoq.It.isAny()))
+                .callback((_e, cb) => {
+                    callbacks.w.close = cb;
+                })
+                .returns(() => wstream.object);
+            wstream
+                //tslint:disable-next-line:no-any
+                .setup((s: any) => s.___matches) // typemoq sometimes outsmarts itself
+                .returns(() => undefined);
+            raw.setup(r => r.createWriteStream(tgt)) // expect the specific filename
+                .returns(() => wstream.object);
+
+            const rstream = TypeMoq.Mock.ofType<fs.ReadStream>(undefined, TypeMoq.MockBehavior.Strict);
+            rstream
+                .setup(s => s.on('error', TypeMoq.It.isAny()))
+                .callback((_e, cb) => {
+                    callbacks.r.err = cb;
+                })
+                .returns(() => rstream.object);
+            rstream.setup(s => s.pipe(wstream.object));
+            raw.setup(r => r.createReadStream(src)) // expect the specific filename
+                .returns(() => rstream.object);
+
+            return callbacks;
+        }
+
+        test('wraps the low-level function', async () => {
+            const src = 'spam.py';
+            const tgt = 'eggs.py';
+            const cb = setupMocks(src, tgt);
+
+            // Due to the use of deferred, we must call the handler
+            // registered on the stream in order to make the promise
+            // resolve.
+            const promise = filesystem.copyFile(src, tgt);
+            cb.w.close();
+            await promise;
+
+            verifyAll();
+        });
+
+        test('fails if createReadStream fails', async () => {
+            raw.setup(r => r.createReadStream(TypeMoq.It.isAny())) // We don't care about the filename.
+                .throws(new Error('file not found'));
+
+            const promise = filesystem.copyFile('spam', 'eggs');
+
+            await expect(promise).to.eventually.be.rejected;
+            verifyAll();
+        });
+
+        test('fails if createWriteStream fails', async () => {
+            const rstream = TypeMoq.Mock.ofType<fs.ReadStream>(undefined, TypeMoq.MockBehavior.Strict);
+            rstream.setup(s => s.on('error', TypeMoq.It.isAny()));
+            raw.setup(r => r.createReadStream(TypeMoq.It.isAny())) // We don't care about the filename.
+                .throws(new Error('file not found'));
+
+            const promise = filesystem.copyFile('spam', 'eggs');
+
+            await expect(promise).to.eventually.be.rejected;
+            verifyAll();
+        });
+
+        test('fails if read stream errors out', async () => {
+            const src = 'spam.py';
+            const tgt = 'eggs.py';
+            const cb = setupMocks(src, tgt);
+
+            const promise = filesystem.copyFile(src, tgt);
+            cb.r.err(new Error('oops!'));
+
+            await expect(promise).to.eventually.be.rejected;
+            verifyAll();
+        });
+
+        test('fails if write stream errors out', async () => {
+            const src = 'spam.py';
+            const tgt = 'eggs.py';
+            const cb = setupMocks(src, tgt);
+
+            const promise = filesystem.copyFile(src, tgt);
+            cb.w.err(new Error('oops!'));
+
+            await expect(promise).to.eventually.be.rejected;
+            verifyAll();
+        });
+    });
+
+    suite('rmFile', () => {
+        test('wraps the low-level function', async () => {
+            const filename = 'x/y/z/spam.py';
+            raw.setup(r => r.unlink(filename)) // expect the specific filename
+                .returns(() => Promise.resolve());
+
+            await filesystem.rmfile(filename);
+
+            verifyAll();
+        });
+
+        test('fails if the low-level call fails', async () => {
+            raw.setup(r => r.unlink(TypeMoq.It.isAny())) // We don't care about the filename.
+                .throws(new Error('file not found'));
+
+            const promise = filesystem.rmfile('spam.py');
+
+            await expect(promise).to.eventually.be.rejected;
+            verifyAll();
+        });
+    });
+
+    suite('mkdirp', () => {
+        test('wraps the low-level function', async () => {
+            const dirname = 'x/y/z/spam';
+            raw.setup(r => r.mkdirp(dirname)) // expect the specific filename
+                .returns(() => Promise.resolve());
+
+            await filesystem.mkdirp(dirname);
+
+            verifyAll();
+        });
+
+        test('fails if the low-level call fails', async () => {
+            raw.setup(r => r.mkdirp(TypeMoq.It.isAny())) // We don't care about the filename.
+                .throws(new Error('file not found'));
+
+            const promise = filesystem.mkdirp('spam');
+
+            await expect(promise).to.eventually.be.rejected;
+            verifyAll();
+        });
+    });
+
+    suite('rmtree', () => {
+        test('wraps the low-level function', async () => {
+            const dirname = 'x/y/z/spam';
+            raw.setup(r => r.rmdir(dirname)) // expect the specific filename
+                .returns(() => Promise.resolve());
+
+            await filesystem.rmtree(dirname);
+
+            verifyAll();
+        });
+
+        test('fails if the low-level call fails', async () => {
+            raw.setup(r => r.rmdir(TypeMoq.It.isAny())) // We don't care about the filename.
+                .throws(new Error('file not found'));
+
+            const promise = filesystem.rmtree('spam');
+
+            await expect(promise).to.eventually.be.rejected;
+            verifyAll();
+        });
+    });
+
+    suite('listdir', () => {
+        function setupForFileType(filename: string, filetype: FileType) {
+            const lstat = createMockLegacyStat();
+            if ((filetype & FileType.SymbolicLink) > 0) {
+                lstat
+                    .setup(s => s.isSymbolicLink()) // we don't care about any other type here
+                    .returns(() => true);
+
+                const stat = createMockLegacyStat();
+                // filetype won't be Unknown here.
+                setupStatFileType(stat, filetype - FileType.SymbolicLink);
+                raw.setup(r => r.stat(filename)) // expect the specific filename
+                    .returns(() => Promise.resolve(stat.object));
+            } else {
+                lstat
+                    .setup(s => s.isSymbolicLink())
+                    .returns(() => false)
+                    .verifiable(TypeMoq.Times.atLeastOnce());
+                setupStatFileType(lstat, filetype);
+            }
+            raw.setup(r => r.lstat(filename)) // expect the specific filename
+                .returns(() => Promise.resolve(lstat.object));
+        }
+
+        test('mixed', async () => {
+            const dirname = 'x/y/z/spam';
+            const names = [
+                // These match the items in "expected".
+                'dev1',
+                'w',
+                'spam.py',
+                'other'
+            ];
+            const expected: [string, FileType][] = [
+                ['x/y/z/spam/dev1', FileType.Unknown],
+                ['x/y/z/spam/w', FileType.Directory],
+                ['x/y/z/spam/spam.py', FileType.File],
+                ['x/y/z/spam/other', FileType.SymbolicLink | FileType.File]
+            ];
+            raw.setup(r => r.readdir(dirname)) // expect the specific filename
+                .returns(() => Promise.resolve(names));
+            names.forEach((name, i) => {
+                const [filename, filetype] = expected[i];
+                raw.setup(r => r.join(dirname, name)) // expect the specific filename
+                    .returns(() => filename);
+                setupForFileType(filename, filetype);
+            });
+
+            const entries = await filesystem.listdir(dirname);
+
+            expect(entries).to.deep.equal(expected);
+            verifyAll();
+        });
+
+        test('empty', async () => {
+            const dirname = 'x/y/z/spam';
+            const expected: [string, FileType][] = [];
+            raw.setup(r => r.readdir(dirname)) // expect the specific filename
+                .returns(() => Promise.resolve([]));
+
+            const entries = await filesystem.listdir(dirname);
+
+            expect(entries).to.deep.equal(expected);
+            verifyAll();
+        });
+
+        test('fails if the low-level call fails', async () => {
+            raw.setup(r => r.readdir(TypeMoq.It.isAny())) // We don't care about the filename.
+                .throws(new Error('file not found'));
+
+            const promise = filesystem.listdir('spam');
+
+            await expect(promise).to.eventually.be.rejected;
+            verifyAll();
+        });
+    });
+
+    suite('readTextSync', () => {
+        test('wraps the low-level function', () => {
+            const filename = 'x/y/z/spam.py';
+            const expected = '<text>';
+            raw.setup(r => r.readFileSync(filename, 'utf8')) // expect the specific filename
+                .returns(() => expected);
+
+            const text = filesystem.readTextSync(filename);
+
+            expect(text).to.equal(expected);
+            verifyAll();
+        });
+
+        test('fails if the low-level call fails', async () => {
+            raw.setup(r => r.readFileSync(TypeMoq.It.isAny(), TypeMoq.It.isAny())) // We don't care about the filename.
+                .throws(new Error('file not found'));
+
+            expect(() => filesystem.readTextSync('spam.py')).to.throw();
+
+            verifyAll();
+        });
+    });
+
+    suite('createReadStream', () => {
+        test('wraps the low-level function', () => {
+            const filename = 'x/y/z/spam.py';
+            //tslint:disable-next-line:no-any
+            const expected = {} as any;
+            raw.setup(r => r.createReadStream(filename)) // expect the specific filename
+                .returns(() => expected);
+
+            const stream = filesystem.createReadStream(filename);
+
+            expect(stream).to.equal(expected);
+            verifyAll();
+        });
+
+        test('fails if the low-level call fails', async () => {
+            raw.setup(r => r.createReadStream(TypeMoq.It.isAny())) // We don't care about the filename.
+                .throws(new Error('file not found'));
+
+            expect(() => filesystem.createReadStream('spam.py')).to.throw();
+
+            verifyAll();
+        });
+    });
+
+    suite('createWriteStream', () => {
+        test('wraps the low-level function', () => {
+            const filename = 'x/y/z/spam.py';
+            //tslint:disable-next-line:no-any
+            const expected = {} as any;
+            raw.setup(r => r.createWriteStream(filename)) // expect the specific filename
+                .returns(() => expected);
+
+            const stream = filesystem.createWriteStream(filename);
+
+            expect(stream).to.equal(expected);
+            verifyAll();
+        });
+
+        test('fails if the low-level call fails', async () => {
+            raw.setup(r => r.createWriteStream(TypeMoq.It.isAny())) // We don't care about the filename.
+                .throws(new Error('file not found'));
+
+            expect(() => filesystem.createWriteStream('spam.py')).to.throw();
+
+            verifyAll();
+        });
+    });
+});
+
+// tslint:disable-next-line:no-suspicious-comment
+// TODO(GH-8995): The FileSystem isn't unit-tesstable currently.  Once
+// we address that, all its methods should have tests here.
diff --git a/src/test/common/variables/envVarsService.functional.test.ts b/src/test/common/variables/envVarsService.functional.test.ts
index 6dbb78fb49af..ce795f6cc1dd 100644
--- a/src/test/common/variables/envVarsService.functional.test.ts
+++ b/src/test/common/variables/envVarsService.functional.test.ts
@@ -7,7 +7,6 @@
 
 import { expect, use } from 'chai';
 import * as chaiAsPromised from 'chai-as-promised';
-import * as path from 'path';
 import { FileSystem } from '../../../client/common/platform/fileSystem';
 import { PathUtils } from '../../../client/common/platform/pathUtils';
 import { PlatformService } from '../../../client/common/platform/platformService';
@@ -19,7 +18,8 @@ import { getOSType } from '../../common';
 
 use(chaiAsPromised);
 
-const envFilesFolderPath = path.join(__dirname, '..', '..', '..', '..', 'src', 'testMultiRootWkspc', 'workspace4');
+// Functional tests that run code using the VS Code API are found
+// in envVarsService.test.ts.
 
 suite('Environment Variables Service', () => {
     let pathUtils: IPathUtils;
@@ -35,51 +35,5 @@ suite('Environment Variables Service', () => {
             const vars = await variablesService.parseFile(undefined);
             expect(vars).to.equal(undefined, 'Variables should be undefined');
         });
-
-        test('Custom variables should be undefined with non-existent files', async () => {
-            const vars = await variablesService.parseFile(path.join(envFilesFolderPath, 'abcd'));
-            expect(vars).to.equal(undefined, 'Variables should be undefined');
-        });
-
-        test('Custom variables should be undefined when folder name is passed instead of a file name', async () => {
-            const vars = await variablesService.parseFile(envFilesFolderPath);
-            expect(vars).to.equal(undefined, 'Variables should be undefined');
-        });
-
-        test('Custom variables should be not undefined with a valid environment file', async () => {
-            const vars = await variablesService.parseFile(path.join(envFilesFolderPath, '.env'));
-            expect(vars).to.not.equal(undefined, 'Variables should be undefined');
-        });
-
-        test('Custom variables should be parsed from env file', async () => {
-            const vars = await variablesService.parseFile(path.join(envFilesFolderPath, '.env'));
-
-            expect(vars).to.not.equal(undefined, 'Variables is is undefiend');
-            expect(Object.keys(vars!)).lengthOf(2, 'Incorrect number of variables');
-            expect(vars).to.have.property('X1234PYEXTUNITTESTVAR', '1234', 'X1234PYEXTUNITTESTVAR value is invalid');
-            expect(vars).to.have.property('PYTHONPATH', '../workspace5', 'PYTHONPATH value is invalid');
-        });
-
-        test('PATH and PYTHONPATH from env file should be returned as is', async () => {
-            const vars = await variablesService.parseFile(path.join(envFilesFolderPath, '.env5'));
-            const expectedPythonPath = '/usr/one/three:/usr/one/four';
-            const expectedPath = '/usr/x:/usr/y';
-            expect(vars).to.not.equal(undefined, 'Variables is is undefiend');
-            expect(Object.keys(vars!)).lengthOf(5, 'Incorrect number of variables');
-            expect(vars).to.have.property('X', '1', 'X value is invalid');
-            expect(vars).to.have.property('Y', '2', 'Y value is invalid');
-            expect(vars).to.have.property('PYTHONPATH', expectedPythonPath, 'PYTHONPATH value is invalid');
-            expect(vars).to.have.property('PATH', expectedPath, 'PATH value is invalid');
-        });
-
-        test('Simple variable substitution is supported', async () => {
-            const vars = await variablesService.parseFile(path.join(envFilesFolderPath, '.env6'), { BINDIR: '/usr/bin' });
-
-            expect(vars).to.not.equal(undefined, 'Variables is undefiend');
-            expect(Object.keys(vars!)).lengthOf(3, 'Incorrect number of variables');
-            expect(vars).to.have.property('REPO', '/home/user/git/foobar', 'value is invalid');
-            expect(vars).to.have.property('PYTHONPATH', '/home/user/git/foobar/foo:/home/user/git/foobar/bar', 'value is invalid');
-            expect(vars).to.have.property('PYTHON', '/usr/bin/python3', 'value is invalid');
-        });
     });
 });
diff --git a/src/test/common/variables/envVarsService.test.ts b/src/test/common/variables/envVarsService.test.ts
new file mode 100644
index 000000000000..6fd33a453c07
--- /dev/null
+++ b/src/test/common/variables/envVarsService.test.ts
@@ -0,0 +1,88 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+// tslint:disable:max-func-body-length
+
+import { expect, use } from 'chai';
+import * as chaiAsPromised from 'chai-as-promised';
+import * as path from 'path';
+import { FileSystem } from '../../../client/common/platform/fileSystem';
+import { PathUtils } from '../../../client/common/platform/pathUtils';
+import { PlatformService } from '../../../client/common/platform/platformService';
+import { IPathUtils } from '../../../client/common/types';
+import { OSType } from '../../../client/common/utils/platform';
+import { EnvironmentVariablesService } from '../../../client/common/variables/environment';
+import { IEnvironmentVariablesService } from '../../../client/common/variables/types';
+import { getOSType } from '../../common';
+
+use(chaiAsPromised);
+
+const envFilesFolderPath = path.join(__dirname, '..', '..', '..', '..', 'src', 'testMultiRootWkspc', 'workspace4');
+
+// Functional tests that do not run code using the VS Code API are found
+// in envVarsService.test.ts.
+
+suite('Environment Variables Service', () => {
+    let pathUtils: IPathUtils;
+    let variablesService: IEnvironmentVariablesService;
+    setup(() => {
+        pathUtils = new PathUtils(getOSType() === OSType.Windows);
+        const fs = new FileSystem(new PlatformService());
+        variablesService = new EnvironmentVariablesService(pathUtils, fs);
+    });
+
+    suite('parseFile()', () => {
+        test('Custom variables should be undefined with no argument', async () => {
+            const vars = await variablesService.parseFile(undefined);
+            expect(vars).to.equal(undefined, 'Variables should be undefined');
+        });
+
+        test('Custom variables should be undefined with non-existent files', async () => {
+            const vars = await variablesService.parseFile(path.join(envFilesFolderPath, 'abcd'));
+            expect(vars).to.equal(undefined, 'Variables should be undefined');
+        });
+
+        test('Custom variables should be undefined when folder name is passed instead of a file name', async () => {
+            const vars = await variablesService.parseFile(envFilesFolderPath);
+            expect(vars).to.equal(undefined, 'Variables should be undefined');
+        });
+
+        test('Custom variables should be not undefined with a valid environment file', async () => {
+            const vars = await variablesService.parseFile(path.join(envFilesFolderPath, '.env'));
+            expect(vars).to.not.equal(undefined, 'Variables should be undefined');
+        });
+
+        test('Custom variables should be parsed from env file', async () => {
+            const vars = await variablesService.parseFile(path.join(envFilesFolderPath, '.env'));
+
+            expect(vars).to.not.equal(undefined, 'Variables is is undefiend');
+            expect(Object.keys(vars!)).lengthOf(2, 'Incorrect number of variables');
+            expect(vars).to.have.property('X1234PYEXTUNITTESTVAR', '1234', 'X1234PYEXTUNITTESTVAR value is invalid');
+            expect(vars).to.have.property('PYTHONPATH', '../workspace5', 'PYTHONPATH value is invalid');
+        });
+
+        test('PATH and PYTHONPATH from env file should be returned as is', async () => {
+            const vars = await variablesService.parseFile(path.join(envFilesFolderPath, '.env5'));
+            const expectedPythonPath = '/usr/one/three:/usr/one/four';
+            const expectedPath = '/usr/x:/usr/y';
+            expect(vars).to.not.equal(undefined, 'Variables is is undefiend');
+            expect(Object.keys(vars!)).lengthOf(5, 'Incorrect number of variables');
+            expect(vars).to.have.property('X', '1', 'X value is invalid');
+            expect(vars).to.have.property('Y', '2', 'Y value is invalid');
+            expect(vars).to.have.property('PYTHONPATH', expectedPythonPath, 'PYTHONPATH value is invalid');
+            expect(vars).to.have.property('PATH', expectedPath, 'PATH value is invalid');
+        });
+
+        test('Simple variable substitution is supported', async () => {
+            const vars = await variablesService.parseFile(path.join(envFilesFolderPath, '.env6'), { BINDIR: '/usr/bin' });
+
+            expect(vars).to.not.equal(undefined, 'Variables is undefiend');
+            expect(Object.keys(vars!)).lengthOf(3, 'Incorrect number of variables');
+            expect(vars).to.have.property('REPO', '/home/user/git/foobar', 'value is invalid');
+            expect(vars).to.have.property('PYTHONPATH', '/home/user/git/foobar/foo:/home/user/git/foobar/bar', 'value is invalid');
+            expect(vars).to.have.property('PYTHON', '/usr/bin/python3', 'value is invalid');
+        });
+    });
+});
diff --git a/src/test/datascience/dataScienceIocContainer.ts b/src/test/datascience/dataScienceIocContainer.ts
index d0f3ae6afbcc..a258758a18ef 100644
--- a/src/test/datascience/dataScienceIocContainer.ts
+++ b/src/test/datascience/dataScienceIocContainer.ts
@@ -344,6 +344,7 @@ export class DataScienceIocContainer extends UnitTestIocContainer {
 
     constructor() {
         super();
+        this.useVSCodeAPI = false;
         const isRollingBuild = process.env ? process.env.VSCODE_PYTHON_ROLLING !== undefined : false;
         this.shouldMockJupyter = !isRollingBuild;
         this.asyncRegistry = new AsyncDisposableRegistry();
diff --git a/src/test/serviceRegistry.ts b/src/test/serviceRegistry.ts
index a9635b02b4e4..05e1f914dde1 100644
--- a/src/test/serviceRegistry.ts
+++ b/src/test/serviceRegistry.ts
@@ -1,19 +1,20 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-import { Container } from 'inversify';
+import * as fsextra from 'fs-extra';
+import { Container, inject } from 'inversify';
 import { anything, instance, mock, when } from 'ts-mockito';
 import * as TypeMoq from 'typemoq';
-import { Disposable, Memento, OutputChannel } from 'vscode';
+import { Disposable, Memento, OutputChannel, Uri } from 'vscode';
 import { STANDARD_OUTPUT_CHANNEL } from '../client/common/constants';
 import { Logger } from '../client/common/logger';
 import { IS_WINDOWS } from '../client/common/platform/constants';
-import { FileSystem } from '../client/common/platform/fileSystem';
+import { convertStat, FileSystem, RawFileSystem } from '../client/common/platform/fileSystem';
 import { PathUtils } from '../client/common/platform/pathUtils';
 import { PlatformService } from '../client/common/platform/platformService';
 import { RegistryImplementation } from '../client/common/platform/registry';
 import { registerTypes as platformRegisterTypes } from '../client/common/platform/serviceRegistry';
-import { IFileSystem, IPlatformService, IRegistry } from '../client/common/platform/types';
+import { FileStat, FileType, IFileSystem, IPlatformService, IRegistry } from '../client/common/platform/types';
 import { BufferDecoder } from '../client/common/process/decoder';
 import { ProcessService } from '../client/common/process/proc';
 import { PythonExecutionFactory } from '../client/common/process/pythonExecutionFactory';
@@ -72,7 +73,42 @@ import { MockMemento } from './mocks/mementos';
 import { MockProcessService } from './mocks/proc';
 import { MockProcess } from './mocks/process';
 
+// This is necessary for unit tests and functional tests, since they
+// do not run under VS Code so they do not have access to the actual
+// "vscode" namespace.
+class FakeVSCodeFileSystemAPI {
+    public async stat(uri: Uri): Promise<FileStat> {
+        const filename = uri.fsPath;
+
+        let filetype = FileType.Unknown;
+        let stat = await fsextra.lstat(filename);
+        if (stat.isSymbolicLink()) {
+            filetype = FileType.SymbolicLink;
+            stat = await fsextra.stat(filename);
+        }
+        if (stat.isFile()) {
+            filetype |= FileType.File;
+        } else if (stat.isDirectory()) {
+            filetype |= FileType.Directory;
+        }
+        return convertStat(stat, filetype);
+    }
+}
+class LegacyFileSystem extends FileSystem {
+    constructor(@inject(IPlatformService) platformService: IPlatformService) {
+        super(platformService);
+        const vscfs = new FakeVSCodeFileSystemAPI();
+        this.raw = RawFileSystem.withDefaults(undefined, vscfs);
+    }
+}
+
 export class IocContainer {
+    // This may be set (before any registration happens) to indicate
+    // whether or not IOC should depend on the VS Code API (e.g. the
+    // "vscode" module).  So in "functional" tests, this should be set
+    // to "false".
+    public useVSCodeAPI = true;
+
     public readonly serviceManager: IServiceManager;
     public readonly serviceContainer: IServiceContainer;
 
@@ -119,7 +155,11 @@ export class IocContainer {
     }
     public registerFileSystemTypes() {
         this.serviceManager.addSingleton<IPlatformService>(IPlatformService, PlatformService);
-        this.serviceManager.addSingleton<IFileSystem>(IFileSystem, FileSystem);
+        this.serviceManager.addSingleton<IFileSystem>(
+            IFileSystem,
+            // Maybe use fake vscode.workspace.filesystem API:
+            this.useVSCodeAPI ? FileSystem : LegacyFileSystem
+        );
     }
     public registerProcessTypes() {
         processRegisterTypes(this.serviceManager);