diff --git a/src/harness/loggedIO.ts b/src/harness/loggedIO.ts
index 81b5e4a672d54..25e982cf6804e 100644
--- a/src/harness/loggedIO.ts
+++ b/src/harness/loggedIO.ts
@@ -8,7 +8,12 @@ interface FileInformation {
 }
 
 interface FindFileResult {
+}
 
+interface IOLogFile {
+    path: string;
+    codepage: number;
+    result?: FileInformation;
 }
 
 interface IOLog {
@@ -17,11 +22,7 @@ interface IOLog {
     executingPath: string;
     currentDirectory: string;
     useCustomLibraryFile?: boolean;
-    filesRead: {
-        path: string;
-        codepage: number;
-        result?: FileInformation;
-    }[];
+    filesRead: IOLogFile[];
     filesWritten: {
         path: string;
         contents: string;
@@ -61,7 +62,7 @@ interface IOLog {
     }[];
     directoriesRead: {
         path: string,
-        extension: string[],
+        extensions: string[],
         exclude: string[],
         include: string[],
         result: string[]
@@ -170,8 +171,7 @@ namespace Playback {
             path => callAndRecord(underlying.fileExists(path), recordLog.fileExists, { path }),
             memoize(path => {
                 // If we read from the file, it must exist
-                const noResult = {};
-                if (findResultByPath(wrapper, replayLog.filesRead, path, noResult) !== noResult) {
+                if (findFileByPath(wrapper, replayLog.filesRead, path, /*throwFileNotFoundError*/ false)) {
                     return true;
                 }
                 else {
@@ -215,16 +215,30 @@ namespace Playback {
                 recordLog.filesRead.push(logEntry);
                 return result;
             },
-            memoize(path => findResultByPath(wrapper, replayLog.filesRead, path).contents));
+            memoize(path => findFileByPath(wrapper, replayLog.filesRead, path, /*throwFileNotFoundError*/ true).contents));
 
         wrapper.readDirectory = recordReplay(wrapper.readDirectory, underlying)(
-            (path, extension, exclude, include) => {
-                const result = (<ts.System>underlying).readDirectory(path, extension, exclude, include);
-                const logEntry = { path, extension, exclude, include, result };
+            (path, extensions, exclude, include) => {
+                const result = (<ts.System>underlying).readDirectory(path, extensions, exclude, include);
+                const logEntry = { path, extensions, exclude, include, result };
                 recordLog.directoriesRead.push(logEntry);
                 return result;
             },
-            (path, extension, exclude) => findResultByPath(wrapper, replayLog.directoriesRead, path));
+            (path, extensions, exclude) => {
+                // Because extensions is an array of all allowed extension, we will want to merge each of the replayLog.directoriesRead into one
+                // if each of the directoriesRead has matched path with the given path (directory with same path but different extension will considered
+                // different entry).
+                // TODO (yuisu): We can certainly remove these once we recapture the RWC using new API
+                const normalizedPath = ts.normalizePath(path).toLowerCase();
+                const result: string[] = [];
+                 for (const directory of replayLog.directoriesRead) {
+                    if (ts.normalizeSlashes(directory.path).toLowerCase() === normalizedPath) {
+                        result.push(...directory.result);
+                    }
+                }
+
+                return result;
+            });
 
         wrapper.writeFile = recordReplay(wrapper.writeFile, underlying)(
             (path: string, contents: string) => callAndRecord(underlying.writeFile(path, contents), recordLog.filesWritten, { path, contents, bom: false }),
@@ -279,30 +293,22 @@ namespace Playback {
         return results[0].result;
     }
 
-    function findResultByPath<T>(wrapper: { resolvePath(s: string): string }, logArray: { path: string; result?: T }[], expectedPath: string, defaultValue?: T): T {
+    function findFileByPath(wrapper: { resolvePath(s: string): string }, logArray: IOLogFile[],
+        expectedPath: string, throwFileNotFoundError: boolean): FileInformation {
         const normalizedName = ts.normalizePath(expectedPath).toLowerCase();
         // Try to find the result through normal fileName
-        for (let i = 0; i < logArray.length; i++) {
-            if (ts.normalizeSlashes(logArray[i].path).toLowerCase() === normalizedName) {
-                return logArray[i].result;
-            }
-        }
-        // Fallback, try to resolve the target paths as well
-        if (replayLog.pathsResolved.length > 0) {
-            const normalizedResolvedName = wrapper.resolvePath(expectedPath).toLowerCase();
-            for (let i = 0; i < logArray.length; i++) {
-                if (wrapper.resolvePath(logArray[i].path).toLowerCase() === normalizedResolvedName) {
-                    return logArray[i].result;
-                }
+        for (const log of logArray) {
+            if (ts.normalizeSlashes(log.path).toLowerCase() === normalizedName) {
+                return log.result;
             }
         }
 
         // If we got here, we didn't find a match
-        if (defaultValue === undefined) {
+        if (throwFileNotFoundError) {
             throw new Error("No matching result in log array for path: " + expectedPath);
         }
         else {
-            return defaultValue;
+            return undefined;
         }
     }