diff --git a/test/unit/cmap_spec.js b/test/unit/cmap_spec.js
index b20a4409d..2fd77d30d 100644
--- a/test/unit/cmap_spec.js
+++ b/test/unit/cmap_spec.js
@@ -40,305 +40,218 @@ describe("cmap", function () {
     fetchBuiltInCMap = null;
   });
 
-  it("parses beginbfchar", function (done) {
+  it("parses beginbfchar", async function () {
     // prettier-ignore
     const str = "2 beginbfchar\n" +
               "<03> <00>\n" +
               "<04> <01>\n" +
               "endbfchar\n";
     const stream = new StringStream(str);
-    const cmapPromise = CMapFactory.create({ encoding: stream });
-    cmapPromise
-      .then(function (cmap) {
-        expect(cmap.lookup(0x03)).toEqual(String.fromCharCode(0x00));
-        expect(cmap.lookup(0x04)).toEqual(String.fromCharCode(0x01));
-        expect(cmap.lookup(0x05)).toBeUndefined();
-        done();
-      })
-      .catch(function (reason) {
-        done.fail(reason);
-      });
+    const cmap = await CMapFactory.create({ encoding: stream });
+    expect(cmap.lookup(0x03)).toEqual(String.fromCharCode(0x00));
+    expect(cmap.lookup(0x04)).toEqual(String.fromCharCode(0x01));
+    expect(cmap.lookup(0x05)).toBeUndefined();
   });
-  it("parses beginbfrange with range", function (done) {
+
+  it("parses beginbfrange with range", async function () {
     // prettier-ignore
     const str = "1 beginbfrange\n" +
               "<06> <0B> 0\n" +
               "endbfrange\n";
     const stream = new StringStream(str);
-    const cmapPromise = CMapFactory.create({ encoding: stream });
-    cmapPromise
-      .then(function (cmap) {
-        expect(cmap.lookup(0x05)).toBeUndefined();
-        expect(cmap.lookup(0x06)).toEqual(String.fromCharCode(0x00));
-        expect(cmap.lookup(0x0b)).toEqual(String.fromCharCode(0x05));
-        expect(cmap.lookup(0x0c)).toBeUndefined();
-        done();
-      })
-      .catch(function (reason) {
-        done.fail(reason);
-      });
+    const cmap = await CMapFactory.create({ encoding: stream });
+    expect(cmap.lookup(0x05)).toBeUndefined();
+    expect(cmap.lookup(0x06)).toEqual(String.fromCharCode(0x00));
+    expect(cmap.lookup(0x0b)).toEqual(String.fromCharCode(0x05));
+    expect(cmap.lookup(0x0c)).toBeUndefined();
   });
-  it("parses beginbfrange with array", function (done) {
+
+  it("parses beginbfrange with array", async function () {
     // prettier-ignore
     const str = "1 beginbfrange\n" +
               "<0D> <12> [ 0 1 2 3 4 5 ]\n" +
               "endbfrange\n";
     const stream = new StringStream(str);
-    const cmapPromise = CMapFactory.create({ encoding: stream });
-    cmapPromise
-      .then(function (cmap) {
-        expect(cmap.lookup(0x0c)).toBeUndefined();
-        expect(cmap.lookup(0x0d)).toEqual(0x00);
-        expect(cmap.lookup(0x12)).toEqual(0x05);
-        expect(cmap.lookup(0x13)).toBeUndefined();
-        done();
-      })
-      .catch(function (reason) {
-        done.fail(reason);
-      });
+    const cmap = await CMapFactory.create({ encoding: stream });
+    expect(cmap.lookup(0x0c)).toBeUndefined();
+    expect(cmap.lookup(0x0d)).toEqual(0x00);
+    expect(cmap.lookup(0x12)).toEqual(0x05);
+    expect(cmap.lookup(0x13)).toBeUndefined();
   });
-  it("parses begincidchar", function (done) {
+
+  it("parses begincidchar", async function () {
     // prettier-ignore
     const str = "1 begincidchar\n" +
               "<14> 0\n" +
               "endcidchar\n";
     const stream = new StringStream(str);
-    const cmapPromise = CMapFactory.create({ encoding: stream });
-    cmapPromise
-      .then(function (cmap) {
-        expect(cmap.lookup(0x14)).toEqual(0x00);
-        expect(cmap.lookup(0x15)).toBeUndefined();
-        done();
-      })
-      .catch(function (reason) {
-        done.fail(reason);
-      });
+    const cmap = await CMapFactory.create({ encoding: stream });
+    expect(cmap.lookup(0x14)).toEqual(0x00);
+    expect(cmap.lookup(0x15)).toBeUndefined();
   });
-  it("parses begincidrange", function (done) {
+
+  it("parses begincidrange", async function () {
     // prettier-ignore
     const str = "1 begincidrange\n" +
               "<0016> <001B>   0\n" +
               "endcidrange\n";
     const stream = new StringStream(str);
-    const cmapPromise = CMapFactory.create({ encoding: stream });
-    cmapPromise
-      .then(function (cmap) {
-        expect(cmap.lookup(0x15)).toBeUndefined();
-        expect(cmap.lookup(0x16)).toEqual(0x00);
-        expect(cmap.lookup(0x1b)).toEqual(0x05);
-        expect(cmap.lookup(0x1c)).toBeUndefined();
-        done();
-      })
-      .catch(function (reason) {
-        done.fail(reason);
-      });
+    const cmap = await CMapFactory.create({ encoding: stream });
+    expect(cmap.lookup(0x15)).toBeUndefined();
+    expect(cmap.lookup(0x16)).toEqual(0x00);
+    expect(cmap.lookup(0x1b)).toEqual(0x05);
+    expect(cmap.lookup(0x1c)).toBeUndefined();
   });
-  it("decodes codespace ranges", function (done) {
+
+  it("decodes codespace ranges", async function () {
     // prettier-ignore
     const str = "1 begincodespacerange\n" +
               "<01> <02>\n" +
               "<00000003> <00000004>\n" +
               "endcodespacerange\n";
     const stream = new StringStream(str);
-    const cmapPromise = CMapFactory.create({ encoding: stream });
-    cmapPromise
-      .then(function (cmap) {
-        const c = {};
-        cmap.readCharCode(String.fromCharCode(1), 0, c);
-        expect(c.charcode).toEqual(1);
-        expect(c.length).toEqual(1);
-        cmap.readCharCode(String.fromCharCode(0, 0, 0, 3), 0, c);
-        expect(c.charcode).toEqual(3);
-        expect(c.length).toEqual(4);
-        done();
-      })
-      .catch(function (reason) {
-        done.fail(reason);
-      });
+    const cmap = await CMapFactory.create({ encoding: stream });
+    const c = {};
+    cmap.readCharCode(String.fromCharCode(1), 0, c);
+    expect(c.charcode).toEqual(1);
+    expect(c.length).toEqual(1);
+    cmap.readCharCode(String.fromCharCode(0, 0, 0, 3), 0, c);
+    expect(c.charcode).toEqual(3);
+    expect(c.length).toEqual(4);
   });
-  it("decodes 4 byte codespace ranges", function (done) {
+
+  it("decodes 4 byte codespace ranges", async function () {
     // prettier-ignore
     const str = "1 begincodespacerange\n" +
               "<8EA1A1A1> <8EA1FEFE>\n" +
               "endcodespacerange\n";
     const stream = new StringStream(str);
-    const cmapPromise = CMapFactory.create({ encoding: stream });
-    cmapPromise
-      .then(function (cmap) {
-        const c = {};
-        cmap.readCharCode(String.fromCharCode(0x8e, 0xa1, 0xa1, 0xa1), 0, c);
-        expect(c.charcode).toEqual(0x8ea1a1a1);
-        expect(c.length).toEqual(4);
-        done();
-      })
-      .catch(function (reason) {
-        done.fail(reason);
-      });
+    const cmap = await CMapFactory.create({ encoding: stream });
+    const c = {};
+    cmap.readCharCode(String.fromCharCode(0x8e, 0xa1, 0xa1, 0xa1), 0, c);
+    expect(c.charcode).toEqual(0x8ea1a1a1);
+    expect(c.length).toEqual(4);
   });
-  it("read usecmap", function (done) {
+
+  it("read usecmap", async function () {
     const str = "/Adobe-Japan1-1 usecmap\n";
     const stream = new StringStream(str);
-    const cmapPromise = CMapFactory.create({
+    const cmap = await CMapFactory.create({
       encoding: stream,
       fetchBuiltInCMap,
       useCMap: null,
     });
-    cmapPromise
-      .then(function (cmap) {
-        expect(cmap instanceof CMap).toEqual(true);
-        expect(cmap.useCMap).not.toBeNull();
-        expect(cmap.builtInCMap).toBeFalsy();
-        expect(cmap.length).toEqual(0x20a7);
-        expect(cmap.isIdentityCMap).toEqual(false);
-        done();
-      })
-      .catch(function (reason) {
-        done.fail(reason);
-      });
+    expect(cmap instanceof CMap).toEqual(true);
+    expect(cmap.useCMap).not.toBeNull();
+    expect(cmap.builtInCMap).toBeFalsy();
+    expect(cmap.length).toEqual(0x20a7);
+    expect(cmap.isIdentityCMap).toEqual(false);
   });
-  it("parses cmapname", function (done) {
+
+  it("parses cmapname", async function () {
     const str = "/CMapName /Identity-H def\n";
     const stream = new StringStream(str);
-    const cmapPromise = CMapFactory.create({ encoding: stream });
-    cmapPromise
-      .then(function (cmap) {
-        expect(cmap.name).toEqual("Identity-H");
-        done();
-      })
-      .catch(function (reason) {
-        done.fail(reason);
-      });
+    const cmap = await CMapFactory.create({ encoding: stream });
+    expect(cmap.name).toEqual("Identity-H");
   });
-  it("parses wmode", function (done) {
+
+  it("parses wmode", async function () {
     const str = "/WMode 1 def\n";
     const stream = new StringStream(str);
-    const cmapPromise = CMapFactory.create({ encoding: stream });
-    cmapPromise
-      .then(function (cmap) {
-        expect(cmap.vertical).toEqual(true);
-        done();
-      })
-      .catch(function (reason) {
-        done.fail(reason);
-      });
+    const cmap = await CMapFactory.create({ encoding: stream });
+    expect(cmap.vertical).toEqual(true);
   });
-  it("loads built in cmap", function (done) {
-    const cmapPromise = CMapFactory.create({
+
+  it("loads built in cmap", async function () {
+    const cmap = await CMapFactory.create({
       encoding: Name.get("Adobe-Japan1-1"),
       fetchBuiltInCMap,
       useCMap: null,
     });
-    cmapPromise
-      .then(function (cmap) {
-        expect(cmap instanceof CMap).toEqual(true);
-        expect(cmap.useCMap).toBeNull();
-        expect(cmap.builtInCMap).toBeTruthy();
-        expect(cmap.length).toEqual(0x20a7);
-        expect(cmap.isIdentityCMap).toEqual(false);
-        done();
-      })
-      .catch(function (reason) {
-        done.fail(reason);
-      });
+    expect(cmap instanceof CMap).toEqual(true);
+    expect(cmap.useCMap).toBeNull();
+    expect(cmap.builtInCMap).toBeTruthy();
+    expect(cmap.length).toEqual(0x20a7);
+    expect(cmap.isIdentityCMap).toEqual(false);
   });
-  it("loads built in identity cmap", function (done) {
-    const cmapPromise = CMapFactory.create({
+
+  it("loads built in identity cmap", async function () {
+    const cmap = await CMapFactory.create({
       encoding: Name.get("Identity-H"),
       fetchBuiltInCMap,
       useCMap: null,
     });
-    cmapPromise
-      .then(function (cmap) {
-        expect(cmap instanceof IdentityCMap).toEqual(true);
-        expect(cmap.vertical).toEqual(false);
-        expect(cmap.length).toEqual(0x10000);
-        expect(function () {
-          return cmap.isIdentityCMap;
-        }).toThrow(new Error("should not access .isIdentityCMap"));
-        done();
-      })
-      .catch(function (reason) {
-        done.fail(reason);
+    expect(cmap instanceof IdentityCMap).toEqual(true);
+    expect(cmap.vertical).toEqual(false);
+    expect(cmap.length).toEqual(0x10000);
+    expect(function () {
+      return cmap.isIdentityCMap;
+    }).toThrow(new Error("should not access .isIdentityCMap"));
+  });
+
+  it("attempts to load a non-existent built-in CMap", async function () {
+    try {
+      await CMapFactory.create({
+        encoding: Name.get("null"),
+        fetchBuiltInCMap,
+        useCMap: null,
       });
+
+      // Shouldn't get here.
+      expect(false).toEqual(true);
+    } catch (reason) {
+      expect(reason instanceof Error).toEqual(true);
+      expect(reason.message).toEqual("Unknown CMap name: null");
+    }
   });
 
-  it("attempts to load a non-existent built-in CMap", function (done) {
-    const cmapPromise = CMapFactory.create({
-      encoding: Name.get("null"),
-      fetchBuiltInCMap,
-      useCMap: null,
-    });
-    cmapPromise.then(
-      function () {
-        done.fail("No CMap should be loaded");
-      },
-      function (reason) {
-        expect(reason instanceof Error).toEqual(true);
-        expect(reason.message).toEqual("Unknown CMap name: null");
-        done();
-      }
-    );
-  });
-
-  it("attempts to load a built-in CMap without the necessary API parameters", function (done) {
+  it("attempts to load a built-in CMap without the necessary API parameters", async function () {
     function tmpFetchBuiltInCMap(name) {
       const CMapReaderFactory = new DefaultCMapReaderFactory({});
-
-      return CMapReaderFactory.fetch({
-        name,
-      });
+      return CMapReaderFactory.fetch({ name });
     }
 
-    const cmapPromise = CMapFactory.create({
-      encoding: Name.get("Adobe-Japan1-1"),
-      fetchBuiltInCMap: tmpFetchBuiltInCMap,
-      useCMap: null,
-    });
-    cmapPromise.then(
-      function () {
-        done.fail("No CMap should be loaded");
-      },
-      function (reason) {
-        expect(reason instanceof Error).toEqual(true);
-        expect(reason.message).toEqual(
-          'The CMap "baseUrl" parameter must be specified, ensure that ' +
-            'the "cMapUrl" and "cMapPacked" API parameters are provided.'
-        );
-        done();
-      }
-    );
+    try {
+      await CMapFactory.create({
+        encoding: Name.get("Adobe-Japan1-1"),
+        fetchBuiltInCMap: tmpFetchBuiltInCMap,
+        useCMap: null,
+      });
+
+      // Shouldn't get here.
+      expect(false).toEqual(true);
+    } catch (reason) {
+      expect(reason instanceof Error).toEqual(true);
+      expect(reason.message).toEqual(
+        'The CMap "baseUrl" parameter must be specified, ensure that ' +
+          'the "cMapUrl" and "cMapPacked" API parameters are provided.'
+      );
+    }
   });
 
-  it("attempts to load a built-in CMap with inconsistent API parameters", function (done) {
+  it("attempts to load a built-in CMap with inconsistent API parameters", async function () {
     function tmpFetchBuiltInCMap(name) {
       const CMapReaderFactory = new DefaultCMapReaderFactory({
         baseUrl: CMAP_PARAMS.cMapUrl,
         isCompressed: false,
       });
-
-      return CMapReaderFactory.fetch({
-        name,
-      });
+      return CMapReaderFactory.fetch({ name });
     }
 
-    const cmapPromise = CMapFactory.create({
-      encoding: Name.get("Adobe-Japan1-1"),
-      fetchBuiltInCMap: tmpFetchBuiltInCMap,
-      useCMap: null,
-    });
-    cmapPromise.then(
-      function () {
-        done.fail("No CMap should be loaded");
-      },
-      function (reason) {
-        expect(reason instanceof Error).toEqual(true);
-        const message = reason.message;
-        expect(message.startsWith("Unable to load CMap at: ")).toEqual(true);
-        expect(message.endsWith("/external/bcmaps/Adobe-Japan1-1")).toEqual(
-          true
-        );
-        done();
-      }
-    );
+    try {
+      await CMapFactory.create({
+        encoding: Name.get("Adobe-Japan1-1"),
+        fetchBuiltInCMap: tmpFetchBuiltInCMap,
+        useCMap: null,
+      });
+
+      // Shouldn't get here.
+      expect(false).toEqual(true);
+    } catch (reason) {
+      expect(reason instanceof Error).toEqual(true);
+      const message = reason.message;
+      expect(message.startsWith("Unable to load CMap at: ")).toEqual(true);
+      expect(message.endsWith("/external/bcmaps/Adobe-Japan1-1")).toEqual(true);
+    }
   });
 });