diff --git a/news/3 Code Health/6911.md b/news/3 Code Health/6911.md
new file mode 100644
index 000000000000..f7a40ecad97d
--- /dev/null
+++ b/news/3 Code Health/6911.md	
@@ -0,0 +1 @@
+Use the new VS Code filesystem API as much as possible.
diff --git a/src/client/common/platform/fileSystem.ts b/src/client/common/platform/fileSystem.ts
index 25886aabc12d..24f26a1f13d5 100644
--- a/src/client/common/platform/fileSystem.ts
+++ b/src/client/common/platform/fileSystem.ts
@@ -4,7 +4,6 @@
 'use strict';
 
 import { createHash } from 'crypto';
-import * as fs from 'fs';
 import * as fsextra from 'fs-extra';
 import * as glob from 'glob';
 import { injectable } from 'inversify';
@@ -12,7 +11,6 @@ import * as fspath from 'path';
 import * as tmpMod from 'tmp';
 import * as util from 'util';
 import * as vscode from 'vscode';
-import { createDeferred } from '../utils/async';
 import { getOSType, OSType } from '../utils/platform';
 import {
     FileStat, FileType,
@@ -22,25 +20,42 @@ import {
 } from './types';
 
 // tslint:disable:max-classes-per-file
+// tslint:disable:no-suspicious-comment
 
 const ENCODING: string = 'utf8';
 
-// Determine the file type from the given file info.
-function getFileType(stat: FileStat): FileType {
+const FILE_NOT_FOUND = vscode.FileSystemError.FileNotFound().name;
+const FILE_EXISTS = vscode.FileSystemError.FileExists().name;
+
+function isFileNotFoundError(err: Error): boolean {
+    return err.name === FILE_NOT_FOUND;
+}
+
+function isFileExistsError(err: Error): boolean {
+    return err.name === FILE_EXISTS;
+}
+
+function convertFileStat(stat: fsextra.Stats): FileStat {
+    let fileType = FileType.Unknown;
     if (stat.isFile()) {
-        return FileType.File;
+        fileType = FileType.File;
     } else if (stat.isDirectory()) {
-        return FileType.Directory;
+        fileType = FileType.Directory;
     } else if (stat.isSymbolicLink()) {
-        return FileType.SymbolicLink;
-    } else {
-        return FileType.Unknown;
-    }
+        fileType = FileType.SymbolicLink;
+    }
+    return {
+        type: fileType,
+        size: stat.size,
+        ctime: stat.ctimeMs,
+        mtime: stat.mtimeMs
+    };
 }
 
 // The parts of node's 'path' module used by FileSystemPath.
 interface INodePath {
     join(...filenames: string[]): string;
+    dirname(filename: string): string;
     normalize(filename: string): string;
 }
 
@@ -66,6 +81,10 @@ export class FileSystemPaths implements IFileSystemPaths {
         return this.raw.join(...filenames);
     }
 
+    public dirname(filename: string): string {
+        return this.raw.dirname(filename);
+    }
+
     public normCase(filename: string): string {
         filename = this.raw.normalize(filename);
         return this.isCaseSensitive ? filename.toUpperCase() : filename;
@@ -112,36 +131,32 @@ export class TempFileSystem {
     }
 }
 
-// This is the parts of node's 'fs' module that we use in RawFileSystem.
-interface IRawFS {
-    // non-async
-    createWriteStream(filePath: string): fs.WriteStream;
+// 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 {
+    copy(source: vscode.Uri, target: vscode.Uri, options?: {overwrite: boolean}): Thenable<void>;
+    createDirectory(uri: vscode.Uri): Thenable<void>;
+    delete(uri: vscode.Uri, options?: {recursive: boolean; useTrash: boolean}): Thenable<void>;
+    readDirectory(uri: vscode.Uri): Thenable<[string, FileType][]>;
+    readFile(uri: vscode.Uri): Thenable<Uint8Array>;
+    stat(uri: vscode.Uri): Thenable<FileStat>;
+    writeFile(uri: vscode.Uri, content: Uint8Array): Thenable<void>;
 }
 
 // This is the parts of the 'fs-extra' module that we use in RawFileSystem.
 interface IRawFSExtra {
     chmod(filePath: string, mode: string | number): Promise<void>;
-    readFile(path: string, encoding: string): Promise<string>;
-    //tslint:disable-next-line:no-any
-    writeFile(path: string, data: any, options: any): Promise<void>;
-    unlink(filename: string): Promise<void>;
-    stat(filename: string): Promise<fsextra.Stats>;
     lstat(filename: string): Promise<fsextra.Stats>;
-    mkdirp(dirname: string): Promise<void>;
-    rmdir(dirname: string): Promise<void>;
-    readdir(dirname: string): Promise<string[]>;
-    remove(dirname: string): Promise<void>;
 
     // non-async
     statSync(filename: string): fsextra.Stats;
     readFileSync(path: string, encoding: string): string;
-    createReadStream(src: string): fsextra.ReadStream;
-    createWriteStream(dest: string): fsextra.WriteStream;
+    createWriteStream(filePath: string): fsextra.WriteStream;
 }
 
-// The parts of IFileSystemPaths used by RawFileSystem.
 interface IRawPath {
-    join(...filenames: string[]): string;
+    dirname(filename: string): string;
 }
 
 // Later we will drop "FileSystem", switching usage to
@@ -150,105 +165,155 @@ interface IRawPath {
 // The low-level filesystem operations used by the extension.
 export class RawFileSystem implements IRawFileSystem {
     constructor(
-        protected readonly path: IRawPath,
-        protected readonly nodefs: IRawFS,
+        protected readonly paths: IRawPath,
+        protected readonly vscfs: IVSCodeFileSystemAPI,
         protected readonly fsExtra: IRawFSExtra
     ) { }
 
     // Create a new object using common-case default values.
-    public static withDefaults(): RawFileSystem{
+    public static withDefaults(
+        paths?: IRawPath,
+        vscfs?: IVSCodeFileSystemAPI,
+        fsExtra?: IRawFSExtra
+    ): RawFileSystem{
         return new RawFileSystem(
-            FileSystemPaths.withDefaults(),
-            fs,
-            fsextra
+            paths || FileSystemPaths.withDefaults(),
+            vscfs || vscode.workspace.fs,
+            fsExtra || fsextra
         );
     }
 
     //****************************
-    // fs-extra
+    // VS Code API
 
     public async readText(filename: string): Promise<string> {
-        return this.fsExtra.readFile(filename, ENCODING);
+        const uri = vscode.Uri.file(filename);
+        const data = Buffer.from(
+            await this.vscfs.readFile(uri));
+        return data.toString(ENCODING);
     }
 
-    public async writeText(filename: string, data: {}): Promise<void> {
-        const options: fsextra.WriteFileOptions = {
-            encoding: ENCODING
-        };
-        await this.fsExtra.writeFile(filename, data, options);
-    }
-
-    public async mkdirp(dirname: string): Promise<void> {
-        return this.fsExtra.mkdirp(dirname);
+    public async writeText(filename: string, text: string): Promise<void> {
+        const uri = vscode.Uri.file(filename);
+        const data = Buffer.from(text);
+        await this.vscfs.writeFile(uri, data);
     }
 
     public async rmtree(dirname: string): Promise<void> {
-        return this.fsExtra.stat(dirname)
-            .then(() => this.fsExtra.remove(dirname));
+        const uri = vscode.Uri.file(dirname);
+        // TODO (https://github.com/microsoft/vscode/issues/84177)
+        //   The docs say "throws - FileNotFound when uri doesn't exist".
+        //   However, it happily does nothing (at least for remote-over-SSH).
+        //   So we have to manually stat, just to be sure.
+        await this.vscfs.stat(uri);
+        return this.vscfs.delete(uri, {
+            recursive: true,
+            useTrash: false
+        });
     }
 
     public async rmfile(filename: string): Promise<void> {
-        return this.fsExtra.unlink(filename);
-    }
-
-    public async chmod(filename: string, mode: string | number): Promise<void> {
-        return this.fsExtra.chmod(filename, mode);
+        const uri = vscode.Uri.file(filename);
+        return this.vscfs.delete(uri, {
+            recursive: false,
+            useTrash: false
+        });
     }
 
     public async stat(filename: string): Promise<FileStat> {
-        return this.fsExtra.stat(filename);
+        const uri = vscode.Uri.file(filename);
+        return this.vscfs.stat(uri);
     }
 
-    public async lstat(filename: string): Promise<FileStat> {
-        return this.fsExtra.lstat(filename);
+    public async listdir(dirname: string): Promise<[string, FileType][]> {
+        const uri = vscode.Uri.file(dirname);
+        return this.vscfs.readDirectory(uri);
     }
 
-    // Once we move to the VS Code API, this method becomes a trivial wrapper.
-    public async listdir(dirname: string): Promise<[string, FileType][]> {
-        const names: string[] = await this.fsExtra.readdir(dirname);
-        const promises = names
-            .map(name => {
-                 const filename = this.path.join(dirname, name);
-                 return this.lstat(filename)
-                     .then(stat => [name, getFileType(stat)] as [string, FileType])
-                     .catch(() => [name, FileType.Unknown] as [string, FileType]);
-            });
-        return Promise.all(promises);
+    public async mkdirp(dirname: string): Promise<void> {
+        // TODO https://github.com/microsoft/vscode/issues/84175
+        //   Hopefully VS Code provides this method in their API
+        //   so we don't have to roll our own.
+        const stack = [dirname];
+        while (stack.length > 0) {
+            const current = stack.pop() || '';
+            const uri = vscode.Uri.file(current);
+            try {
+                await this.vscfs.createDirectory(uri);
+            } catch (err) {
+                if (isFileExistsError(err)) {
+                    // already done!
+                    return;
+                }
+                // According to the docs, FileNotFound means the parent
+                // does not exist.
+                // See: https://code.visualstudio.com/api/references/vscode-api#FileSystemProvider
+                if (!isFileNotFoundError(err)) {
+                    // Fail for anything else.
+                    throw err; // re-throw
+                }
+                // Try creating the parent first.
+                const parent = this.paths.dirname(current);
+                if (parent === '' || parent === current) {
+                    // This shouldn't ever happen.
+                    throw err;
+                }
+                stack.push(current);
+                stack.push(parent);
+            }
+        }
     }
 
-    // Once we move to the VS Code API, this method becomes a trivial wrapper.
     public async copyFile(src: string, dest: string): Promise<void> {
-        const deferred = createDeferred<void>();
-        const rs = this.fsExtra.createReadStream(src)
-            .on('error', (err) => {
-                deferred.reject(err);
-            });
-        const ws = this.fsExtra.createWriteStream(dest)
-            .on('error', (err) => {
-                deferred.reject(err);
-            }).on('close', () => {
-                deferred.resolve();
-            });
-        rs.pipe(ws);
-        return deferred.promise;
+        const srcURI = vscode.Uri.file(src);
+        const destURI = vscode.Uri.file(dest);
+        // TODO (https://github.com/microsoft/vscode/issues/84177)
+        //   The docs say "throws - FileNotFound when parent of
+        //   destination doesn't exist".  However, it happily creates
+        //   the parent directory (at least for remote-over-SSH).
+        //   So we have to manually stat, just to be sure.
+        await this.vscfs.stat(vscode.Uri.file(this.paths.dirname(dest)));
+        await this.vscfs.copy(srcURI, destURI, {
+            overwrite: true
+        });
+    }
+
+    //****************************
+    // fs-extra
+
+    public async chmod(filename: string, mode: string | number): Promise<void> {
+        // TODO https://github.com/microsoft/vscode/issues/84175
+        //   This functionality has been requested for the VS Code API.
+        return this.fsExtra.chmod(filename, mode);
+    }
+
+    public async lstat(filename: string): Promise<FileStat> {
+        // TODO https://github.com/microsoft/vscode/issues/84175
+        //   This functionality has been requested for the VS Code API.
+        const stat = await this.fsExtra.lstat(filename);
+        return convertFileStat(stat);
     }
 
     //****************************
     // non-async (fs-extra)
 
     public statSync(filename: string): FileStat {
-        return this.fsExtra.statSync(filename);
+        // TODO https://github.com/microsoft/vscode/issues/84175
+        //   This functionality has been requested for the VS Code API.
+        const stat = this.fsExtra.statSync(filename);
+        return convertFileStat(stat);
     }
 
     public readTextSync(filename: string): string {
+        // TODO https://github.com/microsoft/vscode/issues/84175
+        //   This functionality has been requested for the VS Code API.
         return this.fsExtra.readFileSync(filename, ENCODING);
     }
 
-    //****************************
-    // non-async (fs)
-
     public createWriteStream(filename: string): WriteStream {
-        return this.nodefs.createWriteStream(filename);
+        // TODO https://github.com/microsoft/vscode/issues/84175
+        //   This functionality has been requested for the VS Code API.
+        return this.fsExtra.createWriteStream(filename);
     }
 }
 
@@ -257,20 +322,26 @@ export class RawFileSystem implements IRawFileSystem {
 export class FileSystemUtils implements IFileSystemUtils {
     constructor(
         public readonly raw: IRawFileSystem,
-        public readonly path: IFileSystemPaths,
+        public readonly paths: IFileSystemPaths,
         public readonly tmp: ITempFileSystem,
         protected readonly getHash: (data: string) => string,
         protected readonly globFile: (pat: string) => Promise<string[]>
     ) { }
     // Create a new object using common-case default values.
-    public static withDefaults(): FileSystemUtils {
-        const paths = FileSystemPaths.withDefaults();
+    public static withDefaults(
+        raw?: IRawFileSystem,
+        paths?: IFileSystemPaths,
+        tmp?: ITempFileSystem,
+        getHash?: (data: string) => string,
+        globFile?: (pat: string) => Promise<string[]>
+    ): FileSystemUtils {
+        paths = paths || FileSystemPaths.withDefaults();
         return new FileSystemUtils(
-            new RawFileSystem(paths, fs, fsextra),
+            raw || RawFileSystem.withDefaults(paths),
             paths,
-            TempFileSystem.withDefaults(),
-            getHashString,
-            util.promisify(glob)
+            tmp || TempFileSystem.withDefaults(),
+            getHash || getHashString,
+            globFile || util.promisify(glob)
         );
     }
 
@@ -296,8 +367,8 @@ export class FileSystemUtils implements IFileSystemUtils {
         if (path1 === path2) {
             return true;
         }
-        path1 = this.path.normCase(path1);
-        path2 = this.path.normCase(path2);
+        path1 = this.paths.normCase(path1);
+        path2 = this.paths.normCase(path2);
         return path1 === path2;
     }
 
@@ -307,19 +378,15 @@ export class FileSystemUtils implements IFileSystemUtils {
     ): Promise<boolean> {
         let stat: FileStat;
         try {
-            stat = await this.raw.stat(filename);
+            stat = await this._stat(filename);
         } catch (err) {
             return false;
         }
+
         if (fileType === undefined) {
             return true;
-        } else if (fileType === FileType.File) {
-            return stat.isFile();
-        } else if (fileType === FileType.Directory) {
-            return stat.isDirectory();
-        } else {
-            return false;
         }
+        return stat.type === fileType;
     }
     public async fileExists(filename: string): Promise<boolean> {
         return this.pathExists(filename, FileType.File);
@@ -338,12 +405,12 @@ export class FileSystemUtils implements IFileSystemUtils {
     public async getSubDirectories(dirname: string): Promise<string[]> {
         return (await this.listdir(dirname))
             .filter(([_name, fileType]) => fileType === FileType.Directory)
-            .map(([name, _fileType]) => this.path.join(dirname, name));
+            .map(([name, _fileType]) => this.paths.join(dirname, name));
     }
     public async getFiles(dirname: string): Promise<string[]> {
         return (await this.listdir(dirname))
             .filter(([_name, fileType]) => fileType === FileType.File)
-            .map(([name, _fileType]) => this.path.join(dirname, name));
+            .map(([name, _fileType]) => this.paths.join(dirname, name));
     }
 
     public async isDirReadonly(dirname: string): Promise<boolean> {
@@ -352,7 +419,7 @@ export class FileSystemUtils implements IFileSystemUtils {
             tmpFile = await this.tmp.createFile('___vscpTest___', dirname);
         } catch {
             // Use a stat call to ensure the directory exists.
-            await this.raw.stat(dirname);
+            await this._stat(dirname);
             return true;
         }
         tmpFile.dispose();
@@ -361,7 +428,7 @@ export class FileSystemUtils implements IFileSystemUtils {
 
     public async getFileHash(filename: string): Promise<string> {
         const stat = await this.raw.lstat(filename);
-        const data = `${stat.ctimeMs}-${stat.mtimeMs}`;
+        const data = `${stat.ctime}-${stat.mtime}`;
         return this.getHash(data);
     }
 
@@ -369,6 +436,10 @@ export class FileSystemUtils implements IFileSystemUtils {
         const files = await this.globFile(globPattern);
         return Array.isArray(files) ? files : [];
     }
+
+    public async _stat(filename: string): Promise<FileStat> {
+        return this.raw.stat(filename);
+    }
 }
 
 // We *could* use ICryptoUtils, but it's a bit overkill, issue tracked
@@ -382,7 +453,7 @@ function getHashString(data: string): string {
 // more aliases (to cause less churn)
 @injectable()
 export class FileSystem implements IFileSystem {
-    private readonly utils: FileSystemUtils;
+    protected utils: FileSystemUtils;
     constructor() {
         this.utils = FileSystemUtils.withDefaults();
     }
@@ -442,12 +513,8 @@ export class FileSystem implements IFileSystem {
     //****************************
     // aliases
 
-    public async stat(filePath: string): Promise<vscode.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 vsc = require('vscode');
-        return vsc.workspace.fs.stat(vscode.Uri.file(filePath));
+    public async stat(filePath: string): Promise<FileStat> {
+        return this.utils._stat(filePath);
     }
 
     public async readFile(filename: string): Promise<string> {
diff --git a/src/client/common/platform/types.ts b/src/client/common/platform/types.ts
index 317540932e99..880f87b90175 100644
--- a/src/client/common/platform/types.ts
+++ b/src/client/common/platform/types.ts
@@ -4,7 +4,6 @@
 'use strict';
 
 import * as fs from 'fs';
-import * as fsextra from 'fs-extra';
 import { SemVer } from 'semver';
 import * as vscode from 'vscode';
 import { Architecture, OSType } from '../utils/platform';
@@ -48,11 +47,12 @@ export interface ITempFileSystem {
 
 export interface IFileSystemPaths {
     join(...filenames: string[]): string;
+    dirname(filename: string): string;
     normCase(filename: string): string;
 }
 
 export import FileType = vscode.FileType;
-export type FileStat = fsextra.Stats;
+export type FileStat = vscode.FileStat;
 export type WriteStream = fs.WriteStream;
 
 // Later we will drop "IFileSystem", switching usage to
@@ -104,7 +104,7 @@ export interface IRawFileSystem {
 export const IFileSystemUtils = Symbol('IFileSystemUtils');
 export interface IFileSystemUtils {
     readonly raw: IRawFileSystem;
-    readonly path: IFileSystemPaths;
+    readonly paths: IFileSystemPaths;
     readonly tmp: ITempFileSystem;
 
     //***********************
@@ -157,7 +157,7 @@ export interface IFileSystem {
     search(globPattern: string): Promise<string[]>;
     arePathsSame(path1: string, path2: string): boolean;
 
-    stat(filePath: string): Promise<vscode.FileStat>;
+    stat(filePath: string): Promise<FileStat>;
     readFile(filename: string): Promise<string>;
     writeFile(filename: string, data: {}): Promise<void>;
     chmod(filename: string, mode: string): Promise<void>;
diff --git a/src/client/workspaceSymbols/provider.ts b/src/client/workspaceSymbols/provider.ts
index 019bcd25592d..ee2460be6e8c 100644
--- a/src/client/workspaceSymbols/provider.ts
+++ b/src/client/workspaceSymbols/provider.ts
@@ -43,7 +43,13 @@ export class WorkspaceSymbolProvider implements IWorspaceSymbolProvider {
             .filter(generator => generator !== undefined && generator.enabled)
             .map(async generator => {
                 // load tags
-                const items = await parseTags(generator!.workspaceFolder.fsPath, generator!.tagFilePath, query, token);
+                const items = await parseTags(
+                    generator!.workspaceFolder.fsPath,
+                    generator!.tagFilePath,
+                    query,
+                    token,
+                    this.fs
+                );
                 if (!Array.isArray(items)) {
                     return [];
                 }
diff --git a/src/test/common/crypto.unit.test.ts b/src/test/common/crypto.unit.test.ts
index dfa6f1801dcd..e97b5b4adaed 100644
--- a/src/test/common/crypto.unit.test.ts
+++ b/src/test/common/crypto.unit.test.ts
@@ -4,19 +4,23 @@
 'use strict';
 
 import { assert, expect } from 'chai';
+import * as fsextra from 'fs-extra';
 import * as path from 'path';
 import { CryptoUtils } from '../../client/common/crypto';
-import { FileSystem } from '../../client/common/platform/fileSystem';
 import { EXTENSION_ROOT_DIR_FOR_TESTS } from '../constants';
 
 // tslint:disable-next-line: max-func-body-length
 suite('Crypto Utils', async () => {
     let crypto: CryptoUtils;
-    const fs = new FileSystem();
-    const file = path.join(EXTENSION_ROOT_DIR_FOR_TESTS, 'src', 'test', 'common', 'randomWords.txt');
     setup(() => {
         crypto = new CryptoUtils();
     });
+    async function getWordList(): Promise<string[]> {
+        const file = path.join(EXTENSION_ROOT_DIR_FOR_TESTS, 'src', 'test', 'common', 'randomWords.txt');
+        const words = await fsextra.readFile(file, 'utf8');
+        return words.split('\n');
+    }
+
     test('If hashFormat equals `number`, method createHash() returns a number', async () => {
         const hash = crypto.createHash('blabla', 'number');
         assert.typeOf(hash, 'number', 'Type should be a number');
@@ -52,8 +56,7 @@ suite('Crypto Utils', async () => {
         assert.notEqual(hash1, hash2, 'Hashes should be different strings');
     });
     test('If hashFormat equals `number`, ensure numbers are uniformly distributed on scale from 0 to 100', async () => {
-        const words = await fs.readFile(file);
-        const wordList = words.split('\n');
+        const wordList = await getWordList();
         const buckets: number[] = Array(100).fill(0);
         const hashes = Array(10).fill(0);
         for (const w of wordList) {
@@ -72,8 +75,7 @@ suite('Crypto Utils', async () => {
         }
     });
     test('If hashFormat equals `number`, on a scale of 0 to 100, small difference in the input on average produce large differences (about 33) in the output ', async () => {
-        const words = await fs.readFile(file);
-        const wordList = words.split('\n');
+        const wordList = await getWordList();
         const buckets: number[] = Array(100).fill(0);
         let hashes: number[] = [];
         let totalDifference = 0;
diff --git a/src/test/common/platform/filesystem.functional.test.ts b/src/test/common/platform/filesystem.functional.test.ts
index 24419c7369d8..74f3e1f18b7e 100644
--- a/src/test/common/platform/filesystem.functional.test.ts
+++ b/src/test/common/platform/filesystem.functional.test.ts
@@ -24,23 +24,26 @@ const assertArrays = require('chai-arrays');
 use(assertArrays);
 use(chaiAsPromised);
 
-const WINDOWS = /^win/.test(process.platform);
+// Note: all functional tests that trigger the VS Code "fs" API are
+// found in filesystem.test.ts.
 
-const DOES_NOT_EXIST = 'this file does not exist';
+export const WINDOWS = /^win/.test(process.platform);
 
-async function assertDoesNotExist(filename: string) {
+export const DOES_NOT_EXIST = 'this file does not exist';
+
+export async function assertDoesNotExist(filename: string) {
     await expect(
         fsextra.stat(filename)
     ).to.eventually.be.rejected;
 }
 
-async function assertExists(filename: string) {
+export async function assertExists(filename: string) {
     await expect(
         fsextra.stat(filename)
     ).to.not.eventually.be.rejected;
 }
 
-class FSFixture {
+export class FSFixture {
     public tempDir: tmpMod.SynchrounousResult | undefined;
     public sockServer: net.Server | undefined;
 
@@ -196,138 +199,6 @@ suite('Raw FileSystem', () => {
         await fix.cleanUp();
     });
 
-    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 fsextra.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);
-
-            const actual = await fsextra.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);
-
-            const actual = await fsextra.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);
-
-            const actual = await fsextra.readFile(filename)
-                .then(buffer => buffer.toString());
-            expect(actual).to.equal(data);
-        });
-    });
-
-    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('rmtree', () => {
-        test('deletes the directory and everything in it', async () => {
-            const dirname = await fix.createDirectory('x');
-            const filename = await fix.createFile('x/y/z/spam.py');
-            await assertExists(filename);
-
-            await filesystem.rmtree(dirname);
-
-            await assertDoesNotExist(dirname);
-        });
-
-        test('fails if the directory does not exist', async () => {
-            const promise = filesystem.rmtree(DOES_NOT_EXIST);
-
-            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('chmod (non-Windows)', () => {
         suiteSetup(function () {
             // On Windows, chmod won't have any effect on the file itself.
@@ -336,7 +207,6 @@ suite('Raw FileSystem', () => {
                 this.skip();
             }
         });
-
         async function checkMode(filename: string, expected: number) {
             const stat = await fsextra.stat(filename);
             expect(stat.mode & 0o777).to.equal(expected);
@@ -385,47 +255,17 @@ suite('Raw FileSystem', () => {
         });
     });
 
-    suite('stat', () => {
-        test('gets the info for an existing file', async () => {
-            const filename = await fix.createFile('x/y/z/spam.py', '...');
-            const expected = await fsextra.stat(filename);
-
-            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 expected = await fsextra.stat(dirname);
-
-            const stat = await filesystem.stat(dirname);
-
-            expect(stat).to.deep.equal(expected);
-        });
-
-        test('for symlinks, gets the info for the linked file', async () => {
-            const filename = await fix.createFile('x/y/z/spam.py', '...');
-            const symlink = await fix.createSymlink('x/y/z/eggs.py', filename);
-            const expected = await fsextra.stat(filename);
-
-            const stat = await filesystem.stat(symlink);
-
-            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('lstat', () => {
         test('for symlinks, gives the link info', async () => {
             const filename = await fix.createFile('x/y/z/spam.py', '...');
             const symlink = await fix.createSymlink('x/y/z/eggs.py', filename);
-            const expected = await fsextra.lstat(symlink);
+            const old = await fsextra.lstat(symlink);
+            const expected = {
+                type: FileType.SymbolicLink,
+                size: old.size,
+                ctime: old.ctimeMs,
+                mtime: old.mtimeMs
+            };
 
             const stat = await filesystem.lstat(symlink);
 
@@ -434,7 +274,13 @@ suite('Raw FileSystem', () => {
 
         test('for normal files, gives the file info', async () => {
             const filename = await fix.createFile('x/y/z/spam.py', '...');
-            const expected = await fsextra.stat(filename);
+            const old = await fsextra.stat(filename);
+            const expected = {
+                type: FileType.File,
+                size: old.size,
+                ctime: old.ctimeMs,
+                mtime: old.mtimeMs
+            };
 
             const stat = await filesystem.lstat(filename);
 
@@ -448,120 +294,16 @@ suite('Raw FileSystem', () => {
         });
     });
 
-    suite('listdir', () => {
-        test('mixed', async () => {
-            // Create the target directory and its contents.
-            const dirname = await fix.createDirectory('x/y/z');
-            await fix.createFile('x/y/z/__init__.py', '');
-            const script = await fix.createFile('x/y/z/__main__.py', '<script here>');
-            await fix.createFile('x/y/z/spam.py', '...');
-            await fix.createSocket('x/y/z/ipc.sock');
-            await fix.createFile('x/y/z/eggs.py', '"""..."""');
-            await fix.createSymlink(
-                'x/y/z/info.py',
-                // Link to an ignored file.
-                await fix.createFile('x/_info.py', '<info here>') // source
-            );
-            await fix.createDirectory('x/y/z/w');
-            // 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([
-                ['__init__.py', FileType.File],
-                ['__main__.py', FileType.File],
-                ['eggs.py', FileType.File],
-                ['info.py', FileType.SymbolicLink],
-                ['ipc.sock', FileType.Unknown],
-                ['spam.py', FileType.File],
-                ['w', 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('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);
-
-            const actual = await fsextra.readFile(dest)
-                .then(buffer => buffer.toString());
-            expect(actual).to.equal(data);
-            const original = await fsextra.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);
-
-            const actual = await fsextra.readFile(dest)
-                .then(buffer => buffer.toString());
-            expect(actual).to.equal(data);
-            const original = await fsextra.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('statSync', () => {
         test('gets the info for an existing file', async () => {
             const filename = await fix.createFile('x/y/z/spam.py', '...');
-            const expected = await fsextra.stat(filename);
+            const old = await fsextra.stat(filename);
+            const expected = {
+                type: FileType.File,
+                size: old.size,
+                ctime: old.ctimeMs,
+                mtime: old.mtimeMs
+            };
 
             const stat = filesystem.statSync(filename);
 
@@ -570,7 +312,13 @@ suite('Raw FileSystem', () => {
 
         test('gets the info for an existing directory', async () => {
             const dirname = await fix.createDirectory('x/y/z/spam');
-            const expected = await fsextra.stat(dirname);
+            const old = await fsextra.stat(dirname);
+            const expected = {
+                type: FileType.Directory,
+                size: old.size,
+                ctime: old.ctimeMs,
+                mtime: old.mtimeMs
+            };
 
             const stat = filesystem.statSync(dirname);
 
@@ -580,7 +328,13 @@ suite('Raw FileSystem', () => {
         test('for symlinks, gets the info for the linked file', async () => {
             const filename = await fix.createFile('x/y/z/spam.py', '...');
             const symlink = await fix.createSymlink('x/y/z/eggs.py', filename);
-            const expected = await fsextra.stat(filename);
+            const old = await fsextra.stat(filename);
+            const expected = {
+                type: FileType.File,
+                size: old.size,
+                ctime: old.ctimeMs,
+                mtime: old.mtimeMs
+            };
 
             const stat = filesystem.statSync(symlink);
 
@@ -722,190 +476,6 @@ suite('FileSystem Utils', () => {
         });
     });
 
-    suite('pathExists', () => {
-        test('file missing (any)', async () => {
-            const exists = await utils.pathExists(DOES_NOT_EXIST);
-
-            expect(exists).to.equal(false);
-        });
-
-        Object.keys(FileType).forEach(ft => {
-            test(`file missing (${ft})`, async () => {
-                //tslint:disable-next-line:no-any
-                const exists = await utils.pathExists(DOES_NOT_EXIST, ft as any as FileType);
-
-                expect(exists).to.equal(false);
-            });
-        });
-
-        test('any', async () => {
-            const filename = await fix.createFile('x/y/z/spam.py');
-
-            const exists = await utils.pathExists(filename);
-
-            expect(exists).to.equal(true);
-        });
-
-        test('want file, got file', async () => {
-            const filename = await fix.createFile('x/y/z/spam.py');
-
-            const exists = await utils.pathExists(filename, FileType.File);
-
-            expect(exists).to.equal(true);
-        });
-
-        test('want file, not file', async () => {
-            const filename = await fix.createDirectory('x/y/z/spam.py');
-
-            const exists = await utils.pathExists(filename, FileType.File);
-
-            expect(exists).to.equal(false);
-        });
-
-        test('want directory, got directory', async () => {
-            const dirname = await fix.createDirectory('x/y/z/spam');
-
-            const exists = await utils.pathExists(dirname, FileType.Directory);
-
-            expect(exists).to.equal(true);
-        });
-
-        test('want directory, not directory', async () => {
-            const dirname = await fix.createFile('x/y/z/spam');
-
-            const exists = await utils.pathExists(dirname, FileType.Directory);
-
-            expect(exists).to.equal(false);
-        });
-
-        test('symlink', async () => {
-            const filename = await fix.createFile('x/y/z/spam.py', '...');
-            const symlink = await fix.createSymlink('x/y/z/eggs.py', filename);
-
-            const exists = await utils.pathExists(symlink, FileType.SymbolicLink);
-
-            expect(exists).to.equal(false);
-        });
-
-        test('unknown', async () => {
-            const sockFile = await fix.createSocket('x/y/z/ipc.sock');
-
-            const exists = await utils.pathExists(sockFile, FileType.Unknown);
-
-            expect(exists).to.equal(false);
-        });
-    });
-
-    suite('fileExists', () => {
-        test('want file, got file', async () => {
-            const filename = await fix.createFile('x/y/z/spam.py');
-
-            const exists = await utils.fileExists(filename);
-
-            expect(exists).to.equal(true);
-        });
-    });
-
-    suite('directoryExists', () => {
-        test('want directory, got directory', async () => {
-            const dirname = await fix.createDirectory('x/y/z/spam');
-
-            const exists = await utils.directoryExists(dirname);
-
-            expect(exists).to.equal(true);
-        });
-    });
-
-    suite('getSubDirectories', () => {
-        test('mixed types', async () => {
-            const symlinkSource = await fix.createFile('x/info.py');
-            const dirname = await fix.createDirectory('x/y/z/scripts');
-            const subdir1 = await fix.createDirectory('x/y/z/scripts/w');
-            await fix.createFile('x/y/z/scripts/spam.py');
-            const subdir2 = await fix.createDirectory('x/y/z/scripts/v');
-            await fix.createFile('x/y/z/scripts/eggs.py');
-            await fix.createSocket('x/y/z/scripts/spam.sock');
-            await fix.createSymlink('x/y/z/scripts/other', symlinkSource);
-            await fix.createFile('x/y/z/scripts/data.json');
-
-            const results = await utils.getSubDirectories(dirname);
-
-            expect(results.sort()).to.deep.equal([
-                subdir2,
-                subdir1
-            ]);
-        });
-
-        test('empty if the directory does not exist', async () => {
-            const entries = await utils.getSubDirectories(DOES_NOT_EXIST);
-
-            expect(entries).to.deep.equal([]);
-        });
-    });
-
-    suite('getFiles', () => {
-        test('mixed types', async () => {
-            const symlinkSource = await fix.createFile('x/info.py');
-            const dirname = await fix.createDirectory('x/y/z/scripts');
-            await fix.createDirectory('x/y/z/scripts/w');
-            const file1 = await fix.createFile('x/y/z/scripts/spam.py');
-            await fix.createDirectory('x/y/z/scripts/v');
-            const file2 = await fix.createFile('x/y/z/scripts/eggs.py');
-            await fix.createSocket('x/y/z/scripts/spam.sock');
-            await fix.createSymlink('x/y/z/scripts/other', symlinkSource);
-            const file3 = await fix.createFile('x/y/z/scripts/data.json');
-
-            const results = await utils.getFiles(dirname);
-
-            expect(results.sort()).to.deep.equal([
-                file3,
-                file2,
-                file1
-            ]);
-        });
-
-        test('empty if the directory does not exist', async () => {
-            const entries = await utils.getFiles(DOES_NOT_EXIST);
-
-            expect(entries).to.deep.equal([]);
-        });
-    });
-
-    suite('isDirReadonly', () => {
-        suite('non-Windows', () => {
-            suiteSetup(function () {
-                if (WINDOWS) {
-                    // tslint:disable-next-line:no-invalid-this
-                    this.skip();
-                }
-            });
-
-            // On Windows, chmod won't have any effect on the file itself.
-            test('is readonly', async () => {
-                const dirname = await fix.createDirectory('x/y/z/spam');
-                await fsextra.chmod(dirname, 0o444);
-
-                const isReadonly = await utils.isDirReadonly(dirname);
-
-                expect(isReadonly).to.equal(true);
-            });
-        });
-
-        test('is not readonly', async () => {
-            const dirname = await fix.createDirectory('x/y/z/spam');
-
-            const isReadonly = await utils.isDirReadonly(dirname);
-
-            expect(isReadonly).to.equal(false);
-        });
-
-        test('fails if the file does not exist', async () => {
-            const promise = utils.isDirReadonly(DOES_NOT_EXIST);
-
-            await expect(promise).to.eventually.be.rejected;
-        });
-    });
-
     suite('getFileHash', () => {
         test('Getting hash for a file should return non-empty string', async () => {
             const filename = await fix.createFile('x/y/z/spam.py');
@@ -1004,24 +574,6 @@ suite('FileSystem - legacy aliases', () => {
         }
     }
 
-    test('ReadFile returns contents of a file', async () => {
-        const file = __filename;
-        const filesystem = new FileSystem();
-        const expectedContents = await fsextra.readFile(file).then(buffer => buffer.toString());
-
-        const content = await filesystem.readFile(file);
-
-        expect(content).to.be.equal(expectedContents);
-    });
-
-    test('ReadFile throws an exception if file does not exist', async () => {
-        const filesystem = new FileSystem();
-
-        const readPromise = filesystem.readFile('xyz');
-
-        await expect(readPromise).to.be.rejectedWith();
-    });
-
     suite('Case sensitivity', () => {
         const path1 = 'c:\\users\\Peter Smith\\my documents\\test.txt';
         const path2 = 'c:\\USERS\\Peter Smith\\my documents\\test.TXT';
diff --git a/src/test/common/platform/filesystem.test.ts b/src/test/common/platform/filesystem.test.ts
new file mode 100644
index 000000000000..937b46ef515e
--- /dev/null
+++ b/src/test/common/platform/filesystem.test.ts
@@ -0,0 +1,560 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { expect } from 'chai';
+import * as fsextra from 'fs-extra';
+import * as path from 'path';
+import {
+    FileSystem, FileSystemUtils, RawFileSystem
+} from '../../../client/common/platform/fileSystem';
+import {
+    FileStat, FileType,
+    IFileSystemUtils, IRawFileSystem
+} from '../../../client/common/platform/types';
+import {
+    assertDoesNotExist, assertExists, DOES_NOT_EXIST, FSFixture, WINDOWS
+} from './filesystem.functional.test';
+
+// Note: all functional tests that do not trigger the VS Code "fs" API
+// are found in filesystem.functional.test.ts.
+
+// tslint:disable:max-func-body-length chai-vague-errors
+// tslint:disable:no-suspicious-comment
+
+suite('Raw FileSystem', () => {
+    let filesystem: IRawFileSystem;
+    let fix: FSFixture;
+    setup(async () => {
+        filesystem = RawFileSystem.withDefaults();
+        fix = new FSFixture();
+
+        await assertDoesNotExist(DOES_NOT_EXIST);
+    });
+    teardown(async () => {
+        await fix.cleanUp();
+    });
+
+    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 fsextra.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);
+
+            const actual = await fsextra.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);
+
+            const actual = await fsextra.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);
+
+            const actual = await fsextra.readFile(filename)
+                .then(buffer => buffer.toString());
+            expect(actual).to.equal(data);
+        });
+    });
+
+    suite('rmtree', () => {
+        test('deletes the directory and everything in it', async () => {
+            const dirname = await fix.createDirectory('x');
+            const filename = await fix.createFile('x/y/z/spam.py');
+            await assertExists(filename);
+
+            await filesystem.rmtree(dirname);
+
+            await assertDoesNotExist(dirname);
+        });
+
+        test('fails if the directory does not exist', async () => {
+            const promise = filesystem.rmtree(DOES_NOT_EXIST);
+
+            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('stat', () => {
+        function convertStat(old: fsextra.Stats, filetype: FileType): FileStat {
+            return {
+                type: filetype,
+                size: old.size,
+                // TODO (https://github.com/microsoft/vscode/issues/84177)
+                //   FileStat.ctime and FileStat.mtime only have 1-second resolution.
+                //   So for now we round to the nearest integer.
+                // TODO (https://github.com/microsoft/vscode/issues/84177)
+                //   FileStat.ctime is consistently 0 instead of the actual ctime.
+                ctime: 0,
+                //ctime: Math.round(old.ctimeMs),
+                mtime: Math.round(old.mtimeMs)
+            };
+        }
+
+        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 () => {
+            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('fails if the file does not exist', async () => {
+            const promise = filesystem.stat(DOES_NOT_EXIST);
+
+            await expect(promise).to.eventually.be.rejected;
+        });
+    });
+
+    suite('listdir', () => {
+        test('mixed', async () => {
+            // Create the target directory and its contents.
+            const dirname = await fix.createDirectory('x/y/z');
+            await fix.createFile('x/y/z/__init__.py', '');
+            const script = await fix.createFile('x/y/z/__main__.py', '<script here>');
+            await fix.createFile('x/y/z/spam.py', '...');
+            await fix.createSocket('x/y/z/ipc.sock');
+            await fix.createFile('x/y/z/eggs.py', '"""..."""');
+            await fix.createSymlink(
+                'x/y/z/info.py',
+                // Link to an ignored file.
+                await fix.createFile('x/_info.py', '<info here>') // source
+            );
+            await fix.createDirectory('x/y/z/w');
+            // 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([
+                ['__init__.py', FileType.File],
+                ['__main__.py', FileType.File],
+                ['eggs.py', FileType.File],
+                ['info.py', FileType.SymbolicLink | FileType.File],
+                ['ipc.sock', FileType.File], // This isn't "Unknown" for some reason.
+                ['spam.py', FileType.File],
+                ['w', 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('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('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);
+
+            const actual = await fsextra.readFile(dest)
+                .then(buffer => buffer.toString());
+            expect(actual).to.equal(data);
+            const original = await fsextra.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);
+
+            const actual = await fsextra.readFile(dest)
+                .then(buffer => buffer.toString());
+            expect(actual).to.equal(data);
+            const original = await fsextra.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('FileSystem Utils', () => {
+    let utils: IFileSystemUtils;
+    let fix: FSFixture;
+    setup(() => {
+        utils = FileSystemUtils.withDefaults();
+        fix = new FSFixture();
+    });
+    teardown(async () => {
+        await fix.cleanUp();
+    });
+
+    suite('pathExists', () => {
+        test('file missing (any)', async () => {
+            const exists = await utils.pathExists(DOES_NOT_EXIST);
+
+            expect(exists).to.equal(false);
+        });
+
+        Object.keys(FileType).forEach(ft => {
+            test(`file missing (${ft})`, async () => {
+                //tslint:disable-next-line:no-any
+                const exists = await utils.pathExists(DOES_NOT_EXIST, ft as any as FileType);
+
+                expect(exists).to.equal(false);
+            });
+        });
+
+        test('any', async () => {
+            const filename = await fix.createFile('x/y/z/spam.py');
+
+            const exists = await utils.pathExists(filename);
+
+            expect(exists).to.equal(true);
+        });
+
+        test('want file, got file', async () => {
+            const filename = await fix.createFile('x/y/z/spam.py');
+
+            const exists = await utils.pathExists(filename, FileType.File);
+
+            expect(exists).to.equal(true);
+        });
+
+        test('want file, not file', async () => {
+            const filename = await fix.createDirectory('x/y/z/spam.py');
+
+            const exists = await utils.pathExists(filename, FileType.File);
+
+            expect(exists).to.equal(false);
+        });
+
+        test('want directory, got directory', async () => {
+            const dirname = await fix.createDirectory('x/y/z/spam');
+
+            const exists = await utils.pathExists(dirname, FileType.Directory);
+
+            expect(exists).to.equal(true);
+        });
+
+        test('want directory, not directory', async () => {
+            const dirname = await fix.createFile('x/y/z/spam');
+
+            const exists = await utils.pathExists(dirname, FileType.Directory);
+
+            expect(exists).to.equal(false);
+        });
+
+        test('symlink', async () => {
+            const filename = await fix.createFile('x/y/z/spam.py', '...');
+            const symlink = await fix.createSymlink('x/y/z/eggs.py', filename);
+
+            const exists = await utils.pathExists(symlink, FileType.SymbolicLink);
+
+            expect(exists).to.equal(false);
+        });
+
+        test('unknown', async () => {
+            const sockFile = await fix.createSocket('x/y/z/ipc.sock');
+
+            const exists = await utils.pathExists(sockFile, FileType.Unknown);
+
+            expect(exists).to.equal(false);
+        });
+    });
+
+    suite('fileExists', () => {
+        test('want file, got file', async () => {
+            const filename = await fix.createFile('x/y/z/spam.py');
+
+            const exists = await utils.fileExists(filename);
+
+            expect(exists).to.equal(true);
+        });
+    });
+
+    suite('directoryExists', () => {
+        test('want directory, got directory', async () => {
+            const dirname = await fix.createDirectory('x/y/z/spam');
+
+            const exists = await utils.directoryExists(dirname);
+
+            expect(exists).to.equal(true);
+        });
+    });
+
+    suite('getSubDirectories', () => {
+        test('mixed types', async () => {
+            const symlinkSource = await fix.createFile('x/info.py');
+            const dirname = await fix.createDirectory('x/y/z/scripts');
+            const subdir1 = await fix.createDirectory('x/y/z/scripts/w');
+            await fix.createFile('x/y/z/scripts/spam.py');
+            const subdir2 = await fix.createDirectory('x/y/z/scripts/v');
+            await fix.createFile('x/y/z/scripts/eggs.py');
+            await fix.createSocket('x/y/z/scripts/spam.sock');
+            await fix.createSymlink('x/y/z/scripts/other', symlinkSource);
+            await fix.createFile('x/y/z/scripts/data.json');
+
+            const results = await utils.getSubDirectories(dirname);
+
+            expect(results.sort()).to.deep.equal([
+                subdir2,
+                subdir1
+            ]);
+        });
+
+        test('empty if the directory does not exist', async () => {
+            const entries = await utils.getSubDirectories(DOES_NOT_EXIST);
+
+            expect(entries).to.deep.equal([]);
+        });
+    });
+
+    suite('getFiles', () => {
+        test('mixed types', async () => {
+            const symlinkSource = await fix.createFile('x/info.py');
+            const dirname = await fix.createDirectory('x/y/z/scripts');
+            await fix.createDirectory('x/y/z/scripts/w');
+            const file1 = await fix.createFile('x/y/z/scripts/spam.py');
+            await fix.createDirectory('x/y/z/scripts/v');
+            const file2 = await fix.createFile('x/y/z/scripts/eggs.py');
+            const file3 = await fix.createSocket('x/y/z/scripts/spam.sock');
+            await fix.createSymlink('x/y/z/scripts/other', symlinkSource);
+            const file4 = await fix.createFile('x/y/z/scripts/data.json');
+
+            const results = await utils.getFiles(dirname);
+
+            expect(results.sort()).to.deep.equal([
+                file4,
+                file2,
+                file1,
+                file3
+            ]);
+        });
+
+        test('empty if the directory does not exist', async () => {
+            const entries = await utils.getFiles(DOES_NOT_EXIST);
+
+            expect(entries).to.deep.equal([]);
+        });
+    });
+
+    suite('isDirReadonly', () => {
+        suite('non-Windows', () => {
+            suiteSetup(function () {
+                if (WINDOWS) {
+                    // tslint:disable-next-line:no-invalid-this
+                    this.skip();
+                }
+            });
+
+            // On Windows, chmod won't have any effect on the file itself.
+            test('is readonly', async () => {
+                const dirname = await fix.createDirectory('x/y/z/spam');
+                await fsextra.chmod(dirname, 0o444);
+
+                const isReadonly = await utils.isDirReadonly(dirname);
+
+                expect(isReadonly).to.equal(true);
+            });
+        });
+
+        test('is not readonly', async () => {
+            const dirname = await fix.createDirectory('x/y/z/spam');
+
+            const isReadonly = await utils.isDirReadonly(dirname);
+
+            expect(isReadonly).to.equal(false);
+        });
+
+        test('fails if the file does not exist', async () => {
+            const promise = utils.isDirReadonly(DOES_NOT_EXIST);
+
+            await expect(promise).to.eventually.be.rejected;
+        });
+    });
+});
+
+suite('FileSystem - legacy aliases', () => {
+    const fileToAppendTo = path.join(__dirname, 'created_for_testing_dummy.txt');
+    setup(() => {
+        cleanTestFiles(); // This smells like functional testing...
+    });
+    teardown(cleanTestFiles);
+    function cleanTestFiles() {
+        if (fsextra.existsSync(fileToAppendTo)) {
+            fsextra.unlinkSync(fileToAppendTo);
+        }
+    }
+
+    test('ReadFile returns contents of a file', async () => {
+        const file = __filename;
+        const filesystem = new FileSystem();
+        const expectedContents = await fsextra.readFile(file).then(buffer => buffer.toString());
+
+        const content = await filesystem.readFile(file);
+
+        expect(content).to.be.equal(expectedContents);
+    });
+
+    test('ReadFile throws an exception if file does not exist', async () => {
+        const filesystem = new FileSystem();
+
+        const readPromise = filesystem.readFile('xyz');
+
+        await expect(readPromise).to.be.rejectedWith();
+    });
+});
diff --git a/src/test/common/platform/filesystem.unit.test.ts b/src/test/common/platform/filesystem.unit.test.ts
index ac5d7c096109..bedecb2d74c3 100644
--- a/src/test/common/platform/filesystem.unit.test.ts
+++ b/src/test/common/platform/filesystem.unit.test.ts
@@ -2,9 +2,10 @@
 // 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 { Disposable } from 'vscode';
+import { Disposable, FileSystemError, Uri } from 'vscode';
 import {
     FileSystemPaths, FileSystemUtils, RawFileSystem, TempFileSystem
 } from '../../../client/common/platform/fileSystem';
@@ -16,28 +17,50 @@ import {
 
 // tslint:disable:max-func-body-length chai-vague-errors
 
+function createMockStat(): TypeMoq.IMock<FileStat> {
+    const stat = TypeMoq.Mock.ofType<FileStat>(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));
+    return stat;
+}
+
+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));
+    return stat;
+}
+
 //tslint:disable-next-line:no-any
 type TempCallback = (err: any, path: string, fd: number, cleanupCallback: () => void) => void;
 interface IRawFS {
+    // VS Code
+    copy(source: Uri, target: Uri, options?: {overwrite: boolean}): Thenable<void>;
+    createDirectory(uri: Uri): Thenable<void>;
+    delete(uri: Uri, options?: {recursive: boolean; useTrash: boolean}): Thenable<void>;
+    readDirectory(uri: Uri): Thenable<[string, FileType][]>;
+    readFile(uri: Uri): Thenable<Uint8Array>;
+    stat(uri: Uri): Thenable<FileStat>;
+    writeFile(uri: Uri, content: Uint8Array): Thenable<void>;
+
     // "fs-extra"
     chmod(filePath: string, mode: string): Promise<void>;
-    readFile(path: string, encoding: string): Promise<string>;
-    //tslint:disable-next-line:no-any
-    writeFile(path: string, data: any, options: any): Promise<void>;
-    unlink(filename: string): Promise<void>;
-    stat(filename: string): Promise<fsextra.Stats>;
     lstat(filename: string): Promise<fsextra.Stats>;
-    mkdirp(dirname: string): Promise<void>;
-    rmdir(dirname: string): Promise<void>;
-    readdir(dirname: string): Promise<string[]>;
-    remove(dirname: string): Promise<void>;
     statSync(filename: string): fsextra.Stats;
     readFileSync(path: string, encoding: string): string;
-    createReadStream(src: string): fsextra.ReadStream;
-    createWriteStream(dest: string): fsextra.WriteStream;
+    createWriteStream(dest: string): fs.WriteStream;
 
     // fs paths (IFileSystemPaths)
     join(...filenames: string[]): string;
+    dirname(filename: string): string;
     normalize(filename: string): string;
 
     // "tmp"
@@ -91,10 +114,10 @@ suite('FileSystem - Temporary files', () => {
 
 suite('FileSystem paths', () => {
     let raw: TypeMoq.IMock<IRawFS>;
-    let path: IFileSystemPaths;
+    let paths: IFileSystemPaths;
     setup(() => {
         raw = TypeMoq.Mock.ofType<IRawFS>(undefined, TypeMoq.MockBehavior.Strict);
-        path = new FileSystemPaths(
+        paths = new FileSystemPaths(
             false, // isWindows
             raw.object
         );
@@ -109,7 +132,20 @@ suite('FileSystem paths', () => {
             raw.setup(r => r.join('x', 'y/z', 'spam.py'))
                 .returns(() => expected);
 
-            const result = path.join('x', 'y/z', 'spam.py');
+            const result = paths.join('x', 'y/z', 'spam.py');
+
+            expect(result).to.equal(expected);
+        });
+    });
+
+    suite('dirname', () => {
+        test('wraps low-level function', () => {
+            const filename = 'x/y/z/spam.py';
+            const expected = 'x/y/z';
+            raw.setup(r => r.dirname(filename))
+                .returns(() => expected);
+
+            const result = paths.dirname(filename);
 
             expect(result).to.equal(expected);
         });
@@ -120,12 +156,12 @@ suite('FileSystem paths', () => {
             const filename = 'x/y/z/spam.py';
             raw.setup(r => r.normalize(filename))
                 .returns(() => filename);
-            path = new FileSystemPaths(
+            paths = new FileSystemPaths(
                 false, // isWindows
                 raw.object
             );
 
-            const result = path.normCase(filename);
+            const result = paths.normCase(filename);
 
             expect(result).to.equal(filename);
             verifyAll();
@@ -136,12 +172,12 @@ suite('FileSystem paths', () => {
             const expected = 'X\\Y\\Z\\SPAM.PY';
             raw.setup(r => r.normalize(filename))
                 .returns(() => expected);
-            path = new FileSystemPaths(
+            paths = new FileSystemPaths(
                 true, // isWindows
                 raw.object
             );
 
-            const result = path.normCase(filename);
+            const result = paths.normCase(filename);
 
             expect(result).to.equal(expected);
             verifyAll();
@@ -152,12 +188,12 @@ suite('FileSystem paths', () => {
             const expected = filename;
             raw.setup(r => r.normalize(filename))
                 .returns(() => expected);
-            path = new FileSystemPaths(
+            paths = new FileSystemPaths(
                 false, // isWindows
                 raw.object
             );
 
-            const result = path.normCase(filename);
+            const result = paths.normCase(filename);
 
             expect(result).to.equal(expected);
             verifyAll();
@@ -168,12 +204,12 @@ suite('FileSystem paths', () => {
             const expected = 'X\\Y\\Z\\SPAM.PY';
             raw.setup(r => r.normalize(filename))
                 .returns(() => filename);
-            path = new FileSystemPaths(
+            paths = new FileSystemPaths(
                 true, // isWindows
                 raw.object
             );
 
-            const result = path.normCase(filename);
+            const result = paths.normCase(filename);
 
             expect(result).to.equal(expected);
             verifyAll();
@@ -184,12 +220,12 @@ suite('FileSystem paths', () => {
             const expected = 'X\\Y\\Z\\SPAM.PY';
             raw.setup(r => r.normalize(filename))
                 .returns(() => expected);
-            path = new FileSystemPaths(
+            paths = new FileSystemPaths(
                 true, // isWindows
                 raw.object
             );
 
-            const result = path.normCase(filename);
+            const result = paths.normCase(filename);
 
             expect(result).to.equal(expected);
             verifyAll();
@@ -200,12 +236,12 @@ suite('FileSystem paths', () => {
             const expected = 'x/y/z/spam.py';
             raw.setup(r => r.normalize(filename))
                 .returns(() => filename);
-            path = new FileSystemPaths(
+            paths = new FileSystemPaths(
                 false, // isWindows
                 raw.object
             );
 
-            const result = path.normCase(filename);
+            const result = paths.normCase(filename);
 
             expect(result).to.equal(expected);
             verifyAll();
@@ -216,12 +252,12 @@ suite('FileSystem paths', () => {
             const expected = 'X/Y/Z/SPAM.PY';
             raw.setup(r => r.normalize(filename))
                 .returns(() => expected);
-            path = new FileSystemPaths(
+            paths = new FileSystemPaths(
                 false, // isWindows
                 raw.object
             );
 
-            const result = path.normCase(filename);
+            const result = paths.normCase(filename);
 
             expect(result).to.equal(expected);
             verifyAll();
@@ -231,9 +267,11 @@ suite('FileSystem paths', () => {
 
 suite('Raw FileSystem', () => {
     let raw: TypeMoq.IMock<IRawFS>;
+    let oldStat: TypeMoq.IMock<fsextra.Stats>;
     let filesystem: IRawFileSystem;
     setup(() => {
         raw = TypeMoq.Mock.ofType<IRawFS>(undefined, TypeMoq.MockBehavior.Strict);
+        oldStat = createMockLegacyStat();
         filesystem = new RawFileSystem(
             raw.object,
             raw.object,
@@ -242,14 +280,56 @@ suite('Raw FileSystem', () => {
     });
     function verifyAll() {
         raw.verifyAll();
+        oldStat.verifyAll();
+    }
+
+    function setupOldStat(stat: FileStat, old?: TypeMoq.IMock<fsextra.Stats> | null) {
+        if (old === undefined) {
+            old = oldStat;
+        } else if (old === null) {
+            old = createMockLegacyStat();
+        }
+
+        if (stat.type === FileType.File) {
+            old!.setup(s => s.isFile())
+                .returns(() => true);
+        } else if (stat.type === FileType.Directory) {
+            old!.setup(s => s.isFile())
+                .returns(() => false);
+            old!.setup(s => s.isDirectory())
+                .returns(() => true);
+        } else if (stat.type === FileType.SymbolicLink) {
+            old!.setup(s => s.isFile())
+                .returns(() => false);
+            old!.setup(s => s.isDirectory())
+                .returns(() => false);
+            old!.setup(s => s.isSymbolicLink())
+                .returns(() => true);
+        } else {
+            old!.setup(s => s.isFile())
+                .returns(() => false);
+            old!.setup(s => s.isDirectory())
+                .returns(() => false);
+            old!.setup(s => s.isSymbolicLink())
+                .returns(() => false);
+        }
+        old!.setup(s => s.size)
+            .returns(() => stat.size);
+        old!.setup(s => s.ctimeMs)
+            .returns(() => stat.ctime);
+        old!.setup(s => s.mtimeMs)
+            .returns(() => stat.mtime);
+
+        return old!;
     }
 
     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, TypeMoq.It.isAny()))
-                .returns(() => Promise.resolve(expected));
+            const data = Buffer.from(expected);
+            raw.setup(r => r.readFile(Uri.file(filename)))
+                .returns(() => Promise.resolve(data));
 
             const text = await filesystem.readText(filename);
 
@@ -259,9 +339,10 @@ suite('Raw FileSystem', () => {
 
         test('always UTF-8', async () => {
             const filename = 'x/y/z/spam.py';
-            const expected = '<text>';
-            raw.setup(r => r.readFile(filename, 'utf8'))
-                .returns(() => Promise.resolve(expected));
+            const expected = '... 😁 ...';
+            const data = Buffer.from(expected);
+            raw.setup(r => r.readFile(Uri.file(filename)))
+                .returns(() => Promise.resolve(data));
 
             const text = await filesystem.readText(filename);
 
@@ -273,11 +354,24 @@ suite('Raw FileSystem', () => {
     suite('writeText', () => {
         test('wraps the low-level function', async () => {
             const filename = 'x/y/z/spam.py';
-            const data = '<data>';
-            raw.setup(r => r.writeFile(filename, data, { encoding: 'utf8' }))
+            const text = '<data>';
+            const data = Buffer.from(text);
+            raw.setup(r => r.writeFile(Uri.file(filename), data))
                 .returns(() => Promise.resolve());
 
-            await filesystem.writeText(filename, data);
+            await filesystem.writeText(filename, text);
+
+            verifyAll();
+        });
+
+        test('always UTF-8', async () => {
+            const filename = 'x/y/z/spam.py';
+            const text = '... 😁 ...';
+            const data = Buffer.from(text);
+            raw.setup(r => r.writeFile(Uri.file(filename), data))
+                .returns(() => Promise.resolve());
+
+            await filesystem.writeText(filename, text);
 
             verifyAll();
         });
@@ -286,8 +380,34 @@ suite('Raw FileSystem', () => {
     suite('mkdirp', () => {
         test('wraps the low-level function', async () => {
             const dirname = 'x/y/z/spam';
-            raw.setup(r => r.mkdirp(dirname))
+            raw.setup(r => r.createDirectory(Uri.file(dirname)))
+                .returns(() => Promise.resolve());
+
+            await filesystem.mkdirp(dirname);
+
+            verifyAll();
+        });
+
+        test('creates missing parent directories', async () => {
+            const dirname = 'x/y/z/spam';
+            raw.setup(r => r.createDirectory(Uri.file(dirname)))
+                .throws(FileSystemError.FileNotFound(dirname))
+                .verifiable(TypeMoq.Times.exactly(2));
+            raw.setup(r => r.dirname(dirname))
+                .returns(() => 'x/y/z');
+            raw.setup(r => r.createDirectory(Uri.file('x/y/z')))
+                .throws(FileSystemError.FileNotFound('x/y/z'))
+                .verifiable(TypeMoq.Times.exactly(2));
+            raw.setup(r => r.dirname('x/y/z'))
+                .returns(() => 'x/y');
+            raw.setup(r => r.createDirectory(Uri.file('x/y')))
                 .returns(() => Promise.resolve());
+            raw.setup(r => r.createDirectory(Uri.file('x/y/z')))
+                .returns(() => Promise.resolve())
+                .verifiable(TypeMoq.Times.exactly(2));
+            raw.setup(r => r.createDirectory(Uri.file(dirname)))
+                .returns(() => Promise.resolve())
+                .verifiable(TypeMoq.Times.exactly(2));
 
             await filesystem.mkdirp(dirname);
 
@@ -298,32 +418,35 @@ suite('Raw FileSystem', () => {
     suite('rmtree', () => {
         test('wraps the low-level function', async () => {
             const dirname = 'x/y/z/spam';
-            raw.setup(r => r.stat(dirname))
-                //tslint:disable-next-line:no-any
-                .returns(() => Promise.resolve({} as any as FileStat));
-            raw.setup(r => r.remove(dirname))
+            const uri = Uri.file(dirname);
+            const stat = createMockStat();
+            raw.setup(r => r.stat(uri))
+                .returns(() => Promise.resolve(stat.object));
+            raw.setup(r => r.delete(uri, { recursive: true, useTrash: false }))
                 .returns(() => Promise.resolve());
 
             await filesystem.rmtree(dirname);
 
             verifyAll();
+            stat.verifyAll();
         });
 
         test('fails if the directory does not exist', async () => {
             const dirname = 'x/y/z/spam';
-            raw.setup(r => r.stat(dirname))
+            raw.setup(r => r.stat(Uri.file(dirname)))
                 .throws(new Error('file not found'));
 
             const promise = filesystem.rmtree(dirname);
 
             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))
+            raw.setup(r => r.delete(Uri.file(filename), { recursive: false, useTrash: false }))
                 .returns(() => Promise.resolve());
 
             await filesystem.rmfile(filename);
@@ -349,8 +472,8 @@ suite('Raw FileSystem', () => {
         test('wraps the low-level function', async () => {
             const filename = 'x/y/z/spam.py';
             //tslint:disable-next-line:no-any
-            const expected: FileStat = {} as any;
-            raw.setup(r => r.stat(filename))
+            const expected: FileStat = { type: FileType.File } as any;
+            raw.setup(r => r.stat(Uri.file(filename)))
                 .returns(() => Promise.resolve(expected));
 
             const stat = await filesystem.stat(filename);
@@ -363,97 +486,57 @@ suite('Raw FileSystem', () => {
     suite('lstat', () => {
         test('wraps the low-level function', async () => {
             const filename = 'x/y/z/spam.py';
+            const expected: FileStat = {
+                type: FileType.File,
+                size: 10,
+                ctime: 101,
+                mtime: 102
             //tslint:disable-next-line:no-any
-            const expected: FileStat = {} as any;
+            } as any;
+            setupOldStat(expected);
             raw.setup(r => r.lstat(filename))
-                .returns(() => Promise.resolve(expected));
+                .returns(() => Promise.resolve(oldStat.object));
 
             const stat = await filesystem.lstat(filename);
 
-            expect(stat).to.equal(expected);
+            expect(stat).to.deep.equal(expected);
             verifyAll();
         });
     });
 
     suite('listdir', () => {
-        function setupStat(filename: string, ft: FileType) {
-            const stat = TypeMoq.Mock.ofType<FileStat>(undefined, TypeMoq.MockBehavior.Strict);
-            if (ft === FileType.File) {
-                stat.setup(s => s.isFile())
-                    .returns(() => true);
-            } else if (ft === FileType.Directory) {
-                stat.setup(s => s.isFile())
-                    .returns(() => false);
-                stat.setup(s => s.isDirectory())
-                    .returns(() => true);
-            } else if (ft === FileType.SymbolicLink) {
-                stat.setup(s => s.isFile())
-                    .returns(() => false);
-                stat.setup(s => s.isDirectory())
-                    .returns(() => false);
-                stat.setup(s => s.isSymbolicLink())
-                    .returns(() => true);
-            } else {
-                stat.setup(s => s.isFile())
-                    .returns(() => false);
-                stat.setup(s => s.isDirectory())
-                    .returns(() => false);
-                stat.setup(s => s.isSymbolicLink())
-                    .returns(() => false);
-            }
-            // This is necessary because passing "stat.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));
-            raw.setup(r => r.lstat(filename))
-                .returns(() => Promise.resolve(stat.object));
-            return stat;
-        }
-
         test('mixed', async () => {
             const dirname = 'x/y/z/spam';
             const expected: [string, FileType][] = [
                 ['dev1', FileType.Unknown],
                 ['w', FileType.Directory],
                 ['spam.py', FileType.File],
-                ['other', FileType.SymbolicLink]
+                ['other', FileType.SymbolicLink | FileType.File]
             ];
-            const names = expected.map(([name, _ft]) => name);
-            raw.setup(r => r.readdir(dirname))
-                .returns(() => Promise.resolve(names));
-            const stats: TypeMoq.IMock<FileStat>[] = [];
-            expected.forEach(([name, ft]) => {
-                const filename = `${dirname}/${name}`;
-                raw.setup(r => r.join(dirname, name))
-                    .returns(() => filename);
-                stats.push(
-                    setupStat(filename, ft));
-            });
+            raw.setup(r => r.readDirectory(Uri.file(dirname)))
+                .returns(() => Promise.resolve(expected));
 
             const entries = await filesystem.listdir(dirname);
 
             expect(entries).to.deep.equal(expected);
             verifyAll();
-            stats.forEach(stat => stat.verifyAll());
         });
 
         test('empty', async () => {
             const dirname = 'x/y/z/spam';
-            const names: string[] = [];
-            raw.setup(r => r.readdir(dirname))
-                .returns(() => Promise.resolve(names));
+            const expected: [string, FileType][] = [];
+            raw.setup(r => r.readDirectory(Uri.file(dirname)))
+                .returns(() => Promise.resolve(expected));
 
             const entries = await filesystem.listdir(dirname);
 
-            expect(entries).to.deep.equal([]);
+            expect(entries).to.deep.equal(expected);
             verifyAll();
         });
 
         test('fails if the low-level call fails', async () => {
             const dirname = 'x/y/z/spam';
-            raw.setup(r => r.readdir(dirname))
+            raw.setup(r => r.readDirectory(Uri.file(dirname)))
                 .throws(new Error('file not found'));
 
             const promise = filesystem.listdir(dirname);
@@ -464,48 +547,34 @@ suite('Raw FileSystem', () => {
     });
 
     suite('copyFile', () => {
-        let rs: TypeMoq.IMock<fsextra.ReadStream>;
-        let ws: TypeMoq.IMock<fsextra.WriteStream>;
-        let done: () => void;
-        let finished: boolean;
-        setup(() => {
-            rs = TypeMoq.Mock.ofType<fsextra.ReadStream>(undefined, TypeMoq.MockBehavior.Strict);
-            ws = TypeMoq.Mock.ofType<fsextra.WriteStream>(undefined, TypeMoq.MockBehavior.Strict);
-
-            rs.setup(s => s.on('error', TypeMoq.It.isAny()))
-                .returns(() => rs.object);
-            finished = false;
-            done = () => {
-                throw Error();
-            };
-            rs.setup(s => s.pipe(TypeMoq.It.isAny()))
-                .callback(_r => {
-                    done();
-                    finished = true;
-                });
-
-            ws.setup(s => s.on('error', TypeMoq.It.isAny()))
-                .returns(() => ws.object);
-            ws.setup(s => s.on('close', TypeMoq.It.isAny()))
-                .callback((_e, cb) => {
-                    done = cb;
-                })
-                .returns(() => ws.object);
-        });
-
         test('read/write streams are used properly', async () => {
             const src = 'x/y/z/spam.py';
             const dest = 'x/y/z/spam.py.bak';
-            raw.setup(r => r.createReadStream(src))
-                .returns(() => rs.object);
-            raw.setup(r => r.createWriteStream(dest))
-                .returns(() => ws.object);
+            raw.setup(r => r.dirname(dest))
+                .returns(() => 'x/y/z');
+            const stat = createMockStat();
+            raw.setup(r => r.stat(Uri.file('x/y/z')))
+                .returns(() => Promise.resolve(stat.object));
+            raw.setup(r => r.copy(Uri.file(src), Uri.file(dest), { overwrite: true }))
+                .returns(() => Promise.resolve());
 
             await filesystem.copyFile(src, dest);
 
-            expect(finished).to.equal(true);
-            rs.verifyAll();
-            ws.verifyAll();
+            verifyAll();
+            stat.verifyAll();
+        });
+
+        test('fails if the parent directory does not exist', async () => {
+            const src = '/tmp/spam.py';
+            const dest = '/tmp/__does_not_exist__/spam.py';
+            raw.setup(r => r.dirname(dest))
+                .returns(() => '/tmp/__does_not_exist__');
+            raw.setup(r => r.stat(Uri.file('/tmp/__does_not_exist__')))
+                .throws(new Error('file not found'));
+
+            const promise = filesystem.copyFile(src, dest);
+
+            await expect(promise).to.eventually.be.rejected;
             verifyAll();
         });
     });
@@ -513,14 +582,20 @@ suite('Raw FileSystem', () => {
     suite('statSync', () => {
         test('wraps the low-level function', () => {
             const filename = 'x/y/z/spam.py';
+            const expected: FileStat = {
+                type: FileType.File,
+                size: 10,
+                ctime: 101,
+                mtime: 102
             //tslint:disable-next-line:no-any
-            const expected: FileStat = {} as any;
+            } as any;
+            setupOldStat(expected);
             raw.setup(r => r.statSync(filename))
-                .returns(() => expected);
+                .returns(() => oldStat.object);
 
             const stat = filesystem.statSync(filename);
 
-            expect(stat).to.equal(expected);
+            expect(stat).to.deep.equal(expected);
             verifyAll();
         });
     });
@@ -580,7 +655,7 @@ suite('FileSystem Utils', () => {
     let deps: TypeMoq.IMock<IDeps>;
     let utils: IFileSystemUtils;
     setup(() => {
-        stat = TypeMoq.Mock.ofType<FileStat>(undefined, TypeMoq.MockBehavior.Strict);
+        stat = createMockStat();
         filesystem = TypeMoq.Mock.ofType<IRawFileSystem>(undefined, TypeMoq.MockBehavior.Strict);
         path = TypeMoq.Mock.ofType<IFileSystemPaths>(undefined, TypeMoq.MockBehavior.Strict);
         tmp = TypeMoq.Mock.ofType<ITempFileSystem>(undefined, TypeMoq.MockBehavior.Strict);
@@ -592,13 +667,6 @@ suite('FileSystem Utils', () => {
             ((data: string) => deps.object.getHashString(data)),
             ((p: string) => deps.object.glob(p))
         );
-
-        // This is necessary because passing "stat.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));
     });
     function verifyAll() {
         filesystem.verifyAll();
@@ -714,8 +782,8 @@ suite('FileSystem Utils', () => {
             const filename = 'x/y/z/spam.py';
             filesystem.setup(f => f.stat(filename))
                 .returns(() => Promise.resolve(stat.object));
-            stat.setup(s => s.isFile())
-                .returns(() => true);
+            stat.setup(s => s.type)
+                .returns(() => FileType.File);
 
             const exists = await utils.pathExists(filename, FileType.File);
 
@@ -727,8 +795,8 @@ suite('FileSystem Utils', () => {
             const filename = 'x/y/z/spam.py';
             filesystem.setup(f => f.stat(filename))
                 .returns(() => Promise.resolve(stat.object));
-            stat.setup(s => s.isFile())
-                .returns(() => false);
+            stat.setup(s => s.type)
+                .returns(() => FileType.Directory);
 
             const exists = await utils.pathExists(filename, FileType.File);
 
@@ -740,8 +808,8 @@ suite('FileSystem Utils', () => {
             const dirname = 'x/y/z/spam';
             filesystem.setup(f => f.stat(dirname))
                 .returns(() => Promise.resolve(stat.object));
-            stat.setup(s => s.isDirectory())
-                .returns(() => true);
+            stat.setup(s => s.type)
+                .returns(() => FileType.Directory);
 
             const exists = await utils.pathExists(dirname, FileType.Directory);
 
@@ -753,8 +821,8 @@ suite('FileSystem Utils', () => {
             const dirname = 'x/y/z/spam';
             filesystem.setup(f => f.stat(dirname))
                 .returns(() => Promise.resolve(stat.object));
-            stat.setup(s => s.isDirectory())
-                .returns(() => false);
+            stat.setup(s => s.type)
+                .returns(() => FileType.File);
 
             const exists = await utils.pathExists(dirname, FileType.Directory);
 
@@ -766,10 +834,12 @@ suite('FileSystem Utils', () => {
             const filename = 'x/y/z/spam.py';
             filesystem.setup(f => f.stat(filename))
                 .returns(() => Promise.resolve(stat.object));
+            stat.setup(s => s.type)
+                .returns(() => FileType.SymbolicLink);
 
             const exists = await utils.pathExists(filename, FileType.SymbolicLink);
 
-            expect(exists).to.equal(false);
+            expect(exists).to.equal(true);
             verifyAll();
         });
 
@@ -777,10 +847,12 @@ suite('FileSystem Utils', () => {
             const filename = 'x/y/z/spam.py';
             filesystem.setup(f => f.stat(filename))
                 .returns(() => Promise.resolve(stat.object));
+            stat.setup(s => s.type)
+                .returns(() => FileType.Unknown);
 
             const exists = await utils.pathExists(filename, FileType.Unknown);
 
-            expect(exists).to.equal(false);
+            expect(exists).to.equal(true);
             verifyAll();
         });
     });
@@ -790,8 +862,8 @@ suite('FileSystem Utils', () => {
             const filename = 'x/y/z/spam.py';
             filesystem.setup(f => f.stat(filename))
                 .returns(() => Promise.resolve(stat.object));
-            stat.setup(s => s.isFile())
-                .returns(() => true);
+            stat.setup(s => s.type)
+                .returns(() => FileType.File);
 
             const exists = await utils.fileExists(filename);
 
@@ -805,8 +877,8 @@ suite('FileSystem Utils', () => {
             const dirname = 'x/y/z/spam';
             filesystem.setup(f => f.stat(dirname))
                 .returns(() => Promise.resolve(stat.object));
-            stat.setup(s => s.isDirectory())
-                .returns(() => true);
+            stat.setup(s => s.type)
+                .returns(() => FileType.Directory);
 
             const exists = await utils.directoryExists(dirname);
 
@@ -961,9 +1033,9 @@ suite('FileSystem Utils', () => {
             const filename = 'x/y/z/spam.py';
             filesystem.setup(f => f.lstat(filename))
                 .returns(() => Promise.resolve(stat.object));
-            stat.setup(s => s.ctimeMs)
+            stat.setup(s => s.ctime)
                 .returns(() => 101);
-            stat.setup(s => s.mtimeMs)
+            stat.setup(s => s.mtime)
                 .returns(() => 102);
             const expected = '<hash>';
             deps.setup(d => d.getHashString('101-102'))
diff --git a/src/test/datascience/dataScienceIocContainer.ts b/src/test/datascience/dataScienceIocContainer.ts
index fd32cfb78932..ee93c8f30096 100644
--- a/src/test/datascience/dataScienceIocContainer.ts
+++ b/src/test/datascience/dataScienceIocContainer.ts
@@ -298,6 +298,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 11335a1ba111..91ab8a5ef8d8 100644
--- a/src/test/serviceRegistry.ts
+++ b/src/test/serviceRegistry.ts
@@ -1,19 +1,23 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+import * as fsextra from 'fs-extra';
 import { Container } from 'inversify';
+import * as path from 'path';
 import { anything, instance, mock, when } from 'ts-mockito';
 import * as TypeMoq from 'typemoq';
 import { Disposable, Memento, OutputChannel } 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 {
+    FileSystem, FileSystemPaths, FileSystemUtils, 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';
@@ -22,6 +26,7 @@ import { registerTypes as processRegisterTypes } from '../client/common/process/
 import { IBufferDecoder, IProcessServiceFactory, IPythonExecutionFactory, IPythonToolExecutionService } from '../client/common/process/types';
 import { registerTypes as commonRegisterTypes } from '../client/common/serviceRegistry';
 import { GLOBAL_MEMENTO, ICurrentProcess, IDisposableRegistry, ILogger, IMemento, IOutputChannel, IPathUtils, IsWindows, WORKSPACE_MEMENTO } from '../client/common/types';
+import { createDeferred } from '../client/common/utils/async';
 import { registerTypes as variableRegisterTypes } from '../client/common/variables/serviceRegistry';
 import { registerTypes as formattersRegisterTypes } from '../client/formatters/serviceRegistry';
 import { EnvironmentActivationService } from '../client/interpreter/activation/service';
@@ -58,7 +63,93 @@ 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 LegacyRawFileSystem extends RawFileSystem {
+    public async readText(filename: string): Promise<string> {
+        return fsextra.readFile(filename, 'utf8');
+    }
+    public async writeText(filename: string, text: string): Promise<void> {
+        return fsextra.writeFile(filename, text, {
+            encoding: 'utf8'
+        });
+    }
+    public async rmtree(dirname: string): Promise<void> {
+        return fsextra.stat(dirname)
+            .then(() => fsextra.remove(dirname));
+    }
+    public async rmfile(filename: string): Promise<void> {
+        return fsextra.unlink(filename);
+    }
+    public async stat(filename: string): Promise<FileStat> {
+        const stat = await fsextra.stat(filename);
+        let fileType = FileType.Unknown;
+        if (stat.isFile()) {
+            fileType = FileType.File;
+        } else if (stat.isDirectory()) {
+            fileType = FileType.Directory;
+        } else if (stat.isSymbolicLink()) {
+            fileType = FileType.SymbolicLink;
+        }
+        return {
+            type: fileType,
+            size: stat.size,
+            ctime: stat.ctimeMs,
+            mtime: stat.mtimeMs
+        };
+    }
+    public async listdir(dirname: string): Promise<[string, FileType][]> {
+        const names: string[] = await fsextra.readdir(dirname);
+        const promises = names
+            .map(name => {
+                 const filename = path.join(dirname, name);
+                 return this.lstat(filename)
+                     .then(stat => [name, stat.type] as [string, FileType])
+                     .catch(() => [name, FileType.Unknown] as [string, FileType]);
+            });
+        return Promise.all(promises);
+    }
+    public async mkdirp(dirname: string): Promise<void> {
+        return fsextra.mkdirp(dirname);
+    }
+    public async copyFile(src: string, dest: string): Promise<void> {
+        const deferred = createDeferred<void>();
+        const rs = fsextra.createReadStream(src)
+            .on('error', (err) => {
+                deferred.reject(err);
+            });
+        const ws = fsextra.createWriteStream(dest)
+            .on('error', (err) => {
+                deferred.reject(err);
+            }).on('close', () => {
+                deferred.resolve();
+            });
+        rs.pipe(ws);
+        return deferred.promise;
+    }
+}
+class LegacyFileSystem extends FileSystem {
+    constructor() {
+        super();
+        const paths = FileSystemPaths.withDefaults();
+        const raw = new LegacyRawFileSystem(
+            paths,
+            // tslint:disable-next-line:no-any
+            undefined as any,
+            fsextra
+        );
+        this.utils = FileSystemUtils.withDefaults(raw, paths);
+    }
+}
+
 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;
 
@@ -105,7 +196,10 @@ export class IocContainer {
     }
     public registerFileSystemTypes() {
         this.serviceManager.addSingleton<IPlatformService>(IPlatformService, PlatformService);
-        this.serviceManager.addSingleton<IFileSystem>(IFileSystem, FileSystem);
+        this.serviceManager.addSingleton<IFileSystem>(
+            IFileSystem,
+            this.useVSCodeAPI ? FileSystem : LegacyFileSystem
+        );
     }
     public registerProcessTypes() {
         processRegisterTypes(this.serviceManager);
diff --git a/src/test/vscode-mock.ts b/src/test/vscode-mock.ts
index 18e56f318b40..1e3cb5721d74 100644
--- a/src/test/vscode-mock.ts
+++ b/src/test/vscode-mock.ts
@@ -83,6 +83,7 @@ mockedVSCode.DebugAdapterExecutable = vscodeMocks.vscMock.DebugAdapterExecutable
 mockedVSCode.DebugAdapterServer = vscodeMocks.vscMock.DebugAdapterServer;
 mockedVSCode.QuickInputButtons = vscodeMocks.vscMockExtHostedTypes.QuickInputButtons;
 mockedVSCode.FileType = vscodeMocks.vscMock.FileType;
+mockedVSCode.FileSystemError = vscodeMocks.vscMockExtHostedTypes.FileSystemError;
 
 // This API is used in src/client/telemetry/telemetry.ts
 const extensions = TypeMoq.Mock.ofType<typeof vscode.extensions>();