146 lines
4.6 KiB
JavaScript
146 lines
4.6 KiB
JavaScript
// Don't want to use the FileReader, don't want to lowerCase the type either
|
|
// import from 'https://wpt.live/resources/testharnessreport.js'
|
|
import('https://wpt.live/FileAPI/file/File-constructor.any.js')
|
|
import('https://wpt.live/FileAPI/blob/Blob-constructor.any.js')
|
|
import('https://wpt.live/FileAPI/blob/Blob-array-buffer.any.js')
|
|
import('https://wpt.live/FileAPI/blob/Blob-slice-overflow.any.js')
|
|
import('https://wpt.live/FileAPI/blob/Blob-slice.any.js')
|
|
import('https://wpt.live/FileAPI/blob/Blob-stream.any.js')
|
|
import('https://wpt.live/FileAPI/blob/Blob-text.any.js')
|
|
import('./own-misc-test.js')
|
|
import { File, Blob } from '../from.js'
|
|
|
|
let hasFailed
|
|
globalThis.self = globalThis
|
|
await import('https://wpt.live/resources/testharness.js')
|
|
|
|
setup({
|
|
explicit_timeout: true,
|
|
explicit_done: true
|
|
})
|
|
|
|
function test_blob (fn, expectations) {
|
|
const expected = expectations.expected
|
|
const type = expectations.type
|
|
const desc = expectations.desc
|
|
const length = expectations.length
|
|
|
|
const t = async_test(desc)
|
|
t.step(async function () {
|
|
const blob = fn()
|
|
assert_true(blob instanceof Blob)
|
|
assert_false(blob instanceof File)
|
|
assert_equals(blob.type.toLowerCase(), type.toLowerCase())
|
|
assert_equals(await blob.text(), expected)
|
|
t.done()
|
|
})
|
|
}
|
|
|
|
function test_blob_binary (fn, expectations) {
|
|
const expected = expectations.expected
|
|
const type = expectations.type
|
|
const desc = expectations.desc
|
|
|
|
const t = async_test(desc)
|
|
t.step(async function () {
|
|
const blob = fn()
|
|
assert_true(blob instanceof Blob)
|
|
assert_false(blob instanceof File)
|
|
assert_equals(blob.type.toLowerCase(), type)
|
|
const result = await blob.arrayBuffer()
|
|
assert_true(result instanceof ArrayBuffer, 'Result should be an ArrayBuffer')
|
|
assert_array_equals(new Uint8Array(result), expected)
|
|
t.done()
|
|
})
|
|
}
|
|
|
|
// Assert that two TypedArray objects have the same byte values
|
|
globalThis.assert_equals_typed_array = (array1, array2) => {
|
|
const [view1, view2] = [array1, array2].map((array) => {
|
|
assert_true(array.buffer instanceof ArrayBuffer,
|
|
'Expect input ArrayBuffers to contain field `buffer`')
|
|
return new DataView(array.buffer, array.byteOffset, array.byteLength)
|
|
})
|
|
|
|
assert_equals(view1.byteLength, view2.byteLength,
|
|
'Expect both arrays to be of the same byte length')
|
|
|
|
const byteLength = view1.byteLength
|
|
|
|
for (let i = 0; i < byteLength; ++i) {
|
|
assert_equals(view1.getUint8(i), view2.getUint8(i),
|
|
`Expect byte at buffer position ${i} to be equal`)
|
|
}
|
|
}
|
|
|
|
globalThis.add_result_callback((test, ...args) => {
|
|
if ([
|
|
'Blob with type "A"',
|
|
'Blob with type "TEXT/HTML"',
|
|
'Getters and value conversions should happen in order until an exception is thrown.',
|
|
'Using type in File constructor: TEXT/PLAIN',
|
|
'Using type in File constructor: text/plain;charset=UTF-8'
|
|
].includes(test.name)) return
|
|
|
|
const INDENT_SIZE = 2
|
|
const reporter = {}
|
|
|
|
reporter.startSuite = name => console.log(`\n ${(name)}\n`)
|
|
|
|
reporter.pass = message => console.log((indent(('√ ') + message, INDENT_SIZE)))
|
|
|
|
reporter.fail = message => console.log((indent('\u00D7 ' + message, INDENT_SIZE)))
|
|
|
|
reporter.reportStack = stack => console.log((indent(stack, INDENT_SIZE * 2)))
|
|
|
|
function indent (string, times) {
|
|
const prefix = ' '.repeat(times)
|
|
return string.split('\n').map(l => prefix + l).join('\n')
|
|
}
|
|
|
|
if (test.status === 0) {
|
|
reporter.pass(test.name)
|
|
} else if (test.status === 1) {
|
|
reporter.fail(`${test.name}\n`)
|
|
reporter.reportStack(`${test.message}\n${test.stack}`)
|
|
hasFailed = true
|
|
} else if (test.status === 2) {
|
|
reporter.fail(`${test.name} (timeout)\n`)
|
|
reporter.reportStack(`${test.message}\n${test.stack}`)
|
|
hasFailed = true
|
|
} else if (test.status === 3) {
|
|
reporter.fail(`${test.name} (incomplete)\n`)
|
|
reporter.reportStack(`${test.message}\n${test.stack}`)
|
|
hasFailed = true
|
|
} else if (test.status === 4) {
|
|
reporter.fail(`${test.name} (precondition failed)\n`)
|
|
reporter.reportStack(`${test.message}\n${test.stack}`)
|
|
hasFailed = true
|
|
} else {
|
|
reporter.fail(`unknown test status: ${test.status}`)
|
|
hasFailed = true
|
|
}
|
|
})
|
|
|
|
globalThis.File = File
|
|
globalThis.Blob = Blob
|
|
globalThis.garbageCollect = () => {}
|
|
globalThis.test_blob = test_blob
|
|
globalThis.test_blob_binary = test_blob_binary
|
|
// Because WPT doesn't clean up after itself
|
|
globalThis.MessageChannel = class extends MessageChannel {
|
|
constructor () {
|
|
super()
|
|
setTimeout(() => {
|
|
this.port1.close()
|
|
this.port2.close()
|
|
this.port1.onmessage = this.port2.onmessage = null
|
|
}, 100)
|
|
}
|
|
}
|
|
|
|
|
|
if (hasFailed) {
|
|
console.log('Tests failed')
|
|
process.exit(1)
|
|
} |