protected projectService: server.ProjectService;

constructor(

readonly globalTypingsCacheLocation: string,

throttleLimit: number,

installTypingHost: server.ServerHost,

readonly typesRegistry = createMap<void>(),

log?: TI.Log) {

super(installTypingHost, globalTypingsCacheLocation, safeList.path, throttleLimit, log);

}

protected postExecActions: PostExecAction[] = [];

executePendingCommands() {

const actionsToRun = this.postExecActions;

this.postExecActions = [];

for (const action of actionsToRun) {

action.callback(action.success);

}

}

checkPendingCommands(expectedCount: number) {

assert.equal(this.postExecActions.length, expectedCount, `Expected ${expectedCount} post install actions`);

}

onProjectClosed() {

}

attach(projectService: server.ProjectService) {

this.projectService = projectService;

}

getInstallTypingHost() {

return this.installTypingHost;

}

installWorker(_requestId: number, _args: string[], _cwd: string, cb: TI.RequestCompletedAction): void {

this.addPostExecAction("success", cb);

}

sendResponse(response: server.SetTypings | server.InvalidateCachedTypings) {

this.projectService.updateTypingsForProject(response);

}

enqueueInstallTypingsRequest(project: server.Project, typeAcquisition: TypeAcquisition, unresolvedImports: server.SortedReadonlyArray<string>) {

const request = server.createInstallTypingsRequest(project, typeAcquisition, unresolvedImports, this.globalTypingsCacheLocation);

this.install(request);

}

addPostExecAction(stdout: string | string[], cb: TI.RequestCompletedAction) {

const out = typeof stdout === "string" ? stdout : createNpmPackageJsonString(stdout);

const action: PostExecAction = {

success: !!out,

callback: cb

};

this.postExecActions.push(action);

}

const dependencies: MapLike<any> = {};

for (const typing of installedTypings) {

dependencies[typing] = "1.0.0";

}

return JSON.stringify({ dependencies });

public events: server.ProjectServiceEvent[] = [];

handler: server.ProjectServiceEventHandler = (event: server.ProjectServiceEvent) => {

this.events.push(event);

}

checkEventCountOfType(eventType: "context" | "configFileDiag", expectedCount: number) {

const eventsOfType = filter(this.events, e => e.eventName === eventType);

assert.equal(eventsOfType.length, expectedCount, `The actual event counts of type ${eventType} is ${eventsOfType.length}, while expected ${expectedCount}`);

}

useCaseSensitiveFileNames?: boolean;

executingFilePath?: string;

currentDirectory?: string;

newLine?: string;

if (!params) {

params = {};

}

const host = new TestServerHost(

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

params.executingFilePath || getExecutingFilePathFromLibFile(),

params.currentDirectory || "/",

fileOrFolderList,

params.newLine);

return host;

private seq = 0;

getProjectService() {

return this.projectService;

}

public getSeq() {

return this.seq;

}

public getNextSeq() {

return this.seq + 1;

}

public executeCommandSeq<T extends server.protocol.Request>(request: Partial<T>) {

this.seq++;

request.seq = this.seq;

request.type = "request";

return this.executeCommand(<T>request);

}

if (typingsInstaller === undefined) {

typingsInstaller = new TestTypingsInstaller("/a/data/", /*throttleLimit*/5, host);

}

const opts: server.SessionOptions = {

host,

cancellationToken: cancellationToken || server.nullCancellationToken,

useSingleInferredProject: false,

typingsInstaller,

byteLength: Utils.byteLength,

hrtime: process.hrtime,

logger: nullLogger,

canUseEvents: projectServiceEventHandler !== undefined,

eventHandler: projectServiceEventHandler,

throttleWaitMilliseconds

};

return new TestSession(opts);

cancellationToken?: HostCancellationToken;

logger?: server.Logger;

useSingleInferredProject?: boolean;

typingsInstaller?: server.ITypingsInstaller;

eventHandler?: server.ProjectServiceEventHandler;

constructor(host: server.ServerHost, logger: server.Logger, cancellationToken: HostCancellationToken, useSingleInferredProject: boolean,

typingsInstaller: server.ITypingsInstaller, eventHandler: server.ProjectServiceEventHandler) {

super({

host, logger, cancellationToken, useSingleInferredProject, typingsInstaller, eventHandler

});

}

checkNumberOfProjects(count: { inferredProjects?: number, configuredProjects?: number, externalProjects?: number }) {

checkNumberOfProjects(this, count);

}

const cancellationToken = parameters.cancellationToken || server.nullCancellationToken;

const logger = parameters.logger || nullLogger;

const useSingleInferredProject = parameters.useSingleInferredProject !== undefined ? parameters.useSingleInferredProject : false;

return new TestProjectService(host, logger, cancellationToken, useSingleInferredProject, parameters.typingsInstaller, parameters.eventHandler);

path: string;

content?: string;

fileSize?: number;

const path = toPath(fullPath);

if (fs.has(path)) {

Debug.assert(isFolder(fs.get(path)));

return (<Folder>fs.get(path));

}

const entry: Folder = { path, entries: [], fullPath };

fs.set(path, entry);

const baseFullPath = getDirectoryPath(fullPath);

if (fullPath !== baseFullPath) {

addFolder(baseFullPath, toPath, fs).entries.push(entry);

}

return entry;

assert.equal(map.size, expectedKeys.length, `${caption}: incorrect size of map`);

for (const name of expectedKeys) {

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

}

assert.equal(actualFileNames.length, expectedFileNames.length, `${caption}: incorrect actual number of files, expected ${JSON.stringify(expectedFileNames)}, got ${actualFileNames}`);

for (const f of expectedFileNames) {

assert.isTrue(contains(actualFileNames, f), `${caption}: expected to find ${f} in ${JSON.stringify(actualFileNames)}`);

}

checkNumberOfConfiguredProjects(projectService, count.configuredProjects || 0);

checkNumberOfExternalProjects(projectService, count.externalProjects || 0);

checkNumberOfInferredProjects(projectService, count.inferredProjects || 0);

private map: TimeOutCallback[] = [];

private nextId = 1;

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() {

// 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];

}

}

args: string[] = [];

private readonly output: string[] = [];

private fs: Map<FSEntry>;

private getCanonicalFileName: (s: string) => string;

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

private timeoutCallbacks = new Callbacks();

private immediateCallbacks = new Callbacks();

readonly watchedDirectories = createMultiMap<{ cb: DirectoryWatcherCallback, recursive: boolean }>();

readonly watchedFiles = createMultiMap<FileWatcherCallback>();

private filesOrFolders: FileOrFolder[];

constructor(public useCaseSensitiveFileNames: boolean, private executingFilePath: string, private currentDirectory: string, fileOrFolderList: FileOrFolder[], public readonly newLine = "\n") {

this.getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);

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

this.reloadFS(fileOrFolderList);

}

reloadFS(filesOrFolders: FileOrFolder[]) {

this.filesOrFolders = filesOrFolders;

this.fs = createMap<FSEntry>();

// always inject safelist file in the list of files

for (const fileOrFolder of filesOrFolders.concat(safeList)) {

const path = this.toPath(fileOrFolder.path);

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

if (typeof fileOrFolder.content === "string") {

const entry = { path, content: fileOrFolder.content, fullPath, fileSize: fileOrFolder.fileSize };

this.fs.set(path, entry);

addFolder(getDirectoryPath(fullPath), this.toPath, this.fs).entries.push(entry);

}

else {

addFolder(fullPath, this.toPath, this.fs);

}

}

}

fileExists(s: string) {

const path = this.toPath(s);

return this.fs.has(path) && isFile(this.fs.get(path));

}

getFileSize(s: string) {

const path = this.toPath(s);

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

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

if (isFile(entry)) {

return entry.fileSize ? entry.fileSize : entry.content.length;

}

}

return undefined;

}

directoryExists(s: string) {

const path = this.toPath(s);

return this.fs.has(path) && isFolder(this.fs.get(path));

}

getDirectories(s: string) {

const path = this.toPath(s);

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

return [];

}

else {

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

return isFolder(entry) ? map(entry.entries, x => getBaseFileName(x.fullPath)) : [];

}

}

readDirectory(path: string, extensions?: ReadonlyArray<string>, exclude?: ReadonlyArray<string>, include?: ReadonlyArray<string>, depth?: number): string[] {

return ts.matchFiles(path, extensions, exclude, include, this.useCaseSensitiveFileNames, this.getCurrentDirectory(), depth, (dir) => {

const directories: string[] = [];

const files: string[] = [];

const dirEntry = this.fs.get(this.toPath(dir));

if (isFolder(dirEntry)) {

dirEntry.entries.forEach((entry) => {

if (isFolder(entry)) {

directories.push(entry.fullPath);

}

else if (isFile(entry)) {

files.push(entry.fullPath);

}

});

}

return { directories, files };

});

}

watchDirectory(directoryName: string, callback: DirectoryWatcherCallback, recursive: boolean): DirectoryWatcher {

const path = this.toPath(directoryName);

const cbWithRecursive = { cb: callback, recursive };

this.watchedDirectories.add(path, cbWithRecursive);

return {

referenceCount: 0,

directoryName,

close: () => this.watchedDirectories.remove(path, cbWithRecursive)

};

}

createHash(s: string): string {

return Harness.LanguageService.mockHash(s);

}

triggerDirectoryWatcherCallback(directoryName: string, fileName: string): void {

const path = this.toPath(directoryName);

const callbacks = this.watchedDirectories.get(path);

if (callbacks) {

for (const callback of callbacks) {

callback.cb(fileName);

}

}

}

triggerFileWatcherCallback(fileName: string, eventKind: FileWatcherEventKind): void {

const path = this.toPath(fileName);

const callbacks = this.watchedFiles.get(path);

if (callbacks) {

for (const callback of callbacks) {

callback(path, eventKind);

}

}

}

watchFile(fileName: string, callback: FileWatcherCallback) {

const path = this.toPath(fileName);

this.watchedFiles.add(path, callback);

return { close: () => this.watchedFiles.remove(path, callback) };

}

// TOOD: record and invoke callbacks to simulate timer events

setTimeout(callback: TimeOutCallback, _time: number, ...args: any[]) {

return this.timeoutCallbacks.register(callback, args);

}

clearTimeout(timeoutId: any): void {

this.timeoutCallbacks.unregister(timeoutId);

}

checkTimeoutQueueLength(expected: number) {

const callbacksCount = this.timeoutCallbacks.count();

assert.equal(callbacksCount, expected, `expected ${expected} timeout callbacks queued but found ${callbacksCount}.`);

}

runQueuedTimeoutCallbacks() {

this.timeoutCallbacks.invoke();

}

runQueuedImmediateCallbacks() {

this.immediateCallbacks.invoke();

}

setImmediate(callback: TimeOutCallback, _time: number, ...args: any[]) {

return this.immediateCallbacks.register(callback, args);

}

clearImmediate(timeoutId: any): void {

this.immediateCallbacks.unregister(timeoutId);

}

createDirectory(directoryName: string): void {

this.createFileOrFolder({ path: directoryName });

}

writeFile(path: string, content: string): void {

this.createFileOrFolder({ path, content, fileSize: content.length });

}

createFileOrFolder(f: FileOrFolder, createParentDirectory = false): void {

const base = getDirectoryPath(f.path);

if (base !== f.path && !this.directoryExists(base)) {

if (createParentDirectory) {

// TODO: avoid reloading FS on every creation

this.createFileOrFolder({ path: base }, createParentDirectory);

}

else {

throw new Error(`directory ${base} does not exist`);

}

}

const filesOrFolders = this.filesOrFolders.slice(0);

filesOrFolders.push(f);

this.reloadFS(filesOrFolders);

}

write(message: string) {

this.output.push(message);

}

getOutput(): ReadonlyArray<string> {

return this.output;

}

clearOutput() {

this.output.length = 0;

}

readonly readFile = (s: string) => (<File>this.fs.get(this.toPath(s))).content;

readonly resolvePath = (s: string) => s;

readonly getExecutingFilePath = () => this.executingFilePath;

readonly getCurrentDirectory = () => this.currentDirectory;

readonly exit = notImplemented;

readonly getEnvironmentVariable = notImplemented;

private currentId = -1;

private requestToCancel = -1;

private isCancellationRequestedCount = 0;

constructor(private cancelAfterRequest = 0) {

}

setRequest(requestId: number) {

this.currentId = requestId;

}

setRequestToCancel(requestId: number) {

this.resetToken();

this.requestToCancel = requestId;

}

resetRequest(requestId: number) {

assert.equal(requestId, this.currentId, "unexpected request id in cancellation");

this.currentId = undefined;

}

isCancellationRequested() {

this.isCancellationRequestedCount++;

// If the request id is the request to cancel and isCancellationRequestedCount

// has been met then cancel the request. Ex: cancel the request if it is a

// nav bar request & isCancellationRequested() has already been called three times.

return this.requestToCancel === this.currentId && this.isCancellationRequestedCount >= this.cancelAfterRequest;

}

resetToken() {

this.currentId = -1;

this.isCancellationRequestedCount = 0;

this.requestToCancel = -1;

}

const newRequest: protocol.Request = {

seq: 0,

type: "request",

command,

arguments: args

};

return newRequest;

for (const file of files) {

const request = makeSessionRequest<protocol.OpenRequestArgs>(CommandNames.Open, { file: file.path });

session.executeCommand(request);

}