Merge branch 'master' into incrementalBuildInfo

src/testRunner/parallel/host.ts

@@ -538,25 +538,23 @@ namespace Harness.Parallel.Host {
 
                 let xunitReporter: import("mocha").reporters.XUnit | undefined;
                 let failedTestReporter: import("../../../scripts/failed-tests") | undefined;
-                if (Utils.getExecutionEnvironment() !== Utils.ExecutionEnvironment.Browser) {
-                    if (process.env.CI === "true") {
-                        xunitReporter = new Mocha.reporters.XUnit(replayRunner, {
-                            reporterOptions: {
-                                suiteName: "Tests",
-                                output: "./TEST-results.xml"
-                            }
-                        });
-                        patchStats(xunitReporter.stats);
-                        xunitReporter.write(`<?xml version="1.0" encoding="UTF-8"?>\n`);
-                    }
-                    else {
-                        failedTestReporter = new FailedTestReporter(replayRunner, {
-                            reporterOptions: {
-                                file: path.resolve(".failed-tests"),
-                                keepFailed
-                            }
-                        });
-                    }
+                if (process.env.CI === "true") {
+                    xunitReporter = new Mocha.reporters.XUnit(replayRunner, {
+                        reporterOptions: {
+                            suiteName: "Tests",
+                            output: "./TEST-results.xml"
+                        }
+                    });
+                    patchStats(xunitReporter.stats);
+                    xunitReporter.write(`<?xml version="1.0" encoding="UTF-8"?>\n`);
+                }
+                else {
+                    failedTestReporter = new FailedTestReporter(replayRunner, {
+                        reporterOptions: {
+                            file: path.resolve(".failed-tests"),
+                            keepFailed
+                        }
+                    });
                 }
 
                 const savedUseColors = Base.useColors;

src/testRunner/runner.ts

@@ -182,10 +182,7 @@ function handleTestConfig() {
         runners.push(new CompilerBaselineRunner(CompilerTestType.Conformance));
         runners.push(new CompilerBaselineRunner(CompilerTestType.Regressions));
 
-        // TODO: project tests don"t work in the browser yet
-        if (Utils.getExecutionEnvironment() !== Utils.ExecutionEnvironment.Browser) {
-            runners.push(new project.ProjectRunner());
-        }
+        runners.push(new project.ProjectRunner());
 
         // language services
         runners.push(new FourSlashRunner(FourSlash.FourSlashTestType.Native));
@@ -195,7 +192,7 @@ function handleTestConfig() {
         // runners.push(new GeneratedFourslashRunner());
 
         // CRON-only tests
-        if (Utils.getExecutionEnvironment() !== Utils.ExecutionEnvironment.Browser && process.env.TRAVIS_EVENT_TYPE === "cron") {
+        if (process.env.TRAVIS_EVENT_TYPE === "cron") {
             runners.push(new UserCodeRunner());
         }
     }
@@ -229,13 +226,11 @@ function beginTests() {
 let isWorker: boolean;
 function startTestEnvironment() {
     isWorker = handleTestConfig();
-    if (Utils.getExecutionEnvironment() !== Utils.ExecutionEnvironment.Browser) {
-        if (isWorker) {
-            return Harness.Parallel.Worker.start();
-        }
-        else if (taskConfigsFolder && workerCount && workerCount > 1) {
-            return Harness.Parallel.Host.start();
-        }
+    if (isWorker) {
+        return Harness.Parallel.Worker.start();
+    }
+    else if (taskConfigsFolder && workerCount && workerCount > 1) {
+        return Harness.Parallel.Host.start();
     }
     beginTests();
 }

src/testRunner/tsconfig.json

@@ -105,6 +105,7 @@
         "unittests/tscWatch/resolutionCache.ts",
         "unittests/tscWatch/watchEnvironment.ts",
         "unittests/tscWatch/watchApi.ts",
+        "unittests/tsserver/applyChangesToOpenFiles.ts",
         "unittests/tsserver/cachingFileSystemInformation.ts",
         "unittests/tsserver/cancellationToken.ts",
         "unittests/tsserver/compileOnSave.ts",

src/testRunner/unittests/services/textChanges.ts

@@ -140,13 +140,13 @@ var z = 3; // comment 4
                 deleteNode(changeTracker, sourceFile, findVariableStatementContaining("y", sourceFile));
             });
             runSingleFileTest("deleteNode2", /*placeOpenBraceOnNewLineForFunctions*/ false, text, /*validateNodes*/ false, (sourceFile, changeTracker) => {
-                deleteNode(changeTracker, sourceFile, findVariableStatementContaining("y", sourceFile), { useNonAdjustedStartPosition: true });
+                deleteNode(changeTracker, sourceFile, findVariableStatementContaining("y", sourceFile), { leadingTriviaOption: textChanges.LeadingTriviaOption.Exclude });
             });
             runSingleFileTest("deleteNode3", /*placeOpenBraceOnNewLineForFunctions*/ false, text, /*validateNodes*/ false, (sourceFile, changeTracker) => {
-                deleteNode(changeTracker, sourceFile, findVariableStatementContaining("y", sourceFile), { useNonAdjustedEndPosition: true });
+                deleteNode(changeTracker, sourceFile, findVariableStatementContaining("y", sourceFile), { trailingTriviaOption: textChanges.TrailingTriviaOption.Exclude });
             });
             runSingleFileTest("deleteNode4", /*placeOpenBraceOnNewLineForFunctions*/ false, text, /*validateNodes*/ false, (sourceFile, changeTracker) => {
-                deleteNode(changeTracker, sourceFile, findVariableStatementContaining("y", sourceFile), { useNonAdjustedStartPosition: true, useNonAdjustedEndPosition: true });
+                deleteNode(changeTracker, sourceFile, findVariableStatementContaining("y", sourceFile), { leadingTriviaOption: textChanges.LeadingTriviaOption.Exclude, trailingTriviaOption: textChanges.TrailingTriviaOption.Exclude });
             });
             runSingleFileTest("deleteNode5", /*placeOpenBraceOnNewLineForFunctions*/ false, text, /*validateNodes*/ false, (sourceFile, changeTracker) => {
                 deleteNode(changeTracker, sourceFile, findVariableStatementContaining("x", sourceFile));
@@ -167,15 +167,15 @@ var a = 4; // comment 7
             });
             runSingleFileTest("deleteNodeRange2", /*placeOpenBraceOnNewLineForFunctions*/ false, text, /*validateNodes*/ false, (sourceFile, changeTracker) => {
                 changeTracker.deleteNodeRange(sourceFile, findVariableStatementContaining("y", sourceFile), findVariableStatementContaining("z", sourceFile),
-                    { useNonAdjustedStartPosition: true });
+                    { leadingTriviaOption: textChanges.LeadingTriviaOption.Exclude });
             });
             runSingleFileTest("deleteNodeRange3", /*placeOpenBraceOnNewLineForFunctions*/ false, text, /*validateNodes*/ false, (sourceFile, changeTracker) => {
                 changeTracker.deleteNodeRange(sourceFile, findVariableStatementContaining("y", sourceFile), findVariableStatementContaining("z", sourceFile),
-                    { useNonAdjustedEndPosition: true });
+                    { trailingTriviaOption: textChanges.TrailingTriviaOption.Exclude });
             });
             runSingleFileTest("deleteNodeRange4", /*placeOpenBraceOnNewLineForFunctions*/ false, text, /*validateNodes*/ false, (sourceFile, changeTracker) => {
                 changeTracker.deleteNodeRange(sourceFile, findVariableStatementContaining("y", sourceFile), findVariableStatementContaining("z", sourceFile),
-                    { useNonAdjustedStartPosition: true, useNonAdjustedEndPosition: true });
+                    { leadingTriviaOption: textChanges.LeadingTriviaOption.Exclude, trailingTriviaOption: textChanges.TrailingTriviaOption.Exclude });
             });
         }
         function createTestVariableDeclaration(name: string) {
@@ -254,16 +254,16 @@ var a = 4; // comment 7`;
                 changeTracker.replaceNode(sourceFile, findVariableStatementContaining("y", sourceFile), createTestClass(), { suffix: newLineCharacter });
             });
             runSingleFileTest("replaceNode2", /*placeOpenBraceOnNewLineForFunctions*/ true, text, /*validateNodes*/ true, (sourceFile, changeTracker) => {
-                changeTracker.replaceNode(sourceFile, findVariableStatementContaining("y", sourceFile), createTestClass(), { useNonAdjustedStartPosition: true, suffix: newLineCharacter, prefix: newLineCharacter });
+                changeTracker.replaceNode(sourceFile, findVariableStatementContaining("y", sourceFile), createTestClass(), { leadingTriviaOption: textChanges.LeadingTriviaOption.Exclude, suffix: newLineCharacter, prefix: newLineCharacter });
             });
             runSingleFileTest("replaceNode3", /*placeOpenBraceOnNewLineForFunctions*/ true, text, /*validateNodes*/ true, (sourceFile, changeTracker) => {
-                changeTracker.replaceNode(sourceFile, findVariableStatementContaining("y", sourceFile), createTestClass(), { useNonAdjustedEndPosition: true, suffix: newLineCharacter });
+                changeTracker.replaceNode(sourceFile, findVariableStatementContaining("y", sourceFile), createTestClass(), { trailingTriviaOption: textChanges.TrailingTriviaOption.Exclude, suffix: newLineCharacter });
             });
             runSingleFileTest("replaceNode4", /*placeOpenBraceOnNewLineForFunctions*/ true, text, /*validateNodes*/ true, (sourceFile, changeTracker) => {
-                changeTracker.replaceNode(sourceFile, findVariableStatementContaining("y", sourceFile), createTestClass(), { useNonAdjustedStartPosition: true, useNonAdjustedEndPosition: true });
+                changeTracker.replaceNode(sourceFile, findVariableStatementContaining("y", sourceFile), createTestClass(), { leadingTriviaOption: textChanges.LeadingTriviaOption.Exclude, trailingTriviaOption: textChanges.TrailingTriviaOption.Exclude });
             });
             runSingleFileTest("replaceNode5", /*placeOpenBraceOnNewLineForFunctions*/ true, text, /*validateNodes*/ true, (sourceFile, changeTracker) => {
-                changeTracker.replaceNode(sourceFile, findVariableStatementContaining("x", sourceFile), createTestClass(), { useNonAdjustedStartPosition: true, useNonAdjustedEndPosition: true });
+                changeTracker.replaceNode(sourceFile, findVariableStatementContaining("x", sourceFile), createTestClass(), { leadingTriviaOption: textChanges.LeadingTriviaOption.Exclude, trailingTriviaOption: textChanges.TrailingTriviaOption.Exclude });
             });
         }
         {
@@ -279,13 +279,13 @@ var a = 4; // comment 7`;
                 changeTracker.replaceNodeRange(sourceFile, findVariableStatementContaining("y", sourceFile), findVariableStatementContaining("z", sourceFile), createTestClass(), { suffix: newLineCharacter });
             });
             runSingleFileTest("replaceNodeRange2", /*placeOpenBraceOnNewLineForFunctions*/ true, text, /*validateNodes*/ true, (sourceFile, changeTracker) => {
-                changeTracker.replaceNodeRange(sourceFile, findVariableStatementContaining("y", sourceFile), findVariableStatementContaining("z", sourceFile), createTestClass(), { useNonAdjustedStartPosition: true, suffix: newLineCharacter, prefix: newLineCharacter });
+                changeTracker.replaceNodeRange(sourceFile, findVariableStatementContaining("y", sourceFile), findVariableStatementContaining("z", sourceFile), createTestClass(), { leadingTriviaOption: textChanges.LeadingTriviaOption.Exclude, suffix: newLineCharacter, prefix: newLineCharacter });
             });
             runSingleFileTest("replaceNodeRange3", /*placeOpenBraceOnNewLineForFunctions*/ true, text, /*validateNodes*/ true, (sourceFile, changeTracker) => {
-                changeTracker.replaceNodeRange(sourceFile, findVariableStatementContaining("y", sourceFile), findVariableStatementContaining("z", sourceFile), createTestClass(), { useNonAdjustedEndPosition: true, suffix: newLineCharacter });
+                changeTracker.replaceNodeRange(sourceFile, findVariableStatementContaining("y", sourceFile), findVariableStatementContaining("z", sourceFile), createTestClass(), { trailingTriviaOption: textChanges.TrailingTriviaOption.Exclude, suffix: newLineCharacter });
             });
             runSingleFileTest("replaceNodeRange4", /*placeOpenBraceOnNewLineForFunctions*/ true, text, /*validateNodes*/ true, (sourceFile, changeTracker) => {
-                changeTracker.replaceNodeRange(sourceFile, findVariableStatementContaining("y", sourceFile), findVariableStatementContaining("z", sourceFile), createTestClass(), { useNonAdjustedStartPosition: true, useNonAdjustedEndPosition: true });
+                changeTracker.replaceNodeRange(sourceFile, findVariableStatementContaining("y", sourceFile), findVariableStatementContaining("z", sourceFile), createTestClass(), { leadingTriviaOption: textChanges.LeadingTriviaOption.Exclude, trailingTriviaOption: textChanges.TrailingTriviaOption.Exclude });
             });
         }
         {

src/testRunner/unittests/tsserver/applyChangesToOpenFiles.ts

@@ -0,0 +1,148 @@
+namespace ts.projectSystem {
+    describe("unittests:: tsserver:: applyChangesToOpenFiles", () => {
+        const configFile: File = {
+            path: "/a/b/tsconfig.json",
+            content: "{}"
+        };
+        const file3: File = {
+            path: "/a/b/file3.ts",
+            content: "let xyz = 1;"
+        };
+        const app: File = {
+            path: "/a/b/app.ts",
+            content: "let z = 1;"
+        };
+
+        function fileContentWithComment(file: File) {
+            return `// some copy right notice
+${file.content}`;
+        }
+
+        function verifyText(service: server.ProjectService, file: string, expected: string) {
+            const info = service.getScriptInfo(file)!;
+            const snap = info.getSnapshot();
+            // Verified applied in reverse order
+            assert.equal(snap.getText(0, snap.getLength()), expected, `Text of changed file: ${file}`);
+        }
+
+        function verifyProjectVersion(project: server.Project, expected: number) {
+            assert.equal(Number(project.getProjectVersion()), expected);
+        }
+
+        function verify(applyChangesToOpen: (session: TestSession) => void) {
+            const host = createServerHost([app, file3, commonFile1, commonFile2, libFile, configFile]);
+            const session = createSession(host);
+            session.executeCommandSeq<protocol.OpenRequest>({
+                command: protocol.CommandTypes.Open,
+                arguments: { file: app.path }
+            });
+            const service = session.getProjectService();
+            const project = service.configuredProjects.get(configFile.path)!;
+            assert.isDefined(project);
+            verifyProjectVersion(project, 1);
+            session.executeCommandSeq<protocol.OpenRequest>({
+                command: protocol.CommandTypes.Open,
+                arguments: {
+                    file: file3.path,
+                    fileContent: fileContentWithComment(file3)
+                }
+            });
+            verifyProjectVersion(project, 2);
+
+            // Verify Texts
+            verifyText(service, commonFile1.path, commonFile1.content);
+            verifyText(service, commonFile2.path, commonFile2.content);
+            verifyText(service, app.path, app.content);
+            verifyText(service, file3.path, fileContentWithComment(file3));
+
+            // Apply changes
+            applyChangesToOpen(session);
+
+            // Verify again
+            verifyProjectVersion(project, 3);
+            // Open file contents
+            verifyText(service, commonFile1.path, fileContentWithComment(commonFile1));
+            verifyText(service, commonFile2.path, fileContentWithComment(commonFile2));
+            verifyText(service, app.path, "let zzz = 10;let zz = 10;let z = 1;");
+            verifyText(service, file3.path, file3.content);
+        }
+
+        it("with applyChangedToOpenFiles request", () => {
+            verify(session =>
+                session.executeCommandSeq<protocol.ApplyChangedToOpenFilesRequest>({
+                    command: protocol.CommandTypes.ApplyChangedToOpenFiles,
+                    arguments: {
+                        openFiles: [
+                            {
+                                fileName: commonFile1.path,
+                                content: fileContentWithComment(commonFile1)
+                            },
+                            {
+                                fileName: commonFile2.path,
+                                content: fileContentWithComment(commonFile2)
+                            }
+                        ],
+                        changedFiles: [
+                            {
+                                fileName: app.path,
+                                changes: [
+                                    {
+                                        span: { start: 0, length: 0 },
+                                        newText: "let zzz = 10;"
+                                    },
+                                    {
+                                        span: { start: 0, length: 0 },
+                                        newText: "let zz = 10;"
+                                    }
+                                ]
+                            }
+                        ],
+                        closedFiles: [
+                            file3.path
+                        ]
+                    }
+                })
+            );
+        });
+
+        it("with updateOpen request", () => {
+            verify(session =>
+                session.executeCommandSeq<protocol.UpdateOpenRequest>({
+                    command: protocol.CommandTypes.UpdateOpen,
+                    arguments: {
+                        openFiles: [
+                            {
+                                file: commonFile1.path,
+                                fileContent: fileContentWithComment(commonFile1)
+                            },
+                            {
+                                file: commonFile2.path,
+                                fileContent: fileContentWithComment(commonFile2)
+                            }
+                        ],
+                        changedFiles: [
+                            {
+                                fileName: app.path,
+                                textChanges: [
+                                    {
+                                        start: { line: 1, offset: 1 },
+                                        end: { line: 1, offset: 1 },
+                                        newText: "let zzz = 10;",
+                                    },
+                                    {
+                                        start: { line: 1, offset: 1 },
+                                        end: { line: 1, offset: 1 },
+                                        newText: "let zz = 10;",
+                                    }
+                                ]
+                            }
+                        ],
+                        closedFiles: [
+                            file3.path
+                        ]
+                    }
+                })
+            );
+        });
+    });
+}

src/testRunner/unittests/tsserver/documentRegistry.ts

@@ -41,13 +41,13 @@ namespace ts.projectSystem {
 
         function changeFileToNotImportModule(service: TestProjectService) {
             const info = service.getScriptInfo(file.path)!;
-            service.applyChangesToFile(info, [{ span: { start: 0, length: importModuleContent.length }, newText: "" }]);
+            service.applyChangesToFile(info, singleIterator({ span: { start: 0, length: importModuleContent.length }, newText: "" }));
             checkProject(service, /*moduleIsOrphan*/ true);
         }
 
         function changeFileToImportModule(service: TestProjectService) {
             const info = service.getScriptInfo(file.path)!;
-            service.applyChangesToFile(info, [{ span: { start: 0, length: 0 }, newText: importModuleContent }]);
+            service.applyChangesToFile(info, singleIterator({ span: { start: 0, length: 0 }, newText: importModuleContent }));
             checkProject(service, /*moduleIsOrphan*/ false);
         }
 

src/testRunner/unittests/tsserver/externalProjects.ts

@@ -161,7 +161,7 @@ namespace ts.projectSystem {
             checkNumberOfInferredProjects(projectService, 0);
 
             externalFiles[0].content = "let x =1;";
-            projectService.applyChangesInOpenFiles(externalFiles, [], []);
+            projectService.applyChangesInOpenFiles(arrayIterator(externalFiles));
         });
 
         it("external project that included config files", () => {
@@ -790,9 +790,7 @@ namespace ts.projectSystem {
                 rootFiles: [{ fileName: tsconfig.path }, { fileName: jsFilePath }],
                 options: { allowJs: false }
             }]);
-            service.applyChangesInOpenFiles([
-                { fileName: jsFilePath, scriptKind: ScriptKind.JS, content: "" }
-            ], /*changedFiles*/ undefined, /*closedFiles*/ undefined);
+            service.applyChangesInOpenFiles(singleIterator({ fileName: jsFilePath, scriptKind: ScriptKind.JS, content: "" }));
             checkNumberOfProjects(service, { configuredProjects: 1, inferredProjects: 1 });
             checkProjectActualFiles(configProject, [tsconfig.path]);
             const inferredProject = service.inferredProjects[0];

src/testRunner/unittests/tsserver/projects.ts

@@ -202,7 +202,7 @@ namespace ts.projectSystem {
 
                 const host = createServerHost([file1, config1]);
                 const projectService = createProjectService(host, { useSingleInferredProject: true }, { syntaxOnly: true });
-                projectService.applyChangesInOpenFiles([{ fileName: file1.path, content: file1.content }], [], []);
+                projectService.applyChangesInOpenFiles(singleIterator({ fileName: file1.path, content: file1.content }));
 
                 checkNumberOfProjects(projectService, { inferredProjects: 1 });
                 const proj = projectService.inferredProjects[0];
@@ -588,11 +588,11 @@ namespace ts.projectSystem {
 
             const host = createServerHost([]);
             const projectService = createProjectService(host);
-            projectService.applyChangesInOpenFiles([tsFile], [], []);
+            projectService.applyChangesInOpenFiles(singleIterator(tsFile));
             const projs = projectService.synchronizeProjectList([]);
             projectService.findProject(projs[0].info!.projectName)!.getLanguageService().getNavigationBarItems(tsFile.fileName);
             projectService.synchronizeProjectList([projs[0].info!]);
-            projectService.applyChangesInOpenFiles([jsFile], [], []);
+            projectService.applyChangesInOpenFiles(singleIterator(jsFile));
         });
 
         it("config file is deleted", () => {
@@ -696,11 +696,12 @@ namespace ts.projectSystem {
             checkProjectActualFiles(configuredProjectAt(projectService, 0), [file1.path, file2.path, config.path]);
 
             // Open HTML file
-            projectService.applyChangesInOpenFiles(
-                /*openFiles*/[{ fileName: file2.path, hasMixedContent: true, scriptKind: ScriptKind.JS, content: `var hello = "hello";` }],
-                /*changedFiles*/ undefined,
-                /*closedFiles*/ undefined);
-
+            projectService.applyChangesInOpenFiles(singleIterator({
+                fileName: file2.path,
+                hasMixedContent: true,
+                scriptKind: ScriptKind.JS,
+                content: `var hello = "hello";`
+            }));
             // Now HTML file is included in the project
             checkNumberOfProjects(projectService, { configuredProjects: 1 });
             checkProjectActualFiles(configuredProjectAt(projectService, 0), [file1.path, file2.path, config.path]);
@@ -853,7 +854,7 @@ namespace ts.projectSystem {
             checkNumberOfProjects(projectService, { inferredProjects: 1 });
             projectService.applyChangesInOpenFiles(
                 /*openFiles*/ undefined,
-                /*changedFiles*/[{ fileName: file1.path, changes: [{ span: createTextSpan(0, file1.path.length), newText: "let y = 1" }] }],
+                /*changedFiles*/singleIterator({ fileName: file1.path, changes: singleIterator({ span: createTextSpan(0, file1.path.length), newText: "let y = 1" }) }),
                 /*closedFiles*/ undefined);
 
             checkNumberOfProjects(projectService, { inferredProjects: 1 });

src/testRunner/unittests/tsserver/watchEnvironment.ts

@@ -132,4 +132,79 @@ namespace ts.projectSystem {
             verifyRootedDirectoryWatch("c:/users/username/");
         });
     });
+
+    it(`unittests:: tsserver:: watchEnvironment:: tsserverProjectSystem recursive watch directory implementation does not watch files/directories in node_modules starting with "."`, () => {
+        const projectFolder = "/a/username/project";
+        const projectSrcFolder = `${projectFolder}/src`;
+        const configFile: File = {
+            path: `${projectFolder}/tsconfig.json`,
+            content: "{}"
+        };
+        const index: File = {
+            path: `${projectSrcFolder}/index.ts`,
+            content: `import {} from "file"`
+        };
+        const file1: File = {
+            path: `${projectSrcFolder}/file1.ts`,
+            content: ""
+        };
+        const nodeModulesExistingUnusedFile: File = {
+            path: `${projectFolder}/node_modules/someFile.d.ts`,
+            content: ""
+        };
+
+        const fileNames = [index, file1, configFile, libFile].map(file => file.path);
+        // All closed files(files other than index), project folder, project/src folder and project/node_modules/@types folder
+        const expectedWatchedFiles = arrayToMap(fileNames.slice(1), identity, () => 1);
+        const expectedWatchedDirectories = arrayToMap([projectFolder, projectSrcFolder, `${projectFolder}/${nodeModules}`, `${projectFolder}/${nodeModulesAtTypes}`], identity, () => 1);
+
+        const environmentVariables = createMap<string>();
+        environmentVariables.set("TSC_WATCHDIRECTORY", Tsc_WatchDirectory.NonRecursiveWatchDirectory);
+        const host = createServerHost([index, file1, configFile, libFile, nodeModulesExistingUnusedFile], { environmentVariables });
+        const projectService = createProjectService(host);
+        projectService.openClientFile(index.path);
+
+        const project = Debug.assertDefined(projectService.configuredProjects.get(configFile.path));
+        verifyProject();
+
+        const nodeModulesIgnoredFileFromIgnoreDirectory: File = {
+            path: `${projectFolder}/node_modules/.cache/someFile.d.ts`,
+            content: ""
+        };
+        host.ensureFileOrFolder(nodeModulesIgnoredFileFromIgnoreDirectory);
+        host.checkTimeoutQueueLength(0);
+        verifyProject();
+
+        const nodeModulesIgnoredFile: File = {
+            path: `${projectFolder}/node_modules/.cacheFile.ts`,
+            content: ""
+        };
+        host.ensureFileOrFolder(nodeModulesIgnoredFile);
+        host.checkTimeoutQueueLength(0);
+        verifyProject();
+
+        const gitIgnoredFileFromIgnoreDirectory: File = {
+            path: `${projectFolder}/.git/someFile.d.ts`,
+            content: ""
+        };
+        host.ensureFileOrFolder(gitIgnoredFileFromIgnoreDirectory);
+        host.checkTimeoutQueueLength(0);
+        verifyProject();
+
+        const gitIgnoredFile: File = {
+            path: `${projectFolder}/.gitCache.d.ts`,
+            content: ""
+        };
+        host.ensureFileOrFolder(gitIgnoredFile);
+        host.checkTimeoutQueueLength(0);
+        verifyProject();
+
+        function verifyProject() {
+            checkWatchedDirectories(host, emptyArray, /*recursive*/ true);
+            checkWatchedFilesDetailed(host, expectedWatchedFiles);
+            checkWatchedDirectoriesDetailed(host, expectedWatchedDirectories, /*recursive*/ false);
+            checkProjectActualFiles(project, fileNames);
+        }
+    });
+
 }