LayoutTests/streams/shadowing-Promise.html - WebKit - Git at Google

 <!DOCTYPE html>
 <script src='../resources/testharness.js'></script>
 <script src='../resources/testharnessreport.js'></script>
 <script>
 test(function() {
     const PromiseBackup = Promise;

     try {
         Promise = function() { assert_unreached("streams should not use this Promise object"); };

         new ReadableStream();
         new WritableStream();
     } finally {
         Promise = PromiseBackup;
     }
 }, 'Streams and promises: replace Promise constructor');

 test(function() {
     const PromiseResolveBackup = Promise.resolve;

     try {
         Promise.resolve = function() { assert_unreached("streams should not use this Promise.resolve method"); };

         new ReadableStream();
         new WritableStream();
     } finally {
         Promise.resolve = PromiseResolveBackup;
     }
 }, 'Streams and promises: replace Promise.resolve');

 test(function() {
     const PromiseRejectBackup = Promise.reject;

     function handle() { }

     try {
         Promise.reject = function() { assert_unreached("streams should not use this Promise.reject method"); };

         ReadableStream.prototype.cancel.call({}, "reason").then(handle, handle);
         WritableStream.prototype.abort.call({}, "reason").then(handle, handle);
     } finally {
         Promise.reject = PromiseRejectBackup;
     }
 }, 'Streams and promises: replace Promise.reject');

 test(function() {
     function createMangledPromise() {
         const promise = Promise.resolve();
         Object.setPrototypeOf(promise, { constructor: Promise, then: function() { assert_unreached("streams should not use this promise then method"); } });
         return promise;
     }
     new ReadableStream({ start: function() { return createMangledPromise(); } })
     new WritableStream({ start: function() { return createMangledPromise(); } })
 }, 'Streams and promises: replace prototype of a promise object');

 test(function() {
     const PromiseThenBackup = Promise.prototype.then;

     try {
         Promise.prototype.then = function() { assert_unreached("streams should not use this Promise.prototype.then method"); };

         new ReadableStream();
         new WritableStream();
     } finally {
         Promise.prototype.then = PromiseThenBackup;
     }
 }, 'Streams and promises: replace then method in Promise prototype');

 test(function() {
     const PromiseCatchBackup = Promise.prototype.catch;
     const PromiseThenBackup = Promise.prototype.then;

     try {
         Promise.prototype.catch = function() { assert_unreached("streams should not use this Promise.prototype.catch method"); };
         Promise.prototype.then = function() { assert_unreached("streams should not use this Promise.prototype.catch method"); };

         const rs = new ReadableStream();
         rs.tee();
     } finally {
         Promise.prototype.catch = PromiseCatchBackup;
         Promise.prototype.then = PromiseThenBackup;
     }
 }, 'Streams and promises: replace catch method in Promise prototype');

 test(function() {
     function createMangledPromise() {
         const promise = Promise.resolve();
         promise.then = function() { assert_unreached("streams should not use this promise then method"); };
         return promise;
     }
     new ReadableStream({ start: function() { return createMangledPromise(); } })
     new WritableStream({ start: function() { return createMangledPromise(); } })
 }, 'Streams and promises: replace then method in promise object');

 test(function() {
     const NumberBackup = Number;
     const NumberIsNaNBackup = Number.isNaN;
     const NumberIsFiniteBackup = Number.isFinite;

     try {
         Number.isNaN = function() { assert_unreached("streams should not use this Number.isNaN method"); };
         Number.isFinite = function() { assert_unreached("streams should not use this Number.isFinite method"); };
         Number = null;

         new ReadableStream({
             start: function(controller) {
                 controller.enqueue("small potato");
             }
         }, {
             size: function(chunk) { return 2; },
             highWaterMark: 1
         });

     } finally {
         Number = NumberBackup;
         Number.isNaN = NumberIsNaNBackup;
         Number.isFinite = NumberIsFiniteBackup;
     }
 }, 'Streams should not directly use Number and related methods');
 test(function() {
     const ReadableStreamGetReaderBackup = ReadableStream.prototype.getReader;

     try {
         ReadableStream.prototype.getReader = function() { assert_unreached("streams should not use this ReadableStream.getReader method"); };
         new ReadableStream().tee();
     } finally {
         ReadableStream.prototype.getReader = ReadableStreamGetReaderBackup;
     }
 }, 'Streams should not directly use ReadableStream public APIs');

 promise_test(function() {
     const ReadableStreamDefaultReader = new ReadableStream().getReader().constructor;
     const ReadableStreamDefaultReaderReadBackup = ReadableStreamDefaultReader.prototype.read;

     function cleanTest() {
         ReadableStreamDefaultReader.prototype.read = ReadableStreamDefaultReaderReadBackup;
     }

     try {
         ReadableStreamDefaultReader.prototype.read = function() { assert_unreached("streams should not use this ReadableStreamDefaultReader.read method"); };

         [s1, s2] = new ReadableStream({
             start: function(controller) {
                 controller.close();
             }
         }).tee();
         return s1.getReader().closed.then(cleanTest, cleanTest);

     } catch (error) {
         cleanTest();
         assert_unreached("test should not throw");
     }
 }, 'Streams should not directly use ReadableStreamDefaultReader read public API');
 </script>
	<!DOCTYPE html>
	<script src='../resources/testharness.js'></script>
	<script src='../resources/testharnessreport.js'></script>
	<script>
	test(function() {
	const PromiseBackup = Promise;

	try {
	Promise = function() { assert_unreached("streams should not use this Promise object"); };

	new ReadableStream();
	new WritableStream();
	} finally {
	Promise = PromiseBackup;
	}
	}, 'Streams and promises: replace Promise constructor');

	test(function() {
	const PromiseResolveBackup = Promise.resolve;

	try {
	Promise.resolve = function() { assert_unreached("streams should not use this Promise.resolve method"); };

	new ReadableStream();
	new WritableStream();
	} finally {
	Promise.resolve = PromiseResolveBackup;
	}
	}, 'Streams and promises: replace Promise.resolve');

	test(function() {
	const PromiseRejectBackup = Promise.reject;

	function handle() { }

	try {
	Promise.reject = function() { assert_unreached("streams should not use this Promise.reject method"); };

	ReadableStream.prototype.cancel.call({}, "reason").then(handle, handle);
	WritableStream.prototype.abort.call({}, "reason").then(handle, handle);
	} finally {
	Promise.reject = PromiseRejectBackup;
	}
	}, 'Streams and promises: replace Promise.reject');

	test(function() {
	function createMangledPromise() {
	const promise = Promise.resolve();
	Object.setPrototypeOf(promise, { constructor: Promise, then: function() { assert_unreached("streams should not use this promise then method"); } });
	return promise;
	}
	new ReadableStream({ start: function() { return createMangledPromise(); } })
	new WritableStream({ start: function() { return createMangledPromise(); } })
	}, 'Streams and promises: replace prototype of a promise object');

	test(function() {
	const PromiseThenBackup = Promise.prototype.then;

	try {
	Promise.prototype.then = function() { assert_unreached("streams should not use this Promise.prototype.then method"); };

	new ReadableStream();
	new WritableStream();
	} finally {
	Promise.prototype.then = PromiseThenBackup;
	}
	}, 'Streams and promises: replace then method in Promise prototype');

	test(function() {
	const PromiseCatchBackup = Promise.prototype.catch;
	const PromiseThenBackup = Promise.prototype.then;

	try {
	Promise.prototype.catch = function() { assert_unreached("streams should not use this Promise.prototype.catch method"); };
	Promise.prototype.then = function() { assert_unreached("streams should not use this Promise.prototype.catch method"); };

	const rs = new ReadableStream();
	rs.tee();
	} finally {
	Promise.prototype.catch = PromiseCatchBackup;
	Promise.prototype.then = PromiseThenBackup;
	}
	}, 'Streams and promises: replace catch method in Promise prototype');

	test(function() {
	function createMangledPromise() {
	const promise = Promise.resolve();
	promise.then = function() { assert_unreached("streams should not use this promise then method"); };
	return promise;
	}
	new ReadableStream({ start: function() { return createMangledPromise(); } })
	new WritableStream({ start: function() { return createMangledPromise(); } })
	}, 'Streams and promises: replace then method in promise object');

	test(function() {
	const NumberBackup = Number;
	const NumberIsNaNBackup = Number.isNaN;
	const NumberIsFiniteBackup = Number.isFinite;

	try {
	Number.isNaN = function() { assert_unreached("streams should not use this Number.isNaN method"); };
	Number.isFinite = function() { assert_unreached("streams should not use this Number.isFinite method"); };
	Number = null;

	new ReadableStream({
	start: function(controller) {
	controller.enqueue("small potato");
	}
	}, {
	size: function(chunk) { return 2; },
	highWaterMark: 1
	});

	} finally {
	Number = NumberBackup;
	Number.isNaN = NumberIsNaNBackup;
	Number.isFinite = NumberIsFiniteBackup;
	}
	}, 'Streams should not directly use Number and related methods');
	test(function() {
	const ReadableStreamGetReaderBackup = ReadableStream.prototype.getReader;

	try {
	ReadableStream.prototype.getReader = function() { assert_unreached("streams should not use this ReadableStream.getReader method"); };
	new ReadableStream().tee();
	} finally {
	ReadableStream.prototype.getReader = ReadableStreamGetReaderBackup;
	}
	}, 'Streams should not directly use ReadableStream public APIs');

	promise_test(function() {
	const ReadableStreamDefaultReader = new ReadableStream().getReader().constructor;
	const ReadableStreamDefaultReaderReadBackup = ReadableStreamDefaultReader.prototype.read;

	function cleanTest() {
	ReadableStreamDefaultReader.prototype.read = ReadableStreamDefaultReaderReadBackup;
	}

	try {
	ReadableStreamDefaultReader.prototype.read = function() { assert_unreached("streams should not use this ReadableStreamDefaultReader.read method"); };

	[s1, s2] = new ReadableStream({
	start: function(controller) {
	controller.close();
	}
	}).tee();
	return s1.getReader().closed.then(cleanTest, cleanTest);

	} catch (error) {
	cleanTest();
	assert_unreached("test should not throw");
	}
	}, 'Streams should not directly use ReadableStreamDefaultReader read public API');
	</script>