send-stream-stats.https.any.js

Enable keyboard shortcuts

This test has a WPT meta file that expects 1 subtest issues.
This WPT test may be referenced by the following Test IDs:
- /webtransport/send-stream-stats.https.any.html - WPT Dashboard Interop Dashboard
- /webtransport/send-stream-stats.https.any.serviceworker.html - WPT Dashboard Interop Dashboard
- /webtransport/send-stream-stats.https.any.sharedworker.html - WPT Dashboard Interop Dashboard
- /webtransport/send-stream-stats.https.any.worker.html - WPT Dashboard Interop Dashboard

// META: global=window,worker

// META: script=resources/webtransport-test-helpers.sub.js

// META: timeout=long

async function create_web_transport(t) {

  const wt = new WebTransport(webtransport_url('echo.py'));

  t.add_cleanup(() => wt.close());

  wt.closed.catch(() => {});

  await wt.ready;

  return wt;

function assert_send_stats(stats, expected_bytes) {

  assert_equals(stats.bytesWritten, expected_bytes, 'bytesWritten');

  assert_equals(stats.bytesSent, expected_bytes, 'bytesSent');

  assert_equals(stats.bytesAcknowledged, expected_bytes, 'bytesAcknowledged');

async function wait_for_send_stats(stats_source, expected_bytes) {

  let stats;

  for (let i = 0; i < 100; ++i) {

    stats = await stats_source.getStats();

    if (stats.bytesSent === expected_bytes &&

        stats.bytesAcknowledged === expected_bytes) {

      break;

    await wait(50);

  assert_send_stats(stats, expected_bytes);

async function read_bytes(readable, expected) {

  const reader = readable.getReader({mode: 'byob'});

  const data = await readInto(reader, new ArrayBuffer(expected.byteLength));

  reader.releaseLock();

  assert_array_equals(new Uint8Array(data), expected);

promise_test(async t => {

  const wt = await create_web_transport(t);

  const group = wt.createSendGroup();

  assert_send_stats(await group.getStats(), 0);

  const bidirectional = await wt.createBidirectionalStream({sendGroup: group});

  const unidirectional =

      await wt.createUnidirectionalStream({sendGroup: group});

  assert_send_stats(await bidirectional.writable.getStats(), 0);

  assert_send_stats(await unidirectional.getStats(), 0);

  const bidirectional_data =

      new TextEncoder().encode('bidirectional stream stats');

  const unidirectional_data =

      new TextEncoder().encode('unidirectional stream stats');

  const expected_group_bytes =

      bidirectional_data.byteLength + unidirectional_data.byteLength;

  const bidirectional_writer = bidirectional.writable.getWriter();

  const unidirectional_writer = unidirectional.getWriter();

  await Promise.all([

    bidirectional_writer.write(bidirectional_data),

    unidirectional_writer.write(unidirectional_data),

]);

  const incoming_reader = wt.incomingUnidirectionalStreams.getReader();

  const {value: unidirectional_echo} = await incoming_reader.read();

  incoming_reader.releaseLock();

  await Promise.all([

    read_bytes(bidirectional.readable, bidirectional_data),

    read_bytes(unidirectional_echo, unidirectional_data),

]);

  await wait_for_send_stats(bidirectional.writable,

                            bidirectional_data.byteLength);

  await wait_for_send_stats(unidirectional, unidirectional_data.byteLength);

  await wait_for_send_stats(group, expected_group_bytes);

  await Promise.all([

    bidirectional_writer.close(),

    unidirectional_writer.close(),

]);

  await Promise.all([

    read_stream(bidirectional.readable),

    read_stream(unidirectional_echo),

]);

  assert_send_stats(await bidirectional.writable.getStats(),

                    bidirectional_data.byteLength);

  assert_send_stats(await unidirectional.getStats(),

                    unidirectional_data.byteLength);

  assert_send_stats(await group.getStats(), expected_group_bytes);

  wt.close();

  await wt.closed;

  assert_send_stats(await bidirectional.writable.getStats(),

                    bidirectional_data.byteLength);

  assert_send_stats(await unidirectional.getStats(),

                    unidirectional_data.byteLength);

  assert_send_stats(await group.getStats(), expected_group_bytes);

}, 'getStats() reports active and finalized send stream and group counters');