diff --git a/src/client/common/platform/fileSystem.ts b/src/client/common/platform/fileSystem.ts
index 3ed20df830f4..2d8f5d25e4c6 100644
--- a/src/client/common/platform/fileSystem.ts
+++ b/src/client/common/platform/fileSystem.ts
@@ -10,54 +10,131 @@ import { inject, injectable } from 'inversify';
 import * as path from 'path';
 import * as tmp from 'tmp';
 import { promisify } from 'util';
-import { FileStat } from 'vscode';
 import { createDeferred } from '../utils/async';
 import { noop } from '../utils/misc';
-import { IFileSystem, IPlatformService, TemporaryFile } from './types';
+import { FileStat, FileType, IFileSystem, IPlatformService, TemporaryFile } from './types';
 
 const globAsync = promisify(glob);
 
+// This helper function determines the file type of the given stats
+// object.  The type follows the convention of node's fs module, where
+// a file has exactly one type.  Symlinks are not resolved.
+function convertFileType(stat: fs.Stats): FileType {
+    if (stat.isFile()) {
+        return FileType.File;
+    } else if (stat.isDirectory()) {
+        return FileType.Directory;
+    } else if (stat.isSymbolicLink()) {
+        // The caller is responsible for combining this ("logical or")
+        // with File or Directory as necessary.
+        return FileType.SymbolicLink;
+    } else {
+        return FileType.Unknown;
+    }
+}
+
+async function getFileType(filename: string): Promise<FileType> {
+    let stat: fs.Stats;
+    try {
+        // Note that we used to use stat() here instead of lstat().
+        // This shouldn't matter because the only consumers were
+        // internal methods that have been updated appropriately.
+        stat = await fs.lstat(filename);
+    } catch {
+        return FileType.Unknown;
+    }
+    if (!stat.isSymbolicLink()) {
+        return convertFileType(stat);
+    }
+
+    // For symlinks we emulate the behavior of the vscode.workspace.fs API.
+    // See: https://code.visualstudio.com/api/references/vscode-api#FileType
+    try {
+        stat = await fs.stat(filename);
+    } catch {
+        return FileType.SymbolicLink;
+    }
+    if (stat.isFile()) {
+        return FileType.SymbolicLink | FileType.File;
+    } else if (stat.isDirectory()) {
+        return FileType.SymbolicLink | FileType.Directory;
+    } else {
+        return FileType.SymbolicLink;
+    }
+}
+
+export function convertStat(old: fs.Stats, filetype: FileType): FileStat {
+    return {
+        type: filetype,
+        size: old.size,
+        // FileStat.ctime and FileStat.mtime only have 1-millisecond
+        // resolution, while node provides nanosecond resolution.  So
+        // for now we round to the nearest integer.
+        // See: https://github.com/microsoft/vscode/issues/84526
+        ctime: Math.round(old.ctimeMs),
+        mtime: Math.round(old.mtimeMs)
+    };
+}
+
 @injectable()
 export class FileSystem implements IFileSystem {
-    constructor(@inject(IPlatformService) private platformService: IPlatformService) {}
+    constructor(
+        @inject(IPlatformService) private platformService: IPlatformService
+    ) { }
+
+    //=================================
+    // path-related
 
     public get directorySeparatorChar(): string {
         return path.sep;
     }
+
+    public arePathsSame(path1: string, path2: string): boolean {
+        path1 = path.normalize(path1);
+        path2 = path.normalize(path2);
+        if (this.platformService.isWindows) {
+            return path1.toUpperCase() === path2.toUpperCase();
+        } else {
+            return path1 === path2;
+        }
+    }
+
+    public getRealPath(filePath: string): Promise<string> {
+        return new Promise<string>(resolve => {
+            fs.realpath(filePath, (err, realPath) => {
+                resolve(err ? filePath : realPath);
+            });
+        });
+    }
+
+    //=================================
+    // "raw" operations
+
     public async stat(filePath: string): Promise<FileStat> {
         // Do not import vscode directly, as this isn't available in the Debugger Context.
         // If stat is used in debugger context, it will fail, however theres a separate PR that will resolve this.
         // tslint:disable-next-line: no-require-imports
         const vscode = require('vscode');
+        // Note that, prior to the November release of VS Code,
+        // stat.ctime was always 0.
+        // See: https://github.com/microsoft/vscode/issues/84525
         return vscode.workspace.fs.stat(vscode.Uri.file(filePath));
     }
-
-    public objectExists(filePath: string, statCheck: (s: fs.Stats) => boolean): Promise<boolean> {
-        return new Promise<boolean>(resolve => {
-            fs.stat(filePath, (error, stats) => {
-                if (error) {
-                    return resolve(false);
-                }
-                return resolve(statCheck(stats));
-            });
-        });
+    public async lstat(filename: string): Promise<FileStat> {
+        const stat = await fs.lstat(filename);
+        // Note that, unlike stat(), lstat() does not include the type
+        // of the symlink's target.
+        const fileType = convertFileType(stat);
+        return convertStat(stat, fileType);
     }
 
-    public fileExists(filePath: string): Promise<boolean> {
-        return this.objectExists(filePath, stats => stats.isFile());
-    }
-    public fileExistsSync(filePath: string): boolean {
-        return fs.existsSync(filePath);
-    }
-    /**
-     * Reads the contents of the file using utf8 and returns the string contents.
-     * @param {string} filePath
-     * @returns {Promise<string>}
-     * @memberof FileSystem
-     */
+    // Return the UTF8-decoded text of the file.
     public readFile(filePath: string): Promise<string> {
         return fs.readFile(filePath, 'utf8');
     }
+    public readFileSync(filePath: string): string {
+        return fs.readFileSync(filePath, 'utf8');
+    }
     public readData(filePath: string): Promise<Buffer> {
         return fs.readFile(filePath);
     }
@@ -66,10 +143,6 @@ export class FileSystem implements IFileSystem {
         await fs.writeFile(filePath, data, options);
     }
 
-    public directoryExists(filePath: string): Promise<boolean> {
-        return this.objectExists(filePath, stats => stats.isDirectory());
-    }
-
     public createDirectory(directoryPath: string): Promise<void> {
         return fs.mkdirp(directoryPath);
     }
@@ -80,79 +153,20 @@ export class FileSystem implements IFileSystem {
         return deferred.promise;
     }
 
-    public async listdir(root: string): Promise<string[]> {
-        return new Promise<string[]>(resolve => {
-            // Now look for Interpreters in this directory
-            fs.readdir(root, (err, names) => {
-                if (err) {
-                    return resolve([]);
-                }
-                resolve(names.map(name => path.join(root, name)));
-            });
-        });
-    }
-
-    public getSubDirectories(rootDir: string): Promise<string[]> {
-        return new Promise<string[]>(resolve => {
-            fs.readdir(rootDir, async (error, files) => {
-                if (error) {
-                    return resolve([]);
-                }
-                const subDirs = (await Promise.all(
-                    files.map(async name => {
-                        const fullPath = path.join(rootDir, name);
-                        try {
-                            if ((await fs.stat(fullPath)).isDirectory()) {
-                                return fullPath;
-                            }
-                            // tslint:disable-next-line:no-empty
-                        } catch (ex) {}
-                    })
-                )).filter(dir => dir !== undefined) as string[];
-                resolve(subDirs);
+    public async listdir(dirname: string): Promise<[string, FileType][]> {
+        const files = await fs.readdir(dirname);
+        const promises = files
+            .map(async basename => {
+                const filename = path.join(dirname, basename);
+                const fileType = await getFileType(filename);
+                return [filename, fileType] as [string, FileType];
             });
-        });
-    }
-
-    public async getFiles(rootDir: string): Promise<string[]> {
-        const files = await fs.readdir(rootDir);
-        return files.filter(async f => {
-            const fullPath = path.join(rootDir, f);
-            if ((await fs.stat(fullPath)).isFile()) {
-                return true;
-            }
-            return false;
-        });
-    }
-
-    public arePathsSame(path1: string, path2: string): boolean {
-        path1 = path.normalize(path1);
-        path2 = path.normalize(path2);
-        if (this.platformService.isWindows) {
-            return path1.toUpperCase() === path2.toUpperCase();
-        } else {
-            return path1 === path2;
-        }
+        return Promise.all(promises);
     }
 
     public appendFile(filename: string, data: {}): Promise<void> {
         return fs.appendFile(filename, data);
     }
-    public appendFileSync(filename: string, data: {}, encoding: string): void;
-    public appendFileSync(filename: string, data: {}, options?: { encoding?: string; mode?: number; flag?: string }): void;
-    // tslint:disable-next-line:unified-signatures
-    public appendFileSync(filename: string, data: {}, options?: { encoding?: string; mode?: string; flag?: string }): void;
-    public appendFileSync(filename: string, data: {}, optionsOrEncoding: {}): void {
-        return fs.appendFileSync(filename, data, optionsOrEncoding);
-    }
-
-    public getRealPath(filePath: string): Promise<string> {
-        return new Promise<string>(resolve => {
-            fs.realpath(filePath, (err, realPath) => {
-                resolve(err ? filePath : realPath);
-            });
-        });
-    }
 
     public copyFile(src: string, dest: string): Promise<void> {
         const deferred = createDeferred<void>();
@@ -177,6 +191,90 @@ export class FileSystem implements IFileSystem {
         return deferred.promise;
     }
 
+    public chmod(filePath: string, mode: string | number): Promise<void> {
+        return new Promise<void>((resolve, reject) => {
+            fileSystem.chmod(filePath, mode, (err: NodeJS.ErrnoException | null) => {
+                if (err) {
+                    return reject(err);
+                }
+                resolve();
+            });
+        });
+    }
+
+    public async move(src: string, tgt: string) {
+        await fs.rename(src, tgt);
+    }
+
+    public createReadStream(filePath: string): fileSystem.ReadStream {
+        return fileSystem.createReadStream(filePath);
+    }
+
+    public createWriteStream(filePath: string): fileSystem.WriteStream {
+        return fileSystem.createWriteStream(filePath);
+    }
+
+    //=================================
+    // utils
+
+    public objectExists(filePath: string, statCheck: (s: fs.Stats) => boolean): Promise<boolean> {
+        return new Promise<boolean>(resolve => {
+            // Note that we are using stat() rather than lstat().  This
+            // means that any symlinks are getting resolved.
+            fs.stat(filePath, (error, stats) => {
+                if (error) {
+                    return resolve(false);
+                }
+                return resolve(statCheck(stats));
+            });
+        });
+    }
+    public fileExists(filePath: string): Promise<boolean> {
+        return this.objectExists(filePath, stats => stats.isFile());
+    }
+    public fileExistsSync(filePath: string): boolean {
+        return fs.existsSync(filePath);
+    }
+    public directoryExists(filePath: string): Promise<boolean> {
+        return this.objectExists(filePath, stats => stats.isDirectory());
+    }
+
+    public async getSubDirectories(dirname: string): Promise<string[]> {
+        let files: [string, FileType][];
+        try {
+            files = await this.listdir(dirname);
+        } catch {
+            // We're only preserving pre-existng behavior here...
+            return [];
+        }
+        return files
+            .filter(([_file, fileType]) => {
+                // We preserve the pre-existing behavior of following
+                // symlinks.
+                return (fileType & FileType.Directory) > 0;
+            })
+            .map(([filename, _ft]) => filename);
+    }
+    public async getFiles(dirname: string): Promise<string[]> {
+        let files: [string, FileType][];
+        try {
+            files = await this.listdir(dirname);
+        } catch (err) {
+            // This matches what getSubDirectories() does.
+            if (!await fs.pathExists(dirname)) {
+                return [];
+            }
+            throw err; // re-throw
+        }
+        return files
+            .filter(([_file, fileType]) => {
+                // We preserve the pre-existing behavior of following
+                // symlinks.
+                return (fileType & FileType.File) > 0;
+            })
+            .map(([filename, _ft]) => filename);
+    }
+
     public getFileHash(filePath: string): Promise<string> {
         return new Promise<string>((resolve, reject) => {
             fs.lstat(filePath, (err, stats) => {
@@ -191,6 +289,7 @@ export class FileSystem implements IFileSystem {
             });
         });
     }
+
     public async search(globPattern: string, cwd?: string): Promise<string[]> {
         let found: string[];
         if (cwd) {
@@ -203,6 +302,7 @@ export class FileSystem implements IFileSystem {
         }
         return Array.isArray(found) ? found : [];
     }
+
     public createTemporaryFile(extension: string): Promise<TemporaryFile> {
         return new Promise<TemporaryFile>((resolve, reject) => {
             tmp.file({ postfix: extension }, (err, tmpFile, _, cleanupCallback) => {
@@ -214,33 +314,6 @@ export class FileSystem implements IFileSystem {
         });
     }
 
-    public createReadStream(filePath: string): fileSystem.ReadStream {
-        return fileSystem.createReadStream(filePath);
-    }
-
-    public createWriteStream(filePath: string): fileSystem.WriteStream {
-        return fileSystem.createWriteStream(filePath);
-    }
-
-    public chmod(filePath: string, mode: string): Promise<void> {
-        return new Promise<void>((resolve, reject) => {
-            fileSystem.chmod(filePath, mode, (err: NodeJS.ErrnoException | null) => {
-                if (err) {
-                    return reject(err);
-                }
-                resolve();
-            });
-        });
-    }
-
-    public readFileSync(filePath: string): string {
-        return fs.readFileSync(filePath, 'utf8');
-    }
-
-    public async move(src: string, tgt: string) {
-        await fs.rename(src, tgt);
-    }
-
     public async isDirReadonly(dirname: string): Promise<boolean> {
         const filePath = `${dirname}${path.sep}___vscpTest___`;
         return new Promise<boolean>(resolve => {
diff --git a/src/client/common/platform/types.ts b/src/client/common/platform/types.ts
index cadd7b0ae1a1..95deb9065c01 100644
--- a/src/client/common/platform/types.ts
+++ b/src/client/common/platform/types.ts
@@ -4,7 +4,7 @@
 import * as fs from 'fs';
 import * as fsextra from 'fs-extra';
 import { SemVer } from 'semver';
-import { Disposable, FileStat } from 'vscode';
+import * as vscode from 'vscode';
 import { Architecture, OSType } from '../utils/platform';
 
 export enum RegistryHive {
@@ -32,43 +32,46 @@ export interface IPlatformService {
     getVersion(): Promise<SemVer>;
 }
 
-export type TemporaryFile = { filePath: string } & Disposable;
-export type TemporaryDirectory = { path: string } & Disposable;
+export type TemporaryFile = { filePath: string } & vscode.Disposable;
+export type TemporaryDirectory = { path: string } & vscode.Disposable;
 
+export import FileType = vscode.FileType;
+export import FileStat = vscode.FileStat;
 export type WriteStream = fs.WriteStream;
 
 export const IFileSystem = Symbol('IFileSystem');
 export interface IFileSystem {
+    // path-related
     directorySeparatorChar: string;
+    arePathsSame(path1: string, path2: string): boolean;
+    getRealPath(path: string): Promise<string>;
+
+    // "raw" operations
     stat(filePath: string): Promise<FileStat>;
-    objectExists(path: string, statCheck: (s: fs.Stats) => boolean): Promise<boolean>;
-    fileExists(path: string): Promise<boolean>;
-    fileExistsSync(path: string): boolean;
-    directoryExists(path: string): Promise<boolean>;
     createDirectory(path: string): Promise<void>;
     deleteDirectory(path: string): Promise<void>;
-    listdir(dirname: string): Promise<string[]>;
-    getSubDirectories(rootDir: string): Promise<string[]>;
-    getFiles(rootDir: string): Promise<string[]>;
-    arePathsSame(path1: string, path2: string): boolean;
-    readData(filePath: string): Promise<Buffer>;
+    listdir(dirname: string): Promise<[string, FileType][]>;
     readFile(filePath: string): Promise<string>;
+    readData(filePath: string): Promise<Buffer>;
     writeFile(filePath: string, data: {}, options?: string | fsextra.WriteFileOptions): Promise<void>;
-    readFileSync(filename: string): string;
     appendFile(filename: string, data: {}): Promise<void>;
-    appendFileSync(filename: string, data: {}, encoding: string): void;
-    appendFileSync(filename: string, data: {}, options?: { encoding?: string; mode?: number; flag?: string }): void;
-    // tslint:disable-next-line:unified-signatures
-    appendFileSync(filename: string, data: {}, options?: { encoding?: string; mode?: string; flag?: string }): void;
-    getRealPath(path: string): Promise<string>;
     copyFile(src: string, dest: string): Promise<void>;
     deleteFile(filename: string): Promise<void>;
+    chmod(path: string, mode: string | number): Promise<void>;
+    move(src: string, tgt: string): Promise<void>;
+    // sync
+    readFileSync(filename: string): string;
+    createReadStream(path: string): fs.ReadStream;
+    createWriteStream(path: string): fs.WriteStream;
+
+    // utils
+    fileExists(path: string): Promise<boolean>;
+    fileExistsSync(path: string): boolean;
+    directoryExists(path: string): Promise<boolean>;
+    getSubDirectories(rootDir: string): Promise<string[]>;
+    getFiles(rootDir: string): Promise<string[]>;
     getFileHash(filePath: string): Promise<string>;
     search(globPattern: string, cwd?: string): Promise<string[]>;
     createTemporaryFile(extension: string): Promise<TemporaryFile>;
-    createReadStream(path: string): fs.ReadStream;
-    createWriteStream(path: string): fs.WriteStream;
-    chmod(path: string, mode: string): Promise<void>;
-    move(src: string, tgt: string): Promise<void>;
     isDirReadonly(dirname: string): Promise<boolean>;
 }
diff --git a/src/client/debugger/debugAdapter/main.ts b/src/client/debugger/debugAdapter/main.ts
index 0403dc5c7905..c078ee92bb8e 100644
--- a/src/client/debugger/debugAdapter/main.ts
+++ b/src/client/debugger/debugAdapter/main.ts
@@ -9,6 +9,7 @@ if ((Reflect as any).metadata === undefined) {
     require('reflect-metadata');
 }
 
+import * as fsextra from 'fs-extra';
 import { Socket } from 'net';
 import { EOL } from 'os';
 import * as path from 'path';
@@ -20,7 +21,6 @@ import { DebugProtocol } from 'vscode-debugprotocol';
 import { EXTENSION_ROOT_DIR } from '../../common/constants';
 import '../../common/extensions';
 import { isNotInstalledError } from '../../common/helpers';
-import { IFileSystem } from '../../common/platform/types';
 import { ICurrentProcess, IDisposable, IDisposableRegistry } from '../../common/types';
 import { createDeferred, Deferred, sleep } from '../../common/utils/async';
 import { noop } from '../../common/utils/misc';
@@ -47,7 +47,10 @@ export class PythonDebugger extends DebugSession {
     public debugServer?: BaseDebugServer;
     public client = createDeferred<Socket>();
     private supportsRunInTerminalRequest: boolean = false;
-    constructor(private readonly serviceContainer: IServiceContainer) {
+    constructor(
+        private readonly serviceContainer: IServiceContainer,
+        private readonly fileExistsSync = fsextra.existsSync
+    ) {
         super(false);
     }
     public shutdown(): void {
@@ -106,8 +109,7 @@ export class PythonDebugger extends DebugSession {
 
     }
     protected launchRequest(response: DebugProtocol.LaunchResponse, args: LaunchRequestArguments): void {
-        const fs = this.serviceContainer.get<IFileSystem>(IFileSystem);
-        if ((typeof args.module !== 'string' || args.module.length === 0) && args.program && !fs.fileExistsSync(args.program)) {
+        if ((typeof args.module !== 'string' || args.module.length === 0) && args.program && !this.fileExistsSync(args.program)) {
             return this.sendErrorResponse(response, { format: `File does not exist. "${args.program}"`, id: 1 }, undefined, undefined, ErrorDestination.User);
         }
 
diff --git a/src/client/debugger/debugAdapter/serviceRegistry.ts b/src/client/debugger/debugAdapter/serviceRegistry.ts
index f9337be584b9..140c1b0fe0dd 100644
--- a/src/client/debugger/debugAdapter/serviceRegistry.ts
+++ b/src/client/debugger/debugAdapter/serviceRegistry.ts
@@ -5,9 +5,6 @@
 
 import { Container } from 'inversify';
 import { SocketServer } from '../../common/net/socket/socketServer';
-import { FileSystem } from '../../common/platform/fileSystem';
-import { PlatformService } from '../../common/platform/platformService';
-import { IFileSystem, IPlatformService } from '../../common/platform/types';
 import { CurrentProcess } from '../../common/process/currentProcess';
 import { BufferDecoder } from '../../common/process/decoder';
 import { IBufferDecoder, IProcessServiceFactory } from '../../common/process/types';
@@ -37,8 +34,6 @@ export function registerTypes(serviceManager: IServiceManager) {
     serviceManager.addSingleton<IDebugStreamProvider>(IDebugStreamProvider, DebugStreamProvider);
     serviceManager.addSingleton<IProtocolLogger>(IProtocolLogger, ProtocolLogger);
     serviceManager.add<IProtocolParser>(IProtocolParser, ProtocolParser);
-    serviceManager.addSingleton<IFileSystem>(IFileSystem, FileSystem);
-    serviceManager.addSingleton<IPlatformService>(IPlatformService, PlatformService);
     serviceManager.addSingleton<ISocketServer>(ISocketServer, SocketServer);
     serviceManager.addSingleton<IProtocolMessageWriter>(IProtocolMessageWriter, ProtocolMessageWriter);
     serviceManager.addSingleton<IBufferDecoder>(IBufferDecoder, BufferDecoder);
diff --git a/src/client/interpreter/locators/helpers.ts b/src/client/interpreter/locators/helpers.ts
index 096437ac624f..ed40d44463a4 100644
--- a/src/client/interpreter/locators/helpers.ts
+++ b/src/client/interpreter/locators/helpers.ts
@@ -8,15 +8,18 @@ import { IPipEnvServiceHelper } from './types';
 
 const CheckPythonInterpreterRegEx = IS_WINDOWS ? /^python(\d+(.\d+)?)?\.exe$/ : /^python(\d+(.\d+)?)?$/;
 
-export function lookForInterpretersInDirectory(pathToCheck: string, fs: IFileSystem): Promise<string[]> {
+export async function lookForInterpretersInDirectory(pathToCheck: string, fs: IFileSystem): Promise<string[]> {
     // Technically, we should be able to use fs.getFiles().  However,
     // that breaks some tests.  So we stick with the broader behavior.
-    return fs.listdir(pathToCheck)
-        .then(subDirs => subDirs.filter(fileName => CheckPythonInterpreterRegEx.test(path.basename(fileName))))
-        .catch(err => {
-            traceError('Python Extension (lookForInterpretersInDirectory.fs.listdir):', err);
-            return [] as string[];
-        });
+    try {
+        const subDirs = await fs.listdir(pathToCheck);
+        return subDirs
+            .map(([filename, _ft]) => filename)
+            .filter(fileName => CheckPythonInterpreterRegEx.test(path.basename(fileName)));
+    } catch (err) {
+        traceError('Python Extension (lookForInterpretersInDirectory.fs.listdir):', err);
+        return [] as string[];
+    }
 }
 
 @injectable()
diff --git a/src/test/common/platform/filesystem.functional.test.ts b/src/test/common/platform/filesystem.functional.test.ts
new file mode 100644
index 000000000000..d3759d69c301
--- /dev/null
+++ b/src/test/common/platform/filesystem.functional.test.ts
@@ -0,0 +1,1314 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+// tslint:disable:max-func-body-length chai-vague-errors
+
+import { expect, use } from 'chai';
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import { convertStat, FileSystem } from '../../../client/common/platform/fileSystem';
+import { PlatformService } from '../../../client/common/platform/platformService';
+import { FileType, TemporaryFile } from '../../../client/common/platform/types';
+import { sleep } from '../../../client/common/utils/async';
+import {
+    assertDoesNotExist, assertExists, DOES_NOT_EXIST, fixPath, FSFixture,
+    SUPPORTS_SYMLINKS, WINDOWS
+} from './utils';
+
+// tslint:disable:no-require-imports no-var-requires
+const assertArrays = require('chai-arrays');
+use(require('chai-as-promised'));
+use(assertArrays);
+
+suite('FileSystem', () => {
+    let fileSystem: FileSystem;
+    let fix: FSFixture;
+    setup(async () => {
+        fileSystem = new FileSystem(
+            new PlatformService()
+        );
+        fix = new FSFixture();
+
+        await assertDoesNotExist(DOES_NOT_EXIST);
+    });
+    teardown(async () => {
+        await fix.cleanUp();
+        await fix.ensureDeleted(DOES_NOT_EXIST);
+    });
+
+    suite('path-related', () => {
+        suite('directorySeparatorChar', () => {
+            test('value', () => {
+                const sep = fileSystem.directorySeparatorChar;
+
+                expect(sep).to.equal(path.sep);
+            });
+        });
+
+        suite('arePathsSame', () => {
+            test('identical', () => {
+                const filename = 'x/y/z/spam.py';
+
+                const result = fileSystem.arePathsSame(filename, filename);
+
+                expect(result).to.equal(true);
+            });
+
+            test('not the same', () => {
+                const file1 = 'x/y/z/spam.py';
+                const file2 = 'a/b/c/spam.py';
+
+                const result = fileSystem.arePathsSame(file1, file2);
+
+                expect(result).to.equal(false);
+            });
+
+            test('with different separators', () => {
+                const file1 = 'x/y/z/spam.py';
+                const file2 = 'x\\y\\z\\spam.py';
+                const expected = WINDOWS;
+
+                const result = fileSystem.arePathsSame(file1, file2);
+
+                expect(result).to.equal(expected);
+            });
+
+            test('with different case', () => {
+                const file1 = 'x/y/z/spam.py';
+                const file2 = 'x/Y/z/Spam.py';
+                const expected = WINDOWS;
+
+                const result = fileSystem.arePathsSame(file1, file2);
+
+                expect(result).to.equal(expected);
+            });
+        });
+
+        suite('getRealPath', () => {
+            const prevCwd = process.cwd();
+            let cwd: string;
+            setup(async () => {
+                cwd = await fix.createDirectory('x/y/z');
+                process.chdir(cwd);
+            });
+            teardown(() => {
+                process.chdir(prevCwd);
+            });
+
+            test('basename-only', async () => {
+                const expected = await fix.createFile('x/y/z/spam.py');
+
+                const resolved = await fileSystem.getRealPath('spam.py');
+
+                expect(resolved).to.equal(expected);
+            });
+
+            test('absolute', async () => {
+                const filename = await fix.createFile('spam.py');
+                const expected = filename;
+
+                const resolved = await fileSystem.getRealPath(filename);
+
+                expect(resolved).to.equal(expected);
+            });
+
+            test('relative', async () => {
+                const expected = await fix.createFile('x/y/z/w/spam.py');
+                const relpath = fixPath('./w/spam.py');
+
+                const resolved = await fileSystem.getRealPath(relpath);
+
+                expect(resolved).to.equal(expected);
+            });
+
+            test('parent', async () => {
+                const expected = await fix.resolve('x/y');
+
+                const resolved = await fileSystem.getRealPath('..');
+
+                expect(resolved).to.equal(expected);
+            });
+
+            test('cousin', async () => {
+                const expected = await fix.createFile('x/w/spam.py');
+                const relpath = fixPath('../../w/spam.py');
+
+                const resolved = await fileSystem.getRealPath(relpath);
+
+                expect(resolved).to.equal(expected);
+            });
+
+            test('does not exist', async () => {
+                const resolved = await fileSystem.getRealPath('spam.py');
+
+                // The original path was returned unchanged.
+                expect(resolved).to.equal('spam.py'); // instead of <TMP>/x/y/z/spam.py
+            });
+
+            test('directory does not exist', async () => {
+                const relpath = fixPath('../../w/spam.py');
+
+                const resolved = await fileSystem.getRealPath(relpath);
+
+                // The original path was returned unchanged.
+                expect(resolved).to.equal(relpath); // instead of <TMP>/x/w/spam.py
+            });
+
+            test('symlink', async function() {
+                if (!SUPPORTS_SYMLINKS) {
+                    // tslint:disable-next-line:no-invalid-this
+                    this.skip();
+                }
+                const expected = await fix.createFile('spam.py');
+                await fix.createSymlink('x/y/z/eggs.py', expected);
+
+                const resolved = await fileSystem.getRealPath('eggs.py');
+
+                expect(resolved).to.equal(expected);
+            });
+
+            test('symlink chain', async function() {
+                if (!SUPPORTS_SYMLINKS) {
+                    // tslint:disable-next-line:no-invalid-this
+                    this.skip();
+                }
+                const expected = await fix.createFile('w/spam.py');
+                const symlink1 = await fix.createSymlink('x/y/spam.py', expected);
+                await fix.createSymlink('x/y/z/eggs.py', symlink1);
+
+                const resolved = await fileSystem.getRealPath('eggs.py');
+
+                expect(resolved).to.equal(expected);
+            });
+
+            test('symlink (target does not exist)', async function() {
+                if (!SUPPORTS_SYMLINKS) {
+                    // tslint:disable-next-line:no-invalid-this
+                    this.skip();
+                }
+                const filename = await fix.resolve('spam.py');
+                await fix.createSymlink('x/y/z/eggs.py', filename);
+
+                const resolved = await fileSystem.getRealPath('eggs.py');
+
+                // The original path was returned unchanged.
+                expect(resolved).to.equal('eggs.py'); // instead of <TMP>/spam.py
+            });
+
+            test('mixed', async function() {
+                if (!SUPPORTS_SYMLINKS) {
+                    // tslint:disable-next-line:no-invalid-this
+                    this.skip();
+                }
+                const expected = await fix.createFile('x/y/w/eggs.py');
+                await fix.createSymlink('x/w/spam.py', expected);
+                const relpath = fixPath('../../w/spam.py');
+
+                const resolved = await fileSystem.getRealPath(relpath);
+
+                expect(resolved).to.equal(expected);
+            });
+        });
+    });
+
+    suite('raw', () => {
+        suite('lstat', () => {
+            test('for symlinks, gives the link info', async function() {
+                if (!SUPPORTS_SYMLINKS) {
+                    // tslint:disable-next-line:no-invalid-this
+                    this.skip();
+                }
+                const filename = await fix.createFile('x/y/z/spam.py', '...');
+                const symlink = await fix.createSymlink('x/y/z/eggs.py', filename);
+                const expected = convertStat(
+                    await fs.lstat(symlink),
+                    FileType.SymbolicLink
+                );
+
+                const stat = await fileSystem.lstat(symlink);
+
+                expect(stat).to.deep.equal(expected);
+            });
+
+            test('for normal files, gives the file info', async () => {
+                const filename = await fix.createFile('x/y/z/spam.py', '...');
+                // Ideally we would compare to the result of
+                // fileSystem.stat().  However, we do not have access
+                // to the VS Code API here.
+                const expected = convertStat(
+                    await fs.lstat(filename),
+                    FileType.File
+                );
+
+                const stat = await fileSystem.lstat(filename);
+
+                expect(stat).to.deep.equal(expected);
+            });
+
+            test('fails if the file does not exist', async () => {
+                const promise = fileSystem.lstat(DOES_NOT_EXIST);
+
+                await expect(promise).to.eventually.be.rejected;
+            });
+        });
+
+        suite('createDirectory', () => {
+            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.createDirectory(dirname);
+
+                await assertExists(dirname);
+            });
+
+            test('works if the directory already exists', async () => {
+                const dirname = await fix.createDirectory('spam');
+                await assertExists(dirname);
+
+                await fileSystem.createDirectory(dirname);
+
+                await assertExists(dirname);
+            });
+        });
+
+        suite('deleteDirectory', () => {
+            test('deletes the directory if empty', async () => {
+                const dirname = await fix.createDirectory('x');
+                await assertExists(dirname);
+
+                await fileSystem.deleteDirectory(dirname);
+
+                await assertDoesNotExist(dirname);
+            });
+
+            test('fails if the directory is not empty', async () => {
+                const dirname = await fix.createDirectory('x');
+                const filename = await fix.createFile('x/y/z/spam.py');
+                await assertExists(filename);
+
+                const promise = fileSystem.deleteDirectory(dirname);
+
+                await expect(promise).to.eventually.be.rejected;
+            });
+
+            test('fails if the directory does not exist', async () => {
+                const promise = fileSystem.deleteDirectory(DOES_NOT_EXIST);
+
+                await expect(promise).to.eventually.be.rejected;
+            });
+        });
+
+        suite('listdir', () => {
+            if (SUPPORTS_SYMLINKS) {
+                test('mixed', async () => {
+                    // Create the target directory and its contents.
+                    const dirname = await fix.createDirectory('x/y/z');
+                    const file1 = await fix.createFile('x/y/z/__init__.py', '');
+                    const script = await fix.createFile('x/y/z/__main__.py', '<script here>');
+                    const file2 = await fix.createFile('x/y/z/spam.py', '...');
+                    const symlink1 = await fix.createSymlink(
+                        'x/y/z/info.py',
+                        // Link to an ignored file.
+                        await fix.createFile('x/_info.py', '<info here>') // source
+                    );
+                    const sock = await fix.createSocket('x/y/z/ipc.sock');
+                    const file3 = await fix.createFile('x/y/z/eggs.py', '"""..."""');
+                    const symlink2 = await fix.createSymlink(
+                        'x/y/z/broken',
+                        DOES_NOT_EXIST // source
+                    );
+                    const symlink3 = await fix.createSymlink(
+                        'x/y/z/ipc.sck',
+                        sock // source
+                    );
+                    const subdir = await fix.createDirectory('x/y/z/w');
+                    const symlink4 = await fix.createSymlink(
+                        'x/y/z/static_files',
+                        await fix.resolve('x/y/z/w/data') // source
+                    );
+                    // Create other files and directories (should be ignored).
+                    await fix.createSymlink(
+                        'my-script.py',
+                        // Link to a listed file.
+                        script // source (__main__.py)
+                    );
+                    const ignored1 = await fix.createFile('x/__init__.py', '');
+                    await fix.createFile('x/y/__init__.py', '');
+                    await fix.createSymlink(
+                        'x/y/z/w/__init__.py',
+                        ignored1 // source (x/__init__.py)
+                    );
+                    await fix.createDirectory('x/y/z/w/data');
+                    await fix.createFile('x/y/z/w/data/v1.json');
+
+                    const entries = await fileSystem.listdir(dirname);
+
+                    expect(entries.sort()).to.deep.equal([
+                        [file1, FileType.File],
+                        [script, FileType.File],
+                        [symlink2, FileType.SymbolicLink],
+                        [file3, FileType.File],
+                        [symlink1, FileType.SymbolicLink | FileType.File],
+                        [symlink3, FileType.SymbolicLink],
+                        [sock, FileType.Unknown],
+                        [file2, FileType.File],
+                        [symlink4, FileType.SymbolicLink | FileType.Directory],
+                        [subdir, FileType.Directory]
+                    ]);
+                });
+            } else {
+                test('mixed', async () => {
+                    // Create the target directory and its contents.
+                    const dirname = await fix.createDirectory('x/y/z');
+                    const file1 = await fix.createFile('x/y/z/__init__.py', '');
+                    const script = await fix.createFile('x/y/z/__main__.py', '<script here>');
+                    const file2 = await fix.createFile('x/y/z/spam.py', '...');
+                    const sock = await fix.createSocket('x/y/z/ipc.sock');
+                    const file3 = await fix.createFile('x/y/z/eggs.py', '"""..."""');
+                    const subdir = await fix.createDirectory('x/y/z/w');
+                    // Create other files and directories (should be ignored).
+                    await fix.createFile('x/__init__.py', '');
+                    await fix.createFile('x/y/__init__.py', '');
+                    await fix.createDirectory('x/y/z/w/data');
+                    await fix.createFile('x/y/z/w/data/v1.json');
+
+                    const entries = await fileSystem.listdir(dirname);
+
+                    expect(entries.sort()).to.deep.equal([
+                        [file1, FileType.File],
+                        [script, FileType.File],
+                        [file3, FileType.File],
+                        [sock, FileType.Unknown],
+                        [file2, FileType.File],
+                        [subdir, FileType.Directory]
+                    ]);
+                });
+            }
+
+            test('empty', async () => {
+                const dirname = await fix.createDirectory('x/y/z/eggs');
+
+                const entries = await fileSystem.listdir(dirname);
+
+                expect(entries).to.deep.equal([]);
+            });
+
+            test('fails if the directory does not exist', async () => {
+                const promise = fileSystem.listdir(DOES_NOT_EXIST);
+
+                await expect(promise).to.eventually.be.rejected;
+            });
+        });
+
+        suite('readFile', () => {
+            test('returns contents of a file', async () => {
+                const expected = '<some text>';
+                const filename = await fix.createFile('x/y/z/spam.py', expected);
+
+                const content = await fileSystem.readFile(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.readFile(filename);
+
+                expect(text).to.equal(expected);
+            });
+
+            test('returns garbage if encoding is UCS-2', async () => {
+                const filename = await fix.resolve('spam.py');
+                // There are probably cases where this would fail too.
+                // However, the extension never has to deal with non-UTF8
+                // cases, so it doesn't matter too much.
+                const original = '... 😁 ...';
+                await fs.writeFile(filename, original, { encoding: 'ucs2' });
+
+                const text = await fileSystem.readFile(filename);
+
+                expect(text).to.equal('.\u0000.\u0000.\u0000 \u0000=�\u0001� \u0000.\u0000.\u0000.\u0000');
+            });
+
+            test('throws an exception if file does not exist', async () => {
+                const promise = fileSystem.readFile(DOES_NOT_EXIST);
+
+                await expect(promise).to.eventually.be.rejected;
+            });
+        });
+
+        suite('writeFile', () => {
+            test('creates the file if missing', async () => {
+                const filename = await fix.resolve('x/y/z/spam.py');
+                await assertDoesNotExist(filename);
+                const data = 'line1\nline2\n';
+
+                await fileSystem.writeFile(filename, data);
+
+                const actual = await fs.readFile(filename)
+                    .then(buffer => buffer.toString());
+                expect(actual).to.equal(data);
+            });
+
+            test('always UTF-8', async () => {
+                const filename = await fix.resolve('x/y/z/spam.py');
+                const data = '... 😁 ...';
+
+                await fileSystem.writeFile(filename, data);
+
+                const actual = await fs.readFile(filename)
+                    .then(buffer => buffer.toString());
+                expect(actual).to.equal(data);
+            });
+
+            test('overwrites existing file', async () => {
+                const filename = await fix.createFile('x/y/z/spam.py', '...');
+                const data = 'line1\nline2\n';
+
+                await fileSystem.writeFile(filename, data);
+
+                const actual = await fs.readFile(filename)
+                    .then(buffer => buffer.toString());
+                expect(actual).to.equal(data);
+            });
+        });
+
+        suite('appendFile', () => {
+            test('existing file', async () => {
+                const orig = 'spamspamspam\n\n';
+                const dataToAppend = `Some Data\n${new Date().toString()}\nAnd another line`;
+                const filename = await fix.createFile('spam.txt', orig);
+                const expected = `${orig}${dataToAppend}`;
+
+                await fileSystem.appendFile(filename, dataToAppend);
+
+                const actual = await fs.readFile(filename, 'utf8');
+                expect(actual).to.be.equal(expected);
+            });
+
+            test('existing empty file', async () => {
+                const filename = await fix.createFile('spam.txt');
+                const dataToAppend = `Some Data\n${new Date().toString()}\nAnd another line`;
+                const expected = dataToAppend;
+
+                await fileSystem.appendFile(filename, dataToAppend);
+
+                const actual = await fs.readFile(filename, 'utf8');
+                expect(actual).to.be.equal(expected);
+            });
+
+            test('creates the file if it does not already exist', async () => {
+                await fileSystem.appendFile(DOES_NOT_EXIST, 'spam');
+
+                const actual = await fs.readFile(DOES_NOT_EXIST, 'utf8');
+                expect(actual).to.be.equal('spam');
+            });
+
+            test('fails if not a file', async () => {
+                const dirname = await fix.createDirectory('spam');
+
+                const promise = fileSystem.appendFile(dirname, 'spam');
+
+                await expect(promise).to.eventually.be.rejected;
+            });
+        });
+
+        suite('copyFile', () => {
+            test('the source file gets copied (same directory)', async () => {
+                const data = '<content>';
+                const src = await fix.createFile('x/y/z/spam.py', data);
+                const dest = await fix.resolve('x/y/z/spam.py.bak');
+                await assertDoesNotExist(dest);
+
+                await fileSystem.copyFile(src, dest);
+
+                const actual = await fs.readFile(dest)
+                    .then(buffer => buffer.toString());
+                expect(actual).to.equal(data);
+                const original = await fs.readFile(src)
+                    .then(buffer => buffer.toString());
+                expect(original).to.equal(data);
+            });
+
+            test('the source file gets copied (different directory)', async () => {
+                const data = '<content>';
+                const src = await fix.createFile('x/y/z/spam.py', data);
+                const dest = await fix.resolve('x/y/eggs.py');
+                await assertDoesNotExist(dest);
+
+                await fileSystem.copyFile(src, dest);
+
+                const actual = await fs.readFile(dest)
+                    .then(buffer => buffer.toString());
+                expect(actual).to.equal(data);
+                const original = await fs.readFile(src)
+                    .then(buffer => buffer.toString());
+                expect(original).to.equal(data);
+            });
+
+            test('fails if the source does not exist', async () => {
+                const dest = await fix.resolve('x/spam.py');
+
+                const promise = fileSystem.copyFile(DOES_NOT_EXIST, dest);
+
+                await expect(promise).to.eventually.be.rejected;
+            });
+
+            test('fails if the target parent directory does not exist', async () => {
+                const src = await fix.createFile('x/spam.py', '...');
+                const dest = await fix.resolve('y/eggs.py', false);
+                await assertDoesNotExist(path.dirname(dest));
+
+                const promise = fileSystem.copyFile(src, dest);
+
+                await expect(promise).to.eventually.be.rejected;
+            });
+        });
+
+        suite('deleteFile', () => {
+            test('deletes the file', async () => {
+                const filename = await fix.createFile('x/y/z/spam.py', '...');
+                await assertExists(filename);
+
+                await fileSystem.deleteFile(filename);
+
+                await assertDoesNotExist(filename);
+            });
+
+            test('fails if the file does not exist', async () => {
+                const promise = fileSystem.deleteFile(DOES_NOT_EXIST);
+
+                await expect(promise).to.eventually.be.rejected;
+            });
+        });
+
+        suite('chmod (non-Windows)', () => {
+            suiteSetup(function () {
+                // On Windows, chmod won't have any effect on the file itself.
+                if (WINDOWS) {
+                    // tslint:disable-next-line:no-invalid-this
+                    this.skip();
+                }
+            });
+
+            async function checkMode(filename: string, expected: number) {
+                const stat = await fs.stat(filename);
+                expect(stat.mode & 0o777).to.equal(expected);
+            }
+
+            test('the file mode gets updated (string)', async () => {
+                const filename = await fix.createFile('spam.py', '...');
+                await fs.chmod(filename, 0o644);
+
+                await fileSystem.chmod(filename, '755');
+
+                await checkMode(filename, 0o755);
+            });
+
+            test('the file mode gets updated (number)', async () => {
+                const filename = await fix.createFile('spam.py', '...');
+                await fs.chmod(filename, 0o644);
+
+                await fileSystem.chmod(filename, 0o755);
+
+                await checkMode(filename, 0o755);
+            });
+
+            test('the file mode gets updated for a directory', async () => {
+                const dirname = await fix.createDirectory('spam');
+                await fs.chmod(dirname, 0o755);
+
+                await fileSystem.chmod(dirname, 0o700);
+
+                await checkMode(dirname, 0o700);
+            });
+
+            test('nothing happens if the file mode already matches', async () => {
+                const filename = await fix.createFile('spam.py', '...');
+                await fs.chmod(filename, 0o644);
+
+                await fileSystem.chmod(filename, 0o644);
+
+                await checkMode(filename, 0o644);
+            });
+
+            test('fails if the file does not exist', async () => {
+                const promise = fileSystem.chmod(DOES_NOT_EXIST, 0o755);
+
+                await expect(promise).to.eventually.be.rejected;
+            });
+        });
+
+        suite('move', () => {
+            test('rename file', async () => {
+                const source = await fix.createFile('spam.py', '<text>');
+                const target = await fix.resolve('eggs-txt');
+                await assertDoesNotExist(target);
+
+                await fileSystem.move(source, target);
+
+                await assertExists(target);
+                const text = await fs.readFile(target, 'utf8');
+                expect(text).to.equal('<text>');
+                await assertDoesNotExist(source);
+            });
+
+            test('rename directory', async () => {
+                const source = await fix.createDirectory('spam');
+                await fix.createFile('spam/data.json', '<text>');
+                const target = await fix.resolve('eggs');
+                const filename = await fix.resolve('eggs/data.json', false);
+                await assertDoesNotExist(target);
+
+                await fileSystem.move(source, target);
+
+                await assertExists(filename);
+                const text = await fs.readFile(filename, 'utf8');
+                expect(text).to.equal('<text>');
+                await assertDoesNotExist(source);
+            });
+
+            test('rename symlink', async function() {
+                if (!SUPPORTS_SYMLINKS) {
+                    // tslint:disable-next-line:no-invalid-this
+                    this.skip();
+                }
+                const filename = await fix.createFile('spam.py');
+                const symlink = await fix.createSymlink('spam.lnk', filename);
+                const target = await fix.resolve('eggs');
+                await assertDoesNotExist(target);
+
+                await fileSystem.move(symlink, target);
+
+                await assertExists(target);
+                const linked = await fs.readlink(target);
+                expect(linked).to.equal(filename);
+                await assertDoesNotExist(symlink);
+            });
+
+            test('move file', async () => {
+                const source = await fix.createFile('spam.py', '<text>');
+                await fix.createDirectory('eggs');
+                const target = await fix.resolve('eggs/spam.py');
+                await assertDoesNotExist(target);
+
+                await fileSystem.move(source, target);
+
+                await assertExists(target);
+                const text = await fs.readFile(target, 'utf8');
+                expect(text).to.equal('<text>');
+                await assertDoesNotExist(source);
+            });
+
+            test('move directory', async () => {
+                const source = await fix.createDirectory('spam/spam/spam/eggs/spam');
+                await fix.createFile('spam/spam/spam/eggs/spam/data.json', '<text>');
+                await fix.createDirectory('spam/spam/spam/hash');
+                const target = await fix.resolve('spam/spam/spam/hash/spam');
+                const filename = await fix.resolve('spam/spam/spam/hash/spam/data.json', false);
+                await assertDoesNotExist(target);
+
+                await fileSystem.move(source, target);
+
+                await assertExists(filename);
+                const text = await fs.readFile(filename, 'utf8');
+                expect(text).to.equal('<text>');
+                await assertDoesNotExist(source);
+            });
+
+            test('move symlink', async function() {
+                if (!SUPPORTS_SYMLINKS) {
+                    // tslint:disable-next-line:no-invalid-this
+                    this.skip();
+                }
+                const filename = await fix.createFile('spam.py');
+                const symlink = await fix.createSymlink('w/spam.lnk', filename);
+                const target = await fix.resolve('x/spam.lnk');
+                await assertDoesNotExist(target);
+
+                await fileSystem.move(symlink, target);
+
+                await assertExists(target);
+                const linked = await fs.readlink(target);
+                expect(linked).to.equal(filename);
+                await assertDoesNotExist(symlink);
+            });
+
+            test('file target already exists', async () => {
+                const source = await fix.createFile('spam.py', '<text>');
+                const target = await fix.createFile('eggs-txt', '<other>');
+
+                await fileSystem.move(source, target);
+
+                await assertDoesNotExist(source);
+                await assertExists(target);
+                const text2 = await fs.readFile(target, 'utf8');
+                expect(text2).to.equal('<text>');
+            });
+
+            test('directory target already exists', async () => {
+                const source = await fix.createDirectory('spam');
+                const file3 = await fix.createFile('spam/data.json', '<text>');
+                const target = await fix.createDirectory('eggs');
+                const file1 = await fix.createFile('eggs/spam.py', '<code>');
+                const file2 = await fix.createFile('eggs/data.json', '<other>');
+
+                const promise = fileSystem.move(source, target);
+
+                await expect(promise).to.eventually.be.rejected;
+                // Make sure nothing changed.
+                const text1 = await fs.readFile(file1, 'utf8');
+                expect(text1).to.equal('<code>');
+                const text2 = await fs.readFile(file2, 'utf8');
+                expect(text2).to.equal('<other>');
+                const text3 = await fs.readFile(file3, 'utf8');
+                expect(text3).to.equal('<text>');
+            });
+
+            test('fails if the file does not exist', async () => {
+                const source = await fix.resolve(DOES_NOT_EXIST);
+                const target = await fix.resolve('spam.py');
+
+                const promise = fileSystem.move(source, target);
+
+                await expect(promise).to.eventually.be.rejected;
+                // Make sure nothing changed.
+                await assertDoesNotExist(target);
+            });
+
+            test('fails if the target directory does not exist', async () => {
+                const source = await fix.createFile('x/spam.py', '<text>');
+                const target = await fix.resolve('w/spam.py', false);
+                await assertDoesNotExist(path.dirname(target));
+
+                const promise = fileSystem.move(source, target);
+
+                await expect(promise).to.eventually.be.rejected;
+                // Make sure nothing changed.
+                await assertExists(source);
+                await assertDoesNotExist(target);
+            });
+        });
+
+        //=============================
+        // sync methods
+
+        suite('readFileSync', () => {
+            test('returns contents of a file', async () => {
+                const expected = '<some text>';
+                const filename = await fix.createFile('x/y/z/spam.py', expected);
+
+                const text = fileSystem.readFileSync(filename);
+
+                expect(text).to.be.equal(expected);
+            });
+
+            test('always UTF-8', async () => {
+                const expected = '... 😁 ...';
+                const filename = await fix.createFile('x/y/z/spam.py', expected);
+
+                const text = fileSystem.readFileSync(filename);
+
+                expect(text).to.equal(expected);
+            });
+
+            test('throws an exception if file does not exist', () => {
+                expect(
+                    () => fileSystem.readFileSync(DOES_NOT_EXIST)
+                ).to.throw(Error);
+            });
+        });
+
+        suite('createReadStream', () => {
+            test('returns the correct ReadStream', async () => {
+                const filename = await fix.createFile('x/y/z/spam.py', '...');
+                const expected = fs.createReadStream(filename);
+                expected.destroy();
+
+                const stream = fileSystem.createReadStream(filename);
+                stream.destroy();
+
+                expect(stream.path).to.deep.equal(expected.path);
+            });
+
+            // Missing tests:
+            // * creation fails if the file does not exist
+            // * .read() works as expected
+            // * .pipe() works as expected
+        });
+
+        suite('createWriteStream', () => {
+            test('returns the correct WriteStream', async () => {
+                const filename = await fix.resolve('x/y/z/spam.py');
+                const expected = fs.createWriteStream(filename);
+                expected.destroy();
+
+                const stream = fileSystem.createWriteStream(filename);
+                stream.destroy();
+
+                expect(stream.path).to.deep.equal(expected.path);
+            });
+
+            test('creates the file if missing', async () => {
+                const filename = await fix.resolve('x/y/z/spam.py');
+                await assertDoesNotExist(filename);
+                const data = 'line1\nline2\n';
+
+                const stream = fileSystem.createWriteStream(filename);
+                stream.write(data);
+                stream.destroy();
+
+                const actual = await fs.readFile(filename)
+                    .then(buffer => buffer.toString());
+                expect(actual).to.equal(data);
+            });
+
+            test('always UTF-8', async () => {
+                const filename = await fix.resolve('x/y/z/spam.py');
+                const data = '... 😁 ...';
+
+                const stream = fileSystem.createWriteStream(filename);
+                stream.write(data);
+                stream.destroy();
+
+                const actual = await fs.readFile(filename)
+                    .then(buffer => buffer.toString());
+                expect(actual).to.equal(data);
+            });
+
+            test('overwrites existing file', async () => {
+                const filename = await fix.createFile('x/y/z/spam.py', '...');
+                const data = 'line1\nline2\n';
+
+                const stream = fileSystem.createWriteStream(filename);
+                stream.write(data);
+                stream.destroy();
+
+                const actual = await fs.readFile(filename)
+                    .then(buffer => buffer.toString());
+                expect(actual).to.equal(data);
+            });
+        });
+    });
+
+    suite('utils', () => {
+        suite('fileExists', () => {
+            test('want file, got file', async () => {
+                const filename = await fix.createFile('x/y/z/spam.py');
+
+                const exists = await fileSystem.fileExists(filename);
+
+                expect(exists).to.equal(true);
+            });
+
+            test('want file, not file', async () => {
+                const filename = await fix.createDirectory('x/y/z/spam.py');
+
+                const exists = await fileSystem.fileExists(filename);
+
+                expect(exists).to.equal(false);
+            });
+
+            test('symlink', async function() {
+                if (!SUPPORTS_SYMLINKS) {
+                    // tslint:disable-next-line:no-invalid-this
+                    this.skip();
+                }
+                const filename = await fix.createFile('x/y/z/spam.py', '...');
+                const symlink = await fix.createSymlink('x/y/z/eggs.py', filename);
+
+                const exists = await fileSystem.fileExists(symlink);
+
+                // This is because we currently use stat() and not lstat().
+                expect(exists).to.equal(true);
+            });
+
+            test('unknown', async () => {
+                const sockFile = await fix.createSocket('x/y/z/ipc.sock');
+
+                const exists = await fileSystem.fileExists(sockFile);
+
+                expect(exists).to.equal(false);
+            });
+        });
+
+        suite('directoryExists', () => {
+            test('want directory, got directory', async () => {
+                const dirname = await fix.createDirectory('x/y/z/spam');
+
+                const exists = await fileSystem.directoryExists(dirname);
+
+                expect(exists).to.equal(true);
+            });
+
+            test('want directory, not directory', async () => {
+                const dirname = await fix.createFile('x/y/z/spam');
+
+                const exists = await fileSystem.directoryExists(dirname);
+
+                expect(exists).to.equal(false);
+            });
+
+            test('symlink', async () => {
+                const dirname = await fix.createDirectory('x/y/z/spam');
+                const symlink = await fix.createSymlink('x/y/z/eggs', dirname);
+
+                const exists = await fileSystem.directoryExists(symlink);
+
+                // This is because we currently use stat() and not lstat().
+                expect(exists).to.equal(true);
+            });
+
+            test('unknown', async () => {
+                const sockFile = await fix.createSocket('x/y/z/ipc.sock');
+
+                const exists = await fileSystem.directoryExists(sockFile);
+
+                expect(exists).to.equal(false);
+            });
+        });
+
+        suite('getSubDirectories', () => {
+            if (SUPPORTS_SYMLINKS) {
+                test('mixed types', async () => {
+                    const symlinkFileSource = await fix.createFile('x/info.py');
+                    const symlinkDirSource = await fix.createDirectory('x/data');
+                    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', symlinkFileSource);
+                    const symlink = await fix.createSymlink('x/y/z/scripts/datadir', symlinkDirSource);
+                    await fix.createFile('x/y/z/scripts/data.json');
+
+                    const results = await fileSystem.getSubDirectories(dirname);
+
+                    expect(results.sort()).to.deep.equal([
+                        symlink,
+                        subdir2,
+                        subdir1
+                    ]);
+                });
+            } else {
+                test('mixed types', async () => {
+                    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.createFile('x/y/z/scripts/data.json');
+
+                    const results = await fileSystem.getSubDirectories(dirname);
+
+                    expect(results.sort()).to.deep.equal([
+                        subdir2,
+                        subdir1
+                    ]);
+                });
+            }
+
+            test('empty if the directory does not exist', async () => {
+                const entries = await fileSystem.getSubDirectories(DOES_NOT_EXIST);
+
+                expect(entries).to.deep.equal([]);
+            });
+        });
+
+        suite('getFiles', () => {
+            if (SUPPORTS_SYMLINKS) {
+                test('mixed types', async () => {
+                    const symlinkFileSource = await fix.createFile('x/info.py');
+                    const symlinkDirSource = await fix.createDirectory('x/data');
+                    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');
+                    const symlink = await fix.createSymlink('x/y/z/scripts/other', symlinkFileSource);
+                    await fix.createSymlink('x/y/z/scripts/datadir', symlinkDirSource);
+                    const file3 = await fix.createFile('x/y/z/scripts/data.json');
+
+                    const results = await fileSystem.getFiles(dirname);
+
+                    expect(results.sort()).to.deep.equal([
+                        file3,
+                        file2,
+                        symlink,
+                        file1
+                    ]);
+                });
+            } else {
+                test('mixed types', async () => {
+                    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');
+                    const file3 = await fix.createFile('x/y/z/scripts/data.json');
+
+                    const results = await fileSystem.getFiles(dirname);
+
+                    expect(results.sort()).to.deep.equal([
+                        file3,
+                        file2,
+                        file1
+                    ]);
+                });
+            }
+
+            test('empty if the directory does not exist', async () => {
+                const entries = await fileSystem.getFiles(DOES_NOT_EXIST);
+
+                expect(entries).to.deep.equal([]);
+            });
+        });
+
+        suite('getFileHash', () => {
+            // Since getFileHash() relies on timestamps, we have to take
+            // into account filesystem timestamp resolution.  For instance
+            // on FAT and HFS it is 1 second.
+            // See: https://nodejs.org/api/fs.html#fs_stat_time_values
+
+            test('Getting hash for a file should return non-empty string', async () => {
+                const filename = await fix.createFile('x/y/z/spam.py');
+
+                const hash = await fileSystem.getFileHash(filename);
+
+                expect(hash).to.not.equal('');
+            });
+
+            test('the returned hash is stable', async () => {
+                const filename = await fix.createFile('x/y/z/spam.py');
+
+                const hash1 = await fileSystem.getFileHash(filename);
+                const hash2 = await fileSystem.getFileHash(filename);
+                await sleep(2_000); // just in case
+                const hash3 = await fileSystem.getFileHash(filename);
+
+                expect(hash1).to.equal(hash2);
+                expect(hash1).to.equal(hash3);
+                expect(hash2).to.equal(hash3);
+            });
+
+            test('the returned hash changes with modification', async () => {
+                const filename = await fix.createFile('x/y/z/spam.py', 'original text');
+
+                const hash1 = await fileSystem.getFileHash(filename);
+                await sleep(2_000); // for filesystems with 1s resolution
+                await fs.writeFile(filename, 'new text');
+                const hash2 = await fileSystem.getFileHash(filename);
+
+                expect(hash1).to.not.equal(hash2);
+            });
+
+            test('the returned hash is unique', async () => {
+                const file1 = await fix.createFile('spam.py');
+                await sleep(2_000); // for filesystems with 1s resolution
+                const file2 = await fix.createFile('x/y/z/spam.py');
+                await sleep(2_000); // for filesystems with 1s resolution
+                const file3 = await fix.createFile('eggs.py');
+
+                const hash1 = await fileSystem.getFileHash(file1);
+                const hash2 = await fileSystem.getFileHash(file2);
+                const hash3 = await fileSystem.getFileHash(file3);
+
+                expect(hash1).to.not.equal(hash2);
+                expect(hash1).to.not.equal(hash3);
+                expect(hash2).to.not.equal(hash3);
+            });
+
+            test('Getting hash for non existent file should throw error', async () => {
+                const promise = fileSystem.getFileHash(DOES_NOT_EXIST);
+
+                await expect(promise).to.eventually.be.rejected;
+            });
+        });
+
+        suite('search', () => {
+            test('found matches', async () => {
+                const pattern = await fix.resolve(`x/y/z/spam.*`);
+                const expected: string[] = [
+                    await fix.createFile('x/y/z/spam.py'),
+                    await fix.createFile('x/y/z/spam.pyc'),
+                    await fix.createFile('x/y/z/spam.so'),
+                    await fix.createDirectory('x/y/z/spam.data')
+                ];
+                // non-matches
+                await fix.createFile('x/spam.py');
+                await fix.createFile('x/y/z/eggs.py');
+                await fix.createFile('x/y/z/spam-all.py');
+                await fix.createFile('x/y/z/spam');
+                await fix.createFile('x/spam.py');
+
+                const files = await fileSystem.search(pattern);
+
+                expect(files.sort()).to.deep.equal(expected.sort());
+            });
+
+            test('no matches', async () => {
+                const pattern = await fix.resolve(`x/y/z/spam.*`);
+
+                const files = await fileSystem.search(pattern);
+
+                expect(files).to.deep.equal([]);
+            });
+        });
+
+        suite('createTemporaryFile', () => {
+            async function createTemporaryFile(suffix: string): Promise<TemporaryFile> {
+                const tempfile = await fileSystem.createTemporaryFile(suffix);
+                fix.addFSCleanup(tempfile.filePath, tempfile.dispose);
+                return tempfile;
+            }
+
+            test('TemporaryFile is created properly', async () => {
+                const tempfile = await fileSystem.createTemporaryFile('.tmp');
+                fix.addFSCleanup(tempfile.filePath, tempfile.dispose);
+                await assertExists(tempfile.filePath);
+
+                expect(tempfile.filePath.endsWith('.tmp')).to.equal(true, `bad suffix on ${tempfile.filePath}`);
+            });
+
+            test('TemporaryFile is disposed properly', async () => {
+                const tempfile = await createTemporaryFile('.tmp');
+                await assertExists(tempfile.filePath);
+
+                tempfile.dispose();
+
+                await assertDoesNotExist(tempfile.filePath);
+            });
+
+            test('Ensure creating a temporary file results in a unique temp file path', async () => {
+                const tempFile = await createTemporaryFile('.tmp');
+                const tempFile2 = await createTemporaryFile('.tmp');
+
+                const filename1 = tempFile.filePath;
+                const filename2 = tempFile2.filePath;
+
+                expect(filename1).to.not.equal(filename2);
+            });
+
+            test('Ensure writing to a temp file is supported via file stream', async () => {
+                const tempfile = await createTemporaryFile('.tmp');
+                const stream = fileSystem.createWriteStream(tempfile.filePath);
+                fix.addCleanup(() => stream.destroy());
+                const data = '...';
+
+                stream.write(data, 'utf8');
+
+                const actual = await fs.readFile(tempfile.filePath, 'utf8');
+                expect(actual).to.equal(data);
+            });
+
+            test('Ensure chmod works against a temporary file', async () => {
+                // Note that on Windows chmod is a noop.
+                const tempfile = await createTemporaryFile('.tmp');
+
+                await expect(
+                    fs.chmod(tempfile.filePath, '7777')
+                ).to.not.eventually.be.rejected;
+            });
+        });
+
+        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 fs.chmod(dirname, 0o444);
+
+                    const isReadonly = await fileSystem.isDirReadonly(dirname);
+
+                    expect(isReadonly).to.equal(false);
+                });
+            });
+
+            test('is not readonly', async () => {
+                const dirname = await fix.createDirectory('x/y/z/spam');
+
+                const isReadonly = await fileSystem.isDirReadonly(dirname);
+
+                expect(isReadonly).to.equal(true);
+            });
+
+            // Failing may be more sensible, but for now we are sticking
+            // with the existing behavior.
+            test('false if the directory does not exist', async () => {
+                const isReadonly = await fileSystem.isDirReadonly(DOES_NOT_EXIST);
+
+                expect(isReadonly).to.equal(false);
+            });
+        });
+
+        //=============================
+        // sync methods
+
+        suite('fileExistsSync', () => {
+            test('want file, got file', async () => {
+                const filename = await fix.createFile('x/y/z/spam.py');
+
+                const exists = fileSystem.fileExistsSync(filename);
+
+                expect(exists).to.equal(true);
+            });
+
+            test('want file, not file', async () => {
+                const filename = await fix.createDirectory('x/y/z/spam.py');
+
+                const exists = fileSystem.fileExistsSync(filename);
+
+                // Note that currently the "file" can be *anything*.  It
+                // doesn't have to be just a regular file.  This is the
+                // way it already worked, so we're keeping it that way
+                // for now.
+                expect(exists).to.equal(true);
+            });
+
+            test('symlink', async function() {
+                if (!SUPPORTS_SYMLINKS) {
+                    // tslint:disable-next-line:no-invalid-this
+                    this.skip();
+                }
+                const filename = await fix.createFile('x/y/z/spam.py', '...');
+                const symlink = await fix.createSymlink('x/y/z/eggs.py', filename);
+
+                const exists = fileSystem.fileExistsSync(symlink);
+
+                // Note that currently the "file" can be *anything*.  It
+                // doesn't have to be just a regular file.  This is the
+                // way it already worked, so we're keeping it that way
+                // for now.
+                expect(exists).to.equal(true);
+            });
+
+            test('unknown', async () => {
+                const sockFile = await fix.createSocket('x/y/z/ipc.sock');
+
+                const exists = fileSystem.fileExistsSync(sockFile);
+
+                // Note that currently the "file" can be *anything*.  It
+                // doesn't have to be just a regular file.  This is the
+                // way it already worked, so we're keeping it that way
+                // for now.
+                expect(exists).to.equal(true);
+            });
+        });
+    });
+});
diff --git a/src/test/common/platform/filesystem.test.ts b/src/test/common/platform/filesystem.test.ts
new file mode 100644
index 000000000000..5125f4fe1649
--- /dev/null
+++ b/src/test/common/platform/filesystem.test.ts
@@ -0,0 +1,90 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+// tslint:disable:max-func-body-length chai-vague-errors
+// tslint:disable:no-suspicious-comment
+
+import { expect } from 'chai';
+import * as fsextra from 'fs-extra';
+import {
+    convertStat, FileSystem
+} from '../../../client/common/platform/fileSystem';
+import { PlatformService } from '../../../client/common/platform/platformService';
+import {
+    FileType, IFileSystem
+} from '../../../client/common/platform/types';
+import {
+    assertDoesNotExist, DOES_NOT_EXIST, FSFixture, SUPPORTS_SYMLINKS
+} from './utils';
+
+// Note: all functional tests that do not trigger the VS Code "fs" API
+// are found in filesystem.functional.test.ts.
+
+suite('FileSystem', () => {
+    let filesystem: IFileSystem;
+    let fix: FSFixture;
+    setup(async () => {
+        filesystem = new FileSystem(
+            new PlatformService()
+        );
+        fix = new FSFixture();
+
+        await assertDoesNotExist(DOES_NOT_EXIST);
+    });
+    teardown(async () => {
+        await fix.cleanUp();
+    });
+
+    suite('stat', () => {
+        test('gets the info for an existing file', async () => {
+            const filename = await fix.createFile('x/y/z/spam.py', '...');
+            const old = await fsextra.stat(filename);
+            const expected = convertStat(old, FileType.File);
+
+            const stat = await filesystem.stat(filename);
+
+            expect(stat).to.deep.equal(expected);
+        });
+
+        test('gets the info for an existing directory', async () => {
+            const dirname = await fix.createDirectory('x/y/z/spam');
+            const old = await fsextra.stat(dirname);
+            const expected = convertStat(old, FileType.Directory);
+
+            const stat = await filesystem.stat(dirname);
+
+            expect(stat).to.deep.equal(expected);
+        });
+
+        test('for symlinks, gets the info for the linked file', async function() {
+            if (!SUPPORTS_SYMLINKS) {
+                // tslint:disable-next-line:no-invalid-this
+                this.skip();
+            }
+            const filename = await fix.createFile('x/y/z/spam.py', '...');
+            const symlink = await fix.createSymlink('x/y/z/eggs.py', filename);
+            const old = await fsextra.stat(filename);
+            const expected = convertStat(old, FileType.SymbolicLink | FileType.File);
+
+            const stat = await filesystem.stat(symlink);
+
+            expect(stat).to.deep.equal(expected);
+        });
+
+        test('gets the info for a socket', async () => {
+            const sock = await fix.createSocket('x/spam.sock');
+            const old = await fsextra.stat(sock);
+            const expected = convertStat(old, FileType.Unknown);
+
+            const stat = await filesystem.stat(sock);
+
+            expect(stat).to.deep.equal(expected);
+        });
+
+        test('fails if the file does not exist', async () => {
+            const promise = filesystem.stat(DOES_NOT_EXIST);
+
+            await expect(promise).to.eventually.be.rejected;
+        });
+    });
+});
diff --git a/src/test/common/platform/filesystem.unit.test.ts b/src/test/common/platform/filesystem.unit.test.ts
index b681cdcc2dad..80235951e3e7 100644
--- a/src/test/common/platform/filesystem.unit.test.ts
+++ b/src/test/common/platform/filesystem.unit.test.ts
@@ -1,130 +1,90 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-import { expect, use } from 'chai';
-import * as fs from 'fs-extra';
-import * as path from 'path';
+// tslint:disable:max-func-body-length
+
+import { expect } from 'chai';
 import * as TypeMoq from 'typemoq';
 import { FileSystem } from '../../../client/common/platform/fileSystem';
-import { IFileSystem, IPlatformService, TemporaryFile } from '../../../client/common/platform/types';
-// tslint:disable:no-require-imports no-var-requires
-const assertArrays = require('chai-arrays');
-use(require('chai-as-promised'));
-use(assertArrays);
+import { IPlatformService } from '../../../client/common/platform/types';
+import { getNamesAndValues } from '../../../client/common/utils/enum';
+import { OSType } from '../../../client/common/utils/platform';
 
-// tslint:disable-next-line:max-func-body-length
 suite('FileSystem', () => {
     let platformService: TypeMoq.IMock<IPlatformService>;
-    let fileSystem: IFileSystem;
-    const fileToAppendTo = path.join(__dirname, 'created_for_testing_dummy.txt');
+    let fileSystem: FileSystem;
     setup(() => {
-        platformService = TypeMoq.Mock.ofType<IPlatformService>();
+        platformService = TypeMoq.Mock.ofType<IPlatformService>(undefined, TypeMoq.MockBehavior.Strict);
         fileSystem = new FileSystem(platformService.object);
-        cleanTestFiles();
     });
-    teardown(cleanTestFiles);
-    function cleanTestFiles() {
-        if (fs.existsSync(fileToAppendTo)) {
-            fs.unlinkSync(fileToAppendTo);
-        }
+    function verifyAll() {
+        platformService.verifyAll();
     }
-    test('ReadFile returns contents of a file', async () => {
-        const file = __filename;
-        const expectedContents = await fs.readFile(file).then(buffer => buffer.toString());
-        const content = await fileSystem.readFile(file);
 
-        expect(content).to.be.equal(expectedContents);
-    });
+    suite('path-related', () => {
+        const caseInsensitive = [OSType.Windows];
 
-    test('ReadFile throws an exception if file does not exist', async () => {
-        const readPromise = fs.readFile('xyz', { encoding: 'utf8' });
-        await expect(readPromise).to.be.rejectedWith();
-    });
+        suite('arePathsSame', () => {
+            getNamesAndValues<OSType>(OSType).forEach(item => {
+                const osType = item.value;
 
-    function caseSensitivityFileCheck(isWindows: boolean, isOsx: boolean, isLinux: boolean) {
-        platformService.setup(p => p.isWindows).returns(() => isWindows);
-        platformService.setup(p => p.isMac).returns(() => isOsx);
-        platformService.setup(p => p.isLinux).returns(() => isLinux);
-        const path1 = 'c:\\users\\Peter Smith\\my documents\\test.txt';
-        const path2 = 'c:\\USERS\\Peter Smith\\my documents\\test.TXT';
-        const path3 = 'c:\\USERS\\Peter Smith\\my documents\\test.exe';
-
-        if (isWindows) {
-            expect(fileSystem.arePathsSame(path1, path2)).to.be.equal(true, 'file paths do not match (windows)');
-        } else {
-            expect(fileSystem.arePathsSame(path1, path2)).to.be.equal(false, 'file match (non windows)');
-        }
-
-        expect(fileSystem.arePathsSame(path1, path1)).to.be.equal(true, '1. file paths do not match');
-        expect(fileSystem.arePathsSame(path2, path2)).to.be.equal(true, '2. file paths do not match');
-        expect(fileSystem.arePathsSame(path1, path3)).to.be.equal(false, '2. file paths do not match');
-    }
+                function setPlatform(numCalls = 1) {
+                    platformService.setup(p => p.isWindows)
+                        .returns(() => osType === OSType.Windows)
+                        .verifiable(TypeMoq.Times.exactly(numCalls));
+                }
 
-    test('Case sensitivity is ignored when comparing file names on windows', async () => {
-        caseSensitivityFileCheck(true, false, false);
-    });
+                test(`True if paths are identical (type: ${item.name})`, () => {
+                    setPlatform(2);
+                    const path1 = 'c:\\users\\Peter Smith\\my documents\\test.txt';
+                    const path2 = 'c:\\USERS\\Peter Smith\\my documents\\test.TXT';
 
-    test('Case sensitivity is not ignored when comparing file names on osx', async () => {
-        caseSensitivityFileCheck(false, true, false);
-    });
+                    const areSame11 = fileSystem.arePathsSame(path1, path1);
+                    const areSame22 = fileSystem.arePathsSame(path2, path2);
 
-    test('Case sensitivity is not ignored when comparing file names on linux', async () => {
-        caseSensitivityFileCheck(false, false, true);
-    });
-    test('Check existence of files synchronously', async () => {
-        expect(fileSystem.fileExistsSync(__filename)).to.be.equal(true, 'file not found');
-    });
+                    expect(areSame11).to.be.equal(true, '1. file paths do not match');
+                    expect(areSame22).to.be.equal(true, '2. file paths do not match');
+                    verifyAll();
+                });
 
-    test('Test appending to file', async () => {
-        const dataToAppend = `Some Data\n${new Date().toString()}\nAnd another line`;
-        fileSystem.appendFileSync(fileToAppendTo, dataToAppend);
-        const fileContents = await fileSystem.readFile(fileToAppendTo);
-        expect(fileContents).to.be.equal(dataToAppend);
-    });
-    test('Test searching for files', async () => {
-        const searchPattern = `${path.basename(__filename, __filename.substring(__filename.length - 3))}.*`;
-        const files = await fileSystem.search(path.join(__dirname, searchPattern));
-        expect(files).to.be.array();
-        expect(files.length).to.be.at.least(1);
-        const expectedFileName = __filename.replace(/\\/g, '/');
-        const fileName = files[0].replace(/\\/g, '/');
-        expect(fileName).to.equal(expectedFileName);
-    });
-    test('Ensure creating a temporary file results in a unique temp file path', async () => {
-        const tempFile = await fileSystem.createTemporaryFile('.tmp');
-        const tempFile2 = await fileSystem.createTemporaryFile('.tmp');
-        expect(tempFile.filePath).to.not.equal(tempFile2.filePath, 'Temp files must be unique, implementation of createTemporaryFile is off.');
-    });
-    test('Ensure writing to a temp file is supported via file stream', async () => {
-        await fileSystem.createTemporaryFile('.tmp').then((tf: TemporaryFile) => {
-            expect(tf).to.not.equal(undefined, 'Error trying to create a temporary file');
-            const writeStream = fileSystem.createWriteStream(tf.filePath);
-            writeStream.write('hello', 'utf8', (err: Error | null | undefined) => {
-                expect(err).to.equal(undefined, `Failed to write to a temp file, error is ${err}`);
-            });
-        }, (failReason) => {
-            expect(failReason).to.equal('No errors occurred', `Failed to create a temporary file with error ${failReason}`);
-        });
-    });
-    test('Ensure chmod works against a temporary file', async () => {
-        await fileSystem.createTemporaryFile('.tmp').then(async (fl: TemporaryFile) => {
-            await fileSystem.chmod(fl.filePath, '7777').then(
-                (_success: void) => {
-                    // cannot check for success other than we got here, chmod in Windows won't have any effect on the file itself.
-                },
-                (failReason) => {
-                    expect(failReason).to.equal('There was no error using chmod', `Failed to perform chmod operation successfully, got error ${failReason}`);
+                test(`False if paths are completely different (type: ${item.name})`, () => {
+                    setPlatform();
+                    const path1 = 'c:\\users\\Peter Smith\\my documents\\test.txt';
+                    const path2 = 'c:\\users\\Peter Smith\\my documents\\test.exe';
+
+                    const areSame = fileSystem.arePathsSame(path1, path2);
+
+                    expect(areSame).to.be.equal(false, 'file paths do not match');
+                    verifyAll();
                 });
-        });
-    });
-    test('Getting hash for non existent file should throw error', async () => {
-        const promise = fileSystem.getFileHash('some unknown file');
 
-        await expect(promise).to.eventually.be.rejected;
-    });
-    test('Getting hash for a file should return non-empty string', async () => {
-        const hash = await fileSystem.getFileHash(__filename);
+                if (caseInsensitive.includes(osType)) {
+                    test(`True if paths only differ by case (type: ${item.name})`, () => {
+                        setPlatform();
+                        const path1 = 'c:\\users\\Peter Smith\\my documents\\test.txt';
+                        const path2 = 'c:\\USERS\\Peter Smith\\my documents\\test.TXT';
 
-        expect(hash).to.be.length.greaterThan(0);
+                        const areSame = fileSystem.arePathsSame(path1, path2);
+
+                        expect(areSame).to.be.equal(true, 'file paths match');
+                        verifyAll();
+                    });
+                } else {
+                    test(`False if paths only differ by case (type: ${item.name})`, () => {
+                        setPlatform();
+                        const path1 = 'c:\\users\\Peter Smith\\my documents\\test.txt';
+                        const path2 = 'c:\\USERS\\Peter Smith\\my documents\\test.TXT';
+
+                        const areSame = fileSystem.arePathsSame(path1, path2);
+
+                        expect(areSame).to.be.equal(false, 'file paths do not match');
+                        verifyAll();
+                    });
+                }
+
+                // Missing tests:
+                // * exercize normalization
+            });
+        });
     });
 });
diff --git a/src/test/common/platform/utils.ts b/src/test/common/platform/utils.ts
new file mode 100644
index 000000000000..4764277795e9
--- /dev/null
+++ b/src/test/common/platform/utils.ts
@@ -0,0 +1,200 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+// tslint:disable:no-console
+
+import { expect } from 'chai';
+import * as fsextra from 'fs-extra';
+import * as net from 'net';
+import * as path from 'path';
+import * as tmpMod from 'tmp';
+
+// Note: all functional tests that trigger the VS Code "fs" API are
+// found in filesystem.test.ts.
+
+export const WINDOWS = /^win/.test(process.platform);
+
+export const SUPPORTS_SYMLINKS = (() => {
+    const source = fsextra.readdirSync('.')[0];
+    const symlink = `${source}.symlink`;
+    try {
+        fsextra.symlinkSync(source, symlink);
+    } catch {
+        return false;
+    }
+    fsextra.unlinkSync(symlink);
+    return true;
+})();
+
+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;
+}
+
+export async function assertExists(filename: string) {
+    await expect(
+        fsextra.stat(filename)
+    ).to.not.eventually.be.rejected;
+}
+
+export function fixPath(filename: string): string {
+    return path.normalize(filename);
+}
+
+export class CleanupFixture {
+    private cleanups: (() => void | Promise<void>)[];
+    constructor() {
+        this.cleanups = [];
+    }
+
+    public addCleanup(cleanup: () => void | Promise<void>) {
+        this.cleanups.push(cleanup);
+    }
+
+    public async cleanUp() {
+        const cleanups = this.cleanups;
+        this.cleanups = [];
+
+        return Promise.all(cleanups.map(async (cleanup, i) => {
+            try {
+                const res = cleanup();
+                if (res) {
+                    await res;
+                }
+            } catch (err) {
+                console.log(`cleanup ${i + 1} failed: ${err}`);
+                console.log('moving on...');
+            }
+        }));
+    }
+}
+
+export class FSFixture extends CleanupFixture {
+    private tempDir: string | undefined;
+    private sockServer: net.Server | undefined;
+
+    public addFSCleanup(filename: string, dispose?: () => void) {
+        this.addCleanup(() => this.ensureDeleted(filename, dispose));
+    }
+
+    public async resolve(relname: string, mkdirs = true): Promise<string> {
+        const tempDir = this.ensureTempDir();
+        relname = path.normalize(relname);
+        const filename = path.join(tempDir, relname);
+        if (mkdirs) {
+            await fsextra.mkdirp(
+                path.dirname(filename));
+        }
+        return filename;
+    }
+
+    public async createFile(relname: string, text = ''): Promise<string> {
+        const filename = await this.resolve(relname);
+        await fsextra.writeFile(filename, text);
+        return filename;
+    }
+
+    public async createDirectory(relname: string): Promise<string> {
+        const dirname = await this.resolve(relname);
+        await fsextra.mkdir(dirname);
+        return dirname;
+    }
+
+    public async createSymlink(relname: string, source: string): Promise<string> {
+        if (!SUPPORTS_SYMLINKS) {
+            throw Error('this platform does not support symlinks');
+        }
+        const symlink = await this.resolve(relname);
+        // We cannot use fsextra.ensureSymlink() because it requires
+        // that "source" exist.
+        await fsextra.symlink(source, symlink);
+        return symlink;
+    }
+
+    public async createSocket(relname: string): Promise<string> {
+        const srv = this.ensureSocketServer();
+        const filename = await this.resolve(relname);
+        await new Promise(resolve => srv!.listen(filename, 0, resolve));
+        return filename;
+    }
+
+    public async ensureDeleted(filename: string, dispose?: () => void) {
+        if (dispose) {
+            try {
+                dispose();
+                return; // Trust that dispose() did what it's supposed to.
+            } catch (err) {
+                // For temp directories, the "unsafeCleanup: true"
+                // option of the "tmp" module is supposed to support
+                // a non-empty directory, but apparently that isn't
+                // always the case.
+                // (see #8804)
+                if (!await fsextra.pathExists(filename)) {
+                    return;
+                }
+                console.log(`failure during dispose() for ${filename}: ${err}`);
+                console.log('...manually deleting');
+                // Fall back to fsextra.
+            }
+        }
+
+        try {
+            await fsextra.remove(filename);
+        } catch (err) {
+            if (!await fsextra.pathExists(filename)) {
+                return;
+            }
+            console.log(`failure while deleting ${filename}: ${err}`);
+        }
+    }
+
+    private ensureTempDir(): string {
+        if (this.tempDir) {
+            return this.tempDir;
+        }
+
+        const tempDir = tmpMod.dirSync({
+            prefix: 'pyvsc-fs-tests-',
+            unsafeCleanup: true
+        });
+        this.tempDir = tempDir.name;
+
+        this.addFSCleanup(tempDir.name, async () => {
+            if (!this.tempDir) {
+                return;
+            }
+            this.tempDir = undefined;
+
+            await this.ensureDeleted(tempDir.name, tempDir.removeCallback);
+            //try {
+            //    tempDir.removeCallback();
+            //} catch {
+            //    // The "unsafeCleanup: true" option is supposed
+            //    // to support a non-empty directory, but apparently
+            //    // that isn't always the case.  (see #8804)
+            //    await fsextra.remove(tempDir.name);
+            //}
+        });
+        return tempDir.name;
+    }
+
+    private ensureSocketServer(): net.Server {
+        if (this.sockServer) {
+            return this.sockServer;
+        }
+
+        const srv = net.createServer();
+        this.sockServer = srv;
+        this.addCleanup(async () => {
+            try {
+                await new Promise(resolve => srv.close(resolve));
+            } catch (err) {
+                console.log(`failure while closing socket server: ${err}`);
+            }
+        });
+        return srv;
+    }
+}
diff --git a/src/test/debugger/debugAdapter/serviceRegistry.unit.test.ts b/src/test/debugger/debugAdapter/serviceRegistry.unit.test.ts
index 9cc0a024610b..f38c112b2d76 100644
--- a/src/test/debugger/debugAdapter/serviceRegistry.unit.test.ts
+++ b/src/test/debugger/debugAdapter/serviceRegistry.unit.test.ts
@@ -6,9 +6,6 @@
 import { expect } from 'chai';
 import { anything, instance, mock, verify } from 'ts-mockito';
 import { SocketServer } from '../../../client/common/net/socket/socketServer';
-import { FileSystem } from '../../../client/common/platform/fileSystem';
-import { PlatformService } from '../../../client/common/platform/platformService';
-import { IFileSystem, IPlatformService } from '../../../client/common/platform/types';
 import { CurrentProcess } from '../../../client/common/process/currentProcess';
 import { BufferDecoder } from '../../../client/common/process/decoder';
 import { IBufferDecoder, IProcessServiceFactory } from '../../../client/common/process/types';
@@ -38,8 +35,6 @@ suite('Debugger debug adapter Service Registry', () => {
         verify(serviceManager.addSingleton<IDebugStreamProvider>(IDebugStreamProvider, DebugStreamProvider)).once();
         verify(serviceManager.addSingleton<IProtocolLogger>(IProtocolLogger, ProtocolLogger)).once();
         verify(serviceManager.add<IProtocolParser>(IProtocolParser, ProtocolParser)).once();
-        verify(serviceManager.addSingleton<IFileSystem>(IFileSystem, FileSystem)).once();
-        verify(serviceManager.addSingleton<IPlatformService>(IPlatformService, PlatformService)).once();
         verify(serviceManager.addSingleton<ISocketServer>(ISocketServer, SocketServer)).once();
         verify(serviceManager.addSingleton<IProtocolMessageWriter>(IProtocolMessageWriter, ProtocolMessageWriter)).once();
         verify(serviceManager.addSingleton<IBufferDecoder>(IBufferDecoder, BufferDecoder)).once();
diff --git a/src/test/mocks/vsc/index.ts b/src/test/mocks/vsc/index.ts
index c7df9e7c2148..8e5edfb699d1 100644
--- a/src/test/mocks/vsc/index.ts
+++ b/src/test/mocks/vsc/index.ts
@@ -183,4 +183,11 @@ export namespace vscMock {
     export class DebugAdapterExecutable {
         constructor(public readonly command: string, public readonly args: string[] = [], public readonly options?: DebugAdapterExecutableOptions) { }
     }
+
+    export enum FileType {
+        Unknown = 0,
+        File = 1,
+        Directory = 2,
+        SymbolicLink = 64
+    }
 }
diff --git a/src/test/vscode-mock.ts b/src/test/vscode-mock.ts
index be2f0c367624..18e56f318b40 100644
--- a/src/test/vscode-mock.ts
+++ b/src/test/vscode-mock.ts
@@ -82,6 +82,7 @@ mockedVSCode.CodeActionKind = vscodeMocks.vscMock.CodeActionKind;
 mockedVSCode.DebugAdapterExecutable = vscodeMocks.vscMock.DebugAdapterExecutable;
 mockedVSCode.DebugAdapterServer = vscodeMocks.vscMock.DebugAdapterServer;
 mockedVSCode.QuickInputButtons = vscodeMocks.vscMockExtHostedTypes.QuickInputButtons;
+mockedVSCode.FileType = vscodeMocks.vscMock.FileType;
 
 // This API is used in src/client/telemetry/telemetry.ts
 const extensions = TypeMoq.Mock.ofType<typeof vscode.extensions>();