LayoutTests/streams/streams-gc.html - Issue 1167343002: Add methods for creating V8 extras-based ReadableStreams from C++

Side by Side Diff: LayoutTests/streams/streams-gc.html

Issue 1167343002: Add methods for creating V8 extras-based ReadableStreams from C++ (Closed) Base URL: https://chromium.googlesource.com/chromium/blink.git@master

Patch Set: That todo is not necessary according to yhirano@ Created 5 years, 5 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 unified diff | Download patch

OLD	NEW
(Empty)
	1 <!DOCTYPE html>

	2 <script src="../resources/testharness.js"></script>

	3 <script src="../resources/testharnessreport.js"></script>

	4

	5 <div id="container">

	6 <div id="element"></div>

	7 </div>

	8

	9 <script>

	10 "use strict";

	11

	12 promise_test(function () {

	13 let request, source;

	14 {

	15 const holder = internals.createReadableStreamTestCase();

	16 request = holder.request;

	17 source = holder.source;

	18 }

	19

	20 const body = request.body;

	21 const reader = body.getReader();

	22 request = undefined;

	23

	24 gc();

	25

	26 source.enqueue(1);

	27

	28 return reader.read().then(function (result) {

	29 assert_equals(result.value, 1);

	30 assert_equals(result.done, false);

	31

	32 source.close();

	33

	34 return reader.read().then(function (result) {

	35 assert_equals(result.value, undefined);

	36 assert_equals(result.done, true);

	37 });

	38 });

	39 }, "when the request is GCed (but not the stream), enqueue and close should stil l work");

	40

	41 promise_test(function (t) {

	42 let request, source;

	43 {

	44 const holder = internals.createReadableStreamTestCase();

	45 request = holder.request;

	46 source = holder.source;

	47 }

	48

	49 let body = request.body;

	50 const reader = body.getReader();

	51 request = undefined;

	52 body = undefined;

	53

	54 gc();

	55

	56 source.enqueue(2);

	57

	58 return reader.read().then(function (result) {

	59 assert_equals(result.value, 2);

	60 assert_equals(result.done, false);

	61

	62 const e = new Error("boo!");

	63 source.error(e);

	64

	65 const unreached = t.unreached_func('promise should not be fulfilled');

	66 return reader.read().then(

	67 unreached,

	68 function (err) {

	69 assert_equals(err, e);

	70 }

	71 );

	72 });

	73 }, "when the request and stream are GCed (but not the reader), enqueue and error should still work");

	74

	75 promise_test(function () {

	76 let request, source;

	77 {

	78 const holder = internals.createReadableStreamTestCase();

	79 request = holder.request;

	80 source = holder.source;

	81 }

	82

	83 let body = request.body;

	84 let reader = body.getReader();

	85 const closed = reader.closed;

	86 request = undefined;

	87 body = undefined;

	88 reader = undefined;

	89

	90 gc();

	91

	92 source.close();

	93

	94 return closed;

	95 }, "when the request and stream and reader are GCed (but a closed promise is kep t), close should still work");

	96

	97 promise_test(function (t) {

	98 let request, source;

	99 {

	100 const holder = internals.createReadableStreamTestCase();

	101 request = holder.request;

	102 source = holder.source;

	103 }

	104

	105 let body = request.body;

	106 let reader = body.getReader();

	107 const closed = reader.closed;

	108 request = undefined;

	109 body = undefined;

	110 reader = undefined;

	111

	112 gc();

	113

	114 const e = new Error("boo!");

	115 source.error(e);

	116

	117 const unreached = t.unreached_func('promise should not be fulfilled');

	118 return closed.then(

	119 unreached,

	120 function (err) {

	121 assert_equals(err, e);

	122 }

	123 );

	124 }, "when the request and stream and reader are GCed (but a closed promise is kep t), error should still work");

	125

	126 test(function () {

	127 let request, source;

	128 {

	129 const holder = internals.createReadableStreamTestCase();

	130 request = holder.request;

	131 source = holder.source;

	132 }

	133

	134 request = undefined;

	135

	136 gc();

	137

	138 source.enqueue("a");

	139 source.enqueue(2);

	140 source.close();

	141 }, "enqueuing and closing after the request/stream/etc. are collected should be a no-op, not a crash");

	142

	143 test(function () {

	144 let request, source;

	145 {

	146 const holder = internals.createReadableStreamTestCase();

	147 request = holder.request;

	148 source = holder.source;

	149 }

	150

	151 request.body.cancel();

	152

	153 request = undefined;

	154

	155 gc();

	156

	157 source.enqueue("a");

	158 source.enqueue(2);

	159 source.close();

	160 }, "enqueuing and closing after the stream has been canceled should be a no-op, not a crash");

	161

	162 test(function () {

	163 let request = internals.createReadableStreamTestCase().request;

	164 let body = request.body;

	165

	166 body.request = request;

	167

	168 request = undefined;

	169 body = undefined;

	170

	171 gc();

	172 }, "attaching a request to a stream should not cause a leak or crash");

	173

	174 </script>

OLD	NEW

« no previous file with comments | « no previous file | Source/bindings/core/v8/ScriptState.h » ('j') | no next file with comments »