Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1581)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: Source/core/streams/ReadableStreamReaderTest.cpp

Issue 1004623007: Streams Implementation Update: async read (Closed) Base URL: https://chromium.googlesource.com/chromium/blink.git@stream-reader-read
Patch Set: Created 5 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « Source/core/streams/ReadableStreamReader.idl ('k') | Source/core/streams/ReadableStreamTest.cpp » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: Source/core/streams/ReadableStreamReaderTest.cpp
diff --git a/Source/core/streams/ReadableStreamReaderTest.cpp b/Source/core/streams/ReadableStreamReaderTest.cpp
index b7b1c0e0a5133cfedd1ac57965fcc8bd803bb103..43634d2c40bc941b7562aa526b75a1b64d63886f 100644
--- a/Source/core/streams/ReadableStreamReaderTest.cpp
+++ b/Source/core/streams/ReadableStreamReaderTest.cpp
@@ -24,6 +24,14 @@ using StringStream = ReadableStreamImpl<ReadableStreamChunkTypeTraits<String>>;
namespace {
+struct ReadResult {
+ ReadResult() : isDone(false), isSet(false) { }
+
+ String valueString;
+ bool isDone;
+ bool isSet;
+};
+
class StringCapturingFunction final : public ScriptFunction {
public:
static v8::Handle<v8::Function> createFunction(ScriptState* scriptState, String* value)
@@ -49,6 +57,56 @@ private:
String* m_value;
};
+class ReadResultCapturingFunction final : public ScriptFunction {
+public:
+ static v8::Handle<v8::Function> createFunction(ScriptState* scriptState, ReadResult* value)
+ {
+ ReadResultCapturingFunction* self = new ReadResultCapturingFunction(scriptState, value);
+ return self->bindToV8Function();
+ }
+
+private:
+ ReadResultCapturingFunction(ScriptState* scriptState, ReadResult* value)
+ : ScriptFunction(scriptState)
+ , m_result(value)
+ {
+ }
+
+ ScriptValue call(ScriptValue result) override
+ {
+ ASSERT(!result.isEmpty());
+ v8::Isolate* isolate = scriptState()->isolate();
+ if (!result.isObject()) {
+ return result;
+ }
+ v8::Local<v8::Object> object = result.v8Value().As<v8::Object>();
+ v8::Local<v8::String> doneString = v8String(isolate, "done");
+ v8::Local<v8::String> valueString = v8String(isolate, "value");
+ v8::Local<v8::Context> context = scriptState()->context();
+ v8::Maybe<bool> hasDone = object->Has(context, doneString);
+ v8::Maybe<bool> hasValue = object->Has(context, valueString);
+
+ if (hasDone.IsNothing() || !hasDone.FromJust() || hasValue.IsNothing() || !hasValue.FromJust()) {
+ return result;
+ }
+
+ v8::Local<v8::Value> done;
+ v8::Local<v8::Value> value;
+
+ if (!object->Get(context, doneString).ToLocal(&done) || !object->Get(context, valueString).ToLocal(&value) || !done->IsBoolean()) {
+ return result;
+ }
+
+ m_result->isSet = true;
+ m_result->isDone = done.As<v8::Boolean>()->Value();
+ m_result->valueString = toCoreString(value->ToString(isolate));
+
+ return result;
+ }
+
+ ReadResult* m_result;
+};
+
class NoopUnderlyingSource final : public GarbageCollectedFinalized<NoopUnderlyingSource>, public UnderlyingSource {
USING_GARBAGE_COLLECTED_MIXIN(NoopUnderlyingSource);
public:
@@ -75,8 +133,10 @@ public:
m_stream->didSourceStart();
}
- ~ReadableStreamReaderTest()
+ ~ReadableStreamReaderTest() override
{
+ EXPECT_FALSE(m_exceptionState.hadException());
+
// We need to call |error| in order to make
// ActiveDOMObject::hasPendingActivity return false.
m_stream->error(DOMException::create(AbortError, "done"));
@@ -90,6 +150,11 @@ public:
return StringCapturingFunction::createFunction(scriptState(), value);
}
+ v8::Handle<v8::Function> createResultCaptor(ReadResult* value)
+ {
+ return ReadResultCapturingFunction::createFunction(scriptState(), value);
+ }
+
OwnPtr<DummyPageHolder> m_page;
ScriptState::Scope m_scope;
ExceptionState m_exceptionState;
@@ -104,123 +169,145 @@ TEST_F(ReadableStreamReaderTest, Construct)
TEST_F(ReadableStreamReaderTest, Release)
{
+ String onFulfilled, onRejected;
ReadableStreamReader* reader = new ReadableStreamReader(m_stream);
EXPECT_TRUE(reader->isActive());
- reader->releaseLock();
+
+ reader->closed(scriptState()).then(createCaptor(&onFulfilled), createCaptor(&onRejected));
+ reader->releaseLock(m_exceptionState);
EXPECT_FALSE(reader->isActive());
+ EXPECT_FALSE(m_exceptionState.hadException());
+
+ EXPECT_TRUE(onFulfilled.isNull());
+ EXPECT_TRUE(onRejected.isNull());
+
+ isolate()->RunMicrotasks();
+ EXPECT_EQ("undefined", onFulfilled);
+ EXPECT_TRUE(onRejected.isNull());
ReadableStreamReader* another = new ReadableStreamReader(m_stream);
EXPECT_TRUE(another->isActive());
EXPECT_FALSE(reader->isActive());
- reader->releaseLock();
+ reader->releaseLock(m_exceptionState);
EXPECT_TRUE(another->isActive());
EXPECT_FALSE(reader->isActive());
+ EXPECT_FALSE(m_exceptionState.hadException());
}
-TEST_F(ReadableStreamReaderTest, MaskState)
+TEST_F(ReadableStreamReaderTest, ReadAfterRelease)
{
- m_stream->enqueue("hello");
- EXPECT_EQ("readable", m_stream->stateString());
-
ReadableStreamReader* reader = new ReadableStreamReader(m_stream);
- EXPECT_EQ("waiting", m_stream->stateString());
- EXPECT_EQ("readable", reader->state());
+ EXPECT_TRUE(reader->isActive());
+ reader->releaseLock(m_exceptionState);
+ EXPECT_FALSE(m_exceptionState.hadException());
+ EXPECT_FALSE(reader->isActive());
- reader->releaseLock();
- EXPECT_EQ("readable", m_stream->stateString());
- EXPECT_EQ("closed", reader->state());
+ ReadResult result;
+ String onRejected;
+ reader->read(scriptState()).then(createResultCaptor(&result), createCaptor(&onRejected));
- ReadableStreamReader* another = new ReadableStreamReader(m_stream);
- EXPECT_EQ("waiting", m_stream->stateString());
- EXPECT_EQ("closed", reader->state());
- EXPECT_EQ("readable", another->state());
+ EXPECT_FALSE(result.isSet);
+ EXPECT_TRUE(onRejected.isNull());
+ isolate()->RunMicrotasks();
+
+ EXPECT_TRUE(result.isSet);
+ EXPECT_TRUE(result.isDone);
+ EXPECT_EQ("undefined", result.valueString);
+ EXPECT_TRUE(onRejected.isNull());
}
-TEST_F(ReadableStreamReaderTest, MaskReady)
+TEST_F(ReadableStreamReaderTest, ReleaseShouldFailWhenCalledWhileReading)
{
- m_stream->enqueue("hello");
- isolate()->RunMicrotasks();
-
ReadableStreamReader* reader = new ReadableStreamReader(m_stream);
- {
- String s1, s2;
- reader->ready(scriptState()).then(createCaptor(&s1));
- m_stream->ready(scriptState()).then(createCaptor(&s2));
- isolate()->RunMicrotasks();
- EXPECT_EQ("undefined", s1);
- EXPECT_TRUE(s2.isNull());
-
- reader->releaseLock();
- isolate()->RunMicrotasks();
- EXPECT_EQ("undefined", s2);
- }
+ EXPECT_TRUE(reader->isActive());
+ reader->read(scriptState());
- {
- String s1, s2;
- reader->ready(scriptState()).then(createCaptor(&s1));
- m_stream->ready(scriptState()).then(createCaptor(&s2));
- isolate()->RunMicrotasks();
- EXPECT_EQ("undefined", s1);
- EXPECT_EQ("undefined", s2);
- }
+ reader->releaseLock(m_exceptionState);
+ EXPECT_TRUE(reader->isActive());
+ EXPECT_TRUE(m_exceptionState.hadException());
+ m_exceptionState.clearException();
- ReadableStreamReader* another = new ReadableStreamReader(m_stream);
- {
- String s1, s2, s3;
- reader->ready(scriptState()).then(createCaptor(&s1));
- m_stream->ready(scriptState()).then(createCaptor(&s2));
- another->ready(scriptState()).then(createCaptor(&s3));
- isolate()->RunMicrotasks();
- EXPECT_EQ("undefined", s1);
- EXPECT_TRUE(s2.isNull());
- EXPECT_EQ("undefined", s3);
-
- // We need to call here to ensure all promises having captors are
- // resolved or rejected.
- m_stream->error(DOMException::create(AbortError, "done"));
- isolate()->RunMicrotasks();
- }
+ m_stream->enqueue("hello");
+ reader->releaseLock(m_exceptionState);
+ EXPECT_FALSE(reader->isActive());
+ EXPECT_FALSE(m_exceptionState.hadException());
}
-TEST_F(ReadableStreamReaderTest, ReaderRead)
+TEST_F(ReadableStreamReaderTest, EnqueueThenRead)
{
m_stream->enqueue("hello");
+ m_stream->enqueue("world");
ReadableStreamReader* reader = new ReadableStreamReader(m_stream);
-
EXPECT_EQ(ReadableStream::Readable, m_stream->stateInternal());
- ScriptValue value = reader->read(scriptState(), m_exceptionState);
- EXPECT_FALSE(m_exceptionState.hadException());
- String stringValue;
- EXPECT_TRUE(value.toString(stringValue));
- EXPECT_EQ("hello", stringValue);
+ ReadResult result;
+ String onRejected;
+ reader->read(scriptState()).then(createResultCaptor(&result), createCaptor(&onRejected));
+
+ EXPECT_FALSE(result.isSet);
+ EXPECT_TRUE(onRejected.isNull());
+
+ isolate()->RunMicrotasks();
+
+ EXPECT_TRUE(result.isSet);
+ EXPECT_FALSE(result.isDone);
+ EXPECT_EQ("hello", result.valueString);
+ EXPECT_TRUE(onRejected.isNull());
+
+ ReadResult result2;
+ String onRejected2;
+ reader->read(scriptState()).then(createResultCaptor(&result2), createCaptor(&onRejected2));
+
+ EXPECT_FALSE(result2.isSet);
+ EXPECT_TRUE(onRejected2.isNull());
+
+ isolate()->RunMicrotasks();
+
+ EXPECT_TRUE(result2.isSet);
+ EXPECT_FALSE(result2.isDone);
+ EXPECT_EQ("world", result2.valueString);
+ EXPECT_TRUE(onRejected2.isNull());
}
-TEST_F(ReadableStreamReaderTest, StreamReadShouldFailWhenLocked)
+TEST_F(ReadableStreamReaderTest, ReadThenEnqueue)
{
- m_stream->enqueue("hello");
ReadableStreamReader* reader = new ReadableStreamReader(m_stream);
- EXPECT_TRUE(reader->isActive());
-
EXPECT_EQ(ReadableStream::Readable, m_stream->stateInternal());
- m_stream->read(scriptState(), m_exceptionState);
- EXPECT_TRUE(m_exceptionState.hadException());
- EXPECT_EQ(ReadableStream::Readable, m_stream->stateInternal());
-}
+ ReadResult result, result2;
+ String onRejected, onRejected2;
+ reader->read(scriptState()).then(createResultCaptor(&result), createCaptor(&onRejected));
+ reader->read(scriptState()).then(createResultCaptor(&result2), createCaptor(&onRejected2));
+
+ EXPECT_FALSE(result.isSet);
+ EXPECT_TRUE(onRejected.isNull());
+ EXPECT_FALSE(result2.isSet);
+ EXPECT_TRUE(onRejected2.isNull());
+
+ isolate()->RunMicrotasks();
+
+ EXPECT_FALSE(result.isSet);
+ EXPECT_TRUE(onRejected.isNull());
+ EXPECT_FALSE(result2.isSet);
+ EXPECT_TRUE(onRejected2.isNull());
-TEST_F(ReadableStreamReaderTest, ReaderReadShouldFailWhenNotLocked)
-{
m_stream->enqueue("hello");
- ReadableStreamReader* reader = new ReadableStreamReader(m_stream);
- reader->releaseLock();
- EXPECT_FALSE(reader->isActive());
+ isolate()->RunMicrotasks();
- EXPECT_EQ(ReadableStream::Readable, m_stream->stateInternal());
- reader->read(scriptState(), m_exceptionState);
+ EXPECT_TRUE(result.isSet);
+ EXPECT_FALSE(result.isDone);
+ EXPECT_EQ("hello", result.valueString);
+ EXPECT_TRUE(onRejected.isNull());
+ EXPECT_FALSE(result2.isSet);
+ EXPECT_TRUE(onRejected2.isNull());
- EXPECT_TRUE(m_exceptionState.hadException());
- EXPECT_EQ(ReadableStream::Readable, m_stream->stateInternal());
+ m_stream->enqueue("world");
+ isolate()->RunMicrotasks();
+
+ EXPECT_TRUE(result2.isSet);
+ EXPECT_FALSE(result2.isDone);
+ EXPECT_EQ("world", result2.valueString);
+ EXPECT_TRUE(onRejected2.isNull());
}
TEST_F(ReadableStreamReaderTest, ClosedReader)
@@ -229,25 +316,26 @@ TEST_F(ReadableStreamReaderTest, ClosedReader)
m_stream->close();
- EXPECT_EQ("closed", m_stream->stateString());
- EXPECT_EQ("closed", reader->state());
EXPECT_FALSE(reader->isActive());
String onClosedFulfilled, onClosedRejected;
- String onReadyFulfilled, onReadyRejected;
+ ReadResult result;
+ String onReadRejected;
isolate()->RunMicrotasks();
reader->closed(scriptState()).then(createCaptor(&onClosedFulfilled), createCaptor(&onClosedRejected));
- reader->ready(scriptState()).then(createCaptor(&onReadyFulfilled), createCaptor(&onReadyRejected));
+ reader->read(scriptState()).then(createResultCaptor(&result), createCaptor(&onReadRejected));
EXPECT_TRUE(onClosedFulfilled.isNull());
EXPECT_TRUE(onClosedRejected.isNull());
- EXPECT_TRUE(onReadyFulfilled.isNull());
- EXPECT_TRUE(onReadyRejected.isNull());
+ EXPECT_FALSE(result.isSet);
+ EXPECT_TRUE(onReadRejected.isNull());
isolate()->RunMicrotasks();
EXPECT_EQ("undefined", onClosedFulfilled);
EXPECT_TRUE(onClosedRejected.isNull());
- EXPECT_EQ("undefined", onReadyFulfilled);
- EXPECT_TRUE(onReadyRejected.isNull());
+ EXPECT_TRUE(result.isSet);
+ EXPECT_TRUE(result.isDone);
+ EXPECT_EQ("undefined", result.valueString);
+ EXPECT_TRUE(onReadRejected.isNull());
}
TEST_F(ReadableStreamReaderTest, ErroredReader)
@@ -256,177 +344,206 @@ TEST_F(ReadableStreamReaderTest, ErroredReader)
m_stream->error(DOMException::create(SyntaxError, "some error"));
- EXPECT_EQ("errored", m_stream->stateString());
- EXPECT_EQ("errored", reader->state());
+ EXPECT_EQ(ReadableStream::Errored, m_stream->stateInternal());
EXPECT_FALSE(reader->isActive());
String onClosedFulfilled, onClosedRejected;
- String onReadyFulfilled, onReadyRejected;
+ String onReadFulfilled, onReadRejected;
+ isolate()->RunMicrotasks();
reader->closed(scriptState()).then(createCaptor(&onClosedFulfilled), createCaptor(&onClosedRejected));
- reader->ready(scriptState()).then(createCaptor(&onReadyFulfilled), createCaptor(&onReadyRejected));
+ reader->read(scriptState()).then(createCaptor(&onReadFulfilled), createCaptor(&onReadRejected));
EXPECT_TRUE(onClosedFulfilled.isNull());
EXPECT_TRUE(onClosedRejected.isNull());
- EXPECT_TRUE(onReadyFulfilled.isNull());
- EXPECT_TRUE(onReadyRejected.isNull());
+ EXPECT_TRUE(onReadFulfilled.isNull());
+ EXPECT_TRUE(onReadRejected.isNull());
isolate()->RunMicrotasks();
EXPECT_TRUE(onClosedFulfilled.isNull());
EXPECT_EQ("SyntaxError: some error", onClosedRejected);
- EXPECT_EQ("undefined", onReadyFulfilled);
- EXPECT_TRUE(onReadyRejected.isNull());
+ EXPECT_TRUE(onReadFulfilled.isNull());
+ EXPECT_EQ("SyntaxError: some error", onReadRejected);
}
-TEST_F(ReadableStreamReaderTest, ReadyPromiseShouldNotBeResolvedWhenLocked)
+TEST_F(ReadableStreamReaderTest, PendingReadsShouldBeResolvedWhenClosed)
{
- String s;
- ScriptPromise ready = m_stream->ready(scriptState());
- ready.then(createCaptor(&s));
- isolate()->RunMicrotasks();
- EXPECT_TRUE(s.isNull());
-
ReadableStreamReader* reader = new ReadableStreamReader(m_stream);
- EXPECT_TRUE(reader->isActive());
- EXPECT_NE(ready, m_stream->ready(scriptState()));
+ EXPECT_EQ(ReadableStream::Readable, m_stream->stateInternal());
- isolate()->RunMicrotasks();
- EXPECT_TRUE(s.isNull());
+ ReadResult result, result2;
+ String onRejected, onRejected2;
+ reader->read(scriptState()).then(createResultCaptor(&result), createCaptor(&onRejected));
+ reader->read(scriptState()).then(createResultCaptor(&result2), createCaptor(&onRejected2));
- // We need to call here to ensure all promises having captors are resolved
- // or rejected.
- m_stream->error(DOMException::create(AbortError, "done"));
isolate()->RunMicrotasks();
-}
+ EXPECT_FALSE(result.isSet);
+ EXPECT_TRUE(onRejected.isNull());
+ EXPECT_FALSE(result2.isSet);
+ EXPECT_TRUE(onRejected2.isNull());
-TEST_F(ReadableStreamReaderTest, ReaderShouldBeReleasedWhenClosed)
-{
- ReadableStreamReader* reader = new ReadableStreamReader(m_stream);
- EXPECT_TRUE(reader->isActive());
m_stream->close();
- EXPECT_FALSE(reader->isActive());
-}
+ EXPECT_FALSE(result.isSet);
+ EXPECT_TRUE(onRejected.isNull());
+ EXPECT_FALSE(result2.isSet);
+ EXPECT_TRUE(onRejected2.isNull());
-TEST_F(ReadableStreamReaderTest, ReaderShouldBeReleasedWhenCanceled)
-{
- ReadableStreamReader* reader = new ReadableStreamReader(m_stream);
- EXPECT_TRUE(reader->isActive());
- reader->cancel(scriptState(), ScriptValue(scriptState(), v8::Undefined(isolate())));
- EXPECT_FALSE(reader->isActive());
+ isolate()->RunMicrotasks();
+
+ EXPECT_TRUE(result.isSet);
+ EXPECT_TRUE(result.isDone);
+ EXPECT_EQ("undefined", result.valueString);
+ EXPECT_TRUE(onRejected.isNull());
+
+ EXPECT_TRUE(result2.isSet);
+ EXPECT_TRUE(result2.isDone);
+ EXPECT_EQ("undefined", result2.valueString);
+ EXPECT_TRUE(onRejected2.isNull());
}
-TEST_F(ReadableStreamReaderTest, ReaderShouldBeReleasedWhenErrored)
+TEST_F(ReadableStreamReaderTest, PendingReadsShouldBeRejectedWhenErrored)
{
ReadableStreamReader* reader = new ReadableStreamReader(m_stream);
- EXPECT_TRUE(reader->isActive());
+ EXPECT_EQ(ReadableStream::Readable, m_stream->stateInternal());
+
+ String onFulfilled, onFulfilled2;
+ String onRejected, onRejected2;
+ reader->read(scriptState()).then(createCaptor(&onFulfilled), createCaptor(&onRejected));
+ reader->read(scriptState()).then(createCaptor(&onFulfilled2), createCaptor(&onRejected2));
+
+ isolate()->RunMicrotasks();
+ EXPECT_TRUE(onFulfilled.isNull());
+ EXPECT_TRUE(onRejected.isNull());
+ EXPECT_TRUE(onFulfilled2.isNull());
+ EXPECT_TRUE(onRejected2.isNull());
+
m_stream->error(DOMException::create(SyntaxError, "some error"));
- EXPECT_FALSE(reader->isActive());
+ EXPECT_TRUE(onFulfilled.isNull());
+ EXPECT_TRUE(onRejected.isNull());
+ EXPECT_TRUE(onFulfilled2.isNull());
+ EXPECT_TRUE(onRejected2.isNull());
+
+ isolate()->RunMicrotasks();
+
+ EXPECT_TRUE(onFulfilled.isNull());
+ EXPECT_EQ(onRejected, "SyntaxError: some error");
+ EXPECT_TRUE(onFulfilled2.isNull());
+ EXPECT_EQ(onRejected2, "SyntaxError: some error");
}
-TEST_F(ReadableStreamReaderTest, StreamCancelShouldFailWhenLocked)
+TEST_F(ReadableStreamReaderTest, PendingReadsShouldBeResolvedWhenCanceled)
{
ReadableStreamReader* reader = new ReadableStreamReader(m_stream);
- EXPECT_TRUE(reader->isActive());
- ScriptPromise p = m_stream->cancel(scriptState(), ScriptValue(scriptState(), v8::Undefined(isolate())));
- EXPECT_EQ(ReadableStream::Waiting, m_stream->stateInternal());
- String onFulfilled, onRejected;
- p.then(createCaptor(&onFulfilled), createCaptor(&onRejected));
+ EXPECT_EQ(ReadableStream::Readable, m_stream->stateInternal());
- EXPECT_TRUE(onFulfilled.isNull());
+ ReadResult result, result2;
+ String onRejected, onRejected2;
+ reader->read(scriptState()).then(createResultCaptor(&result), createCaptor(&onRejected));
+ reader->read(scriptState()).then(createResultCaptor(&result2), createCaptor(&onRejected2));
+
+ isolate()->RunMicrotasks();
+ EXPECT_FALSE(result.isSet);
EXPECT_TRUE(onRejected.isNull());
+ EXPECT_FALSE(result2.isSet);
+ EXPECT_TRUE(onRejected2.isNull());
+
+ reader->cancel(scriptState(), ScriptValue(scriptState(), v8::Undefined(isolate())));
+ EXPECT_FALSE(reader->isActive());
+ EXPECT_FALSE(result.isSet);
+ EXPECT_TRUE(onRejected.isNull());
+ EXPECT_FALSE(result2.isSet);
+ EXPECT_TRUE(onRejected2.isNull());
+
isolate()->RunMicrotasks();
- EXPECT_TRUE(onFulfilled.isNull());
- EXPECT_EQ("TypeError: this stream is locked to a ReadableStreamReader", onRejected);
+
+ EXPECT_TRUE(result.isSet);
+ EXPECT_TRUE(result.isDone);
+ EXPECT_EQ("undefined", result.valueString);
+ EXPECT_TRUE(onRejected.isNull());
+
+ EXPECT_TRUE(result2.isSet);
+ EXPECT_TRUE(result2.isDone);
+ EXPECT_EQ("undefined", result2.valueString);
+ EXPECT_TRUE(onRejected2.isNull());
}
-TEST_F(ReadableStreamReaderTest, ReaderCancelShouldNotWorkWhenNotActive)
+TEST_F(ReadableStreamReaderTest, CancelShouldNotWorkWhenNotActive)
{
ReadableStreamReader* reader = new ReadableStreamReader(m_stream);
- reader->releaseLock();
+ reader->releaseLock(m_exceptionState);
EXPECT_FALSE(reader->isActive());
- ScriptPromise p = reader->cancel(scriptState(), ScriptValue(scriptState(), v8::Undefined(isolate())));
- EXPECT_EQ(ReadableStream::Waiting, m_stream->stateInternal());
String onFulfilled, onRejected;
- p.then(createCaptor(&onFulfilled), createCaptor(&onRejected));
+ reader->cancel(scriptState(), ScriptValue(scriptState(), v8::Undefined(isolate()))).then(createCaptor(&onFulfilled), createCaptor(&onRejected));
+ EXPECT_EQ(ReadableStream::Readable, m_stream->stateInternal());
EXPECT_TRUE(onFulfilled.isNull());
EXPECT_TRUE(onRejected.isNull());
+
isolate()->RunMicrotasks();
+
EXPECT_EQ("undefined", onFulfilled);
EXPECT_TRUE(onRejected.isNull());
+ EXPECT_EQ(ReadableStream::Readable, m_stream->stateInternal());
}
-TEST_F(ReadableStreamReaderTest, ReadyShouldNotBeResolvedWhileLocked)
+TEST_F(ReadableStreamReaderTest, Cancel)
{
- String onFulfilled;
- m_stream->ready(scriptState()).then(createCaptor(&onFulfilled));
-
ReadableStreamReader* reader = new ReadableStreamReader(m_stream);
+ EXPECT_EQ(ReadableStream::Readable, m_stream->stateInternal());
- m_stream->enqueue("hello");
- m_stream->enqueue("world");
-
- ASSERT_EQ("readable", reader->state());
- reader->read(scriptState(), m_exceptionState);
- ASSERT_EQ("readable", reader->state());
- reader->read(scriptState(), m_exceptionState);
- ASSERT_EQ("waiting", reader->state());
+ String onClosedFulfilled, onClosedRejected;
+ String onCancelFulfilled, onCancelRejected;
+ reader->closed(scriptState()).then(createCaptor(&onClosedFulfilled), createCaptor(&onClosedRejected));
+ reader->cancel(scriptState(), ScriptValue(scriptState(), v8::Undefined(isolate()))).then(createCaptor(&onCancelFulfilled), createCaptor(&onCancelRejected));
- isolate()->RunMicrotasks();
- EXPECT_TRUE(onFulfilled.isNull());
+ EXPECT_EQ(ReadableStream::Closed, m_stream->stateInternal());
+ EXPECT_TRUE(onClosedFulfilled.isNull());
+ EXPECT_TRUE(onClosedRejected.isNull());
+ EXPECT_TRUE(onCancelFulfilled.isNull());
+ EXPECT_TRUE(onCancelRejected.isNull());
- // We need to call here to ensure all promises having captors are resolved
- // or rejected.
- m_stream->error(DOMException::create(AbortError, "done"));
isolate()->RunMicrotasks();
+ EXPECT_EQ("undefined", onClosedFulfilled);
+ EXPECT_TRUE(onClosedRejected.isNull());
+ EXPECT_EQ("undefined", onCancelFulfilled);
+ EXPECT_TRUE(onCancelRejected.isNull());
}
-TEST_F(ReadableStreamReaderTest, ReadyShouldNotBeResolvedWhenReleasedIfNotReady)
+TEST_F(ReadableStreamReaderTest, Close)
{
- String onFulfilled;
- m_stream->ready(scriptState()).then(createCaptor(&onFulfilled));
-
ReadableStreamReader* reader = new ReadableStreamReader(m_stream);
+ EXPECT_EQ(ReadableStream::Readable, m_stream->stateInternal());
- m_stream->enqueue("hello");
- m_stream->enqueue("world");
-
- ASSERT_EQ("readable", reader->state());
- reader->read(scriptState(), m_exceptionState);
- ASSERT_EQ("readable", reader->state());
- reader->read(scriptState(), m_exceptionState);
- ASSERT_EQ("waiting", reader->state());
+ String onFulfilled, onRejected;
+ reader->closed(scriptState()).then(createCaptor(&onFulfilled), createCaptor(&onRejected));
- reader->releaseLock();
+ m_stream->close();
- isolate()->RunMicrotasks();
+ EXPECT_EQ(ReadableStream::Closed, m_stream->stateInternal());
EXPECT_TRUE(onFulfilled.isNull());
+ EXPECT_TRUE(onRejected.isNull());
- // We need to call here to ensure all promises having captors are resolved
- // or rejected.
- m_stream->error(DOMException::create(AbortError, "done"));
isolate()->RunMicrotasks();
+ EXPECT_EQ("undefined", onFulfilled);
+ EXPECT_TRUE(onRejected.isNull());
}
-TEST_F(ReadableStreamReaderTest, ReadyShouldBeResolvedWhenReleasedIfReady)
+TEST_F(ReadableStreamReaderTest, Error)
{
- String onFulfilled;
- m_stream->ready(scriptState()).then(createCaptor(&onFulfilled));
-
ReadableStreamReader* reader = new ReadableStreamReader(m_stream);
+ EXPECT_EQ(ReadableStream::Readable, m_stream->stateInternal());
- m_stream->enqueue("hello");
- m_stream->enqueue("world");
+ String onFulfilled, onRejected;
+ reader->closed(scriptState()).then(createCaptor(&onFulfilled), createCaptor(&onRejected));
- ASSERT_EQ("readable", reader->state());
- reader->read(scriptState(), m_exceptionState);
- ASSERT_EQ("readable", reader->state());
+ m_stream->error(DOMException::create(SyntaxError, "some error"));
- isolate()->RunMicrotasks();
- reader->releaseLock();
+ EXPECT_EQ(ReadableStream::Errored, m_stream->stateInternal());
EXPECT_TRUE(onFulfilled.isNull());
+ EXPECT_TRUE(onRejected.isNull());
isolate()->RunMicrotasks();
- EXPECT_EQ("undefined", onFulfilled);
+ EXPECT_TRUE(onFulfilled.isNull());
+ EXPECT_EQ("SyntaxError: some error", onRejected);
}
} // namespace
« no previous file with comments | « Source/core/streams/ReadableStreamReader.idl ('k') | Source/core/streams/ReadableStreamTest.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698