ikan Uploader :
Directory : /proc/self/root/home/ubuntu/node-v16.18.1/test/fixtures/wpt/streams/
Upload File : |
| Current File : //proc/self/root/home/ubuntu/node-v16.18.1/test/fixtures/wpt/streams/queuing-strategies.any.js |
// META: global=window,worker,jsshell
'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 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');
Kontol Shell Bypass