@zzzen/pyright-internal 1.1.254

package/dist/tests/harness/fourslash/testState.js

@@ -0,0 +1,1381 @@
+"use strict";
+/*
+ * testState.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * TestState wraps currently test states and provides a way to query and manipulate
+ * the test states.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNodeAtMarker = exports.getNodeForRange = exports.parseAndGetTestState = exports.TestState = void 0;
+const assert_1 = __importDefault(require("assert"));
+const JSONC = __importStar(require("jsonc-parser"));
+const vscode_languageserver_1 = require("vscode-languageserver");
+const parseTreeUtils_1 = require("../../../analyzer/parseTreeUtils");
+const service_1 = require("../../../analyzer/service");
+const collectionUtils_1 = require("../../../common/collectionUtils");
+const configOptions_1 = require("../../../common/configOptions");
+const console_1 = require("../../../common/console");
+const core_1 = require("../../../common/core");
+const debug = __importStar(require("../../../common/debug"));
+const deferred_1 = require("../../../common/deferred");
+const pathUtils_1 = require("../../../common/pathUtils");
+const positionUtils_1 = require("../../../common/positionUtils");
+const stringUtils_1 = require("../../../common/stringUtils");
+const textRange_1 = require("../../../common/textRange");
+const definitionProvider_1 = require("../../../languageService/definitionProvider");
+const hoverProvider_1 = require("../../../languageService/hoverProvider");
+const tokenizer_1 = require("../../../parser/tokenizer");
+const pyrightFileSystem_1 = require("../../../pyrightFileSystem");
+const testAccessHost_1 = require("../testAccessHost");
+const host = __importStar(require("../testHost"));
+const utils_1 = require("../utils");
+const factory_1 = require("../vfs/factory");
+const vfs = __importStar(require("../vfs/filesystem"));
+const fourSlashParser_1 = require("./fourSlashParser");
+const fourSlashTypes_1 = require("./fourSlashTypes");
+const testLanguageService_1 = require("./testLanguageService");
+const testAccessHost = new testAccessHost_1.TestAccessHost(vfs.MODULE_PATH, [factory_1.libFolder, factory_1.distlibFolder]);
+class TestState {
+    constructor(basePath, testData, mountPaths, hostSpecificFeatures) {
+        var _a, _b;
+        this.testData = testData;
+        this._files = [];
+        // The current caret position in the active file
+        this.currentCaretPosition = 0;
+        // The position of the end of the current selection, or -1 if nothing is selected
+        this.selectionEnd = -1;
+        this.lastKnownMarker = '';
+        this._hostSpecificFeatures = hostSpecificFeatures !== null && hostSpecificFeatures !== void 0 ? hostSpecificFeatures : new testLanguageService_1.TestFeatures();
+        const nullConsole = new console_1.NullConsole();
+        const ignoreCase = (0, core_1.toBoolean)(testData.globalOptions["ignorecase" /* ignoreCase */]);
+        this._cancellationToken = new fourSlashTypes_1.TestCancellationToken();
+        const sourceFiles = [];
+        const files = {};
+        for (const file of testData.files) {
+            // if one of file is configuration file, set config options from the given json
+            if (this._isConfig(file, ignoreCase)) {
+                try {
+                    this.rawConfigJson = JSONC.parse(file.content);
+                }
+                catch (e) {
+                    throw new Error(`Failed to parse test ${file.fileName}: ${e.message}`);
+                }
+            }
+            else {
+                files[file.fileName] = new vfs.File(file.content, { meta: file.fileOptions, encoding: 'utf8' });
+                if (!(0, core_1.toBoolean)(file.fileOptions["library" /* library */])) {
+                    sourceFiles.push(file.fileName);
+                }
+            }
+        }
+        this.console = nullConsole;
+        this.testFS = (0, factory_1.createFromFileSystem)(host.HOST, ignoreCase, { cwd: basePath, files, meta: testData.globalOptions }, mountPaths);
+        this.fs = new pyrightFileSystem_1.PyrightFileSystem(this.testFS);
+        this._files = sourceFiles;
+        const configOptions = this._convertGlobalOptionsToConfigOptions(this.testData.globalOptions, mountPaths);
+        if (this.rawConfigJson) {
+            configOptions.initializeFromJson(this.rawConfigJson, 'basic', nullConsole, this.fs, testAccessHost);
+            this._applyTestConfigOptions(configOptions);
+        }
+        const service = this._createAnalysisService(nullConsole, this._hostSpecificFeatures.importResolverFactory, configOptions);
+        this.workspace = {
+            workspaceName: 'test workspace',
+            rootPath: this.fs.getModulePath(),
+            rootUri: (0, pathUtils_1.convertPathToUri)(this.fs, this.fs.getModulePath()),
+            serviceInstance: service,
+            disableLanguageServices: false,
+            disableOrganizeImports: false,
+            isInitialized: (0, deferred_1.createDeferred)(),
+            searchPathsToWatch: [],
+        };
+        const indexer = (0, core_1.toBoolean)(testData.globalOptions["indexer" /* indexer */]);
+        const indexerWithoutStdLib = (0, core_1.toBoolean)(testData.globalOptions["indexerwithoutstdlib" /* indexerWithoutStdLib */]);
+        if (indexer || indexerWithoutStdLib) {
+            const indexerOptions = testData.globalOptions["indexeroptions" /* indexerOptions */];
+            configOptions.indexing = true;
+            this._hostSpecificFeatures.runIndexer(this.workspace, indexerWithoutStdLib, indexerOptions);
+        }
+        if (this._files.length > 0) {
+            // Open the first file by default
+            this.openFile(this._files[0]);
+        }
+        for (const filePath of this._files) {
+            const file = files[filePath];
+            if ((_a = file.meta) === null || _a === void 0 ? void 0 : _a["ipythonmode" /* ipythonMode */]) {
+                (_b = this.program.getSourceFile(filePath)) === null || _b === void 0 ? void 0 : _b.test_enableIPythonMode(true);
+            }
+        }
+    }
+    get importResolver() {
+        return this.workspace.serviceInstance.getImportResolver();
+    }
+    get configOptions() {
+        return this.workspace.serviceInstance.getConfigOptions();
+    }
+    get program() {
+        return this.workspace.serviceInstance.test_program;
+    }
+    cwd() {
+        return this.testFS.cwd();
+    }
+    // Entry points from fourslash.ts
+    goToMarker(nameOrMarker = '') {
+        const marker = (0, core_1.isString)(nameOrMarker) ? this.getMarkerByName(nameOrMarker) : nameOrMarker;
+        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 "${nameOrMarker}" has been invalidated by unrecoverable edits to the file.`);
+        }
+        const mName = (0, core_1.isString)(nameOrMarker) ? nameOrMarker : this.getMarkerName(marker);
+        this.lastKnownMarker = mName;
+        this.goToPosition(marker.position);
+    }
+    goToEachMarker(markers, action) {
+        assert_1.default.ok(markers.length > 0);
+        for (let i = 0; i < markers.length; i++) {
+            this.goToMarker(markers[i]);
+            action(markers[i], i);
+        }
+    }
+    getMappedFilePath(path) {
+        this.importResolver.ensurePartialStubPackages(this.configOptions.findExecEnvironment(path));
+        return this.fs.getMappedFilePath(path);
+    }
+    getMarkerName(m) {
+        let found;
+        this.testData.markerPositions.forEach((marker, name) => {
+            if (marker === m) {
+                found = name;
+            }
+        });
+        assert_1.default.ok(found);
+        return found;
+    }
+    getMarkerByName(markerName) {
+        const markerPos = this.testData.markerPositions.get(markerName);
+        if (markerPos === undefined) {
+            throw new Error(`Unknown marker "${markerName}" Available markers: ${this.getMarkerNames()
+                .map((m) => '"' + m + '"')
+                .join(', ')}`);
+        }
+        else {
+            return markerPos;
+        }
+    }
+    getMarkers() {
+        //  Return a copy of the list
+        return this.testData.markers.slice(0);
+    }
+    getMarkerNames() {
+        return [...this.testData.markerPositions.keys()];
+    }
+    getPositionRange(markerString) {
+        const marker = this.getMarkerByName(markerString);
+        const ranges = this.getRanges().filter((r) => r.marker === marker);
+        if (ranges.length !== 1) {
+            this.raiseError(`no matching range for ${markerString}`);
+        }
+        const range = ranges[0];
+        return this.convertPositionRange(range);
+    }
+    expandPositionRange(range, start, end) {
+        return {
+            start: { line: range.start.line, character: range.start.character - start },
+            end: { line: range.end.line, character: range.end.character + end },
+        };
+    }
+    convertPositionRange(range) {
+        return this.convertOffsetsToRange(range.fileName, range.pos, range.end);
+    }
+    convertPathToUri(path) {
+        return (0, pathUtils_1.convertPathToUri)(this.fs, path);
+    }
+    getDirectoryPath(path) {
+        return (0, pathUtils_1.getDirectoryPath)(path);
+    }
+    goToPosition(positionOrLineAndColumn) {
+        const pos = (0, core_1.isNumber)(positionOrLineAndColumn)
+            ? positionOrLineAndColumn
+            : this.convertPositionToOffset(this.activeFile.fileName, positionOrLineAndColumn);
+        this.currentCaretPosition = pos;
+        this.selectionEnd = -1;
+    }
+    select(startMarker, endMarker) {
+        const start = this.getMarkerByName(startMarker);
+        const end = this.getMarkerByName(endMarker);
+        assert_1.default.ok(start.fileName === end.fileName);
+        if (this.activeFile.fileName !== start.fileName) {
+            this.openFile(start.fileName);
+        }
+        this.goToPosition(start.position);
+        this.selectionEnd = end.position;
+    }
+    selectAllInFile(fileName) {
+        this.openFile(fileName);
+        this.goToPosition(0);
+        this.selectionEnd = this.activeFile.content.length;
+    }
+    selectRange(range) {
+        this.goToRangeStart(range);
+        this.selectionEnd = range.end;
+    }
+    selectLine(index) {
+        const lineStart = this.convertPositionToOffset(this.activeFile.fileName, { line: index, character: 0 });
+        const lineEnd = lineStart + this._getLineContent(index).length;
+        this.selectRange({ fileName: this.activeFile.fileName, pos: lineStart, end: lineEnd });
+    }
+    goToEachRange(action) {
+        const ranges = this.getRanges();
+        assert_1.default.ok(ranges.length > 0);
+        for (const range of ranges) {
+            this.selectRange(range);
+            action(range);
+        }
+    }
+    goToRangeStart({ fileName, pos }) {
+        this.openFile(fileName);
+        this.goToPosition(pos);
+    }
+    getRanges() {
+        return this.testData.ranges;
+    }
+    getRangesInFile(fileName = this.activeFile.fileName) {
+        return this.getRanges().filter((r) => r.fileName === fileName);
+    }
+    getRangesByText() {
+        if (this.testData.rangesByText) {
+            return this.testData.rangesByText;
+        }
+        const result = this.createMultiMap(this.getRanges(), (r) => this._rangeText(r));
+        this.testData.rangesByText = result;
+        return result;
+    }
+    getFilteredRanges(predicate) {
+        return this.getRanges().filter((r) => { var _a; return predicate(r.marker, (_a = r.marker) === null || _a === void 0 ? void 0 : _a.data, this._rangeText(r)); });
+    }
+    getRangeByMarkerName(markerName) {
+        const marker = this.getMarkerByName(markerName);
+        return this.getRanges().find((r) => r.marker === marker);
+    }
+    goToBOF() {
+        this.goToPosition(0);
+    }
+    goToEOF() {
+        const len = this._getFileContent(this.activeFile.fileName).length;
+        this.goToPosition(len);
+    }
+    moveCaretRight(count = 1) {
+        this.currentCaretPosition += count;
+        this.currentCaretPosition = Math.min(this.currentCaretPosition, this._getFileContent(this.activeFile.fileName).length);
+        this.selectionEnd = -1;
+    }
+    // Opens a file given its 0-based index or fileName
+    openFile(indexOrName) {
+        const fileToOpen = this._findFile(indexOrName);
+        fileToOpen.fileName = (0, pathUtils_1.normalizeSlashes)(fileToOpen.fileName);
+        this.activeFile = fileToOpen;
+        this.program.setFileOpened(this.activeFile.fileName, 1, [{ text: fileToOpen.content }]);
+    }
+    openFiles(indexOrNames) {
+        for (const indexOrName of indexOrNames) {
+            this.openFile(indexOrName);
+        }
+    }
+    printCurrentFileState(showWhitespace, makeCaretVisible) {
+        for (const file of this.testData.files) {
+            const active = this.activeFile === file;
+            host.HOST.log(`=== Script (${file.fileName}) ${active ? '(active, cursor at |)' : ''} ===`);
+            let content = this._getFileContent(file.fileName);
+            if (active) {
+                content =
+                    content.substr(0, this.currentCaretPosition) +
+                        (makeCaretVisible ? '|' : '') +
+                        content.substr(this.currentCaretPosition);
+            }
+            if (showWhitespace) {
+                content = this._makeWhitespaceVisible(content);
+            }
+            host.HOST.log(content);
+        }
+    }
+    deleteChar(count = 1) {
+        const offset = this.currentCaretPosition;
+        const ch = '';
+        const checkCadence = (count >> 2) + 1;
+        for (let i = 0; i < count; i++) {
+            this._editScriptAndUpdateMarkers(this.activeFile.fileName, offset, offset + 1, ch);
+            if (i % checkCadence === 0) {
+                this._checkPostEditInvariants();
+            }
+        }
+        this._checkPostEditInvariants();
+    }
+    replace(start, length, text) {
+        this._editScriptAndUpdateMarkers(this.activeFile.fileName, start, start + length, text);
+        this._checkPostEditInvariants();
+    }
+    deleteLineRange(startIndex, endIndexInclusive) {
+        const startPos = this.convertPositionToOffset(this.activeFile.fileName, { line: startIndex, character: 0 });
+        const endPos = this.convertPositionToOffset(this.activeFile.fileName, {
+            line: endIndexInclusive + 1,
+            character: 0,
+        });
+        this.replace(startPos, endPos - startPos, '');
+    }
+    deleteCharBehindMarker(count = 1) {
+        let offset = this.currentCaretPosition;
+        const ch = '';
+        const checkCadence = (count >> 2) + 1;
+        for (let i = 0; i < count; i++) {
+            this.currentCaretPosition--;
+            offset--;
+            this._editScriptAndUpdateMarkers(this.activeFile.fileName, offset, offset + 1, ch);
+            if (i % checkCadence === 0) {
+                this._checkPostEditInvariants();
+            }
+            // Don't need to examine formatting because there are no formatting changes on backspace.
+        }
+        this._checkPostEditInvariants();
+    }
+    // Enters lines of text at the current caret position
+    type(text) {
+        let offset = this.currentCaretPosition;
+        const selection = this._getSelection();
+        this.replace(selection.start, selection.length, '');
+        for (let i = 0; i < text.length; i++) {
+            const ch = text.charAt(i);
+            this._editScriptAndUpdateMarkers(this.activeFile.fileName, offset, offset, ch);
+            this.currentCaretPosition++;
+            offset++;
+        }
+        this._checkPostEditInvariants();
+    }
+    // Enters text as if the user had pasted it
+    paste(text) {
+        this._editScriptAndUpdateMarkers(this.activeFile.fileName, this.currentCaretPosition, this.currentCaretPosition, text);
+        this._checkPostEditInvariants();
+    }
+    verifyDiagnostics(map) {
+        this._analyze();
+        // organize things per file
+        const resultPerFile = this._getDiagnosticsPerFile();
+        const rangePerFile = this.createMultiMap(this.getRanges(), (r) => r.fileName);
+        if (!hasDiagnostics(resultPerFile) && rangePerFile.size === 0) {
+            // no errors and no error is expected. we are done
+            return;
+        }
+        for (const [file, ranges] of rangePerFile.entries()) {
+            const rangesPerCategory = this.createMultiMap(ranges, (r) => {
+                if (map) {
+                    const name = this.getMarkerName(r.marker);
+                    return map[name].category;
+                }
+                return r.marker.data.category;
+            });
+            if (!rangesPerCategory.has('error')) {
+                rangesPerCategory.set('error', []);
+            }
+            if (!rangesPerCategory.has('warning')) {
+                rangesPerCategory.set('warning', []);
+            }
+            if (!rangesPerCategory.has('information')) {
+                rangesPerCategory.set('information', []);
+            }
+            const result = resultPerFile.get(file);
+            resultPerFile.delete(file);
+            for (const [category, expected] of rangesPerCategory.entries()) {
+                const lines = result.parseResults.tokenizerOutput.lines;
+                const actual = category === 'error'
+                    ? result.errors
+                    : category === 'warning'
+                        ? result.warnings
+                        : category === 'information'
+                            ? result.information
+                            : this.raiseError(`unexpected category ${category}`);
+                if (expected.length !== actual.length) {
+                    this.raiseError(`contains unexpected result - expected: ${(0, utils_1.stringify)(expected)}, actual: ${(0, utils_1.stringify)(actual)}`);
+                }
+                for (const range of expected) {
+                    const rangeSpan = textRange_1.TextRange.fromBounds(range.pos, range.end);
+                    const matches = actual.filter((d) => {
+                        const diagnosticSpan = textRange_1.TextRange.fromBounds((0, positionUtils_1.convertPositionToOffset)(d.range.start, lines), (0, positionUtils_1.convertPositionToOffset)(d.range.end, lines));
+                        return this._deepEqual(diagnosticSpan, rangeSpan);
+                    });
+                    if (matches.length === 0) {
+                        this.raiseError(`doesn't contain expected range: ${(0, utils_1.stringify)(range)}`);
+                    }
+                    // if map is provided, check message as well
+                    if (map) {
+                        const name = this.getMarkerName(range.marker);
+                        const message = map[name].message;
+                        if (matches.filter((d) => message === d.message).length !== 1) {
+                            this.raiseError(`message doesn't match: ${message} of ${name} - ${(0, utils_1.stringify)(range)}, actual: ${(0, utils_1.stringify)(matches)}`);
+                        }
+                    }
+                }
+            }
+        }
+        if (hasDiagnostics(resultPerFile)) {
+            this.raiseError(`these diagnostics were unexpected: ${(0, utils_1.stringify)(resultPerFile)}`);
+        }
+        function hasDiagnostics(resultPerFile) {
+            for (const entry of resultPerFile.values()) {
+                if (entry.errors.length + entry.warnings.length > 0) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+    async verifyCodeActions(map, verifyCodeActionCount) {
+        // make sure we don't use cache built from other tests
+        this.workspace.serviceInstance.invalidateAndForceReanalysis();
+        this._analyze();
+        for (const range of this.getRanges()) {
+            const name = this.getMarkerName(range.marker);
+            if (!map[name]) {
+                continue;
+            }
+            const codeActions = await this._getCodeActions(range);
+            if (verifyCodeActionCount) {
+                if (codeActions.length !== map[name].codeActions.length) {
+                    this.raiseError(`doesn't contain expected result: ${(0, utils_1.stringify)(map[name])}, actual: ${(0, utils_1.stringify)(codeActions)}`);
+                }
+            }
+            for (const expected of map[name].codeActions) {
+                let expectedCommand;
+                if (expected.command) {
+                    expectedCommand = {
+                        title: expected.command.title,
+                        command: expected.command.command,
+                        arguments: convertToString(expected.command.arguments),
+                    };
+                }
+                const matches = codeActions.filter((a) => {
+                    const actualCommand = a.command
+                        ? {
+                            title: a.command.title,
+                            command: a.command.command,
+                            arguments: convertToString(a.command.arguments),
+                        }
+                        : undefined;
+                    const actualEdit = a.edit;
+                    return (a.title === expected.title &&
+                        a.kind === expected.kind &&
+                        this._deepEqual(actualCommand, expectedCommand) &&
+                        this._deepEqual(actualEdit, expected.edit));
+                });
+                if (matches.length !== 1) {
+                    this.raiseError(`doesn't contain expected result: ${(0, utils_1.stringify)(expected)}, actual: ${(0, utils_1.stringify)(codeActions)}`);
+                }
+            }
+        }
+        function convertToString(args) {
+            return args === null || args === void 0 ? void 0 : args.map((a) => {
+                if ((0, core_1.isString)(a)) {
+                    return (0, pathUtils_1.normalizeSlashes)(a);
+                }
+                return JSON.stringify(a);
+            });
+        }
+    }
+    async verifyCommand(command, files) {
+        this._analyze();
+        const commandResult = await this._hostSpecificFeatures.execute(new testLanguageService_1.TestLanguageService(this.workspace, this.console, this.fs), { command: command.command, arguments: command.arguments || [] }, vscode_languageserver_1.CancellationToken.None);
+        if (command.command === 'pyright.createtypestub') {
+            await this._verifyFiles(files);
+        }
+        else if (command.command === 'pyright.organizeimports') {
+            // Organize imports command can be used on only one file at a time,
+            // so there is no looping over "commandResult" or "files".
+            const workspaceEditResult = commandResult;
+            const uri = Object.keys(workspaceEditResult.changes)[0];
+            const textEdit = workspaceEditResult.changes[uri][0];
+            const actualText = textEdit.newText;
+            const expectedText = Object.values(files)[0];
+            if (actualText !== expectedText) {
+                this.raiseError(`doesn't contain expected result: ${(0, utils_1.stringify)(expectedText)}, actual: ${(0, utils_1.stringify)(actualText)}`);
+            }
+        }
+        return commandResult;
+    }
+    verifyWorkspaceEdit(expected, actual) {
+        if (actual.changes) {
+            this._verifyTextEditMap(expected.changes, actual.changes);
+        }
+        else {
+            (0, assert_1.default)(!expected.changes);
+        }
+        if (actual.documentChanges) {
+            this._verifyDocumentEdits(expected.documentChanges, actual.documentChanges);
+        }
+        else {
+            (0, assert_1.default)(!expected.documentChanges);
+        }
+        if (actual.changeAnnotations) {
+            this._verifyChangeAnnotations(expected.changeAnnotations, actual.changeAnnotations);
+        }
+        else {
+            (0, assert_1.default)(!expected.changeAnnotations);
+        }
+    }
+    _verifyChangeAnnotations(expected, actual) {
+        assert_1.default.strictEqual(Object.entries(expected).length, Object.entries(actual).length);
+        for (const key of Object.keys(expected)) {
+            const expectedAnnotation = expected[key];
+            const actualAnnotation = actual[key];
+            // We need to improve it to test localized strings.
+            assert_1.default.strictEqual(expectedAnnotation.label, actualAnnotation.label);
+            assert_1.default.strictEqual(expectedAnnotation.description, actualAnnotation.description);
+            assert_1.default.strictEqual(expectedAnnotation.needsConfirmation, actualAnnotation.needsConfirmation);
+        }
+    }
+    _textDocumentAreSame(expected, actual) {
+        return expected.version === actual.version && expected.uri === actual.uri;
+    }
+    _verifyDocumentEdits(expected, actual) {
+        assert_1.default.strictEqual(expected.length, actual.length);
+        for (const op of expected) {
+            (0, assert_1.default)(actual.some((a) => {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+                const expectedKind = vscode_languageserver_1.TextDocumentEdit.is(op) ? 'edit' : op.kind;
+                const actualKind = vscode_languageserver_1.TextDocumentEdit.is(a) ? 'edit' : a.kind;
+                if (expectedKind !== actualKind) {
+                    return false;
+                }
+                switch (expectedKind) {
+                    case 'edit': {
+                        const expectedEdit = op;
+                        const actualEdit = a;
+                        if (!this._textDocumentAreSame(expectedEdit.textDocument, actualEdit.textDocument)) {
+                            return false;
+                        }
+                        return this._textEditsAreSame(expectedEdit.edits, actualEdit.edits);
+                    }
+                    case 'create': {
+                        const expectedOp = op;
+                        const actualOp = a;
+                        return (expectedOp.kind === actualOp.kind &&
+                            expectedOp.annotationId === actualOp.annotationId &&
+                            expectedOp.uri === actualOp.uri &&
+                            ((_a = expectedOp.options) === null || _a === void 0 ? void 0 : _a.ignoreIfExists) === ((_b = actualOp.options) === null || _b === void 0 ? void 0 : _b.ignoreIfExists) &&
+                            ((_c = expectedOp.options) === null || _c === void 0 ? void 0 : _c.overwrite) === ((_d = actualOp.options) === null || _d === void 0 ? void 0 : _d.overwrite));
+                    }
+                    case 'rename': {
+                        const expectedOp = op;
+                        const actualOp = a;
+                        return (expectedOp.kind === actualOp.kind &&
+                            expectedOp.annotationId === actualOp.annotationId &&
+                            expectedOp.oldUri === actualOp.oldUri &&
+                            expectedOp.newUri === actualOp.newUri &&
+                            ((_e = expectedOp.options) === null || _e === void 0 ? void 0 : _e.ignoreIfExists) === ((_f = actualOp.options) === null || _f === void 0 ? void 0 : _f.ignoreIfExists) &&
+                            ((_g = expectedOp.options) === null || _g === void 0 ? void 0 : _g.overwrite) === ((_h = actualOp.options) === null || _h === void 0 ? void 0 : _h.overwrite));
+                    }
+                    case 'delete': {
+                        const expectedOp = op;
+                        const actualOp = a;
+                        return (expectedOp.annotationId === actualOp.annotationId &&
+                            expectedOp.kind === actualOp.kind &&
+                            expectedOp.uri === actualOp.uri &&
+                            ((_j = expectedOp.options) === null || _j === void 0 ? void 0 : _j.ignoreIfNotExists) === ((_k = actualOp.options) === null || _k === void 0 ? void 0 : _k.ignoreIfNotExists) &&
+                            ((_l = expectedOp.options) === null || _l === void 0 ? void 0 : _l.recursive) === ((_m = actualOp.options) === null || _m === void 0 ? void 0 : _m.recursive));
+                    }
+                    default:
+                        debug.assertNever(expectedKind);
+                }
+            }));
+        }
+    }
+    _verifyTextEditMap(expected, actual) {
+        assert_1.default.strictEqual(Object.entries(expected).length, Object.entries(actual).length);
+        for (const key of Object.keys(expected)) {
+            (0, assert_1.default)(this._textEditsAreSame(expected[key], actual[key]));
+        }
+    }
+    _textEditsAreSame(expectedEdits, actualEdits) {
+        if (expectedEdits.length !== actualEdits.length) {
+            return false;
+        }
+        for (const edit of expectedEdits) {
+            if (!actualEdits.some((a) => this._textEditAreSame(edit, a))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    _textEditAreSame(expected, actual) {
+        if (!(0, textRange_1.rangesAreEqual)(expected.range, actual.range)) {
+            return false;
+        }
+        if (expected.newText !== actual.newText) {
+            return false;
+        }
+        const expectedAnnotation = vscode_languageserver_1.AnnotatedTextEdit.is(expected) ? expected.annotationId : '';
+        const actualAnnotation = vscode_languageserver_1.AnnotatedTextEdit.is(actual) ? actual.annotationId : '';
+        return expectedAnnotation === actualAnnotation;
+    }
+    async verifyInvokeCodeAction(map, verifyCodeActionCount) {
+        var _a;
+        this._analyze();
+        for (const range of this.getRanges()) {
+            const name = this.getMarkerName(range.marker);
+            if (!map[name]) {
+                continue;
+            }
+            const ls = new testLanguageService_1.TestLanguageService(this.workspace, this.console, this.fs);
+            const codeActions = await this._getCodeActions(range);
+            if (verifyCodeActionCount) {
+                if (codeActions.length !== Object.keys(map).length) {
+                    this.raiseError(`doesn't contain expected result: ${(0, utils_1.stringify)(map[name])}, actual: ${(0, utils_1.stringify)(codeActions)}`);
+                }
+            }
+            const matches = codeActions.filter((c) => c.title === map[name].title);
+            if (matches.length === 0) {
+                this.raiseError(`doesn't contain expected result: ${(0, utils_1.stringify)(map[name])}, actual: ${(0, utils_1.stringify)(codeActions)}`);
+            }
+            for (const codeAction of matches) {
+                const results = await this._hostSpecificFeatures.execute(ls, {
+                    command: codeAction.command.command,
+                    arguments: ((_a = codeAction.command) === null || _a === void 0 ? void 0 : _a.arguments) || [],
+                }, vscode_languageserver_1.CancellationToken.None);
+                if (map[name].edits) {
+                    const workspaceEdits = results;
+                    for (const edits of Object.values(workspaceEdits.changes)) {
+                        for (const edit of edits) {
+                            if (map[name].edits.filter((e) => this._editsAreEqual(e, edit)).length !== 1) {
+                                this.raiseError(`doesn't contain expected result: ${(0, utils_1.stringify)(map[name])}, actual: ${(0, utils_1.stringify)(edits)}`);
+                            }
+                        }
+                    }
+                }
+            }
+            if (map[name].files) {
+                await this._verifyFiles(map[name].files);
+            }
+        }
+    }
+    verifyHover(kind, map) {
+        // Do not force analyze, it can lead to test passing while it doesn't work in product
+        for (const range of this.getRanges()) {
+            const name = this.getMarkerName(range.marker);
+            const expected = map[name];
+            if (expected === undefined) {
+                continue;
+            }
+            const rangePos = this.convertOffsetsToRange(range.fileName, range.pos, range.end);
+            const actual = (0, hoverProvider_1.convertHoverResults)(kind, this.program.getHoverForPosition(range.fileName, rangePos.start, kind, vscode_languageserver_1.CancellationToken.None));
+            // if expected is null then there should be nothing shown on hover
+            if (expected === null) {
+                assert_1.default.equal(actual, undefined);
+                continue;
+            }
+            assert_1.default.ok(actual);
+            assert_1.default.deepEqual(actual.range, rangePos);
+            if (vscode_languageserver_1.MarkupContent.is(actual.contents)) {
+                assert_1.default.equal(actual.contents.value, expected);
+                assert_1.default.equal(actual.contents.kind, kind);
+            }
+            else {
+                assert_1.default.fail(`Unexpected type of contents object "${actual.contents}", should be MarkupContent.`);
+            }
+        }
+    }
+    verifyCaretAtMarker(markerName = '') {
+        const pos = this.getMarkerByName(markerName);
+        if (pos.fileName !== this.activeFile.fileName) {
+            throw new Error(`verifyCaretAtMarker failed - expected to be in file "${pos.fileName}", but was in file "${this.activeFile.fileName}"`);
+        }
+        if (pos.position !== this.currentCaretPosition) {
+            throw new Error(`verifyCaretAtMarker failed - expected to be at marker "/*${markerName}*/, but was at position ${this.currentCaretPosition}(${this._getLineColStringAtPosition(this.currentCaretPosition)})`);
+        }
+    }
+    verifyCurrentLineContent(text) {
+        const actual = this._getCurrentLineContent();
+        if (actual !== text) {
+            throw new Error('verifyCurrentLineContent\n' + this._displayExpectedAndActualString(text, actual, /* quoted */ true));
+        }
+    }
+    verifyCurrentFileContent(text) {
+        this._verifyFileContent(this.activeFile.fileName, text);
+    }
+    verifyTextAtCaretIs(text) {
+        const actual = this._getFileContent(this.activeFile.fileName).substring(this.currentCaretPosition, this.currentCaretPosition + text.length);
+        if (actual !== text) {
+            throw new Error('verifyTextAtCaretIs\n' + this._displayExpectedAndActualString(text, actual, /* quoted */ true));
+        }
+    }
+    verifyRangeIs(expectedText, includeWhiteSpace) {
+        this._verifyTextMatches(this._rangeText(this._getOnlyRange()), !!includeWhiteSpace, expectedText);
+    }
+    async verifyCompletion(verifyMode, docFormat, map, abbrMap) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        this._analyze();
+        for (const marker of this.getMarkers()) {
+            const markerName = this.getMarkerName(marker);
+            if (!map[markerName]) {
+                continue;
+            }
+            this.lastKnownMarker = markerName;
+            const filePath = marker.fileName;
+            const expectedCompletions = map[markerName].completions;
+            const completionPosition = this.convertOffsetToPosition(filePath, marker.position);
+            const options = { format: docFormat, snippet: true, lazyEdit: true, autoImport: true };
+            const nameMap = abbrMap ? new Map(Object.entries(abbrMap)) : undefined;
+            const result = await this.workspace.serviceInstance.getCompletionsForPosition(filePath, completionPosition, this.workspace.rootPath, options, nameMap, vscode_languageserver_1.CancellationToken.None);
+            if (result === null || result === void 0 ? void 0 : result.completionList) {
+                if (verifyMode === 'exact') {
+                    if (result.completionList.items.length !== expectedCompletions.length) {
+                        assert_1.default.fail(`${markerName} - Expected ${expectedCompletions.length} items but received ${result.completionList.items.length}. Actual completions:\n${(0, utils_1.stringify)(result.completionList.items.map((r) => r.label))}`);
+                    }
+                }
+                for (let i = 0; i < expectedCompletions.length; i++) {
+                    const expected = expectedCompletions[i];
+                    const actualIndex = result.completionList.items.findIndex((a) => a.label === expected.label &&
+                        (expected.kind ? a.kind === expected.kind : true) &&
+                        (expected.detail ? a.detail === expected.detail : true) &&
+                        (expected.documentation && vscode_languageserver_1.MarkupContent.is(a.documentation)
+                            ? a.documentation.value === expected.documentation
+                            : true));
+                    if (actualIndex >= 0) {
+                        if (verifyMode === 'excluded') {
+                            // we're not supposed to find the completions passed to the test
+                            assert_1.default.fail(`${markerName} - Completion item with label "${expected.label}" unexpected. Actual completions:\n${(0, utils_1.stringify)(result.completionList.items.map((r) => r.label))}`);
+                        }
+                        const actual = result.completionList.items[actualIndex];
+                        if (expected.additionalTextEdits !== undefined) {
+                            if (actual.additionalTextEdits === undefined) {
+                                this.workspace.serviceInstance.resolveCompletionItem(filePath, actual, options, nameMap, vscode_languageserver_1.CancellationToken.None);
+                            }
+                        }
+                        this.verifyCompletionItem(expected, actual);
+                        if (expected.documentation !== undefined) {
+                            if (actual.documentation === undefined) {
+                                this.workspace.serviceInstance.resolveCompletionItem(filePath, actual, options, nameMap, vscode_languageserver_1.CancellationToken.None);
+                            }
+                            if (vscode_languageserver_1.MarkupContent.is(actual.documentation)) {
+                                assert_1.default.strictEqual(actual.documentation.value, expected.documentation);
+                                assert_1.default.strictEqual(actual.documentation.kind, docFormat);
+                            }
+                            else {
+                                assert_1.default.fail(`${markerName} - Unexpected type of contents object "${actual.documentation}", should be MarkupContent.`);
+                            }
+                        }
+                        result.completionList.items.splice(actualIndex, 1);
+                    }
+                    else {
+                        if (verifyMode === 'included' || verifyMode === 'exact') {
+                            // we're supposed to find all items passed to the test
+                            assert_1.default.fail(`${markerName} - Completion item with label "${expected.label}" expected. Actual completions:\n${(0, utils_1.stringify)(result.completionList.items.map((r) => r.label))}`);
+                        }
+                    }
+                }
+                if (verifyMode === 'exact') {
+                    if (result.completionList.items.length !== 0) {
+                        // we removed every item we found, there should not be any remaining
+                        assert_1.default.fail(`${markerName} - Completion items unexpected: ${(0, utils_1.stringify)(result.completionList.items.map((r) => r.label))}`);
+                    }
+                }
+            }
+            else {
+                if (verifyMode !== 'exact' || expectedCompletions.length > 0) {
+                    assert_1.default.fail(`${markerName} - Failed to get completions`);
+                }
+            }
+            if (map[markerName].memberAccessInfo !== undefined && (result === null || result === void 0 ? void 0 : result.memberAccessInfo) !== undefined) {
+                const expectedModule = (_a = map[markerName].memberAccessInfo) === null || _a === void 0 ? void 0 : _a.lastKnownModule;
+                const expectedType = (_b = map[markerName].memberAccessInfo) === null || _b === void 0 ? void 0 : _b.lastKnownMemberName;
+                const expectedName = (_c = map[markerName].memberAccessInfo) === null || _c === void 0 ? void 0 : _c.unknownMemberName;
+                if (((_d = result === null || result === void 0 ? void 0 : result.memberAccessInfo) === null || _d === void 0 ? void 0 : _d.lastKnownModule) !== expectedModule ||
+                    ((_e = result === null || result === void 0 ? void 0 : result.memberAccessInfo) === null || _e === void 0 ? void 0 : _e.lastKnownMemberName) !== expectedType ||
+                    ((_f = result === null || result === void 0 ? void 0 : result.memberAccessInfo) === null || _f === void 0 ? void 0 : _f.unknownMemberName) !== expectedName) {
+                    assert_1.default.fail(`${markerName} - Expected completion results memberAccessInfo with \n    lastKnownModule: "${expectedModule}"\n    lastKnownMemberName: "${expectedType}"\n    unknownMemberName: "${expectedName}"\n  Actual memberAccessInfo:\n    lastKnownModule: "${(_h = (_g = result.memberAccessInfo) === null || _g === void 0 ? void 0 : _g.lastKnownModule) !== null && _h !== void 0 ? _h : ''}"\n    lastKnownMemberName: "${(_k = (_j = result.memberAccessInfo) === null || _j === void 0 ? void 0 : _j.lastKnownMemberName) !== null && _k !== void 0 ? _k : ''}\n    unknownMemberName: "${(_m = (_l = result.memberAccessInfo) === null || _l === void 0 ? void 0 : _l.unknownMemberName) !== null && _m !== void 0 ? _m : ''}" `);
+                }
+            }
+        }
+    }
+    verifySignature(docFormat, map) {
+        this._analyze();
+        for (const marker of this.getMarkers()) {
+            const fileName = marker.fileName;
+            const name = this.getMarkerName(marker);
+            if (!(name in map)) {
+                continue;
+            }
+            const expected = map[name];
+            const position = this.convertOffsetToPosition(fileName, marker.position);
+            const actual = this.program.getSignatureHelpForPosition(fileName, position, docFormat, vscode_languageserver_1.CancellationToken.None);
+            if (expected.noSig) {
+                assert_1.default.equal(actual, undefined);
+                continue;
+            }
+            assert_1.default.ok(actual);
+            assert_1.default.ok(actual.signatures);
+            assert_1.default.ok(expected.activeParameters);
+            assert_1.default.equal(actual.signatures.length, expected.activeParameters.length);
+            actual.signatures.forEach((sig, index) => {
+                const expectedSig = expected.signatures[index];
+                assert_1.default.equal(sig.label, expectedSig.label);
+                assert_1.default.ok(sig.parameters);
+                const actualParameters = [];
+                sig.parameters.forEach((p) => {
+                    actualParameters.push(sig.label.substring(p.startOffset, p.endOffset));
+                });
+                assert_1.default.deepEqual(actualParameters, expectedSig.parameters);
+                if (expectedSig.documentation === undefined) {
+                    assert_1.default.equal(sig.documentation, undefined);
+                }
+                else {
+                    assert_1.default.deepEqual(sig.documentation, {
+                        kind: docFormat,
+                        value: expectedSig.documentation,
+                    });
+                }
+            });
+            assert_1.default.deepEqual(actual.signatures.map((sig) => sig.activeParameter), expected.activeParameters);
+            if (expected.callHasParameters !== undefined) {
+                assert_1.default.equal(actual.callHasParameters, expected.callHasParameters);
+            }
+        }
+    }
+    verifyFindAllReferences(map) {
+        var _a;
+        this._analyze();
+        for (const marker of this.getMarkers()) {
+            const fileName = marker.fileName;
+            const name = this.getMarkerName(marker);
+            if (!(name in map)) {
+                continue;
+            }
+            const expected = map[name].references;
+            const position = this.convertOffsetToPosition(fileName, marker.position);
+            const actual = [];
+            this.program.reportReferencesForPosition(fileName, position, true, (locs) => (0, collectionUtils_1.appendArray)(actual, locs), vscode_languageserver_1.CancellationToken.None);
+            assert_1.default.strictEqual((_a = actual === null || actual === void 0 ? void 0 : actual.length) !== null && _a !== void 0 ? _a : 0, expected.length, `${name} has failed`);
+            for (const r of expected) {
+                assert_1.default.equal(actual === null || actual === void 0 ? void 0 : actual.filter((d) => this._deepEqual(d, r)).length, 1);
+            }
+        }
+    }
+    getDocumentHighlightKind(m) {
+        const kind = (m === null || m === void 0 ? void 0 : m.data) ? m.data.kind : undefined;
+        switch (kind) {
+            case 'text':
+                return vscode_languageserver_1.DocumentHighlightKind.Text;
+            case 'read':
+                return vscode_languageserver_1.DocumentHighlightKind.Read;
+            case 'write':
+                return vscode_languageserver_1.DocumentHighlightKind.Write;
+            default:
+                return undefined;
+        }
+    }
+    verifyHighlightReferences(map) {
+        var _a;
+        this._analyze();
+        for (const name of Object.keys(map)) {
+            const marker = this.getMarkerByName(name);
+            const fileName = marker.fileName;
+            const expected = map[name].references;
+            const position = this.convertOffsetToPosition(fileName, marker.position);
+            const actual = this.program.getDocumentHighlight(fileName, position, vscode_languageserver_1.CancellationToken.None);
+            assert_1.default.equal((_a = actual === null || actual === void 0 ? void 0 : actual.length) !== null && _a !== void 0 ? _a : 0, expected.length);
+            for (const r of expected) {
+                const match = actual === null || actual === void 0 ? void 0 : actual.filter((h) => this._deepEqual(h.range, r.range));
+                assert_1.default.equal(match === null || match === void 0 ? void 0 : match.length, 1);
+                if (r.kind) {
+                    assert_1.default.equal(match[0].kind, r.kind);
+                }
+            }
+        }
+    }
+    verifyFindDefinitions(map, filter = definitionProvider_1.DefinitionFilter.All) {
+        var _a;
+        this._analyze();
+        for (const marker of this.getMarkers()) {
+            const fileName = marker.fileName;
+            const name = this.getMarkerName(marker);
+            if (!(name in map)) {
+                continue;
+            }
+            const expected = map[name].definitions;
+            const position = this.convertOffsetToPosition(fileName, marker.position);
+            const actual = this.program.getDefinitionsForPosition(fileName, position, filter, vscode_languageserver_1.CancellationToken.None);
+            assert_1.default.equal((_a = actual === null || actual === void 0 ? void 0 : actual.length) !== null && _a !== void 0 ? _a : 0, expected.length);
+            for (const r of expected) {
+                assert_1.default.equal(actual === null || actual === void 0 ? void 0 : actual.filter((d) => this._deepEqual(d, r)).length, 1);
+            }
+        }
+    }
+    verifyFindTypeDefinitions(map) {
+        var _a;
+        this._analyze();
+        for (const marker of this.getMarkers()) {
+            const fileName = marker.fileName;
+            const name = this.getMarkerName(marker);
+            if (!(name in map)) {
+                continue;
+            }
+            const expected = map[name].definitions;
+            const position = this.convertOffsetToPosition(fileName, marker.position);
+            const actual = this.program.getTypeDefinitionsForPosition(fileName, position, vscode_languageserver_1.CancellationToken.None);
+            assert_1.default.strictEqual((_a = actual === null || actual === void 0 ? void 0 : actual.length) !== null && _a !== void 0 ? _a : 0, expected.length, name);
+            for (const r of expected) {
+                assert_1.default.strictEqual(actual === null || actual === void 0 ? void 0 : actual.filter((d) => this._deepEqual(d, r)).length, 1, name);
+            }
+        }
+    }
+    verifyRename(map) {
+        var _a;
+        this._analyze();
+        for (const marker of this.getMarkers()) {
+            const fileName = marker.fileName;
+            const name = this.getMarkerName(marker);
+            if (!(name in map)) {
+                continue;
+            }
+            const expected = map[name];
+            const position = this.convertOffsetToPosition(fileName, marker.position);
+            const actual = this.program.renameSymbolAtPosition(fileName, position, expected.newName, 
+            /* isDefaultWorkspace */ false, 
+            /* allowModuleRename */ false, vscode_languageserver_1.CancellationToken.None);
+            assert_1.default.equal((_a = actual === null || actual === void 0 ? void 0 : actual.edits.length) !== null && _a !== void 0 ? _a : 0, expected.changes.length);
+            for (const c of expected.changes) {
+                assert_1.default.equal(actual === null || actual === void 0 ? void 0 : actual.edits.filter((e) => this._deepEqual(e, c)).length, 1);
+            }
+        }
+    }
+    setCancelled(numberOfCalls) {
+        this._cancellationToken.setCancelled(numberOfCalls);
+    }
+    resetCancelled() {
+        this._cancellationToken.resetCancelled();
+    }
+    _isConfig(file, ignoreCase) {
+        const comparer = (0, stringUtils_1.getStringComparer)(ignoreCase);
+        return service_1.configFileNames.some((f) => comparer((0, pathUtils_1.getBaseFileName)(file.fileName), f) === 0 /* EqualTo */);
+    }
+    _convertGlobalOptionsToConfigOptions(globalOptions, mountPaths) {
+        var _a;
+        const srtRoot = "projectroot" /* projectRoot */;
+        const projectRoot = (0, pathUtils_1.normalizeSlashes)((_a = globalOptions[srtRoot]) !== null && _a !== void 0 ? _a : vfs.MODULE_PATH);
+        const configOptions = new configOptions_1.ConfigOptions(projectRoot);
+        // add more global options as we need them
+        return this._applyTestConfigOptions(configOptions, mountPaths);
+    }
+    _applyTestConfigOptions(configOptions, mountPaths) {
+        // Always enable "test mode".
+        configOptions.internalTestMode = true;
+        // Always analyze all files
+        configOptions.checkOnlyOpenFiles = false;
+        // make sure we set typing path
+        if (configOptions.stubPath === undefined) {
+            configOptions.stubPath = (0, pathUtils_1.normalizePath)((0, pathUtils_1.combinePaths)(vfs.MODULE_PATH, 'typings'));
+        }
+        configOptions.include.push((0, pathUtils_1.getFileSpec)(this.fs, configOptions.projectRoot, '.'));
+        configOptions.exclude.push((0, pathUtils_1.getFileSpec)(this.fs, configOptions.projectRoot, factory_1.typeshedFolder));
+        configOptions.exclude.push((0, pathUtils_1.getFileSpec)(this.fs, configOptions.projectRoot, factory_1.distlibFolder));
+        configOptions.exclude.push((0, pathUtils_1.getFileSpec)(this.fs, configOptions.projectRoot, factory_1.libFolder));
+        if (mountPaths) {
+            for (const mountPath of mountPaths.keys()) {
+                configOptions.exclude.push((0, pathUtils_1.getFileSpec)(this.fs, configOptions.projectRoot, mountPath));
+            }
+        }
+        return configOptions;
+    }
+    _getFileContent(fileName) {
+        const files = this.testData.files.filter((f) => (0, pathUtils_1.comparePaths)(f.fileName, fileName, this.testFS.ignoreCase) === 0 /* EqualTo */);
+        return files[0].content;
+    }
+    convertPositionToOffset(fileName, position) {
+        const lines = this._getTextRangeCollection(fileName);
+        return (0, positionUtils_1.convertPositionToOffset)(position, lines);
+    }
+    convertOffsetToPosition(fileName, offset) {
+        const lines = this._getTextRangeCollection(fileName);
+        return (0, positionUtils_1.convertOffsetToPosition)(offset, lines);
+    }
+    convertOffsetsToRange(fileName, startOffset, endOffset) {
+        const lines = this._getTextRangeCollection(fileName);
+        return {
+            start: (0, positionUtils_1.convertOffsetToPosition)(startOffset, lines),
+            end: (0, positionUtils_1.convertOffsetToPosition)(endOffset, lines),
+        };
+    }
+    _getParseResult(fileName) {
+        const file = this.program.getBoundSourceFile(fileName);
+        return file.getParseResults();
+    }
+    _getTextRangeCollection(fileName) {
+        if (fileName in this._files) {
+            return this._getParseResult(fileName).tokenizerOutput.lines;
+        }
+        // slow path
+        const fileContents = this.fs.readFileSync(fileName, 'utf8');
+        const tokenizer = new tokenizer_1.Tokenizer();
+        return tokenizer.tokenize(fileContents).lines;
+    }
+    raiseError(message) {
+        throw new Error(this._messageAtLastKnownMarker(message));
+    }
+    _messageAtLastKnownMarker(message) {
+        const locationDescription = this.lastKnownMarker
+            ? this.lastKnownMarker
+            : this._getLineColStringAtPosition(this.currentCaretPosition);
+        return `At ${locationDescription}: ${message}`;
+    }
+    _checkPostEditInvariants() {
+        // blank for now
+    }
+    _editScriptAndUpdateMarkers(fileName, editStart, editEnd, newText) {
+        // this.languageServiceAdapterHost.editScript(fileName, editStart, editEnd, newText);
+        for (const marker of this.testData.markers) {
+            if (marker.fileName === fileName) {
+                marker.position = this._updatePosition(marker.position, editStart, editEnd, newText);
+            }
+        }
+        for (const range of this.testData.ranges) {
+            if (range.fileName === fileName) {
+                range.pos = this._updatePosition(range.pos, editStart, editEnd, newText);
+                range.end = this._updatePosition(range.end, editStart, editEnd, newText);
+            }
+        }
+        this.testData.rangesByText = undefined;
+    }
+    _removeWhitespace(text) {
+        return text.replace(/\s/g, '');
+    }
+    createMultiMap(values, getKey) {
+        const map = new Map();
+        map.add = multiMapAdd;
+        map.remove = multiMapRemove;
+        if (values && getKey) {
+            for (const value of values) {
+                map.add(getKey(value), value);
+            }
+        }
+        return map;
+        function multiMapAdd(key, value) {
+            let values = this.get(key);
+            if (values) {
+                values.push(value);
+            }
+            else {
+                this.set(key, (values = [value]));
+            }
+            return values;
+        }
+        function multiMapRemove(key, value) {
+            const values = this.get(key);
+            if (values) {
+                values.forEach((v, i, arr) => {
+                    if (v === value) {
+                        arr.splice(i, 1);
+                    }
+                });
+                if (!values.length) {
+                    this.delete(key);
+                }
+            }
+        }
+    }
+    _rangeText({ fileName, pos, end }) {
+        return this._getFileContent(fileName).slice(pos, end);
+    }
+    _getOnlyRange() {
+        const ranges = this.getRanges();
+        if (ranges.length !== 1) {
+            this.raiseError('Exactly one range should be specified in the test file.');
+        }
+        return ranges[0];
+    }
+    _verifyFileContent(fileName, text) {
+        const actual = this._getFileContent(fileName);
+        if (actual !== text) {
+            throw new Error(`verifyFileContent failed:\n${this._showTextDiff(text, actual)}`);
+        }
+    }
+    _verifyTextMatches(actualText, includeWhitespace, expectedText) {
+        const removeWhitespace = (s) => (includeWhitespace ? s : this._removeWhitespace(s));
+        if (removeWhitespace(actualText) !== removeWhitespace(expectedText)) {
+            this.raiseError(`Actual range text doesn't match expected text.\n${this._showTextDiff(expectedText, actualText)}`);
+        }
+    }
+    _getSelection() {
+        return textRange_1.TextRange.fromBounds(this.currentCaretPosition, this.selectionEnd === -1 ? this.currentCaretPosition : this.selectionEnd);
+    }
+    _getLineContent(index) {
+        const text = this._getFileContent(this.activeFile.fileName);
+        const pos = this.convertPositionToOffset(this.activeFile.fileName, { line: index, character: 0 });
+        let startPos = pos;
+        let endPos = pos;
+        while (startPos > 0) {
+            const ch = text.charCodeAt(startPos - 1);
+            if (ch === 13 /* CarriageReturn */ || ch === 10 /* LineFeed */) {
+                break;
+            }
+            startPos--;
+        }
+        while (endPos < text.length) {
+            const ch = text.charCodeAt(endPos);
+            if (ch === 13 /* CarriageReturn */ || ch === 10 /* LineFeed */) {
+                break;
+            }
+            endPos++;
+        }
+        return text.substring(startPos, endPos);
+    }
+    // Get the text of the entire line the caret is currently at
+    _getCurrentLineContent() {
+        return this._getLineContent(this.convertOffsetToPosition(this.activeFile.fileName, this.currentCaretPosition).line);
+    }
+    _findFile(indexOrName) {
+        if (typeof indexOrName === 'number') {
+            const index = indexOrName;
+            if (index >= this.testData.files.length) {
+                throw new Error(`File index (${index}) in openFile was out of range. There are only ${this.testData.files.length} files in this test.`);
+            }
+            else {
+                return this.testData.files[index];
+            }
+        }
+        else if ((0, core_1.isString)(indexOrName)) {
+            const { file, availableNames } = this._tryFindFileWorker(indexOrName);
+            if (!file) {
+                throw new Error(`No test file named "${indexOrName}" exists. Available file names are: ${availableNames.join(', ')}`);
+            }
+            return file;
+        }
+        else {
+            return debug.assertNever(indexOrName);
+        }
+    }
+    _tryFindFileWorker(name) {
+        name = (0, pathUtils_1.normalizePath)(name);
+        let file;
+        const availableNames = [];
+        this.testData.files.forEach((f) => {
+            const fn = (0, pathUtils_1.normalizePath)(f.fileName);
+            if (fn) {
+                if (fn === name) {
+                    file = f;
+                }
+                availableNames.push(fn);
+            }
+        });
+        assert_1.default.ok(file);
+        return { file, availableNames };
+    }
+    _getLineColStringAtPosition(position, file = this.activeFile) {
+        const pos = this.convertOffsetToPosition(file.fileName, position);
+        return `line ${pos.line + 1}, col ${pos.character}`;
+    }
+    _showTextDiff(expected, actual) {
+        // Only show whitespace if the difference is whitespace-only.
+        if (this._differOnlyByWhitespace(expected, actual)) {
+            expected = this._makeWhitespaceVisible(expected);
+            actual = this._makeWhitespaceVisible(actual);
+        }
+        return this._displayExpectedAndActualString(expected, actual);
+    }
+    _differOnlyByWhitespace(a, b) {
+        return this._removeWhitespace(a) === this._removeWhitespace(b);
+    }
+    _displayExpectedAndActualString(expected, actual, quoted = false) {
+        const expectMsg = '\x1b[1mExpected\x1b[0m\x1b[31m';
+        const actualMsg = '\x1b[1mActual\x1b[0m\x1b[31m';
+        const expectedString = quoted ? '"' + expected + '"' : expected;
+        const actualString = quoted ? '"' + actual + '"' : actual;
+        return `\n${expectMsg}:\n${expectedString}\n\n${actualMsg}:\n${actualString}`;
+    }
+    _makeWhitespaceVisible(text) {
+        return text
+            .replace(/ /g, '\u00B7')
+            .replace(/\r/g, '\u00B6')
+            .replace(/\n/g, '\u2193\n')
+            .replace(/\t/g, '\u2192   ');
+    }
+    _updatePosition(position, editStart, editEnd, { length }) {
+        // If inside the edit, return -1 to mark as invalid
+        return position <= editStart ? position : position < editEnd ? -1 : position + length - +(editEnd - editStart);
+    }
+    _analyze() {
+        while (this.program.analyze()) {
+            // Continue to call analyze until it completes. Since we're not
+            // specifying a timeout, it should complete the first time.
+        }
+    }
+    _getDiagnosticsPerFile() {
+        const sourceFiles = this._files.map((f) => this.program.getSourceFile(f));
+        const results = sourceFiles.map((sourceFile, index) => {
+            if (sourceFile) {
+                const diagnostics = sourceFile.getDiagnostics(this.configOptions) || [];
+                const filePath = sourceFile.getFilePath();
+                const value = {
+                    filePath,
+                    parseResults: sourceFile.getParseResults(),
+                    errors: diagnostics.filter((diag) => diag.category === 0 /* Error */),
+                    warnings: diagnostics.filter((diag) => diag.category === 1 /* Warning */),
+                    information: diagnostics.filter((diag) => diag.category === 2 /* Information */),
+                };
+                return [filePath, value];
+            }
+            else {
+                this.raiseError(`Source file not found for ${this._files[index]}`);
+            }
+        });
+        return new Map(results);
+    }
+    _createAnalysisService(nullConsole, importResolverFactory, configOptions) {
+        // we do not initiate automatic analysis or file watcher in test.
+        const service = new service_1.AnalyzerService('test service', this.fs, nullConsole, () => testAccessHost, importResolverFactory, configOptions);
+        // directly set files to track rather than using fileSpec from config
+        // to discover those files from file system
+        service.test_program.setTrackedFiles(this._files
+            .filter((path) => {
+            const fileExtension = (0, pathUtils_1.getFileExtension)(path).toLowerCase();
+            return fileExtension === '.py' || fileExtension === '.pyi';
+        })
+            .filter((path) => service.isTracked(path)));
+        return service;
+    }
+    _deepEqual(a, e) {
+        try {
+            // NOTE: find better way.
+            assert_1.default.deepStrictEqual(a, e);
+        }
+        catch {
+            return false;
+        }
+        return true;
+    }
+    async _waitForFile(filePath) {
+        while (!this.fs.existsSync(filePath)) {
+            await new Promise((res) => setTimeout(() => {
+                res();
+            }, 200));
+        }
+    }
+    _getCodeActions(range) {
+        const file = range.fileName;
+        const textRange = {
+            start: this.convertOffsetToPosition(file, range.pos),
+            end: this.convertOffsetToPosition(file, range.end),
+        };
+        return this._hostSpecificFeatures.getCodeActionsForPosition(this.workspace, file, textRange, vscode_languageserver_1.CancellationToken.None);
+    }
+    async _verifyFiles(files) {
+        for (const filePath of Object.keys(files)) {
+            const expected = files[filePath];
+            const normalizedFilePath = (0, pathUtils_1.normalizeSlashes)(filePath);
+            // wait until the file exists
+            await this._waitForFile(normalizedFilePath);
+            const actual = this.fs.readFileSync(normalizedFilePath, 'utf8');
+            if (actual !== expected) {
+                this.raiseError(`doesn't contain expected result: ${(0, utils_1.stringify)(expected)}, actual: ${(0, utils_1.stringify)(actual)}`);
+            }
+        }
+    }
+    _editsAreEqual(actual, expected) {
+        if (actual === expected) {
+            return true;
+        }
+        if (actual === undefined || expected === undefined) {
+            return false;
+        }
+        return (0, textRange_1.rangesAreEqual)(actual.range, expected.range) && actual.newText === expected.newText;
+    }
+    _verifyEdit(actual, expected) {
+        if (!this._editsAreEqual(actual, expected)) {
+            this.raiseError(`doesn't contain expected result: ${(0, utils_1.stringify)(expected)}, actual: ${(0, utils_1.stringify)(actual)}`);
+        }
+    }
+    _verifyEdits(actual, expected) {
+        actual = actual !== null && actual !== void 0 ? actual : [];
+        expected = expected !== null && expected !== void 0 ? expected : [];
+        let extra = expected.slice(0);
+        let left = actual.slice(0);
+        for (const item of actual) {
+            extra = extra.filter((e) => !this._editsAreEqual(e, item));
+        }
+        for (const item of expected) {
+            left = left.filter((e) => !this._editsAreEqual(e, item));
+        }
+        if (extra.length > 0 || left.length > 0) {
+            this.raiseError(`doesn't contain expected result: ${(0, utils_1.stringify)(extra)}, actual: ${(0, utils_1.stringify)(left)}`);
+        }
+    }
+    verifyCompletionItem(expected, actual) {
+        var _a;
+        assert_1.default.strictEqual(actual.label, expected.label);
+        assert_1.default.strictEqual(actual.detail, expected.detail);
+        assert_1.default.strictEqual(actual.kind, expected.kind);
+        assert_1.default.strictEqual(actual.insertText, expected.insertionText);
+        this._verifyEdit(actual.textEdit, expected.textEdit);
+        this._verifyEdits(actual.additionalTextEdits, expected.additionalTextEdits);
+        if (expected.detailDescription !== undefined) {
+            assert_1.default.strictEqual((_a = actual.labelDetails) === null || _a === void 0 ? void 0 : _a.description, expected.detailDescription);
+        }
+    }
+}
+exports.TestState = TestState;
+function parseAndGetTestState(code, projectRoot = '/', anonymousFileName = 'unnamedFile.py') {
+    const data = (0, fourSlashParser_1.parseTestData)((0, pathUtils_1.normalizeSlashes)(projectRoot), code, anonymousFileName);
+    const state = new TestState((0, pathUtils_1.normalizeSlashes)('/'), data);
+    return { data, state };
+}
+exports.parseAndGetTestState = parseAndGetTestState;
+function getNodeForRange(codeOrState, markerName = 'marker') {
+    const state = (0, core_1.isString)(codeOrState) ? parseAndGetTestState(codeOrState).state : codeOrState;
+    const range = state.getRangeByMarkerName(markerName);
+    (0, assert_1.default)(range);
+    const textRange = textRange_1.TextRange.fromBounds(range.pos, range.end);
+    const node = getNodeAtMarker(state, markerName);
+    let current = node;
+    while (current) {
+        if (textRange_1.TextRange.containsRange(current, textRange)) {
+            return current;
+        }
+        current = current.parent;
+    }
+    return node;
+}
+exports.getNodeForRange = getNodeForRange;
+function getNodeAtMarker(codeOrState, markerName = 'marker') {
+    const state = (0, core_1.isString)(codeOrState) ? parseAndGetTestState(codeOrState).state : codeOrState;
+    const marker = state.getMarkerByName(markerName);
+    const sourceFile = state.program.getBoundSourceFile(marker.fileName);
+    (0, assert_1.default)(sourceFile);
+    const parserResults = sourceFile.getParseResults();
+    (0, assert_1.default)(parserResults);
+    const node = (0, parseTreeUtils_1.findNodeByOffset)(parserResults.parseTree, marker.position);
+    (0, assert_1.default)(node);
+    return node;
+}
+exports.getNodeAtMarker = getNodeAtMarker;
+//# sourceMappingURL=testState.js.map