mozilla-central/testing/web-platform/tests/webtransport/datagrams.https.any.js (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

Test Info: Warnings

// META: global=window,worker
// META: script=/common/get-host-info.sub.js
// META: script=resources/webtransport-test-helpers.sub.js
// Write datagrams until the producer receives the AbortSignal.
async function write_datagrams(writer, signal) {
const encoder = new TextEncoder();
let counter = 0;
const sentTokens = [];
const aborted = new Promise((resolve) => {
signal.addEventListener('abort', resolve);
});
while (true) {
await Promise.race([writer.ready, aborted]);
if (signal.aborted) {
break;
}
var token = counter.toString();
sentTokens.push(token);
writer.write(encoder.encode(token));
counter++;
}
return sentTokens;
}
// Write N datagrams without waiting, then wait for them
async function write_N_datagrams(writer, n) {
const encoder = new TextEncoder();
const sentTokens = [];
const promises = [];
while (sentTokens.length < n) {
const token = sentTokens.length.toString();
sentTokens.push(token);
promises.push(writer.write(encoder.encode(token)));
}
await Promise.all(promises);
return sentTokens;
}
// Read datagrams until the consumer has received enough i.e. N datagrams. Call
// abort() after reading.
async function read_datagrams(reader, controller, N) {
const decoder = new TextDecoder();
const receivedTokens = [];
while (receivedTokens.length < N) {
const { value: token, done } = await reader.read();
assert_false(done);
receivedTokens.push(decoder.decode(token));
}
controller.abort();
return receivedTokens;
}
// Write numbers until the producer receives the AbortSignal.
async function write_numbers(writer, signal) {
let counter = 0;
const sentNumbers = [];
const aborted =
new Promise((resolve) => signal.addEventListener('abort', resolve));
// Counter should be less than 256 because reader stores numbers in Uint8Array.
while (counter < 256) {
await Promise.race([writer.ready, aborted])
if (signal.aborted) {
break;
}
sentNumbers.push(counter);
chunk = new Uint8Array(1);
chunk[0] = counter;
writer.write(chunk);
counter++;
}
return sentNumbers;
}
// Write large datagrams of size 10 until the producer receives the AbortSignal.
async function write_large_datagrams(writer, signal) {
const aborted = new Promise((resolve) => {
signal.addEventListener('abort', resolve);
});
while (true) {
await Promise.race([writer.ready, aborted]);
if (signal.aborted) {
break;
}
writer.write(new Uint8Array(10));
}
}
// Read datagrams with BYOB reader until the consumer has received enough i.e. N
// datagrams. Call abort() after reading.
async function read_numbers_byob(reader, controller, N) {
let buffer = new ArrayBuffer(N);
buffer = await readInto(reader, buffer);
controller.abort();
return Array.from(new Uint8Array(buffer));
}
promise_test(async t => {
// Establish a WebTransport session.
const wt = new WebTransport(webtransport_url('echo.py'));
await wt.ready;
const writer = wt.datagrams.writable.getWriter();
const reader = wt.datagrams.readable.getReader();
const controller = new AbortController();
const signal = controller.signal;
// Write and read datagrams.
const N = 5;
const [sentTokens, receivedTokens] = await Promise.all([
write_datagrams(writer, signal),
read_datagrams(reader, controller, N)
]);
// Check receivedTokens is a subset of sentTokens.
const subset = receivedTokens.every(token => sentTokens.includes(token));
assert_true(subset);
}, 'Datagrams are echoed successfully');
promise_test(async t => {
// Establish a WebTransport session.
const wt = new WebTransport(webtransport_url('echo.py'));
await wt.ready;
const writer = wt.datagrams.writable.getWriter();
const reader = wt.datagrams.readable.getReader({ mode: 'byob' });
const controller = new AbortController();
const signal = controller.signal;
// Write and read datagrams.
// Numbers are less than 256, consider N to be a small number.
const N = 5;
const [sentNumbers, receiveNumbers] = await Promise.all([
write_numbers(writer, signal),
read_numbers_byob(reader, controller, N)
]);
// No duplicated numbers received.
assert_equals((new Set(receiveNumbers)).size, N);
// Check receiveNumbers is a subset of sentNumbers.
const subset = receiveNumbers.every(token => sentNumbers.includes(token));
assert_true(subset);
}, 'Successfully reading datagrams with BYOB reader.');
promise_test(async t => {
// Establish a WebTransport session.
const wt = new WebTransport(webtransport_url('echo.py'));
await wt.ready;
const writer = wt.datagrams.writable.getWriter();
const reader = wt.datagrams.readable.getReader({ mode: 'byob' });
const controller = new AbortController();
const signal = controller.signal;
// Write datagrams of size 10, but only 1 byte buffer is provided for BYOB
// reader. To avoid splitting a datagram, stream will be errored.
const buffer = new ArrayBuffer(1);
const [error, _] = await Promise.all([
reader.read(new Uint8Array(buffer)).catch(e => {
controller.abort();
return e;
}),
write_large_datagrams(writer, signal)
]);
assert_equals(error.name, 'RangeError');
}, 'Reading datagrams with insufficient buffer should be rejected.');
promise_test(async t => {
// Establish a WebTransport session.
const wt = new WebTransport(webtransport_url('echo_datagram_length.py'));
await wt.ready;
const writer = wt.datagrams.writable.getWriter();
const reader = wt.datagrams.readable.getReader();
// Write and read max-size datagram.
const maxDatagramSize = wt.datagrams.maxDatagramSize;
await writer.write(new Uint8Array(maxDatagramSize));
// the server should echo the datagram length encoded in JSON
const { value: token, done } = await reader.read();
assert_false(done);
const decoder = new TextDecoder();
const datagramStr = decoder.decode(token);
const jsonObject = JSON.parse(datagramStr);
assert_equals(jsonObject['length'], maxDatagramSize);
}, 'Transfer max-size datagram');
promise_test(async t => {
// Establish a WebTransport session.
const wt = new WebTransport(webtransport_url('echo.py'));
await wt.ready;
const writer = wt.datagrams.writable.getWriter();
const reader = wt.datagrams.readable.getReader();
// Write and read max-size datagram.
await writer.write(new Uint8Array(wt.datagrams.maxDatagramSize+1));
// This should resolve with no datagram sent, which is hard to test for.
// Wait for incoming datagrams to arrive, and if they do, fail.
const result = await Promise.race([reader.read(), wait(500)]);
assert_equals(result, undefined);
}, 'Fail to transfer max-size+1 datagram');
promise_test(async t => {
// Make a WebTransport connection, but session is not necessarily established.
const wt = new WebTransport(webtransport_url('echo.py'));
const writer = wt.datagrams.writable.getWriter();
const reader = wt.datagrams.readable.getReader();
const controller = new AbortController();
const signal = controller.signal;
// Write and read datagrams.
const N = 5;
wt.datagrams.outgoingHighWaterMark = N;
const [sentTokens, receivedTokens] = await Promise.all([
write_N_datagrams(writer, N),
read_datagrams(reader, controller, N)
]);
// Check receivedTokens is a subset of sentTokens.
const subset = receivedTokens.every(token => sentTokens.includes(token));
assert_true(subset);
// Make sure WebTransport session is established.
await wt.ready;
}, 'Sending and receiving datagrams is ready to use before session is established');
promise_test(async t => {
// Establish a WebTransport session.
const wt = new WebTransport(webtransport_url('echo.py'));
await wt.ready;
const N = 5;
wt.datagrams.outgoingHighWaterMark = N;
const writer = wt.datagrams.writable.getWriter();
const encoder = new TextEncoder();
// Write N-1 datagrams.
let counter;
for (counter = 0; counter < N-1; counter++) {
var datagram = counter.toString();
let resolved = false;
writer.write(encoder.encode(datagram));
// Check writer.ready resolves immediately.
writer.ready.then(() => resolved = true);
// TODO(nidhijaju): The number of `await Promise.resolve()` calls is
// implementation dependent, so we should not have this as the final
// solution.
for (let i = 0; i < 10; i++) {
await Promise.resolve();
}
assert_true(resolved);
}
// Write one more datagram.
resolved = false;
const last_datagram = counter.toString();
writer.write(encoder.encode(last_datagram));
// Check writer.ready does not resolve immediately.
writer.ready.then(() => resolved = true);
for (let i = 0; i < 10; i++) {
await Promise.resolve();
}
assert_false(resolved);
// Make sure writer.ready is resolved eventually.
await writer.ready;
}, 'Datagram\'s outgoingHighWaterMark correctly regulates written datagrams');
promise_test(async t => {
// Establish a WebTransport session.
const wt = new WebTransport(webtransport_url('echo.py'));
await wt.ready;
const N = 5;
wt.datagrams.incomingHighWaterMark = N;
const writer = wt.datagrams.writable.getWriter();
const encoder = new TextEncoder();
// Write 10*N datagrams.
let counter;
for (counter = 0; counter < 10*N; counter++) {
var datagram = counter.toString();
writer.write(encoder.encode(datagram));
await writer.ready;
}
// Wait for incoming datagrams to arrive.
wait(500);
const reader = wt.datagrams.readable.getReader();
// Read all of the immediately available datagrams.
let receivedDatagrams = 0;
while (true) {
let resolved = false;
reader.read().then(() => resolved = true);
// TODO(nidhijaju): Find a better solution instead of just having numerous
// `await Promise.resolve()` calls.
for (let i = 0; i < 10; i++) {
await Promise.resolve();
}
if (!resolved) {
break;
}
receivedDatagrams++;
}
// Check that the receivedDatagrams is less than or equal to the
// incomingHighWaterMark.
assert_less_than_equal(receivedDatagrams, N);
}, 'Datagrams read is less than or equal to the incomingHighWaterMark');
promise_test(async t => {
// Establish a WebTransport session.
const wt = new WebTransport(webtransport_url('echo.py'));
await wt.ready;
assert_equals(wt.datagrams.incomingMaxAge, Infinity);
assert_equals(wt.datagrams.outgoingMaxAge, Infinity);
wt.datagrams.incomingMaxAge = 5;
assert_equals(wt.datagrams.incomingMaxAge, 5);
wt.datagrams.outgoingMaxAge = 5;
assert_equals(wt.datagrams.outgoingMaxAge, 5);
assert_throws_js(RangeError, () => { wt.datagrams.incomingMaxAge = -1; });
assert_throws_js(RangeError, () => { wt.datagrams.outgoingMaxAge = -1; });
assert_throws_js(RangeError, () => { wt.datagrams.incomingMaxAge = NaN; });
assert_throws_js(RangeError, () => { wt.datagrams.outgoingMaxAge = NaN; });
wt.datagrams.incomingMaxAge = 0;
assert_equals(wt.datagrams.incomingMaxAge, Infinity);
wt.datagrams.outgoingMaxAge = 0;
assert_equals(wt.datagrams.outgoingMaxAge, Infinity);
}, 'Datagram MaxAge getters/setters work correctly');
promise_test(async t => {
// Establish a WebTransport session.
const wt = new WebTransport(webtransport_url('echo.py'));
await wt.ready;
// Initial values are implementation-defined
assert_greater_than_equal(wt.datagrams.incomingHighWaterMark, 1);
assert_greater_than_equal(wt.datagrams.outgoingHighWaterMark, 1);
wt.datagrams.incomingHighWaterMark = 5;
assert_equals(wt.datagrams.incomingHighWaterMark, 5);
wt.datagrams.outgoingHighWaterMark = 5;
assert_equals(wt.datagrams.outgoingHighWaterMark, 5);
assert_throws_js(RangeError, () => { wt.datagrams.incomingHighWaterMark = -1; });
assert_throws_js(RangeError, () => { wt.datagrams.outgoingHighWaterMark = -1; });
assert_throws_js(RangeError, () => { wt.datagrams.incomingHighWaterMark = NaN; });
assert_throws_js(RangeError, () => { wt.datagrams.outgoingHighWaterMark = NaN; });
wt.datagrams.incomingHighWaterMark = 0.5;
assert_equals(wt.datagrams.incomingHighWaterMark, 1);
wt.datagrams.outgoingHighWaterMark = 0.5;
assert_equals(wt.datagrams.outgoingHighWaterMark, 1);
wt.datagrams.incomingHighWaterMark = 0;
assert_equals(wt.datagrams.incomingHighWaterMark, 1);
wt.datagrams.outgoingHighWaterMark = 0;
assert_equals(wt.datagrams.outgoingHighWaterMark, 1);
}, 'Datagram HighWaterMark getters/setters work correctly');