3 files changed, 240 insertions, 0 deletions
diff --git a/cli/tests/unit/filereader_test.ts b/cli/tests/unit/filereader_test.ts
new file mode 100644
index 000000000..9b2cf1d12
--- /dev/null
+++ b/cli/tests/unit/filereader_test.ts
@@ -0,0 +1,220 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import { unitTest, assertEquals } from "./test_util.ts";
+
+unitTest(function fileReaderConstruct(): void {
+  const fr = new FileReader();
+  assertEquals(fr.readyState, FileReader.EMPTY);
+
+  assertEquals(FileReader.EMPTY, 0);
+  assertEquals(FileReader.LOADING, 1);
+  assertEquals(FileReader.DONE, 2);
+});
+
+unitTest(async function fileReaderLoadBlob(): Promise<void> {
+  await new Promise<void>((resolve) => {
+    const fr = new FileReader();
+    const b1 = new Blob(["Hello World"]);
+
+    assertEquals(fr.readyState, FileReader.EMPTY);
+
+    const hasOnEvents = {
+      load: false,
+      loadend: false,
+      loadstart: false,
+      progress: 0,
+    };
+    const hasDispatchedEvents = {
+      load: false,
+      loadend: false,
+      loadstart: false,
+      progress: 0,
+    };
+    let result: string | null = null;
+
+    fr.addEventListener("load", () => {
+      hasDispatchedEvents.load = true;
+    });
+    fr.addEventListener("loadend", () => {
+      hasDispatchedEvents.loadend = true;
+    });
+    fr.addEventListener("loadstart", () => {
+      hasDispatchedEvents.loadstart = true;
+    });
+    fr.addEventListener("progress", () => {
+      hasDispatchedEvents.progress += 1;
+    });
+
+    fr.onloadstart = (): void => {
+      hasOnEvents.loadstart = true;
+    };
+    fr.onprogress = (): void => {
+      assertEquals(fr.readyState, FileReader.LOADING);
+
+      hasOnEvents.progress += 1;
+    };
+    fr.onload = (): void => {
+      hasOnEvents.load = true;
+    };
+    fr.onloadend = (ev): void => {
+      hasOnEvents.loadend = true;
+      result = fr.result as string;
+
+      assertEquals(hasOnEvents.loadstart, true);
+      assertEquals(hasDispatchedEvents.loadstart, true);
+      assertEquals(hasOnEvents.load, true);
+      assertEquals(hasDispatchedEvents.load, true);
+      assertEquals(hasOnEvents.loadend, true);
+      assertEquals(hasDispatchedEvents.loadend, true);
+
+      assertEquals(fr.readyState, FileReader.DONE);
+
+      assertEquals(result, "Hello World");
+      assertEquals(ev.lengthComputable, true);
+      resolve();
+    };
+
+    fr.readAsText(b1);
+  });
+});
+
+unitTest(async function fileReaderLoadBlobDouble(): Promise<void> {
+  // impl note from https://w3c.github.io/FileAPI/
+  // Event handler for the load or error events could have started another load,
+  // if that happens the loadend event for the first load is not fired
+
+  const fr = new FileReader();
+  const b1 = new Blob(["First load"]);
+  const b2 = new Blob(["Second load"]);
+
+  await new Promise<void>((resolve) => {
+    let result: string | null = null;
+
+    fr.onload = (): void => {
+      result = fr.result as string;
+      assertEquals(result === "First load" || result === "Second load", true);
+
+      if (result === "First load") {
+        fr.readAsText(b2);
+      }
+    };
+    fr.onloadend = (): void => {
+      assertEquals(result, "Second load");
+
+      resolve();
+    };
+
+    fr.readAsText(b1);
+  });
+});
+
+unitTest(async function fileReaderLoadBlobArrayBuffer(): Promise<void> {
+  await new Promise<void>((resolve) => {
+    const fr = new FileReader();
+    const b1 = new Blob(["Hello World"]);
+    let result: ArrayBuffer | null = null;
+
+    fr.onloadend = (ev): void => {
+      assertEquals(fr.result instanceof ArrayBuffer, true);
+      result = fr.result as ArrayBuffer;
+
+      const decoder = new TextDecoder();
+      const text = decoder.decode(result);
+
+      assertEquals(text, "Hello World");
+      assertEquals(ev.lengthComputable, true);
+      resolve();
+    };
+
+    fr.readAsArrayBuffer(b1);
+  });
+});
+
+unitTest(async function fileReaderLoadBlobDataUrl(): Promise<void> {
+  await new Promise<void>((resolve) => {
+    const fr = new FileReader();
+    const b1 = new Blob(["Hello World"]);
+    let result: string | null = null;
+
+    fr.onloadend = (ev): void => {
+      result = fr.result as string;
+      assertEquals(
+        result,
+        "data:application/octet-stream;base64,SGVsbG8gV29ybGQ=",
+      );
+      assertEquals(ev.lengthComputable, true);
+      resolve();
+    };
+
+    fr.readAsDataURL(b1);
+  });
+});
+
+unitTest(async function fileReaderLoadBlobAbort(): Promise<void> {
+  await new Promise<void>((resolve) => {
+    const fr = new FileReader();
+    const b1 = new Blob(["Hello World"]);
+
+    const hasOnEvents = {
+      load: false,
+      loadend: false,
+      abort: false,
+    };
+
+    fr.onload = (): void => {
+      hasOnEvents.load = true;
+    };
+    fr.onloadend = (ev): void => {
+      hasOnEvents.loadend = true;
+
+      assertEquals(hasOnEvents.load, false);
+      assertEquals(hasOnEvents.loadend, true);
+      assertEquals(hasOnEvents.abort, true);
+
+      assertEquals(fr.readyState, FileReader.DONE);
+      assertEquals(fr.result, null);
+      assertEquals(ev.lengthComputable, false);
+      resolve();
+    };
+    fr.onabort = (): void => {
+      hasOnEvents.abort = true;
+    };
+
+    fr.readAsDataURL(b1);
+    fr.abort();
+  });
+});
+
+unitTest(async function fileReaderLoadBlobAbort(): Promise<void> {
+  await new Promise<void>((resolve) => {
+    const fr = new FileReader();
+    const b1 = new Blob(["Hello World"]);
+
+    const hasOnEvents = {
+      load: false,
+      loadend: false,
+      abort: false,
+    };
+
+    fr.onload = (): void => {
+      hasOnEvents.load = true;
+    };
+    fr.onloadend = (ev): void => {
+      hasOnEvents.loadend = true;
+
+      assertEquals(hasOnEvents.load, false);
+      assertEquals(hasOnEvents.loadend, true);
+      assertEquals(hasOnEvents.abort, true);
+
+      assertEquals(fr.readyState, FileReader.DONE);
+      assertEquals(fr.result, null);
+      assertEquals(ev.lengthComputable, false);
+      resolve();
+    };
+    fr.onabort = (): void => {
+      hasOnEvents.abort = true;
+    };
+
+    fr.readAsDataURL(b1);
+    fr.abort();
+  });
+});
diff --git a/cli/tests/unit/progressevent_test.ts b/cli/tests/unit/progressevent_test.ts
new file mode 100644
index 000000000..4f852e458
--- /dev/null
+++ b/cli/tests/unit/progressevent_test.ts
@@ -0,0 +1,18 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import { unitTest, assertEquals } from "./test_util.ts";
+
+unitTest(function progressEventConstruct(): void {
+  const progressEventDefs = new ProgressEvent("progressEventType", {});
+  assertEquals(progressEventDefs.lengthComputable, false);
+  assertEquals(progressEventDefs.loaded, 0);
+  assertEquals(progressEventDefs.total, 0);
+
+  const progressEvent = new ProgressEvent("progressEventType", {
+    lengthComputable: true,
+    loaded: 123,
+    total: 456,
+  });
+  assertEquals(progressEvent.lengthComputable, true);
+  assertEquals(progressEvent.loaded, 123);
+  assertEquals(progressEvent.total, 456);
+});
diff --git a/cli/tests/unit/unit_tests.ts b/cli/tests/unit/unit_tests.ts
index ad820a55c..03f0c6f1c 100644
--- a/cli/tests/unit/unit_tests.ts
+++ b/cli/tests/unit/unit_tests.ts
@@ -23,6 +23,7 @@ import "./event_test.ts";
 import "./event_target_test.ts";
 import "./fetch_test.ts";
 import "./file_test.ts";
+import "./filereader_test.ts";
 import "./files_test.ts";
 import "./filter_function_test.ts";
 import "./form_data_test.ts";
@@ -43,6 +44,7 @@ import "./os_test.ts";
 import "./permissions_test.ts";
 import "./path_from_url_test.ts";
 import "./process_test.ts";
+import "./progressevent_test.ts";
 import "./real_path_test.ts";
 import "./read_dir_test.ts";
 import "./read_text_file_test.ts";