1 files changed, 303 insertions, 0 deletions
diff --git a/dom/promise/tests/test_webassembly_compile.html b/dom/promise/tests/test_webassembly_compile.html
new file mode 100644
index 0000000000..1f3bb7e099
--- /dev/null
+++ b/dom/promise/tests/test_webassembly_compile.html
@@ -0,0 +1,303 @@
+<!--
+  Any copyright is dedicated to the Public Domain.
+  http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<html>
+<head>
+  <title>WebAssembly.compile Test</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<script>
+const wasmIsSupported = SpecialPowers.Cu.getJSTestingFunctions().wasmIsSupported;
+
+// The test_webassembly_compile_sample.wasm is a medium-sized module with 100
+// functions that call each other recursively, returning a computed sum.
+// Any other non-trivial module could be generated and used.
+var sampleCode;
+const sampleURL = "test_webassembly_compile_sample.wasm";
+const sampleExportName = "run";
+const sampleResult = 1275;
+
+function checkSampleModule(m) {
+  ok(m instanceof WebAssembly.Module, "got a module");
+  var i = new WebAssembly.Instance(m);
+  ok(i instanceof WebAssembly.Instance, "got an instance");
+  ok(i.exports[sampleExportName]() === sampleResult, "got result");
+}
+
+function checkSampleInstance(i) {
+  ok(i instanceof WebAssembly.Instance, "got a module");
+  ok(i.exports[sampleExportName]() === sampleResult, "got result");
+}
+
+function fetchSampleModuleCode() {
+  fetch(sampleURL)
+  .then(response => response.arrayBuffer())
+  .then(buffer => { sampleCode = buffer; runTest(); })
+  .catch(err => ok(false, String(err)));
+}
+
+function propertiesExist() {
+  if (!wasmIsSupported()) {
+    ok(!this.WebAssembly, "If the device doesn't support, there will be no WebAssembly object");
+    SimpleTest.finish();
+    return;
+  }
+
+  ok(WebAssembly, "WebAssembly object should exist");
+  ok(WebAssembly.compile, "WebAssembly.compile function should exist");
+  runTest();
+}
+
+function compileFail() {
+  WebAssembly.compile().then(
+    () => { ok(false, "should have failed"); runTest(); }
+  ).catch(
+    err => { ok(err instanceof TypeError, "empty compile failed"); runTest(); }
+  );
+}
+
+function compileSuccess() {
+  WebAssembly.compile(sampleCode).then(
+    m => { checkSampleModule(m); runTest(); }
+  ).catch(
+    err => { ok(false, String(err)); runTest(); }
+  );
+}
+
+function compileManySuccess() {
+  const N = 100;
+
+  var arr = [];
+  for (var i = 0; i < N; i++)
+    arr.push(WebAssembly.compile(sampleCode));
+
+  SpecialPowers.gc();
+
+  Promise.all(arr).then(ms => {
+    ok(ms.length === N, "got the right number");
+    for (var j = 0; j < N; j++)
+      checkSampleModule(ms[j]);
+    runTest();
+  }).catch(
+    err => { ok(false, String(err)); runTest(); }
+  );
+}
+
+function terminateCompileInWorker() {
+    var w = new Worker(`data:text/plain,
+      var sampleCode;
+      function spawnWork() {
+        const N = 100;
+        var arr = [];
+        for (var i = 0; i < N; i++)
+          arr.push(WebAssembly.compile(sampleCode));
+        Promise.all(arr).then(spawnWork);
+      }
+      onmessage = e => {
+        sampleCode = e.data;
+        spawnWork();
+        postMessage("ok");
+      }
+    `);
+    w.postMessage(sampleCode);
+    w.onmessage = e => {
+      ok(e.data === "ok", "worker finished first step");
+      w.terminate();
+      runTest();
+    };
+}
+
+function instantiateFail() {
+  WebAssembly.instantiate().then(
+    () => { ok(false, "should have failed"); runTest(); }
+  ).catch(
+    err => { ok(err instanceof TypeError, "empty compile failed"); runTest(); }
+  );
+}
+
+function instantiateSuccess() {
+  WebAssembly.instantiate(sampleCode).then(
+    r => { checkSampleModule(r.module); checkSampleInstance(r.instance); runTest(); }
+  ).catch(
+    err => { ok(false, String(err)); runTest(); }
+  );
+}
+
+function chainSuccess() {
+  WebAssembly.compile(sampleCode).then(
+    m => WebAssembly.instantiate(m)
+  ).then(
+    i => { checkSampleInstance(i); runTest(); }
+  ).catch(
+    err => { ok(false, String(err)); runTest(); }
+  );
+}
+
+function compileStreamingNonResponse() {
+  WebAssembly.compileStreaming({})
+  .then(() => { ok(false); })
+  .catch(err => { ok(err instanceof TypeError, "rejected {}"); runTest(); });
+}
+
+function compileStreamingNoMime() {
+  WebAssembly.compileStreaming(new Response(new ArrayBuffer()))
+  .then(() => { ok(false); })
+  .catch(err => { ok(err instanceof TypeError, "rejected no MIME type"); runTest(); });
+}
+
+function compileStreamingBadMime() {
+  var badMimes = [
+    "",
+    "application/js",
+    "application/js;application/wasm",
+    "application/wasm;application/js",
+    "application/wasm;",
+    "application/wasm1",
+  ];
+  var promises = [];
+  for (let mimeType of badMimes) {
+    var init = { headers: { "Content-Type": mimeType } };
+    promises.push(
+      WebAssembly.compileStreaming(new Response(sampleCode, init))
+      .then(() => Promise.reject(), err => {
+        is(err.message,
+          `WebAssembly: Response has unsupported MIME type '${mimeType}' expected 'application/wasm'`,
+          "correct MIME type error message");
+        return Promise.resolve();
+      })
+    );
+  }
+  Promise.all(promises)
+  .then(() => { ok(true, "all bad MIME types rejected"); runTest(); });
+}
+
+function compileStreamingGoodMime() {
+  var badMimes = [
+    "application/wasm",
+    "   application/wasm ",
+    "application/wasm   ",
+  ];
+  var promises = [];
+  for (let mimeType of badMimes) {
+    var init = { headers: { "Content-Type": mimeType } };
+    promises.push(
+      WebAssembly.compileStreaming(new Response(sampleCode, init))
+    );
+  }
+  Promise.all(promises)
+  .then(() => { ok(true, "all good MIME types accepted"); runTest(); });
+}
+
+function compileStreamingDoubleUseFail() {
+  fetch(sampleURL)
+  .then(response => {
+      WebAssembly.compileStreaming(response)
+      .then(m => {
+        checkSampleModule(m);
+        return WebAssembly.compileStreaming(response);
+      })
+      .then(
+        () => ok(false, "should have failed on second use"),
+        err => { ok(true, "failed on second use"); runTest(); }
+      );
+  });
+}
+
+function compileStreamingNullBody() {
+  var init = { headers: { "Content-Type": "application/wasm" } };
+  WebAssembly.compileStreaming(new Response(undefined, init))
+  .then(() => { ok(false); })
+  .catch(err => { ok(err instanceof WebAssembly.CompileError, "null body"); runTest(); });
+}
+
+function compileStreamingFetch() {
+  WebAssembly.compileStreaming(fetch(sampleURL))
+  .then(m => { checkSampleModule(m); runTest(); })
+  .catch(err => { ok(false, String(err)); });
+}
+
+function instantiateStreamingFetch() {
+  WebAssembly.instantiateStreaming(fetch(sampleURL))
+  .then(({module, instance}) => { checkSampleModule(module); checkSampleInstance(instance); runTest(); })
+  .catch(err => { ok(false, String(err)); });
+}
+
+function compileManyStreamingFetch() {
+  const N = 20;
+
+  var arr = [];
+  for (var i = 0; i < N; i++)
+    arr.push(WebAssembly.compileStreaming(fetch(sampleURL)));
+
+  SpecialPowers.gc();
+
+  Promise.all(arr).then(ms => {
+    ok(ms.length === N, "got the right number");
+    for (var j = 0; j < N; j++)
+      checkSampleModule(ms[j]);
+    runTest();
+  }).catch(
+    err => { ok(false, String(err)); runTest(); }
+  );
+}
+
+function runWorkerTests() {
+  var w = new Worker("test_webassembly_compile_worker.js");
+  w.postMessage(sampleCode);
+  w.onmessage = e => {
+    ok(e.data === "ok", "worker test: " + e.data);
+    runTest();
+  };
+}
+
+function terminateCompileStreamingInWorker() {
+  var w = new Worker("test_webassembly_compile_worker_terminate.js");
+  w.onmessage = e => {
+    ok(e.data === "ok", "worker streaming terminate test: " + e.data);
+    w.terminate();
+    runTest();
+  };
+}
+
+var tests = [ propertiesExist,
+              compileFail,
+              compileSuccess,
+              compileManySuccess,
+              terminateCompileInWorker,
+              instantiateFail,
+              instantiateSuccess,
+              chainSuccess,
+              compileStreamingNonResponse,
+              compileStreamingNoMime,
+              compileStreamingBadMime,
+              compileStreamingGoodMime,
+              compileStreamingDoubleUseFail,
+              compileStreamingNullBody,
+              compileStreamingFetch,
+              instantiateStreamingFetch,
+              compileManyStreamingFetch,
+              runWorkerTests,
+              terminateCompileStreamingInWorker,
+            ];
+
+// This initialization must always run
+tests.unshift(fetchSampleModuleCode);
+
+function runTest() {
+  if (!tests.length) {
+    SimpleTest.finish();
+    return;
+  }
+
+  var test = tests.shift();
+  test();
+}
+
+SimpleTest.waitForExplicitFinish();
+runTest();
+</script>
+</body>
+</html>