mirror of
https://github.com/servo/servo.git
synced 2025-07-13 02:13:40 +01:00
145 lines
5.2 KiB
HTML
145 lines
5.2 KiB
HTML
<!DOCTYPE html>
|
|
<html>
|
|
<head>
|
|
<title>
|
|
Test AudioContext.suspend() and AudioContext.resume()
|
|
</title>
|
|
<script src="/resources/testharness.js"></script>
|
|
<script src="/resources/testharnessreport.js"></script>
|
|
<script src="/webaudio/resources/audit-util.js"></script>
|
|
<script src="/webaudio/resources/audit.js"></script>
|
|
</head>
|
|
<body>
|
|
<script id="layout-test-code">
|
|
let offlineContext;
|
|
let osc;
|
|
let p1;
|
|
let p2;
|
|
let p3;
|
|
|
|
let sampleRate = 44100;
|
|
let durationInSeconds = 1;
|
|
|
|
let audit = Audit.createTaskRunner();
|
|
|
|
// Task: test suspend().
|
|
audit.define(
|
|
{
|
|
label: 'test-suspend',
|
|
description: 'Test suspend() for offline context'
|
|
},
|
|
function(task, should) {
|
|
// Test suspend/resume. Ideally this test is best with a online
|
|
// AudioContext, but content shell doesn't really have a working
|
|
// online AudioContext. Hence, use an OfflineAudioContext. Not all
|
|
// possible scenarios can be easily checked with an offline context
|
|
// instead of an online context.
|
|
|
|
// Create an audio context with an oscillator.
|
|
should(
|
|
() => {
|
|
offlineContext = new OfflineAudioContext(
|
|
1, durationInSeconds * sampleRate, sampleRate);
|
|
},
|
|
'offlineContext = new OfflineAudioContext(1, ' +
|
|
(durationInSeconds * sampleRate) + ', ' + sampleRate + ')')
|
|
.notThrow();
|
|
osc = offlineContext.createOscillator();
|
|
osc.connect(offlineContext.destination);
|
|
|
|
// Verify the state.
|
|
should(offlineContext.state, 'offlineContext.state')
|
|
.beEqualTo('suspended');
|
|
|
|
// Multiple calls to suspend() should not be a problem. But we can't
|
|
// test that on an offline context. Thus, check that suspend() on
|
|
// an OfflineAudioContext rejects the promise.
|
|
should(
|
|
() => p1 = offlineContext.suspend(),
|
|
'p1 = offlineContext.suspend()')
|
|
.notThrow();
|
|
should(p1 instanceof Promise, 'p1 instanceof Promise').beTrue();
|
|
|
|
should(p1, 'p1').beRejected().then(task.done.bind(task));
|
|
});
|
|
|
|
|
|
// Task: test resume().
|
|
audit.define(
|
|
{
|
|
label: 'test-resume',
|
|
description: 'Test resume() for offline context'
|
|
},
|
|
function(task, should) {
|
|
// Multiple calls to resume should not be a problem. But we can't
|
|
// test that on an offline context. Thus, check that resume() on an
|
|
// OfflineAudioContext rejects the promise.
|
|
should(
|
|
() => p2 = offlineContext.resume(),
|
|
'p2 = offlineContext.resume()')
|
|
.notThrow();
|
|
should(p2 instanceof Promise, 'p2 instanceof Promise').beTrue();
|
|
|
|
// Resume doesn't actually resume an offline context
|
|
should(offlineContext.state, 'After resume, offlineContext.state')
|
|
.beEqualTo('suspended');
|
|
should(p2, 'p2').beRejected().then(task.done.bind(task));
|
|
});
|
|
|
|
// Task: test the state after context closed.
|
|
audit.define(
|
|
{
|
|
label: 'test-after-close',
|
|
description: 'Test state after context closed'
|
|
},
|
|
function(task, should) {
|
|
// Render the offline context.
|
|
osc.start();
|
|
|
|
// Test suspend/resume in tested promise pattern. We don't care
|
|
// about the actual result of the offline rendering.
|
|
should(
|
|
() => p3 = offlineContext.startRendering(),
|
|
'p3 = offlineContext.startRendering()')
|
|
.notThrow();
|
|
|
|
p3.then(() => {
|
|
should(offlineContext.state, 'After close, offlineContext.state')
|
|
.beEqualTo('closed');
|
|
|
|
// suspend() should be rejected on a closed context.
|
|
should(offlineContext.suspend(), 'offlineContext.suspend()')
|
|
.beRejected()
|
|
.then(() => {
|
|
// resume() should be rejected on closed context.
|
|
should(offlineContext.resume(), 'offlineContext.resume()')
|
|
.beRejected()
|
|
.then(task.done.bind(task));
|
|
})
|
|
});
|
|
});
|
|
|
|
audit.define(
|
|
{
|
|
label: 'resume-running-context',
|
|
description: 'Test resuming a running context'
|
|
},
|
|
(task, should) => {
|
|
let context;
|
|
should(() => context = new AudioContext(), 'Create online context')
|
|
.notThrow();
|
|
|
|
should(context.state, 'context.state').beEqualTo('running');
|
|
should(context.resume(), 'context.resume')
|
|
.beResolved()
|
|
.then(() => {
|
|
should(context.state, 'context.state after resume')
|
|
.beEqualTo('running');
|
|
})
|
|
.then(() => task.done());
|
|
});
|
|
|
|
audit.run();
|
|
</script>
|
|
</body>
|
|
</html>
|