Import and uplift streams spec wpt tests.

Upstreamed from https://bugzilla.mozilla.org/show_bug.cgi?id=1230148
web-platform-tests · Jan 18, 2016 · 4541fb6 · 4541fb6
1 parent eb08ad5
commit 4541fb6
Show file tree

Hide file tree

Showing 30 changed files with 4,311 additions and 0 deletions.
diff --git a/streams/byte-length-queuing-strategy.https.html b/streams/byte-length-queuing-strategy.https.html
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/service-workers/service-workers/resources/test-helpers.js"></script>
+<script src="resources/test-initializer.js"></script>
+
+<script src="byte-length-queuing-strategy.js"></script>
+<script>
+'use strict';
+worker_test('byte-length-queuing-strategy.js');
+</script>
diff --git a/streams/byte-length-queuing-strategy.js b/streams/byte-length-queuing-strategy.js
@@ -0,0 +1,107 @@
+'use strict';
+
+if (self.importScripts) {
+  self.importScripts('/resources/testharness.js');
+}
+
+test(() => {
+
+  new ByteLengthQueuingStrategy({ highWaterMark: 4 });
+
+}, 'Can construct a ByteLengthQueuingStrategy with a valid high water mark');
+
+test(() => {
+
+  for (let highWaterMark of [-Infinity, NaN, 'foo', {}, () => {}]) {
+    const strategy = new ByteLengthQueuingStrategy({ highWaterMark });
+    assert_equals(strategy.highWaterMark, highWaterMark, `${highWaterMark} gets set correctly`);
+  }
+
+}, 'Can construct a ByteLengthQueuingStrategy with any value as its high water mark');
+
+test(() => {
+
+  const highWaterMark = 1;
+  const highWaterMarkObjectGetter = {
+    get highWaterMark() { return highWaterMark; }
+  };
+  const error = new Error('wow!');
+  const highWaterMarkObjectGetterThrowing = {
+    get highWaterMark() { throw error; }
+  };
+
+  assert_throws({ name: 'TypeError' }, () => new ByteLengthQueuingStrategy(), 'construction fails with undefined');
+  assert_throws({ name: 'TypeError' }, () => new ByteLengthQueuingStrategy(null), 'construction fails with null');
+  assert_throws({ name: 'Error' }, () => new ByteLengthQueuingStrategy(highWaterMarkObjectGetterThrowing),
+    'construction fails with an object with a throwing highWaterMark getter');
+
+  // Should not fail:
+  new ByteLengthQueuingStrategy('potato');
+  new ByteLengthQueuingStrategy({});
+  new ByteLengthQueuingStrategy(highWaterMarkObjectGetter);
+
+}, 'ByteLengthQueuingStrategy constructor behaves as expected with strange arguments');
+
+test(() => {
+
+  const size = 1024;
+  const chunk = { byteLength: size };
+  const chunkGetter = {
+    get byteLength() { return size; }
+  };
+  const error = new Error('wow!');
+  const chunkGetterThrowing = {
+    get byteLength() { throw error; }
+  };
+  assert_throws({ name: 'TypeError' }, () => ByteLengthQueuingStrategy.prototype.size(), 'size fails with undefined');
+  assert_throws({ name: 'TypeError' }, () => ByteLengthQueuingStrategy.prototype.size(null), 'size fails with null');
+  assert_equals(ByteLengthQueuingStrategy.prototype.size('potato'), undefined,
+    'size succeeds with undefined with a random non-object type');
+  assert_equals(ByteLengthQueuingStrategy.prototype.size({}), undefined,
+    'size succeeds with undefined with an object without hwm property');
+  assert_equals(ByteLengthQueuingStrategy.prototype.size(chunk), size,
+    'size succeeds with the right amount with an object with a hwm');
+  assert_equals(ByteLengthQueuingStrategy.prototype.size(chunkGetter), size,
+    'size succeeds with the right amount with an object with a hwm getter');
+  assert_throws({ name: 'Error' }, () => ByteLengthQueuingStrategy.prototype.size(chunkGetterThrowing),
+    'size fails with the error thrown by the getter');
+
+}, 'ByteLengthQueuingStrategy size behaves as expected with strange arguments');
+
+test(() => {
+
+  const thisValue = null;
+  const returnValue = { 'returned from': 'byteLength getter' };
+  const chunk = {
+    get byteLength() { return returnValue; }
+  };
+
+  assert_equals(ByteLengthQueuingStrategy.prototype.size.call(thisValue, chunk), returnValue);
+
+}, 'ByteLengthQueuingStrategy.prototype.size should work generically on its this and its arguments');
+
+test(() => {
+
+  const strategy = new ByteLengthQueuingStrategy({ highWaterMark: 4 });
+
+  assert_object_equals(Object.getOwnPropertyDescriptor(strategy, 'highWaterMark'),
+    { value: 4, writable: true, enumerable: true, configurable: true },
+    'highWaterMark property should be a data property with the value passed the constructor');
+  assert_equals(typeof strategy.size, 'function');
+
+}, 'ByteLengthQueuingStrategy instances have the correct properties');
+
+test(() => {
+
+  const strategy = new ByteLengthQueuingStrategy({ highWaterMark: 4 });
+  assert_equals(strategy.highWaterMark, 4);
+
+  strategy.highWaterMark = 10;
+  assert_equals(strategy.highWaterMark, 10);
+
+  strategy.highWaterMark = 'banana';
+  assert_equals(strategy.highWaterMark, 'banana');
+
+}, 'ByteLengthQueuingStrategy\'s highWaterMark property can be set to anything');
+
+done();
diff --git a/streams/count-queuing-strategy.https.html b/streams/count-queuing-strategy.https.html
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/service-workers/service-workers/resources/test-helpers.js"></script>
+<script src="resources/test-initializer.js"></script>
+
+<script src="count-queuing-strategy.js"></script>
+<script>
+'use strict';
+worker_test('count-queuing-strategy.js');
+</script>
diff --git a/streams/count-queuing-strategy.js b/streams/count-queuing-strategy.js
@@ -0,0 +1,106 @@
+'use strict';
+
+if (self.importScripts) {
+  self.importScripts('/resources/testharness.js');
+}
+
+test(() => {
+
+  new CountQueuingStrategy({ highWaterMark: 4 });
+
+}, 'Can construct a CountQueuingStrategy with a valid high water mark');
+
+test(() => {
+
+  for (let highWaterMark of [-Infinity, NaN, 'foo', {}, () => {}]) {
+    const strategy = new CountQueuingStrategy({ highWaterMark });
+    assert_equals(strategy.highWaterMark, highWaterMark, `${highWaterMark} gets set correctly`);
+  }
+
+}, 'Can construct a CountQueuingStrategy with any value as its high water mark');
+
+test(() => {
+
+  const highWaterMark = 1;
+  const highWaterMarkObjectGetter = {
+    get highWaterMark() { return highWaterMark; }
+  };
+  const error = new Error('wow!');
+  const highWaterMarkObjectGetterThrowing = {
+    get highWaterMark() { throw error; }
+  };
+
+  assert_throws({ name: 'TypeError' }, () => new CountQueuingStrategy(), 'construction fails with undefined');
+  assert_throws({ name: 'TypeError' }, () => new CountQueuingStrategy(null), 'construction fails with null');
+  assert_throws({ name: 'Error' }, () => new CountQueuingStrategy(highWaterMarkObjectGetterThrowing),
+    'construction fails with an object with a throwing highWaterMark getter');
+
+  // Should not fail:
+  new CountQueuingStrategy('potato');
+  new CountQueuingStrategy({});
+  new CountQueuingStrategy(highWaterMarkObjectGetter);
+
+}, 'CountQueuingStrategy constructor behaves as expected with strange arguments');
+
+
+test(() => {
+
+  const thisValue = null;
+  const chunk = {
+    get byteLength() {
+      throw new TypeError('shouldn\'t be called');
+    }
+  };
+
+  assert_equals(CountQueuingStrategy.prototype.size.call(thisValue, chunk), 1);
+
+}, 'CountQueuingStrategy.prototype.size should work generically on its this and its arguments');
+
+test(() => {
+
+  const size = 1024;
+  const chunk = { byteLength: size };
+  const chunkGetter = {
+    get byteLength() { return size; }
+  };
+  const error = new Error('wow!');
+  const chunkGetterThrowing = {
+    get byteLength() { throw error; }
+  };
+
+  assert_equals(CountQueuingStrategy.prototype.size(), 1, 'size returns 1 with undefined');
+  assert_equals(CountQueuingStrategy.prototype.size(null), 1, 'size returns 1 with null');
+  assert_equals(CountQueuingStrategy.prototype.size('potato'), 1, 'size returns 1 with non-object type');
+  assert_equals(CountQueuingStrategy.prototype.size({}), 1, 'size returns 1 with empty object');
+  assert_equals(CountQueuingStrategy.prototype.size(chunk), 1, 'size returns 1 with a chunk');
+  assert_equals(CountQueuingStrategy.prototype.size(chunkGetter), 1, 'size returns 1 with chunk getter');
+  assert_equals(CountQueuingStrategy.prototype.size(chunkGetterThrowing), 1,
+    'size returns 1 with chunk getter that throws');
+
+}, 'CountQueuingStrategy size behaves as expected with strange arguments');
+
+test(() => {
+
+  const strategy = new CountQueuingStrategy({ highWaterMark: 4 });
+
+  assert_object_equals(Object.getOwnPropertyDescriptor(strategy, 'highWaterMark'),
+    { value: 4, writable: true, enumerable: true, configurable: true },
+    'highWaterMark property should be a data property with the value passed the constructor');
+  assert_equals(typeof strategy.size, 'function');
+
+}, 'CountQueuingStrategy instances have the correct properties');
+
+test(() => {
+
+  const strategy = new CountQueuingStrategy({ highWaterMark: 4 });
+  assert_equals(strategy.highWaterMark, 4);
+
+  strategy.highWaterMark = 10;
+  assert_equals(strategy.highWaterMark, 10);
+
+  strategy.highWaterMark = 'banana';
+  assert_equals(strategy.highWaterMark, 'banana');
+
+}, 'CountQueuingStrategy\'s highWaterMark property can be set to anything');
+
+done();
diff --git a/streams/readable-streams/bad-strategies.https.html b/streams/readable-streams/bad-strategies.https.html
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/service-workers/service-workers/resources/test-helpers.js"></script>
+<script src="../resources/test-initializer.js"></script>
+
+<script src="bad-strategies.js"></script>
+<script>
+'use strict';
+worker_test('bad-strategies.js');
+</script>