Bug 1630436 [wpt PR 22982] - Streams: update tests for Web IDL conver…

…sion, a=testonly

Automatic update from web-platform-tests
Streams: update tests for Web IDL conversion

Follows whatwg/streams#1035. Notable changes:

- Updates for the normative changes listed there.
- Introduce an idlharness test
- Remove various tests for things that are covered by idlharness, such as brand checks, the order of getting values from dictionaries, etc.
- Updated for the fact that everything is now globally exposed, so some roundabout code to get constructors can be removed.
- Slight timing updates: the pattern of returning a promise from an underlying sink/source/transformer `start()` function, then waiting on that before doing asserts, does not work with Web IDL's "promise resolved with". So instead we use `flushAsyncEvents()` to wait a little longer.
- Consolidated queuing strategy tests into a single file, since after deleting the things covered by idlharness, most of the tests are shared.
- Added tests that underlyingSink/underlyingSource are converted after queuingStrategy, since those dictionary conversions are done in prose.
- Added a test for various updates to the Web IDL async iterators specification.
--

wpt-commits: 887350c2f46def5b01c4dd1f8d2eee35dfb9c5bb
wpt-pr: 22982

testing/web-platform/tests/interfaces/streams.idl

@@ -0,0 +1,204 @@
+[Exposed=(Window,Worker,Worklet)]
+interface ReadableStream {
+  constructor(optional object underlyingSource, optional QueuingStrategy strategy = {});
+
+  readonly attribute boolean locked;
+
+  Promise<void> cancel(optional any reason);
+  ReadableStreamReader getReader(optional ReadableStreamGetReaderOptions options = {});
+  ReadableStream pipeThrough(ReadableWritablePair transform, optional StreamPipeOptions options = {});
+  Promise<void> pipeTo(WritableStream destination, optional StreamPipeOptions options = {});
+  sequence<ReadableStream> tee();
+
+  async iterable<any>(optional ReadableStreamIteratorOptions options = {});
+};
+
+typedef (ReadableStreamDefaultReader or ReadableStreamBYOBReader) ReadableStreamReader;
+
+enum ReadableStreamReaderMode { "byob" };
+
+dictionary ReadableStreamGetReaderOptions {
+  ReadableStreamReaderMode mode;
+};
+
+dictionary ReadableStreamIteratorOptions {
+  boolean preventCancel = false;
+};
+
+dictionary ReadableWritablePair {
+  required ReadableStream readable;
+  required WritableStream writable;
+};
+
+dictionary StreamPipeOptions {
+  boolean preventClose = false;
+  boolean preventAbort = false;
+  boolean preventCancel = false;
+  AbortSignal signal;
+};
+
+dictionary UnderlyingSource {
+  UnderlyingSourceStartCallback start;
+  UnderlyingSourcePullCallback pull;
+  UnderlyingSourceCancelCallback cancel;
+  ReadableStreamType type;
+  [EnforceRange] unsigned long long autoAllocateChunkSize;
+};
+
+typedef (ReadableStreamDefaultController or ReadableByteStreamController) ReadableStreamController;
+
+callback UnderlyingSourceStartCallback = any (ReadableStreamController controller);
+callback UnderlyingSourcePullCallback = Promise<void> (ReadableStreamController controller);
+callback UnderlyingSourceCancelCallback = Promise<void> (optional any reason);
+
+enum ReadableStreamType { "bytes" };
+
+[Exposed=(Window,Worker,Worklet)]
+interface ReadableStreamDefaultReader {
+  constructor(ReadableStream stream);
+
+  readonly attribute Promise<void> closed;
+
+  Promise<void> cancel(optional any reason);
+  Promise<any> read();
+  void releaseLock();
+};
+
+[Exposed=(Window,Worker,Worklet)]
+interface ReadableStreamBYOBReader {
+  constructor(ReadableStream stream);
+
+  readonly attribute Promise<void> closed;
+
+  Promise<void> cancel(optional any reason);
+  Promise<any> read(ArrayBufferView view);
+  void releaseLock();
+};
+
+[Exposed=(Window,Worker,Worklet)]
+interface ReadableStreamDefaultController {
+  readonly attribute unrestricted double? desiredSize;
+
+  void close();
+  void enqueue(optional any chunk);
+  void error(optional any e);
+};
+
+[Exposed=(Window,Worker,Worklet)]
+interface ReadableByteStreamController {
+  readonly attribute ReadableStreamBYOBRequest? byobRequest;
+  readonly attribute unrestricted double? desiredSize;
+
+  void close();
+  void enqueue(ArrayBufferView chunk);
+  void error(optional any e);
+};
+
+[Exposed=(Window,Worker,Worklet)]
+interface ReadableStreamBYOBRequest {
+  readonly attribute ArrayBufferView? view;
+
+  void respond([EnforceRange] unsigned long long bytesWritten);
+  void respondWithNewView(ArrayBufferView view);
+};
+
+[Exposed=(Window,Worker,Worklet)]
+interface WritableStream {
+  constructor(optional object underlyingSink, optional QueuingStrategy strategy = {});
+
+  readonly attribute boolean locked;
+
+  Promise<void> abort(optional any reason);
+  Promise<void> close();
+  WritableStreamDefaultWriter getWriter();
+};
+
+dictionary UnderlyingSink {
+  UnderlyingSinkStartCallback start;
+  UnderlyingSinkWriteCallback write;
+  UnderlyingSinkCloseCallback close;
+  UnderlyingSinkAbortCallback abort;
+  any type;
+};
+
+callback UnderlyingSinkStartCallback = any (WritableStreamDefaultController controller);
+callback UnderlyingSinkWriteCallback = Promise<void> (WritableStreamDefaultController controller, optional any chunk);
+callback UnderlyingSinkCloseCallback = Promise<void> ();
+callback UnderlyingSinkAbortCallback = Promise<void> (optional any reason);
+
+[Exposed=(Window,Worker,Worklet)]
+interface WritableStreamDefaultWriter {
+  constructor(WritableStream stream);
+
+  readonly attribute Promise<void> closed;
+  readonly attribute unrestricted double? desiredSize;
+  readonly attribute Promise<void> ready;
+
+  Promise<void> abort(optional any reason);
+  Promise<void> close();
+  void releaseLock();
+  Promise<void> write(optional any chunk);
+};
+
+[Exposed=(Window,Worker,Worklet)]
+interface WritableStreamDefaultController {
+  void error(optional any e);
+};
+
+[Exposed=(Window,Worker,Worklet)]
+interface TransformStream {
+  constructor(optional object transformer,
+              optional QueuingStrategy writableStrategy = {},
+              optional QueuingStrategy readableStrategy = {});
+
+  readonly attribute ReadableStream readable;
+  readonly attribute WritableStream writable;
+};
+
+dictionary Transformer {
+  TransformerStartCallback start;
+  TransformerTransformCallback transform;
+  TransformerFlushCallback flush;
+  any readableType;
+  any writableType;
+};
+
+callback TransformerStartCallback = any (TransformStreamDefaultController controller);
+callback TransformerFlushCallback = Promise<void> (TransformStreamDefaultController controller);
+callback TransformerTransformCallback = Promise<void> (TransformStreamDefaultController controller, optional any chunk);
+
+[Exposed=(Window,Worker,Worklet)]
+interface TransformStreamDefaultController {
+  readonly attribute unrestricted double? desiredSize;
+
+  void enqueue(optional any chunk);
+  void error(optional any reason);
+  void terminate();
+};
+
+dictionary QueuingStrategy {
+  unrestricted double highWaterMark;
+  QueuingStrategySize size;
+};
+
+callback QueuingStrategySize = unrestricted double (optional any chunk);
+
+dictionary QueuingStrategyInit {
+  required unrestricted double highWaterMark;
+};
+
+[Exposed=(Window,Worker,Worklet)]
+interface ByteLengthQueuingStrategy {
+  constructor(QueuingStrategyInit init);
+
+  attribute unrestricted double highWaterMark;
+  readonly attribute Function size;
+};
+
+[Exposed=(Window,Worker,Worklet)]
+interface CountQueuingStrategy {
+  constructor(QueuingStrategyInit init);
+
+  readonly attribute unrestricted double highWaterMark;
+  readonly attribute Function size;
+};