Dante/Kmake
1
0
Fork 0
forked from LeenkxTeam/Kmake
Code Pull Requests Activity

Upload Kmake

Browse Source
This commit is contained in:
Gorochu
2026-05-26 23:36:42 -07:00
parent ba051b2f74
commit 555ec72358
41615 changed files with 13344630 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
test/fixtures/wpt/FileAPI/blob/Blob-array-buffer.any.js vendored Normal file
View File

@ -0,0 +1,45 @@
// META: title=Blob Array Buffer
// META: script=../support/Blob.js
'use strict';
promise_test(async () => {
const input_arr = new TextEncoder().encode("PASS");
const blob = new Blob([input_arr]);
const array_buffer = await blob.arrayBuffer();
assert_true(array_buffer instanceof ArrayBuffer);
assert_equals_typed_array(new Uint8Array(array_buffer), input_arr);
}, "Blob.arrayBuffer()")
promise_test(async () => {
const input_arr = new TextEncoder().encode("");
const blob = new Blob([input_arr]);
const array_buffer = await blob.arrayBuffer();
assert_true(array_buffer instanceof ArrayBuffer);
assert_equals_typed_array(new Uint8Array(array_buffer), input_arr);
}, "Blob.arrayBuffer() empty Blob data")
promise_test(async () => {
const input_arr = new TextEncoder().encode("\u08B8\u000a");
const blob = new Blob([input_arr]);
const array_buffer = await blob.arrayBuffer();
assert_equals_typed_array(new Uint8Array(array_buffer), input_arr);
}, "Blob.arrayBuffer() non-ascii input")
promise_test(async () => {
const input_arr = [8, 241, 48, 123, 151];
const typed_arr = new Uint8Array(input_arr);
const blob = new Blob([typed_arr]);
const array_buffer = await blob.arrayBuffer();
assert_equals_typed_array(new Uint8Array(array_buffer), typed_arr);
}, "Blob.arrayBuffer() non-unicode input")
promise_test(async () => {
const input_arr = new TextEncoder().encode("PASS");
const blob = new Blob([input_arr]);
const array_buffer_results = await Promise.all([blob.arrayBuffer(),
blob.arrayBuffer(), blob.arrayBuffer()]);
for (let array_buffer of array_buffer_results) {
assert_true(array_buffer instanceof ArrayBuffer);
assert_equals_typed_array(new Uint8Array(array_buffer), input_arr);
}
}, "Blob.arrayBuffer() concurrent reads")

45
test/fixtures/wpt/FileAPI/blob/Blob-bytes.any.js vendored Normal file
View File

@ -0,0 +1,45 @@
// META: title=Blob bytes()
// META: script=../support/Blob.js
'use strict';
promise_test(async () => {
const input_arr = new TextEncoder().encode("PASS");
const blob = new Blob([input_arr]);
const uint8array = await blob.bytes();
assert_true(uint8array instanceof Uint8Array);
assert_equals_typed_array(uint8array, input_arr);
}, "Blob.bytes()")
promise_test(async () => {
const input_arr = new TextEncoder().encode("");
const blob = new Blob([input_arr]);
const uint8array = await blob.bytes();
assert_true(uint8array instanceof Uint8Array);
assert_equals_typed_array(uint8array, input_arr);
}, "Blob.bytes() empty Blob data")
promise_test(async () => {
const input_arr = new TextEncoder().encode("\u08B8\u000a");
const blob = new Blob([input_arr]);
const uint8array = await blob.bytes();
assert_equals_typed_array(uint8array, input_arr);
}, "Blob.bytes() non-ascii input")
promise_test(async () => {
const input_arr = [8, 241, 48, 123, 151];
const typed_arr = new Uint8Array(input_arr);
const blob = new Blob([typed_arr]);
const uint8array = await blob.bytes();
assert_equals_typed_array(uint8array, typed_arr);
}, "Blob.bytes() non-unicode input")
promise_test(async () => {
const input_arr = new TextEncoder().encode("PASS");
const blob = new Blob([input_arr]);
const uint8array_results = await Promise.all([blob.bytes(),
blob.bytes(), blob.bytes()]);
for (let uint8array of uint8array_results) {
assert_true(uint8array instanceof Uint8Array);
assert_equals_typed_array(uint8array, input_arr);
}
}, "Blob.bytes() concurrent reads")

53
test/fixtures/wpt/FileAPI/blob/Blob-constructor-dom.window.js vendored Normal file
View File

@ -0,0 +1,53 @@
// META: title=Blob constructor
// META: script=../support/Blob.js
'use strict';
var test_error = {
name: "test",
message: "test error",
};
test(function() {
var args = [
document.createElement("div"),
window,
];
args.forEach(function(arg) {
assert_throws_js(TypeError, function() {
new Blob(arg);
}, "Should throw for argument " + format_value(arg) + ".");
});
}, "Passing platform objects for blobParts should throw a TypeError.");
test(function() {
var element = document.createElement("div");
element.appendChild(document.createElement("div"));
element.appendChild(document.createElement("p"));
var list = element.children;
Object.defineProperty(list, "length", {
get: function() { throw test_error; }
});
assert_throws_exactly(test_error, function() {
new Blob(list);
});
}, "A platform object that supports indexed properties should be treated as a sequence for the blobParts argument (overwritten 'length'.)");
test_blob(function() {
var select = document.createElement("select");
select.appendChild(document.createElement("option"));
return new Blob(select);
}, {
expected: "[object HTMLOptionElement]",
type: "",
desc: "Passing an platform object that supports indexed properties as the blobParts array should work (select)."
});
test_blob(function() {
var elm = document.createElement("div");
elm.setAttribute("foo", "bar");
return new Blob(elm.attributes);
}, {
expected: "[object Attr]",
type: "",
desc: "Passing an platform object that supports indexed properties as the blobParts array should work (attributes)."
});

104
test/fixtures/wpt/FileAPI/blob/Blob-constructor-endings.html vendored Normal file
View File

@ -0,0 +1,104 @@
<!DOCTYPE html>
<meta charset=utf-8>
<title>Blob constructor: endings option</title>
<link rel=help href="https://w3c.github.io/FileAPI/#constructorBlob">
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script>
// Windows platforms use CRLF as the native line ending. All others use LF.
const crlf = navigator.platform.startsWith('Win');
const native_ending = crlf ? '\r\n' : '\n';
function readBlobAsPromise(blob) {
return new Promise((resolve, reject) => {
const reader = new FileReader();
reader.readAsText(blob);
reader.onload = e => resolve(reader.result);
reader.onerror = e => reject(reader.error);
});
}
[
'transparent',
'native'
].forEach(value => test(t => {
assert_class_string(new Blob([], {endings: value}), 'Blob',
`Constructor should allow "${value}" endings`);
}, `Valid "endings" value: ${JSON.stringify(value)}`));
[
null,
'',
'invalidEnumValue',
'Transparent',
'NATIVE',
0,
{}
].forEach(value => test(t => {
assert_throws_js(TypeError, () => new Blob([], {endings: value}),
'Blob constructor should throw');
}, `Invalid "endings" value: ${JSON.stringify(value)}`));
test(t => {
const test_error = {name: 'test'};
assert_throws_exactly(
test_error,
() => new Blob([], { get endings() { throw test_error; }}),
'Blob constructor should propagate exceptions from "endings" property');
}, 'Exception propagation from options');
test(t => {
let got = false;
new Blob([], { get endings() { got = true; } });
assert_true(got, 'The "endings" property was accessed during construction.');
}, 'The "endings" options property is used');
[
{name: 'LF', input: '\n', native: native_ending},
{name: 'CR', input: '\r', native: native_ending},
{name: 'CRLF', input: '\r\n', native: native_ending},
{name: 'CRCR', input: '\r\r', native: native_ending.repeat(2)},
{name: 'LFCR', input: '\n\r', native: native_ending.repeat(2)},
{name: 'LFLF', input: '\n\n', native: native_ending.repeat(2)},
{name: 'CRCRLF', input: '\r\r\n', native: native_ending.repeat(2)},
{name: 'CRLFLF', input: '\r\n\n', native: native_ending.repeat(2)},
{name: 'CRLFCR', input: '\r\n\r\n', native: native_ending.repeat(2)},
{name: 'CRLFCRLF', input: '\r\n\r\n', native: native_ending.repeat(2)},
{name: 'LFCRLFCR', input: '\n\r\n\r', native: native_ending.repeat(3)},
].forEach(testCase => {
promise_test(async t => {
const blob = new Blob([testCase.input]);
assert_equals(
await readBlobAsPromise(blob), testCase.input,
'Newlines should not change with endings unspecified');
}, `Input ${testCase.name} with endings unspecified`);
promise_test(async t => {
const blob = new Blob([testCase.input], {endings: 'transparent'});
assert_equals(
await readBlobAsPromise(blob), testCase.input,
'Newlines should not change with endings "transparent"');
}, `Input ${testCase.name} with endings 'transparent'`);
promise_test(async t => {
const blob = new Blob([testCase.input], {endings: 'native'});
assert_equals(
await readBlobAsPromise(blob), testCase.native,
'Newlines should match the platform with endings "native"');
}, `Input ${testCase.name} with endings 'native'`);
});
promise_test(async t => {
const blob = new Blob(['\r', '\n'], {endings: 'native'});
const expected = native_ending.repeat(2);
assert_equals(
await readBlobAsPromise(blob), expected,
'CR/LF in adjacent strings should be converted to two platform newlines');
}, `CR/LF in adjacent input strings`);
</script>

469
test/fixtures/wpt/FileAPI/blob/Blob-constructor.any.js vendored Normal file
View File

@ -0,0 +1,469 @@
// META: title=Blob constructor
// META: script=../support/Blob.js
'use strict';
test(function() {
assert_true("Blob" in globalThis, "globalThis should have a Blob property.");
assert_equals(Blob.length, 0, "Blob.length should be 0.");
assert_true(Blob instanceof Function, "Blob should be a function.");
}, "Blob interface object");
// Step 1.
test(function() {
var blob = new Blob();
assert_true(blob instanceof Blob);
assert_equals(String(blob), '[object Blob]');
assert_equals(blob.size, 0);
assert_equals(blob.type, "");
}, "Blob constructor with no arguments");
test(function() {
assert_throws_js(TypeError, function() { var blob = Blob(); });
}, "Blob constructor with no arguments, without 'new'");
test(function() {
var blob = new Blob;
assert_true(blob instanceof Blob);
assert_equals(blob.size, 0);
assert_equals(blob.type, "");
}, "Blob constructor without brackets");
test(function() {
var blob = new Blob(undefined);
assert_true(blob instanceof Blob);
assert_equals(String(blob), '[object Blob]');
assert_equals(blob.size, 0);
assert_equals(blob.type, "");
}, "Blob constructor with undefined as first argument");
// blobParts argument (WebIDL).
test(function() {
var args = [
null,
true,
false,
0,
1,
1.5,
"FAIL",
new Date(),
new RegExp(),
{},
{ 0: "FAIL", length: 1 },
];
args.forEach(function(arg) {
assert_throws_js(TypeError, function() {
new Blob(arg);
}, "Should throw for argument " + format_value(arg) + ".");
});
}, "Passing non-objects, Dates and RegExps for blobParts should throw a TypeError.");
test_blob(function() {
return new Blob({
[Symbol.iterator]: Array.prototype[Symbol.iterator],
});
}, {
expected: "",
type: "",
desc: "A plain object with @@iterator should be treated as a sequence for the blobParts argument."
});
test(t => {
const blob = new Blob({
[Symbol.iterator]() {
var i = 0;
return {next: () => [
{done:false, value:'ab'},
{done:false, value:'cde'},
{done:true}
][i++]
};
}
});
assert_equals(blob.size, 5, 'Custom @@iterator should be treated as a sequence');
}, "A plain object with custom @@iterator should be treated as a sequence for the blobParts argument.");
test_blob(function() {
return new Blob({
[Symbol.iterator]: Array.prototype[Symbol.iterator],
0: "PASS",
length: 1
});
}, {
expected: "PASS",
type: "",
desc: "A plain object with @@iterator and a length property should be treated as a sequence for the blobParts argument."
});
test_blob(function() {
return new Blob(new String("xyz"));
}, {
expected: "xyz",
type: "",
desc: "A String object should be treated as a sequence for the blobParts argument."
});
test_blob(function() {
return new Blob(new Uint8Array([1, 2, 3]));
}, {
expected: "123",
type: "",
desc: "A Uint8Array object should be treated as a sequence for the blobParts argument."
});
var test_error = {
name: "test",
message: "test error",
};
test(function() {
var obj = {
[Symbol.iterator]: Array.prototype[Symbol.iterator],
get length() { throw test_error; }
};
assert_throws_exactly(test_error, function() {
new Blob(obj);
});
}, "The length getter should be invoked and any exceptions should be propagated.");
test(function() {
assert_throws_exactly(test_error, function() {
var obj = {
[Symbol.iterator]: Array.prototype[Symbol.iterator],
length: {
valueOf: null,
toString: function() { throw test_error; }
}
};
new Blob(obj);
});
assert_throws_exactly(test_error, function() {
var obj = {
[Symbol.iterator]: Array.prototype[Symbol.iterator],
length: { valueOf: function() { throw test_error; } }
};
new Blob(obj);
});
}, "ToUint32 should be applied to the length and any exceptions should be propagated.");
test(function() {
var received = [];
var obj = {
get [Symbol.iterator]() {
received.push("Symbol.iterator");
return Array.prototype[Symbol.iterator];
},
get length() {
received.push("length getter");
return {
valueOf: function() {
received.push("length valueOf");
return 3;
}
};
},
get 0() {
received.push("0 getter");
return {
toString: function() {
received.push("0 toString");
return "a";
}
};
},
get 1() {
received.push("1 getter");
throw test_error;
},
get 2() {
received.push("2 getter");
assert_unreached("Should not call the getter for 2 if the getter for 1 threw.");
}
};
assert_throws_exactly(test_error, function() {
new Blob(obj);
});
assert_array_equals(received, [
"Symbol.iterator",
"length getter",
"length valueOf",
"0 getter",
"0 toString",
"length getter",
"length valueOf",
"1 getter",
]);
}, "Getters and value conversions should happen in order until an exception is thrown.");
// XXX should add tests edge cases of ToLength(length)
test(function() {
assert_throws_exactly(test_error, function() {
new Blob([{ toString: function() { throw test_error; } }]);
}, "Throwing toString");
assert_throws_exactly(test_error, function() {
new Blob([{ toString: undefined, valueOf: function() { throw test_error; } }]);
}, "Throwing valueOf");
assert_throws_exactly(test_error, function() {
new Blob([{
toString: function() { throw test_error; },
valueOf: function() { assert_unreached("Should not call valueOf if toString is present."); }
}]);
}, "Throwing toString and valueOf");
assert_throws_js(TypeError, function() {
new Blob([{toString: null, valueOf: null}]);
}, "Null toString and valueOf");
}, "ToString should be called on elements of the blobParts array and any exceptions should be propagated.");
test_blob(function() {
var arr = [
{ toString: function() { arr.pop(); return "PASS"; } },
{ toString: function() { assert_unreached("Should have removed the second element of the array rather than called toString() on it."); } }
];
return new Blob(arr);
}, {
expected: "PASS",
type: "",
desc: "Changes to the blobParts array should be reflected in the returned Blob (pop)."
});
test_blob(function() {
var arr = [
{
toString: function() {
if (arr.length === 3) {
return "A";
}
arr.unshift({
toString: function() {
assert_unreached("Should only access index 0 once.");
}
});
return "P";
}
},
{
toString: function() {
return "SS";
}
}
];
return new Blob(arr);
}, {
expected: "PASS",
type: "",
desc: "Changes to the blobParts array should be reflected in the returned Blob (unshift)."
});
test_blob(function() {
// https://www.w3.org/Bugs/Public/show_bug.cgi?id=17652
return new Blob([
null,
undefined,
true,
false,
0,
1,
new String("stringobject"),
[],
['x', 'y'],
{},
{ 0: "FAIL", length: 1 },
{ toString: function() { return "stringA"; } },
{ toString: undefined, valueOf: function() { return "stringB"; } },
{ valueOf: function() { assert_unreached("Should not call valueOf if toString is present on the prototype."); } }
]);
}, {
expected: "nullundefinedtruefalse01stringobjectx,y[object Object][object Object]stringAstringB[object Object]",
type: "",
desc: "ToString should be called on elements of the blobParts array."
});
test_blob(function() {
return new Blob([
new ArrayBuffer(8)
]);
}, {
expected: "\0\0\0\0\0\0\0\0",
type: "",
desc: "ArrayBuffer elements of the blobParts array should be supported."
});
test_blob(function() {
return new Blob([
new Uint8Array([0x50, 0x41, 0x53, 0x53]),
new Int8Array([0x50, 0x41, 0x53, 0x53]),
new Uint16Array([0x4150, 0x5353]),
new Int16Array([0x4150, 0x5353]),
new Uint32Array([0x53534150]),
new Int32Array([0x53534150]),
new Float16Array([2.65625, 58.59375]),
new Float32Array([0xD341500000])
]);
}, {
expected: "PASSPASSPASSPASSPASSPASSPASSPASS",
type: "",
desc: "Passing typed arrays as elements of the blobParts array should work."
});
test_blob(function() {
return new Blob([
// 0x535 3415053534150
// 0x535 = 0b010100110101 -> Sign = +, Exponent = 1333 - 1023 = 310
// 0x13415053534150 * 2**(-52)
// ==> 0x13415053534150 * 2**258 = 2510297372767036725005267563121821874921913208671273727396467555337665343087229079989707079680
new Float64Array([2510297372767036725005267563121821874921913208671273727396467555337665343087229079989707079680])
]);
}, {
expected: "PASSPASS",
type: "",
desc: "Passing a Float64Array as element of the blobParts array should work."
});
test_blob(function() {
return new Blob([
new BigInt64Array([BigInt("0x5353415053534150")]),
new BigUint64Array([BigInt("0x5353415053534150")])
]);
}, {
expected: "PASSPASSPASSPASS",
type: "",
desc: "Passing BigInt typed arrays as elements of the blobParts array should work."
});
var t_ports = async_test("Passing a FrozenArray as the blobParts array should work (FrozenArray<MessagePort>).");
t_ports.step(function() {
var channel = new MessageChannel();
channel.port2.onmessage = this.step_func(function(e) {
var b_ports = new Blob(e.ports);
assert_equals(b_ports.size, "[object MessagePort]".length);
this.done();
});
var channel2 = new MessageChannel();
channel.port1.postMessage('', [channel2.port1]);
});
test_blob(function() {
var blob = new Blob(['foo']);
return new Blob([blob, blob]);
}, {
expected: "foofoo",
type: "",
desc: "Array with two blobs"
});
test_blob_binary(function() {
var view = new Uint8Array([0, 255, 0]);
return new Blob([view.buffer, view.buffer]);
}, {
expected: [0, 255, 0, 0, 255, 0],
type: "",
desc: "Array with two buffers"
});
test_blob_binary(function() {
var view = new Uint8Array([0, 255, 0, 4]);
var blob = new Blob([view, view]);
assert_equals(blob.size, 8);
var view1 = new Uint16Array(view.buffer, 2);
return new Blob([view1, view.buffer, view1]);
}, {
expected: [0, 4, 0, 255, 0, 4, 0, 4],
type: "",
desc: "Array with two bufferviews"
});
test_blob(function() {
var view = new Uint8Array([0]);
var blob = new Blob(["fo"]);
return new Blob([view.buffer, blob, "foo"]);
}, {
expected: "\0fofoo",
type: "",
desc: "Array with mixed types"
});
test(function() {
const accessed = [];
const stringified = [];
new Blob([], {
get type() { accessed.push('type'); },
get endings() { accessed.push('endings'); }
});
new Blob([], {
type: { toString: () => { stringified.push('type'); return ''; } },
endings: { toString: () => { stringified.push('endings'); return 'transparent'; } }
});
assert_array_equals(accessed, ['endings', 'type']);
assert_array_equals(stringified, ['endings', 'type']);
}, "options properties should be accessed in lexicographic order.");
test(function() {
assert_throws_exactly(test_error, function() {
new Blob(
[{ toString: function() { throw test_error } }],
{
get type() { assert_unreached("type getter should not be called."); }
}
);
});
}, "Arguments should be evaluated from left to right.");
[
null,
undefined,
{},
{ unrecognized: true },
/regex/,
function() {}
].forEach(function(arg, idx) {
test_blob(function() {
return new Blob([], arg);
}, {
expected: "",
type: "",
desc: "Passing " + format_value(arg) + " (index " + idx + ") for options should use the defaults."
});
test_blob(function() {
return new Blob(["\na\r\nb\n\rc\r"], arg);
}, {
expected: "\na\r\nb\n\rc\r",
type: "",
desc: "Passing " + format_value(arg) + " (index " + idx + ") for options should use the defaults (with newlines)."
});
});
[
123,
123.4,
true,
'abc'
].forEach(arg => {
test(t => {
assert_throws_js(TypeError, () => new Blob([], arg),
'Blob constructor should throw with invalid property bag');
}, `Passing ${JSON.stringify(arg)} for options should throw`);
});
var type_tests = [
// blobParts, type, expected type
[[], '', ''],
[[], 'a', 'a'],
[[], 'A', 'a'],
[[], 'text/html', 'text/html'],
[[], 'TEXT/HTML', 'text/html'],
[[], 'text/plain;charset=utf-8', 'text/plain;charset=utf-8'],
[[], '\u00E5', ''],
[[], '\uD801\uDC7E', ''], // U+1047E
[[], ' image/gif ', ' image/gif '],
[[], '\timage/gif\t', ''],
[[], 'image/gif;\u007f', ''],
[[], '\u0130mage/gif', ''], // uppercase i with dot
[[], '\u0131mage/gif', ''], // lowercase dotless i
[[], 'image/gif\u0000', ''],
// check that type isn't changed based on sniffing
[[0x3C, 0x48, 0x54, 0x4D, 0x4C, 0x3E], 'unknown/unknown', 'unknown/unknown'], // "<HTML>"
[[0x00, 0xFF], 'text/plain', 'text/plain'],
[[0x47, 0x49, 0x46, 0x38, 0x39, 0x61], 'image/png', 'image/png'], // "GIF89a"
];
type_tests.forEach(function(t) {
test(function() {
var arr = new Uint8Array([t[0]]).buffer;
var b = new Blob([arr], {type:t[1]});
assert_equals(b.type, t[2]);
}, "Blob with type " + format_value(t[1]));
});

9
test/fixtures/wpt/FileAPI/blob/Blob-in-worker.worker.js vendored Normal file
View File

@ -0,0 +1,9 @@
importScripts("/resources/testharness.js");
promise_test(async () => {
const data = "TEST";
const blob = new Blob([data], {type: "text/plain"});
assert_equals(await blob.text(), data);
}, 'Create Blob in Worker');
done();

32
test/fixtures/wpt/FileAPI/blob/Blob-slice-overflow.any.js vendored Normal file
View File

@ -0,0 +1,32 @@
// META: title=Blob slice overflow
'use strict';
var text = '';
for (var i = 0; i < 2000; ++i) {
text += 'A';
}
test(function() {
var blob = new Blob([text]);
var sliceBlob = blob.slice(-1, blob.size);
assert_equals(sliceBlob.size, 1, "Blob slice size");
}, "slice start is negative, relativeStart will be max((size + start), 0)");
test(function() {
var blob = new Blob([text]);
var sliceBlob = blob.slice(blob.size + 1, blob.size);
assert_equals(sliceBlob.size, 0, "Blob slice size");
}, "slice start is greater than blob size, relativeStart will be min(start, size)");
test(function() {
var blob = new Blob([text]);
var sliceBlob = blob.slice(blob.size - 2, -1);
assert_equals(sliceBlob.size, 1, "Blob slice size");
}, "slice end is negative, relativeEnd will be max((size + end), 0)");
test(function() {
var blob = new Blob([text]);
var sliceBlob = blob.slice(blob.size - 2, blob.size + 999);
assert_equals(sliceBlob.size, 2, "Blob slice size");
}, "slice end is greater than blob size, relativeEnd will be min(end, size)");

231
test/fixtures/wpt/FileAPI/blob/Blob-slice.any.js vendored Normal file
View File

@ -0,0 +1,231 @@
// META: title=Blob slice
// META: script=../support/Blob.js
'use strict';
test_blob(function() {
var blobTemp = new Blob(["PASS"]);
return blobTemp.slice();
}, {
expected: "PASS",
type: "",
desc: "no-argument Blob slice"
});
test(function() {
var blob1, blob2;
test_blob(function() {
return blob1 = new Blob(["squiggle"]);
}, {
expected: "squiggle",
type: "",
desc: "blob1."
});
test_blob(function() {
return blob2 = new Blob(["steak"], {type: "content/type"});
}, {
expected: "steak",
type: "content/type",
desc: "blob2."
});
test_blob(function() {
return new Blob().slice(0,0,null);
}, {
expected: "",
type: "null",
desc: "null type Blob slice"
});
test_blob(function() {
return new Blob().slice(0,0,undefined);
}, {
expected: "",
type: "",
desc: "undefined type Blob slice"
});
test_blob(function() {
return new Blob().slice(0,0);
}, {
expected: "",
type: "",
desc: "no type Blob slice"
});
var arrayBuffer = new ArrayBuffer(16);
var int8View = new Int8Array(arrayBuffer);
for (var i = 0; i < 16; i++) {
int8View[i] = i + 65;
}
var testData = [
[
["PASSSTRING"],
[{start: -6, contents: "STRING"},
{start: -12, contents: "PASSSTRING"},
{start: 4, contents: "STRING"},
{start: 12, contents: ""},
{start: 0, end: -6, contents: "PASS"},
{start: 0, end: -12, contents: ""},
{start: 0, end: 4, contents: "PASS"},
{start: 0, end: 12, contents: "PASSSTRING"},
{start: 7, end: 4, contents: ""}]
],
// Test 3 strings
[
["foo", "bar", "baz"],
[{start: 0, end: 9, contents: "foobarbaz"},
{start: 0, end: 3, contents: "foo"},
{start: 3, end: 9, contents: "barbaz"},
{start: 6, end: 9, contents: "baz"},
{start: 6, end: 12, contents: "baz"},
{start: 0, end: 9, contents: "foobarbaz"},
{start: 0, end: 11, contents: "foobarbaz"},
{start: 10, end: 15, contents: ""}]
],
// Test string, Blob, string
[
["foo", blob1, "baz"],
[{start: 0, end: 3, contents: "foo"},
{start: 3, end: 11, contents: "squiggle"},
{start: 2, end: 4, contents: "os"},
{start: 10, end: 12, contents: "eb"}]
],
// Test blob, string, blob
[
[blob1, "foo", blob1],
[{start: 0, end: 8, contents: "squiggle"},
{start: 7, end: 9, contents: "ef"},
{start: 10, end: 12, contents: "os"},
{start: 1, end: 4, contents: "qui"},
{start: 12, end: 15, contents: "qui"},
{start: 40, end: 60, contents: ""}]
],
// Test blobs all the way down
[
[blob2, blob1, blob2],
[{start: 0, end: 5, contents: "steak"},
{start: 5, end: 13, contents: "squiggle"},
{start: 13, end: 18, contents: "steak"},
{start: 1, end: 3, contents: "te"},
{start: 6, end: 10, contents: "quig"}]
],
// Test an ArrayBufferView
[
[int8View, blob1, "foo"],
[{start: 0, end: 8, contents: "ABCDEFGH"},
{start: 8, end: 18, contents: "IJKLMNOPsq"},
{start: 17, end: 20, contents: "qui"},
{start: 4, end: 12, contents: "EFGHIJKL"}]
],
// Test a partial ArrayBufferView
[
[new Uint8Array(arrayBuffer, 3, 5), blob1, "foo"],
[{start: 0, end: 8, contents: "DEFGHsqu"},
{start: 8, end: 18, contents: "igglefoo"},
{start: 4, end: 12, contents: "Hsquiggl"}]
],
// Test type coercion of a number
[
[3, int8View, "foo"],
[{start: 0, end: 8, contents: "3ABCDEFG"},
{start: 8, end: 18, contents: "HIJKLMNOPf"},
{start: 17, end: 21, contents: "foo"},
{start: 4, end: 12, contents: "DEFGHIJK"}]
],
[
[(new Uint8Array([0, 255, 0])).buffer,
new Blob(['abcd']),
'efgh',
'ijklmnopqrstuvwxyz'],
[{start: 1, end: 4, contents: "\uFFFD\u0000a"},
{start: 4, end: 8, contents: "bcde"},
{start: 8, end: 12, contents: "fghi"},
{start: 1, end: 12, contents: "\uFFFD\u0000abcdefghi"}]
]
];
testData.forEach(function(data, i) {
var blobs = data[0];
var tests = data[1];
tests.forEach(function(expectations, j) {
test(function() {
var blob = new Blob(blobs);
assert_true(blob instanceof Blob);
assert_false(blob instanceof File);
test_blob(function() {
return expectations.end === undefined
? blob.slice(expectations.start)
: blob.slice(expectations.start, expectations.end);
}, {
expected: expectations.contents,
type: "",
desc: "Slicing test: slice (" + i + "," + j + ")."
});
}, "Slicing test (" + i + "," + j + ").");
});
});
}, "Slices");
var invalidTypes = [
"\xFF",
"te\x09xt/plain",
"te\x00xt/plain",
"te\x1Fxt/plain",
"te\x7Fxt/plain"
];
invalidTypes.forEach(function(type) {
test_blob(function() {
var blob = new Blob(["PASS"]);
return blob.slice(0, 4, type);
}, {
expected: "PASS",
type: "",
desc: "Invalid contentType (" + format_value(type) + ")"
});
});
var validTypes = [
"te(xt/plain",
"te)xt/plain",
"te<xt/plain",
"te>xt/plain",
"te@xt/plain",
"te,xt/plain",
"te;xt/plain",
"te:xt/plain",
"te\\xt/plain",
"te\"xt/plain",
"te/xt/plain",
"te[xt/plain",
"te]xt/plain",
"te?xt/plain",
"te=xt/plain",
"te{xt/plain",
"te}xt/plain",
"te\x20xt/plain",
"TEXT/PLAIN",
"text/plain;charset = UTF-8",
"text/plain;charset=UTF-8"
];
validTypes.forEach(function(type) {
test_blob(function() {
var blob = new Blob(["PASS"]);
return blob.slice(0, 4, type);
}, {
expected: "PASS",
type: type.toLowerCase(),
desc: "Valid contentType (" + format_value(type) + ")"
});
});

11
test/fixtures/wpt/FileAPI/blob/Blob-stream-byob-crash.html vendored Normal file
View File

@ -0,0 +1,11 @@
<!DOCTYPE html>
<script type="module">
let a = new Blob(['', '', undefined], { })
let b = a.stream()
let c = new ReadableStreamBYOBReader(b)
let d = new Int16Array(8)
await c.read(d)
c.releaseLock()
await a.text()
await b.cancel()
</script>

13
test/fixtures/wpt/FileAPI/blob/Blob-stream-sync-xhr-crash.html vendored Normal file
View File

@ -0,0 +1,13 @@
<!DOCTYPE html>
<script>
const blob = new Blob([1, 2]);
const readable = blob.stream()
const writable = new WritableStream({}, {
size() {
let xhr = new XMLHttpRequest()
xhr.open("POST", "1", false)
xhr.send()
}
})
readable.pipeThrough({ readable, writable })
</script>

94
test/fixtures/wpt/FileAPI/blob/Blob-stream.any.js vendored Normal file
View File

@ -0,0 +1,94 @@
// META: title=Blob Stream
// META: script=../support/Blob.js
// META: script=/common/gc.js
'use strict';
// Helper function that triggers garbage collection while reading a chunk
// if perform_gc is true.
async function read_and_gc(reader, perform_gc) {
// Passing Uint8Array for byte streams; non-byte streams will simply ignore it
const read_promise = reader.read(new Uint8Array(64));
if (perform_gc) {
await garbageCollect();
}
return read_promise;
}
// Takes in a ReadableStream and reads from it until it is done, returning
// an array that contains the results of each read operation. If perform_gc
// is true, garbage collection is triggered while reading every chunk.
async function read_all_chunks(stream, { perform_gc = false, mode } = {}) {
assert_true(stream instanceof ReadableStream);
assert_true('getReader' in stream);
const reader = stream.getReader({ mode });
assert_true('read' in reader);
let read_value = await read_and_gc(reader, perform_gc);
let out = [];
let i = 0;
while (!read_value.done) {
for (let val of read_value.value) {
out[i++] = val;
}
read_value = await read_and_gc(reader, perform_gc);
}
return out;
}
promise_test(async () => {
const blob = new Blob(["PASS"]);
const stream = blob.stream();
const chunks = await read_all_chunks(stream);
for (let [index, value] of chunks.entries()) {
assert_equals(value, "PASS".charCodeAt(index));
}
}, "Blob.stream()")
promise_test(async () => {
const blob = new Blob();
const stream = blob.stream();
const chunks = await read_all_chunks(stream);
assert_array_equals(chunks, []);
}, "Blob.stream() empty Blob")
promise_test(async () => {
const input_arr = [8, 241, 48, 123, 151];
const typed_arr = new Uint8Array(input_arr);
const blob = new Blob([typed_arr]);
const stream = blob.stream();
const chunks = await read_all_chunks(stream);
assert_array_equals(chunks, input_arr);
}, "Blob.stream() non-unicode input")
promise_test(async() => {
const input_arr = [8, 241, 48, 123, 151];
const typed_arr = new Uint8Array(input_arr);
let blob = new Blob([typed_arr]);
const stream = blob.stream();
blob = null;
await garbageCollect();
const chunks = await read_all_chunks(stream, { perform_gc: true });
assert_array_equals(chunks, input_arr);
}, "Blob.stream() garbage collection of blob shouldn't break stream " +
"consumption")
promise_test(async() => {
const input_arr = [8, 241, 48, 123, 151];
const typed_arr = new Uint8Array(input_arr);
let blob = new Blob([typed_arr]);
const chunksPromise = read_all_chunks(blob.stream());
// It somehow matters to do GC here instead of doing `perform_gc: true`
await garbageCollect();
assert_array_equals(await chunksPromise, input_arr);
}, "Blob.stream() garbage collection of stream shouldn't break stream " +
"consumption")
promise_test(async () => {
const input_arr = [8, 241, 48, 123, 151];
const typed_arr = new Uint8Array(input_arr);
let blob = new Blob([typed_arr]);
const stream = blob.stream();
const chunks = await read_all_chunks(stream, { mode: "byob" });
assert_array_equals(chunks, input_arr);
}, "Reading Blob.stream() with BYOB reader")

64
test/fixtures/wpt/FileAPI/blob/Blob-text.any.js vendored Normal file
View File

@ -0,0 +1,64 @@
// META: title=Blob Text
// META: script=../support/Blob.js
'use strict';
promise_test(async () => {
const blob = new Blob(["PASS"]);
const text = await blob.text();
assert_equals(text, "PASS");
}, "Blob.text()")
promise_test(async () => {
const blob = new Blob();
const text = await blob.text();
assert_equals(text, "");
}, "Blob.text() empty blob data")
promise_test(async () => {
const blob = new Blob(["P", "A", "SS"]);
const text = await blob.text();
assert_equals(text, "PASS");
}, "Blob.text() multi-element array in constructor")
promise_test(async () => {
const non_unicode = "\u0061\u030A";
const input_arr = new TextEncoder().encode(non_unicode);
const blob = new Blob([input_arr]);
const text = await blob.text();
assert_equals(text, non_unicode);
}, "Blob.text() non-unicode")
promise_test(async () => {
const blob = new Blob(["PASS"], { type: "text/plain;charset=utf-16le" });
const text = await blob.text();
assert_equals(text, "PASS");
}, "Blob.text() different charset param in type option")
promise_test(async () => {
const non_unicode = "\u0061\u030A";
const input_arr = new TextEncoder().encode(non_unicode);
const blob = new Blob([input_arr], { type: "text/plain;charset=utf-16le" });
const text = await blob.text();
assert_equals(text, non_unicode);
}, "Blob.text() different charset param with non-ascii input")
promise_test(async () => {
const input_arr = new Uint8Array([192, 193, 245, 246, 247, 248, 249, 250, 251,
252, 253, 254, 255]);
const blob = new Blob([input_arr]);
const text = await blob.text();
assert_equals(text, "\ufffd\ufffd\ufffd\ufffd\ufffd\ufffd\ufffd\ufffd\ufffd" +
"\ufffd\ufffd\ufffd\ufffd");
}, "Blob.text() invalid utf-8 input")
promise_test(async () => {
const input_arr = new Uint8Array([192, 193, 245, 246, 247, 248, 249, 250, 251,
252, 253, 254, 255]);
const blob = new Blob([input_arr]);
const text_results = await Promise.all([blob.text(), blob.text(),
blob.text()]);
for (let text of text_results) {
assert_equals(text, "\ufffd\ufffd\ufffd\ufffd\ufffd\ufffd\ufffd\ufffd\ufffd" +
"\ufffd\ufffd\ufffd\ufffd");
}
}, "Blob.text() concurrent reads")