useCaseSensitiveFileNames?: boolean;

executingFilePath?: string;

currentDirectory?: string;

newLine?: string;

useWindowsStylePaths?: boolean;

environmentVariables?: Map<string>;

if (!params) {

params = {};

}

const host = new TestServerHost(/*withSafelist*/ false,

params.useCaseSensitiveFileNames !== undefined ? params.useCaseSensitiveFileNames : false,

params.executingFilePath || getExecutingFilePathFromLibFile(),

params.currentDirectory || "/",

fileOrFolderList,

params.newLine,

params.useWindowsStylePaths,

params.environmentVariables);

return host;

if (!params) {

params = {};

}

const host = new TestServerHost(/*withSafelist*/ true,

params.useCaseSensitiveFileNames !== undefined ? params.useCaseSensitiveFileNames : false,

params.executingFilePath || getExecutingFilePathFromLibFile(),

params.currentDirectory || "/",

fileOrFolderList,

params.newLine,

params.useWindowsStylePaths,

params.environmentVariables);

return host;

path: string;

content: string;

fileSize?: number;

/** Location of the symlink. */

path: string;

/** Relative path to the real file. */

symLink: string;

path: Path;

fullPath: string;

modifiedTime: Date;

if (callbacks) {

// The array copy is made to ensure that even if one of the callback removes the callbacks,

// we dont miss any callbacks following it

const cbs = callbacks.slice();

for (const cb of cbs) {

invokeCallback(cb);

}

}

if (map.size === expectedKeys.length) {

return "";

}

const notInActual: string[] = [];

const duplicates: string[] = [];

const seen = createMap<true>();

forEach(expectedKeys, expectedKey => {

if (seen.has(expectedKey)) {

duplicates.push(expectedKey);

return;

}

seen.set(expectedKey, true);

if (!map.has(expectedKey)) {

notInActual.push(expectedKey);

}

});

const inActualNotExpected: string[] = [];

map.forEach((_value, key) => {

if (!seen.has(key)) {

inActualNotExpected.push(key);

}

seen.set(key, true);

});

return `\n\nNotInActual: ${notInActual}\nDuplicates: ${duplicates}\nInActualButNotInExpected: ${inActualNotExpected}`;

verifyMapSize(caption, map, expectedKeys);

for (const name of expectedKeys) {

assert.isTrue(map.has(name), `${caption} is expected to contain ${name}, actual keys: ${arrayFrom(map.keys())}`);

}

const expectedKeys = isArray(expectedKeysMapOrArray) ? arrayToMap(expectedKeysMapOrArray, s => s, () => eachKeyCount!) : expectedKeysMapOrArray;

verifyMapSize(caption, actual, arrayFrom(expectedKeys.keys()));

expectedKeys.forEach((count, name) => {

assert.isTrue(actual.has(name), `${caption}: expected to contain ${name}, actual keys: ${arrayFrom(actual.keys())}`);

assert.equal(actual.get(name)!.length, count, `${caption}: Expected to be have ${count} entries for ${name}. Actual entry: ${JSON.stringify(actual.get(name))}`);

});

assert.equal(actual.length, expected.length, `${caption}: incorrect actual number of files, expected:\r\n${expected.join("\r\n")}\r\ngot: ${actual.join("\r\n")}`);

for (const f of expected) {

assert.equal(true, contains(actual, f), `${caption}: expected to find ${f} in ${actual}`);

}

if (isArray(expectedFiles)) {

checkMultiMapKeyCount("watchedFiles", host.watchedFiles, expectedFiles, eachFileWatchCount!);

}

else {

checkMultiMapKeyCount("watchedFiles", host.watchedFiles, expectedFiles);

}

if (isArray(expectedDirectories)) {

checkMultiMapKeyCount(`watchedDirectories${recursive ? " recursive" : ""}`, recursive ? host.watchedDirectoriesRecursive : host.watchedDirectories, expectedDirectories, recursiveOrEachDirectoryWatchCount as number);

}

else {

recursive = recursiveOrEachDirectoryWatchCount as boolean;

checkMultiMapKeyCount(`watchedDirectories${recursive ? " recursive" : ""}`, recursive ? host.watchedDirectoriesRecursive : host.watchedDirectories, expectedDirectories);

}

const mapExpected = arrayToSet(expected);

const mapSeen = createMap<true>();

for (const f of host.getOutput()) {

assert.isUndefined(mapSeen.get(f), `Already found ${f} in ${JSON.stringify(host.getOutput())}`);

if (mapExpected.has(f)) {

mapExpected.delete(f);

mapSeen.set(f, true);

}

}

assert.equal(mapExpected.size, 0, `Output has missing ${JSON.stringify(arrayFrom(mapExpected.keys()))} in ${JSON.stringify(host.getOutput())}`);

const mapExpectedToBeAbsent = arrayToSet(expectedToBeAbsent);

for (const f of host.getOutput()) {

assert.isFalse(mapExpectedToBeAbsent.has(f), `Contains ${f} in ${JSON.stringify(host.getOutput())}`);

}

private map: TimeOutCallback[] = [];

private nextId = 1;

getNextId() {

return this.nextId;

}

register(cb: (...args: any[]) => void, args: any[]) {

const timeoutId = this.nextId;

this.nextId++;

this.map[timeoutId] = cb.bind(/*this*/ undefined, ...args);

return timeoutId;

}

unregister(id: any) {

if (typeof id === "number") {

delete this.map[id];

}

}

count() {

let n = 0;

for (const _ in this.map) {

n++;

}

return n;

}

invoke(invokeKey?: number) {

if (invokeKey) {

this.map[invokeKey]();

delete this.map[invokeKey];

return;

}

// Note: invoking a callback may result in new callbacks been queued,

// so do not clear the entire callback list regardless. Only remove the

// ones we have invoked.

for (const key in this.map) {

this.map[key]();

delete this.map[key];

}

}

/** Invokes the directory watcher for the parent instead of the file changed */

invokeDirectoryWatcherInsteadOfFileChanged: boolean;

/** When new file is created, do not invoke watches for it */

ignoreWatchInvokedWithTriggerAsFileCreate: boolean;

/** Invoke the file delete, followed by create instead of file changed */

invokeFileDeleteCreateAsPartInsteadOfChange: boolean;

WatchFile = "RecursiveDirectoryUsingFsWatchFile",

NonRecursiveWatchDirectory = "RecursiveDirectoryUsingNonRecursiveWatchDirectory",

DynamicPolling = "RecursiveDirectoryUsingDynamicPriorityPolling"

args: string[] = [];

private readonly output: string[] = [];

private fs: Map<FSEntry> = createMap<FSEntry>();

private time = timeIncrements;

getCanonicalFileName: (s: string) => string;

private toPath: (f: string) => Path;

private timeoutCallbacks = new Callbacks();

private immediateCallbacks = new Callbacks();

readonly screenClears: number[] = [];

readonly watchedDirectories = createMultiMap<TestDirectoryWatcher>();

readonly watchedDirectoriesRecursive = createMultiMap<TestDirectoryWatcher>();

readonly watchedFiles = createMultiMap<TestFileWatcher>();

private readonly executingFilePath: string;

private readonly currentDirectory: string;

private readonly dynamicPriorityWatchFile: HostWatchFile | undefined;

private readonly customRecursiveWatchDirectory: HostWatchDirectory | undefined;

constructor(public withSafeList: boolean, public useCaseSensitiveFileNames: boolean, executingFilePath: string, currentDirectory: string, fileOrFolderorSymLinkList: ReadonlyArray<FileOrFolderOrSymLink>, public readonly newLine = "\n", public readonly useWindowsStylePath?: boolean, private readonly environmentVariables?: Map<string>) {

this.getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);

this.toPath = s => toPath(s, currentDirectory, this.getCanonicalFileName);

this.executingFilePath = this.getHostSpecificPath(executingFilePath);

this.currentDirectory = this.getHostSpecificPath(currentDirectory);

this.reloadFS(fileOrFolderorSymLinkList);

this.dynamicPriorityWatchFile = this.environmentVariables && this.environmentVariables.get("TSC_WATCHFILE") === "DynamicPriorityPolling" ?

createDynamicPriorityPollingWatchFile(this) :

undefined;

const tscWatchDirectory = this.environmentVariables && this.environmentVariables.get("TSC_WATCHDIRECTORY") as Tsc_WatchDirectory;

if (tscWatchDirectory === Tsc_WatchDirectory.WatchFile) {

const watchDirectory: HostWatchDirectory = (directory, cb) => this.watchFile(directory, () => cb(directory), PollingInterval.Medium);

this.customRecursiveWatchDirectory = createRecursiveDirectoryWatcher({

useCaseSensitiveFileNames: this.useCaseSensitiveFileNames,

directoryExists: path => this.directoryExists(path),

getAccessibleSortedChildDirectories: path => this.getDirectories(path),

watchDirectory,

realpath: s => this.realpath(s)

});

}

else if (tscWatchDirectory === Tsc_WatchDirectory.NonRecursiveWatchDirectory) {

const watchDirectory: HostWatchDirectory = (directory, cb) => this.watchDirectory(directory, fileName => cb(fileName), /*recursive*/ false);

this.customRecursiveWatchDirectory = createRecursiveDirectoryWatcher({

useCaseSensitiveFileNames: this.useCaseSensitiveFileNames,

directoryExists: path => this.directoryExists(path),

getAccessibleSortedChildDirectories: path => this.getDirectories(path),

watchDirectory,

realpath: s => this.realpath(s)

});

}

else if (tscWatchDirectory === Tsc_WatchDirectory.DynamicPolling) {

const watchFile = createDynamicPriorityPollingWatchFile(this);

const watchDirectory: HostWatchDirectory = (directory, cb) => watchFile(directory, () => cb(directory), PollingInterval.Medium);

this.customRecursiveWatchDirectory = createRecursiveDirectoryWatcher({

useCaseSensitiveFileNames: this.useCaseSensitiveFileNames,

directoryExists: path => this.directoryExists(path),

getAccessibleSortedChildDirectories: path => this.getDirectories(path),

watchDirectory,

realpath: s => this.realpath(s)

});

}

}

getNewLine() {

return this.newLine;

}

toNormalizedAbsolutePath(s: string) {

return getNormalizedAbsolutePath(s, this.currentDirectory);

}

toFullPath(s: string) {

return this.toPath(this.toNormalizedAbsolutePath(s));

}

getHostSpecificPath(s: string) {

if (this.useWindowsStylePath && s.startsWith(directorySeparator)) {

return "c:/" + s.substring(1);

}

return s;

}

private now() {

this.time += timeIncrements;

return new Date(this.time);

}

reloadFS(fileOrFolderOrSymLinkList: ReadonlyArray<FileOrFolderOrSymLink>, options?: Partial<ReloadWatchInvokeOptions>) {

const mapNewLeaves = createMap<true>();

const isNewFs = this.fs.size === 0;

fileOrFolderOrSymLinkList = fileOrFolderOrSymLinkList.concat(this.withSafeList ? safeList : []);

const filesOrFoldersToLoad: ReadonlyArray<FileOrFolderOrSymLink> = !this.useWindowsStylePath ? fileOrFolderOrSymLinkList :

fileOrFolderOrSymLinkList.map<FileOrFolderOrSymLink>(f => {

const result = clone(f);

result.path = this.getHostSpecificPath(f.path);

return result;

});

for (const fileOrDirectory of filesOrFoldersToLoad) {

const path = this.toFullPath(fileOrDirectory.path);

mapNewLeaves.set(path, true);

// If its a change

const currentEntry = this.fs.get(path);

if (currentEntry) {

if (isFsFile(currentEntry)) {

if (isFile(fileOrDirectory)) {

// Update file

if (currentEntry.content !== fileOrDirectory.content) {

this.modifyFile(fileOrDirectory.path, fileOrDirectory.content, options);

}

}

else {

// TODO: Changing from file => folder/Symlink

}

}

else if (isFsSymLink(currentEntry)) {

// TODO: update symlinks

}

else {

// Folder

if (isFile(fileOrDirectory)) {

// TODO: Changing from folder => file

}

else {

// Folder update: Nothing to do.

currentEntry.modifiedTime = this.now();

}

}

}

else {

this.ensureFileOrFolder(fileOrDirectory, options && options.ignoreWatchInvokedWithTriggerAsFileCreate);

}

}

if (!isNewFs) {

this.fs.forEach((fileOrDirectory, path) => {

// If this entry is not from the new file or folder

if (!mapNewLeaves.get(path)) {

// Leaf entries that arent in new list => remove these

if (isFsFile(fileOrDirectory) || isFsSymLink(fileOrDirectory) || isFsFolder(fileOrDirectory) && fileOrDirectory.entries.length === 0) {

this.removeFileOrFolder(fileOrDirectory, folder => !mapNewLeaves.get(folder.path));

}

}

});

}

}

modifyFile(filePath: string, content: string, options?: Partial<ReloadWatchInvokeOptions>) {

const path = this.toFullPath(filePath);

const currentEntry = this.fs.get(path);

if (!currentEntry || !isFsFile(currentEntry)) {

throw new Error(`file not present: ${filePath}`);

}

if (options && options.invokeFileDeleteCreateAsPartInsteadOfChange) {

this.removeFileOrFolder(currentEntry, returnFalse);

this.ensureFileOrFolder({ path: filePath, content });

}

else {

currentEntry.content = content;

currentEntry.modifiedTime = this.now();

this.fs.get(getDirectoryPath(currentEntry.path))!.modifiedTime = this.now();

if (options && options.invokeDirectoryWatcherInsteadOfFileChanged) {

this.invokeDirectoryWatcher(getDirectoryPath(currentEntry.fullPath), currentEntry.fullPath);

}

else {

this.invokeFileWatcher(currentEntry.fullPath, FileWatcherEventKind.Changed);

}

}

}

renameFolder(folderName: string, newFolderName: string) {

const fullPath = getNormalizedAbsolutePath(folderName, this.currentDirectory);

const path = this.toPath(fullPath);

const folder = this.fs.get(path) as FsFolder;

Debug.assert(!!folder);

// Only remove the folder

this.removeFileOrFolder(folder, returnFalse, /*isRenaming*/ true);

// Add updated folder with new folder name

const newFullPath = getNormalizedAbsolutePath(newFolderName, this.currentDirectory);

const newFolder = this.toFsFolder(newFullPath);

const newPath = newFolder.path;

const basePath = getDirectoryPath(path);

Debug.assert(basePath !== path);

Debug.assert(basePath === getDirectoryPath(newPath));

const baseFolder = this.fs.get(basePath) as FsFolder;

this.addFileOrFolderInFolder(baseFolder, newFolder);

// Invoke watches for files in the folder as deleted (from old path)

this.renameFolderEntries(folder, newFolder);

}

private renameFolderEntries(oldFolder: FsFolder, newFolder: FsFolder) {

for (const entry of oldFolder.entries) {

this.fs.delete(entry.path);

this.invokeFileWatcher(entry.fullPath, FileWatcherEventKind.Deleted);

entry.fullPath = combinePaths(newFolder.fullPath, getBaseFileName(entry.fullPath));

entry.path = this.toPath(entry.fullPath);

if (newFolder !== oldFolder) {

newFolder.entries.push(entry);

}

this.fs.set(entry.path, entry);

this.invokeFileWatcher(entry.fullPath, FileWatcherEventKind.Created);

if (isFsFolder(entry)) {

this.renameFolderEntries(entry, entry);

}

}

}

ensureFileOrFolder(fileOrDirectoryOrSymLink: FileOrFolderOrSymLink, ignoreWatchInvokedWithTriggerAsFileCreate?: boolean) {

if (isFile(fileOrDirectoryOrSymLink)) {

const file = this.toFsFile(fileOrDirectoryOrSymLink);

// file may already exist when updating existing type declaration file

if (!this.fs.get(file.path)) {

const baseFolder = this.ensureFolder(getDirectoryPath(file.fullPath));

this.addFileOrFolderInFolder(baseFolder, file, ignoreWatchInvokedWithTriggerAsFileCreate);

}

}

else if (isSymLink(fileOrDirectoryOrSymLink)) {

const symLink = this.toFsSymLink(fileOrDirectoryOrSymLink);

Debug.assert(!this.fs.get(symLink.path));

const baseFolder = this.ensureFolder(getDirectoryPath(symLink.fullPath));

this.addFileOrFolderInFolder(baseFolder, symLink, ignoreWatchInvokedWithTriggerAsFileCreate);

}

else {

const fullPath = getNormalizedAbsolutePath(fileOrDirectoryOrSymLink.path, this.currentDirectory);

this.ensureFolder(fullPath);

}

}

private ensureFolder(fullPath: string): FsFolder {

const path = this.toPath(fullPath);

let folder = this.fs.get(path) as FsFolder;

if (!folder) {

folder = this.toFsFolder(fullPath);

const baseFullPath = getDirectoryPath(fullPath);

if (fullPath !== baseFullPath) {

// Add folder in the base folder

const baseFolder = this.ensureFolder(baseFullPath);

this.addFileOrFolderInFolder(baseFolder, folder);

}

else {

// root folder

Debug.assert(this.fs.size === 0);

this.fs.set(path, folder);

}

}

Debug.assert(isFsFolder(folder));

return folder;

}

private addFileOrFolderInFolder(folder: FsFolder, fileOrDirectory: FsFile | FsFolder | FsSymLink, ignoreWatch?: boolean) {

if (!this.fs.has(fileOrDirectory.path)) {

insertSorted(folder.entries, fileOrDirectory, (a, b) => compareStringsCaseSensitive(getBaseFileName(a.path), getBaseFileName(b.path)));

}

folder.modifiedTime = this.now();

this.fs.set(fileOrDirectory.path, fileOrDirectory);

if (ignoreWatch) {

return;

}

this.invokeFileWatcher(fileOrDirectory.fullPath, FileWatcherEventKind.Created);

if (isFsFolder(fileOrDirectory)) {

this.invokeDirectoryWatcher(fileOrDirectory.fullPath, "");

this.invokeWatchedDirectoriesRecursiveCallback(fileOrDirectory.fullPath, "");

}

this.invokeDirectoryWatcher(folder.fullPath, fileOrDirectory.fullPath);

}

private removeFileOrFolder(fileOrDirectory: FsFile | FsFolder | FsSymLink, isRemovableLeafFolder: (folder: FsFolder) => boolean, isRenaming = false) {

const basePath = getDirectoryPath(fileOrDirectory.path);

const baseFolder = this.fs.get(basePath) as FsFolder;

if (basePath !== fileOrDirectory.path) {

Debug.assert(!!baseFolder);

baseFolder.modifiedTime = this.now();

filterMutate(baseFolder.entries, entry => entry !== fileOrDirectory);

}

this.fs.delete(fileOrDirectory.path);

this.invokeFileWatcher(fileOrDirectory.fullPath, FileWatcherEventKind.Deleted);

if (isFsFolder(fileOrDirectory)) {

Debug.assert(fileOrDirectory.entries.length === 0 || isRenaming);

// Invoke directory and recursive directory watcher for the folder

// Here we arent invoking recursive directory watchers for the base folders

// since that is something we would want to do for both file as well as folder we are deleting

this.invokeWatchedDirectoriesCallback(fileOrDirectory.fullPath, "");

this.invokeWatchedDirectoriesRecursiveCallback(fileOrDirectory.fullPath, "");

}

if (basePath !== fileOrDirectory.path) {

if (baseFolder.entries.length === 0 && isRemovableLeafFolder(baseFolder)) {

this.removeFileOrFolder(baseFolder, isRemovableLeafFolder);

}

else {

this.invokeRecursiveDirectoryWatcher(baseFolder.fullPath, fileOrDirectory.fullPath);

}

}

}

deleteFile(filePath: string) {

const path = this.toFullPath(filePath);

const currentEntry = this.fs.get(path) as FsFile;

Debug.assert(isFsFile(currentEntry));

this.removeFileOrFolder(currentEntry, returnFalse);

}

deleteFolder(folderPath: string, recursive?: boolean) {

const path = this.toFullPath(folderPath);

const currentEntry = this.fs.get(path) as FsFolder;

Debug.assert(isFsFolder(currentEntry));

if (recursive && currentEntry.entries.length) {

const subEntries = currentEntry.entries.slice();

subEntries.forEach(fsEntry => {

if (isFsFolder(fsEntry)) {

this.deleteFolder(fsEntry.fullPath, recursive);

}

else {

this.removeFileOrFolder(fsEntry, returnFalse);

}

});

}

this.removeFileOrFolder(currentEntry, returnFalse);

}

// For overriding the methods

invokeWatchedDirectoriesCallback(folderFullPath: string, relativePath: string) {

invokeWatcherCallbacks(this.watchedDirectories.get(this.toPath(folderFullPath))!, cb => this.directoryCallback(cb, relativePath));

}

invokeWatchedDirectoriesRecursiveCallback(folderFullPath: string, relativePath: string) {

invokeWatcherCallbacks(this.watchedDirectoriesRecursive.get(this.toPath(folderFullPath))!, cb => this.directoryCallback(cb, relativePath));

}

invokeFileWatcher(fileFullPath: string, eventKind: FileWatcherEventKind, useFileNameInCallback?: boolean) {

invokeWatcherCallbacks(this.watchedFiles.get(this.toPath(fileFullPath))!, ({ cb, fileName }) => cb(useFileNameInCallback ? fileName : fileFullPath, eventKind));

}

private getRelativePathToDirectory(directoryFullPath: string, fileFullPath: string) {

return getRelativePathToDirectoryOrUrl(directoryFullPath, fileFullPath, this.currentDirectory, this.getCanonicalFileName, /*isAbsolutePathAnUrl*/ false);

}

/**

private invokeDirectoryWatcher(folderFullPath: string, fileName: string) {

const relativePath = this.getRelativePathToDirectory(folderFullPath, fileName);

// Folder is changed when the directory watcher is invoked

this.invokeFileWatcher(folderFullPath, FileWatcherEventKind.Changed, /*useFileNameInCallback*/ true);

this.invokeWatchedDirectoriesCallback(folderFullPath, relativePath);

this.invokeRecursiveDirectoryWatcher(folderFullPath, fileName);

}

private directoryCallback({ cb, directoryName }: TestDirectoryWatcher, relativePath: string) {

cb(combinePaths(directoryName, relativePath));

}

/**

private invokeRecursiveDirectoryWatcher(fullPath: string, fileName: string) {

const relativePath = this.getRelativePathToDirectory(fullPath, fileName);

this.invokeWatchedDirectoriesRecursiveCallback(fullPath, relativePath);