mirror of
https://github.com/zhw2590582/ArtPlayer.git
synced 2026-10-18 19:01:20 -08:00
673 lines
25 KiB
JavaScript
673 lines
25 KiB
JavaScript
import assert from 'node:assert/strict'
|
|
import fs from 'node:fs'
|
|
// eslint-disable-next-line test/no-import-node-test -- Deterministic candidate scheduling uses the Node runner.
|
|
import test from 'node:test'
|
|
import vm from 'node:vm'
|
|
import { danmukuCandidate, danmukuCandidateEnvironment } from './helpers/danmuku-candidate.js'
|
|
import { deferred } from './helpers/danmuku.js'
|
|
|
|
const implementation = await danmukuCandidate()
|
|
const prefix = `Danmuku scheduler ${implementation.name}`
|
|
const output = (env, event) => env.events.filter(item => item.name === `artplayerPluginDanmuku:${event}`)
|
|
|
|
function measuredNode(node) {
|
|
node.clientWidth = 100
|
|
node.clientHeight = 20
|
|
Object.defineProperty(node, 'offsetTop', { get: () => Number.parseFloat(node.style.top) || 0 })
|
|
return node
|
|
}
|
|
|
|
async function fixture(options = {}, { automatic = false } = {}) {
|
|
const env = danmukuCandidateEnvironment(implementation)
|
|
const plugin = env.factory({ danmuku: [], ...options })(env.art)
|
|
const owner = plugin.show()
|
|
const createElement = env.context.document.createElement
|
|
env.context.document.createElement = tag => measuredNode(createElement(tag))
|
|
const layer = env.art.template.$danmuku
|
|
let content = layer.textContent
|
|
Object.defineProperty(layer, 'textContent', {
|
|
get: () => content,
|
|
set(value) {
|
|
content = value
|
|
for (const child of layer.children)
|
|
child.parentElement = null
|
|
layer.children.length = 0
|
|
},
|
|
})
|
|
layer.appendChild = (child) => {
|
|
const siblings = child.parentElement?.children
|
|
const index = siblings?.indexOf(child) ?? -1
|
|
if (index >= 0)
|
|
siblings.splice(index, 1)
|
|
layer.children.push(child)
|
|
child.parentElement = layer
|
|
return child
|
|
}
|
|
const worker = env.workers[0]
|
|
const actualBlob = env.urls.get(worker.url)
|
|
const workerCode = actualBlob
|
|
? await actualBlob.text()
|
|
: fs.readFileSync(new URL('../packages/artplayer-plugin-danmuku/src/worker.js', import.meta.url), 'utf8')
|
|
const responses = []
|
|
const workerContext = vm.createContext({ postMessage: data => responses.push(structuredClone(data)), URL: { revokeObjectURL() {} }, location: { href: worker.url } })
|
|
workerContext.self = workerContext
|
|
vm.runInContext(workerCode, workerContext, { timeout: 1000 })
|
|
function calculate(message) {
|
|
workerContext.input = structuredClone(message)
|
|
const count = responses.length
|
|
vm.runInContext('onmessage({ data: input })', workerContext, { timeout: 1000 })
|
|
assert.equal(responses.length, count + 1, 'The actual Worker algorithm must produce the response')
|
|
return responses.at(-1)
|
|
}
|
|
function deliver(data) {
|
|
const event = { data }
|
|
worker.onmessage?.(event)
|
|
for (const callback of [...worker.listeners.get('message') || []])
|
|
callback(event)
|
|
}
|
|
function reply(index) {
|
|
const message = worker.messages[index].message
|
|
deliver(calculate(message))
|
|
}
|
|
const post = worker.postMessage.bind(worker)
|
|
worker.postMessage = (message) => {
|
|
post(structuredClone(message))
|
|
if (automatic)
|
|
queueMicrotask(() => deliver(calculate(message)))
|
|
}
|
|
return { env, plugin, owner, worker, layer, calculate, deliver, reply }
|
|
}
|
|
|
|
function geometry(mode = 1) {
|
|
return { type: 'getDanmuTop', target: { mode, height: 20, speed: 148 }, visibles: [], antiOverlap: true, clientWidth: 640, clientHeight: 360, marginTop: 10, marginBottom: 90 }
|
|
}
|
|
|
|
test(`${prefix}: repeated play/playing and direct starts preserve events and internal return with only one queued frame`, async () => {
|
|
const { env, owner } = await fixture()
|
|
env.art.playing = true
|
|
env.art.emit('video:play')
|
|
env.art.emit('video:playing')
|
|
assert.equal(owner.start(), owner)
|
|
assert.equal(output(env, 'start').length, 3)
|
|
assert.equal(env.frames.size, 1)
|
|
assert.equal(owner.stop(), owner)
|
|
assert.equal(owner.stop(), owner)
|
|
assert.equal(output(env, 'stop').length, 2)
|
|
assert.equal(env.frames.size, 0)
|
|
env.destroy()
|
|
})
|
|
|
|
test(`${prefix}: additional starts while beforeVisible is pending do not schedule an overlapping frame`, async () => {
|
|
const gate = deferred()
|
|
const { env, plugin, owner } = await fixture({ beforeVisible: () => gate.promise })
|
|
await plugin.emit({ text: 'waiting callback', time: 10 })
|
|
env.art.playing = true
|
|
owner.start()
|
|
env.frame()
|
|
await env.flush()
|
|
owner.start()
|
|
env.art.emit('video:playing')
|
|
assert.equal(env.frames.size, 0, 'The existing asynchronous frame owns this generation')
|
|
env.destroy()
|
|
gate.resolve(true)
|
|
await env.flush()
|
|
})
|
|
|
|
for (const action of ['pause', 'destroy', 'reset', 'replace', 'seek', 'hide']) {
|
|
for (const stage of ['beforeVisible', 'worker']) {
|
|
test(`${prefix}: ${action} invalidates the pending ${stage} continuation without modifying an obsolete row`, async () => {
|
|
const gate = deferred()
|
|
const state = await fixture(stage === 'beforeVisible' ? { beforeVisible: () => gate.promise } : {})
|
|
const { env, plugin, owner, worker, layer } = state
|
|
await plugin.emit({ text: 'old', time: 10, mode: 1 })
|
|
const row = owner.queue[0]
|
|
env.art.playing = true
|
|
owner.start()
|
|
env.frame()
|
|
await env.flush()
|
|
let response
|
|
if (stage === 'worker') {
|
|
assert.equal(worker.messages.length, 1)
|
|
response = state.calculate(worker.messages[0].message)
|
|
}
|
|
if (action === 'pause') {
|
|
env.art.playing = false
|
|
owner.stop()
|
|
}
|
|
else if (action === 'destroy') {
|
|
env.destroy()
|
|
}
|
|
else if (action === 'reset') {
|
|
plugin.reset()
|
|
}
|
|
else if (action === 'replace') {
|
|
plugin.config({ danmuku: [{ text: 'new', time: 20 }] })
|
|
await plugin.load()
|
|
}
|
|
else if (action === 'hide') {
|
|
plugin.hide()
|
|
}
|
|
else {
|
|
env.art.currentTime = 20
|
|
env.art.emit('video:seeking')
|
|
}
|
|
const snapshot = { rowState: row.$state, rowRef: row.$ref, nodes: [...layer.children], events: output(env, 'visible').length, messages: worker.messages.length }
|
|
if (stage === 'worker')
|
|
state.deliver(response)
|
|
else
|
|
gate.resolve(true)
|
|
await env.flush()
|
|
assert.equal(row.$state, snapshot.rowState)
|
|
assert.equal(row.$ref, snapshot.rowRef)
|
|
assert.deepEqual(layer.children, snapshot.nodes)
|
|
assert.equal(output(env, 'visible').length, snapshot.events)
|
|
assert.equal(worker.messages.length, snapshot.messages)
|
|
if (action !== 'destroy')
|
|
env.destroy()
|
|
})
|
|
}
|
|
}
|
|
|
|
test(`${prefix}: pausing a never-settled callback does not block a fresh generation`, async () => {
|
|
const gate = deferred()
|
|
let calls = 0
|
|
const { env, plugin, owner } = await fixture({ beforeVisible: () => ++calls === 1 ? gate.promise : true }, { automatic: true })
|
|
await plugin.emit({ text: 'resumable', time: 10, mode: 1 })
|
|
env.art.playing = true
|
|
owner.start()
|
|
env.frame()
|
|
await env.flush()
|
|
owner.stop()
|
|
owner.start()
|
|
await env.flush()
|
|
assert.equal(env.frames.size, 1)
|
|
env.frame()
|
|
await env.flush()
|
|
assert.equal(output(env, 'visible').length, 1)
|
|
assert.equal(calls, 2)
|
|
env.destroy()
|
|
gate.resolve(true)
|
|
await env.flush()
|
|
assert.equal(output(env, 'visible').length, 1)
|
|
})
|
|
|
|
test(`${prefix}: an already delivered Worker reply cannot resume its JavaScript continuation after destroy`, async () => {
|
|
const { env, plugin, owner, layer, reply } = await fixture()
|
|
await plugin.emit({ text: 'queued microtask', time: 10, mode: 1 })
|
|
env.art.playing = true
|
|
owner.start()
|
|
env.frame()
|
|
await env.flush()
|
|
reply(0)
|
|
env.destroy()
|
|
const row = owner.queue[0]
|
|
const snapshot = { state: row.$state, ref: row.$ref, nodes: [...layer.children] }
|
|
await env.flush()
|
|
assert.equal(row.$state, snapshot.state)
|
|
assert.equal(row.$ref, snapshot.ref)
|
|
assert.deepEqual(layer.children, snapshot.nodes)
|
|
assert.equal(output(env, 'visible').length, 0)
|
|
assert.equal(env.frames.size, 0)
|
|
})
|
|
|
|
test(`${prefix}: beforeVisible rejection reports the original error once, skips that row until start, and allows other rows`, async () => {
|
|
const error = new Error('visibility hook rejected')
|
|
const calls = []
|
|
let retry = false
|
|
const { env, plugin, owner } = await fixture({
|
|
beforeVisible(row) {
|
|
calls.push(row.text)
|
|
return row.text === 'failed' && !retry ? Promise.reject(error) : true
|
|
},
|
|
}, { automatic: true })
|
|
await plugin.load([{ text: 'failed', time: 10, mode: 1 }, { text: 'healthy', time: 10, mode: 1 }])
|
|
env.art.playing = true
|
|
owner.start()
|
|
env.frame()
|
|
await env.flush()
|
|
await env.flush()
|
|
assert.deepEqual(output(env, 'error').map(event => event.args[0]), [error])
|
|
assert.deepEqual(output(env, 'visible').map(event => event.args[0].text), ['healthy'])
|
|
env.frame()
|
|
await env.flush()
|
|
assert.deepEqual(calls, ['failed', 'healthy'])
|
|
retry = true
|
|
assert.equal(owner.start(), owner)
|
|
assert.equal(env.frames.size, 1)
|
|
env.frame()
|
|
await env.flush()
|
|
assert.deepEqual(calls, ['failed', 'healthy', 'failed'])
|
|
assert.deepEqual(output(env, 'visible').map(event => event.args[0].text), ['healthy', 'failed'])
|
|
assert.equal(output(env, 'error').length, 1)
|
|
env.destroy()
|
|
})
|
|
|
|
test(`${prefix}: a cancelled beforeVisible rejection is observed without reporting a stale error`, async () => {
|
|
const gate = deferred()
|
|
const { env, plugin, owner } = await fixture({ beforeVisible: () => gate.promise })
|
|
await plugin.emit({ text: 'cancelled', time: 10 })
|
|
env.art.playing = true
|
|
owner.start()
|
|
env.frame()
|
|
await env.flush()
|
|
env.destroy()
|
|
gate.reject(new Error('rejected after destroy'))
|
|
await env.flush()
|
|
assert.equal(output(env, 'error').length, 0)
|
|
assert.equal(output(env, 'visible').length, 0)
|
|
assert.equal(env.frames.size, 0)
|
|
})
|
|
|
|
test(`${prefix}: beforeVisible false remains eligible for the next frame`, async () => {
|
|
let calls = 0
|
|
const { env, plugin, owner } = await fixture({ beforeVisible: () => ++calls > 1 }, { automatic: true })
|
|
await plugin.emit({ text: 'retry false', time: 10, mode: 1 })
|
|
env.art.playing = true
|
|
owner.start()
|
|
env.frame()
|
|
await env.flush()
|
|
assert.equal(output(env, 'visible').length, 0)
|
|
env.frame()
|
|
await env.flush()
|
|
assert.equal(calls, 2)
|
|
assert.equal(output(env, 'visible').length, 1)
|
|
assert.equal(output(env, 'error').length, 0)
|
|
env.destroy()
|
|
})
|
|
|
|
test(`${prefix}: hide preserves an already visible row and show permits fresh scheduling`, async () => {
|
|
const { env, plugin, owner } = await fixture({}, { automatic: true })
|
|
await plugin.emit({ text: 'visible before hide', time: 10, mode: 1 })
|
|
env.art.playing = true
|
|
owner.start()
|
|
env.frame()
|
|
await env.flush()
|
|
const row = owner.queue[0]
|
|
const ref = row.$ref
|
|
const resets = output(env, 'reset').length
|
|
assert.equal(plugin.hide(), owner)
|
|
assert.equal(row.$state, 'emit')
|
|
assert.equal(row.$ref, ref)
|
|
assert.equal(output(env, 'reset').length, resets)
|
|
assert.equal(plugin.show(), owner)
|
|
await plugin.emit({ text: 'visible after show', time: 10, mode: 1 })
|
|
env.frame()
|
|
await env.flush()
|
|
assert.equal(output(env, 'visible').length, 2)
|
|
env.destroy()
|
|
})
|
|
|
|
test(`${prefix}: replacing beforeVisible releases an unresolved old callback without resetting displayed rows`, async () => {
|
|
const gate = deferred()
|
|
const calls = []
|
|
const { env, plugin, owner } = await fixture({
|
|
beforeVisible(row) {
|
|
calls.push(`old:${row.text}`)
|
|
return row.text === 'pending' ? gate.promise : true
|
|
},
|
|
}, { automatic: true })
|
|
await plugin.load([{ text: 'displayed', time: 10, mode: 1 }, { text: 'pending', time: 10, mode: 1 }])
|
|
env.art.playing = true
|
|
owner.start()
|
|
env.frame()
|
|
await env.flush()
|
|
await env.flush()
|
|
const displayed = owner.queue[0]
|
|
const ref = displayed.$ref
|
|
const resets = output(env, 'reset').length
|
|
assert.deepEqual(calls, ['old:displayed', 'old:pending'])
|
|
plugin.config({
|
|
beforeVisible(row) {
|
|
calls.push(`new:${row.text}`)
|
|
return true
|
|
},
|
|
})
|
|
assert.equal(displayed.$state, 'emit')
|
|
assert.equal(displayed.$ref, ref)
|
|
assert.equal(output(env, 'reset').length, resets)
|
|
assert.equal(env.frames.size, 1)
|
|
env.frame()
|
|
await env.flush()
|
|
assert.deepEqual(calls, ['old:displayed', 'old:pending', 'new:pending'])
|
|
assert.deepEqual(output(env, 'visible').map(event => event.args[0].text), ['displayed', 'pending'])
|
|
gate.resolve(true)
|
|
await env.flush()
|
|
assert.equal(output(env, 'visible').length, 2)
|
|
env.destroy()
|
|
})
|
|
|
|
test(`${prefix}: configuring the same beforeVisible callback preserves the pending operation`, async () => {
|
|
const gate = deferred()
|
|
let calls = 0
|
|
const beforeVisible = () => {
|
|
calls++
|
|
return gate.promise
|
|
}
|
|
const { env, plugin, owner } = await fixture({ beforeVisible }, { automatic: true })
|
|
await plugin.emit({ text: 'same callback', time: 10, mode: 1 })
|
|
env.art.playing = true
|
|
owner.start()
|
|
env.frame()
|
|
await env.flush()
|
|
const configurations = output(env, 'config').length
|
|
plugin.config({ beforeVisible })
|
|
assert.equal(output(env, 'config').length, configurations)
|
|
assert.equal(env.frames.size, 0)
|
|
gate.resolve(true)
|
|
await env.flush()
|
|
assert.equal(calls, 1)
|
|
assert.equal(output(env, 'visible').length, 1)
|
|
assert.equal(env.frames.size, 1)
|
|
env.destroy()
|
|
})
|
|
|
|
for (const action of ['destroy', 'stop']) {
|
|
test(`${prefix}: ${action} inside a Worker rebuild error listener prevents the outer start from reviving stopped rows`, async () => {
|
|
const { env, plugin, owner, worker } = await fixture({}, { automatic: true })
|
|
await plugin.emit({ text: 'already displayed', time: 10, mode: 1 })
|
|
env.art.playing = true
|
|
owner.start()
|
|
env.frame()
|
|
await env.flush()
|
|
const row = owner.queue[0]
|
|
assert.equal(row.$state, 'emit')
|
|
const workerError = new Error('initial worker fault')
|
|
worker.onerror({ error: workerError, preventDefault() {} })
|
|
owner.stop()
|
|
assert.equal(row.$state, 'stop')
|
|
const rebuildError = new Error('rebuild original error')
|
|
// This is an explicit constructor-failure seam, not a native Worker assertion.
|
|
owner.createWorker = () => {
|
|
throw rebuildError
|
|
}
|
|
env.art.on('artplayerPluginDanmuku:error', (error) => {
|
|
if (error === rebuildError) {
|
|
if (action === 'destroy')
|
|
env.destroy()
|
|
else
|
|
owner.stop()
|
|
}
|
|
})
|
|
const starts = output(env, 'start').length
|
|
assert.equal(owner.start(), owner)
|
|
await env.flush()
|
|
assert.equal(row.$state, 'stop')
|
|
assert.equal(owner.isStop, true)
|
|
assert.equal(output(env, 'start').length, starts)
|
|
assert.equal(env.frames.size, 0)
|
|
assert.deepEqual(output(env, 'error').map(event => event.args[0]), [workerError, rebuildError])
|
|
if (action !== 'destroy')
|
|
env.destroy()
|
|
})
|
|
}
|
|
|
|
for (const action of ['reset', 'hide', 'start']) {
|
|
test(`${prefix}: ${action} reentry from a rebuild error owns the recovery without a second outer start`, async () => {
|
|
const { env, plugin, owner, worker } = await fixture({}, { automatic: true })
|
|
await plugin.emit({ text: 'displayed before recovery', time: 10, mode: 1 })
|
|
env.art.playing = true
|
|
owner.start()
|
|
env.frame()
|
|
await env.flush()
|
|
const row = owner.queue[0]
|
|
assert.equal(row.$state, 'emit')
|
|
const workerError = new Error('worker failed before reentry')
|
|
worker.onerror({ error: workerError, preventDefault() {} })
|
|
owner.stop()
|
|
const createWorker = owner.createWorker
|
|
const rebuildError = new Error('one rebuild failure')
|
|
owner.createWorker = () => {
|
|
throw rebuildError
|
|
}
|
|
let recoveries = 0
|
|
env.art.on('artplayerPluginDanmuku:error', (error) => {
|
|
if (error !== rebuildError)
|
|
return
|
|
recoveries++
|
|
assert.equal(recoveries, 1, 'The recovery listener must not retry itself indefinitely')
|
|
owner.createWorker = createWorker
|
|
owner[action]()
|
|
})
|
|
const starts = output(env, 'start').length
|
|
const resets = output(env, 'reset').length
|
|
assert.equal(owner.start(), owner)
|
|
await env.flush()
|
|
assert.equal(recoveries, 1)
|
|
assert.deepEqual(output(env, 'error').map(event => event.args[0]), [workerError, rebuildError])
|
|
assert.equal(output(env, 'start').length, starts + (action === 'start' ? 1 : 0))
|
|
assert.equal(output(env, 'reset').length, resets + (action === 'reset' ? 1 : 0))
|
|
assert.equal(row.$state, action === 'reset' ? 'wait' : action === 'start' ? 'emit' : 'stop')
|
|
assert.equal(owner.isHide, action === 'hide')
|
|
assert.equal(env.frames.size, action === 'start' ? 1 : 0)
|
|
if (action === 'reset')
|
|
assert.equal(row.$ref, null)
|
|
env.destroy()
|
|
})
|
|
}
|
|
|
|
test(`${prefix}: requests in the same millisecond have distinct ids and reverse replies settle the right promises`, async () => {
|
|
const { env, owner, worker, reply } = await fixture()
|
|
let first
|
|
let second
|
|
owner.postMessage(geometry(1)).then(value => first = value)
|
|
owner.postMessage(geometry(2)).then(value => second = value)
|
|
assert.equal(worker.messages.length, 2)
|
|
assert.notEqual(worker.messages[0].message.id, worker.messages[1].message.id)
|
|
reply(1)
|
|
await env.flush()
|
|
assert.equal(first, undefined)
|
|
assert.equal(second.result, 250)
|
|
assert.equal(second.id, worker.messages[1].message.id)
|
|
reply(0)
|
|
await env.flush()
|
|
assert.equal(first.result, 10)
|
|
assert.equal(first.id, worker.messages[0].message.id)
|
|
env.destroy()
|
|
})
|
|
|
|
test(`${prefix}: a synchronous real algorithm response cannot arrive before its resolver is installed`, async () => {
|
|
const { env, owner, worker, calculate, deliver } = await fixture()
|
|
const post = worker.postMessage.bind(worker)
|
|
worker.postMessage = (message) => {
|
|
post(message)
|
|
deliver(calculate(message))
|
|
}
|
|
let response
|
|
owner.postMessage(geometry(2)).then(value => response = value)
|
|
await env.flush()
|
|
assert.equal(response?.result, 250)
|
|
env.destroy()
|
|
})
|
|
|
|
test(`${prefix}: the actual algorithm places three same-time fixed rows on distinct tracks in one frame`, async () => {
|
|
const { env, plugin, owner, layer } = await fixture({}, { automatic: true })
|
|
await plugin.load([0, 1, 2].map(index => ({ text: `fixed-${index}`, time: 10, mode: 1 })))
|
|
env.art.playing = true
|
|
owner.start()
|
|
env.frame()
|
|
for (let step = 0; step < 3; step++)
|
|
await env.flush()
|
|
assert.deepEqual(Array.from(owner.queue, row => row.$state), ['emit', 'emit', 'emit'])
|
|
assert.deepEqual(Array.from(owner.queue, row => row.$ref.offsetTop), [10, 30, 50])
|
|
assert.equal(layer.children.length, 3)
|
|
assert.deepEqual(output(env, 'visible').map(event => event.args[0].text), ['fixed-0', 'fixed-1', 'fixed-2'])
|
|
assert.equal(env.frames.size, 1)
|
|
env.destroy()
|
|
})
|
|
|
|
test(`${prefix}: a sampled three-hour simulated clock preserves batch order, pooled nodes, pause and seek state`, async (t) => {
|
|
// Advance a controlled clock at lifecycle boundaries; this is not a real-time
|
|
// endurance, frame-rate, CSS animation or browser memory measurement.
|
|
const { env, plugin, owner, worker, layer } = await fixture({}, { automatic: true })
|
|
t.after(() => env.destroy())
|
|
const batchCount = 180
|
|
const batchSize = 4
|
|
const firstTime = 10
|
|
const horizon = 3 * 60 * 60
|
|
const rows = Array.from({ length: batchCount * batchSize }, (_, index) => ({
|
|
text: `long-${index}`,
|
|
time: firstTime + Math.floor(index / batchSize) * 60,
|
|
mode: 1,
|
|
}))
|
|
await plugin.load(rows)
|
|
const queue = owner.queue
|
|
const expectedOrder = Array.from(queue, row => row.text)
|
|
let advanced = 0
|
|
const tick = (milliseconds) => {
|
|
advanced += milliseconds
|
|
env.tick(milliseconds)
|
|
}
|
|
const membership = () => {
|
|
const items = Object.entries(owner.states).flatMap(([state, items]) => {
|
|
for (const item of items)
|
|
assert.equal(item.$state, state)
|
|
return Array.from(items)
|
|
})
|
|
assert.equal(items.length, queue.length)
|
|
assert.equal(new Set(items).size, queue.length, 'Every row belongs to exactly one state pool')
|
|
assert(items.every(item => queue.includes(item)))
|
|
}
|
|
let pooledNodes
|
|
let pauses = 0
|
|
env.art.playing = true
|
|
env.art.emit('video:play')
|
|
env.art.emit('video:playing')
|
|
|
|
for (let batch = 0; batch < batchCount; batch++) {
|
|
const time = firstTime + batch * 60
|
|
tick((time - env.art.currentTime) * 1000)
|
|
env.art.currentTime = time
|
|
assert.equal(env.frames.size, 1)
|
|
const requests = worker.messages.length
|
|
await env.frame()
|
|
const active = Array.from(queue.slice(batch * batchSize, (batch + 1) * batchSize))
|
|
assert.deepEqual(output(env, 'visible').slice(-batchSize).map(event => event.args[0]), active)
|
|
assert.equal(worker.messages.length, requests + batchSize, 'One position request per row in this batch')
|
|
assert.deepEqual(worker.messages.slice(requests).map(item => item.message.visibles.length), [0, 1, 2, 3])
|
|
assert.deepEqual(active.map(row => row.$state), ['emit', 'emit', 'emit', 'emit'])
|
|
assert.deepEqual(active.map(row => row.$ref.offsetTop), [10, 30, 50, 70])
|
|
if (!pooledNodes)
|
|
pooledNodes = new Set(layer.children)
|
|
assert.equal(layer.children.length, batchSize)
|
|
assert(active.every(row => pooledNodes.has(row.$ref)), 'Later batches reuse the original measured nodes')
|
|
membership()
|
|
|
|
tick(1000)
|
|
env.art.currentTime++
|
|
await env.frame()
|
|
assert(active.every(row => row.$restTime === 4))
|
|
if (batch % 12 === 11) {
|
|
pauses++
|
|
const refs = active.map(row => row.$ref)
|
|
const resetCount = output(env, 'reset').length
|
|
env.art.playing = false
|
|
env.art.emit('video:pause')
|
|
assert.equal(env.frames.size, 0)
|
|
tick(120000)
|
|
env.art.currentTime = time + 20
|
|
env.art.emit('video:seeking')
|
|
env.art.emit('video:seeked')
|
|
assert.equal(output(env, 'reset').length, resetCount)
|
|
assert(active.every(row => row.$state === 'stop' && row.$restTime === 4))
|
|
assert.deepEqual(active.map(row => row.$ref), refs)
|
|
env.art.playing = true
|
|
env.art.emit('video:play')
|
|
env.art.emit('video:playing')
|
|
assert.equal(env.frames.size, 1)
|
|
await env.frame()
|
|
assert(active.every(row => row.$state === 'emit' && row.$restTime === 4))
|
|
assert.deepEqual(active.map(row => row.$ref), refs)
|
|
assert.equal(worker.messages.length, requests + batchSize, 'Resume and seek must not allocate duplicate rows')
|
|
}
|
|
|
|
tick(5000)
|
|
env.art.currentTime += 5
|
|
await env.frame()
|
|
assert(active.every(row => row.$state === 'wait' && row.$ref === null))
|
|
assert.equal(owner.$refs.length, batchSize)
|
|
assert.equal(new Set(owner.$refs).size, batchSize, 'Each reusable node returns to the pool once')
|
|
assert.equal(layer.children.length, batchSize)
|
|
assert.equal(env.frames.size, 1)
|
|
membership()
|
|
}
|
|
|
|
tick((firstTime + horizon - env.art.currentTime) * 1000)
|
|
env.art.currentTime = firstTime + horizon
|
|
await env.frame()
|
|
assert.equal(pauses, 15)
|
|
assert(advanced > horizon * 1000, 'The simulated wall clock also includes the paused intervals')
|
|
assert.equal(owner.queue, queue)
|
|
assert(queue.every(row => row.$state === 'wait' && row.$ref === null))
|
|
assert.deepEqual(output(env, 'visible').map(event => event.args[0].text), expectedOrder)
|
|
assert.equal(worker.messages.length, rows.length)
|
|
assert.equal(new Set(worker.messages.map(item => item.message.id)).size, rows.length)
|
|
assert.equal(output(env, 'error').length, 0)
|
|
assert.equal(env.workers.length, 1)
|
|
owner.stop()
|
|
assert.equal(env.frames.size, 0)
|
|
})
|
|
|
|
test(`${prefix}: paused wall clock does not consume remaining lifetime and expiration returns a row to wait`, async () => {
|
|
const { env, plugin, owner } = await fixture({}, { automatic: true })
|
|
await plugin.emit({ text: 'clock', time: 10, mode: 1 })
|
|
env.art.playing = true
|
|
owner.start()
|
|
env.frame()
|
|
await env.flush()
|
|
const row = owner.queue[0]
|
|
assert.equal(row.$restTime, 5)
|
|
env.tick(1000)
|
|
env.art.currentTime = 11
|
|
env.frame()
|
|
await env.flush()
|
|
assert.equal(row.$restTime, 4)
|
|
env.art.playing = false
|
|
owner.stop()
|
|
assert.equal(row.$state, 'stop')
|
|
env.tick(5000)
|
|
env.art.playing = true
|
|
owner.start()
|
|
env.frame()
|
|
await env.flush()
|
|
assert.equal(row.$restTime, 4)
|
|
env.tick(500)
|
|
env.art.currentTime = 11.5
|
|
env.frame()
|
|
await env.flush()
|
|
assert.equal(row.$restTime, 3.5)
|
|
env.tick(4000)
|
|
env.art.currentTime = 15.5
|
|
env.frame()
|
|
await env.flush()
|
|
assert.equal(row.$state, 'wait')
|
|
assert.equal(row.$ref, null)
|
|
assert.equal(owner.queue.length, 1)
|
|
assert.equal(output(env, 'visible').length, 1)
|
|
env.destroy()
|
|
})
|
|
|
|
test(`${prefix}: playbackRate is sampled for new rows while active lifetime and seek reset-event semantics stay compatible`, async () => {
|
|
const { env, plugin, owner } = await fixture({ synchronousPlayback: true }, { automatic: true })
|
|
await plugin.load([{ text: 'already-visible', time: 10, mode: 1 }, { text: 'after-seek', time: 20, mode: 1 }])
|
|
env.art.playbackRate = 2
|
|
env.art.playing = true
|
|
owner.start()
|
|
env.frame()
|
|
await env.flush()
|
|
const existing = owner.queue[0]
|
|
assert.equal(existing.$restTime, 2.5)
|
|
env.art.playbackRate = 4
|
|
const resets = output(env, 'reset').length
|
|
env.art.currentTime = 20
|
|
env.art.emit('video:seeking')
|
|
assert.equal(existing.$state, 'emit')
|
|
assert.equal(existing.$restTime, 2.5)
|
|
assert.equal(output(env, 'reset').length, resets)
|
|
assert.equal(env.frames.size, 1)
|
|
env.frame()
|
|
await env.flush()
|
|
assert.equal(owner.queue[1].$restTime, 1.25)
|
|
assert.equal(existing.$restTime, 2.5)
|
|
env.destroy()
|
|
})
|