From de8068e21f0394fb3c352c0c86dad9d36d1bb778 Mon Sep 17 00:00:00 2001
From: Cameron McCormack <cam@mcc.id.au>
Date: Thu, 2 Oct 2014 12:32:09 +1000
Subject: [PATCH] Bug 1028497 - Part 26: Tests. r=jdaggett

---
 layout/style/test/BitPattern.woff             | Bin 0 -> 6248 bytes
 layout/style/test/mochitest.ini               |   4 +
 layout/style/test/neverending_font_load.sjs   |   6 +
 .../test/neverending_stylesheet_load.sjs      |   6 +
 layout/style/test/test_font_loading_api.html  | 882 ++++++++++++++++++
 5 files changed, 898 insertions(+)
 create mode 100644 layout/style/test/BitPattern.woff
 create mode 100644 layout/style/test/neverending_font_load.sjs
 create mode 100644 layout/style/test/neverending_stylesheet_load.sjs
 create mode 100644 layout/style/test/test_font_loading_api.html

diff --git a/layout/style/test/BitPattern.woff b/layout/style/test/BitPattern.woff
new file mode 100644
index 0000000000000000000000000000000000000000..e4e8244057758f6b888ce985643f59b54f7a2560
GIT binary patch
literal 6248
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%0ABOU5C2`i
zf;_AR=MH0f!H@Ss5ru*W2_V#kjPpPFLI(Q#?<2NRh$|%-UiJ@Ly0~}(dA!rn(HZHN
z{321eQqscFa~;7!icA22v4Upb^Da#QlIy?R(aF5(Lp;RbzE(#qtasAz--Fq#GnzFt
zqBifU$-C?u%M|rEV81Ckk;b-&PpBhbxFbEHsc<N^UENE(4GjtDr+IH<sy~`OHcaH!
z7*{2Bo)5~oO!FV*w1_+4Xo-e%SX5u|eC|4n3e<m|ZBZ(m`k)~;-%uQP010jR1Z=Ka
zr1d~STe<f5K6)5&D>stNufQgyuw0Z<UoxPQWR1&54bD$j{!n|{aDJM!=z!`h$GPrQ
zbuQx)bXZt3HR&?_9U!uz*2Hx*IoU1p%ZlS;`Q7<jQT5@0Xq{7Z>#3uF3_3`qH2J@p
Q+exA&V*k6LPX?g=Kiqt#lK=n!

literal 0
HcmV?d00001

diff --git a/layout/style/test/mochitest.ini b/layout/style/test/mochitest.ini
index 1db9bc77212f..817d91ee2eb3 100644
--- a/layout/style/test/mochitest.ini
+++ b/layout/style/test/mochitest.ini
@@ -11,6 +11,8 @@ support-files =
   media_queries_dynamic_xbl_iframe.html
   media_queries_dynamic_xbl_style.css
   media_queries_iframe.html
+  neverending_font_load.sjs
+  neverending_stylesheet_load.sjs
   post-redirect-1.css
   post-redirect-2.css
   post-redirect-3.css
@@ -136,6 +138,8 @@ support-files = flexbox_layout_testcases.js
 [test_font_face_parser.html]
 [test_font_family_parsing.html]
 [test_font_feature_values_parsing.html]
+[test_font_loading_api.html]
+support-files = BitPattern.woff
 [test_garbage_at_end_of_declarations.html]
 [test_grid_item_shorthands.html]
 [test_grid_container_shorthands.html]
diff --git a/layout/style/test/neverending_font_load.sjs b/layout/style/test/neverending_font_load.sjs
new file mode 100644
index 000000000000..7bf419aaf6bd
--- /dev/null
+++ b/layout/style/test/neverending_font_load.sjs
@@ -0,0 +1,6 @@
+function handleRequest(request, response)
+{
+  response.processAsync();
+  response.setHeader("Content-Type", "application/octet-stream", false);
+  response.write("");
+}
diff --git a/layout/style/test/neverending_stylesheet_load.sjs b/layout/style/test/neverending_stylesheet_load.sjs
new file mode 100644
index 000000000000..386ffbe3565f
--- /dev/null
+++ b/layout/style/test/neverending_stylesheet_load.sjs
@@ -0,0 +1,6 @@
+function handleRequest(request, response)
+{
+  response.processAsync();
+  response.setHeader("Content-Type", "text/css", false);
+  response.write("");
+}
diff --git a/layout/style/test/test_font_loading_api.html b/layout/style/test/test_font_loading_api.html
new file mode 100644
index 000000000000..f04031f65e41
--- /dev/null
+++ b/layout/style/test/test_font_loading_api.html
@@ -0,0 +1,882 @@
+<!DOCTYPE html>
+<meta charset=utf-8>
+<title>Test for the CSS Font Loading API</title>
+<script src=/tests/SimpleTest/SimpleTest.js></script>
+<link rel=stylesheet type=text/css href=/tests/SimpleTest/test.css>
+
+<script src=descriptor_database.js></script>
+
+<script>
+// Map of FontFace descriptor attribute names to @font-face rule descriptor
+// names.
+var descriptorNames = {
+  style: "font-style",
+  weight: "font-weight",
+  stretch: "font-stretch",
+  unicodeRange: "unicode-range",
+  variant: "font-variant",
+  featureSettings: "font-feature-settings"
+};
+
+// Default values for the FontFace descriptor attributes other than family, as
+// Gecko currently serializes them.
+var defaultValues = {
+  style: "normal",
+  weight: "normal",
+  stretch: "normal",
+  unicodeRange: "U+0000-10FFFF",
+  variant: "normal",
+  featureSettings: "normal"
+};
+
+// Non-default values for the FontFace descriptor attributes other than family
+// along with how Gecko currently serializes them.  Each value is chosen to be
+// differeny from the default value and also has a different serialized form.
+var nonDefaultValues = {
+  style: ["Italic", "italic"],
+  weight: ["Bold", "bold"],
+  stretch: ["Ultra-Condensed", "ultra-condensed"],
+  unicodeRange: ["U+3??", "U+0300-03FF"],
+  variant: ["Small-Caps", "small-caps"],
+  featureSettings: ["'dlig' on", "\"dlig\""]
+};
+
+// Invalid values for the FontFace descriptor attributes other than family.
+var invalidValues = {
+  style: "initial",
+  weight: "bolder",
+  stretch: "wider",
+  unicodeRange: "U+1????-2????",
+  variant: "inherit",
+  featureSettings: "dlig"
+};
+
+// Invalid font family names.
+var invalidFontFamilyNames = [
+  "", "\"\"", "sans-serif", "A, B", "inherit"
+];
+
+// Will hold an ArrayBuffer containing a valid font.
+var fontData;
+
+var queue = Promise.resolve();
+
+function is_resolved_with(aPromise, aExpectedValue, aDescription, aTestID) {
+  // This assumes that all Promise tasks come from the task source.
+  var handled = false;
+  return new Promise(function(aResolve, aReject) {
+    aPromise.then(function(aValue) {
+      if (!handled) {
+        handled = true;
+        is(aValue, aExpectedValue, aDescription + " should be resolved with the expected value " + aTestID);
+        aResolve();
+      }
+    }, function(aError) {
+      if (!handled) {
+        handled = true;
+        ok(false, aDescription + " should be resolved; instead it was rejected with " + aError + " " + aTestID);
+        aResolve();
+      }
+    });
+    Promise.resolve().then(function() {
+      if (!handled) {
+        handled = true;
+        ok(false, aDescription + " should be resolved; instead it is pending " + aTestID);
+        aResolve();
+      }
+    });
+  });
+}
+
+function is_pending(aPromise, aDescription, aTestID) {
+  // This assumes that all Promise tasks come from the task source.
+  var handled = false;
+  return new Promise(function(aResolve, aReject) {
+    aPromise.then(function(aValue) {
+      if (!handled) {
+        handled = true;
+        ok(false, aDescription + " should be pending; instead it was resolved with " + aValue + " " + aTestID);
+        aResolve();
+      }
+    }, function(aError) {
+      if (!handled) {
+        handled = true;
+        ok(false, aDescription + " should be pending; instead it was rejected with " + aError + " " + aTestID);
+        aResolve();
+      }
+    });
+    Promise.resolve().then(function() {
+      if (!handled) {
+        handled = true;
+        ok(true, aDescription + " should be pending " + aTestID);
+        aResolve();
+      }
+    });
+  });
+}
+
+function fetchAsArrayBuffer(aURL) {
+  var xhr;
+  return new Promise(function(aResolve, aReject) {
+    var xhr = new XMLHttpRequest();
+    xhr.open("GET", aURL);
+    xhr.responseType = "arraybuffer";
+    xhr.onreadystatechange = function(evt) {
+      if (xhr.readyState == 4) {
+        if (xhr.status >= 200 && xhr.status <= 299) {
+          aResolve(xhr.response);
+        } else {
+          aReject(new Error("Error fetching file " + aURL + ", status " + xhr.status));
+        }
+      }
+    };
+    xhr.send();
+  });
+}
+
+function setTimeoutZero() {
+  return new Promise(function(aResolve, aReject) {
+    setTimeout(aResolve, 0);
+  });
+}
+
+function awaitRefresh() {
+  function awaitOneRefresh() {
+    return new Promise(function(aResolve, aReject) {
+      requestAnimationFrame(aResolve);
+    });
+  }
+
+  return awaitOneRefresh().then(awaitOneRefresh);
+}
+
+function runTest() {
+  SimpleTest.waitForExplicitFinish();
+
+  queue = queue.then(function() {
+
+    // First, initialize fontData.
+    return fetchAsArrayBuffer("BitPattern.woff")
+             .then(function(aResult) { fontData = aResult; });
+
+  }).then(function() {
+
+    // (TEST 1) Some miscellaneous tests for FontFaceSet and FontFace.
+    ok(window.FontFaceSet, "FontFaceSet interface object should be present (TEST 1)");
+    is(Object.getPrototypeOf(FontFaceSet.prototype), EventTarget.prototype, "FontFaceSet should inherit from EventTarget (TEST 1)");
+    ok(document.fonts instanceof FontFaceSet, "document.fonts should be a a FontFaceSet (TEST 1)");
+    ok(window.FontFace, "FontFace interface object should be present (TEST 1)");
+    is(Object.getPrototypeOf(FontFace.prototype), Object.prototype, "FontFace should inherit from Object (TEST 1)");
+
+    // (TEST 2) Some miscellaneous tests for CSSFontFaceLoadEvent.
+    ok(window.CSSFontFaceLoadEvent, "CSSFontFaceLoadEvent interface object should be present (TEST 2)");
+    is(Object.getPrototypeOf(CSSFontFaceLoadEvent.prototype), Event.prototype, "CSSFontFaceLoadEvent should inherit from Event (TEST 2)");
+
+  }).then(function() {
+
+    // (TEST 3) Test that document.fonts.ready starts out resolved with the
+    // FontFaceSet.
+    return is_resolved_with(document.fonts.ready, document.fonts, "initial value of document.fonts", "(TEST 3)");
+
+  }).then(function() {
+
+    // (TEST 4) Test that document.fonts in this test document starts out with no
+    // FontFace objects in it.
+    is(Array.from(document.fonts).length, 0, "initial number of FontFace objects in document.fonts (TEST 4)");
+
+    // (TEST 5) Test that document.fonts.status starts off as loaded.
+    is(document.fonts.status, "loaded", "initial value of document.fonts.status (TEST 5)");
+
+    // (TEST 6) Test initial value of FontFace.status when a url() source is
+    // used.
+    is(new FontFace("test", "url(x)").status, "unloaded", "initial value of FontFace.status when a url() source is used (TEST 6)");
+
+    // (TEST 7) Test initial value of FontFace.status when an invalid
+    // ArrayBuffer source is used.
+    is(new FontFace("test", new ArrayBuffer(0)).status, "unloaded", "initial value of FontFace.status when an invalid ArrayBuffer source is used (TEST 7)");
+
+    // (TEST 8) Test initial value of FontFace.status when a valid ArrayBuffer
+    // source is used.
+    is(new FontFace("test", fontData).status, "unloaded", "initial value of FontFace.status when a valid ArrayBuffer source is used (TEST 8)");
+
+    // (TEST 9) Test initial value of FontFace.loaded when an invalid url()
+    // source is used.
+    return is_pending(new FontFace("test", "").loaded, "initial value of FontFace.loaded when an invalid url() source is used", "(TEST 9)");
+
+  }).then(function() {
+
+    // (TEST 10) Test initial value of FontFace.loaded when a valid url()
+    // source is used.
+    return is_pending(new FontFace("test", "url(x)").loaded, "initial value of FontFace.loaded when a valid url() source is used", "(TEST 10)");
+
+  }).then(function() {
+
+    // (TEST 11) Test initial value of FontFace.loaded when an invalid
+    // ArrayBuffer source is used.
+    return is_pending(new FontFace("test", new ArrayBuffer(0)).loaded, "initial value of FontFace.loaded when an invalid ArrayBuffer source is used", "(TEST 11)");
+
+  }).then(function() {
+
+    // (TEST 12) Test initial value of FontFace.loaded when a valid ArrayBuffer
+    // source is used.
+    return is_pending(new FontFace("test", fontData).loaded, "initial value of FontFace.loaded when a valid ArrayBuffer source is used", "(TEST 12)");
+
+  }).then(function() {
+
+    // (TEST 13) Test initial values of the descriptor attributes on FontFace
+    // objects.
+    var face = new FontFace("test", fontData);
+    // XXX Spec issue: what values do the descriptor attributes have before the
+    // constructor's dictionary argument is parsed?
+    for (var desc in defaultValues) {
+      is(face[desc], defaultValues[desc], "initial value of FontFace." + desc + " (TEST 13)");
+    }
+
+    // (TEST 14) Test default values of the FontFaceDescriptors dictionary.
+    return face.loaded.then(function() {
+      for (var desc in defaultValues) {
+        is(face[desc], defaultValues[desc], "default value of FontFace." + desc + " (TEST 14)");
+      }
+    }, function(aError) {
+      ok(false, "FontFace should have loaded succesfully (TEST 14)");
+    });
+
+  }).then(function() {
+
+    // (TEST 15) Test passing non-default descriptor values to the FontFace
+    // constructor.
+    var descriptorTests = Promise.resolve();
+    Object.keys(nonDefaultValues).forEach(function(aDesc) {
+      descriptorTests = descriptorTests.then(function() {
+        var init = {};
+        init[aDesc] = nonDefaultValues[aDesc][0];
+        var face = new FontFace("test", fontData, init);
+        var ok_todo = aDesc == "variant" ? todo : ok;
+        ok_todo(face[aDesc] == nonDefaultValues[aDesc][1], "specified valid non-default value of FontFace." + aDesc + " immediately after construction (TEST 15)");
+        return face.loaded.then(function() {
+          ok_todo(face[aDesc] == nonDefaultValues[aDesc][1], "specified valid non-default value of FontFace." + aDesc + " (TEST 15)");
+        }, function(aError) {
+          ok(false, "FontFace should have loaded succesfully (TEST 15)");
+        });
+      });
+    });
+    return descriptorTests;
+
+  }).then(function() {
+
+    // (TEST 16) Test passing invalid descriptor values to the FontFace
+    // constructor.
+    var descriptorTests = Promise.resolve();
+    Object.keys(invalidValues).forEach(function(aDesc) {
+      descriptorTests = descriptorTests.then(function() {
+        var init = {};
+        init[aDesc] = invalidValues[aDesc];
+        var face = new FontFace("test", fontData, init);
+        var ok_todo = aDesc == "variant" ? todo : ok;
+        ok_todo(face.status == "error", "FontFace should be error immediately after construction with invalid value of FontFace." + aDesc + " (TEST 16)");
+        return face.loaded.then(function() {
+          ok_todo(false, "FontFace should not load after invalid value of FontFace." + aDesc + " specified (TEST 16)");
+        }, function(aError) {
+          ok(true, "FontFace should not load after invalid value of FontFace." + aDesc + " specified (TEST 16)");
+          is(aError.name, "SyntaxError", "FontFace.loaded with invalid value of FontFace." + aDesc + " should be rejected with a SyntaxError (TEST 16)");
+        });
+      });
+    });
+    return descriptorTests;
+
+  }).then(function() {
+
+    // (TEST 17) Test passing an invalid font family name to the FontFace
+    // constructor.
+    var familyTests = Promise.resolve();
+    invalidFontFamilyNames.forEach(function(aFamilyName) {
+      familyTests = familyTests.then(function() {
+        var face = new FontFace(aFamilyName, fontData);
+        is(face.status, "error", "FontFace should be error immediately after construction with invalid family name " + aFamilyName + " (TEST 17)");
+        return face.loaded.then(function() {
+          ok(false, "FontFace should not load after invalid family name " + aFamilyName + " specified (TEST 17)");
+        }, function(aError) {
+          ok(true, "FontFace should not load after invalid family name " + aFamilyName + " specified (TEST 17)");
+          is(aError.name, "SyntaxError", "FontFace.loaded with invalid family name " + aFamilyName + " should be rejected with a SyntaxError (TEST 17)");
+        });
+      });
+    });
+    return familyTests;
+
+  }).then(function() {
+
+    // (TEST 18) Test passing valid url() source strings to the FontFace
+    // constructor.
+    var srcTests = Promise.resolve();
+    gCSSFontFaceDescriptors.src.values.forEach(function(aSrc) {
+      srcTests = srcTests.then(function() {
+        var face = new FontFace("test", aSrc);
+        return face.load().then(function() {
+          ok(true, "FontFace should load with valid url() src " + aSrc + " (TEST 18)");
+        }, function(aError) {
+          is(aError.name, "NetworkError", "FontFace had NetworkError when loading with valid url() src " + aSrc + " (TEST 18)");
+        });
+      });
+    });
+    return srcTests;
+
+  }).then(function() {
+
+    // (TEST 19) Test passing invalid url() source strings to the FontFace
+    // constructor.
+    var srcTests = Promise.resolve();
+    gCSSFontFaceDescriptors.src.invalid_values.forEach(function(aSrc) {
+      srcTests = srcTests.then(function() {
+        var face = new FontFace("test", aSrc);
+        return face.load().then(function() {
+          ok(false, "FontFace should not load with invalid url() src " + aSrc + " (TEST 19)");
+        }, function(aError) {
+          is(aError.name, "SyntaxError", "FontFace.ready should have been rejected with a SyntaxError when loaded with an invalid url() src " + aSrc + " (TEST 19)");
+        });
+      });
+    });
+    return srcTests;
+
+  }).then(function() {
+
+    // (TEST 20) Test that the status of a FontFace constructed with a valid
+    // ArrayBuffer source eventually becomes "loaded".
+    var face = new FontFace("test", fontData);
+    return face.loaded.then(function() {
+      is(face.status, "loaded", "status of FontFace constructed with a valid ArrayBuffer source should eventually be \"loaded\" (TEST 20)");
+    }, function(aError) {
+      ok(false, "FontFace constructed with a valid ArrayBuffer should eventually load (TEST 20)");
+    });
+
+  }).then(function() {
+
+    // (TEST 21) Test that the status of a FontFace constructed with an invalid
+    // ArrayBuffer source eventually becomes "error".
+    var face = new FontFace("test", new ArrayBuffer(0));
+    return face.loaded.then(function() {
+      ok(false, "FontFace constructed with an invalid ArrayBuffer should not load (TEST 21)");
+    }, function(aError) {
+      is(aError.name, "SyntaxError", "loaded of FontFace constructed with an invalid ArrayBuffer source should be rejected with TypeError (TEST 21)");
+      is(face.status, "error", "status of FontFace constructed with an invalid ArrayBuffer source should eventually be \"error\" (TEST 21)");
+    });
+
+  }).then(function() {
+
+    // (TEST 22) Test assigning non-default descriptor values on the FontFace.
+    var descriptorTests = Promise.resolve();
+    Object.keys(nonDefaultValues).forEach(function(aDesc) {
+      descriptorTests = descriptorTests.then(function() {
+        var face = new FontFace("test", fontData);
+        return face.loaded.then(function() {
+          var ok_todo = aDesc == "variant" ? todo : ok;
+          face[aDesc] = nonDefaultValues[aDesc][0];
+          ok_todo(face[aDesc] == nonDefaultValues[aDesc][1], "assigned valid non-default value to FontFace." + aDesc + " (TEST 22) ");
+        }, function(aError) {
+          ok(false, "FontFace should have loaded succesfully (TEST 22)");
+        });
+      });
+    });
+    return descriptorTests;
+
+  }).then(function() {
+
+    // (TEST 23) Test assigning invalid descriptor values on the FontFace.
+    var descriptorTests = Promise.resolve();
+    Object.keys(invalidValues).forEach(function(aDesc) {
+      descriptorTests = descriptorTests.then(function() {
+        var face = new FontFace("test", fontData);
+        return face.loaded.then(function() {
+          var ok_todo = aDesc == "variant" ? todo : ok;
+          var exceptionName = "";
+          try {
+            face[aDesc] = invalidValues[aDesc];
+          } catch (ex) {
+            exceptionName = ex.name;
+          }
+          ok_todo(exceptionName == "SyntaxError", "assigning invalid value to FontFace." + aDesc + " should throw a SyntaxError (TEST 23)");
+        }, function(aError) {
+          ok(false, "FontFace should have loaded succesfully (TEST 23)");
+        });
+      });
+    });
+    return descriptorTests;
+
+  }).then(function() {
+
+    // (TEST 24) Test that the status of a FontFace with a non-existing url()
+    // source is set to "loading" right after load() is called, that its .loaded
+    // Promise is returned, and that the Promise is eventually rejected with a
+    // NetworkError and its status is set to "error".
+    var face = new FontFace("test", "url(x)");
+    var result = face.load();
+    is(face.status, "loading", "FontFace.status should be \"loading\" right after load() is called (TEST 24)");
+    is(result, face.loaded, "FontFace.load() should return the .loaded Promise (TEST 24)");
+
+    return result.then(function() {
+      ok(false, "FontFace with a non-existing url() source should not load (TEST 24)");
+    }, function(aError) {
+      is(aError.name, "NetworkError", "FontFace with a non-existing url() source should result in its .loaded Promise being rejected with a NetworkError (TEST 24)");
+      is(face.status, "error", "FontFace with a non-existing url() source should result in its .status being set to \"error\" (TEST 24)");
+    });
+
+  }).then(function() {
+
+    // (TEST 25) Test simple manipulation of the FontFaceSet.
+    var face, face2, all;
+    face = new FontFace("test", "url(x)");
+    face2 = new FontFace("test2", "url(x)");
+    ok(!document.fonts.has(face), "newly created FontFace should not be in document.fonts (TEST 25)");
+    document.fonts.add(face);
+    ok(document.fonts.has(face), "should be able to add a FontFace to document.fonts (TEST 25)");
+    document.fonts.add(face);
+    ok(document.fonts.has(face), "should be able to repeatedly add a FontFace to document.fonts (TEST 25)");
+    ok(document.fonts.delete(face), "FontFaceSet.delete should return true when it succeeds (TEST 25)");
+    ok(!document.fonts.has(face), "FontFace should be gone from document.fonts after delete is called (TEST 25)");
+    ok(!document.fonts.delete(face), "FontFaceSet.delete should return false when it fails (TEST 25)");
+    document.fonts.add(face);
+    document.fonts.add(face2);
+    ok(document.fonts.has(face2), "should be able to add a second FontFace to document.fonts (TEST 25)");
+    document.fonts.clear();
+    ok(!document.fonts.has(face) && !document.fonts.has(face2), "FontFaces should be gone from document.fonts after clear is called (TEST 25)");
+    document.fonts.add(face);
+    document.fonts.add(face2);
+    all = Array.from(document.fonts);
+    is(all[0], face, "FontFaces should be returned in the same order as insertion (TEST 25)");
+    is(all[1], face2, "FontFaces should be returned in the same order as insertion (TEST 25)");
+    document.fonts.add(face);
+    all = Array.from(document.fonts);
+    is(all[0], face, "FontFaces should be not be reordered when a duplicate entry is added (TEST 25)");
+    is(all[1], face2, "FontFaces should be not be reordered when a duplicate entry is added (TEST 25)");
+    document.fonts.clear();
+    return document.fonts.read;
+
+  }).then(function() {
+
+    // (TEST 26) Test that FontFaceSet.ready is replaced, .status is set to
+    // "loading", and a loading event is dispatched when a loading FontFace is
+    // added to it.
+    var awaitEvents = new Promise(function(aResolve, aReject) {
+
+      var onloadingTriggered = false, loadingDispatched = false;
+
+      function check() {
+        if (onloadingTriggered && loadingDispatched) {
+          document.fonts.onloading = null;
+          document.fonts.removeEventListener("loading", listener);
+          aResolve();
+        }
+      }
+
+      var listener = function(aEvent) {
+        is(Object.getPrototypeOf(aEvent), Event.prototype, "loading event should be a plain Event object (TEST 26)");
+        loadingDispatched = true;
+        check();
+      };
+      document.fonts.addEventListener("loading", listener);
+      document.fonts.onloading = function(aEvent) {
+        is(Object.getPrototypeOf(aEvent), Event.prototype, "loading event should be a plain Event object (TEST 26)");
+        onloadingTriggered = true;
+        check();
+      };
+    });
+
+    is(document.fonts.status, "loaded", "FontFaceSet.status initially (TEST 26)");
+
+    var oldReady = document.fonts.ready;
+    var face = new FontFace("test", "url(neverending_font_load.sjs)");
+    face.load();
+    document.fonts.add(face);
+
+    var newReady = document.fonts.ready;
+    isnot(newReady, oldReady, "FontFaceSet.ready should be replaced when a loading FontFace is added to it (TEST 26)");
+    is(document.fonts.status, "loading", "FontFaceSet.status should be set to \"loading\" when a loading FontFace is added to it (TEST 26)");
+
+    return awaitEvents
+        .then(is_pending(newReady, "FontFaceSet.ready should be replaced with a fresh pending Promise when a loading FontFace is added to it", "(TEST 26)"))
+        .then(function() {
+          document.fonts.clear();
+          return document.fonts.ready;
+        });
+
+  }).then(function() {
+
+    // (TEST 27) Test that FontFaceSet.ready is resolved, .status is set to
+    // "loaded", and a loadingdone event (but no loadingerror event) is
+    // dispatched when the only loading FontFace in it is removed.
+    var awaitEvents = new Promise(function(aResolve, aReject) {
+
+      var onloadingdoneTriggered = false, loadingdoneDispatched = false;
+      var onloadingerrorTriggered = false, loadingerrorDispatched = false;
+
+      function check() {
+        document.fonts.onloadingdone = null;
+        document.fonts.onloadingerror = null;
+        document.fonts.removeEventListener("loadingdone", doneListener);
+        document.fonts.removeEventListener("loadingerror", errorListener);
+        aResolve();
+      }
+
+      var doneListener = function(aEvent) {
+        is(Object.getPrototypeOf(aEvent), CSSFontFaceLoadEvent.prototype, "loadingdone event should be a CSSFontFaceLoadEvent object (TEST 27)");
+        is(aEvent.fontfaces.length, 0, "the CSSFontFaceLoadEvent should have an empty fontfaces array (TEST 27)");
+        loadingdoneDispatched = true;
+        check();
+      };
+      document.fonts.addEventListener("loadingdone", doneListener);
+      document.fonts.onloadingdone = function(aEvent) {
+        is(Object.getPrototypeOf(aEvent), CSSFontFaceLoadEvent.prototype, "loadingdone event should be a CSSFontFaceLoadEvent object (TEST 27)");
+        is(aEvent.fontfaces.length, 0, "the CSSFontFaceLoadEvent should have an empty fontfaces array (TEST 27)");
+        onloadingdoneTriggered = true;
+        check();
+      };
+      var errorListener = function(aEvent) {
+        loadingerrorDispatched = true;
+        check();
+      }
+      document.fonts.addEventListener("loadingerror", errorListener);
+      document.fonts.onloadingerror = function(aEvent) {
+        onloadingdoneTriggered = true;
+        check();
+      };
+    });
+
+    is(document.fonts.status, "loaded", "FontFaceSet.status should be \"loaded\" initially (TEST 27)");
+
+    var f = new FontFace("test", "url(neverending_font_load.sjs)");
+    f.load();
+    document.fonts.add(f);
+
+    is(document.fonts.status, "loading", "FontFaceSet.status should be \"loading\" when a loading FontFace is in it (TEST 27)");
+
+    document.fonts.clear();
+
+    return awaitEvents
+        .then(is_resolved_with(document.fonts.ready, document.fonts, "FontFaceSet.ready when the FontFaceSet is cleared", "(TEST 27)"))
+        .then(function() {
+          is(document.fonts.status, "loaded", "FontFaceSet.status should be set to \"loaded\" when it is cleared (TEST 27)");
+          return document.fonts.ready;
+        });
+
+  }).then(function() {
+
+    // (TEST 28) Test that FontFaceSet.ready is replaced, .status is set to
+    // "loading", and a loading event is dispatched when a FontFace in it
+    // starts loading.
+    var awaitEvents = new Promise(function(aResolve, aReject) {
+
+      var onloadingTriggered = false, loadingDispatched = false;
+
+      function check() {
+        if (onloadingTriggered && loadingDispatched) {
+          document.fonts.onloading = null;
+          document.fonts.removeEventListener("loading", listener);
+          aResolve();
+        }
+      }
+
+      var listener = function(aEvent) {
+        is(Object.getPrototypeOf(aEvent), Event.prototype, "loading event should be a plain Event object (TEST 28)");
+        loadingDispatched = true;
+        check();
+      };
+      document.fonts.addEventListener("loading", listener);
+      document.fonts.onloading = function(aEvent) {
+        is(Object.getPrototypeOf(aEvent), Event.prototype, "loading event should be a plain Event object (TEST 28)");
+        onloadingTriggered = true;
+        check();
+      };
+    });
+
+    var oldReady = document.fonts.ready;
+    var face = new FontFace("test", "url(neverending_font_load.sjs)");
+    document.fonts.add(face);
+    face.load();
+
+    var newReady = document.fonts.ready;
+    isnot(newReady, oldReady, "FontFaceSet.ready should be replaced when its only FontFace starts loading (TEST 28)");
+    is(document.fonts.status, "loading", "FontFaceSet.status should be set to \"loading\" when its only FontFace starts loading (TEST 28)");
+
+    return awaitEvents
+        .then(is_pending(newReady, "FontFaceSet.ready when the FontFaceSet's only FontFace starts loading", "(TEST 28)"))
+        .then(function() {
+          document.fonts.clear();
+          return document.fonts.ready;
+        });
+
+  }).then(function() {
+
+    // (TEST 29) Test that a loadingdone and a loadingerror event is dispatched
+    // when a FontFace with status "error" is added to the FontFaceSet.
+    var face;
+    var awaitEvents = new Promise(function(aResolve, aReject) {
+
+      var onloadingdoneTriggered = false, loadingdoneDispatched = false;
+      var onloadingerrorTriggered = false, loadingerrorDispatched = false;
+
+      function check() {
+        if (onloadingdoneTriggered && loadingdoneDispatched &&
+            onloadingerrorTriggered && loadingerrorDispatched) {
+          document.fonts.onloadingdone = null;
+          document.fonts.onloadingerror = null;
+          document.fonts.removeEventListener("loadingdone", doneListener);
+          document.fonts.removeEventListener("loadingerror", errorListener);
+          aResolve();
+        }
+      }
+
+      var doneListener = function(aEvent) {
+        loadingdoneDispatched = true;
+        check();
+      };
+      document.fonts.addEventListener("loadingdone", doneListener);
+      document.fonts.onloadingdone = function(aEvent) {
+        is(Object.getPrototypeOf(aEvent), CSSFontFaceLoadEvent.prototype, "loadingdone event should be a CSSFontFaceLoadEvent object (TEST 29)");
+        is(aEvent.fontfaces.length, 0, "the CSSFontFaceLoadEvent should have an empty fontfaces array (TEST 29)");
+        onloadingdoneTriggered = true;
+        check();
+      };
+      var errorListener = function(aEvent) {
+        is(Object.getPrototypeOf(aEvent), CSSFontFaceLoadEvent.prototype, "loadingerror event should be a CSSFontFaceLoadEvent object (TEST 29)");
+        is(aEvent.fontfaces[0], face, "the CSSFontFaceLoadEvent should have a fontfaces array with the FontFace in it (TEST 29)");
+        loadingerrorDispatched = true;
+        check();
+      }
+      document.fonts.addEventListener("loadingerror", errorListener);
+      document.fonts.onloadingerror = function(aEvent) {
+        onloadingerrorTriggered = true;
+        check();
+      };
+    });
+
+    face = new FontFace("test", new ArrayBuffer(0));
+
+    return face.loaded
+      .then(function() {
+        ok(false, "the FontFace should not load (TEST 29)");
+      }, function(aError) {
+        is(face.status, "error", "FontFace should have status \"error\" (TEST 29)");
+        document.fonts.add(face);
+      })
+      .then(awaitEvents)
+      .then(function() {
+        document.fonts.clear();
+        return document.fonts.ready;
+      });
+
+  }).then(function() {
+
+    // (TEST 30) Test that a loadingdone event is dispatched when a FontFace
+    // with status "loaded" is added to the FontFaceSet.
+    var face;
+    var awaitEvents = new Promise(function(aResolve, aReject) {
+
+      var onloadingdoneTriggered = false, loadingdoneDispatched = false;
+
+      function check() {
+        if (onloadingdoneTriggered && loadingdoneDispatched) {
+          document.fonts.onloadingdone = null;
+          document.fonts.removeEventListener("loadingdone", doneListener);
+          aResolve();
+        }
+      }
+
+      var doneListener = function(aEvent) {
+        loadingdoneDispatched = true;
+        check();
+      };
+      document.fonts.addEventListener("loadingdone", doneListener);
+      document.fonts.onloadingdone = function(aEvent) {
+        is(aEvent.fontfaces[0], face, "the CSSFontFaceLoadEvent should have a fontfaces array with the FontFace in it (TEST 30)");
+        onloadingdoneTriggered = true;
+        check();
+      };
+    });
+
+    face = new FontFace("test", fontData);
+
+    return face.loaded
+      .then(function() {
+        is(face.status, "loaded", "FontFace should have status \"loaded\" (TEST 30)");
+        document.fonts.add(face);
+      })
+      .then(awaitEvents)
+      .then(function() {
+        document.fonts.clear();
+      });
+
+  }).then(function() {
+
+    // (TEST 31) Test that a loadingdone event is dispatched when a FontFace
+    // with status "unloaded" is added to the FontFaceSet and load() is called
+    // on it.
+    var face;
+    var awaitEvents = new Promise(function(aResolve, aReject) {
+
+      var onloadingdoneTriggered = false, loadingdoneDispatched = false;
+
+      function check() {
+        if (loadingdoneDispatched && loadingdoneDispatched) {
+          document.fonts.onloadingdone = null;
+          document.fonts.removeEventListener("loadingdone", doneListener);
+          aResolve();
+        }
+      }
+
+      var doneListener = function(aEvent) {
+        loadingdoneDispatched = true;
+        check();
+      };
+      document.fonts.addEventListener("loadingdone", doneListener);
+      document.fonts.onloadingdone = function(aEvent) {
+        is(aEvent.fontfaces[0], face, "the CSSFontFaceLoadEvent should have a fontfaces array with the FontFace in it (TEST 31)");
+        onloadingdoneTriggered = true;
+        check();
+      };
+    });
+
+    face = new FontFace("test", "url(BitPattern.woff)");
+
+    return face.load()
+        .then(function() {
+          is(face.status, "loaded", "FontFace should have status \"loaded\" (TEST 31)");
+          document.fonts.add(face);
+        })
+        .then(awaitEvents)
+        .then(function() {
+          document.fonts.clear();
+          return document.fonts.ready;
+        });
+  }).then(function() {
+
+    // (TEST 32) Test that pending restyles prevent document.fonts.status
+    // from becoming loaded.
+    var face = new FontFace("test", "url(neverending_font_load.sjs)");
+    face.load();
+    document.fonts.add(face);
+
+    is(document.fonts.status, "loading", "FontFaceSet.status after adding a loading FontFace (TEST 32)");
+
+    document.fonts.clear();
+
+    is(document.fonts.status, "loaded", "FontFaceSet.status after clearing (TEST 32)");
+
+    document.fonts.add(face);
+
+    is(document.fonts.status, "loading", "FontFaceSet.status after adding a loading FontFace again (TEST 32)");
+
+    var div = document.querySelector("div");
+    div.style.color = "blue";
+
+    document.fonts.clear();
+    is(document.fonts.status, "loading", "FontFaceSet.status after clearing but when there is a pending restyle (TEST 32)");
+
+    return awaitRefresh()  // wait for a refresh driver tick
+        .then(function() {
+          is(document.fonts.status, "loaded", "FontFaceSet.status after clearing and the restyle has been flushed (TEST 32)");
+          return document.fonts.ready;
+        });
+
+  }).then(function() {
+
+    // (TEST 33) Test that CSS-connected FontFace objects are created
+    // for @font-face rules in the document.
+    var style = document.querySelector("style");
+    var ruleText = "@font-face { font-family: something; src: url(x); ";
+    Object.keys(nonDefaultValues).forEach(function(aDesc) {
+      ruleText += descriptorNames[aDesc] + ": " + nonDefaultValues[aDesc][0] + "; ";
+    });
+    ruleText += "}";
+
+    style.textContent = ruleText;
+    document.body.offsetTop;
+
+    var rule = style.sheet.cssRules[0];
+
+    var all = Array.from(document.fonts);
+    is(all.length, 1, "document.fonts should contain one FontFace (TEST 34)");
+
+    var face = all[0];
+    is(face.family, "\"something\"", "FontFace should have correct family value (TEST 34)");
+    Object.keys(nonDefaultValues).forEach(function(aDesc) {
+      var ok_todo = aDesc == "variant" ? todo : ok;
+      ok_todo(face[aDesc] == nonDefaultValues[aDesc][1], "FontFace should have correct " + aDesc + " value (TEST 34)");
+    });
+
+    document.fonts.clear();
+    ok(document.fonts.has(face), "CSS-connected FontFace should not be removed from document.fonts when clear is called (TEST 34)");
+
+    var exceptionName = "";
+    try {
+      document.fonts.delete(face);
+    } catch (ex) {
+      exceptionName = ex.name;
+    }
+    ok(exceptionName == "InvalidModificationError", "attempting to remove CSS-connected FontFace from document.fonts should throw an InvalidModificationError (TEST 34)");
+    ok(document.fonts.has(face), "CSS-connected FontFace should not be removed from document.fonts when delete is called (TEST 34)");
+
+    style.textContent = "";
+    document.body.offsetTop;
+
+    ok(!document.fonts.has(face), "CSS-connected FontFace should be removed from document.fonts once the rule has been removed (TEST 34)");
+
+    document.fonts.add(face);
+    ok(document.fonts.has(face), "previously CSS-connected FontFace should be able to be added to document.fonts (TEST 34)");
+
+    document.fonts.delete(face);
+    ok(!document.fonts.has(face), "previously CSS-connected FontFace should be able to be removed from document.fonts (TEST 34)");
+
+  }).then(function() {
+
+    // (TEST 34) Test that a pending style sheet load prevents
+    // document.fonts.status from being set to "loaded".
+
+    // First, add a FontFace to document.fonts that will load soon.
+    var face = new FontFace("test", "url(BitPattern.woff)");
+    face.load();
+    document.fonts.add(face);
+
+    // Next, add a style sheet reference.
+    var link = document.createElement("link");
+    link.rel = "stylesheet";
+    link.href = "neverending_stylesheet_load.sjs";
+    link.type = "text/css";
+    document.head.appendChild(link);
+
+    return setTimeoutZero()  // wait for the style sheet to start loading
+        .then(function() {
+          document.fonts.clear();
+          is(document.fonts.status, "loading", "FontFaceSet.status when the FontFaceSet has been cleared of loading FontFaces but there is a pending style sheet load (TEST 33)");
+          document.head.removeChild(link);
+          // XXX Removing the <link> element won't cancel the load of the
+          // style sheet, so we can't do that to test that
+          // document.fonts.ready is resolved once there are no more
+          // loading style sheets.
+        });
+
+    // NOTE: It is important that this style sheet test comes last in the file,
+    // as the neverending style sheet load will interfere with subsequent
+    // sub-tests.
+
+  }).then(function() {
+
+    // End of the tests.
+    SimpleTest.finish();
+
+  }, function(aError) {
+
+    // Something failed.
+    ok(false, "Something failed: " + aError);
+    SimpleTest.finish();
+
+  });
+}
+
+if (SpecialPowers.getBoolPref("layout.css.font-loading-api.enabled")) {
+  runTest();
+} else {
+  ok(true, "CSS Font Loading API is not enabled.");
+}
+</script>
+
+<style></style>
+<div></div>