Added caching, more tests

tests/cases/unittests/expandFiles.ts

@@ -1,164 +1,395 @@
 /// <reference path="..\..\..\src\harness\external\mocha.d.ts" />
 /// <reference path="..\..\..\src\harness\harness.ts" />
 
-describe("expandFiles", () => {
-    it("fail", () => {
-        assert.isTrue(false, "just checking");
-    });
+namespace ts {
+    const caseInsensitiveBasePath = "c:/dev/";
+    const caseInsensitiveHost = createMockParseConfigHost(/*ignoreCase*/ true, caseInsensitiveBasePath, [
+        "a.ts",
+        "a.d.ts",
+        "a.js",
+        "b.ts",
+        "b.js",
+        "c.d.ts",
+        "z/a.ts",
+        "z/abz.ts",
+        "z/aba.ts",
+        "z/b.ts",
+        "z/bbz.ts",
+        "z/bba.ts",
+        "x/a.ts",
+        "x/aa.ts",
+        "x/b.ts",
+        "x/y/a.ts",
+        "x/y/b.ts",
+        "js/a.js",
+        "js/b.js",
+    ]);
 
-    const basePath = "c:/dev/";
-    const caseInsensitiveHost = createMockParseConfigHost(
-        basePath,
-        /*files*/ [
-            "c:/dev/a.ts",
-            "c:/dev/a.d.ts",
-            "c:/dev/a.js",
-            "c:/dev/b.ts",
-            "c:/dev/b.js",
-            "c:/dev/c.d.ts",
-            "c:/dev/z/a.ts",
-            "c:/dev/z/abz.ts",
-            "c:/dev/z/aba.ts",
-            "c:/dev/z/b.ts",
-            "c:/dev/z/bbz.ts",
-            "c:/dev/z/bba.ts",
-            "c:/dev/x/a.ts",
-            "c:/dev/x/aa.ts",
-            "c:/dev/x/b.ts",
-            "c:/dev/x/y/a.ts",
-            "c:/dev/x/y/b.ts"
-        ],
-        /*ignoreCase*/ true);
+    const caseSensitiveBasePath = "/dev/";
+    const caseSensitiveHost = createMockParseConfigHost(/*ignoreCase*/ false, caseSensitiveBasePath, [
+        "a.ts",
+        "a.d.ts",
+        "a.js",
+        "b.ts",
+        "b.js",
+        "A.ts",
+        "B.ts",
+        "c.d.ts",
+        "z/a.ts",
+        "z/abz.ts",
+        "z/aba.ts",
+        "z/b.ts",
+        "z/bbz.ts",
+        "z/bba.ts",
+        "x/a.ts",
+        "x/b.ts",
+        "x/y/a.ts",
+        "x/y/b.ts",
+        "js/a.js",
+        "js/b.js",
+    ]);
 
-    const caseSensitiveHost = createMockParseConfigHost(
-        basePath,
-        /*files*/ [
-            "c:/dev/a.ts",
-            "c:/dev/a.d.ts",
-            "c:/dev/a.js",
-            "c:/dev/b.ts",
-            "c:/dev/b.js",
-            "c:/dev/A.ts",
-            "c:/dev/B.ts",
-            "c:/dev/c.d.ts",
-            "c:/dev/z/a.ts",
-            "c:/dev/z/abz.ts",
-            "c:/dev/z/aba.ts",
-            "c:/dev/z/b.ts",
-            "c:/dev/z/bbz.ts",
-            "c:/dev/z/bba.ts",
-            "c:/dev/x/a.ts",
-            "c:/dev/x/b.ts",
-            "c:/dev/x/y/a.ts",
-            "c:/dev/x/y/b.ts",
-        ],
-        /*ignoreCase*/ false);
+    const caseInsensitiveMixedExtensionHost = createMockParseConfigHost(/*ignoreCase*/ true, caseInsensitiveBasePath, [
+        "a.ts",
+        "a.d.ts",
+        "a.js",
+        "b.tsx",
+        "b.d.ts",
+        "b.jsx",
+        "c.tsx",
+        "c.js",
+        "d.js",
+        "e.jsx",
+        "f.other"
+    ]);
 
-    const expect = _chai.expect;
-    describe("with literal file list", () => {
-        it("without exclusions", () => {
-            const fileNames = ["a.ts", "b.ts"];
-            const results = ts.expandFiles(fileNames, /*includeSpecs*/ undefined, /*excludeSpecs*/ undefined, basePath, {}, caseInsensitiveHost);
-            assert.deepEqual(results, ["c:/dev/a.ts", "c:/dev/b.ts"]);
+    describe("expandFiles", () => {
+        describe("with literal file list", () => {
+            it("without exclusions", () => {
+                const fileNames = ["a.ts", "b.ts"];
+                const expected: ts.ExpandResult = {
+                    fileNames: ["c:/dev/a.ts", "c:/dev/b.ts"],
+                    wildcardDirectories: {},
+                };
+                const actual = ts.expandFiles(fileNames, /*includeSpecs*/ undefined, /*excludeSpecs*/ undefined, caseInsensitiveBasePath, {}, caseInsensitiveHost);
+                assert.deepEqual(actual, expected);
+            });
+            it("missing files are still present", () => {
+                const fileNames = ["z.ts", "x.ts"];
+                const expected: ts.ExpandResult = {
+                    fileNames: ["c:/dev/z.ts", "c:/dev/x.ts"],
+                    wildcardDirectories: {},
+                };
+                const actual = ts.expandFiles(fileNames, /*includeSpecs*/ undefined, /*excludeSpecs*/ undefined, caseInsensitiveBasePath, {}, caseInsensitiveHost);
+                assert.deepEqual(actual, expected);
+            });
+            it("are not removed due to excludes", () => {
+                const fileNames = ["a.ts", "b.ts"];
+                const excludeSpecs = ["b.ts"];
+                const expected: ts.ExpandResult = {
+                    fileNames: ["c:/dev/a.ts", "c:/dev/b.ts"],
+                    wildcardDirectories: {},
+                };
+                const actual = ts.expandFiles(fileNames, /*includeSpecs*/ undefined, excludeSpecs, caseInsensitiveBasePath, {}, caseInsensitiveHost);
+                assert.deepEqual(actual, expected);
+            });
         });
-        it("missing files are still present", () => {
-            const fileNames = ["z.ts", "x.ts"];
-            const results = ts.expandFiles(fileNames, /*includeSpecs*/ undefined, /*excludeSpecs*/ undefined, basePath, {}, caseInsensitiveHost);
-            assert.deepEqual(results, ["c:/dev/z.ts", "c:/dev/x.ts"]);
+
+        describe("with literal include list", () => {
+            it("without exclusions", () => {
+                const includeSpecs = ["a.ts", "b.ts"];
+                const expected: ts.ExpandResult = {
+                    fileNames: ["c:/dev/a.ts", "c:/dev/b.ts"],
+                    wildcardDirectories: {},
+                };
+                const actual = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, /*excludeSpecs*/ undefined, caseInsensitiveBasePath, {}, caseInsensitiveHost);
+                assert.deepEqual(actual, expected);
+            });
+            it("with non .ts file extensions are excluded", () => {
+                const includeSpecs = ["a.js", "b.js"];
+                const expected: ts.ExpandResult = {
+                    fileNames: [],
+                    wildcardDirectories: {},
+                };
+                const actual = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, /*excludeSpecs*/ undefined, caseInsensitiveBasePath, {}, caseInsensitiveHost);
+                assert.deepEqual(actual, expected);
+            });
+            it("with missing files are excluded", () => {
+                const includeSpecs = ["z.ts", "x.ts"];
+                const expected: ts.ExpandResult = {
+                    fileNames: [],
+                    wildcardDirectories: {},
+                };
+                const actual = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, /*excludeSpecs*/ undefined, caseInsensitiveBasePath, {}, caseInsensitiveHost);
+                assert.deepEqual(actual, expected);
+            });
+            it("with literal excludes", () => {
+                const includeSpecs = ["a.ts", "b.ts"];
+                const excludeSpecs = ["b.ts"];
+                const expected: ts.ExpandResult = {
+                    fileNames: ["c:/dev/a.ts"],
+                    wildcardDirectories: {},
+                };
+                const actual = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, excludeSpecs, caseInsensitiveBasePath, {}, caseInsensitiveHost);
+                assert.deepEqual(actual, expected);
+            });
+            it("with wildcard excludes", () => {
+                const includeSpecs = ["a.ts", "b.ts", "z/a.ts", "z/abz.ts", "z/aba.ts", "x/b.ts"];
+                const excludeSpecs = ["*.ts", "z/??z.ts", "*/b.ts"];
+                const expected: ts.ExpandResult = {
+                    fileNames: ["c:/dev/z/a.ts", "c:/dev/z/aba.ts"],
+                    wildcardDirectories: {},
+                };
+                const actual = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, excludeSpecs, caseInsensitiveBasePath, {}, caseInsensitiveHost);
+                assert.deepEqual(actual, expected);
+            });
+            it("with recursive excludes", () => {
+                const includeSpecs = ["a.ts", "b.ts", "x/a.ts", "x/b.ts", "x/y/a.ts", "x/y/b.ts"];
+                const excludeSpecs = ["**/b.ts"];
+                const expected: ts.ExpandResult = {
+                    fileNames: ["c:/dev/a.ts", "c:/dev/x/a.ts", "c:/dev/x/y/a.ts"],
+                    wildcardDirectories: {},
+                };
+                const actual = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, excludeSpecs, caseInsensitiveBasePath, {}, caseInsensitiveHost);
+                assert.deepEqual(actual, expected);
+            });
+            it("with case sensitive exclude", () => {
+                const includeSpecs = ["B.ts"];
+                const excludeSpecs = ["**/b.ts"];
+                const expected: ts.ExpandResult = {
+                    fileNames: ["/dev/B.ts"],
+                    wildcardDirectories: {},
+                };
+                const actual = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, excludeSpecs, caseSensitiveBasePath, {}, caseSensitiveHost);
+                assert.deepEqual(actual, expected);
+            });
         });
-        it("are not removed due to excludes", () => {
-            const fileNames = ["a.ts", "b.ts"];
-            const excludeSpecs = ["b.ts"];
-            const results = ts.expandFiles(fileNames, /*includeSpecs*/ undefined, excludeSpecs, basePath, {}, caseInsensitiveHost);
-            assert.deepEqual(results, ["c:/dev/a.ts", "c:/dev/b.ts"]);
+
+        describe("with wildcard include list", () => {
+            it("same named declarations are excluded", () => {
+                const includeSpecs = ["*.ts"];
+                const expected: ts.ExpandResult = {
+                    fileNames: ["c:/dev/a.ts", "c:/dev/b.ts", "c:/dev/c.d.ts"],
+                    wildcardDirectories: {
+                        "c:/dev": ts.WatchDirectoryFlags.None
+                    },
+                };
+                const actual = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, /*excludeSpecs*/ undefined, caseInsensitiveBasePath, {}, caseInsensitiveHost);
+                assert.deepEqual(actual, expected);
+            });
+            it("`*` matches only ts files", () => {
+                const includeSpecs = ["*"];
+                const expected: ts.ExpandResult = {
+                    fileNames: ["c:/dev/a.ts", "c:/dev/b.ts", "c:/dev/c.d.ts"],
+                    wildcardDirectories: {
+                        "c:/dev": ts.WatchDirectoryFlags.None
+                    },
+                };
+                const actual = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, /*excludeSpecs*/ undefined, caseInsensitiveBasePath, {}, caseInsensitiveHost);
+                assert.deepEqual(actual, expected);
+            });
+            it("`?` matches only a single character", () => {
+                const includeSpecs = ["x/?.ts"];
+                const expected: ts.ExpandResult = {
+                    fileNames: ["c:/dev/x/a.ts", "c:/dev/x/b.ts"],
+                    wildcardDirectories: {
+                        "c:/dev/x": ts.WatchDirectoryFlags.None
+                    },
+                };
+                const actual = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, /*excludeSpecs*/ undefined, caseInsensitiveBasePath, {}, caseInsensitiveHost);
+                assert.deepEqual(actual, expected);
+            });
+            it("with recursive directory", () => {
+                const includeSpecs = ["**/a.ts"];
+                const expected: ts.ExpandResult = {
+                    fileNames: ["c:/dev/a.ts", "c:/dev/x/a.ts", "c:/dev/x/y/a.ts", "c:/dev/z/a.ts"],
+                    wildcardDirectories: {
+                        "c:/dev": ts.WatchDirectoryFlags.Recursive
+                    },
+                };
+                const actual = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, /*excludeSpecs*/ undefined, caseInsensitiveBasePath, {}, caseInsensitiveHost);
+                assert.deepEqual(actual, expected);
+            });
+            it("case sensitive", () => {
+                const includeSpecs = ["**/A.ts"];
+                const expected: ts.ExpandResult = {
+                    fileNames: ["/dev/A.ts"],
+                    wildcardDirectories: {
+                        "/dev": ts.WatchDirectoryFlags.Recursive
+                    },
+                };
+                const actual = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, /*excludeSpecs*/ undefined, caseSensitiveBasePath, {}, caseSensitiveHost);
+                assert.deepEqual(actual, expected);
+            });
+            it("with missing files are excluded", () => {
+                const includeSpecs = ["*/z.ts"];
+                const expected: ts.ExpandResult = {
+                    fileNames: [],
+                    wildcardDirectories: {
+                        "c:/dev": ts.WatchDirectoryFlags.None
+                    },
+                };
+                const actual = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, /*excludeSpecs*/ undefined, caseInsensitiveBasePath, {}, caseInsensitiveHost);
+                assert.deepEqual(actual, expected);
+            });
+            it("always include literal files", () => {
+                const fileNames = ["a.ts"];
+                const includeSpecs = ["*/z.ts"];
+                const excludeSpecs = ["**/a.ts"];
+                const expected: ts.ExpandResult = {
+                    fileNames: ["c:/dev/a.ts"],
+                    wildcardDirectories: {
+                        "c:/dev": ts.WatchDirectoryFlags.None
+                    },
+                };
+                const actual = ts.expandFiles(fileNames, includeSpecs, excludeSpecs, caseInsensitiveBasePath, {}, caseInsensitiveHost);
+                assert.deepEqual(actual, expected);
+            });
+            it("exclude folders", () => {
+                const includeSpecs = ["**/*"];
+                const excludeSpecs = ["z", "x"];
+                const expected: ts.ExpandResult = {
+                    fileNames: [
+                        "c:/dev/a.ts",
+                        "c:/dev/b.ts",
+                        "c:/dev/c.d.ts"
+                    ],
+                    wildcardDirectories: {
+                        "c:/dev": ts.WatchDirectoryFlags.Recursive
+                    }
+                };
+                const actual = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, excludeSpecs, caseInsensitiveBasePath, {}, caseInsensitiveHost);
+                assert.deepEqual(actual, expected);
+            });
+            it("exclude .js files when allowJs=false", () => {
+                const includeSpecs = ["js/*"];
+                const expected: ts.ExpandResult = {
+                    fileNames: [],
+                    wildcardDirectories: {
+                        "c:/dev/js": ts.WatchDirectoryFlags.None
+                    }
+                };
+                const actual = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, /*excludeSpecs*/ undefined, caseInsensitiveBasePath, {}, caseInsensitiveHost);
+                assert.deepEqual(actual, expected);
+            });
+            it("include .js files when allowJs=true", () => {
+                const includeSpecs = ["js/*"];
+                const expected: ts.ExpandResult = {
+                    fileNames: ["c:/dev/js/a.js", "c:/dev/js/b.js"],
+                    wildcardDirectories: {
+                        "c:/dev/js": ts.WatchDirectoryFlags.None
+                    }
+                };
+                const actual = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, /*excludeSpecs*/ undefined, caseInsensitiveBasePath, { allowJs: true }, caseInsensitiveHost);
+                assert.deepEqual(actual, expected);
+            });
+        });
+
+        describe("when called from parseJsonConfigFileContent", () => {
+            it("with jsx=none, allowJs=false", () => {
+                const json: any = {
+                    "compilerOptions": {
+                        "jsx": "none",
+                        "allowJs": false
+                    }
+                };
+                const expected: ts.ExpandResult = {
+                    fileNames: [
+                        "c:/dev/a.ts",
+                        "c:/dev/b.tsx",
+                        "c:/dev/c.tsx",
+                    ],
+                    wildcardDirectories: {
+                        "c:/dev": ts.WatchDirectoryFlags.Recursive
+                    }
+                };
+                const actual = ts.parseJsonConfigFileContent(json, caseInsensitiveMixedExtensionHost, caseInsensitiveBasePath);
+                assert.deepEqual(actual.fileNames, expected.fileNames);
+                assert.deepEqual(actual.wildcardDirectories, expected.wildcardDirectories);
+            });
+            it("with jsx=preserve, allowJs=false", () => {
+                const json: any = {
+                    "compilerOptions": {
+                        "jsx": "preserve",
+                        "allowJs": false
+                    }
+                };
+                const expected: ts.ExpandResult = {
+                    fileNames: [
+                        "c:/dev/a.ts",
+                        "c:/dev/b.tsx",
+                        "c:/dev/c.tsx",
+                    ],
+                    wildcardDirectories: {
+                        "c:/dev": ts.WatchDirectoryFlags.Recursive
+                    }
+                };
+                const actual = ts.parseJsonConfigFileContent(json, caseInsensitiveMixedExtensionHost, caseInsensitiveBasePath);
+                assert.deepEqual(actual.fileNames, expected.fileNames);
+                assert.deepEqual(actual.wildcardDirectories, expected.wildcardDirectories);
+            });
+            it("with jsx=none, allowJs=true", () => {
+                const json: any = {
+                    "compilerOptions": {
+                        "jsx": "none",
+                        "allowJs": true
+                    }
+                };
+                const expected: ts.ExpandResult = {
+                    fileNames: [
+                        "c:/dev/a.ts",
+                        "c:/dev/b.tsx",
+                        "c:/dev/c.tsx",
+                        "c:/dev/d.js",
+                        "c:/dev/e.jsx",
+                    ],
+                    wildcardDirectories: {
+                        "c:/dev": ts.WatchDirectoryFlags.Recursive
+                    }
+                };
+                const actual = ts.parseJsonConfigFileContent(json, caseInsensitiveMixedExtensionHost, caseInsensitiveBasePath);
+                assert.deepEqual(actual.fileNames, expected.fileNames);
+                assert.deepEqual(actual.wildcardDirectories, expected.wildcardDirectories);
+            });
+            it("with jsx=preserve, allowJs=true", () => {
+                const json: any = {
+                    "compilerOptions": {
+                        "jsx": "preserve",
+                        "allowJs": true
+                    }
+                };
+                const expected: ts.ExpandResult = {
+                    fileNames: [
+                        "c:/dev/a.ts",
+                        "c:/dev/b.tsx",
+                        "c:/dev/c.tsx",
+                        "c:/dev/d.js",
+                        "c:/dev/e.jsx",
+                    ],
+                    wildcardDirectories: {
+                        "c:/dev": ts.WatchDirectoryFlags.Recursive
+                    }
+                };
+                const actual = ts.parseJsonConfigFileContent(json, caseInsensitiveMixedExtensionHost, caseInsensitiveBasePath);
+                assert.deepEqual(actual.fileNames, expected.fileNames);
+                assert.deepEqual(actual.wildcardDirectories, expected.wildcardDirectories);
+            });
         });
     });
 
-    describe("with literal include list", () => {
-        it("without exclusions", () => {
-            const includeSpecs = ["a.ts", "b.ts"];
-            const results = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, /*excludeSpecs*/ undefined, basePath, {}, caseInsensitiveHost);
-            assert.deepEqual(results, ["c:/dev/a.ts", "c:/dev/b.ts"]);
-        });
-        it("with non .ts file extensions are excluded", () => {
-            const includeSpecs = ["a.js", "b.js"];
-            const results = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, /*excludeSpecs*/ undefined, basePath, {}, caseInsensitiveHost);
-            assert.deepEqual(results, []);
-        });
-        it("with missing files are excluded", () => {
-            const includeSpecs = ["z.ts", "x.ts"];
-            const results = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, /*excludeSpecs*/ undefined, basePath, {}, caseInsensitiveHost);
-            assert.deepEqual(results, []);
-        });
-        it("with literal excludes", () => {
-            const includeSpecs = ["a.ts", "b.ts"];
-            const excludeSpecs = ["b.ts"];
-            const results = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, excludeSpecs, basePath, {}, caseInsensitiveHost);
-            assert.deepEqual(results, ["c:/dev/a.ts"]);
-        });
-        it("with wildcard excludes", () => {
-            const includeSpecs = ["a.ts", "b.ts", "z/a.ts", "z/abz.ts", "z/aba.ts", "x/b.ts"];
-            const excludeSpecs = ["*.ts", "z/??z.ts", "*/b.ts"];
-            const results = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, excludeSpecs, basePath, {}, caseInsensitiveHost);
-            assert.deepEqual(results, ["c:/dev/z/a.ts", "c:/dev/z/aba.ts"]);
-        });
-        it("with recursive excludes", () => {
-            const includeSpecs = ["a.ts", "b.ts", "x/a.ts", "x/b.ts", "x/y/a.ts", "x/y/b.ts"];
-            const excludeSpecs = ["**/b.ts"];
-            const results = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, excludeSpecs, basePath, {}, caseInsensitiveHost);
-            assert.deepEqual(results, ["c:/dev/a.ts", "c:/dev/x/a.ts", "c:/dev/x/y/a.ts"]);
-        });
-        it("with case sensitive exclude", () => {
-            const includeSpecs = ["B.ts"];
-            const excludeSpecs = ["**/b.ts"];
-            const results = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, excludeSpecs, basePath, {}, caseSensitiveHost);
-            assert.deepEqual(results, ["c:/dev/B.ts"]);
-        });
-    });
+    interface DirectoryEntry {
+        files: ts.Map<string>;
+        directories: ts.Map<string>;
+    }
 
-    describe("with wildcard include list", () => {
-        it("same named declarations are excluded", () => {
-            const includeSpecs = ["*.ts"];
-            const results = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, /*excludeSpecs*/ undefined, basePath, {}, caseInsensitiveHost);
-            assert.deepEqual(results, ["c:/dev/a.ts", "c:/dev/b.ts", "c:/dev/c.d.ts"]);
-        });
-        it("`*` matches only ts files", () => {
-            const includeSpecs = ["*"];
-            const results = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, /*excludeSpecs*/ undefined, basePath, {}, caseInsensitiveHost);
-            assert.deepEqual(results, ["c:/dev/a.ts", "c:/dev/b.ts", "c:/dev/c.d.ts"]);
-        });
-        it("`?` matches only a single character", () => {
-            const includeSpecs = ["x/?.ts"];
-            const results = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, /*excludeSpecs*/ undefined, basePath, {}, caseInsensitiveHost);
-            assert.deepEqual(results, ["c:/dev/x/a.ts", "c:/dev/x/b.ts"]);
-        });
-        it("with recursive directory", () => {
-            const includeSpecs = ["**/a.ts"];
-            const results = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, /*excludeSpecs*/ undefined, basePath, {}, caseInsensitiveHost);
-            assert.deepEqual(results, ["c:/dev/a.ts", "c:/dev/x/a.ts", "c:/dev/x/y/a.ts", "c:/dev/z/a.ts"]);
-        });
-        it("case sensitive", () => {
-            const includeSpecs = ["**/A.ts"];
-            const results = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, /*excludeSpecs*/ undefined, basePath, {}, caseSensitiveHost);
-            assert.deepEqual(results, ["c:/dev/A.ts"]);
-        });
-        it("with missing files are excluded", () => {
-            const includeSpecs = ["*/z.ts"];
-            const results = ts.expandFiles(/*fileNames*/ undefined, includeSpecs, /*excludeSpecs*/ undefined, basePath, {}, caseInsensitiveHost);
-            assert.deepEqual(results, []);
-        });
-        it("always include literal files", () => {
-            const fileNames = ["a.ts"];
-            const includeSpecs = ["*/z.ts"];
-            const excludeSpecs = ["**/a.ts"];
-            const results = ts.expandFiles(fileNames, includeSpecs, excludeSpecs, basePath, {}, caseInsensitiveHost);
-            assert.deepEqual(results, ["c:/dev/a.ts"]);
-        });
-    });
+    interface TestParseConfigHost extends ts.ParseConfigHost {
+        basePath: string;
+    }
 
-    function createMockParseConfigHost(basePath: string, files: string[], ignoreCase: boolean): ts.ParseConfigHost {
+    function createMockParseConfigHost(ignoreCase: boolean, basePath: string, files: string[]): TestParseConfigHost {
         const fileSet: ts.Map<string> = {};
-        const directorySet: ts.Map<{ files: ts.Map<string>; directories: ts.Map<string>; }> = {};
+        const directorySet: ts.Map<DirectoryEntry> = {};
+        const emptyDirectory: DirectoryEntry = { files: {}, directories: {} };
 
         files.sort((a, b) => ts.comparePaths(a, b, basePath, ignoreCase));
         for (const file of files) {
@@ -167,18 +398,24 @@ describe("expandFiles", () => {
 
         return {
             useCaseSensitiveFileNames: !ignoreCase,
+            basePath,
             fileExists,
+            directoryExists,
             readDirectory,
             readFileNames,
             readDirectoryNames
         };
 
         function fileExists(path: string): boolean {
+            path = ts.getNormalizedAbsolutePath(path, basePath);
+            path = ts.removeTrailingDirectorySeparator(path);
             const fileKey = ignoreCase ? path.toLowerCase() : path;
             return ts.hasProperty(fileSet, fileKey);
         }
 
         function directoryExists(path: string): boolean {
+            path = ts.getNormalizedAbsolutePath(path, basePath);
+            path = ts.removeTrailingDirectorySeparator(path);
             const directoryKey = ignoreCase ? path.toLowerCase() : path;
             return ts.hasProperty(directorySet, directoryKey);
         }
@@ -188,7 +425,7 @@ describe("expandFiles", () => {
         }
 
         function readFileNames(path: string) {
-            const files = getDirectoryEntry(path).files;
+            const { files } = getDirectoryEntry(path) || emptyDirectory;
             const result: string[] = [];
             ts.forEachKey(files, key => { result.push(key); });
             result.sort((a, b) => ts.compareStrings(a, b, ignoreCase));
@@ -196,7 +433,7 @@ describe("expandFiles", () => {
         }
 
         function readDirectoryNames(path: string) {
-            const directories = getDirectoryEntry(path).directories;
+            const { directories } = getDirectoryEntry(path); // || emptyDirectory;
             const result: string[] = [];
             ts.forEachKey(directories, key => { result.push(key); });
             result.sort((a, b) => ts.compareStrings(a, b, ignoreCase));
@@ -245,5 +482,4 @@ describe("expandFiles", () => {
             }
         }
     }
-});
-
+}