//

// Copyright (c) Microsoft Corporation. All rights reserved.

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

// http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

//

/// <reference path="..\services\services.ts" />

/// <reference path="..\services\shims.ts" />

/// <reference path="harnessLanguageService.ts" />

/// <reference path="harness.ts" />

/// <reference path="fourslashRunner.ts" />

/* tslint:disable:no-null-keyword */

namespace FourSlash {

ts.disableIncrementalParsing = false;

// Represents a parsed source file with metadata

export interface FourSlashFile {

// The contents of the file (with markers, etc stripped out)

content: string;

fileName: string;

version: number;

// File-specific options (name/value pairs)

fileOptions: Harness.TestCaseParser.CompilerSettings;

}

// Represents a set of parsed source files and options

export interface FourSlashData {

// Global options (name/value pairs)

globalOptions: Harness.TestCaseParser.CompilerSettings;

files: FourSlashFile[];

// A mapping from marker names to name/position pairs

markerPositions: { [index: string]: Marker; };

markers: Marker[];

ranges: Range[];

}

interface MemberListData {

result: {

maybeInaccurate: boolean;

isMemberCompletion: boolean;

entries: {

name: string;

type: string;

kind: string;

kindModifiers: string;

}[];

};

}

export interface Marker {

fileName: string;

position: number;

data?: any;

}

interface MarkerMap {

[index: string]: Marker;

}

export interface Range {

fileName: string;

start: number;

end: number;

marker?: Marker;

}

interface LocationInformation {

position: number;

sourcePosition: number;

sourceLine: number;

sourceColumn: number;

}

interface RangeLocationInformation extends LocationInformation {

marker?: Marker;

}

export interface TextSpan {

start: number;

end: number;

}

export import IndentStyle = ts.IndentStyle;

const entityMap: ts.Map<string> = {

"&": "&amp;",

"\"": "&quot;",

"'": "&#39;",

"/": "&#47;",

"<": "&lt;",

">": "&gt;"

};

export function escapeXmlAttributeValue(s: string) {

return s.replace(/[&<>"'\/]/g, ch => entityMap[ch]);

}

// Name of testcase metadata including ts.CompilerOptions properties that will be used by globalOptions

// To add additional option, add property into the testOptMetadataNames, refer the property in either globalMetadataNames or fileMetadataNames

// Add cases into convertGlobalOptionsToCompilationsSettings function for the compiler to acknowledge such option from meta data

const metadataOptionNames = {

baselineFile: "BaselineFile",

emitThisFile: "emitThisFile", // This flag is used for testing getEmitOutput feature. It allows test-cases to indicate what file to be output in multiple files project

fileName: "Filename",

resolveReference: "ResolveReference", // This flag is used to specify entry file for resolve file references. The flag is only allow once per test file

};

// List of allowed metadata names

const fileMetadataNames = [metadataOptionNames.fileName, metadataOptionNames.emitThisFile, metadataOptionNames.resolveReference];

function convertGlobalOptionsToCompilerOptions(globalOptions: Harness.TestCaseParser.CompilerSettings): ts.CompilerOptions {

const settings: ts.CompilerOptions = { target: ts.ScriptTarget.ES5 };

Harness.Compiler.setCompilerOptionsFromHarnessSetting(globalOptions, settings);

return settings;

}

export class TestCancellationToken implements ts.HostCancellationToken {

// 0 - cancelled

// >0 - not cancelled

// <0 - not cancelled and value denotes number of isCancellationRequested after which token become cancelled

private static NotCanceled: number = -1;

private numberOfCallsBeforeCancellation: number = TestCancellationToken.NotCanceled;

public isCancellationRequested(): boolean {

if (this.numberOfCallsBeforeCancellation < 0) {

return false;

}

if (this.numberOfCallsBeforeCancellation > 0) {

this.numberOfCallsBeforeCancellation--;

return false;

}

return true;

}

public setCancelled(numberOfCalls = 0): void {

ts.Debug.assert(numberOfCalls >= 0);

this.numberOfCallsBeforeCancellation = numberOfCalls;

}

public resetCancelled(): void {

this.numberOfCallsBeforeCancellation = TestCancellationToken.NotCanceled;

}

}

export function verifyOperationIsCancelled(f: () => void) {

try {

f();

}

catch (e) {

if (e instanceof ts.OperationCanceledException) {

return;

}

}

throw new Error("Operation should be cancelled");

}

// This function creates IScriptSnapshot object for testing getPreProcessedFileInfo

// Return object may lack some functionalities for other purposes.

function createScriptSnapShot(sourceText: string): ts.IScriptSnapshot {

return {

getText: (start: number, end: number) => {

return sourceText.substr(start, end - start);

},

getLength: () => {

return sourceText.length;

},

getChangeRange: (oldSnapshot: ts.IScriptSnapshot) => {

return <ts.TextChangeRange>undefined;

}

};

}

export class TestState {

// Language service instance

private languageServiceAdapterHost: Harness.LanguageService.LanguageServiceAdapterHost;

private languageService: ts.LanguageService;

private cancellationToken: TestCancellationToken;

// The current caret position in the active file

public currentCaretPosition = 0;

public lastKnownMarker: string = "";

// The file that's currently 'opened'

public activeFile: FourSlashFile = null;

// Whether or not we should format on keystrokes

public enableFormatting = true;

public formatCodeOptions: ts.FormatCodeOptions;

private inputFiles: ts.Map<string> = {}; // Map between inputFile's fileName and its content for easily looking up when resolving references

// Add input file which has matched file name with the given reference-file path.

// This is necessary when resolveReference flag is specified

private addMatchedInputFile(referenceFilePath: string, extensions: string[]) {

const inputFiles = this.inputFiles;

const languageServiceAdapterHost = this.languageServiceAdapterHost;

if (!extensions) {

tryAdd(referenceFilePath);

}

else {

tryAdd(referenceFilePath) || ts.forEach(extensions, ext => tryAdd(referenceFilePath + ext));

}

function tryAdd(path: string) {

const inputFile = inputFiles[path];

if (inputFile && !Harness.isDefaultLibraryFile(path)) {

languageServiceAdapterHost.addScript(path, inputFile, /*isRootFile*/ true);

return true;

}

}

}

private getLanguageServiceAdapter(testType: FourSlashTestType, cancellationToken: TestCancellationToken, compilationOptions: ts.CompilerOptions): Harness.LanguageService.LanguageServiceAdapter {

switch (testType) {

case FourSlashTestType.Native:

return new Harness.LanguageService.NativeLanguageServiceAdapter(cancellationToken, compilationOptions);

case FourSlashTestType.Shims:

return new Harness.LanguageService.ShimLanguageServiceAdapter(/*preprocessToResolve*/ false, cancellationToken, compilationOptions);

case FourSlashTestType.ShimsWithPreprocess:

return new Harness.LanguageService.ShimLanguageServiceAdapter(/*preprocessToResolve*/ true, cancellationToken, compilationOptions);

case FourSlashTestType.Server:

return new Harness.LanguageService.ServerLanguageServiceAdapter(cancellationToken, compilationOptions);

default:

throw new Error("Unknown FourSlash test type: ");

}

}

constructor(private basePath: string, private testType: FourSlashTestType, public testData: FourSlashData) {

// Create a new Services Adapter

this.cancellationToken = new TestCancellationToken();

const compilationOptions = convertGlobalOptionsToCompilerOptions(this.testData.globalOptions);

if (compilationOptions.typesRoot) {

compilationOptions.typesRoot = ts.getNormalizedAbsolutePath(compilationOptions.typesRoot, this.basePath);

}

const languageServiceAdapter = this.getLanguageServiceAdapter(testType, this.cancellationToken, compilationOptions);

this.languageServiceAdapterHost = languageServiceAdapter.getHost();

this.languageService = languageServiceAdapter.getLanguageService();

// Initialize the language service with all the scripts

let startResolveFileRef: FourSlashFile;

ts.forEach(testData.files, file => {

// Create map between fileName and its content for easily looking up when resolveReference flag is specified

this.inputFiles[file.fileName] = file.content;

if (!startResolveFileRef && file.fileOptions[metadataOptionNames.resolveReference] === "true") {

startResolveFileRef = file;

}

else if (startResolveFileRef) {

// If entry point for resolving file references is already specified, report duplication error

throw new Error("There exists a Fourslash file which has resolveReference flag specified; remove duplicated resolveReference flag");

}

});

if (startResolveFileRef) {

// Add the entry-point file itself into the languageServiceShimHost

this.languageServiceAdapterHost.addScript(startResolveFileRef.fileName, startResolveFileRef.content, /*isRootFile*/ true);

const resolvedResult = languageServiceAdapter.getPreProcessedFileInfo(startResolveFileRef.fileName, startResolveFileRef.content);

const referencedFiles: ts.FileReference[] = resolvedResult.referencedFiles;

const importedFiles: ts.FileReference[] = resolvedResult.importedFiles;

// Add triple reference files into language-service host

ts.forEach(referencedFiles, referenceFile => {

// Fourslash insert tests/cases/fourslash into inputFile.unitName so we will properly append the same base directory to refFile path

const referenceFilePath = this.basePath + "/" + referenceFile.fileName;

this.addMatchedInputFile(referenceFilePath, /* extensions */ undefined);

});

// Add import files into language-service host

ts.forEach(importedFiles, importedFile => {

// Fourslash insert tests/cases/fourslash into inputFile.unitName and import statement doesn't require ".ts"

// so convert them before making appropriate comparison

const importedFilePath = this.basePath + "/" + importedFile.fileName;

this.addMatchedInputFile(importedFilePath, ts.getSupportedExtensions(compilationOptions));

});

// Check if no-default-lib flag is false and if so add default library

if (!resolvedResult.isLibFile) {

this.languageServiceAdapterHost.addScript(Harness.Compiler.defaultLibFileName,

Harness.Compiler.getDefaultLibrarySourceFile().text, /*isRootFile*/ false);

}

}

else {

// resolveReference file-option is not specified then do not resolve any files and include all inputFiles

ts.forEachKey(this.inputFiles, fileName => {

if (!Harness.isDefaultLibraryFile(fileName)) {

this.languageServiceAdapterHost.addScript(fileName, this.inputFiles[fileName], /*isRootFile*/ true);

}

});

this.languageServiceAdapterHost.addScript(Harness.Compiler.defaultLibFileName,

Harness.Compiler.getDefaultLibrarySourceFile().text, /*isRootFile*/ false);

}

this.formatCodeOptions = {

IndentSize: 4,

TabSize: 4,

NewLineCharacter: Harness.IO.newLine(),

ConvertTabsToSpaces: true,

IndentStyle: ts.IndentStyle.Smart,

InsertSpaceAfterCommaDelimiter: true,

InsertSpaceAfterSemicolonInForStatements: true,

InsertSpaceBeforeAndAfterBinaryOperators: true,

InsertSpaceAfterKeywordsInControlFlowStatements: true,

InsertSpaceAfterFunctionKeywordForAnonymousFunctions: false,

InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: false,

InsertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: false,

InsertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: false,

PlaceOpenBraceOnNewLineForFunctions: false,

PlaceOpenBraceOnNewLineForControlBlocks: false,

};

// Open the first file by default

this.openFile(0);

}

private getFileContent(fileName: string): string {

const script = this.languageServiceAdapterHost.getScriptInfo(fileName);

return script.content;

}

// Entry points from fourslash.ts

public goToMarker(name = "") {

const marker = this.getMarkerByName(name);

if (this.activeFile.fileName !== marker.fileName) {

this.openFile(marker.fileName);

}

const content = this.getFileContent(marker.fileName);

if (marker.position === -1 || marker.position > content.length) {

throw new Error(`Marker "${name}" has been invalidated by unrecoverable edits to the file.`);

}

this.lastKnownMarker = name;

this.goToPosition(marker.position);

}

public goToPosition(pos: number) {

this.currentCaretPosition = pos;

}

public moveCaretRight(count = 1) {

this.currentCaretPosition += count;

this.currentCaretPosition = Math.min(this.currentCaretPosition, this.getFileContent(this.activeFile.fileName).length);

}

// Opens a file given its 0-based index or fileName

public openFile(index: number, content?: string, scriptKindName?: string): void;

public openFile(name: string, content?: string, scriptKindName?: string): void;

public openFile(indexOrName: any, content?: string, scriptKindName?: string) {

const fileToOpen: FourSlashFile = this.findFile(indexOrName);

fileToOpen.fileName = ts.normalizeSlashes(fileToOpen.fileName);

this.activeFile = fileToOpen;

// Let the host know that this file is now open

this.languageServiceAdapterHost.openFile(fileToOpen.fileName, content, scriptKindName);

}

public verifyErrorExistsBetweenMarkers(startMarkerName: string, endMarkerName: string, negative: boolean) {

const startMarker = this.getMarkerByName(startMarkerName);

const endMarker = this.getMarkerByName(endMarkerName);

const predicate = function (errorMinChar: number, errorLimChar: number, startPos: number, endPos: number) {

return ((errorMinChar === startPos) && (errorLimChar === endPos)) ? true : false;

};

const exists = this.anyErrorInRange(predicate, startMarker, endMarker);

if (exists !== negative) {

this.printErrorLog(negative, this.getAllDiagnostics());

throw new Error("Failure between markers: " + startMarkerName + ", " + endMarkerName);

}

}

private raiseError(message: string) {

message = this.messageAtLastKnownMarker(message);

throw new Error(message);

}

private messageAtLastKnownMarker(message: string) {

return "Marker: " + this.lastKnownMarker + "\n" + message;

}

private assertionMessageAtLastKnownMarker(msg: string) {

return "\nMarker: " + this.lastKnownMarker + "\nChecking: " + msg + "\n\n";

}

private getDiagnostics(fileName: string): ts.Diagnostic[] {

const syntacticErrors = this.languageService.getSyntacticDiagnostics(fileName);

const semanticErrors = this.languageService.getSemanticDiagnostics(fileName);

const diagnostics: ts.Diagnostic[] = [];

diagnostics.push.apply(diagnostics, syntacticErrors);

diagnostics.push.apply(diagnostics, semanticErrors);

return diagnostics;

}

private getAllDiagnostics(): ts.Diagnostic[] {

const diagnostics: ts.Diagnostic[] = [];

const fileNames = this.languageServiceAdapterHost.getFilenames();

for (let i = 0, n = fileNames.length; i < n; i++) {

diagnostics.push.apply(this.getDiagnostics(fileNames[i]));

}

return diagnostics;

}

public verifyErrorExistsAfterMarker(markerName: string, negative: boolean, after: boolean) {

const marker: Marker = this.getMarkerByName(markerName);

let predicate: (errorMinChar: number, errorLimChar: number, startPos: number, endPos: number) => boolean;

if (after) {

predicate = function (errorMinChar: number, errorLimChar: number, startPos: number, endPos: number) {

return ((errorMinChar >= startPos) && (errorLimChar >= startPos)) ? true : false;

};

}

else {

predicate = function (errorMinChar: number, errorLimChar: number, startPos: number, endPos: number) {

return ((errorMinChar <= startPos) && (errorLimChar <= startPos)) ? true : false;

};

}

const exists = this.anyErrorInRange(predicate, marker);

const diagnostics = this.getAllDiagnostics();

if (exists !== negative) {

this.printErrorLog(negative, diagnostics);

throw new Error("Failure at marker: " + markerName);

}

}

private anyErrorInRange(predicate: (errorMinChar: number, errorLimChar: number, startPos: number, endPos: number) => boolean, startMarker: Marker, endMarker?: Marker) {

const errors = this.getDiagnostics(startMarker.fileName);

let exists = false;

const startPos = startMarker.position;

let endPos: number = undefined;

if (endMarker !== undefined) {

endPos = endMarker.position;

}

errors.forEach(function (error: ts.Diagnostic) {

if (predicate(error.start, error.start + error.length, startPos, endPos)) {

exists = true;

}

});

return exists;

}

private printErrorLog(expectErrors: boolean, errors: ts.Diagnostic[]) {

if (expectErrors) {

Harness.IO.log("Expected error not found. Error list is:");

}

else {

Harness.IO.log("Unexpected error(s) found. Error list is:");

}

errors.forEach(function (error: ts.Diagnostic) {

Harness.IO.log(" minChar: " + error.start +

", limChar: " + (error.start + error.length) +

", message: " + ts.flattenDiagnosticMessageText(error.messageText, Harness.IO.newLine()) + "\n");

});

}

public verifyNumberOfErrorsInCurrentFile(expected: number) {

const errors = this.getDiagnostics(this.activeFile.fileName);

const actual = errors.length;

if (actual !== expected) {

this.printErrorLog(/*expectErrors*/ false, errors);

const errorMsg = "Actual number of errors (" + actual + ") does not match expected number (" + expected + ")";

Harness.IO.log(errorMsg);

this.raiseError(errorMsg);

}

}

public verifyEval(expr: string, value: any) {

const emit = this.languageService.getEmitOutput(this.activeFile.fileName);

if (emit.outputFiles.length !== 1) {

throw new Error("Expected exactly one output from emit of " + this.activeFile.fileName);

}

const evaluation = new Function(`${emit.outputFiles[0].text};\r\nreturn (${expr});`)();

if (evaluation !== value) {

this.raiseError(`Expected evaluation of expression "${expr}" to equal "${value}", but got "${evaluation}"`);

}

}

public verifyGetEmitOutputForCurrentFile(expected: string): void {

const emit = this.languageService.getEmitOutput(this.activeFile.fileName);

if (emit.outputFiles.length !== 1) {

throw new Error("Expected exactly one output from emit of " + this.activeFile.fileName);

}

const actual = emit.outputFiles[0].text;

if (actual !== expected) {

this.raiseError(`Expected emit output to be "${expected}", but got "${actual}"`);

}

}

public verifyGetEmitOutputContentsForCurrentFile(expected: ts.OutputFile[]): void {

const emit = this.languageService.getEmitOutput(this.activeFile.fileName);

assert.equal(emit.outputFiles.length, expected.length, "Number of emit output files");

for (let i = 0; i < emit.outputFiles.length; i++) {

assert.equal(emit.outputFiles[i].name, expected[i].name, "FileName");

assert.equal(emit.outputFiles[i].text, expected[i].text, "Content");

}

}

public verifyMemberListContains(symbol: string, text?: string, documentation?: string, kind?: string) {

const members = this.getMemberListAtCaret();

if (members) {

this.assertItemInCompletionList(members.entries, symbol, text, documentation, kind);

}

else {

this.raiseError("Expected a member list, but none was provided");

}

}

public verifyMemberListCount(expectedCount: number, negative: boolean) {

if (expectedCount === 0 && negative) {

this.verifyMemberListIsEmpty(/*negative*/ false);

return;

}

const members = this.getMemberListAtCaret();

if (members) {

const match = members.entries.length === expectedCount;

if ((!match && !negative) || (match && negative)) {

this.raiseError("Member list count was " + members.entries.length + ". Expected " + expectedCount);

}

}

else if (expectedCount) {

this.raiseError("Member list count was 0. Expected " + expectedCount);

}

}

public verifyMemberListDoesNotContain(symbol: string) {

const members = this.getMemberListAtCaret();

if (members && members.entries.filter(e => e.name === symbol).length !== 0) {

this.raiseError(`Member list did contain ${symbol}`);

}

}

public verifyCompletionListItemsCountIsGreaterThan(count: number, negative: boolean) {

const completions = this.getCompletionListAtCaret();

const itemsCount = completions.entries.length;

if (negative) {

if (itemsCount > count) {

this.raiseError(`Expected completion list items count to not be greater than ${count}, but is actually ${itemsCount}`);

}

}

else {

if (itemsCount <= count) {

this.raiseError(`Expected completion list items count to be greater than ${count}, but is actually ${itemsCount}`);

}

}

}

public verifyCompletionListStartsWithItemsInOrder(items: string[]): void {

if (items.length === 0) {

return;

}

const entries = this.getCompletionListAtCaret().entries;

assert.isTrue(items.length <= entries.length, `Amount of expected items in completion list [ ${items.length} ] is greater than actual number of items in list [ ${entries.length} ]`);

for (let i = 0; i < items.length; i++) {

assert.equal(entries[i].name, items[i], `Unexpected item in completion list`);

}

}

public noItemsWithSameNameButDifferentKind(): void {

const completions = this.getCompletionListAtCaret();

const uniqueItems: ts.Map<string> = {};

for (const item of completions.entries) {

if (!ts.hasProperty(uniqueItems, item.name)) {

uniqueItems[item.name] = item.kind;

}

else {

assert.equal(item.kind, uniqueItems[item.name], `Items should have the same kind, got ${item.kind} and ${uniqueItems[item.name]}`);

}

}

}

public verifyMemberListIsEmpty(negative: boolean) {

const members = this.getMemberListAtCaret();

if ((!members || members.entries.length === 0) && negative) {

this.raiseError("Member list is empty at Caret");

}

else if ((members && members.entries.length !== 0) && !negative) {

let errorMsg = "\n" + "Member List contains: [" + members.entries[0].name;

for (let i = 1; i < members.entries.length; i++) {

errorMsg += ", " + members.entries[i].name;

}

errorMsg += "]\n";

this.raiseError("Member list is not empty at Caret: " + errorMsg);

}

}

public verifyCompletionListIsEmpty(negative: boolean) {

const completions = this.getCompletionListAtCaret();

if ((!completions || completions.entries.length === 0) && negative) {

this.raiseError("Completion list is empty at caret at position " + this.activeFile.fileName + " " + this.currentCaretPosition);

}

else if (completions && completions.entries.length !== 0 && !negative) {

let errorMsg = "\n" + "Completion List contains: [" + completions.entries[0].name;

for (let i = 1; i < completions.entries.length; i++) {

errorMsg += ", " + completions.entries[i].name;

}

errorMsg += "]\n";

this.raiseError("Completion list is not empty at caret at position " + this.activeFile.fileName + " " + this.currentCaretPosition + errorMsg);

}

}

public verifyCompletionListAllowsNewIdentifier(negative: boolean) {

const completions = this.getCompletionListAtCaret();

if ((completions && !completions.isNewIdentifierLocation) && !negative) {

this.raiseError("Expected builder completion entry");

}

else if ((completions && completions.isNewIdentifierLocation) && negative) {

this.raiseError("Un-expected builder completion entry");

}

}

public verifyCompletionListContains(symbol: string, text?: string, documentation?: string, kind?: string) {

const completions = this.getCompletionListAtCaret();

if (completions) {

this.assertItemInCompletionList(completions.entries, symbol, text, documentation, kind);

}

else {

this.raiseError(`No completions at position '${this.currentCaretPosition}' when looking for '${symbol}'.`);

}

}

/**

* Verify that the completion list does NOT contain the given symbol.

* The symbol is considered matched with the symbol in the list if and only if all given parameters must matched.

* When any parameter is omitted, the parameter is ignored during comparison and assumed that the parameter with

* that property of the symbol in the list.

* @param symbol the name of symbol

* @param expectedText the text associated with the symbol

* @param expectedDocumentation the documentation text associated with the symbol

* @param expectedKind the kind of symbol (see ScriptElementKind)

*/

public verifyCompletionListDoesNotContain(symbol: string, expectedText?: string, expectedDocumentation?: string, expectedKind?: string) {

const that = this;

function filterByTextOrDocumentation(entry: ts.CompletionEntry) {

const details = that.getCompletionEntryDetails(entry.name);

const documentation = ts.displayPartsToString(details.documentation);

const text = ts.displayPartsToString(details.displayParts);

if (expectedText && expectedDocumentation) {

return (documentation === expectedDocumentation && text === expectedText) ? true : false;

}

else if (expectedText && !expectedDocumentation) {

return text === expectedText ? true : false;

}

else if (expectedDocumentation && !expectedText) {

return documentation === expectedDocumentation ? true : false;

}

// Because expectedText and expectedDocumentation are undefined, we assume that

// users don"t care to compare them so we will treat that entry as if the entry has matching text and documentation

// and keep it in the list of filtered entry.

return true;

}

const completions = this.getCompletionListAtCaret();

if (completions) {

let filterCompletions = completions.entries.filter(e => e.name === symbol);

filterCompletions = expectedKind ? filterCompletions.filter(e => e.kind === expectedKind) : filterCompletions;

filterCompletions = filterCompletions.filter(filterByTextOrDocumentation);

if (filterCompletions.length !== 0) {

// After filtered using all present criterion, if there are still symbol left in the list

// then these symbols must meet the criterion for Not supposed to be in the list. So we

// raise an error

let error = "Completion list did contain \'" + symbol + "\'.";

const details = this.getCompletionEntryDetails(filterCompletions[0].name);

if (expectedText) {

error += "Expected text: " + expectedText + " to equal: " + ts.displayPartsToString(details.displayParts) + ".";

}

if (expectedDocumentation) {

error += "Expected documentation: " + expectedDocumentation + " to equal: " + ts.displayPartsToString(details.documentation) + ".";

}

if (expectedKind) {

error += "Expected kind: " + expectedKind + " to equal: " + filterCompletions[0].kind + ".";

}

this.raiseError(error);

}

}

}

public verifyCompletionEntryDetails(entryName: string, expectedText: string, expectedDocumentation?: string, kind?: string) {

const details = this.getCompletionEntryDetails(entryName);

assert.equal(ts.displayPartsToString(details.displayParts), expectedText, this.assertionMessageAtLastKnownMarker("completion entry details text"));

if (expectedDocumentation !== undefined) {

assert.equal(ts.displayPartsToString(details.documentation), expectedDocumentation, this.assertionMessageAtLastKnownMarker("completion entry documentation"));

}

if (kind !== undefined) {

assert.equal(details.kind, kind, this.assertionMessageAtLastKnownMarker("completion entry kind"));

}

}

public verifyReferencesAtPositionListContains(fileName: string, start: number, end: number, isWriteAccess?: boolean) {

const references = this.getReferencesAtCaret();

if (!references || references.length === 0) {

this.raiseError("verifyReferencesAtPositionListContains failed - found 0 references, expected at least one.");

}

for (let i = 0; i < references.length; i++) {

const reference = references[i];

if (reference && reference.fileName === fileName && reference.textSpan.start === start && ts.textSpanEnd(reference.textSpan) === end) {

if (typeof isWriteAccess !== "undefined" && reference.isWriteAccess !== isWriteAccess) {

this.raiseError(`verifyReferencesAtPositionListContains failed - item isWriteAccess value does not match, actual: ${reference.isWriteAccess}, expected: ${isWriteAccess}.`);

}

return;

}

}

const missingItem = { fileName: fileName, start: start, end: end, isWriteAccess: isWriteAccess };

this.raiseError(`verifyReferencesAtPositionListContains failed - could not find the item: ${JSON.stringify(missingItem, undefined, 2)} in the returned list: (${JSON.stringify(references, undefined, 2)})`);

}

public verifyReferencesCountIs(count: number, localFilesOnly = true) {

const references = this.getReferencesAtCaret();

let referencesCount = 0;

if (localFilesOnly) {

const localFiles = this.testData.files.map<string>(file => file.fileName);

// Count only the references in local files. Filter the ones in lib and other files.

ts.forEach(references, entry => {

if (localFiles.some((fileName) => fileName === entry.fileName)) {

referencesCount++;

}

});

}

else {

referencesCount = references && references.length || 0;

}

if (referencesCount !== count) {

const condition = localFilesOnly ? "excluding libs" : "including libs";

this.raiseError("Expected references count (" + condition + ") to be " + count + ", but is actually " + referencesCount);

}

}

private getMemberListAtCaret() {

return this.languageService.getCompletionsAtPosition(this.activeFile.fileName, this.currentCaretPosition);

}

private getCompletionListAtCaret() {

return this.languageService.getCompletionsAtPosition(this.activeFile.fileName, this.currentCaretPosition);

}

private getCompletionEntryDetails(entryName: string) {

return this.languageService.getCompletionEntryDetails(this.activeFile.fileName, this.currentCaretPosition, entryName);

}

private getReferencesAtCaret() {

return this.languageService.getReferencesAtPosition(this.activeFile.fileName, this.currentCaretPosition);

}

public getSyntacticDiagnostics(expected: string) {

const diagnostics = this.languageService.getSyntacticDiagnostics(this.activeFile.fileName);

this.testDiagnostics(expected, diagnostics);

}

public getSemanticDiagnostics(expected: string) {

const diagnostics = this.languageService.getSemanticDiagnostics(this.activeFile.fileName);

this.testDiagnostics(expected, diagnostics);

}

private testDiagnostics(expected: string, diagnostics: ts.Diagnostic[]) {

const realized = ts.realizeDiagnostics(diagnostics, "\r\n");

const actual = JSON.stringify(realized, undefined, 2);

assert.equal(actual, expected);

}

public verifyQuickInfoString(negative: boolean, expectedText?: string, expectedDocumentation?: string) {

const actualQuickInfo = this.languageService.getQuickInfoAtPosition(this.activeFile.fileName, this.currentCaretPosition);

const actualQuickInfoText = actualQuickInfo ? ts.displayPartsToString(actualQuickInfo.displayParts) : "";

const actualQuickInfoDocumentation = actualQuickInfo ? ts.displayPartsToString(actualQuickInfo.documentation) : "";

if (negative) {

if (expectedText !== undefined) {

assert.notEqual(actualQuickInfoText, expectedText, this.messageAtLastKnownMarker("quick info text"));

}

// TODO: should be '==='?

if (expectedDocumentation != undefined) {

assert.notEqual(actualQuickInfoDocumentation, expectedDocumentation, this.messageAtLastKnownMarker("quick info doc comment"));

}

}

else {

if (expectedText !== undefined) {

assert.equal(actualQuickInfoText, expectedText, this.messageAtLastKnownMarker("quick info text"));

}

// TODO: should be '==='?

if (expectedDocumentation != undefined) {

assert.equal(actualQuickInfoDocumentation, expectedDocumentation, this.assertionMessageAtLastKnownMarker("quick info doc"));

}

}

}

public verifyQuickInfoDisplayParts(kind: string, kindModifiers: string, textSpan: { start: number; length: number; },

displayParts: ts.SymbolDisplayPart[],

documentation: ts.SymbolDisplayPart[]) {

function getDisplayPartsJson(displayParts: ts.SymbolDisplayPart[]) {

let result = "";

ts.forEach(displayParts, part => {

if (result) {

result += ",\n ";

}

else {

result = "[\n ";

}

result += JSON.stringify(part);

});

if (result) {

result += "\n]";

}

return result;

}

const actualQuickInfo = this.languageService.getQuickInfoAtPosition(this.activeFile.fileName, this.currentCaretPosition);

assert.equal(actualQuickInfo.kind, kind, this.messageAtLastKnownMarker("QuickInfo kind"));

assert.equal(actualQuickInfo.kindModifiers, kindModifiers, this.messageAtLastKnownMarker("QuickInfo kindModifiers"));

assert.equal(JSON.stringify(actualQuickInfo.textSpan), JSON.stringify(textSpan), this.messageAtLastKnownMarker("QuickInfo textSpan"));

assert.equal(getDisplayPartsJson(actualQuickInfo.displayParts), getDisplayPartsJson(displayParts), this.messageAtLastKnownMarker("QuickInfo displayParts"));

assert.equal(getDisplayPartsJson(actualQuickInfo.documentation), getDisplayPartsJson(documentation), this.messageAtLastKnownMarker("QuickInfo documentation"));

}

public verifyRenameLocations(findInStrings: boolean, findInComments: boolean) {

const renameInfo = this.languageService.getRenameInfo(this.activeFile.fileName, this.currentCaretPosition);

if (renameInfo.canRename) {

let references = this.languageService.findRenameLocations(

this.activeFile.fileName, this.currentCaretPosition, findInStrings, findInComments);

let ranges = this.getRanges();

if (!references) {

if (ranges.length !== 0) {

this.raiseError(`Expected ${ranges.length} rename locations; got none.`);

}

return;

}

if (ranges.length !== references.length) {

this.raiseError("Rename location count does not match result.\n\nExpected: " + JSON.stringify(ranges, undefined, 2) + "\n\nActual:" + JSON.stringify(references, undefined, 2));

}

ranges = ranges.sort((r1, r2) => r1.start - r2.start);

references = references.sort((r1, r2) => r1.textSpan.start - r2.textSpan.start);

for (let i = 0, n = ranges.length; i < n; i++) {

const reference = references[i];

const range = ranges[i];

if (reference.textSpan.start !== range.start ||

ts.textSpanEnd(reference.textSpan) !== range.end) {

this.raiseError("Rename location results do not match.\n\nExpected: " + JSON.stringify(ranges, undefined, 2) + "\n\nActual:" + JSON.stringify(references, undefined, 2));

}

}

}

else {

this.raiseError("Expected rename to succeed, but it actually failed.");

}

}

public verifyQuickInfoExists(negative: boolean) {

const actualQuickInfo = this.languageService.getQuickInfoAtPosition(this.activeFile.fileName, this.currentCaretPosition);

if (negative) {

if (actualQuickInfo) {

this.raiseError("verifyQuickInfoExists failed. Expected quick info NOT to exist");

}

}

else {

if (!actualQuickInfo) {

this.raiseError("verifyQuickInfoExists failed. Expected quick info to exist");

}

}

}

public verifyCurrentSignatureHelpIs(expected: string) {

const help = this.getActiveSignatureHelpItem();

assert.equal(

ts.displayPartsToString(help.prefixDisplayParts) +

help.parameters.map(p => ts.displayPartsToString(p.displayParts)).join(ts.displayPartsToString(help.separatorDisplayParts)) +

ts.displayPartsToString(help.suffixDisplayParts), expected);

}

public verifyCurrentParameterIsletiable(isVariable: boolean) {

const signature = this.getActiveSignatureHelpItem();

assert.isNotNull(signature);

assert.equal(isVariable, signature.isVariadic);

}

public verifyCurrentParameterHelpName(name: string) {

const activeParameter = this.getActiveParameter();

const activeParameterName = activeParameter.name;

assert.equal(activeParameterName, name);

}

public verifyCurrentParameterSpanIs(parameter: string) {

const activeParameter = this.getActiveParameter();

assert.equal(ts.displayPartsToString(activeParameter.displayParts), parameter);

}

public verifyCurrentParameterHelpDocComment(docComment: string) {

const activeParameter = this.getActiveParameter();

const activeParameterDocComment = activeParameter.documentation;

assert.equal(ts.displayPartsToString(activeParameterDocComment), docComment, this.assertionMessageAtLastKnownMarker("current parameter Help DocComment"));

}

public verifyCurrentSignatureHelpParameterCount(expectedCount: number) {

assert.equal(this.getActiveSignatureHelpItem().parameters.length, expectedCount);

}

public verifyCurrentSignatureHelpDocComment(docComment: string) {

const actualDocComment = this.getActiveSignatureHelpItem().documentation;

assert.equal(ts.displayPartsToString(actualDocComment), docComment, this.assertionMessageAtLastKnownMarker("current signature help doc comment"));

}

public verifySignatureHelpCount(expected: number) {

const help = this.languageService.getSignatureHelpItems(this.activeFile.fileName, this.currentCaretPosition);

const actual = help && help.items ? help.items.length : 0;

assert.equal(actual, expected);

}

public verifySignatureHelpArgumentCount(expected: number) {

const signatureHelpItems = this.languageService.getSignatureHelpItems(this.activeFile.fileName, this.currentCaretPosition);

const actual = signatureHelpItems.argumentCount;

assert.equal(actual, expected);

}

public verifySignatureHelpPresent(shouldBePresent = true) {

const actual = this.languageService.getSignatureHelpItems(this.activeFile.fileName, this.currentCaretPosition);

if (shouldBePresent) {

if (!actual) {

this.raiseError("Expected signature help to be present, but it wasn't");

}

}

else {

if (actual) {

this.raiseError(`Expected no signature help, but got "${JSON.stringify(actual, undefined, 2)}"`);

}

}

}

private validate(name: string, expected: string, actual: string) {

if (expected && expected !== actual) {

this.raiseError("Expected " + name + " '" + expected + "'. Got '" + actual + "' instead.");

}

}

public verifyRenameInfoSucceeded(displayName?: string, fullDisplayName?: string, kind?: string, kindModifiers?: string) {

const renameInfo = this.languageService.getRenameInfo(this.activeFile.fileName, this.currentCaretPosition);

if (!renameInfo.canRename) {

this.raiseError("Rename did not succeed");

}

this.validate("displayName", displayName, renameInfo.displayName);

this.validate("fullDisplayName", fullDisplayName, renameInfo.fullDisplayName);

this.validate("kind", kind, renameInfo.kind);

this.validate("kindModifiers", kindModifiers, renameInfo.kindModifiers);

if (this.getRanges().length !== 1) {

this.raiseError("Expected a single range to be selected in the test file.");

}