mirror of
https://github.com/zhw2590582/ArtPlayer.git
synced 2026-10-08 19:06:15 -08:00
199 lines
11 KiB
JavaScript
199 lines
11 KiB
JavaScript
import assert from 'node:assert/strict'
|
|
import fs from 'node:fs'
|
|
import process from 'node:process'
|
|
import { ensureArchive, hash, readMember } from '../../refactor/scripts/releases.mjs'
|
|
import { browserCandidate } from '../helpers/browser-candidate.js'
|
|
import { expect, test } from './fixtures.js'
|
|
|
|
let provenance
|
|
const implementations = new Map()
|
|
test.beforeAll(async () => {
|
|
const release = JSON.parse(fs.readFileSync(new URL('../../refactor/baselines/danmuku-release.json', import.meta.url), 'utf8')).release
|
|
const member = `package/${release.manifest.main.replace(/^\.\//u, '')}`
|
|
const published = readMember(await ensureArchive(release), member)
|
|
assert.equal(hash(published), release.files[member])
|
|
implementations.set('published', published.toString())
|
|
const candidate = await browserCandidate('artplayer-plugin-danmuku', process.env.ARTPLAYER_DANMUKU_ARTIFACT)
|
|
provenance = candidate.provenance
|
|
implementations.set('candidate', candidate.code)
|
|
})
|
|
|
|
for (const core of ['published', 'candidate']) {
|
|
for (const implementation of ['published', 'candidate']) {
|
|
for (const rate of [2, 20]) {
|
|
test(`${core} core / ${implementation}: ${rate} rows per second across three native playback cycles`, async ({ page }, testInfo) => {
|
|
// Three 14-second media cycles plus setup/teardown; this is a bounded soak,
|
|
// not the ordinary short browser test deadline or a synthetic clock jump.
|
|
test.setTimeout(90000)
|
|
await page.goto(`/test/player.html?core=${core}`)
|
|
const code = implementations.get(implementation)
|
|
await testInfo.attach('danmuku-selected-input', { contentType: 'application/json', body: JSON.stringify({ implementation, provenance: implementation === 'candidate' ? provenance : { kind: 'published', sha256: hash(code) } }) })
|
|
await page.addScriptTag({ content: code })
|
|
await page.evaluate(() => window.createPlayer('/assets/sample/video.mp4'))
|
|
await page.click('#play')
|
|
await expect.poll(() => page.evaluate(() => window.art.currentTime)).toBeGreaterThan(0.1)
|
|
await page.click('#pause')
|
|
await page.evaluate(() => {
|
|
const art = window.art
|
|
const evidence = window.stabilityEvidence = { workers: [], frames: [], samples: [], visible: [], recycled: [], callbacks: [], cycles: [], errors: [], allocations: 0, reuses: 0, bypassedPool: 0 }
|
|
const NativeWorker = window.Worker
|
|
window.Worker = class extends NativeWorker {
|
|
constructor(...args) {
|
|
super(...args)
|
|
this.record = { posts: 0, replies: 0, terminated: 0, errors: [] }
|
|
evidence.workers.push(this.record)
|
|
this.addEventListener('message', () => this.record.replies++)
|
|
this.addEventListener('error', event => this.record.errors.push(event.message))
|
|
}
|
|
|
|
postMessage(...args) {
|
|
this.record.posts++
|
|
return super.postMessage(...args)
|
|
}
|
|
|
|
terminate() {
|
|
this.record.terminated++
|
|
return super.terminate()
|
|
}
|
|
}
|
|
art.on('artplayerPluginDanmuku:error', error => evidence.errors.push(String(error)))
|
|
art.on('artplayerPluginDanmuku:visible', row => evidence.visible.push({ id: row.id, time: art.currentTime, wall: performance.now() }))
|
|
art.plugins.add(window.artplayerPluginDanmuku({
|
|
danmuku: [],
|
|
heatmap: false,
|
|
emitter: false,
|
|
speed: 1,
|
|
antiOverlap: false,
|
|
beforeVisible(row) {
|
|
evidence.callbacks.push({ id: row.id, time: art.currentTime })
|
|
return true
|
|
},
|
|
}))
|
|
const owner = window.stabilityOwner = art.plugins.artplayerPluginDanmuku.config({})
|
|
const acquire = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(owner), '$ref').get
|
|
const acquired = new WeakSet()
|
|
Object.defineProperty(owner, '$ref', { configurable: true, get() {
|
|
const available = new Set(this.$refs)
|
|
const ref = acquire.call(this)
|
|
if (available.size && !available.has(ref))
|
|
evidence.bypassedPool++
|
|
if (acquired.has(ref))
|
|
evidence.reuses++
|
|
else evidence.allocations++
|
|
acquired.add(ref)
|
|
return ref
|
|
} })
|
|
const getter = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(owner), 'readys').get
|
|
Object.defineProperty(owner, 'readys', { configurable: true, get() {
|
|
const rows = getter.call(this)
|
|
evidence.samples.push({ time: art.currentTime, wall: performance.now(), ids: rows.map(row => row.id) })
|
|
return rows
|
|
} })
|
|
const makeWait = owner.makeWait.bind(owner)
|
|
owner.makeWait = (row) => {
|
|
if (row.$state === 'emit')
|
|
evidence.recycled.push({ id: row.id, time: art.currentTime })
|
|
return makeWait(row)
|
|
}
|
|
const frame = (wall) => {
|
|
if (art.playing)
|
|
evidence.frames.push({ wall, time: art.currentTime })
|
|
window.stabilityFrame = requestAnimationFrame(frame)
|
|
}
|
|
window.stabilityFrame = requestAnimationFrame(frame)
|
|
})
|
|
try {
|
|
for (let cycle = 0; cycle < 3; cycle++) {
|
|
await page.evaluate(async ({ cycle, rate }) => {
|
|
const art = window.art
|
|
const base = art.currentTime
|
|
const rows = Array.from({ length: 12 * rate }, (_, index) => ({ id: `${cycle}-${index}`, text: `Row ${index}`, time: base + 0.5 + index / rate, mode: index % 3 }))
|
|
await art.plugins.artplayerPluginDanmuku.load(rows)
|
|
window.stabilityEnd = base + 14
|
|
window.stabilityEvidence.cycles.push({ cycle, base, rows: rows.map(row => ({ id: row.id, time: row.time })), startWall: performance.now() })
|
|
}, { cycle, rate })
|
|
await page.click('#play')
|
|
await expect.poll(() => page.evaluate(() => window.art.currentTime >= window.stabilityEnd), { timeout: 22000 }).toBe(true)
|
|
await page.click('#pause')
|
|
const snapshot = await page.evaluate(() => {
|
|
const owner = window.stabilityOwner
|
|
const record = window.stabilityEvidence.cycles.at(-1)
|
|
const ids = new Set(record.rows.map(row => row.id))
|
|
const visible = window.stabilityEvidence.visible.filter(row => ids.has(row.id))
|
|
const sampled = new Set(window.stabilityEvidence.samples.flatMap(sample => sample.ids).filter(id => ids.has(id)))
|
|
const shown = new Set(visible.map(row => row.id))
|
|
const refs = owner.queue.map(row => row.$ref).filter(Boolean)
|
|
const queue = new Set(owner.queue)
|
|
const members = Object.values(owner.states).flat()
|
|
const memory = performance.memory
|
|
Object.assign(record, {
|
|
endWall: performance.now(),
|
|
time: window.art.currentTime,
|
|
decodedWidth: window.art.video.videoWidth,
|
|
visibleCount: visible.length,
|
|
uniqueVisible: shown.size,
|
|
missedSampling: record.rows.filter(row => !sampled.has(row.id)).map(row => row.id),
|
|
sampledNotVisible: record.rows.filter(row => sampled.has(row.id) && !shown.has(row.id)).map(row => row.id),
|
|
queue: owner.queue.length,
|
|
states: Object.fromEntries(Object.entries(owner.states).map(([state, rows]) => [state, rows.length])),
|
|
nodes: owner.$danmuku.children.length,
|
|
pooled: owner.$refs.length,
|
|
uniquePool: new Set(owner.$refs).size,
|
|
referenced: refs.length,
|
|
distinctReferences: new Set(refs).size,
|
|
uniqueStateMembers: new Set(members).size,
|
|
validStateMembers: Object.entries(owner.states).every(([state, rows]) => rows.every(row => queue.has(row) && row.$state === state)),
|
|
heap: memory ? { used: memory.usedJSHeapSize, total: memory.totalJSHeapSize } : null,
|
|
})
|
|
return record
|
|
})
|
|
expect(snapshot.decodedWidth).toBeGreaterThan(0)
|
|
expect(snapshot.time - snapshot.base).toBeGreaterThanOrEqual(14)
|
|
// load(rows) appends by public contract; old rows stay in the queue.
|
|
expect(snapshot.queue).toBe((cycle + 1) * 12 * rate)
|
|
expect(Object.values(snapshot.states).reduce((sum, count) => sum + count, 0)).toBe(snapshot.queue)
|
|
if (implementation === 'candidate') {
|
|
expect(snapshot.missedSampling).toEqual([])
|
|
expect(snapshot.sampledNotVisible).toEqual([])
|
|
expect(snapshot.visibleCount).toBe(12 * rate)
|
|
expect(snapshot.uniqueVisible).toBe(12 * rate)
|
|
expect(snapshot.referenced).toBe(0)
|
|
expect(snapshot.uniquePool).toBe(snapshot.pooled)
|
|
expect(snapshot.nodes).toBe(snapshot.pooled)
|
|
expect(snapshot.uniqueStateMembers).toBe(snapshot.queue)
|
|
expect(snapshot.validStateMembers).toBe(true)
|
|
}
|
|
}
|
|
}
|
|
finally {
|
|
const evidence = await page.evaluate(() => {
|
|
cancelAnimationFrame(window.stabilityFrame)
|
|
window.art.destroy()
|
|
return { ...window.stabilityEvidence, destroyed: window.art.isDestroy, retainedPlayerRoots: document.querySelectorAll('.art-video-player').length }
|
|
})
|
|
await testInfo.attach('danmuku-stability-observation', { contentType: 'application/json', body: JSON.stringify({ core, implementation, rate, sha256: hash(code), evidence, scope: 'Three bounded real media cycles; published defects are observed, candidate delivery and resource ownership are asserted. Optional unforced heap readings are not leak proof or comparable across engines.' }) })
|
|
expect(evidence.destroyed).toBe(true)
|
|
expect(evidence.retainedPlayerRoots).toBe(0)
|
|
expect(evidence.errors).toEqual([])
|
|
expect(evidence.workers).toHaveLength(1)
|
|
if (implementation === 'candidate' && evidence.cycles.length === 3) {
|
|
const expected = evidence.cycles.flatMap(cycle => cycle.rows.map(row => row.id)).sort()
|
|
expect(evidence.visible.map(row => row.id).sort()).toEqual(expected)
|
|
expect(evidence.recycled.map(row => row.id).sort()).toEqual(expected)
|
|
expect(evidence.bypassedPool).toBe(0)
|
|
expect(evidence.reuses).toBeGreaterThan(0)
|
|
expect(evidence.allocations + evidence.reuses).toBe(expected.length)
|
|
expect(evidence.cycles.at(-1).nodes).toBe(evidence.allocations)
|
|
}
|
|
for (const worker of evidence.workers) {
|
|
expect(worker.terminated).toBe(1)
|
|
expect(worker.errors).toEqual([])
|
|
if (implementation === 'candidate')
|
|
expect(worker.posts).toBe(worker.replies)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}
|