Implement ByteLengthQueuingStrategy

third_party/WebKit/LayoutTests/http/tests/streams/byte-length-queuing-strategy.js

Index: third_party/WebKit/LayoutTests/http/tests/streams/byte-length-queuing-strategy.js
diff --git a/third_party/WebKit/LayoutTests/http/tests/streams/byte-length-queuing-strategy.js b/third_party/WebKit/LayoutTests/http/tests/streams/byte-length-queuing-strategy.js
new file mode 100644
index 0000000000000000000000000000000000000000..539a922201d5c00907b6d03e9f546508985ac087
--- /dev/null
+++ b/third_party/WebKit/LayoutTests/http/tests/streams/byte-length-queuing-strategy.js
@@ -0,0 +1,82 @@
+'use strict';
+
+if (self.importScripts) {
+  self.importScripts('/resources/testharness.js');
+}
+
+test(() => {
+
+  const strategy = new ByteLengthQueuingStrategy({ highWaterMark: 4 });
+
+}, 'Can construct a ByteLengthQueuingStrategy with a valid high water mark');
+
+test(() => {
+
+  for (const 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 wrong arguments');

[tyoshino (SeeGerritForStatus), 2015/10/02 11:33:28]

nitpick: is the first test case considered to be using a wrong argument?

[domenic, 2015/10/02 22:32:14]

Yeah. (The wrong argument is undefined.)

[tyoshino (SeeGerritForStatus), 2015/10/05 07:55:45]

Ahh, sorry. By "first case", I meant highWaterMarkObjectGetter. I was looking at
L24-L27 and said "first". It was confusing.

So, my question was "new ByteLengthQueuingStrategy(highWaterMarkObjectGetter);"
is considered to be using a wrong argument?"

Any way, it's not a big deal.

+

[yhirano, 2015/10/02 07:27:16]

It would be good to have a test checking that "highwaterMark" value is settable
after construction.

[domenic, 2015/10/02 22:32:14]

Added. Kind of redundant with the property descriptor check but might as well
have it.

+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 wrong 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');
+
+done();