<!DOCTYPE html>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="/common/get-host-info.sub.js"></script>
<script>
  promise_test(async function() {
      var response = await fetch('resources/incrementer.wasm');
      const { instance, module } = await WebAssembly.instantiateStreaming(response);
      assert_true(instance instanceof WebAssembly.Instance);
      assert_true(module instanceof WebAssembly.Module);
  }, "instantiateStreaming using resolved response");

  promise_test(async function() {
      var response = await fetch('resources/incrementer.wasm');
      const { instance } = await WebAssembly.instantiateStreaming(response);
      assert_true(instance instanceof WebAssembly.Instance);
  }, "instantiateStreaming using resolved response and check instantiate");

  promise_test(async function() {
      var result = fetch('resources/incrementer.wasm');
      const { instance } = await WebAssembly.instantiateStreaming(result);
      assert_true(instance instanceof WebAssembly.Instance);
  }, "instantiateStreaming using promise response from fetch and check instantiate");

  promise_test(async function() {
    try {
      var result = fetch('resources/incrementer.wrong_mime_type.wasm');
      const { instance } = await WebAssembly.instantiateStreaming(result);
      assert_true(false);
    } catch (e) {
      assert_true(e.message.includes('MIME type'));
      assert_true(e instanceof Error);
    }
  }, "instantiateStreaming raise error if wrong mime type");

  promise_test(async function() {
    try {
      var result = fetch('resources/incrementer.no_mime_type.wasm?pipe=header(Content-Type,)');
      const { instance } = await WebAssembly.instantiateStreaming(result);
      assert_true(false);
    } catch (e) {
      assert_true(e.message.includes('MIME type'));
      assert_true(e instanceof Error);
    }
  }, "instantiateStreaming raise error if no mime type");

  promise_test(async function() {
    try {
      var result = fetch('webapi/status.py?status=404');
      const { instance } = await WebAssembly.instantiateStreaming(result);
      assert_true(false);
    } catch (e) {
      assert_equals(e.message, "Response has not returned OK status");
      assert_true(e instanceof Error);
    }
  }, "instantiateStreaming raise error if 404 status");

  const getWasmUrl = fileName => { 
    var host_info = get_host_info();
    var url = host_info.HTTP_ORIGIN_WITH_DIFFERENT_PORT  +  '/wasm/';
    return url + fileName + "?pipe=header(Access-Control-Allow-Origin,*)";
  };

  promise_test(async function() {
      var result = fetch(getWasmUrl('resources/incrementer.wasm'), {"mode": "cors"} );
      const { instance } = await WebAssembly.instantiateStreaming(result);
      assert_true(instance instanceof WebAssembly.Instance);
  }, "instantiateStreaming check CORS");

  promise_test(async function() {
    try {
      var result = fetch(getWasmUrl('resources/incrementer.wasm'), {"mode": "no-cors"} );
      const { instance } = await WebAssembly.instantiateStreaming(result);
      assert_true(false);
    } catch (e) {
      assert_equals(e.message, "Response is not CORS-same-origin");
      assert_true(e instanceof Error);
    }
  }, "instantiateStreaming raise error if no-cors");

  promise_test(async function() {
    const { instance } = await fetch('resources/incrementer.wasm')
      .then(v => v.arrayBuffer())
      .then(v => WebAssembly.instantiateStreaming(new Response(v, { headers: { "Content-Type" : "application/wasm" }})));
    assert_true(instance instanceof WebAssembly.Instance);
  }, "instantiateStreaming receive promise with response created from ArrayBuffer");

  promise_test(async function() {
    const { instance } = a = await fetch('resources/incrementer.wasm')
      .then(v => v.arrayBuffer())
      .then(buffer => {
        const stream = new ReadableStream({ 
          start(controller) {
            (async () => {
              await Promise.resolve().then(() => controller.enqueue(buffer.slice(0, 20)));
              await Promise.resolve().then(() => controller.enqueue(buffer.slice(20, buffer.byteLength)));
              await Promise.resolve().then(() => controller.close());
            })();
          }
        });
        return stream; 
      }) 
      .then(stream => WebAssembly.instantiateStreaming(new Response(stream, { headers: { "Content-Type" : "application/wasm" }})));
    assert_true(instance instanceof WebAssembly.Instance);
  }, "instantiateStreaming receive response that deliver data by chunks as bufferArray");

  promise_test(async function() {
      var response = await fetch('resources/incrementer.wasm');
      var blob = await response.blob();
      const { instance, module } = await WebAssembly.instantiateStreaming(new Response(blob, { headers: { "Content-Type" : "application/wasm" }}));
      assert_true(instance instanceof WebAssembly.Instance);
      assert_true(module instanceof WebAssembly.Module);
  }, "instantiateStreaming using blob");

  promise_test(async function(t) {
      var response = await fetch('resources/incrementer.wasm');
      var blob = await response.blob();
      var formData = new FormData;
      formData.append('blob', blob);
      formData.append('blob2', "Hello");
      await promise_rejects_js(t, WebAssembly.CompileError, WebAssembly.instantiateStreaming(new Response(formData, { headers: { "Content-Type" : "application/wasm" }})));
  }, "instantiateStreaming using FormData");
</script>