ctor-audiobuffersource.html

Enable keyboard shortcuts

This WPT test may be referenced by the following Test IDs:
- /webaudio/the-audio-api/the-audiobuffersourcenode-interface/ctor-audiobuffersource.html - WPT Dashboard Interop Dashboard

<!DOCTYPE html>

<html>

  <head>

    <title>

      Test Constructor: AudioBufferSource

    </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>

    <script src="/webaudio/resources/audionodeoptions.js"></script>

  </head>

  <body>

    <script id="layout-test-code">

      let context;

      let audit = Audit.createTaskRunner();

      audit.define('initialize', (task, should) => {

        context = initializeContext(should);

        task.done();

});

      audit.define('invalid constructor', (task, should) => {

        testInvalidConstructor(should, 'AudioBufferSourceNode', context);

        task.done();

});

      audit.define('default constructor', (task, should) => {

        let prefix = 'node0';

        let node =

            testDefaultConstructor(should, 'AudioBufferSourceNode', context, {

              prefix: prefix,

              numberOfInputs: 0,

              numberOfOutputs: 1,

              channelCount: 2,

              channelCountMode: 'max',

              channelInterpretation: 'speakers'

});

        testDefaultAttributes(should, node, prefix, [

          {name: 'buffer', value: null},

          {name: 'detune', value: 0},

          {name: 'loop', value: false},

          {name: 'loopEnd', value: 0.0},

          {name: 'loopStart', value: 0.0},

          {name: 'playbackRate', value: 1.0},

]);

        task.done();

});

      audit.define('nullable buffer', (task, should) => {

        let node;

        let options = {buffer: null};

        should(

            () => {

              node = new AudioBufferSourceNode(context, options);

},

            'node1 = new AudioBufferSourceNode(c, ' + JSON.stringify(options))

            .notThrow();

        should(node.buffer, 'node1.buffer').beEqualTo(null);

        task.done();

});

      audit.define('constructor options', (task, should) => {

        let node;

        let buffer = context.createBuffer(2, 1000, context.sampleRate);

        let options = {

          buffer: buffer,

          detune: .5,

          loop: true,

          loopEnd: (buffer.length / 2) / context.sampleRate,

          loopStart: 5 / context.sampleRate,

          playbackRate: .75

};

        let message = 'node = new AudioBufferSourceNode(c, ' +

            JSON.stringify(options) + ')';

        should(() => {

          node = new AudioBufferSourceNode(context, options);

        }, message).notThrow();

        // Use the factory method to create an equivalent node and compare the

        // results from the constructor against this node.

        let factoryNode = context.createBufferSource();

        factoryNode.buffer = options.buffer;

        factoryNode.detune.value = options.detune;

        factoryNode.loop = options.loop;

        factoryNode.loopEnd = options.loopEnd;

        factoryNode.loopStart = options.loopStart;

        factoryNode.playbackRate.value = options.playbackRate;

        should(node.buffer === buffer, 'node2.buffer === buffer')

            .beEqualTo(true);

        should(node.detune.value, 'node2.detune.value')

            .beEqualTo(factoryNode.detune.value);

        should(node.loop, 'node2.loop').beEqualTo(factoryNode.loop);

        should(node.loopEnd, 'node2.loopEnd').beEqualTo(factoryNode.loopEnd);

        should(node.loopStart, 'node2.loopStart')

            .beEqualTo(factoryNode.loopStart);

        should(node.playbackRate.value, 'node2.playbackRate.value')

            .beEqualTo(factoryNode.playbackRate.value);

        task.done();

});

      audit.run();

    </script>

  </body>

</html>