queuing-strategies.any.js

Enable keyboard shortcuts

// META: global=window,worker,shadowrealm

'use strict';

const highWaterMarkConversions = new Map([

  [-Infinity, -Infinity],

  [-5, -5],

  [false, 0],

  [true, 1],

  [NaN, NaN],

  ['foo', NaN],

  ['0', 0],

  [{}, NaN],

  [() => {}, NaN]

]);

for (const QueuingStrategy of [CountQueuingStrategy, ByteLengthQueuingStrategy]) {

  test(() => {

    new QueuingStrategy({ highWaterMark: 4 });

  }, `${QueuingStrategy.name}: Can construct a with a valid 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_js(TypeError, () => new QueuingStrategy(), 'construction fails with undefined');

    assert_throws_js(TypeError, () => new QueuingStrategy(null), 'construction fails with null');

    assert_throws_js(TypeError, () => new QueuingStrategy(true), 'construction fails with true');

    assert_throws_js(TypeError, () => new QueuingStrategy(5), 'construction fails with 5');

    assert_throws_js(TypeError, () => new QueuingStrategy({}), 'construction fails with {}');

    assert_throws_exactly(error, () => new QueuingStrategy(highWaterMarkObjectGetterThrowing),

      'construction fails with an object with a throwing highWaterMark getter');

    assert_equals((new QueuingStrategy(highWaterMarkObjectGetter)).highWaterMark, highWaterMark);

  }, `${QueuingStrategy.name}: Constructor behaves as expected with strange arguments`);

  test(() => {

    for (const [input, output] of highWaterMarkConversions.entries()) {

      const strategy = new QueuingStrategy({ highWaterMark: input });

      assert_equals(strategy.highWaterMark, output, `${input} gets set correctly`);

  }, `${QueuingStrategy.name}: highWaterMark constructor values are converted per the unrestricted double rules`);

  test(() => {

    const size1 = (new QueuingStrategy({ highWaterMark: 5 })).size;

    const size2 = (new QueuingStrategy({ highWaterMark: 10 })).size;

    assert_equals(size1, size2);

  }, `${QueuingStrategy.name}: size is the same function across all instances`);

  test(() => {

    const size = (new QueuingStrategy({ highWaterMark: 5 })).size;

    assert_equals(size.name, 'size');

  }, `${QueuingStrategy.name}: size should have the right name`);

  test(() => {

    class SubClass extends QueuingStrategy {

      size() {

        return 2;

      subClassMethod() {

        return true;

    const sc = new SubClass({ highWaterMark: 77 });

    assert_equals(sc.constructor.name, 'SubClass', 'constructor.name should be correct');

    assert_equals(sc.highWaterMark, 77, 'highWaterMark should come from the parent class');

    assert_equals(sc.size(), 2, 'size() on the subclass should override the parent');

    assert_true(sc.subClassMethod(), 'subClassMethod() should work');

  }, `${QueuingStrategy.name}: subclassing should work correctly`);

  test(() => {

    const size = new QueuingStrategy({ highWaterMark: 5 }).size;

    assert_false('prototype' in size);

  }, `${QueuingStrategy.name}: size should not have a prototype property`);

test(() => {

  const size = new CountQueuingStrategy({ highWaterMark: 5 }).size;

  assert_throws_js(TypeError, () => new size());

}, `CountQueuingStrategy: size should not be a constructor`);

test(() => {

  const size = new ByteLengthQueuingStrategy({ highWaterMark: 5 }).size;

  assert_throws_js(TypeError, () => new size({ byteLength: 1024 }));

}, `ByteLengthQueuingStrategy: size should not be a constructor`);

test(() => {

  const size = (new CountQueuingStrategy({ highWaterMark: 5 })).size;

  assert_equals(size.length, 0);

}, 'CountQueuingStrategy: size should have the right length');

test(() => {

  const size = (new ByteLengthQueuingStrategy({ highWaterMark: 5 })).size;

  assert_equals(size.length, 1);

}, 'ByteLengthQueuingStrategy: size should have the right length');

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; }

};

  const sizeFunction = (new CountQueuingStrategy({ highWaterMark: 5 })).size;

  assert_equals(sizeFunction(), 1, 'size returns 1 with undefined');

  assert_equals(sizeFunction(null), 1, 'size returns 1 with null');

  assert_equals(sizeFunction('potato'), 1, 'size returns 1 with non-object type');

  assert_equals(sizeFunction({}), 1, 'size returns 1 with empty object');

  assert_equals(sizeFunction(chunk), 1, 'size returns 1 with a chunk');

  assert_equals(sizeFunction(chunkGetter), 1, 'size returns 1 with chunk getter');

  assert_equals(sizeFunction(chunkGetterThrowing), 1,

    'size returns 1 with chunk getter that throws');

}, 'CountQueuingStrategy: size 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; }

};

  const sizeFunction = (new ByteLengthQueuingStrategy({ highWaterMark: 5 })).size;

  assert_throws_js(TypeError, () => sizeFunction(), 'size fails with undefined');

  assert_throws_js(TypeError, () => sizeFunction(null), 'size fails with null');

  assert_equals(sizeFunction('potato'), undefined, 'size succeeds with undefined with a random non-object type');

  assert_equals(sizeFunction({}), undefined, 'size succeeds with undefined with an object without hwm property');

  assert_equals(sizeFunction(chunk), size, 'size succeeds with the right amount with an object with a hwm');

  assert_equals(sizeFunction(chunkGetter), size,

    'size succeeds with the right amount with an object with a hwm getter');

  assert_throws_exactly(error, () => sizeFunction(chunkGetterThrowing),

    'size fails with the error thrown by the getter');

}, 'ByteLengthQueuingStrategy: size behaves as expected with strange arguments');