Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-11-24 05:11:16 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1763142 - Implement transform sink/source algorithms r=mgaudet,emilio

Browse Source 
Differential Revision: https://phabricator.services.mozilla.com/D142228
This commit is contained in:
Kagami Sascha Rosylight 2022-04-06 18:01:28 +00:00
parent e97ca7efb7
commit 0dd4d4b972
22 changed files with 290 additions and 1413 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
dom/streams/ReadableByteStreamController.cpp
View File

@ -1883,7 +1883,7 @@ void SetUpReadableByteStreamController(
aController->PendingPullIntos().clear();
// Step 13. Set stream.[[controller]] to controller.
aStream->SetController(aController);
aStream->SetController(*aController);
// Step 14. Let startResult be the result of performing startAlgorithm.
JS::RootedValue startResult(aCx, JS::UndefinedValue());

9
dom/streams/ReadableStream.h
View File

@ -60,13 +60,14 @@ class ReadableStream final : public nsISupports, public nsWrapperCache {
// Slot Getter/Setters:
public:
ReadableStreamController* Controller() { return mController; }
MOZ_KNOWN_LIVE ReadableStreamController* Controller() { return mController; }
ReadableStreamDefaultController* DefaultController() {
MOZ_ASSERT(mController && mController->IsDefault());
return mController->AsDefault();
}
void SetController(ReadableStreamController* aController) {
mController = aController;
void SetController(ReadableStreamController& aController) {
MOZ_ASSERT(!mController);
mController = &aController;
}
bool Disturbed() const { return mDisturbed; }
@ -137,7 +138,7 @@ class ReadableStream final : public nsISupports, public nsWrapperCache {
// Internal Slots:
private:
RefPtr<ReadableStreamController> mController;
MOZ_KNOWN_LIVE RefPtr<ReadableStreamController> mController;
bool mDisturbed = false;
RefPtr<ReadableStreamGenericReader> mReader;
ReaderState mState = ReaderState::Readable;

2
dom/streams/ReadableStreamDefaultController.cpp
View File

@ -491,7 +491,7 @@ void SetUpReadableStreamDefaultController(
aController->SetAlgorithms(aAlgorithms);
// Step 8.
aStream->SetController(aController);
aStream->SetController(*aController);
// Step 9. Default algorithm returns undefined. See Step 2 of
// https://streams.spec.whatwg.org/#set-up-readable-stream-default-controller

288
dom/streams/TransformStream.cpp
View File

@ -6,9 +6,13 @@
#include "mozilla/dom/TransformStream.h"
#include "TransformerCallbackHelpers.h"
#include "UnderlyingSourceCallbackHelpers.h"
#include "js/TypeDecls.h"
#include "mozilla/Attributes.h"
#include "mozilla/dom/Promise.h"
#include "mozilla/dom/Promise-inl.h"
#include "mozilla/dom/PromiseNativeHandler.h"
#include "mozilla/dom/WritableStream.h"
#include "mozilla/dom/ReadableStream.h"
#include "mozilla/dom/RootedDictionary.h"
@ -17,6 +21,14 @@
#include "mozilla/dom/StreamUtils.h"
#include "nsWrapperCache.h"
// XXX: GCC somehow does not allow attributes before lambda return types, while
// clang requires so. See also bug 1627007.
#ifdef __clang__
# define MOZ_CAN_RUN_SCRIPT_BOUNDARY_LAMBDA MOZ_CAN_RUN_SCRIPT_BOUNDARY
#else
# define MOZ_CAN_RUN_SCRIPT_BOUNDARY_LAMBDA
#endif
namespace mozilla::dom {
NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(TransformStream, mGlobal,
@ -82,6 +94,49 @@ void TransformStreamError(JSContext* aCx, TransformStream* aStream,
TransformStreamErrorWritableAndUnblockWrite(aCx, aStream, aError, aRv);
}
// https://streams.spec.whatwg.org/#transform-stream-default-controller-perform-transform
MOZ_CAN_RUN_SCRIPT static already_AddRefed<Promise>
TransformStreamDefaultControllerPerformTransform(
JSContext* aCx, TransformStreamDefaultController* aController,
JS::HandleValue aChunk, ErrorResult& aRv) {
// Step 1: Let transformPromise be the result of performing
// controller.[[transformAlgorithm]], passing chunk.
RefPtr<TransformerAlgorithms> algorithms = aController->Algorithms();
RefPtr<Promise> transformPromise =
algorithms->TransformCallback(aCx, aChunk, *aController, aRv);
if (aRv.Failed()) {
return nullptr;
}
// Step 2: Return the result of reacting to transformPromise with the
// following rejection steps given the argument r:
auto result = transformPromise->CatchWithCycleCollectedArgs(
[](JSContext* aCx, JS::HandleValue aError, ErrorResult& aRv,
const RefPtr<TransformStreamDefaultController>& aController)
MOZ_CAN_RUN_SCRIPT_BOUNDARY_LAMBDA -> already_AddRefed<Promise> {
// Step 2.1: Perform ! TransformStreamError(controller.[[stream]],
// r).
// TODO: Remove MOZ_KnownLive (bug 1761577)
TransformStreamError(aCx, MOZ_KnownLive(aController->Stream()),
aError, aRv);
if (aRv.Failed()) {
return nullptr;
}
// Step 2.2: Throw r.
JS::RootedValue r(aCx, aError);
aRv.MightThrowJSException();
aRv.ThrowJSException(aCx, r);
return nullptr;
},
RefPtr(aController));
if (result.isErr()) {
aRv.Throw(result.unwrapErr());
return nullptr;
}
return result.unwrap().forget();
}
// https://streams.spec.whatwg.org/#initialize-transform-stream
class TransformStreamUnderlyingSinkAlgorithms final
: public UnderlyingSinkAlgorithmsBase {
@ -103,38 +158,185 @@ class TransformStreamUnderlyingSinkAlgorithms final
aRetVal.setObject(*mStartPromise->PromiseObj());
}
already_AddRefed<Promise> WriteCallback(
MOZ_CAN_RUN_SCRIPT already_AddRefed<Promise> WriteCallback(
JSContext* aCx, JS::Handle<JS::Value> aChunk,
WritableStreamDefaultController& aController, ErrorResult& aRv) override {
// Step 2. Let writeAlgorithm be the following steps, taking a chunk
// argument:
// Step 1. Return ! TransformStreamDefaultSinkWriteAlgorithm(stream,
// chunk).
// TODO
return Promise::CreateResolvedWithUndefined(mStream->GetParentObject(),
aRv);
// Step 2.1. Return ! TransformStreamDefaultSinkWriteAlgorithm(stream,
// chunk).
// Inlining TransformStreamDefaultSinkWriteAlgorithm here:
// https://streams.spec.whatwg.org/#transform-stream-default-sink-write-algorithm
// Step 1: Assert: stream.[[writable]].[[state]] is "writable".
MOZ_ASSERT(mStream->Writable()->State() ==
WritableStream::WriterState::Writable);
// Step 2: Let controller be stream.[[controller]].
RefPtr<TransformStreamDefaultController> controller = mStream->Controller();
// Step 3: If stream.[[backpressure]] is true,
if (mStream->Backpressure()) {
// Step 3.1: Let backpressureChangePromise be
// stream.[[backpressureChangePromise]].
RefPtr<Promise> backpressureChangePromise =
mStream->BackpressureChangePromise();
// Step 3.2: Assert: backpressureChangePromise is not undefined.
MOZ_ASSERT(backpressureChangePromise);
// Step 3.3: Return the result of reacting to backpressureChangePromise
// with the following fulfillment steps:
auto result = backpressureChangePromise->ThenWithCycleCollectedArgsJS(
[](JSContext* aCx, JS::HandleValue, ErrorResult& aRv,
const RefPtr<TransformStream>& aStream,
const RefPtr<TransformStreamDefaultController>& aController,
JS::HandleValue aChunk)
MOZ_CAN_RUN_SCRIPT_BOUNDARY_LAMBDA -> already_AddRefed<Promise> {
// Step 1: Let writable be stream.[[writable]].
RefPtr<WritableStream> writable = aStream->Writable();
// Step 2: Let state be writable.[[state]].
WritableStream::WriterState state = writable->State();
// Step 3: If state is "erroring", throw
// writable.[[storedError]].
if (state == WritableStream::WriterState::Erroring) {
JS::RootedValue storedError(aCx, writable->StoredError());
aRv.MightThrowJSException();
aRv.ThrowJSException(aCx, storedError);
return nullptr;
}
// Step 4: Assert: state is "writable".
MOZ_ASSERT(state == WritableStream::WriterState::Writable);
// Step 5: Return !
// TransformStreamDefaultControllerPerformTransform(controller,
// chunk).
return TransformStreamDefaultControllerPerformTransform(
aCx, aController, aChunk, aRv);
},
std::make_tuple(mStream, controller), std::make_tuple(aChunk));
if (result.isErr()) {
aRv.Throw(result.unwrapErr());
return nullptr;
}
return result.unwrap().forget();
}
// Step 4: Return !
// TransformStreamDefaultControllerPerformTransform(controller, chunk).
return TransformStreamDefaultControllerPerformTransform(aCx, controller,
aChunk, aRv);
}
already_AddRefed<Promise> AbortCallback(
MOZ_CAN_RUN_SCRIPT already_AddRefed<Promise> AbortCallback(
JSContext* aCx, const Optional<JS::Handle<JS::Value>>& aReason,
ErrorResult& aRv) override {
// Step 3. Let abortAlgorithm be the following steps, taking a reason
// argument:
// Step 1. Return ! TransformStreamDefaultSinkAbortAlgorithm(stream,
// reason).
// TODO
// Step 3.1. Return ! TransformStreamDefaultSinkAbortAlgorithm(stream,
// reason).
// Inlining TransformStreamDefaultSinkAbortAlgorithm here:
// https://streams.spec.whatwg.org/#transform-stream-default-sink-abort-algorithm
// Step 1:Perform ! TransformStreamError(stream, reason).
TransformStreamError(
aCx, mStream,
aReason.WasPassed() ? aReason.Value() : JS::UndefinedHandleValue, aRv);
if (aRv.Failed()) {
return nullptr;
}
// Step 2: Return a promise resolved with undefined.
return Promise::CreateResolvedWithUndefined(mStream->GetParentObject(),
aRv);
}
already_AddRefed<Promise> CloseCallback(JSContext* aCx,
ErrorResult& aRv) override {
MOZ_CAN_RUN_SCRIPT already_AddRefed<Promise> CloseCallback(
JSContext* aCx, ErrorResult& aRv) override {
// Step 4. Let closeAlgorithm be the following steps:
// Step 4.1. Return ! TransformStreamDefaultSinkCloseAlgorithm(stream).
// Step 1. Return ! TransformStreamDefaultSinkCloseAlgorithm(stream).
// TODO
return Promise::CreateResolvedWithUndefined(mStream->GetParentObject(),
aRv);
// Inlining TransformStreamDefaultSinkCloseAlgorithm here:
// https://streams.spec.whatwg.org/#transform-stream-default-sink-close-algorithm
// Step 1: Let readable be stream.[[readable]].
RefPtr<ReadableStream> readable = mStream->Readable();
// Step 2: Let controller be stream.[[controller]].
RefPtr<TransformStreamDefaultController> controller = mStream->Controller();
// Step 3: Let flushPromise be the result of performing
// controller.[[flushAlgorithm]].
RefPtr<TransformerAlgorithms> algorithms = controller->Algorithms();
RefPtr<Promise> flushPromise =
algorithms->FlushCallback(aCx, *controller, aRv);
if (aRv.Failed()) {
return nullptr;
}
// Step 4: Perform !
// TransformStreamDefaultControllerClearAlgorithms(controller).
controller->SetAlgorithms(nullptr);
// Step 5: Return the result of reacting to flushPromise:
Result<RefPtr<Promise>, nsresult> result =
flushPromise->ThenCatchWithCycleCollectedArgs(
[](JSContext* aCx, JS::HandleValue aValue, ErrorResult& aRv,
const RefPtr<ReadableStream>& aReadable,
const RefPtr<TransformStream>& aStream)
MOZ_CAN_RUN_SCRIPT_BOUNDARY_LAMBDA
-> already_AddRefed<Promise> {
// Step 5.1: If flushPromise was fulfilled, then:
// Step 5.1.1: If readable.[[state]] is "errored", throw
// readable.[[storedError]].
if (aReadable->State() ==
ReadableStream::ReaderState::Errored) {
JS::RootedValue storedError(aCx, aReadable->StoredError());
aRv.MightThrowJSException();
aRv.ThrowJSException(aCx, storedError);
return nullptr;
}
// Step 5.1.2: Perform !
// ReadableStreamDefaultControllerClose(readable.[[controller]]).
ReadableStreamDefaultControllerClose(
aCx, MOZ_KnownLive(aReadable->Controller()->AsDefault()),
aRv);
return nullptr;
},
[](JSContext* aCx, JS::HandleValue aValue, ErrorResult& aRv,
const RefPtr<ReadableStream>& aReadable,
const RefPtr<TransformStream>& aStream)
MOZ_CAN_RUN_SCRIPT_BOUNDARY_LAMBDA
-> already_AddRefed<Promise> {
// Step 5.2: If flushPromise was rejected with reason r, then:
// Step 5.2.1: Perform ! TransformStreamError(stream, r).
TransformStreamError(aCx, aStream, aValue, aRv);
if (aRv.Failed()) {
return nullptr;
}
// Step 5.2.2: Throw readable.[[storedError]].
JS::RootedValue storedError(aCx, aReadable->StoredError());
aRv.MightThrowJSException();
aRv.ThrowJSException(aCx, storedError);
return nullptr;
},
readable, mStream);
if (result.isErr()) {
aRv.Throw(result.unwrapErr());
return nullptr;
}
return result.unwrap().forget();
}
protected:
@ -142,7 +344,8 @@ class TransformStreamUnderlyingSinkAlgorithms final
private:
RefPtr<Promise> mStartPromise;
RefPtr<TransformStream> mStream;
// MOZ_KNOWN_LIVE because it won't be reassigned
MOZ_KNOWN_LIVE RefPtr<TransformStream> mStream;
};
NS_IMPL_CYCLE_COLLECTION_INHERITED(TransformStreamUnderlyingSinkAlgorithms,
@ -179,21 +382,39 @@ class TransformStreamUnderlyingSourceAlgorithms final
ReadableStreamController& aController,
ErrorResult& aRv) override {
// Step 6. Let pullAlgorithm be the following steps:
// Step 1. Return ! TransformStreamDefaultSourcePullAlgorithm(stream).
// TODO
return Promise::CreateResolvedWithUndefined(mStream->GetParentObject(),
aRv);
// Step 6.1. Return ! TransformStreamDefaultSourcePullAlgorithm(stream).
// Inlining TransformStreamDefaultSourcePullAlgorithm here:
// https://streams.spec.whatwg.org/#transform-stream-default-source-pull-algorithm
// Step 1: Assert: stream.[[backpressure]] is true.
MOZ_ASSERT(mStream->Backpressure());
// Step 2: Assert: stream.[[backpressureChangePromise]] is not undefined.
MOZ_ASSERT(mStream->BackpressureChangePromise());
// Step 3: Perform ! TransformStreamSetBackpressure(stream, false).
TransformStreamSetBackpressure(mStream, false, aRv);
// Step 4: Return stream.[[backpressureChangePromise]].
return do_AddRef(mStream->BackpressureChangePromise());
}
already_AddRefed<Promise> CancelCallback(
MOZ_CAN_RUN_SCRIPT already_AddRefed<Promise> CancelCallback(
JSContext* aCx, const Optional<JS::Handle<JS::Value>>& aReason,
ErrorResult& aRv) override {
// Step 7. Let cancelAlgorithm be the following steps, taking a reason
// argument:
// Step 1. Perform ! TransformStreamErrorWritableAndUnblockWrite(stream,
// reason).
// Step 2. Return a promise resolved with undefined.
// TODO
// Step 7.1. Perform ! TransformStreamErrorWritableAndUnblockWrite(stream,
// reason).
TransformStreamErrorWritableAndUnblockWrite(
aCx, mStream,
aReason.WasPassed() ? aReason.Value() : JS::UndefinedHandleValue, aRv);
if (aRv.Failed()) {
return nullptr;
}
// Step 7.2. Return a promise resolved with undefined.
return Promise::CreateResolvedWithUndefined(mStream->GetParentObject(),
aRv);
}
@ -205,7 +426,8 @@ class TransformStreamUnderlyingSourceAlgorithms final
private:
RefPtr<Promise> mStartPromise;
RefPtr<TransformStream> mStream;
// MOZ_KNOWNLIVE because it will never be reassigned
MOZ_KNOWN_LIVE RefPtr<TransformStream> mStream;
};
NS_IMPL_CYCLE_COLLECTION_INHERITED(TransformStreamUnderlyingSourceAlgorithms,
@ -417,16 +639,12 @@ already_AddRefed<TransformStream> TransformStream::Constructor(
return transformStream.forget();
}
already_AddRefed<ReadableStream> TransformStream::GetReadable(
ErrorResult& aRv) {
aRv.Throw(NS_ERROR_NOT_IMPLEMENTED);
return nullptr;
already_AddRefed<ReadableStream> TransformStream::GetReadable() {
return mReadable.forget();
}
already_AddRefed<WritableStream> TransformStream::GetWritable(
ErrorResult& aRv) {
aRv.Throw(NS_ERROR_NOT_IMPLEMENTED);
return nullptr;
already_AddRefed<WritableStream> TransformStream::GetWritable() {
return mWritable.forget();
}
} // namespace mozilla::dom

4
dom/streams/TransformStream.h
View File

@ -69,8 +69,8 @@ class TransformStream final : public nsISupports, public nsWrapperCache {
const QueuingStrategy& aWritableStrategy,
const QueuingStrategy& aReadableStrategy, ErrorResult& aRv);
already_AddRefed<ReadableStream> GetReadable(ErrorResult& aRv);
already_AddRefed<WritableStream> GetWritable(ErrorResult& aRv);
already_AddRefed<ReadableStream> GetReadable();
already_AddRefed<WritableStream> GetWritable();
private:
nsCOMPtr<nsIGlobalObject> mGlobal;

6
dom/streams/TransformStreamDefaultController.cpp
View File

@ -26,11 +26,17 @@ NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(TransformStreamDefaultController)
NS_INTERFACE_MAP_ENTRY(nsISupports)
NS_INTERFACE_MAP_END
TransformStream* TransformStreamDefaultController::Stream() { return mStream; }
void TransformStreamDefaultController::SetStream(TransformStream& aStream) {
MOZ_ASSERT(!mStream);
mStream = &aStream;
}
TransformerAlgorithms* TransformStreamDefaultController::Algorithms() {
return mTransformerAlgorithms;
}
void TransformStreamDefaultController::SetAlgorithms(
TransformerAlgorithms* aTransformerAlgorithms) {
mTransformerAlgorithms = aTransformerAlgorithms;

2
dom/streams/TransformStreamDefaultController.h
View File

@ -31,7 +31,9 @@ class TransformStreamDefaultController final : public nsISupports,
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(TransformStreamDefaultController)
MOZ_KNOWN_LIVE TransformStream* Stream();
void SetStream(TransformStream& aStream);
TransformerAlgorithms* Algorithms();
void SetAlgorithms(TransformerAlgorithms* aTransformerAlgorithms);
explicit TransformStreamDefaultController(nsIGlobalObject* aGlobal);

20
dom/streams/TransformerCallbackHelpers.cpp
View File

@ -25,11 +25,27 @@ already_AddRefed<Promise> TransformerAlgorithms::TransformCallback(
if (!mTransformCallback) {
// Step 2.1. Let result be
// TransformStreamDefaultControllerEnqueue(controller, chunk).
// TODO
aController.Enqueue(aCx, aChunk, aRv);
// Step 2.2. If result is an abrupt completion, return a promise rejected
// with result.[[Value]].
// TODO
if (aRv.MaybeSetPendingException(aCx)) {
JS::Rooted<JS::Value> error(aCx);
if (!JS_GetPendingException(aCx, &error)) {
// Uncatchable exception; we should mark aRv and return.
aRv.StealExceptionFromJSContext(aCx);
return nullptr;
}
JS_ClearPendingException(aCx);
RefPtr<Promise> promise =
Promise::Create(aController.GetParentObject(), aRv);
if (aRv.Failed()) {
return nullptr;
}
promise->MaybeReject(error);
return promise.forget();
}
// Step 2.3. Otherwise, return a promise resolved with undefined.
return Promise::CreateResolvedWithUndefined(aController.GetParentObject(),

4
dom/webidl/TransformStream.webidl
View File

@ -16,6 +16,6 @@ interface TransformStream {
optional QueuingStrategy writableStrategy = {},
optional QueuingStrategy readableStrategy = {});
[GetterThrows /* skeleton only */] readonly attribute ReadableStream readable;
[GetterThrows /* skeleton only */] readonly attribute WritableStream writable;
readonly attribute ReadableStream readable;
readonly attribute WritableStream writable;
};

54
testing/web-platform/meta/streams/piping/throwing-options.any.js.ini
View File

@ -1,54 +0,0 @@
[throwing-options.any.worker.html]
[pipeThrough should stop after getting preventAbort throws]
expected: FAIL
[pipeThrough should stop after getting preventCancel throws]
expected: FAIL
[pipeThrough should stop after getting preventClose throws]
expected: FAIL
[pipeThrough should stop after getting signal throws]
expected: FAIL
[throwing-options.any.html]
[pipeThrough should stop after getting preventAbort throws]
expected: FAIL
[pipeThrough should stop after getting preventCancel throws]
expected: FAIL
[pipeThrough should stop after getting preventClose throws]
expected: FAIL
[pipeThrough should stop after getting signal throws]
expected: FAIL
[throwing-options.any.sharedworker.html]
[pipeThrough should stop after getting preventAbort throws]
expected: FAIL
[pipeThrough should stop after getting preventCancel throws]
expected: FAIL
[pipeThrough should stop after getting preventClose throws]
expected: FAIL
[pipeThrough should stop after getting signal throws]
expected: FAIL
[throwing-options.any.serviceworker.html]
[pipeThrough should stop after getting preventAbort throws]
expected: FAIL
[pipeThrough should stop after getting preventCancel throws]
expected: FAIL
[pipeThrough should stop after getting preventClose throws]
expected: FAIL
[pipeThrough should stop after getting signal throws]
expected: FAIL

18
testing/web-platform/meta/streams/piping/transform-streams.any.js.ini
View File

@ -1,18 +0,0 @@
[transform-streams.any.html]
[Piping through an identity transform stream should close the destination when the source closes]
expected: FAIL
[transform-streams.any.worker.html]
[Piping through an identity transform stream should close the destination when the source closes]
expected: FAIL
[transform-streams.any.sharedworker.html]
[Piping through an identity transform stream should close the destination when the source closes]
expected: FAIL
[transform-streams.any.serviceworker.html]
[Piping through an identity transform stream should close the destination when the source closes]
expected: FAIL

10
testing/web-platform/meta/streams/transferable/transform-stream.html.ini
View File

@ -1,16 +1,6 @@
[transform-stream.html]
[a TransformStream with a locked readable should not be transferable]
expected: FAIL
[piping through transferred transforms should work]
expected: FAIL
[a TransformStream with a locked writable should not be transferable]
expected: FAIL
[window.postMessage should be able to transfer a TransformStream]
expected: FAIL
[a TransformStream with both sides locked should not be transferable]
expected: FAIL

174
testing/web-platform/meta/streams/transform-streams/backpressure.any.js.ini
View File

@ -1,174 +0,0 @@
[backpressure.any.worker.html]
[backpressure allows no transforms with a default identity transform and no reader]
expected: FAIL
[backpressure only allows one transform() with a identity transform with a readable HWM of 1 and no reader]
expected: FAIL
[transform() should keep being called as long as there is no backpressure]
expected: FAIL
[writes should resolve as soon as transform completes]
expected: FAIL
[calling pull() before the first write() with backpressure should work]
expected: FAIL
[transform() should be able to read the chunk it just enqueued]
expected: FAIL
[blocking transform() should cause backpressure]
expected: FAIL
[writer.closed should resolve after readable is canceled during start]
expected: FAIL
[writer.closed should resolve after readable is canceled with backpressure]
expected: FAIL
[writer.closed should resolve after readable is canceled with no backpressure]
expected: FAIL
[cancelling the readable should cause a pending write to resolve]
expected: FAIL
[cancelling the readable side of a TransformStream should abort an empty pipe]
expected: FAIL
[cancelling the readable side of a TransformStream should abort an empty pipe after startup]
expected: FAIL
[cancelling the readable side of a TransformStream should abort a full pipe]
expected: FAIL
[backpressure.any.sharedworker.html]
[backpressure allows no transforms with a default identity transform and no reader]
expected: FAIL
[backpressure only allows one transform() with a identity transform with a readable HWM of 1 and no reader]
expected: FAIL
[transform() should keep being called as long as there is no backpressure]
expected: FAIL
[writes should resolve as soon as transform completes]
expected: FAIL
[calling pull() before the first write() with backpressure should work]
expected: FAIL
[transform() should be able to read the chunk it just enqueued]
expected: FAIL
[blocking transform() should cause backpressure]
expected: FAIL
[writer.closed should resolve after readable is canceled during start]
expected: FAIL
[writer.closed should resolve after readable is canceled with backpressure]
expected: FAIL
[writer.closed should resolve after readable is canceled with no backpressure]
expected: FAIL
[cancelling the readable should cause a pending write to resolve]
expected: FAIL
[cancelling the readable side of a TransformStream should abort an empty pipe]
expected: FAIL
[cancelling the readable side of a TransformStream should abort an empty pipe after startup]
expected: FAIL
[cancelling the readable side of a TransformStream should abort a full pipe]
expected: FAIL
[backpressure.any.serviceworker.html]
[backpressure allows no transforms with a default identity transform and no reader]
expected: FAIL
[backpressure only allows one transform() with a identity transform with a readable HWM of 1 and no reader]
expected: FAIL
[transform() should keep being called as long as there is no backpressure]
expected: FAIL
[writes should resolve as soon as transform completes]
expected: FAIL
[calling pull() before the first write() with backpressure should work]
expected: FAIL
[transform() should be able to read the chunk it just enqueued]
expected: FAIL
[blocking transform() should cause backpressure]
expected: FAIL
[writer.closed should resolve after readable is canceled during start]
expected: FAIL
[writer.closed should resolve after readable is canceled with backpressure]
expected: FAIL
[writer.closed should resolve after readable is canceled with no backpressure]
expected: FAIL
[cancelling the readable should cause a pending write to resolve]
expected: FAIL
[cancelling the readable side of a TransformStream should abort an empty pipe]
expected: FAIL
[cancelling the readable side of a TransformStream should abort an empty pipe after startup]
expected: FAIL
[cancelling the readable side of a TransformStream should abort a full pipe]
expected: FAIL
[backpressure.any.html]
[backpressure allows no transforms with a default identity transform and no reader]
expected: FAIL
[backpressure only allows one transform() with a identity transform with a readable HWM of 1 and no reader]
expected: FAIL
[transform() should keep being called as long as there is no backpressure]
expected: FAIL
[writes should resolve as soon as transform completes]
expected: FAIL
[calling pull() before the first write() with backpressure should work]
expected: FAIL
[transform() should be able to read the chunk it just enqueued]
expected: FAIL
[blocking transform() should cause backpressure]
expected: FAIL
[writer.closed should resolve after readable is canceled during start]
expected: FAIL
[writer.closed should resolve after readable is canceled with backpressure]
expected: FAIL
[writer.closed should resolve after readable is canceled with no backpressure]
expected: FAIL
[cancelling the readable should cause a pending write to resolve]
expected: FAIL
[cancelling the readable side of a TransformStream should abort an empty pipe]
expected: FAIL
[cancelling the readable side of a TransformStream should abort an empty pipe after startup]
expected: FAIL
[cancelling the readable side of a TransformStream should abort a full pipe]
expected: FAIL

198
testing/web-platform/meta/streams/transform-streams/errors.any.js.ini
View File

@ -1,198 +0,0 @@
[errors.any.sharedworker.html]
[TransformStream errors thrown in transform put the writable and readable in an errored state]
expected: FAIL
[TransformStream errors thrown in flush put the writable and readable in an errored state]
expected: FAIL
[TransformStream transformer.start() rejected promise should error the stream]
expected: FAIL
[when controller.error is followed by a rejection, the error reason should come from controller.error]
expected: FAIL
[cancelling the readable side should error the writable]
expected: FAIL
[it should be possible to error the readable between close requested and complete]
expected: FAIL
[an exception from transform() should error the stream if terminate has been requested but not completed]
expected: FAIL
[abort should set the close reason for the writable when it happens before cancel during start, but cancel should still succeed]
expected: FAIL
[abort should set the close reason for the writable when it happens before cancel during underlying sink write, but cancel should still succeed]
expected: FAIL
[controller.error() should do nothing the second time it is called]
expected: FAIL
[controller.error() should do nothing after readable.cancel()]
expected: FAIL
[controller.error() should do nothing after writable.abort() has completed]
expected: FAIL
[controller.error() should do nothing after a transformer method has thrown an exception]
expected: FAIL
[erroring during write with backpressure should result in the write failing]
expected: FAIL
[a write() that was waiting for backpressure should reject if the writable is aborted]
expected: FAIL
[the readable should be errored with the reason passed to the writable abort() method]
expected: FAIL
[errors.any.serviceworker.html]
[TransformStream errors thrown in transform put the writable and readable in an errored state]
expected: FAIL
[TransformStream errors thrown in flush put the writable and readable in an errored state]
expected: FAIL
[TransformStream transformer.start() rejected promise should error the stream]
expected: FAIL
[when controller.error is followed by a rejection, the error reason should come from controller.error]
expected: FAIL
[cancelling the readable side should error the writable]
expected: FAIL
[it should be possible to error the readable between close requested and complete]
expected: FAIL
[an exception from transform() should error the stream if terminate has been requested but not completed]
expected: FAIL
[abort should set the close reason for the writable when it happens before cancel during start, but cancel should still succeed]
expected: FAIL
[abort should set the close reason for the writable when it happens before cancel during underlying sink write, but cancel should still succeed]
expected: FAIL
[controller.error() should do nothing the second time it is called]
expected: FAIL
[controller.error() should do nothing after readable.cancel()]
expected: FAIL
[controller.error() should do nothing after writable.abort() has completed]
expected: FAIL
[controller.error() should do nothing after a transformer method has thrown an exception]
expected: FAIL
[erroring during write with backpressure should result in the write failing]
expected: FAIL
[a write() that was waiting for backpressure should reject if the writable is aborted]
expected: FAIL
[the readable should be errored with the reason passed to the writable abort() method]
expected: FAIL
[errors.any.worker.html]
[TransformStream errors thrown in transform put the writable and readable in an errored state]
expected: FAIL
[TransformStream errors thrown in flush put the writable and readable in an errored state]
expected: FAIL
[TransformStream transformer.start() rejected promise should error the stream]
expected: FAIL
[when controller.error is followed by a rejection, the error reason should come from controller.error]
expected: FAIL
[cancelling the readable side should error the writable]
expected: FAIL
[it should be possible to error the readable between close requested and complete]
expected: FAIL
[an exception from transform() should error the stream if terminate has been requested but not completed]
expected: FAIL
[abort should set the close reason for the writable when it happens before cancel during start, but cancel should still succeed]
expected: FAIL
[abort should set the close reason for the writable when it happens before cancel during underlying sink write, but cancel should still succeed]
expected: FAIL
[controller.error() should do nothing the second time it is called]
expected: FAIL
[controller.error() should do nothing after readable.cancel()]
expected: FAIL
[controller.error() should do nothing after writable.abort() has completed]
expected: FAIL
[controller.error() should do nothing after a transformer method has thrown an exception]
expected: FAIL
[erroring during write with backpressure should result in the write failing]
expected: FAIL
[a write() that was waiting for backpressure should reject if the writable is aborted]
expected: FAIL
[the readable should be errored with the reason passed to the writable abort() method]
expected: FAIL
[errors.any.html]
[TransformStream errors thrown in transform put the writable and readable in an errored state]
expected: FAIL
[TransformStream errors thrown in flush put the writable and readable in an errored state]
expected: FAIL
[TransformStream transformer.start() rejected promise should error the stream]
expected: FAIL
[when controller.error is followed by a rejection, the error reason should come from controller.error]
expected: FAIL
[cancelling the readable side should error the writable]
expected: FAIL
[it should be possible to error the readable between close requested and complete]
expected: FAIL
[an exception from transform() should error the stream if terminate has been requested but not completed]
expected: FAIL
[abort should set the close reason for the writable when it happens before cancel during start, but cancel should still succeed]
expected: FAIL
[abort should set the close reason for the writable when it happens before cancel during underlying sink write, but cancel should still succeed]
expected: FAIL
[controller.error() should do nothing the second time it is called]
expected: FAIL
[controller.error() should do nothing after readable.cancel()]
expected: FAIL
[controller.error() should do nothing after writable.abort() has completed]
expected: FAIL
[controller.error() should do nothing after a transformer method has thrown an exception]
expected: FAIL
[erroring during write with backpressure should result in the write failing]
expected: FAIL
[a write() that was waiting for backpressure should reject if the writable is aborted]
expected: FAIL
[the readable should be errored with the reason passed to the writable abort() method]
expected: FAIL

66
testing/web-platform/meta/streams/transform-streams/flush.any.js.ini
View File

@ -1,66 +0,0 @@
[flush.any.sharedworker.html]
[TransformStream flush is called immediately when the writable is closed, if no writes are queued]
expected: FAIL
[TransformStream flush is called after all queued writes finish, once the writable is closed]
expected: FAIL
[TransformStream flush gets a chance to enqueue more into the readable]
expected: FAIL
[TransformStream flush gets a chance to enqueue more into the readable, and can then async close]
expected: FAIL
[error() during flush should cause writer.close() to reject]
expected: FAIL
[flush.any.serviceworker.html]
[TransformStream flush is called immediately when the writable is closed, if no writes are queued]
expected: FAIL
[TransformStream flush is called after all queued writes finish, once the writable is closed]
expected: FAIL
[TransformStream flush gets a chance to enqueue more into the readable]
expected: FAIL
[TransformStream flush gets a chance to enqueue more into the readable, and can then async close]
expected: FAIL
[error() during flush should cause writer.close() to reject]
expected: FAIL
[flush.any.html]
[TransformStream flush is called immediately when the writable is closed, if no writes are queued]
expected: FAIL
[TransformStream flush is called after all queued writes finish, once the writable is closed]
expected: FAIL
[TransformStream flush gets a chance to enqueue more into the readable]
expected: FAIL
[TransformStream flush gets a chance to enqueue more into the readable, and can then async close]
expected: FAIL
[error() during flush should cause writer.close() to reject]
expected: FAIL
[flush.any.worker.html]
[TransformStream flush is called immediately when the writable is closed, if no writes are queued]
expected: FAIL
[TransformStream flush is called after all queued writes finish, once the writable is closed]
expected: FAIL
[TransformStream flush gets a chance to enqueue more into the readable]
expected: FAIL
[TransformStream flush gets a chance to enqueue more into the readable, and can then async close]
expected: FAIL
[error() during flush should cause writer.close() to reject]
expected: FAIL

222
testing/web-platform/meta/streams/transform-streams/general.any.js.ini
View File

@ -1,222 +0,0 @@
[general.any.sharedworker.html]
[TransformStream writable starts in the writable state]
expected: FAIL
[Identity TransformStream: can read from readable what is put into writable]
expected: FAIL
[Uppercaser sync TransformStream: can read from readable transformed version of what is put into writable]
expected: FAIL
[Uppercaser-doubler sync TransformStream: can read both chunks put into the readable]
expected: FAIL
[Uppercaser async TransformStream: can read from readable transformed version of what is put into writable]
expected: FAIL
[Uppercaser-doubler async TransformStream: can read both chunks put into the readable]
expected: FAIL
[TransformStream: by default, closing the writable closes the readable (when there are no queued writes)]
expected: FAIL
[TransformStream: by default, closing the writable waits for transforms to finish before closing both]
expected: FAIL
[TransformStream: by default, closing the writable closes the readable after sync enqueues and async done]
expected: FAIL
[TransformStream: by default, closing the writable closes the readable after async enqueues and async done]
expected: FAIL
[Transform stream should call transformer methods as methods]
expected: FAIL
[methods should not not have .apply() or .call() called]
expected: FAIL
[TransformStream start, transform, and flush should be strictly ordered]
expected: FAIL
[it should be possible to call transform() synchronously]
expected: FAIL
[closing the writable should close the readable when there are no queued chunks, even with backpressure]
expected: FAIL
[enqueue() should throw after readable.cancel()]
expected: FAIL
[terminate() should do nothing after readable.cancel()]
expected: FAIL
[Subclassing TransformStream should work]
expected: FAIL
[general.any.html]
[TransformStream writable starts in the writable state]
expected: FAIL
[Identity TransformStream: can read from readable what is put into writable]
expected: FAIL
[Uppercaser sync TransformStream: can read from readable transformed version of what is put into writable]
expected: FAIL
[Uppercaser-doubler sync TransformStream: can read both chunks put into the readable]
expected: FAIL
[Uppercaser async TransformStream: can read from readable transformed version of what is put into writable]
expected: FAIL
[Uppercaser-doubler async TransformStream: can read both chunks put into the readable]
expected: FAIL
[TransformStream: by default, closing the writable closes the readable (when there are no queued writes)]
expected: FAIL
[TransformStream: by default, closing the writable waits for transforms to finish before closing both]
expected: FAIL
[TransformStream: by default, closing the writable closes the readable after sync enqueues and async done]
expected: FAIL
[TransformStream: by default, closing the writable closes the readable after async enqueues and async done]
expected: FAIL
[Transform stream should call transformer methods as methods]
expected: FAIL
[methods should not not have .apply() or .call() called]
expected: FAIL
[TransformStream start, transform, and flush should be strictly ordered]
expected: FAIL
[it should be possible to call transform() synchronously]
expected: FAIL
[closing the writable should close the readable when there are no queued chunks, even with backpressure]
expected: FAIL
[enqueue() should throw after readable.cancel()]
expected: FAIL
[terminate() should do nothing after readable.cancel()]
expected: FAIL
[Subclassing TransformStream should work]
expected: FAIL
[general.any.worker.html]
[TransformStream writable starts in the writable state]
expected: FAIL
[Identity TransformStream: can read from readable what is put into writable]
expected: FAIL
[Uppercaser sync TransformStream: can read from readable transformed version of what is put into writable]
expected: FAIL
[Uppercaser-doubler sync TransformStream: can read both chunks put into the readable]
expected: FAIL
[Uppercaser async TransformStream: can read from readable transformed version of what is put into writable]
expected: FAIL
[Uppercaser-doubler async TransformStream: can read both chunks put into the readable]
expected: FAIL
[TransformStream: by default, closing the writable closes the readable (when there are no queued writes)]
expected: FAIL
[TransformStream: by default, closing the writable waits for transforms to finish before closing both]
expected: FAIL
[TransformStream: by default, closing the writable closes the readable after sync enqueues and async done]
expected: FAIL
[TransformStream: by default, closing the writable closes the readable after async enqueues and async done]
expected: FAIL
[Transform stream should call transformer methods as methods]
expected: FAIL
[methods should not not have .apply() or .call() called]
expected: FAIL
[TransformStream start, transform, and flush should be strictly ordered]
expected: FAIL
[it should be possible to call transform() synchronously]
expected: FAIL
[closing the writable should close the readable when there are no queued chunks, even with backpressure]
expected: FAIL
[enqueue() should throw after readable.cancel()]
expected: FAIL
[terminate() should do nothing after readable.cancel()]
expected: FAIL
[Subclassing TransformStream should work]
expected: FAIL
[general.any.serviceworker.html]
[TransformStream writable starts in the writable state]
expected: FAIL
[Identity TransformStream: can read from readable what is put into writable]
expected: FAIL
[Uppercaser sync TransformStream: can read from readable transformed version of what is put into writable]
expected: FAIL
[Uppercaser-doubler sync TransformStream: can read both chunks put into the readable]
expected: FAIL
[Uppercaser async TransformStream: can read from readable transformed version of what is put into writable]
expected: FAIL
[Uppercaser-doubler async TransformStream: can read both chunks put into the readable]
expected: FAIL
[TransformStream: by default, closing the writable closes the readable (when there are no queued writes)]
expected: FAIL
[TransformStream: by default, closing the writable waits for transforms to finish before closing both]
expected: FAIL
[TransformStream: by default, closing the writable closes the readable after sync enqueues and async done]
expected: FAIL
[TransformStream: by default, closing the writable closes the readable after async enqueues and async done]
expected: FAIL
[Transform stream should call transformer methods as methods]
expected: FAIL
[methods should not not have .apply() or .call() called]
expected: FAIL
[TransformStream start, transform, and flush should be strictly ordered]
expected: FAIL
[it should be possible to call transform() synchronously]
expected: FAIL
[closing the writable should close the readable when there are no queued chunks, even with backpressure]
expected: FAIL
[enqueue() should throw after readable.cancel()]
expected: FAIL
[terminate() should do nothing after readable.cancel()]
expected: FAIL
[Subclassing TransformStream should work]
expected: FAIL

246
testing/web-platform/meta/streams/transform-streams/lipfuzz.any.js.ini
View File

@ -1,246 +0,0 @@
[lipfuzz.any.sharedworker.html]
[testing "" (length 1)]
expected: FAIL
[testing "" (length 0)]
expected: FAIL
[testing "{{in1}}" (length 1)]
expected: FAIL
[testing "z{{in1}}" (length 1)]
expected: FAIL
[testing "{{in1}}q" (length 1)]
expected: FAIL
[testing "{{in1}}{{in1}" (length 1)]
expected: FAIL
[testing "{{in1}}{{in1},}" (length 2)]
expected: FAIL
[testing "{{in1,}}" (length 2)]
expected: FAIL
[testing "{{,in1}}" (length 2)]
expected: FAIL
[testing "{,{in1}}" (length 2)]
expected: FAIL
[testing "{{,in1}" (length 2)]
expected: FAIL
[testing "{" (length 1)]
expected: FAIL
[testing "{," (length 2)]
expected: FAIL
[testing "{,{,i,n,1,},}" (length 7)]
expected: FAIL
[testing "{{in1}}{{in2}}{{in1}}" (length 1)]
expected: FAIL
[testing "{{wrong}}" (length 1)]
expected: FAIL
[testing "{{wron,g}}" (length 2)]
expected: FAIL
[testing "{{quine}}" (length 1)]
expected: FAIL
[testing "{{bogusPartial}}" (length 1)]
expected: FAIL
[testing "{{bogusPartial}}}" (length 1)]
expected: FAIL
[lipfuzz.any.serviceworker.html]
[testing "" (length 1)]
expected: FAIL
[testing "" (length 0)]
expected: FAIL
[testing "{{in1}}" (length 1)]
expected: FAIL
[testing "z{{in1}}" (length 1)]
expected: FAIL
[testing "{{in1}}q" (length 1)]
expected: FAIL
[testing "{{in1}}{{in1}" (length 1)]
expected: FAIL
[testing "{{in1}}{{in1},}" (length 2)]
expected: FAIL
[testing "{{in1,}}" (length 2)]
expected: FAIL
[testing "{{,in1}}" (length 2)]
expected: FAIL
[testing "{,{in1}}" (length 2)]
expected: FAIL
[testing "{{,in1}" (length 2)]
expected: FAIL
[testing "{" (length 1)]
expected: FAIL
[testing "{," (length 2)]
expected: FAIL
[testing "{,{,i,n,1,},}" (length 7)]
expected: FAIL
[testing "{{in1}}{{in2}}{{in1}}" (length 1)]
expected: FAIL
[testing "{{wrong}}" (length 1)]
expected: FAIL
[testing "{{wron,g}}" (length 2)]
expected: FAIL
[testing "{{quine}}" (length 1)]
expected: FAIL
[testing "{{bogusPartial}}" (length 1)]
expected: FAIL
[testing "{{bogusPartial}}}" (length 1)]
expected: FAIL
[lipfuzz.any.worker.html]
[testing "" (length 1)]
expected: FAIL
[testing "" (length 0)]
expected: FAIL
[testing "{{in1}}" (length 1)]
expected: FAIL
[testing "z{{in1}}" (length 1)]
expected: FAIL
[testing "{{in1}}q" (length 1)]
expected: FAIL
[testing "{{in1}}{{in1}" (length 1)]
expected: FAIL
[testing "{{in1}}{{in1},}" (length 2)]
expected: FAIL
[testing "{{in1,}}" (length 2)]
expected: FAIL
[testing "{{,in1}}" (length 2)]
expected: FAIL
[testing "{,{in1}}" (length 2)]
expected: FAIL
[testing "{{,in1}" (length 2)]
expected: FAIL
[testing "{" (length 1)]
expected: FAIL
[testing "{," (length 2)]
expected: FAIL
[testing "{,{,i,n,1,},}" (length 7)]
expected: FAIL
[testing "{{in1}}{{in2}}{{in1}}" (length 1)]
expected: FAIL
[testing "{{wrong}}" (length 1)]
expected: FAIL
[testing "{{wron,g}}" (length 2)]
expected: FAIL
[testing "{{quine}}" (length 1)]
expected: FAIL
[testing "{{bogusPartial}}" (length 1)]
expected: FAIL
[testing "{{bogusPartial}}}" (length 1)]
expected: FAIL
[lipfuzz.any.html]
[testing "" (length 1)]
expected: FAIL
[testing "" (length 0)]
expected: FAIL
[testing "{{in1}}" (length 1)]
expected: FAIL
[testing "z{{in1}}" (length 1)]
expected: FAIL
[testing "{{in1}}q" (length 1)]
expected: FAIL
[testing "{{in1}}{{in1}" (length 1)]
expected: FAIL
[testing "{{in1}}{{in1},}" (length 2)]
expected: FAIL
[testing "{{in1,}}" (length 2)]
expected: FAIL
[testing "{{,in1}}" (length 2)]
expected: FAIL
[testing "{,{in1}}" (length 2)]
expected: FAIL
[testing "{{,in1}" (length 2)]
expected: FAIL
[testing "{" (length 1)]
expected: FAIL
[testing "{," (length 2)]
expected: FAIL
[testing "{,{,i,n,1,},}" (length 7)]
expected: FAIL
[testing "{{in1}}{{in2}}{{in1}}" (length 1)]
expected: FAIL
[testing "{{wrong}}" (length 1)]
expected: FAIL
[testing "{{wron,g}}" (length 2)]
expected: FAIL
[testing "{{quine}}" (length 1)]
expected: FAIL
[testing "{{bogusPartial}}" (length 1)]
expected: FAIL
[testing "{{bogusPartial}}}" (length 1)]
expected: FAIL

18
testing/web-platform/meta/streams/transform-streams/patched-global.any.js.ini
View File

@ -1,18 +0,0 @@
[patched-global.any.html]
[TransformStream should use the original value of ReadableStream and WritableStream]
expected: FAIL
[patched-global.any.worker.html]
[TransformStream should use the original value of ReadableStream and WritableStream]
expected: FAIL
[patched-global.any.serviceworker.html]
[TransformStream should use the original value of ReadableStream and WritableStream]
expected: FAIL
[patched-global.any.sharedworker.html]
[TransformStream should use the original value of ReadableStream and WritableStream]
expected: FAIL

54
testing/web-platform/meta/streams/transform-streams/properties.any.js.ini
View File

@ -1,54 +0,0 @@
[properties.any.worker.html]
[transformer method transform should be called with the right number of arguments]
expected: FAIL
[transformer method transform should be called even when it's located on the prototype chain]
expected: FAIL
[transformer method flush should be called with the right number of arguments]
expected: FAIL
[transformer method flush should be called even when it's located on the prototype chain]
expected: FAIL
[properties.any.html]
[transformer method transform should be called with the right number of arguments]
expected: FAIL
[transformer method transform should be called even when it's located on the prototype chain]
expected: FAIL
[transformer method flush should be called with the right number of arguments]
expected: FAIL
[transformer method flush should be called even when it's located on the prototype chain]
expected: FAIL
[properties.any.sharedworker.html]
[transformer method transform should be called with the right number of arguments]
expected: FAIL
[transformer method transform should be called even when it's located on the prototype chain]
expected: FAIL
[transformer method flush should be called with the right number of arguments]
expected: FAIL
[transformer method flush should be called even when it's located on the prototype chain]
expected: FAIL
[properties.any.serviceworker.html]
[transformer method transform should be called with the right number of arguments]
expected: FAIL
[transformer method transform should be called even when it's located on the prototype chain]
expected: FAIL
[transformer method flush should be called with the right number of arguments]
expected: FAIL
[transformer method flush should be called even when it's located on the prototype chain]
expected: FAIL

138
testing/web-platform/meta/streams/transform-streams/reentrant-strategies.any.js.ini
View File

@ -1,138 +0,0 @@
[reentrant-strategies.any.sharedworker.html]
[enqueue() inside size() should work]
expected: FAIL
[terminate() inside size() should work]
expected: FAIL
[error() inside size() should work]
expected: FAIL
[desiredSize inside size() should work]
expected: FAIL
[readable cancel() inside size() should work]
expected: FAIL
[pipeTo() inside size() should work]
expected: FAIL
[read() inside of size() should work]
expected: FAIL
[writer.write() inside size() should work]
expected: FAIL
[synchronous writer.write() inside size() should work]
expected: FAIL
[writer.close() inside size() should work]
expected: FAIL
[writer.abort() inside size() should work]
expected: FAIL
[reentrant-strategies.any.serviceworker.html]
[enqueue() inside size() should work]
expected: FAIL
[terminate() inside size() should work]
expected: FAIL
[error() inside size() should work]
expected: FAIL
[desiredSize inside size() should work]
expected: FAIL
[readable cancel() inside size() should work]
expected: FAIL
[pipeTo() inside size() should work]
expected: FAIL
[read() inside of size() should work]
expected: FAIL
[writer.write() inside size() should work]
expected: FAIL
[synchronous writer.write() inside size() should work]
expected: FAIL
[writer.close() inside size() should work]
expected: FAIL
[writer.abort() inside size() should work]
expected: FAIL
[reentrant-strategies.any.worker.html]
[enqueue() inside size() should work]
expected: FAIL
[terminate() inside size() should work]
expected: FAIL
[error() inside size() should work]
expected: FAIL
[desiredSize inside size() should work]
expected: FAIL
[readable cancel() inside size() should work]
expected: FAIL
[pipeTo() inside size() should work]
expected: FAIL
[read() inside of size() should work]
expected: FAIL
[writer.write() inside size() should work]
expected: FAIL
[synchronous writer.write() inside size() should work]
expected: FAIL
[writer.close() inside size() should work]
expected: FAIL
[writer.abort() inside size() should work]
expected: FAIL
[reentrant-strategies.any.html]
[enqueue() inside size() should work]
expected: FAIL
[terminate() inside size() should work]
expected: FAIL
[error() inside size() should work]
expected: FAIL
[desiredSize inside size() should work]
expected: FAIL
[readable cancel() inside size() should work]
expected: FAIL
[pipeTo() inside size() should work]
expected: FAIL
[read() inside of size() should work]
expected: FAIL
[writer.write() inside size() should work]
expected: FAIL
[synchronous writer.write() inside size() should work]
expected: FAIL
[writer.close() inside size() should work]
expected: FAIL
[writer.abort() inside size() should work]
expected: FAIL

102
testing/web-platform/meta/streams/transform-streams/strategies.any.js.ini
View File

@ -1,102 +0,0 @@
[strategies.any.html]
[writableStrategy highWaterMark should work]
expected: FAIL
[readableStrategy highWaterMark should work]
expected: FAIL
[writable should have the correct size() function]
expected: FAIL
[default writable strategy should be equivalent to { highWaterMark: 1 }]
expected: FAIL
[default readable strategy should be equivalent to { highWaterMark: 0 }]
expected: FAIL
[writableStrategy highWaterMark should be converted to a number]
expected: FAIL
[a bad readableStrategy size function should cause writer.write() to reject on an identity transform]
expected: FAIL
[a bad readableStrategy size function should error the stream on enqueue even when transformer.transform() catches the exception]
expected: FAIL
[strategies.any.serviceworker.html]
[writableStrategy highWaterMark should work]
expected: FAIL
[readableStrategy highWaterMark should work]
expected: FAIL
[writable should have the correct size() function]
expected: FAIL
[default writable strategy should be equivalent to { highWaterMark: 1 }]
expected: FAIL
[default readable strategy should be equivalent to { highWaterMark: 0 }]
expected: FAIL
[writableStrategy highWaterMark should be converted to a number]
expected: FAIL
[a bad readableStrategy size function should cause writer.write() to reject on an identity transform]
expected: FAIL
[a bad readableStrategy size function should error the stream on enqueue even when transformer.transform() catches the exception]
expected: FAIL
[strategies.any.sharedworker.html]
[writableStrategy highWaterMark should work]
expected: FAIL
[readableStrategy highWaterMark should work]
expected: FAIL
[writable should have the correct size() function]
expected: FAIL
[default writable strategy should be equivalent to { highWaterMark: 1 }]
expected: FAIL
[default readable strategy should be equivalent to { highWaterMark: 0 }]
expected: FAIL
[writableStrategy highWaterMark should be converted to a number]
expected: FAIL
[a bad readableStrategy size function should cause writer.write() to reject on an identity transform]
expected: FAIL
[a bad readableStrategy size function should error the stream on enqueue even when transformer.transform() catches the exception]
expected: FAIL
[strategies.any.worker.html]
[writableStrategy highWaterMark should work]
expected: FAIL
[readableStrategy highWaterMark should work]
expected: FAIL
[writable should have the correct size() function]
expected: FAIL
[default writable strategy should be equivalent to { highWaterMark: 1 }]
expected: FAIL
[default readable strategy should be equivalent to { highWaterMark: 0 }]
expected: FAIL
[writableStrategy highWaterMark should be converted to a number]
expected: FAIL
[a bad readableStrategy size function should cause writer.write() to reject on an identity transform]
expected: FAIL
[a bad readableStrategy size function should error the stream on enqueue even when transformer.transform() catches the exception]
expected: FAIL

66
testing/web-platform/meta/streams/transform-streams/terminate.any.js.ini
View File

@ -1,66 +0,0 @@
[terminate.any.sharedworker.html]
[controller.terminate() should error pipeTo()]
expected: FAIL
[controller.terminate() should prevent remaining chunks from being processed]
expected: FAIL
[controller.error() after controller.terminate() with queued chunk should error the readable]
expected: FAIL
[controller.error() after controller.terminate() without queued chunk should do nothing]
expected: FAIL
[controller.terminate() inside flush() should not prevent writer.close() from succeeding]
expected: FAIL
[terminate.any.worker.html]
[controller.terminate() should error pipeTo()]
expected: FAIL
[controller.terminate() should prevent remaining chunks from being processed]
expected: FAIL
[controller.error() after controller.terminate() with queued chunk should error the readable]
expected: FAIL
[controller.error() after controller.terminate() without queued chunk should do nothing]
expected: FAIL
[controller.terminate() inside flush() should not prevent writer.close() from succeeding]
expected: FAIL
[terminate.any.serviceworker.html]
[controller.terminate() should error pipeTo()]
expected: FAIL
[controller.terminate() should prevent remaining chunks from being processed]
expected: FAIL
[controller.error() after controller.terminate() with queued chunk should error the readable]
expected: FAIL
[controller.error() after controller.terminate() without queued chunk should do nothing]
expected: FAIL
[controller.terminate() inside flush() should not prevent writer.close() from succeeding]
expected: FAIL
[terminate.any.html]
[controller.terminate() should error pipeTo()]
expected: FAIL
[controller.terminate() should prevent remaining chunks from being processed]
expected: FAIL
[controller.error() after controller.terminate() with queued chunk should error the readable]
expected: FAIL
[controller.error() after controller.terminate() without queued chunk should do nothing]
expected: FAIL
[controller.terminate() inside flush() should not prevent writer.close() from succeeding]
expected: FAIL