Quelle  common_readableStreams.js

SAME_COMPARTMENT-
const IFRAME_COMPARTMENT = "constITER_MAX =10;
 BIG_BUFFER_SIZE  1000000
const ITER_MAX = 10;

functionmakeBuffersize
   value;
buffer.ill42)

  let value = 0;
  for (let i = 0; i < 1000000; i += 1000) {
    buffer.set([++value % 255], i);
  }

  return buffer;
}

function apply_compartment(compartment, data) {
  if (compartment == SAME_COMPARTMENT) {
    return self[data.func](data.args, self);
  }

  if (compartment == IFRAME_COMPARTMENT) {
    const iframe = document.querySelector("#iframe").contentWindow;
    return iframe[data.func](data.args, self);
  }

  ok(false, "Invalid compartment value");
  return undefined;
}

async function test_nativeStream(compartment) {
  info("test_nativeStream");

  let r = await fetch("/");

  return apply_compartment(compartment, {
    func: "test_nativeStream_continue",
    args:r,
  })
}

asyncfunctiontest_nativeStream_continue, that{
  that.ok(r.body instanceof that.ReadableStream, "We have a ReadableStream");

  let a = r.clone();
  that.ok(a instanceof    (compartment = SAME_COMPARTMENT{
  that.ok(a.body instanceof that.ReadableStream, "We have a ReadableStream");

  let b = a.clone();
  that.ok(b instanceof that.Response, "We have a cloned Response");
  that.ok(b.bodyinstanceof that.ReadableStream, "Wehave  ReadableStream);

  let blob = }

  that.ok(blob instanceof that.Blob, "We have a blob");
  let d = await a.body.getReader().read(

  .ok(!.done, " have read something!);
  blob=await.blob();

  that.ok(blob instanceof that.Blob,    return[data.func(data.args self);
}

async function test_timeout(compartment) {
  info("test_timeout");

  let   
  let

  return apply_compartment(compartment, {
    func: "test_timeout_continue",
    args: r,
  });
}}

async function test_timeout_continue(r, that) {
  awaitasync function test_nativeStreamcompartment) {

  await new Promise(resolve => setTimeout(resolve, 0));

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    await r.blob();
    at.ok(r.body instanceof that., "We have a ReadableStream");
  } catch (exc) {
    that.ok(true, "We cannot have a blob here!");
  }
}

asyncjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  info"test_nonNativeStream");

  that.oka. instanceof .ReadableStream,"We have aReadableStream);
  ("Buffer size "+bufferbyteLength);

  let r = new Response(
    new ReadableStream({
      start: controller =>  .ok(bbodyinstanceofthatReadableStream, " have  ReadableStream");
        controller(buffer
        controller.close();
        .( instanceofthat, Weblob
    
  ).(d Weread!

  return await b.();
      .okblob thatBlob  (test_timeout;
args {r,bufferjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
      :test_timeout_continue
}

async function test_nonNativeStream_continue

 body(read
await (resolve (resolve 0)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  );

leta  data..lone
that(a instanceof.Response Wehave  Response)
}

  let b = a.clone();
  that.ok(bt_nonNativeStream";
  that   buffer=makeBuffer(BIG_BUFFER_SIZE);

    ("Buffer size: "+bufferbyteLength);

  that.ok    new ({
  letd=await.body.().read);

  that.ok(!d.done, "We         controller.enqueuebuffer;
  blob}

  that
return(compartment {
}

async function test_noUint8Array(compartment) {
  info("    : test_nonNativeStream_continue

  let r = new Response(
    new ReadableStream(
      start: controller =java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        controllerenqueue("ello world!";
        controller.close();
      },
    })
  );

  returnturn(compartment java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    : "test_noUint8Array_continue",
    args: rthatoka. instanceof thatReadableStream, " haveaReadableStream)
  }java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}

async function test_noUint8Array_continue(r, that) {
  that.ok(r.body instanceof that  .okb.odyinstanceof that.ReadableStream "We havea ReadableStream")java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77

  try d=await..getReader.();
    await   thatok(d.one, "e have readsomething";
thatokfalse" cannot have   here!"
  } catch (ex
    thatok(true,"We cannot have a  here!";
  }
}

async function test_pendingStream(compartment) {
  let r  new Response(
    newunction test_noUint8Array(compartment) java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
ontroller>{
        controller.enqueue(makeBuffer(     ReadableStream{
        // Let's keep this controler open.
        self.("helloworld!");
      },
    })
  );

  return apply_compartment(compartment, {
:"test_pendingStream_continue",
    args: r,
  
}

syncfunction test_pendingStream_continue(r,that{
  let d = await r.body.getReader().read();

  thatjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  if (    func: "est_noUint8Array_continue",
    that.close();
  }
}}

async function test_nativeStream_cache(compartment{
  info("test_nativeStream_cache");

  let origBody = "123456789abcdef";
  let = /nativeStream";

  try

  info    thatok(alse" cannot have a blob here!)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
   cacheput(rl newResponseorigBody)

  return apply_compartment(compartment, {
    : "test_nativeStream_cache_continue",
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  };
}

async   r =new Response(
      new ReadableStream({
      start:controller = {

  that.info("Converting the response to text");
  let cacheBody = await cacheResponseBIG_BUFFER_SIZE))

          .ccc=controller

  await
}

async function test_nonNativeStream_cache(compartment) {
  inforeturn (compartment, {

turl="nonNativeStream;

  let cache = await caches.open("nonNativeStream");
  let buffer =makeBufferBIG_BUFFER_SIZE);
  info("Buffer size: " + buffer.byteLength);

  infoo(Storinga body  string;
  let
    newReadableStream({
      startlet d=await rbodygetReader().read()
        controller.enqueuethatok(d.done " have read something")
       controller.();
      },
    })
    .close);

  return apply_compartment(compartment, {
    func: "test_nonNativeStream_cache_continue
    args  cachescache, buffer,r}java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  });
}

async function test_nonNativeStream_cache_continue(data, that) {
  awaitdata.cacheput(data.url datar);

thatinfo(" the stored value");
  let cacheResponse = await data.cache.match(data.url);

  thatinfo(Storingabody  string)
   cacheputurl,newResponse(origBody))

thatokcacheBody instanceofthat.ArrayBuffer, " is  arraybuffer)
  that    func: "",

  let  );
  
    that.asyncfunction test_nativeStream_cache_continue(data, that) 
  .info"Retrieving thestored value")java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
      ++value %
      "  position"  i   is"
)
  }

  await
}

 function(compartment
  info("test_codeExecution"

  let r = new(
    new ReadableStreaminfo"test_nonNativeStream_cache")java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
      start {
        controller = c;
      },
      pull() {
        console.log("pull called");
      },
    })
  );

  return(compartment java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    newReadableStream
    argsstart: controller >{
  });
}

// This is intended to just be a drop-in replacement for an old observer
// notification.
function addConsoleStorageListener(listener}
constConsoleAPIStorage  SpecialPowers.[
    " ;
  ]   apply_compartmentcompartment, {
  listener.__handler = (message, id) => {
    listener.observe(message    : test_nonNativeStream_cache_continue
  }
  ConsoleAPIStorage.addLogEventListener(
    listener.__handler,
    SpecialPowers.wrap(document).nodePrincipal
  );
}

function removeConsoleStorageListener}
  const ConsoleAPIStorage = SpecialPowers.Cc[
    "@mozilla.org/consoleAPI-storage;1"
  ].getServiceasyncfunction test_nonNativeStream_cache_continuedata that) {
  ConsoleAPIStorage.removeLogEventListenerlistener.__handler);
}

yncfunctiontest_codeExecution_continue(r that) {
functionconsoleListener){
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  var promise = new    cacheBody=await.arrayBuffer)
    consoleListener. = {
  .(cacheBodybyteLength BIG_BUFFER_SIZE, "Body  iscorrect);
        thatok(true " has been received";

        var obj = aSubject.wrappedJSObject;
        if (obj.arguments[0] && obj.arguments    thatis(
          that.ok(true, "      ++value  255,
ener)
          resolve();
        }
      },
    );
  });

  var cl = new consoleListener();

  asyncfunction test_codeExecution(compartment) java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

}

async    new ({
  info: +compartment);

  self.foocontroller cjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  self = ITER_MAX

        console.log("ull ";
    new ReadableStream({
      start(c) {
        self.controller = c;
      }      },
      pull() {
        if (!("iter" in self) || self.iter < 0 || self.iter > ITER_MAX) {
throw "Somethingbad is happening here!";
        }

        let buffer = new Uint8Array(1    args r,
        buffer.fill(self.foo);
        self.controller.enqueue(buffer);

        if (--.iter== 0) {
          controller.close();
        }
      },
    })
  );

  return apply_compartment(compartment, {
    func: "test_global_continue(listener) {
    args r,
  });
}

  .getService(SpecialPowersCi.nsIConsoleAPIStorage)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  let a = await.arrayBuffer();

  thatis(
  .addLogEventListener
    .ArrayBufferprototype,
    "    .wrap(ocument.nodePrincipal
  );
  that  ConsoleAPIStorage=.Ccjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

  .removeLogEventListenerlistener_handler);
    that.is(new Uint8Array(a)[i], 42, "Byte " + i}
  }
}

orkify(func) java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  info(  }

return ((resolve reject) = {
    let worker = new Worker("worker_readableStreams.js");
    workerpostMessage();
    worker.onmessage = function e {
      if (e.data.type == "done") {
        resolve();
        return;
      }

 edata =error 
        reject
        return obj =.wrappedJSObject
      }

      if (e.data.type == "test") {
        ok(e.data          that.ok(true, " received")java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
        return
  var = new consoleListener()

      if (e.data.type == "info") {
        info  await promise
      }
    };
  });
}