From 6bf0a5cb5034a7e684dcc3500e841785237ce2dd Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Sun, 7 Apr 2024 19:32:43 +0200
Subject: Adding upstream version 1:115.7.0.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 testing/web-platform/tests/webaudio/META.yml       |    4 +
 testing/web-platform/tests/webaudio/README.md      |    5 +
 .../web-platform/tests/webaudio/historical.html    |   29 +
 .../tests/webaudio/idlharness.https.window.js      |   72 +
 .../tests/webaudio/js/buffer-loader.js             |   44 +
 testing/web-platform/tests/webaudio/js/helpers.js  |  250 ++++
 .../tests/webaudio/js/worklet-recorder.js          |   55 +
 .../tests/webaudio/resources/4ch-440.wav           |  Bin 0 -> 353022 bytes
 .../tests/webaudio/resources/audio-param.js        |   44 +
 .../resources/audiobuffersource-testing.js         |  102 ++
 .../tests/webaudio/resources/audionodeoptions.js   |  292 ++++
 .../tests/webaudio/resources/audioparam-testing.js |  554 ++++++++
 .../tests/webaudio/resources/audit-util.js         |  195 +++
 .../web-platform/tests/webaudio/resources/audit.js | 1445 ++++++++++++++++++++
 .../tests/webaudio/resources/biquad-filters.js     |  376 +++++
 .../tests/webaudio/resources/biquad-testing.js     |  172 +++
 .../webaudio/resources/convolution-testing.js      |  168 +++
 .../tests/webaudio/resources/delay-testing.js      |   66 +
 .../webaudio/resources/distance-model-testing.js   |  196 +++
 .../tests/webaudio/resources/merger-testing.js     |   24 +
 .../tests/webaudio/resources/mix-testing.js        |   23 +
 .../tests/webaudio/resources/mixing-rules.js       |  350 +++++
 .../webaudio/resources/note-grain-on-testing.js    |  165 +++
 .../tests/webaudio/resources/panner-formulas.js    |  190 +++
 .../webaudio/resources/panner-model-testing.js     |  184 +++
 .../webaudio/resources/sin_440Hz_-6dBFS_1s.wav     |  Bin 0 -> 88246 bytes
 .../webaudio/resources/start-stop-exceptions.js    |   45 +
 .../webaudio/resources/stereopanner-testing.js     |  205 +++
 .../processing-model/cycle-without-delay.html      |   36 +
 .../processing-model/delay-time-clamping.html      |   43 +
 .../processing-model/feedback-delay-time.html      |   42 +
 .../the-analysernode-interface/ctor-analyser.html  |  183 +++
 .../realtimeanalyser-basic.html                    |   57 +
 .../realtimeanalyser-fft-scaling.html              |  111 ++
 .../realtimeanalyser-fft-sizing.html               |   54 +
 .../test-analyser-gain.html                        |   50 +
 .../test-analyser-minimum.html                     |   43 +
 .../test-analyser-output.html                      |   44 +
 .../test-analyser-scale.html                       |   51 +
 .../test-analysernode.html                         |  237 ++++
 .../acquire-the-content.html                       |   85 ++
 .../audiobuffer-copy-channel.html                  |  330 +++++
 .../audiobuffer-getChannelData.html                |   66 +
 .../audiobuffer-reuse.html                         |   36 +
 .../the-audiobuffer-interface/audiobuffer.html     |   71 +
 .../crashtests/copyFromChannel-bufferOffset-1.html |   11 +
 .../crashtests/copyToChannel-bufferOffset-1.html   |   10 +
 .../ctor-audiobuffer.html                          |  236 ++++
 .../active-processing.https.html                   |  100 ++
 .../audiobuffersource-basic.html                   |   37 +
 .../audiobuffersource-channels.html                |   97 ++
 .../audiobuffersource-duration-loop.html           |   52 +
 .../audiobuffersource-ended.html                   |   40 +
 .../audiobuffersource-grain.html                   |   71 +
 .../audiobuffersource-multi-channels.html          |   78 ++
 .../audiobuffersource-null.html                    |   59 +
 .../audiobuffersource-one-sample-loop.html         |   47 +
 .../audiobuffersource-playbackrate-zero.html       |  116 ++
 .../audiobuffersource-start.html                   |  174 +++
 .../audiosource-onended.html                       |  101 ++
 .../audiosource-time-limits.html                   |   74 +
 .../buffer-resampling.html                         |  101 ++
 .../ctor-audiobuffersource.html                    |  116 ++
 .../note-grain-on-play.html                        |  121 ++
 .../note-grain-on-timing.html                      |   47 +
 .../audiobuffersource-multi-channels-expected.wav  |  Bin 0 -> 529244 bytes
 .../sample-accurate-scheduling.html                |  110 ++
 .../sub-sample-buffer-stitching.html               |  133 ++
 .../sub-sample-scheduling.html                     |  423 ++++++
 .../audiocontext-detached-execution-context.html   |   31 +
 ...udiocontext-getoutputtimestamp-cross-realm.html |   32 +
 .../audiocontext-getoutputtimestamp.html           |   33 +
 .../audiocontext-not-fully-active.html             |   94 ++
 .../audiocontext-sinkid-constructor.https.html     |  122 ++
 .../audiocontext-sinkid-setsinkid.https.html       |  122 ++
 .../audiocontext-sinkid-state-change.https.html    |   83 ++
 .../audiocontext-suspend-resume-close.html         |  406 ++++++
 .../audiocontext-suspend-resume.html               |  145 ++
 .../audiocontextoptions.html                       |  215 +++
 .../constructor-allowed-to-start.html              |   25 +
 .../crashtests/currentTime-after-discard.html      |   14 +
 .../processing-after-resume.https.html             |   55 +
 .../promise-methods-after-discard.html             |   28 +
 .../resources/not-fully-active-helper.sub.html     |   22 +
 .../suspend-after-construct.html                   |   72 +
 .../suspend-with-navigation.html                   |   65 +
 .../audionode-channel-rules.html                   |  278 ++++
 .../audionode-connect-method-chaining.html         |  165 +++
 .../audionode-connect-order.html                   |   77 ++
 .../audionode-connect-return-value.html            |   15 +
 .../audionode-disconnect-audioparam.html           |  221 +++
 .../audionode-disconnect.html                      |  298 ++++
 .../audionode-iframe.window.js                     |   14 +
 .../the-audionode-interface/audionode.html         |   93 ++
 .../channel-mode-interp-basic.html                 |   66 +
 .../different-contexts.html                        |  101 ++
 .../the-audioparam-interface/adding-events.html    |  144 ++
 .../audioparam-cancel-and-hold.html                |  855 ++++++++++++
 .../the-audioparam-interface/audioparam-close.html |  161 +++
 .../audioparam-connect-audioratesignal.html        |  103 ++
 .../audioparam-exceptional-values.html             |  240 ++++
 .../audioparam-exponentialRampToValueAtTime.html   |   63 +
 .../audioparam-large-endtime.html                  |   73 +
 .../audioparam-linearRampToValueAtTime.html        |   60 +
 .../audioparam-method-chaining.html                |  143 ++
 .../audioparam-nominal-range.html                  |  497 +++++++
 .../audioparam-setTargetAtTime.html                |   61 +
 .../audioparam-setValueAtTime.html                 |   57 +
 .../audioparam-setValueCurve-exceptions.html       |  426 ++++++
 .../audioparam-setValueCurveAtTime.html            |   71 +
 .../audioparam-summingjunction.html                |  120 ++
 .../automation-rate-testing.js                     |  155 +++
 .../the-audioparam-interface/automation-rate.html  |  167 +++
 .../cancel-scheduled-values.html                   |  155 +++
 .../the-audioparam-interface/event-insertion.html  |  411 ++++++
 .../k-rate-audiobuffersource-connections.html      |  164 +++
 .../k-rate-audioworklet-connections.https.html     |   77 ++
 .../k-rate-audioworklet.https.html                 |   79 ++
 .../k-rate-biquad-connection.html                  |  456 ++++++
 .../the-audioparam-interface/k-rate-biquad.html    |  111 ++
 .../k-rate-connections.html                        |  139 ++
 .../k-rate-constant-source.html                    |  176 +++
 .../k-rate-delay-connections.html                  |  156 +++
 .../the-audioparam-interface/k-rate-delay.html     |   49 +
 .../k-rate-dynamics-compressor-connections.html    |  145 ++
 .../the-audioparam-interface/k-rate-gain.html      |   47 +
 .../k-rate-oscillator-connections.html             |  578 ++++++++
 .../k-rate-oscillator.html                         |   88 ++
 .../k-rate-panner-connections.html                 |  238 ++++
 .../the-audioparam-interface/k-rate-panner.html    |  178 +++
 .../k-rate-stereo-panner.html                      |   48 +
 .../the-audioparam-interface/nan-param.html        |   92 ++
 ...retrospective-exponentialRampToValueAtTime.html |   70 +
 .../retrospective-linearRampToValueAtTime.html     |   70 +
 .../retrospective-setTargetAtTime.html             |   80 ++
 .../retrospective-setValueAtTime.html              |   74 +
 .../retrospective-setValueCurveAtTime.html         |   67 +
 .../the-audioparam-interface/retrospective-test.js |   29 +
 .../the-audioparam-interface/set-target-conv.html  |   93 ++
 .../setTargetAtTime-after-event-within-block.html  |   54 +
 .../setValueAtTime-within-block.html               |   48 +
 .../audioworklet-addmodule-resolution.https.html   |   61 +
 .../audioworklet-audioparam-iterable.https.html    |  205 +++
 .../audioworklet-audioparam-size.https.html        |   96 ++
 .../audioworklet-audioparam.https.html             |   85 ++
 .../audioworklet-messageport.https.html            |   66 +
 ...orklet-postmessage-sharedarraybuffer.https.html |   76 +
 ...ostmessage-sharedarraybuffer.https.html.headers |    2 +
 ...gisterprocessor-called-on-globalthis.https.html |   29 +
 ...dioworklet-registerprocessor-dynamic.https.html |   36 +
 .../audioworklet-suspend.https.html                |   39 +
 .../audioworklet-throw-onmessage.https.html        |   62 +
 .../audioworkletglobalscope-sample-rate.https.html |   44 +
 .../audioworkletglobalscope-timing-info.https.html |   59 +
 .../audioworkletnode-automatic-pull.https.html     |   73 +
 .../audioworkletnode-channel-count.https.html      |   77 ++
 .../audioworkletnode-construction.https.html       |   53 +
 ...audioworkletnode-constructor-options.https.html |  149 ++
 .../audioworkletnode-disconnected-input.https.html |  100 ++
 .../audioworkletnode-onerror.https.html            |   58 +
 ...udioworkletnode-output-channel-count.https.html |   80 ++
 .../audioworkletprocessor-options.https.html       |   77 ++
 ...letprocessor-param-getter-overridden.https.html |   59 +
 ...orkletprocessor-process-frozen-array.https.html |   53 +
 ...orkletprocessor-process-zero-outputs.https.html |   36 +
 .../audioworkletprocessor-promises.https.html      |   44 +
 .../baseaudiocontext-audioworklet.https.html       |   30 +
 ...ded-audioworkletnode-with-parameters.https.html |   16 +
 .../process-getter.https.html                      |   23 +
 .../process-parameters.https.html                  |   87 ++
 .../processor-construction-port.https.html         |   61 +
 .../processors/active-processing.js                |   54 +
 .../processors/add-offset.js                       |   34 +
 .../processors/array-check-processor.js            |   94 ++
 .../processors/channel-count-processor.js          |   19 +
 .../processors/construction-port-new-after-new.js  |   16 +
 .../construction-port-new-after-super.js           |   15 +
 .../processors/construction-port-singleton.js      |   16 +
 .../construction-port-super-after-new.js           |   16 +
 .../processors/dummy-processor-globalthis.js       |   12 +
 .../processors/dummy-processor.js                  |   18 +
 .../processors/dynamic-register-processor.js       |   22 +
 .../processors/error-processor.js                  |   40 +
 .../processors/gain-processor.js                   |   38 +
 .../processors/input-count-processor.js            |   22 +
 .../processors/input-length-processor.js           |   27 +
 .../processors/invalid-param-array-processor.js    |   47 +
 .../processors/one-pole-processor.js               |   49 +
 .../processors/option-test-processor.js            |   19 +
 .../processors/param-size-processor.js             |   30 +
 .../processors/port-processor.js                   |   34 +
 .../process-getter-test-instance-processor.js      |   44 +
 .../process-getter-test-prototype-processor.js     |   55 +
 .../processors/process-parameter-test-processor.js |   18 +
 .../processors/promise-processor.js                |   40 +
 .../processors/sharedarraybuffer-processor.js      |   35 +
 .../processors/timing-info-processor.js            |   25 +
 .../processors/zero-output-processor.js            |   42 +
 .../processors/zero-outputs-check-processor.js     |   78 ++
 .../simple-input-output.https.html                 |   90 ++
 .../suspended-context-messageport.https.html       |   51 +
 .../biquad-allpass.html                            |   42 +
 .../biquad-automation.html                         |  406 ++++++
 .../biquad-bandpass.html                           |   44 +
 .../biquad-basic.html                              |  134 ++
 .../biquad-getFrequencyResponse.html               |  394 ++++++
 .../biquad-highpass.html                           |   42 +
 .../biquad-highshelf.html                          |   43 +
 .../biquad-lowpass.html                            |   45 +
 .../biquad-lowshelf.html                           |   43 +
 .../biquad-notch.html                              |   43 +
 .../biquad-peaking.html                            |   46 +
 .../biquad-tail.html                               |   71 +
 .../biquadfilternode-basic.html                    |   64 +
 .../ctor-biquadfilter.html                         |   86 ++
 .../no-dezippering.html                            |  288 ++++
 .../active-processing.https.html                   |   93 ++
 .../audiochannelmerger-basic.html                  |   67 +
 .../audiochannelmerger-disconnect.html             |   82 ++
 .../audiochannelmerger-input-non-default.html      |   79 ++
 .../audiochannelmerger-input.html                  |  113 ++
 .../ctor-channelmerger.html                        |  112 ++
 .../audiochannelsplitter.html                      |  141 ++
 .../ctor-channelsplitter.html                      |  115 ++
 .../constant-source-basic.html                     |   85 ++
 .../constant-source-onended.html                   |   38 +
 .../constant-source-output.html                    |  207 +++
 .../ctor-constantsource.html                       |   50 +
 .../test-constantsourcenode.html                   |  135 ++
 .../active-processing.https.html                   |   93 ++
 .../convolution-mono-mono.html                     |   62 +
 .../convolver-cascade.html                         |   61 +
 .../convolver-channels.html                        |   43 +
 .../convolver-response-1-chan.html                 |  406 ++++++
 .../convolver-response-2-chan.html                 |  373 +++++
 .../convolver-response-4-chan.html                 |  508 +++++++
 .../convolver-setBuffer-already-has-value.html     |   51 +
 .../convolver-setBuffer-null.html                  |   31 +
 .../convolver-upmixing-1-channel-response.html     |  143 ++
 .../ctor-convolver.html                            |  186 +++
 .../the-convolvernode-interface/realtime-conv.html |  149 ++
 .../transferred-buffer-output.html                 |  107 ++
 .../the-delaynode-interface/ctor-delay.html        |   76 +
 .../the-delaynode-interface/delay-test.html        |   61 +
 .../delaynode-channel-count-1.html                 |  104 ++
 .../delaynode-max-default-delay.html               |   49 +
 .../delaynode-max-nondefault-delay.html            |   51 +
 .../delaynode-maxdelay.html                        |   54 +
 .../delaynode-maxdelaylimit.html                   |   68 +
 .../delaynode-scheduling.html                      |   51 +
 .../the-delaynode-interface/delaynode.html         |   61 +
 .../the-delaynode-interface/maxdelay-rounding.html |   78 ++
 .../the-delaynode-interface/no-dezippering.html    |  184 +++
 .../the-destinationnode-interface/destination.html |   51 +
 .../ctor-dynamicscompressor.html                   |  199 +++
 .../dynamicscompressor-basic.html                  |   48 +
 .../the-gainnode-interface/ctor-gain.html          |   79 ++
 .../the-gainnode-interface/gain-basic.html         |   37 +
 .../the-audio-api/the-gainnode-interface/gain.html |  162 +++
 .../the-gainnode-interface/no-dezippering.html     |  121 ++
 .../ctor-iirfilter.html                            |  126 ++
 .../iirfilter-basic.html                           |  204 +++
 .../iirfilter-getFrequencyResponse.html            |  159 +++
 .../the-iirfilternode-interface/iirfilter.html     |  572 ++++++++
 .../test-iirfilternode.html                        |   59 +
 .../cors-check.https.html                          |   76 +
 ...diaElementAudioSourceToScriptProcessorTest.html |  130 ++
 .../no-cors.https.html                             |   75 +
 .../ctor-mediastreamaudiodestination.html          |   64 +
 .../mediastreamaudiosourcenode-ctor.html           |   73 +
 .../mediastreamaudiosourcenode-routing.html        |  127 ++
 .../ctor-offlineaudiocontext.html                  |  203 +++
 .../current-time-block-size.html                   |   17 +
 ...ineaudiocontext-detached-execution-context.html |   34 +
 .../startrendering-after-discard.html              |   24 +
 .../ctor-oscillator.html                           |  112 ++
 .../detune-limiting.html                           |  154 +++
 .../detune-overflow.html                           |   41 +
 .../osc-basic-waveform.html                        |  229 ++++
 .../automation-changes.html                        |  140 ++
 .../the-pannernode-interface/ctor-panner.html      |  468 +++++++
 .../distance-exponential.html                      |   34 +
 .../the-pannernode-interface/distance-inverse.html |   28 +
 .../the-pannernode-interface/distance-linear.html  |   30 +
 .../panner-automation-basic.html                   |  298 ++++
 .../panner-automation-equalpower-stereo.html       |   47 +
 .../panner-automation-position.html                |  265 ++++
 .../the-pannernode-interface/panner-azimuth.html   |   51 +
 .../panner-distance-clamping.html                  |  227 +++
 .../panner-equalpower-stereo.html                  |   44 +
 .../panner-equalpower.html                         |  139 ++
 .../panner-rolloff-clamping.html                   |   98 ++
 .../pannernode-basic.window.js                     |   71 +
 .../pannernode-setposition-throws.html             |   37 +
 .../test-pannernode-automation.html                |   36 +
 .../createPeriodicWaveInfiniteValuesThrows.html    |   22 +
 .../the-periodicwave-interface/periodicWave.html   |  130 ++
 .../simple-input-output.html                       |   98 ++
 .../ctor-stereopanner.html                         |  131 ++
 .../the-stereopanner-interface/no-dezippering.html |  261 ++++
 .../stereopannernode-basic.html                    |   54 +
 .../stereopannernode-panning.html                  |   34 +
 .../ctor-waveshaper.html                           |   72 +
 .../the-waveshapernode-interface/curve-tests.html  |  184 +++
 .../silent-inputs.html                             |  103 ++
 .../waveshaper-copy-curve.html                     |  100 ++
 .../waveshaper-limits.html                         |  110 ++
 .../waveshaper-simple.html                         |   61 +
 .../the-waveshapernode-interface/waveshaper.html   |  127 ++
 309 files changed, 35278 insertions(+)
 create mode 100644 testing/web-platform/tests/webaudio/META.yml
 create mode 100644 testing/web-platform/tests/webaudio/README.md
 create mode 100644 testing/web-platform/tests/webaudio/historical.html
 create mode 100644 testing/web-platform/tests/webaudio/idlharness.https.window.js
 create mode 100644 testing/web-platform/tests/webaudio/js/buffer-loader.js
 create mode 100644 testing/web-platform/tests/webaudio/js/helpers.js
 create mode 100644 testing/web-platform/tests/webaudio/js/worklet-recorder.js
 create mode 100644 testing/web-platform/tests/webaudio/resources/4ch-440.wav
 create mode 100644 testing/web-platform/tests/webaudio/resources/audio-param.js
 create mode 100644 testing/web-platform/tests/webaudio/resources/audiobuffersource-testing.js
 create mode 100644 testing/web-platform/tests/webaudio/resources/audionodeoptions.js
 create mode 100644 testing/web-platform/tests/webaudio/resources/audioparam-testing.js
 create mode 100644 testing/web-platform/tests/webaudio/resources/audit-util.js
 create mode 100644 testing/web-platform/tests/webaudio/resources/audit.js
 create mode 100644 testing/web-platform/tests/webaudio/resources/biquad-filters.js
 create mode 100644 testing/web-platform/tests/webaudio/resources/biquad-testing.js
 create mode 100644 testing/web-platform/tests/webaudio/resources/convolution-testing.js
 create mode 100644 testing/web-platform/tests/webaudio/resources/delay-testing.js
 create mode 100644 testing/web-platform/tests/webaudio/resources/distance-model-testing.js
 create mode 100644 testing/web-platform/tests/webaudio/resources/merger-testing.js
 create mode 100644 testing/web-platform/tests/webaudio/resources/mix-testing.js
 create mode 100644 testing/web-platform/tests/webaudio/resources/mixing-rules.js
 create mode 100644 testing/web-platform/tests/webaudio/resources/note-grain-on-testing.js
 create mode 100644 testing/web-platform/tests/webaudio/resources/panner-formulas.js
 create mode 100644 testing/web-platform/tests/webaudio/resources/panner-model-testing.js
 create mode 100644 testing/web-platform/tests/webaudio/resources/sin_440Hz_-6dBFS_1s.wav
 create mode 100644 testing/web-platform/tests/webaudio/resources/start-stop-exceptions.js
 create mode 100644 testing/web-platform/tests/webaudio/resources/stereopanner-testing.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/processing-model/cycle-without-delay.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/processing-model/delay-time-clamping.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/processing-model/feedback-delay-time.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/ctor-analyser.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/realtimeanalyser-basic.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/realtimeanalyser-fft-scaling.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/realtimeanalyser-fft-sizing.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/test-analyser-gain.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/test-analyser-minimum.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/test-analyser-output.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/test-analyser-scale.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/test-analysernode.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/acquire-the-content.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/audiobuffer-copy-channel.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/audiobuffer-getChannelData.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/audiobuffer-reuse.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/audiobuffer.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/crashtests/copyFromChannel-bufferOffset-1.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/crashtests/copyToChannel-bufferOffset-1.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/ctor-audiobuffer.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/active-processing.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-basic.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-channels.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-duration-loop.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-ended.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-grain.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-multi-channels.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-null.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-one-sample-loop.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-playbackrate-zero.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-start.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiosource-onended.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiosource-time-limits.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/buffer-resampling.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/ctor-audiobuffersource.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/note-grain-on-play.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/note-grain-on-timing.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/resources/audiobuffersource-multi-channels-expected.wav
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/sample-accurate-scheduling.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/sub-sample-buffer-stitching.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/sub-sample-scheduling.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-detached-execution-context.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-getoutputtimestamp-cross-realm.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-getoutputtimestamp.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-not-fully-active.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-sinkid-constructor.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-sinkid-setsinkid.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-sinkid-state-change.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-suspend-resume-close.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-suspend-resume.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontextoptions.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/constructor-allowed-to-start.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/crashtests/currentTime-after-discard.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/processing-after-resume.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/promise-methods-after-discard.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/resources/not-fully-active-helper.sub.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/suspend-after-construct.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/suspend-with-navigation.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-channel-rules.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-connect-method-chaining.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-connect-order.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-connect-return-value.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-disconnect-audioparam.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-disconnect.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-iframe.window.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/channel-mode-interp-basic.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/different-contexts.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/adding-events.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-cancel-and-hold.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-close.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-connect-audioratesignal.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-exceptional-values.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-exponentialRampToValueAtTime.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-large-endtime.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-linearRampToValueAtTime.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-method-chaining.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-nominal-range.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-setTargetAtTime.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-setValueAtTime.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-setValueCurve-exceptions.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-setValueCurveAtTime.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-summingjunction.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/automation-rate-testing.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/automation-rate.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/cancel-scheduled-values.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/event-insertion.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-audiobuffersource-connections.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-audioworklet-connections.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-audioworklet.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-biquad-connection.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-biquad.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-connections.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-constant-source.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-delay-connections.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-delay.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-dynamics-compressor-connections.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-gain.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-oscillator-connections.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-oscillator.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-panner-connections.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-panner.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-stereo-panner.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/nan-param.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/retrospective-exponentialRampToValueAtTime.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/retrospective-linearRampToValueAtTime.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/retrospective-setTargetAtTime.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/retrospective-setValueAtTime.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/retrospective-setValueCurveAtTime.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/retrospective-test.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/set-target-conv.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/setTargetAtTime-after-event-within-block.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/setValueAtTime-within-block.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-addmodule-resolution.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-audioparam-iterable.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-audioparam-size.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-audioparam.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-messageport.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-postmessage-sharedarraybuffer.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-postmessage-sharedarraybuffer.https.html.headers
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-registerprocessor-called-on-globalthis.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-registerprocessor-dynamic.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-suspend.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-throw-onmessage.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletglobalscope-sample-rate.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletglobalscope-timing-info.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-automatic-pull.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-channel-count.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-construction.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-constructor-options.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-disconnected-input.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-onerror.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-output-channel-count.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletprocessor-options.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletprocessor-param-getter-overridden.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletprocessor-process-frozen-array.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletprocessor-process-zero-outputs.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletprocessor-promises.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/baseaudiocontext-audioworklet.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/extended-audioworkletnode-with-parameters.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/process-getter.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/process-parameters.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processor-construction-port.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/active-processing.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/add-offset.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/array-check-processor.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/channel-count-processor.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/construction-port-new-after-new.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/construction-port-new-after-super.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/construction-port-singleton.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/construction-port-super-after-new.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/dummy-processor-globalthis.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/dummy-processor.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/dynamic-register-processor.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/error-processor.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/gain-processor.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/input-count-processor.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/input-length-processor.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/invalid-param-array-processor.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/one-pole-processor.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/option-test-processor.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/param-size-processor.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/port-processor.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/process-getter-test-instance-processor.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/process-getter-test-prototype-processor.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/process-parameter-test-processor.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/promise-processor.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/sharedarraybuffer-processor.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/timing-info-processor.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/zero-output-processor.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/zero-outputs-check-processor.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/simple-input-output.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/suspended-context-messageport.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-allpass.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-automation.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-bandpass.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-basic.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-getFrequencyResponse.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-highpass.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-highshelf.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-lowpass.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-lowshelf.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-notch.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-peaking.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-tail.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquadfilternode-basic.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/ctor-biquadfilter.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/no-dezippering.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-channelmergernode-interface/active-processing.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-channelmergernode-interface/audiochannelmerger-basic.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-channelmergernode-interface/audiochannelmerger-disconnect.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-channelmergernode-interface/audiochannelmerger-input-non-default.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-channelmergernode-interface/audiochannelmerger-input.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-channelmergernode-interface/ctor-channelmerger.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-channelsplitternode-interface/audiochannelsplitter.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-channelsplitternode-interface/ctor-channelsplitter.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-constantsourcenode-interface/constant-source-basic.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-constantsourcenode-interface/constant-source-onended.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-constantsourcenode-interface/constant-source-output.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-constantsourcenode-interface/ctor-constantsource.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-constantsourcenode-interface/test-constantsourcenode.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/active-processing.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolution-mono-mono.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-cascade.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-channels.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-response-1-chan.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-response-2-chan.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-response-4-chan.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-setBuffer-already-has-value.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-setBuffer-null.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-upmixing-1-channel-response.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/ctor-convolver.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/realtime-conv.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/transferred-buffer-output.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/ctor-delay.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delay-test.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode-channel-count-1.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode-max-default-delay.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode-max-nondefault-delay.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode-maxdelay.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode-maxdelaylimit.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode-scheduling.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/maxdelay-rounding.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/no-dezippering.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-destinationnode-interface/destination.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-dynamicscompressornode-interface/ctor-dynamicscompressor.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-dynamicscompressornode-interface/dynamicscompressor-basic.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-gainnode-interface/ctor-gain.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-gainnode-interface/gain-basic.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-gainnode-interface/gain.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-gainnode-interface/no-dezippering.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-iirfilternode-interface/ctor-iirfilter.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-iirfilternode-interface/iirfilter-basic.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-iirfilternode-interface/iirfilter-getFrequencyResponse.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-iirfilternode-interface/iirfilter.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-iirfilternode-interface/test-iirfilternode.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-mediaelementaudiosourcenode-interface/cors-check.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-mediaelementaudiosourcenode-interface/mediaElementAudioSourceToScriptProcessorTest.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-mediaelementaudiosourcenode-interface/no-cors.https.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-mediastreamaudiodestinationnode-interface/ctor-mediastreamaudiodestination.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-mediastreamaudiosourcenode-interface/mediastreamaudiosourcenode-ctor.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-mediastreamaudiosourcenode-interface/mediastreamaudiosourcenode-routing.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-offlineaudiocontext-interface/ctor-offlineaudiocontext.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-offlineaudiocontext-interface/current-time-block-size.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-offlineaudiocontext-interface/offlineaudiocontext-detached-execution-context.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-offlineaudiocontext-interface/startrendering-after-discard.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-oscillatornode-interface/ctor-oscillator.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-oscillatornode-interface/detune-limiting.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-oscillatornode-interface/detune-overflow.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-oscillatornode-interface/osc-basic-waveform.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/automation-changes.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/ctor-panner.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/distance-exponential.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/distance-inverse.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/distance-linear.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-automation-basic.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-automation-equalpower-stereo.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-automation-position.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-azimuth.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-distance-clamping.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-equalpower-stereo.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-equalpower.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-rolloff-clamping.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/pannernode-basic.window.js
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/pannernode-setposition-throws.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/test-pannernode-automation.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-periodicwave-interface/createPeriodicWaveInfiniteValuesThrows.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-periodicwave-interface/periodicWave.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-scriptprocessornode-interface/simple-input-output.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-stereopanner-interface/ctor-stereopanner.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-stereopanner-interface/no-dezippering.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-stereopanner-interface/stereopannernode-basic.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-stereopanner-interface/stereopannernode-panning.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/ctor-waveshaper.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/curve-tests.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/silent-inputs.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/waveshaper-copy-curve.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/waveshaper-limits.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/waveshaper-simple.html
 create mode 100644 testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/waveshaper.html

(limited to 'testing/web-platform/tests/webaudio')

diff --git a/testing/web-platform/tests/webaudio/META.yml b/testing/web-platform/tests/webaudio/META.yml
new file mode 100644
index 0000000000..3bcd1cb8d3
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/META.yml
@@ -0,0 +1,4 @@
+spec: https://webaudio.github.io/web-audio-api/
+suggested_reviewers:
+  - hoch
+  - padenot
diff --git a/testing/web-platform/tests/webaudio/README.md b/testing/web-platform/tests/webaudio/README.md
new file mode 100644
index 0000000000..bcfe291ff3
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/README.md
@@ -0,0 +1,5 @@
+Our test suite is currently tracking the [editor's draft](https://webaudio.github.io/web-audio-api/) of the Web Audio API.
+
+The tests are arranged in subdirectories, corresponding to different
+sections of the spec. So, for example, tests for the `DelayNode` are
+in `the-audio-api/the-delaynode-interface`.
diff --git a/testing/web-platform/tests/webaudio/historical.html b/testing/web-platform/tests/webaudio/historical.html
new file mode 100644
index 0000000000..1f3146c39d
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/historical.html
@@ -0,0 +1,29 @@
+<!doctype html>
+<title>Historical Web Audio API features</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+[
+  "webkitAudioContext",
+  "webkitAudioPannerNode",
+  "webkitOfflineAudioContext",
+].forEach(name => {
+  test(function() {
+    assert_false(name in window);
+  }, name + " interface should not exist");
+});
+
+[
+  "dopplerFactor",
+  "speedOfSound",
+  "setVelocity"
+].forEach(name => {
+  test(function() {
+    assert_false(name in AudioListener.prototype);
+  }, name + " member should not exist on the AudioListener.");
+});
+
+test(function() {
+  assert_false("setVelocity" in PannerNode.prototype);
+}, "setVelocity should not exist on PannerNodes.");
+</script>
diff --git a/testing/web-platform/tests/webaudio/idlharness.https.window.js b/testing/web-platform/tests/webaudio/idlharness.https.window.js
new file mode 100644
index 0000000000..e941a75c26
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/idlharness.https.window.js
@@ -0,0 +1,72 @@
+// META: script=/resources/WebIDLParser.js
+// META: script=/resources/idlharness.js
+// META: timeout=long
+
+// https://webaudio.github.io/web-audio-api/
+
+'use strict';
+
+idl_test(
+  ['webaudio'],
+  ['cssom', 'uievents', 'mediacapture-streams', 'html', 'dom'],
+  async idl_array => {
+    idl_array.add_untested_idls('interface SVGElement {};');
+
+    idl_array.add_objects({
+      BaseAudioContext: [],
+      AudioContext: ['context'],
+      OfflineAudioContext: ['new OfflineAudioContext(1, 1, sample_rate)'],
+      OfflineAudioCompletionEvent: [
+        'new OfflineAudioCompletionEvent("", {renderedBuffer: buffer})'
+      ],
+      AudioBuffer: ['buffer'],
+      AudioNode: [],
+      AudioParam: ['new AudioBufferSourceNode(context).playbackRate'],
+      AudioScheduledSourceNode: [],
+      AnalyserNode: ['new AnalyserNode(context)'],
+      AudioBufferSourceNode: ['new AudioBufferSourceNode(context)'],
+      AudioDestinationNode: ['context.destination'],
+      AudioListener: ['context.listener'],
+      AudioProcessingEvent: [`new AudioProcessingEvent('', {
+        playbackTime: 0, inputBuffer: buffer, outputBuffer: buffer
+      })`],
+      BiquadFilterNode: ['new BiquadFilterNode(context)'],
+      ChannelMergerNode: ['new ChannelMergerNode(context)'],
+      ChannelSplitterNode: ['new ChannelSplitterNode(context)'],
+      ConstantSourceNode: ['new ConstantSourceNode(context)'],
+      ConvolverNode: ['new ConvolverNode(context)'],
+      DelayNode: ['new DelayNode(context)'],
+      DynamicsCompressorNode: ['new DynamicsCompressorNode(context)'],
+      GainNode: ['new GainNode(context)'],
+      IIRFilterNode: [
+        'new IIRFilterNode(context, {feedforward: [1], feedback: [1]})'
+      ],
+      MediaElementAudioSourceNode: [
+        'new MediaElementAudioSourceNode(context, {mediaElement: new Audio})'
+      ],
+      MediaStreamAudioDestinationNode: [
+        'new MediaStreamAudioDestinationNode(context)'
+      ],
+      MediaStreamAudioSourceNode: [],
+      MediaStreamTrackAudioSourceNode: [],
+      OscillatorNode: ['new OscillatorNode(context)'],
+      PannerNode: ['new PannerNode(context)'],
+      PeriodicWave: ['new PeriodicWave(context)'],
+      ScriptProcessorNode: ['context.createScriptProcessor()'],
+      StereoPannerNode: ['new StereoPannerNode(context)'],
+      WaveShaperNode: ['new WaveShaperNode(context)'],
+      AudioWorklet: ['context.audioWorklet'],
+      AudioWorkletGlobalScope: [],
+      AudioParamMap: ['worklet_node.parameters'],
+      AudioWorkletNode: ['worklet_node'],
+      AudioWorkletProcessor: [],
+    });
+
+    self.sample_rate = 44100;
+    self.context = new AudioContext;
+    self.buffer = new AudioBuffer({length: 1, sampleRate: sample_rate});
+    await context.audioWorklet.addModule(
+      'the-audio-api/the-audioworklet-interface/processors/dummy-processor.js');
+    self.worklet_node = new AudioWorkletNode(context, 'dummy');
+  }
+);
diff --git a/testing/web-platform/tests/webaudio/js/buffer-loader.js b/testing/web-platform/tests/webaudio/js/buffer-loader.js
new file mode 100644
index 0000000000..453dc4a521
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/js/buffer-loader.js
@@ -0,0 +1,44 @@
+/* Taken from
+   https://raw.github.com/WebKit/webkit/master/LayoutTests/webaudio/resources/buffer-loader.js */
+
+function BufferLoader(context, urlList, callback) {
+  this.context = context;
+  this.urlList = urlList;
+  this.onload = callback;
+  this.bufferList = new Array();
+  this.loadCount = 0;
+}
+
+BufferLoader.prototype.loadBuffer = function(url, index) {
+  // Load buffer asynchronously
+  var request = new XMLHttpRequest();
+  request.open("GET", url, true);
+  request.responseType = "arraybuffer";
+
+  var loader = this;
+
+  request.onload = function() {
+    loader.context.decodeAudioData(request.response, decodeSuccessCallback, decodeErrorCallback);
+  };
+
+  request.onerror = function() {
+    alert('BufferLoader: XHR error');
+  };
+
+  var decodeSuccessCallback = function(buffer) {
+    loader.bufferList[index] = buffer;
+    if (++loader.loadCount == loader.urlList.length)
+      loader.onload(loader.bufferList);
+  };
+
+  var decodeErrorCallback = function() {
+    alert('decodeErrorCallback: decode error');
+  };
+
+  request.send();
+}
+
+BufferLoader.prototype.load = function() {
+  for (var i = 0; i < this.urlList.length; ++i)
+    this.loadBuffer(this.urlList[i], i);
+}
diff --git a/testing/web-platform/tests/webaudio/js/helpers.js b/testing/web-platform/tests/webaudio/js/helpers.js
new file mode 100644
index 0000000000..413c72051b
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/js/helpers.js
@@ -0,0 +1,250 @@
+/*
+  Returns an array (typed or not), of the passed array with removed trailing and ending
+  zero-valued elements
+ */
+function trimEmptyElements(array) {
+  var start = 0;
+  var end = array.length;
+
+  while (start < array.length) {
+    if (array[start] !== 0) {
+      break;
+    }
+    start++;
+  }
+
+  while (end > 0) {
+    end--;
+    if (array[end] !== 0) {
+      break;
+    }
+  }
+  return array.subarray(start, end);
+}
+
+
+function fuzzyCompare(a, b) {
+  return Math.abs(a - b) < 9e-3;
+}
+
+function compareChannels(buf1, buf2,
+                        /*optional*/ length,
+                        /*optional*/ sourceOffset,
+                        /*optional*/ destOffset,
+                        /*optional*/ skipLengthCheck) {
+  if (!skipLengthCheck) {
+    assert_equals(buf1.length, buf2.length, "Channels must have the same length");
+  }
+  sourceOffset = sourceOffset || 0;
+  destOffset = destOffset || 0;
+  if (length == undefined) {
+    length = buf1.length - sourceOffset;
+  }
+  var difference = 0;
+  var maxDifference = 0;
+  var firstBadIndex = -1;
+  for (var i = 0; i < length; ++i) {
+    if (!fuzzyCompare(buf1[i + sourceOffset], buf2[i + destOffset])) {
+      difference++;
+      maxDifference = Math.max(maxDifference, Math.abs(buf1[i + sourceOffset] - buf2[i + destOffset]));
+      if (firstBadIndex == -1) {
+        firstBadIndex = i;
+      }
+    }
+  };
+
+  assert_equals(difference, 0, "maxDifference: " + maxDifference +
+     ", first bad index: " + firstBadIndex + " with test-data offset " +
+     sourceOffset + " and expected-data offset " + destOffset +
+     "; corresponding values " + buf1[firstBadIndex + sourceOffset] + " and " +
+     buf2[firstBadIndex + destOffset] + " --- differences");
+}
+
+function compareBuffers(got, expected) {
+  if (got.numberOfChannels != expected.numberOfChannels) {
+    assert_equals(got.numberOfChannels, expected.numberOfChannels,
+                  "Correct number of buffer channels");
+    return;
+  }
+  if (got.length != expected.length) {
+    assert_equals(got.length, expected.length,
+                  "Correct buffer length");
+    return;
+  }
+  if (got.sampleRate != expected.sampleRate) {
+    assert_equals(got.sampleRate, expected.sampleRate,
+                  "Correct sample rate");
+    return;
+  }
+
+  for (var i = 0; i < got.numberOfChannels; ++i) {
+    compareChannels(got.getChannelData(i), expected.getChannelData(i),
+                    got.length, 0, 0, true);
+  }
+}
+
+/**
+ * This function assumes that the test is a "single page test" [0], and defines a
+ * single gTest variable with the following properties and methods:
+ *
+ * + numberOfChannels: optional property which specifies the number of channels
+ *                     in the output.  The default value is 2.
+ * + createGraph: mandatory method which takes a context object and does
+ *                everything needed in order to set up the Web Audio graph.
+ *                This function returns the node to be inspected.
+ * + createGraphAsync: async version of createGraph.  This function takes
+ *                     a callback which should be called with an argument
+ *                     set to the node to be inspected when the callee is
+ *                     ready to proceed with the test.  Either this function
+ *                     or createGraph must be provided.
+ * + createExpectedBuffers: optional method which takes a context object and
+ *                          returns either one expected buffer or an array of
+ *                          them, designating what is expected to be observed
+ *                          in the output.  If omitted, the output is expected
+ *                          to be silence.  All buffers must have the same
+ *                          length, which must be a bufferSize supported by
+ *                          ScriptProcessorNode.  This function is guaranteed
+ *                          to be called before createGraph.
+ * + length: property equal to the total number of frames which we are waiting
+ *           to see in the output, mandatory if createExpectedBuffers is not
+ *           provided, in which case it must be a bufferSize supported by
+ *           ScriptProcessorNode (256, 512, 1024, 2048, 4096, 8192, or 16384).
+ *           If createExpectedBuffers is provided then this must be equal to
+ *           the number of expected buffers * the expected buffer length.
+ *
+ * + skipOfflineContextTests: optional. when true, skips running tests on an offline
+ *                            context by circumventing testOnOfflineContext.
+ *
+ * [0]: https://web-platform-tests.org/writing-tests/testharness-api.html#single-page-tests
+ */
+function runTest(name)
+{
+  function runTestFunction () {
+    if (!gTest.numberOfChannels) {
+      gTest.numberOfChannels = 2; // default
+    }
+
+    var testLength;
+
+    function runTestOnContext(context, callback, testOutput) {
+      if (!gTest.createExpectedBuffers) {
+        // Assume that the output is silence
+        var expectedBuffers = getEmptyBuffer(context, gTest.length);
+      } else {
+        var expectedBuffers = gTest.createExpectedBuffers(context);
+      }
+      if (!(expectedBuffers instanceof Array)) {
+        expectedBuffers = [expectedBuffers];
+      }
+      var expectedFrames = 0;
+      for (var i = 0; i < expectedBuffers.length; ++i) {
+        assert_equals(expectedBuffers[i].numberOfChannels, gTest.numberOfChannels,
+                      "Correct number of channels for expected buffer " + i);
+        expectedFrames += expectedBuffers[i].length;
+      }
+      if (gTest.length && gTest.createExpectedBuffers) {
+        assert_equals(expectedFrames,
+                      gTest.length, "Correct number of expected frames");
+      }
+
+      if (gTest.createGraphAsync) {
+        gTest.createGraphAsync(context, function(nodeToInspect) {
+          testOutput(nodeToInspect, expectedBuffers, callback);
+        });
+      } else {
+        testOutput(gTest.createGraph(context), expectedBuffers, callback);
+      }
+    }
+
+    function testOnNormalContext(callback) {
+      function testOutput(nodeToInspect, expectedBuffers, callback) {
+        testLength = 0;
+        var sp = context.createScriptProcessor(expectedBuffers[0].length, gTest.numberOfChannels, 1);
+        nodeToInspect.connect(sp).connect(context.destination);
+        sp.onaudioprocess = function(e) {
+          var expectedBuffer = expectedBuffers.shift();
+          testLength += expectedBuffer.length;
+          compareBuffers(e.inputBuffer, expectedBuffer);
+          if (expectedBuffers.length == 0) {
+            sp.onaudioprocess = null;
+            callback();
+          }
+        };
+      }
+      var context = new AudioContext();
+      runTestOnContext(context, callback, testOutput);
+    }
+
+    function testOnOfflineContext(callback, sampleRate) {
+      function testOutput(nodeToInspect, expectedBuffers, callback) {
+        nodeToInspect.connect(context.destination);
+        context.oncomplete = function(e) {
+          var samplesSeen = 0;
+          while (expectedBuffers.length) {
+            var expectedBuffer = expectedBuffers.shift();
+            assert_equals(e.renderedBuffer.numberOfChannels, expectedBuffer.numberOfChannels,
+                          "Correct number of input buffer channels");
+            for (var i = 0; i < e.renderedBuffer.numberOfChannels; ++i) {
+              compareChannels(e.renderedBuffer.getChannelData(i),
+                             expectedBuffer.getChannelData(i),
+                             expectedBuffer.length,
+                             samplesSeen,
+                             undefined,
+                             true);
+            }
+            samplesSeen += expectedBuffer.length;
+          }
+          callback();
+        };
+        context.startRendering();
+      }
+
+      var context = new OfflineAudioContext(gTest.numberOfChannels, testLength, sampleRate);
+      runTestOnContext(context, callback, testOutput);
+    }
+
+    testOnNormalContext(function() {
+      if (!gTest.skipOfflineContextTests) {
+        testOnOfflineContext(function() {
+          testOnOfflineContext(done, 44100);
+        }, 48000);
+      } else {
+        done();
+      }
+    });
+  };
+
+  runTestFunction();
+}
+
+// Simpler than audit.js, but still logs the message. Requires
+// `setup("explicit_done": true)` if testing code that runs after the "load"
+// event.
+function equals(a, b, msg) {
+  test(function() {
+    assert_equals(a, b);
+  }, msg);
+}
+function is_true(a, msg) {
+  test(function() {
+    assert_true(a);
+  }, msg);
+}
+
+// This allows writing AudioWorkletProcessor code in the same file as the rest
+// of the test, for quick one off AudioWorkletProcessor testing.
+function URLFromScriptsElements(ids)
+{
+  var scriptTexts = [];
+  for (let id of ids) {
+
+    const e = document.querySelector("script#"+id)
+    if (!e) {
+      throw id+" is not the id of a <script> tag";
+    }
+    scriptTexts.push(e.innerText);
+  }
+  const blob = new Blob(scriptTexts, {type: "application/javascript"});
+
+  return URL.createObjectURL(blob);
+}
diff --git a/testing/web-platform/tests/webaudio/js/worklet-recorder.js b/testing/web-platform/tests/webaudio/js/worklet-recorder.js
new file mode 100644
index 0000000000..913ab742aa
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/js/worklet-recorder.js
@@ -0,0 +1,55 @@
+/**
+ * @class RecorderProcessor
+ * @extends AudioWorkletProcessor
+ *
+ * A simple recorder AudioWorkletProcessor. Returns the recorded buffer to the
+ * node when recording is finished.
+ */
+class RecorderProcessor extends AudioWorkletProcessor {
+  /**
+   * @param {*} options
+   * @param {number} options.duration A duration to record in seconds.
+   * @param {number} options.channelCount A channel count to record.
+   */
+  constructor(options) {
+    super();
+    this._createdAt = currentTime;
+    this._elapsed = 0;
+    this._recordDuration = options.duration || 1;
+    this._recordChannelCount = options.channelCount || 1;
+    this._recordBufferLength = sampleRate * this._recordDuration;
+    this._recordBuffer = [];
+    for (let i = 0; i < this._recordChannelCount; ++i) {
+      this._recordBuffer[i] = new Float32Array(this._recordBufferLength);
+    }
+  }
+
+  process(inputs, outputs) {
+    if (this._recordBufferLength <= currentFrame) {
+      this.port.postMessage({
+        type: 'recordfinished',
+        recordBuffer: this._recordBuffer
+      });
+      this.port.close();
+      return false;
+    }
+
+    // Records the incoming data from |inputs| and also bypasses the data to
+    // |outputs|.
+    const input = inputs[0];
+    const output = outputs[0];
+    for (let channel = 0; channel < input.length; ++channel) {
+      const inputChannel = input[channel];
+      const outputChannel = output[channel];
+      outputChannel.set(inputChannel);
+
+      const buffer = this._recordBuffer[channel];
+      const capacity = buffer.length - currentFrame;
+      buffer.set(inputChannel.slice(0, capacity), currentFrame);
+    }
+
+    return true;
+  }
+}
+
+registerProcessor('recorder-processor', RecorderProcessor);
diff --git a/testing/web-platform/tests/webaudio/resources/4ch-440.wav b/testing/web-platform/tests/webaudio/resources/4ch-440.wav
new file mode 100644
index 0000000000..85dc1ea904
Binary files /dev/null and b/testing/web-platform/tests/webaudio/resources/4ch-440.wav differ
diff --git a/testing/web-platform/tests/webaudio/resources/audio-param.js b/testing/web-platform/tests/webaudio/resources/audio-param.js
new file mode 100644
index 0000000000..bc33fe8a21
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/resources/audio-param.js
@@ -0,0 +1,44 @@
+// Define functions that implement the formulas for AudioParam automations.
+
+// AudioParam linearRamp value at time t for a linear ramp between (t0, v0) and
+// (t1, v1).  It is assumed that t0 <= t.  Results are undefined otherwise.
+function audioParamLinearRamp(t, v0, t0, v1, t1) {
+  if (t >= t1)
+    return v1;
+  return (v0 + (v1 - v0) * (t - t0) / (t1 - t0))
+}
+
+// AudioParam exponentialRamp value at time t for an exponential ramp between
+// (t0, v0) and (t1, v1). It is assumed that t0 <= t.  Results are undefined
+// otherwise.
+function audioParamExponentialRamp(t, v0, t0, v1, t1) {
+  if (t >= t1)
+    return v1;
+  return v0 * Math.pow(v1 / v0, (t - t0) / (t1 - t0));
+}
+
+// AudioParam setTarget value at time t for a setTarget curve starting at (t0,
+// v0) with a final value of vFainal and a time constant of timeConstant.  It is
+// assumed that t0 <= t.  Results are undefined otherwise.
+function audioParamSetTarget(t, v0, t0, vFinal, timeConstant) {
+  return vFinal + (v0 - vFinal) * Math.exp(-(t - t0) / timeConstant);
+}
+
+// AudioParam setValueCurve value at time t for a setValueCurve starting at time
+// t0 with curve, curve, and duration duration.  The sample rate is sampleRate.
+// It is assumed that t0 <= t.
+function audioParamSetValueCurve(t, curve, t0, duration) {
+  if (t > t0 + duration)
+    return curve[curve.length - 1];
+
+  let curvePointsPerSecond = (curve.length - 1) / duration;
+
+  let virtualIndex = (t - t0) * curvePointsPerSecond;
+  let index = Math.floor(virtualIndex);
+
+  let delta = virtualIndex - index;
+
+  let c0 = curve[index];
+  let c1 = curve[Math.min(index + 1, curve.length - 1)];
+  return c0 + (c1 - c0) * delta;
+}
diff --git a/testing/web-platform/tests/webaudio/resources/audiobuffersource-testing.js b/testing/web-platform/tests/webaudio/resources/audiobuffersource-testing.js
new file mode 100644
index 0000000000..2233641914
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/resources/audiobuffersource-testing.js
@@ -0,0 +1,102 @@
+function createTestBuffer(context, sampleFrameLength) {
+  let audioBuffer =
+      context.createBuffer(1, sampleFrameLength, context.sampleRate);
+  let channelData = audioBuffer.getChannelData(0);
+
+  // Create a simple linear ramp starting at zero, with each value in the buffer
+  // equal to its index position.
+  for (let i = 0; i < sampleFrameLength; ++i)
+    channelData[i] = i;
+
+  return audioBuffer;
+}
+
+function checkSingleTest(renderedBuffer, i, should) {
+  let renderedData = renderedBuffer.getChannelData(0);
+  let offsetFrame = i * testSpacingFrames;
+
+  let test = tests[i];
+  let expected = test.expected;
+  let description;
+
+  if (test.description) {
+    description = test.description;
+  } else {
+    // No description given, so create a basic one from the given test
+    // parameters.
+    description =
+        'loop from ' + test.loopStartFrame + ' -> ' + test.loopEndFrame;
+    if (test.offsetFrame)
+      description += ' with offset ' + test.offsetFrame;
+    if (test.playbackRate && test.playbackRate != 1)
+      description += ' with playbackRate of ' + test.playbackRate;
+  }
+
+  let framesToTest;
+
+  if (test.renderFrames)
+    framesToTest = test.renderFrames;
+  else if (test.durationFrames)
+    framesToTest = test.durationFrames;
+
+  // Verify that the output matches
+  let prefix = 'Case ' + i + ': ';
+  should(
+      renderedData.slice(offsetFrame, offsetFrame + framesToTest),
+      prefix + description)
+      .beEqualToArray(expected);
+
+  // Verify that we get all zeroes after the buffer (or duration) has passed.
+  should(
+      renderedData.slice(
+          offsetFrame + framesToTest, offsetFrame + testSpacingFrames),
+      prefix + description + ': tail')
+      .beConstantValueOf(0);
+}
+
+function checkAllTests(renderedBuffer, should) {
+  for (let i = 0; i < tests.length; ++i)
+    checkSingleTest(renderedBuffer, i, should);
+}
+
+
+// Create the actual result by modulating playbackRate or detune AudioParam of
+// ABSN. |modTarget| is a string of AudioParam name, |modOffset| is the offset
+// (anchor) point of modulation, and |modRange| is the range of modulation.
+//
+//   createSawtoothWithModulation(context, 'detune', 440, 1200);
+//
+// The above will perform a modulation on detune within the range of
+// [1200, -1200] around the sawtooth waveform on 440Hz.
+function createSawtoothWithModulation(context, modTarget, modOffset, modRange) {
+  let lfo = context.createOscillator();
+  let amp = context.createGain();
+
+  // Create a sawtooth generator with the signal range of [0, 1].
+  let phasor = context.createBufferSource();
+  let phasorBuffer = context.createBuffer(1, sampleRate, sampleRate);
+  let phasorArray = phasorBuffer.getChannelData(0);
+  let phase = 0, phaseStep = 1 / sampleRate;
+  for (let i = 0; i < phasorArray.length; i++) {
+    phasorArray[i] = phase % 1.0;
+    phase += phaseStep;
+  }
+  phasor.buffer = phasorBuffer;
+  phasor.loop = true;
+
+  // 1Hz for audible (human-perceivable) parameter modulation by LFO.
+  lfo.frequency.value = 1.0;
+
+  amp.gain.value = modRange;
+  phasor.playbackRate.value = modOffset;
+
+  // The oscillator output should be amplified accordingly to drive the
+  // modulation within the desired range.
+  lfo.connect(amp);
+  amp.connect(phasor[modTarget]);
+
+  phasor.connect(context.destination);
+
+  lfo.start();
+  phasor.start();
+}
diff --git a/testing/web-platform/tests/webaudio/resources/audionodeoptions.js b/testing/web-platform/tests/webaudio/resources/audionodeoptions.js
new file mode 100644
index 0000000000..3b7867cabf
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/resources/audionodeoptions.js
@@ -0,0 +1,292 @@
+// Test that constructor for the node with name |nodeName| handles the
+// various possible values for channelCount, channelCountMode, and
+// channelInterpretation.
+
+// The |should| parameter is the test function from new |Audit|.
+function testAudioNodeOptions(should, context, nodeName, expectedNodeOptions) {
+  if (expectedNodeOptions === undefined)
+    expectedNodeOptions = {};
+  let node;
+
+  // Test that we can set channelCount and that errors are thrown for
+  // invalid values
+  let testChannelCount = 17;
+  if (expectedNodeOptions.channelCount) {
+    testChannelCount = expectedNodeOptions.channelCount.value;
+  }
+  should(
+      () => {
+        node = new window[nodeName](
+            context, Object.assign({}, expectedNodeOptions.additionalOptions, {
+              channelCount: testChannelCount
+            }));
+      },
+      'new ' + nodeName + '(c, {channelCount: ' + testChannelCount + '})')
+      .notThrow();
+  should(node.channelCount, 'node.channelCount').beEqualTo(testChannelCount);
+
+  if (expectedNodeOptions.channelCount &&
+      expectedNodeOptions.channelCount.isFixed) {
+    // The channel count is fixed.  Verify that we throw an error if
+    // we try to change it. Arbitrarily set the count to be one more
+    // than the expected value.
+    testChannelCount = expectedNodeOptions.channelCount.value + 1;
+    should(
+        () => {
+          node = new window[nodeName](
+              context,
+              Object.assign(
+                  {}, expectedNodeOptions.additionalOptions,
+                  {channelCount: testChannelCount}));
+        },
+        'new ' + nodeName + '(c, {channelCount: ' + testChannelCount + '})')
+        .throw(DOMException,
+               expectedNodeOptions.channelCount.exceptionType);
+    // And test that setting it to the fixed value does not throw.
+    testChannelCount = expectedNodeOptions.channelCount.value;
+    should(
+        () => {
+          node = new window[nodeName](
+              context,
+              Object.assign(
+                  {}, expectedNodeOptions.additionalOptions,
+                  {channelCount: testChannelCount}));
+          node.channelCount = testChannelCount;
+        },
+        '(new ' + nodeName + '(c, {channelCount: ' + testChannelCount + '})).channelCount = ' + testChannelCount)
+        .notThrow();
+  } else {
+    // The channel count is not fixed.  Try to set the count to invalid
+    // values and make sure an error is thrown.
+    [0, 99].forEach(testValue => {
+      should(() => {
+        node = new window[nodeName](
+            context, Object.assign({}, expectedNodeOptions.additionalOptions, {
+              channelCount: testValue
+            }));
+      }, `new ${nodeName}(c, {channelCount: ${testValue}})`)
+          .throw(DOMException, 'NotSupportedError');
+    });
+  }
+
+  // Test channelCountMode
+  let testChannelCountMode = 'max';
+  if (expectedNodeOptions.channelCountMode) {
+    testChannelCountMode = expectedNodeOptions.channelCountMode.value;
+  }
+  should(
+      () => {
+        node = new window[nodeName](
+            context, Object.assign({}, expectedNodeOptions.additionalOptions, {
+              channelCountMode: testChannelCountMode
+            }));
+      },
+      'new ' + nodeName + '(c, {channelCountMode: "' + testChannelCountMode +
+          '"}')
+      .notThrow();
+  should(node.channelCountMode, 'node.channelCountMode')
+      .beEqualTo(testChannelCountMode);
+
+  if (expectedNodeOptions.channelCountMode &&
+      expectedNodeOptions.channelCountMode.isFixed) {
+    // Channel count mode is fixed.  Test setting to something else throws.
+    ['max', 'clamped-max', 'explicit'].forEach(testValue => {
+      if (testValue !== expectedNodeOptions.channelCountMode.value) {
+        should(
+            () => {
+              node = new window[nodeName](
+                  context,
+                  Object.assign(
+                      {}, expectedNodeOptions.additionalOptions,
+                      {channelCountMode: testValue}));
+            },
+            `new ${nodeName}(c, {channelCountMode: "${testValue}"})`)
+            .throw(DOMException,
+                   expectedNodeOptions.channelCountMode.exceptionType);
+      } else {
+        // Test that explicitly setting the the fixed value is allowed.
+        should(
+            () => {
+              node = new window[nodeName](
+                  context,
+                  Object.assign(
+                      {}, expectedNodeOptions.additionalOptions,
+                      {channelCountMode: testValue}));
+              node.channelCountMode = testValue;
+            },
+            `(new ${nodeName}(c, {channelCountMode: "${testValue}"})).channelCountMode = "${testValue}"`)
+            .notThrow();
+      }
+    });
+  } else {
+    // Mode is not fixed. Verify that we can set the mode to all valid
+    // values, and that we throw for invalid values.
+
+    let testValues = ['max', 'clamped-max', 'explicit'];
+
+    testValues.forEach(testValue => {
+      should(() => {
+        node = new window[nodeName](
+            context, Object.assign({}, expectedNodeOptions.additionalOptions, {
+              channelCountMode: testValue
+            }));
+      }, `new ${nodeName}(c, {channelCountMode: "${testValue}"})`).notThrow();
+      should(
+          node.channelCountMode, 'node.channelCountMode after valid setter')
+          .beEqualTo(testValue);
+
+    });
+
+    should(
+        () => {
+          node = new window[nodeName](
+              context,
+              Object.assign(
+                  {}, expectedNodeOptions.additionalOptions,
+                  {channelCountMode: 'foobar'}));
+        },
+        'new ' + nodeName + '(c, {channelCountMode: "foobar"}')
+        .throw(TypeError);
+    should(node.channelCountMode, 'node.channelCountMode after invalid setter')
+        .beEqualTo(testValues[testValues.length - 1]);
+  }
+
+  // Test channelInterpretation
+  if (expectedNodeOptions.channelInterpretation &&
+      expectedNodeOptions.channelInterpretation.isFixed) {
+    // The channel interpretation is fixed.  Verify that we throw an
+    // error if we try to change it.
+    ['speakers', 'discrete'].forEach(testValue => {
+      if (testValue !== expectedNodeOptions.channelInterpretation.value) {
+        should(
+            () => {
+              node = new window[nodeName](
+                  context,
+                  Object.assign(
+                      {}, expectedNodeOptions.additionOptions,
+                      {channelInterpretation: testValue}));
+            },
+            `new ${nodeName}(c, {channelInterpretation: "${testValue}"})`)
+            .throw(DOMException,
+                   expectedNodeOptions.channelCountMode.exceptionType);
+      } else {
+        // Check that assigning the fixed value is OK.
+        should(
+            () => {
+              node = new window[nodeName](
+                  context,
+                  Object.assign(
+                      {}, expectedNodeOptions.additionOptions,
+                      {channelInterpretation: testValue}));
+              node.channelInterpretation = testValue;
+            },
+            `(new ${nodeName}(c, {channelInterpretation: "${testValue}"})).channelInterpretation = "${testValue}"`)
+            .notThrow();
+      }
+    });
+  } else {
+    // Channel interpretation is not fixed. Verify that we can set it
+    // to all possible values.
+    should(
+        () => {
+          node = new window[nodeName](
+              context,
+              Object.assign(
+                  {}, expectedNodeOptions.additionalOptions,
+                  {channelInterpretation: 'speakers'}));
+        },
+        'new ' + nodeName + '(c, {channelInterpretation: "speakers"})')
+        .notThrow();
+    should(node.channelInterpretation, 'node.channelInterpretation')
+        .beEqualTo('speakers');
+
+    should(
+        () => {
+          node = new window[nodeName](
+              context,
+              Object.assign(
+                  {}, expectedNodeOptions.additionalOptions,
+                  {channelInterpretation: 'discrete'}));
+        },
+        'new ' + nodeName + '(c, {channelInterpretation: "discrete"})')
+        .notThrow();
+    should(node.channelInterpretation, 'node.channelInterpretation')
+        .beEqualTo('discrete');
+
+    should(
+        () => {
+          node = new window[nodeName](
+              context,
+              Object.assign(
+                  {}, expectedNodeOptions.additionalOptions,
+                  {channelInterpretation: 'foobar'}));
+        },
+        'new ' + nodeName + '(c, {channelInterpretation: "foobar"})')
+        .throw(TypeError);
+    should(
+        node.channelInterpretation,
+        'node.channelInterpretation after invalid setter')
+        .beEqualTo('discrete');
+  }
+}
+
+function initializeContext(should) {
+  let c;
+  should(() => {
+    c = new OfflineAudioContext(1, 1, 48000);
+  }, 'context = new OfflineAudioContext(...)').notThrow();
+
+  return c;
+}
+
+function testInvalidConstructor(should, name, context) {
+  should(() => {
+    new window[name]();
+  }, 'new ' + name + '()').throw(TypeError);
+  should(() => {
+    new window[name](1);
+  }, 'new ' + name + '(1)').throw(TypeError);
+  should(() => {
+    new window[name](context, 42);
+  }, 'new ' + name + '(context, 42)').throw(TypeError);
+}
+
+function testDefaultConstructor(should, name, context, options) {
+  let node;
+
+  let message = options.prefix + ' = new ' + name + '(context';
+  if (options.constructorOptions)
+    message += ', ' + JSON.stringify(options.constructorOptions);
+  message += ')'
+
+  should(() => {
+    node = new window[name](context, options.constructorOptions);
+  }, message).notThrow();
+
+  should(node instanceof window[name], options.prefix + ' instanceof ' + name)
+      .beEqualTo(true);
+  should(node.numberOfInputs, options.prefix + '.numberOfInputs')
+      .beEqualTo(options.numberOfInputs);
+  should(node.numberOfOutputs, options.prefix + '.numberOfOutputs')
+      .beEqualTo(options.numberOfOutputs);
+  should(node.channelCount, options.prefix + '.channelCount')
+      .beEqualTo(options.channelCount);
+  should(node.channelCountMode, options.prefix + '.channelCountMode')
+      .beEqualTo(options.channelCountMode);
+  should(node.channelInterpretation, options.prefix + '.channelInterpretation')
+      .beEqualTo(options.channelInterpretation);
+
+  return node;
+}
+
+function testDefaultAttributes(should, node, prefix, items) {
+  items.forEach((item) => {
+    let attr = node[item.name];
+    if (attr instanceof AudioParam) {
+      should(attr.value, prefix + '.' + item.name + '.value')
+          .beEqualTo(item.value);
+    } else {
+      should(attr, prefix + '.' + item.name).beEqualTo(item.value);
+    }
+  });
+}
diff --git a/testing/web-platform/tests/webaudio/resources/audioparam-testing.js b/testing/web-platform/tests/webaudio/resources/audioparam-testing.js
new file mode 100644
index 0000000000..bc90ddbef8
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/resources/audioparam-testing.js
@@ -0,0 +1,554 @@
+(function(global) {
+
+  // Information about the starting/ending times and starting/ending values for
+  // each time interval.
+  let timeValueInfo;
+
+  // The difference between starting values between each time interval.
+  let startingValueDelta;
+
+  // For any automation function that has an end or target value, the end value
+  // is based the starting value of the time interval.  The starting value will
+  // be increased or decreased by |startEndValueChange|. We choose half of
+  // |startingValueDelta| so that the ending value will be distinct from the
+  // starting value for next time interval.  This allows us to detect where the
+  // ramp begins and ends.
+  let startEndValueChange;
+
+  // Default threshold to use for detecting discontinuities that should appear
+  // at each time interval.
+  let discontinuityThreshold;
+
+  // Time interval between value changes.  It is best if 1 / numberOfTests is
+  // not close to timeInterval.
+  let timeIntervalInternal = .03;
+
+  let context;
+
+  // Make sure we render long enough to capture all of our test data.
+  function renderLength(numberOfTests) {
+    return timeToSampleFrame((numberOfTests + 1) * timeInterval, sampleRate);
+  }
+
+  // Create a constant reference signal with the given |value|.  Basically the
+  // same as |createConstantBuffer|, but with the parameters to match the other
+  // create functions.  The |endValue| is ignored.
+  function createConstantArray(
+      startTime, endTime, value, endValue, sampleRate) {
+    let startFrame = timeToSampleFrame(startTime, sampleRate);
+    let endFrame = timeToSampleFrame(endTime, sampleRate);
+    let length = endFrame - startFrame;
+
+    let buffer = createConstantBuffer(context, length, value);
+
+    return buffer.getChannelData(0);
+  }
+
+  function getStartEndFrames(startTime, endTime, sampleRate) {
+    // Start frame is the ceiling of the start time because the ramp starts at
+    // or after the sample frame.  End frame is the ceiling because it's the
+    // exclusive ending frame of the automation.
+    let startFrame = Math.ceil(startTime * sampleRate);
+    let endFrame = Math.ceil(endTime * sampleRate);
+
+    return {startFrame: startFrame, endFrame: endFrame};
+  }
+
+  // Create a linear ramp starting at |startValue| and ending at |endValue|. The
+  // ramp starts at time |startTime| and ends at |endTime|.  (The start and end
+  // times are only used to compute how many samples to return.)
+  function createLinearRampArray(
+      startTime, endTime, startValue, endValue, sampleRate) {
+    let frameInfo = getStartEndFrames(startTime, endTime, sampleRate);
+    let startFrame = frameInfo.startFrame;
+    let endFrame = frameInfo.endFrame;
+    let length = endFrame - startFrame;
+    let array = new Array(length);
+
+    let step = Math.fround(
+        (endValue - startValue) / (endTime - startTime) / sampleRate);
+    let start = Math.fround(
+        startValue +
+        (endValue - startValue) * (startFrame / sampleRate - startTime) /
+            (endTime - startTime));
+
+    let slope = (endValue - startValue) / (endTime - startTime);
+
+    // v(t) = v0 + (v1 - v0)*(t-t0)/(t1-t0)
+    for (k = 0; k < length; ++k) {
+      // array[k] = Math.fround(start + k * step);
+      let t = (startFrame + k) / sampleRate;
+      array[k] = startValue + slope * (t - startTime);
+    }
+
+    return array;
+  }
+
+  // Create an exponential ramp starting at |startValue| and ending at
+  // |endValue|. The ramp starts at time |startTime| and ends at |endTime|.
+  // (The start and end times are only used to compute how many samples to
+  // return.)
+  function createExponentialRampArray(
+      startTime, endTime, startValue, endValue, sampleRate) {
+    let deltaTime = endTime - startTime;
+
+    let frameInfo = getStartEndFrames(startTime, endTime, sampleRate);
+    let startFrame = frameInfo.startFrame;
+    let endFrame = frameInfo.endFrame;
+    let length = endFrame - startFrame;
+    let array = new Array(length);
+
+    let ratio = endValue / startValue;
+
+    // v(t) = v0*(v1/v0)^((t-t0)/(t1-t0))
+    for (let k = 0; k < length; ++k) {
+      let t = Math.fround((startFrame + k) / sampleRate);
+      array[k] = Math.fround(
+          startValue * Math.pow(ratio, (t - startTime) / deltaTime));
+    }
+
+    return array;
+  }
+
+  function discreteTimeConstantForSampleRate(timeConstant, sampleRate) {
+    return 1 - Math.exp(-1 / (sampleRate * timeConstant));
+  }
+
+  // Create a signal that starts at |startValue| and exponentially approaches
+  // the target value of |targetValue|, using a time constant of |timeConstant|.
+  // The ramp starts at time |startTime| and ends at |endTime|.  (The start and
+  // end times are only used to compute how many samples to return.)
+  function createExponentialApproachArray(
+      startTime, endTime, startValue, targetValue, sampleRate, timeConstant) {
+    let startFrameFloat = startTime * sampleRate;
+    let frameInfo = getStartEndFrames(startTime, endTime, sampleRate);
+    let startFrame = frameInfo.startFrame;
+    let endFrame = frameInfo.endFrame;
+    let length = Math.floor(endFrame - startFrame);
+    let array = new Array(length);
+    let c = discreteTimeConstantForSampleRate(timeConstant, sampleRate);
+
+    let delta = startValue - targetValue;
+
+    // v(t) = v1 + (v0 - v1) * exp(-(t-t0)/tau)
+    for (let k = 0; k < length; ++k) {
+      let t = (startFrame + k) / sampleRate;
+      let value =
+          targetValue + delta * Math.exp(-(t - startTime) / timeConstant);
+      array[k] = value;
+    }
+
+    return array;
+  }
+
+  // Create a sine wave of the specified duration.
+  function createReferenceSineArray(
+      startTime, endTime, startValue, endValue, sampleRate) {
+    // Ignore |startValue| and |endValue| for the sine wave.
+    let curve = createSineWaveArray(
+        endTime - startTime, freqHz, sineAmplitude, sampleRate);
+    // Sample the curve appropriately.
+    let frameInfo = getStartEndFrames(startTime, endTime, sampleRate);
+    let startFrame = frameInfo.startFrame;
+    let endFrame = frameInfo.endFrame;
+    let length = Math.floor(endFrame - startFrame);
+    let array = new Array(length);
+
+    // v(t) = linearly interpolate between V[k] and V[k + 1] where k =
+    // floor((N-1)/duration*(t - t0))
+    let f = (length - 1) / (endTime - startTime);
+
+    for (let k = 0; k < length; ++k) {
+      let t = (startFrame + k) / sampleRate;
+      let indexFloat = f * (t - startTime);
+      let index = Math.floor(indexFloat);
+      if (index + 1 < length) {
+        let v0 = curve[index];
+        let v1 = curve[index + 1];
+        array[k] = v0 + (v1 - v0) * (indexFloat - index);
+      } else {
+        array[k] = curve[length - 1];
+      }
+    }
+
+    return array;
+  }
+
+  // Create a sine wave of the given frequency and amplitude.  The sine wave is
+  // offset by half the amplitude so that result is always positive.
+  function createSineWaveArray(durationSeconds, freqHz, amplitude, sampleRate) {
+    let length = timeToSampleFrame(durationSeconds, sampleRate);
+    let signal = new Float32Array(length);
+    let omega = 2 * Math.PI * freqHz / sampleRate;
+    let halfAmplitude = amplitude / 2;
+
+    for (let k = 0; k < length; ++k) {
+      signal[k] = halfAmplitude + halfAmplitude * Math.sin(omega * k);
+    }
+
+    return signal;
+  }
+
+  // Return the difference between the starting value and the ending value for
+  // time interval |timeIntervalIndex|.  We alternate between an end value that
+  // is above or below the starting value.
+  function endValueDelta(timeIntervalIndex) {
+    if (timeIntervalIndex & 1) {
+      return -startEndValueChange;
+    } else {
+      return startEndValueChange;
+    }
+  }
+
+  // Relative error metric
+  function relativeErrorMetric(actual, expected) {
+    return (actual - expected) / Math.abs(expected);
+  }
+
+  // Difference metric
+  function differenceErrorMetric(actual, expected) {
+    return actual - expected;
+  }
+
+  // Return the difference between the starting value at |timeIntervalIndex| and
+  // the starting value at the next time interval.  Since we started at a large
+  // initial value, we decrease the value at each time interval.
+  function valueUpdate(timeIntervalIndex) {
+    return -startingValueDelta;
+  }
+
+  // Compare a section of the rendered data against our expected signal.
+  function comparePartialSignals(
+      should, rendered, expectedFunction, startTime, endTime, valueInfo,
+      sampleRate, errorMetric) {
+    let startSample = timeToSampleFrame(startTime, sampleRate);
+    let expected = expectedFunction(
+        startTime, endTime, valueInfo.startValue, valueInfo.endValue,
+        sampleRate, timeConstant);
+
+    let n = expected.length;
+    let maxError = -1;
+    let maxErrorIndex = -1;
+
+    for (let k = 0; k < n; ++k) {
+      // Make sure we don't pass these tests because a NaN has been generated in
+      // either the
+      // rendered data or the reference data.
+      if (!isValidNumber(rendered[startSample + k])) {
+        maxError = Infinity;
+        maxErrorIndex = startSample + k;
+        should(
+            isValidNumber(rendered[startSample + k]),
+            'NaN or infinity for rendered data at ' + maxErrorIndex)
+            .beTrue();
+        break;
+      }
+      if (!isValidNumber(expected[k])) {
+        maxError = Infinity;
+        maxErrorIndex = startSample + k;
+        should(
+            isValidNumber(expected[k]),
+            'NaN or infinity for rendered data at ' + maxErrorIndex)
+            .beTrue();
+        break;
+      }
+      let error = Math.abs(errorMetric(rendered[startSample + k], expected[k]));
+      if (error > maxError) {
+        maxError = error;
+        maxErrorIndex = k;
+      }
+    }
+
+    return {maxError: maxError, index: maxErrorIndex, expected: expected};
+  }
+
+  // Find the discontinuities in the data and compare the locations of the
+  // discontinuities with the times that define the time intervals. There is a
+  // discontinuity if the difference between successive samples exceeds the
+  // threshold.
+  function verifyDiscontinuities(should, values, times, threshold) {
+    let n = values.length;
+    let success = true;
+    let badLocations = 0;
+    let breaks = [];
+
+    // Find discontinuities.
+    for (let k = 1; k < n; ++k) {
+      if (Math.abs(values[k] - values[k - 1]) > threshold) {
+        breaks.push(k);
+      }
+    }
+
+    let testCount;
+
+    // If there are numberOfTests intervals, there are only numberOfTests - 1
+    // internal interval boundaries. Hence the maximum number of discontinuties
+    // we expect to find is numberOfTests - 1. If we find more than that, we
+    // have no reference to compare against. We also assume that the actual
+    // discontinuities are close to the expected ones.
+    //
+    // This is just a sanity check when something goes really wrong.  For
+    // example, if the threshold is too low, every sample frame looks like a
+    // discontinuity.
+    if (breaks.length >= numberOfTests) {
+      testCount = numberOfTests - 1;
+      should(breaks.length, 'Number of discontinuities')
+          .beLessThan(numberOfTests);
+      success = false;
+    } else {
+      testCount = breaks.length;
+    }
+
+    // Compare the location of each discontinuity with the end time of each
+    // interval. (There is no discontinuity at the start of the signal.)
+    for (let k = 0; k < testCount; ++k) {
+      let expectedSampleFrame = timeToSampleFrame(times[k + 1], sampleRate);
+      if (breaks[k] != expectedSampleFrame) {
+        success = false;
+        ++badLocations;
+        should(breaks[k], 'Discontinuity at index')
+            .beEqualTo(expectedSampleFrame);
+      }
+    }
+
+    if (badLocations) {
+      should(badLocations, 'Number of discontinuites at incorrect locations')
+          .beEqualTo(0);
+      success = false;
+    } else {
+      should(
+          breaks.length + 1,
+          'Number of tests started and ended at the correct time')
+          .beEqualTo(numberOfTests);
+    }
+
+    return success;
+  }
+
+  // Compare the rendered data with the expected data.
+  //
+  // testName - string describing the test
+  //
+  // maxError - maximum allowed difference between the rendered data and the
+  // expected data
+  //
+  // rendererdData - array containing the rendered (actual) data
+  //
+  // expectedFunction - function to compute the expected data
+  //
+  // timeValueInfo - array containing information about the start and end times
+  // and the start and end values of each interval.
+  //
+  // breakThreshold - threshold to use for determining discontinuities.
+  function compareSignals(
+      should, testName, maxError, renderedData, expectedFunction, timeValueInfo,
+      breakThreshold, errorMetric) {
+    let success = true;
+    let failedTestCount = 0;
+    let times = timeValueInfo.times;
+    let values = timeValueInfo.values;
+    let n = values.length;
+    let expectedSignal = [];
+
+    success =
+        verifyDiscontinuities(should, renderedData, times, breakThreshold);
+
+    for (let k = 0; k < n; ++k) {
+      let result = comparePartialSignals(
+          should, renderedData, expectedFunction, times[k], times[k + 1],
+          values[k], sampleRate, errorMetric);
+
+      expectedSignal =
+          expectedSignal.concat(Array.prototype.slice.call(result.expected));
+
+      should(
+          result.maxError,
+          'Max error for test ' + k + ' at offset ' +
+              (result.index + timeToSampleFrame(times[k], sampleRate)))
+          .beLessThanOrEqualTo(maxError);
+    }
+
+    should(
+        failedTestCount,
+        'Number of failed tests with an acceptable relative tolerance of ' +
+            maxError)
+        .beEqualTo(0);
+  }
+
+  // Create a function to test the rendered data with the reference data.
+  //
+  // testName - string describing the test
+  //
+  // error - max allowed error between rendered data and the reference data.
+  //
+  // referenceFunction - function that generates the reference data to be
+  // compared with the rendered data.
+  //
+  // jumpThreshold - optional parameter that specifies the threshold to use for
+  // detecting discontinuities.  If not specified, defaults to
+  // discontinuityThreshold.
+  //
+  function checkResultFunction(
+      task, should, testName, error, referenceFunction, jumpThreshold,
+      errorMetric) {
+    return function(event) {
+      let buffer = event.renderedBuffer;
+      renderedData = buffer.getChannelData(0);
+
+      let threshold;
+
+      if (!jumpThreshold) {
+        threshold = discontinuityThreshold;
+      } else {
+        threshold = jumpThreshold;
+      }
+
+      compareSignals(
+          should, testName, error, renderedData, referenceFunction,
+          timeValueInfo, threshold, errorMetric);
+      task.done();
+    }
+  }
+
+  // Run all the automation tests.
+  //
+  // numberOfTests - number of tests (time intervals) to run.
+  //
+  // initialValue - The initial value of the first time interval.
+  //
+  // setValueFunction - function that sets the specified value at the start of a
+  // time interval.
+  //
+  // automationFunction - function that sets the end value for the time
+  // interval. It specifies how the value approaches the end value.
+  //
+  // An object is returned containing an array of start times for each time
+  // interval, and an array giving the start and end values for the interval.
+  function doAutomation(
+      numberOfTests, initialValue, setValueFunction, automationFunction) {
+    let timeInfo = [0];
+    let valueInfo = [];
+    let value = initialValue;
+
+    for (let k = 0; k < numberOfTests; ++k) {
+      let startTime = k * timeInterval;
+      let endTime = (k + 1) * timeInterval;
+      let endValue = value + endValueDelta(k);
+
+      // Set the value at the start of the time interval.
+      setValueFunction(value, startTime);
+
+      // Specify the end or target value, and how we should approach it.
+      automationFunction(endValue, startTime, endTime);
+
+      // Keep track of the start times, and the start and end values for each
+      // time interval.
+      timeInfo.push(endTime);
+      valueInfo.push({startValue: value, endValue: endValue});
+
+      value += valueUpdate(k);
+    }
+
+    return {times: timeInfo, values: valueInfo};
+  }
+
+  // Create the audio graph for the test and then run the test.
+  //
+  // numberOfTests - number of time intervals (tests) to run.
+  //
+  // initialValue - the initial value of the gain at time 0.
+  //
+  // setValueFunction - function to set the value at the beginning of each time
+  // interval.
+  //
+  // automationFunction - the AudioParamTimeline automation function
+  //
+  // testName - string indicating the test that is being run.
+  //
+  // maxError - maximum allowed error between the rendered data and the
+  // reference data
+  //
+  // referenceFunction - function that generates the reference data to be
+  // compared against the rendered data.
+  //
+  // jumpThreshold - optional parameter that specifies the threshold to use for
+  // detecting discontinuities.  If not specified, defaults to
+  // discontinuityThreshold.
+  //
+  function createAudioGraphAndTest(
+      task, should, numberOfTests, initialValue, setValueFunction,
+      automationFunction, testName, maxError, referenceFunction, jumpThreshold,
+      errorMetric) {
+    // Create offline audio context.
+    context =
+        new OfflineAudioContext(2, renderLength(numberOfTests), sampleRate);
+    let constantBuffer =
+        createConstantBuffer(context, renderLength(numberOfTests), 1);
+
+    // We use an AudioGainNode here simply as a convenient way to test the
+    // AudioParam automation, since it's easy to pass a constant value through
+    // the node, automate the .gain attribute and observe the resulting values.
+
+    gainNode = context.createGain();
+
+    let bufferSource = context.createBufferSource();
+    bufferSource.buffer = constantBuffer;
+    bufferSource.connect(gainNode);
+    gainNode.connect(context.destination);
+
+    // Set up default values for the parameters that control how the automation
+    // test values progress for each time interval.
+    startingValueDelta = initialValue / numberOfTests;
+    startEndValueChange = startingValueDelta / 2;
+    discontinuityThreshold = startEndValueChange / 2;
+
+    // Run the automation tests.
+    timeValueInfo = doAutomation(
+        numberOfTests, initialValue, setValueFunction, automationFunction);
+    bufferSource.start(0);
+
+    context.oncomplete = checkResultFunction(
+        task, should, testName, maxError, referenceFunction, jumpThreshold,
+        errorMetric || relativeErrorMetric);
+    context.startRendering();
+  }
+
+  // Export local references to global scope. All the new objects in this file
+  // must be exported through this if it is to be used in the actual test HTML
+  // page.
+  let exports = {
+    'sampleRate': 44100,
+    'gainNode': null,
+    'timeInterval': timeIntervalInternal,
+
+    // Some suitable time constant so that we can see a significant change over
+    // a timeInterval.  This is only needed by setTargetAtTime() which needs a
+    // time constant.
+    'timeConstant': timeIntervalInternal / 3,
+
+    'renderLength': renderLength,
+    'createConstantArray': createConstantArray,
+    'getStartEndFrames': getStartEndFrames,
+    'createLinearRampArray': createLinearRampArray,
+    'createExponentialRampArray': createExponentialRampArray,
+    'discreteTimeConstantForSampleRate': discreteTimeConstantForSampleRate,
+    'createExponentialApproachArray': createExponentialApproachArray,
+    'createReferenceSineArray': createReferenceSineArray,
+    'createSineWaveArray': createSineWaveArray,
+    'endValueDelta': endValueDelta,
+    'relativeErrorMetric': relativeErrorMetric,
+    'differenceErrorMetric': differenceErrorMetric,
+    'valueUpdate': valueUpdate,
+    'comparePartialSignals': comparePartialSignals,
+    'verifyDiscontinuities': verifyDiscontinuities,
+    'compareSignals': compareSignals,
+    'checkResultFunction': checkResultFunction,
+    'doAutomation': doAutomation,
+    'createAudioGraphAndTest': createAudioGraphAndTest
+  };
+
+  for (let reference in exports) {
+    global[reference] = exports[reference];
+  }
+
+})(window);
diff --git a/testing/web-platform/tests/webaudio/resources/audit-util.js b/testing/web-platform/tests/webaudio/resources/audit-util.js
new file mode 100644
index 0000000000..a4dea79658
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/resources/audit-util.js
@@ -0,0 +1,195 @@
+// Copyright 2016 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+
+/**
+ * @fileOverview  This file includes legacy utility functions for the layout
+ *                test.
+ */
+
+// How many frames in a WebAudio render quantum.
+let RENDER_QUANTUM_FRAMES = 128;
+
+// Compare two arrays (commonly extracted from buffer.getChannelData()) with
+// constraints:
+//   options.thresholdSNR: Minimum allowed SNR between the actual and expected
+//     signal. The default value is 10000.
+//   options.thresholdDiffULP: Maximum allowed difference between the actual
+//     and expected signal in ULP(Unit in the last place). The default is 0.
+//   options.thresholdDiffCount: Maximum allowed number of sample differences
+//     which exceeds the threshold. The default is 0.
+//   options.bitDepth: The expected result is assumed to come from an audio
+//     file with this number of bits of precision. The default is 16.
+function compareBuffersWithConstraints(should, actual, expected, options) {
+  if (!options)
+    options = {};
+
+  // Only print out the message if the lengths are different; the
+  // expectation is that they are the same, so don't clutter up the
+  // output.
+  if (actual.length !== expected.length) {
+    should(
+        actual.length === expected.length,
+        'Length of actual and expected buffers should match')
+        .beTrue();
+  }
+
+  let maxError = -1;
+  let diffCount = 0;
+  let errorPosition = -1;
+  let thresholdSNR = (options.thresholdSNR || 10000);
+
+  let thresholdDiffULP = (options.thresholdDiffULP || 0);
+  let thresholdDiffCount = (options.thresholdDiffCount || 0);
+
+  // By default, the bit depth is 16.
+  let bitDepth = (options.bitDepth || 16);
+  let scaleFactor = Math.pow(2, bitDepth - 1);
+
+  let noisePower = 0, signalPower = 0;
+
+  for (let i = 0; i < actual.length; i++) {
+    let diff = actual[i] - expected[i];
+    noisePower += diff * diff;
+    signalPower += expected[i] * expected[i];
+
+    if (Math.abs(diff) > maxError) {
+      maxError = Math.abs(diff);
+      errorPosition = i;
+    }
+
+    // The reference file is a 16-bit WAV file, so we will almost never get
+    // an exact match between it and the actual floating-point result.
+    if (Math.abs(diff) > scaleFactor)
+      diffCount++;
+  }
+
+  let snr = 10 * Math.log10(signalPower / noisePower);
+  let maxErrorULP = maxError * scaleFactor;
+
+  should(snr, 'SNR').beGreaterThanOrEqualTo(thresholdSNR);
+
+  should(
+      maxErrorULP,
+      options.prefix + ': Maximum difference (in ulp units (' + bitDepth +
+          '-bits))')
+      .beLessThanOrEqualTo(thresholdDiffULP);
+
+  should(diffCount, options.prefix + ': Number of differences between results')
+      .beLessThanOrEqualTo(thresholdDiffCount);
+}
+
+// Create an impulse in a buffer of length sampleFrameLength
+function createImpulseBuffer(context, sampleFrameLength) {
+  let audioBuffer =
+      context.createBuffer(1, sampleFrameLength, context.sampleRate);
+  let n = audioBuffer.length;
+  let dataL = audioBuffer.getChannelData(0);
+
+  for (let k = 0; k < n; ++k) {
+    dataL[k] = 0;
+  }
+  dataL[0] = 1;
+
+  return audioBuffer;
+}
+
+// Create a buffer of the given length with a linear ramp having values 0 <= x <
+// 1.
+function createLinearRampBuffer(context, sampleFrameLength) {
+  let audioBuffer =
+      context.createBuffer(1, sampleFrameLength, context.sampleRate);
+  let n = audioBuffer.length;
+  let dataL = audioBuffer.getChannelData(0);
+
+  for (let i = 0; i < n; ++i)
+    dataL[i] = i / n;
+
+  return audioBuffer;
+}
+
+// Create an AudioBuffer of length |sampleFrameLength| having a constant value
+// |constantValue|. If |constantValue| is a number, the buffer has one channel
+// filled with that value. If |constantValue| is an array, the buffer is created
+// wit a number of channels equal to the length of the array, and channel k is
+// filled with the k'th element of the |constantValue| array.
+function createConstantBuffer(context, sampleFrameLength, constantValue) {
+  let channels;
+  let values;
+
+  if (typeof constantValue === 'number') {
+    channels = 1;
+    values = [constantValue];
+  } else {
+    channels = constantValue.length;
+    values = constantValue;
+  }
+
+  let audioBuffer =
+      context.createBuffer(channels, sampleFrameLength, context.sampleRate);
+  let n = audioBuffer.length;
+
+  for (let c = 0; c < channels; ++c) {
+    let data = audioBuffer.getChannelData(c);
+    for (let i = 0; i < n; ++i)
+      data[i] = values[c];
+  }
+
+  return audioBuffer;
+}
+
+// Create a stereo impulse in a buffer of length sampleFrameLength
+function createStereoImpulseBuffer(context, sampleFrameLength) {
+  let audioBuffer =
+      context.createBuffer(2, sampleFrameLength, context.sampleRate);
+  let n = audioBuffer.length;
+  let dataL = audioBuffer.getChannelData(0);
+  let dataR = audioBuffer.getChannelData(1);
+
+  for (let k = 0; k < n; ++k) {
+    dataL[k] = 0;
+    dataR[k] = 0;
+  }
+  dataL[0] = 1;
+  dataR[0] = 1;
+
+  return audioBuffer;
+}
+
+// Convert time (in seconds) to sample frames.
+function timeToSampleFrame(time, sampleRate) {
+  return Math.floor(0.5 + time * sampleRate);
+}
+
+// Compute the number of sample frames consumed by noteGrainOn with
+// the specified |grainOffset|, |duration|, and |sampleRate|.
+function grainLengthInSampleFrames(grainOffset, duration, sampleRate) {
+  let startFrame = timeToSampleFrame(grainOffset, sampleRate);
+  let endFrame = timeToSampleFrame(grainOffset + duration, sampleRate);
+
+  return endFrame - startFrame;
+}
+
+// True if the number is not an infinity or NaN
+function isValidNumber(x) {
+  return !isNaN(x) && (x != Infinity) && (x != -Infinity);
+}
+
+// Compute the (linear) signal-to-noise ratio between |actual| and
+// |expected|.  The result is NOT in dB!  If the |actual| and
+// |expected| have different lengths, the shorter length is used.
+function computeSNR(actual, expected) {
+  let signalPower = 0;
+  let noisePower = 0;
+
+  let length = Math.min(actual.length, expected.length);
+
+  for (let k = 0; k < length; ++k) {
+    let diff = actual[k] - expected[k];
+    signalPower += expected[k] * expected[k];
+    noisePower += diff * diff;
+  }
+
+  return signalPower / noisePower;
+}
diff --git a/testing/web-platform/tests/webaudio/resources/audit.js b/testing/web-platform/tests/webaudio/resources/audit.js
new file mode 100644
index 0000000000..2bb078b111
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/resources/audit.js
@@ -0,0 +1,1445 @@
+// Copyright 2016 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// See https://github.com/web-platform-tests/wpt/issues/12781 for information on
+// the purpose of audit.js, and why testharness.js does not suffice.
+
+/**
+ * @fileOverview  WebAudio layout test utility library. Built around W3C's
+ *                testharness.js. Includes asynchronous test task manager,
+ *                assertion utilities.
+ * @dependency    testharness.js
+ */
+
+
+(function() {
+
+  'use strict';
+
+  // Selected methods from testharness.js.
+  let testharnessProperties = [
+    'test', 'async_test', 'promise_test', 'promise_rejects_js', 'generate_tests',
+    'setup', 'done', 'assert_true', 'assert_false'
+  ];
+
+  // Check if testharness.js is properly loaded. Throw otherwise.
+  for (let name in testharnessProperties) {
+    if (!self.hasOwnProperty(testharnessProperties[name]))
+      throw new Error('Cannot proceed. testharness.js is not loaded.');
+  }
+})();
+
+
+window.Audit = (function() {
+
+  'use strict';
+
+  // NOTE: Moving this method (or any other code above) will change the location
+  // of 'CONSOLE ERROR...' message in the expected text files.
+  function _logError(message) {
+    console.error('[audit.js] ' + message);
+  }
+
+  function _logPassed(message) {
+    test(function(arg) {
+      assert_true(true);
+    }, message);
+  }
+
+  function _logFailed(message, detail) {
+    test(function() {
+      assert_true(false, detail);
+    }, message);
+  }
+
+  function _throwException(message) {
+    throw new Error(message);
+  }
+
+  // TODO(hongchan): remove this hack after confirming all the tests are
+  // finished correctly. (crbug.com/708817)
+  const _testharnessDone = window.done;
+  window.done = () => {
+    _throwException('Do NOT call done() method from the test code.');
+  };
+
+  // Generate a descriptive string from a target value in various types.
+  function _generateDescription(target, options) {
+    let targetString;
+
+    switch (typeof target) {
+      case 'object':
+        // Handle Arrays.
+        if (target instanceof Array || target instanceof Float32Array ||
+            target instanceof Float64Array || target instanceof Uint8Array) {
+          let arrayElements = target.length < options.numberOfArrayElements ?
+              String(target) :
+              String(target.slice(0, options.numberOfArrayElements)) + '...';
+          targetString = '[' + arrayElements + ']';
+        } else if (target === null) {
+          targetString = String(target);
+        } else {
+          targetString = '' + String(target).split(/[\s\]]/)[1];
+        }
+        break;
+      case 'function':
+        if (Error.isPrototypeOf(target)) {
+          targetString = "EcmaScript error " + target.name;
+        } else {
+          targetString = String(target);
+        }
+        break;
+      default:
+        targetString = String(target);
+        break;
+    }
+
+    return targetString;
+  }
+
+  // Return a string suitable for printing one failed element in
+  // |beCloseToArray|.
+  function _formatFailureEntry(index, actual, expected, abserr, threshold) {
+    return '\t[' + index + ']\t' + actual.toExponential(16) + '\t' +
+        expected.toExponential(16) + '\t' + abserr.toExponential(16) + '\t' +
+        (abserr / Math.abs(expected)).toExponential(16) + '\t' +
+        threshold.toExponential(16);
+  }
+
+  // Compute the error threshold criterion for |beCloseToArray|
+  function _closeToThreshold(abserr, relerr, expected) {
+    return Math.max(abserr, relerr * Math.abs(expected));
+  }
+
+  /**
+   * @class Should
+   * @description Assertion subtask for the Audit task.
+   * @param {Task} parentTask           Associated Task object.
+   * @param {Any} actual                Target value to be tested.
+   * @param {String} actualDescription  String description of the test target.
+   */
+  class Should {
+    constructor(parentTask, actual, actualDescription) {
+      this._task = parentTask;
+
+      this._actual = actual;
+      this._actualDescription = (actualDescription || null);
+      this._expected = null;
+      this._expectedDescription = null;
+
+      this._detail = '';
+      // If true and the test failed, print the actual value at the
+      // end of the message.
+      this._printActualForFailure = true;
+
+      this._result = null;
+
+      /**
+       * @param {Number} numberOfErrors   Number of errors to be printed.
+       * @param {Number} numberOfArrayElements  Number of array elements to be
+       *                                        printed in the test log.
+       * @param {Boolean} verbose         Verbose output from the assertion.
+       */
+      this._options = {
+        numberOfErrors: 4,
+        numberOfArrayElements: 16,
+        verbose: false
+      };
+    }
+
+    _processArguments(args) {
+      if (args.length === 0)
+        return;
+
+      if (args.length > 0)
+        this._expected = args[0];
+
+      if (typeof args[1] === 'string') {
+        // case 1: (expected, description, options)
+        this._expectedDescription = args[1];
+        Object.assign(this._options, args[2]);
+      } else if (typeof args[1] === 'object') {
+        // case 2: (expected, options)
+        Object.assign(this._options, args[1]);
+      }
+    }
+
+    _buildResultText() {
+      if (this._result === null)
+        _throwException('Illegal invocation: the assertion is not finished.');
+
+      let actualString = _generateDescription(this._actual, this._options);
+
+      // Use generated text when the description is not provided.
+      if (!this._actualDescription)
+        this._actualDescription = actualString;
+
+      if (!this._expectedDescription) {
+        this._expectedDescription =
+            _generateDescription(this._expected, this._options);
+      }
+
+      // For the assertion with a single operand.
+      this._detail =
+          this._detail.replace(/\$\{actual\}/g, this._actualDescription);
+
+      // If there is a second operand (i.e. expected value), we have to build
+      // the string for it as well.
+      this._detail =
+          this._detail.replace(/\$\{expected\}/g, this._expectedDescription);
+
+      // If there is any property in |_options|, replace the property name
+      // with the value.
+      for (let name in this._options) {
+        if (name === 'numberOfErrors' || name === 'numberOfArrayElements' ||
+            name === 'verbose') {
+          continue;
+        }
+
+        // The RegExp key string contains special character. Take care of it.
+        let re = '\$\{' + name + '\}';
+        re = re.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, '\\$1');
+        this._detail = this._detail.replace(
+            new RegExp(re, 'g'), _generateDescription(this._options[name]));
+      }
+
+      // If the test failed, add the actual value at the end.
+      if (this._result === false && this._printActualForFailure === true) {
+        this._detail += ' Got ' + actualString + '.';
+      }
+    }
+
+    _finalize() {
+      if (this._result) {
+        _logPassed('  ' + this._detail);
+      } else {
+        _logFailed('X ' + this._detail);
+      }
+
+      // This assertion is finished, so update the parent task accordingly.
+      this._task.update(this);
+
+      // TODO(hongchan): configurable 'detail' message.
+    }
+
+    _assert(condition, passDetail, failDetail) {
+      this._result = Boolean(condition);
+      this._detail = this._result ? passDetail : failDetail;
+      this._buildResultText();
+      this._finalize();
+
+      return this._result;
+    }
+
+    get result() {
+      return this._result;
+    }
+
+    get detail() {
+      return this._detail;
+    }
+
+    /**
+     * should() assertions.
+     *
+     * @example All the assertions can have 1, 2 or 3 arguments:
+     *   should().doAssert(expected);
+     *   should().doAssert(expected, options);
+     *   should().doAssert(expected, expectedDescription, options);
+     *
+     * @param {Any} expected                  Expected value of the assertion.
+     * @param {String} expectedDescription    Description of expected value.
+     * @param {Object} options                Options for assertion.
+     * @param {Number} options.numberOfErrors Number of errors to be printed.
+     *                                        (if applicable)
+     * @param {Number} options.numberOfArrayElements  Number of array elements
+     *                                                to be printed. (if
+     *                                                applicable)
+     * @notes Some assertions can have additional options for their specific
+     *        testing.
+     */
+
+    /**
+     * Check if |actual| exists.
+     *
+     * @example
+     *   should({}, 'An empty object').exist();
+     * @result
+     *   "PASS   An empty object does exist."
+     */
+    exist() {
+      return this._assert(
+          this._actual !== null && this._actual !== undefined,
+          '${actual} does exist.', '${actual} does not exist.');
+    }
+
+    /**
+     * Check if |actual| operation wrapped in a function throws an exception
+     * with a expected error type correctly. |expected| is optional. If it is an
+     * instance of DOMException, then the description (second argument) can be
+     * provided to be more strict about the expected exception type. |expected|
+     * also can be other generic error types such as TypeError, RangeError or
+     * etc.
+     *
+     * @example
+     *   should(() => { let a = b; }, 'A bad code').throw();
+     *   should(() => { new SomeConstructor(); }, 'A bad construction')
+     *       .throw(DOMException, 'NotSupportedError');
+     *   should(() => { let c = d; }, 'Assigning d to c')
+     *       .throw(ReferenceError);
+     *   should(() => { let e = f; }, 'Assigning e to f')
+     *       .throw(ReferenceError, { omitErrorMessage: true });
+     *
+     * @result
+     *   "PASS   A bad code threw an exception of ReferenceError: b is not
+     *       defined."
+     *   "PASS   A bad construction threw DOMException:NotSupportedError."
+     *   "PASS   Assigning d to c threw ReferenceError: d is not defined."
+     *   "PASS   Assigning e to f threw ReferenceError: [error message
+     *       omitted]."
+     */
+    throw() {
+      this._processArguments(arguments);
+      this._printActualForFailure = false;
+
+      let didThrowCorrectly = false;
+      let passDetail, failDetail;
+
+      try {
+        // This should throw.
+        this._actual();
+        // Catch did not happen, so the test is failed.
+        failDetail = '${actual} did not throw an exception.';
+      } catch (error) {
+        let errorMessage = this._options.omitErrorMessage ?
+            ': [error message omitted]' :
+            ': "' + error.message + '"';
+        if (this._expected === null || this._expected === undefined) {
+          // The expected error type was not given.
+          didThrowCorrectly = true;
+          passDetail = '${actual} threw ' + error.name + errorMessage + '.';
+        } else if (this._expected === DOMException &&
+                   this._expectedDescription !== undefined) {
+          // Handles DOMException with an expected exception name.
+          if (this._expectedDescription === error.name) {
+            didThrowCorrectly = true;
+            passDetail = '${actual} threw ${expected}' + errorMessage + '.';
+          } else {
+            didThrowCorrectly = false;
+            failDetail =
+                '${actual} threw "' + error.name + '" instead of ${expected}.';
+          }
+        } else if (this._expected == error.constructor) {
+          // Handler other error types.
+          didThrowCorrectly = true;
+          passDetail = '${actual} threw ' + error.name + errorMessage + '.';
+        } else {
+          didThrowCorrectly = false;
+          failDetail =
+              '${actual} threw "' + error.name + '" instead of ${expected}.';
+        }
+      }
+
+      return this._assert(didThrowCorrectly, passDetail, failDetail);
+    }
+
+    /**
+     * Check if |actual| operation wrapped in a function does not throws an
+     * exception correctly.
+     *
+     * @example
+     *   should(() => { let foo = 'bar'; }, 'let foo = "bar"').notThrow();
+     *
+     * @result
+     *   "PASS   let foo = "bar" did not throw an exception."
+     */
+    notThrow() {
+      this._printActualForFailure = false;
+
+      let didThrowCorrectly = false;
+      let passDetail, failDetail;
+
+      try {
+        this._actual();
+        passDetail = '${actual} did not throw an exception.';
+      } catch (error) {
+        didThrowCorrectly = true;
+        failDetail = '${actual} incorrectly threw ' + error.name + ': "' +
+            error.message + '".';
+      }
+
+      return this._assert(!didThrowCorrectly, passDetail, failDetail);
+    }
+
+    /**
+     * Check if |actual| promise is resolved correctly. Note that the returned
+     * result from promise object will be passed to the following then()
+     * function.
+     *
+     * @example
+     *   should('My promise', promise).beResolve().then((result) => {
+     *     log(result);
+     *   });
+     *
+     * @result
+     *   "PASS   My promise resolved correctly."
+     *   "FAIL X My promise rejected *INCORRECTLY* with _ERROR_."
+     */
+    beResolved() {
+      return this._actual.then(
+          function(result) {
+            this._assert(true, '${actual} resolved correctly.', null);
+            return result;
+          }.bind(this),
+          function(error) {
+            this._assert(
+                false, null,
+                '${actual} rejected incorrectly with ' + error + '.');
+          }.bind(this));
+    }
+
+    /**
+     * Check if |actual| promise is rejected correctly.
+     *
+     * @example
+     *   should('My promise', promise).beRejected().then(nextStuff);
+     *
+     * @result
+     *   "PASS   My promise rejected correctly (with _ERROR_)."
+     *   "FAIL X My promise resolved *INCORRECTLY*."
+     */
+    beRejected() {
+      return this._actual.then(
+          function() {
+            this._assert(false, null, '${actual} resolved incorrectly.');
+          }.bind(this),
+          function(error) {
+            this._assert(
+                true, '${actual} rejected correctly with ' + error + '.', null);
+          }.bind(this));
+    }
+
+    /**
+     * Check if |actual| promise is rejected correctly.
+     *
+     * @example
+     *   should(promise, 'My promise').beRejectedWith('_ERROR_').then();
+     *
+     * @result
+     *   "PASS   My promise rejected correctly with _ERROR_."
+     *   "FAIL X My promise rejected correctly but got _ACTUAL_ERROR instead of
+     *           _EXPECTED_ERROR_."
+     *   "FAIL X My promise resolved incorrectly."
+     */
+    beRejectedWith() {
+      this._processArguments(arguments);
+
+      return this._actual.then(
+          function() {
+            this._assert(false, null, '${actual} resolved incorrectly.');
+          }.bind(this),
+          function(error) {
+            if (this._expected !== error.name) {
+              this._assert(
+                  false, null,
+                  '${actual} rejected correctly but got ' + error.name +
+                      ' instead of ' + this._expected + '.');
+            } else {
+              this._assert(
+                  true,
+                  '${actual} rejected correctly with ' + this._expected + '.',
+                  null);
+            }
+          }.bind(this));
+    }
+
+    /**
+     * Check if |actual| is a boolean true.
+     *
+     * @example
+     *   should(3 < 5, '3 < 5').beTrue();
+     *
+     * @result
+     *   "PASS   3 < 5 is true."
+     */
+    beTrue() {
+      return this._assert(
+          this._actual === true, '${actual} is true.',
+          '${actual} is not true.');
+    }
+
+    /**
+     * Check if |actual| is a boolean false.
+     *
+     * @example
+     *   should(3 > 5, '3 > 5').beFalse();
+     *
+     * @result
+     *   "PASS   3 > 5 is false."
+     */
+    beFalse() {
+      return this._assert(
+          this._actual === false, '${actual} is false.',
+          '${actual} is not false.');
+    }
+
+    /**
+     * Check if |actual| is strictly equal to |expected|. (no type coercion)
+     *
+     * @example
+     *   should(1).beEqualTo(1);
+     *
+     * @result
+     *   "PASS   1 is equal to 1."
+     */
+    beEqualTo() {
+      this._processArguments(arguments);
+      return this._assert(
+          this._actual === this._expected, '${actual} is equal to ${expected}.',
+          '${actual} is not equal to ${expected}.');
+    }
+
+    /**
+     * Check if |actual| is not equal to |expected|.
+     *
+     * @example
+     *   should(1).notBeEqualTo(2);
+     *
+     * @result
+     *   "PASS   1 is not equal to 2."
+     */
+    notBeEqualTo() {
+      this._processArguments(arguments);
+      return this._assert(
+          this._actual !== this._expected,
+          '${actual} is not equal to ${expected}.',
+          '${actual} should not be equal to ${expected}.');
+    }
+
+    /**
+     * check if |actual| is NaN
+     *
+     * @example
+     *   should(NaN).beNaN();
+     *
+     * @result
+     *   "PASS   NaN is NaN"
+     *
+     */
+    beNaN() {
+      this._processArguments(arguments);
+      return this._assert(
+          isNaN(this._actual),
+          '${actual} is NaN.',
+          '${actual} is not NaN but should be.');
+    }
+
+    /**
+     * check if |actual| is NOT NaN
+     *
+     * @example
+     *   should(42).notBeNaN();
+     *
+     * @result
+     *   "PASS   42 is not NaN"
+     *
+     */
+    notBeNaN() {
+      this._processArguments(arguments);
+      return this._assert(
+          !isNaN(this._actual),
+          '${actual} is not NaN.',
+          '${actual} is NaN but should not be.');
+    }
+
+    /**
+     * Check if |actual| is greater than |expected|.
+     *
+     * @example
+     *   should(2).beGreaterThanOrEqualTo(2);
+     *
+     * @result
+     *   "PASS   2 is greater than or equal to 2."
+     */
+    beGreaterThan() {
+      this._processArguments(arguments);
+      return this._assert(
+          this._actual > this._expected,
+          '${actual} is greater than ${expected}.',
+          '${actual} is not greater than ${expected}.');
+    }
+
+    /**
+     * Check if |actual| is greater than or equal to |expected|.
+     *
+     * @example
+     *   should(2).beGreaterThan(1);
+     *
+     * @result
+     *   "PASS   2 is greater than 1."
+     */
+    beGreaterThanOrEqualTo() {
+      this._processArguments(arguments);
+      return this._assert(
+          this._actual >= this._expected,
+          '${actual} is greater than or equal to ${expected}.',
+          '${actual} is not greater than or equal to ${expected}.');
+    }
+
+    /**
+     * Check if |actual| is less than |expected|.
+     *
+     * @example
+     *   should(1).beLessThan(2);
+     *
+     * @result
+     *   "PASS   1 is less than 2."
+     */
+    beLessThan() {
+      this._processArguments(arguments);
+      return this._assert(
+          this._actual < this._expected, '${actual} is less than ${expected}.',
+          '${actual} is not less than ${expected}.');
+    }
+
+    /**
+     * Check if |actual| is less than or equal to |expected|.
+     *
+     * @example
+     *   should(1).beLessThanOrEqualTo(1);
+     *
+     * @result
+     *   "PASS   1 is less than or equal to 1."
+     */
+    beLessThanOrEqualTo() {
+      this._processArguments(arguments);
+      return this._assert(
+          this._actual <= this._expected,
+          '${actual} is less than or equal to ${expected}.',
+          '${actual} is not less than or equal to ${expected}.');
+    }
+
+    /**
+     * Check if |actual| array is filled with a constant |expected| value.
+     *
+     * @example
+     *   should([1, 1, 1]).beConstantValueOf(1);
+     *
+     * @result
+     *   "PASS   [1,1,1] contains only the constant 1."
+     */
+    beConstantValueOf() {
+      this._processArguments(arguments);
+      this._printActualForFailure = false;
+
+      let passed = true;
+      let passDetail, failDetail;
+      let errors = {};
+
+      let actual = this._actual;
+      let expected = this._expected;
+      for (let index = 0; index < actual.length; ++index) {
+        if (actual[index] !== expected)
+          errors[index] = actual[index];
+      }
+
+      let numberOfErrors = Object.keys(errors).length;
+      passed = numberOfErrors === 0;
+
+      if (passed) {
+        passDetail = '${actual} contains only the constant ${expected}.';
+      } else {
+        let counter = 0;
+        failDetail =
+            '${actual}: Expected ${expected} for all values but found ' +
+            numberOfErrors + ' unexpected values: ';
+        failDetail += '\n\tIndex\tActual';
+        for (let errorIndex in errors) {
+          failDetail += '\n\t[' + errorIndex + ']' +
+              '\t' + errors[errorIndex];
+          if (++counter >= this._options.numberOfErrors) {
+            failDetail +=
+                '\n\t...and ' + (numberOfErrors - counter) + ' more errors.';
+            break;
+          }
+        }
+      }
+
+      return this._assert(passed, passDetail, failDetail);
+    }
+
+    /**
+     * Check if |actual| array is not filled with a constant |expected| value.
+     *
+     * @example
+     *   should([1, 0, 1]).notBeConstantValueOf(1);
+     *   should([0, 0, 0]).notBeConstantValueOf(0);
+     *
+     * @result
+     *   "PASS   [1,0,1] is not constantly 1 (contains 1 different value)."
+     *   "FAIL X [0,0,0] should have contain at least one value different
+     *     from 0."
+     */
+    notBeConstantValueOf() {
+      this._processArguments(arguments);
+      this._printActualForFailure = false;
+
+      let passed = true;
+      let passDetail;
+      let failDetail;
+      let differences = {};
+
+      let actual = this._actual;
+      let expected = this._expected;
+      for (let index = 0; index < actual.length; ++index) {
+        if (actual[index] !== expected)
+          differences[index] = actual[index];
+      }
+
+      let numberOfDifferences = Object.keys(differences).length;
+      passed = numberOfDifferences > 0;
+
+      if (passed) {
+        let valueString = numberOfDifferences > 1 ? 'values' : 'value';
+        passDetail = '${actual} is not constantly ${expected} (contains ' +
+            numberOfDifferences + ' different ' + valueString + ').';
+      } else {
+        failDetail = '${actual} should have contain at least one value ' +
+            'different from ${expected}.';
+      }
+
+      return this._assert(passed, passDetail, failDetail);
+    }
+
+    /**
+     * Check if |actual| array is identical to |expected| array element-wise.
+     *
+     * @example
+     *   should([1, 2, 3]).beEqualToArray([1, 2, 3]);
+     *
+     * @result
+     *   "[1,2,3] is identical to the array [1,2,3]."
+     */
+    beEqualToArray() {
+      this._processArguments(arguments);
+      this._printActualForFailure = false;
+
+      let passed = true;
+      let passDetail, failDetail;
+      let errorIndices = [];
+
+      if (this._actual.length !== this._expected.length) {
+        passed = false;
+        failDetail = 'The array length does not match.';
+        return this._assert(passed, passDetail, failDetail);
+      }
+
+      let actual = this._actual;
+      let expected = this._expected;
+      for (let index = 0; index < actual.length; ++index) {
+        if (actual[index] !== expected[index])
+          errorIndices.push(index);
+      }
+
+      passed = errorIndices.length === 0;
+
+      if (passed) {
+        passDetail = '${actual} is identical to the array ${expected}.';
+      } else {
+        let counter = 0;
+        failDetail =
+            '${actual} expected to be equal to the array ${expected} ' +
+            'but differs in ' + errorIndices.length + ' places:' +
+            '\n\tIndex\tActual\t\t\tExpected';
+        for (let index of errorIndices) {
+          failDetail += '\n\t[' + index + ']' +
+              '\t' + this._actual[index].toExponential(16) + '\t' +
+              this._expected[index].toExponential(16);
+          if (++counter >= this._options.numberOfErrors) {
+            failDetail += '\n\t...and ' + (errorIndices.length - counter) +
+                ' more errors.';
+            break;
+          }
+        }
+      }
+
+      return this._assert(passed, passDetail, failDetail);
+    }
+
+    /**
+     * Check if |actual| array contains only the values in |expected| in the
+     * order of values in |expected|.
+     *
+     * @example
+     *   Should([1, 1, 3, 3, 2], 'My random array').containValues([1, 3, 2]);
+     *
+     * @result
+     *   "PASS   [1,1,3,3,2] contains all the expected values in the correct
+     *           order: [1,3,2].
+     */
+    containValues() {
+      this._processArguments(arguments);
+      this._printActualForFailure = false;
+
+      let passed = true;
+      let indexedActual = [];
+      let firstErrorIndex = null;
+
+      // Collect the unique value sequence from the actual.
+      for (let i = 0, prev = null; i < this._actual.length; i++) {
+        if (this._actual[i] !== prev) {
+          indexedActual.push({index: i, value: this._actual[i]});
+          prev = this._actual[i];
+        }
+      }
+
+      // Compare against the expected sequence.
+      let failMessage =
+          '${actual} expected to have the value sequence of ${expected} but ' +
+          'got ';
+      if (this._expected.length === indexedActual.length) {
+        for (let j = 0; j < this._expected.length; j++) {
+          if (this._expected[j] !== indexedActual[j].value) {
+            firstErrorIndex = indexedActual[j].index;
+            passed = false;
+            failMessage += this._actual[firstErrorIndex] + ' at index ' +
+                firstErrorIndex + '.';
+            break;
+          }
+        }
+      } else {
+        passed = false;
+        let indexedValues = indexedActual.map(x => x.value);
+        failMessage += `${indexedActual.length} values, [${
+            indexedValues}], instead of ${this._expected.length}.`;
+      }
+
+      return this._assert(
+          passed,
+          '${actual} contains all the expected values in the correct order: ' +
+              '${expected}.',
+          failMessage);
+    }
+
+    /**
+     * Check if |actual| array does not have any glitches. Note that |threshold|
+     * is not optional and is to define the desired threshold value.
+     *
+     * @example
+     *   should([0.5, 0.5, 0.55, 0.5, 0.45, 0.5]).notGlitch(0.06);
+     *
+     * @result
+     *   "PASS   [0.5,0.5,0.55,0.5,0.45,0.5] has no glitch above the threshold
+     *           of 0.06."
+     *
+     */
+    notGlitch() {
+      this._processArguments(arguments);
+      this._printActualForFailure = false;
+
+      let passed = true;
+      let passDetail, failDetail;
+
+      let actual = this._actual;
+      let expected = this._expected;
+      for (let index = 0; index < actual.length; ++index) {
+        let diff = Math.abs(actual[index - 1] - actual[index]);
+        if (diff >= expected) {
+          passed = false;
+          failDetail = '${actual} has a glitch at index ' + index +
+              ' of size ' + diff + '.';
+        }
+      }
+
+      passDetail =
+          '${actual} has no glitch above the threshold of ${expected}.';
+
+      return this._assert(passed, passDetail, failDetail);
+    }
+
+    /**
+     * Check if |actual| is close to |expected| using the given relative error
+     * |threshold|.
+     *
+     * @example
+     *   should(2.3).beCloseTo(2, { threshold: 0.3 });
+     *
+     * @result
+     *   "PASS    2.3 is 2 within an error of 0.3."
+     * @param {Object} options              Options for assertion.
+     * @param {Number} options.threshold    Threshold value for the comparison.
+     */
+    beCloseTo() {
+      this._processArguments(arguments);
+
+      // The threshold is relative except when |expected| is zero, in which case
+      // it is absolute.
+      let absExpected = this._expected ? Math.abs(this._expected) : 1;
+      let error = Math.abs(this._actual - this._expected) / absExpected;
+
+      return this._assert(
+          error <= this._options.threshold,
+          '${actual} is ${expected} within an error of ${threshold}.',
+          '${actual} is not close to ${expected} within a relative error of ' +
+              '${threshold} (RelErr=' + error + ').');
+    }
+
+    /**
+     * Check if |target| array is close to |expected| array element-wise within
+     * a certain error bound given by the |options|.
+     *
+     * The error criterion is:
+     *   abs(actual[k] - expected[k]) < max(absErr, relErr * abs(expected))
+     *
+     * If nothing is given for |options|, then absErr = relErr = 0. If
+     * absErr = 0, then the error criterion is a relative error. A non-zero
+     * absErr value produces a mix intended to handle the case where the
+     * expected value is 0, allowing the target value to differ by absErr from
+     * the expected.
+     *
+     * @param {Number} options.absoluteThreshold    Absolute threshold.
+     * @param {Number} options.relativeThreshold    Relative threshold.
+     */
+    beCloseToArray() {
+      this._processArguments(arguments);
+      this._printActualForFailure = false;
+
+      let passed = true;
+      let passDetail, failDetail;
+
+      // Parsing options.
+      let absErrorThreshold = (this._options.absoluteThreshold || 0);
+      let relErrorThreshold = (this._options.relativeThreshold || 0);
+
+      // A collection of all of the values that satisfy the error criterion.
+      // This holds the absolute difference between the target element and the
+      // expected element.
+      let errors = {};
+
+      // Keep track of the max absolute error found.
+      let maxAbsError = -Infinity, maxAbsErrorIndex = -1;
+
+      // Keep track of the max relative error found, ignoring cases where the
+      // relative error is Infinity because the expected value is 0.
+      let maxRelError = -Infinity, maxRelErrorIndex = -1;
+
+      let actual = this._actual;
+      let expected = this._expected;
+
+      for (let index = 0; index < expected.length; ++index) {
+        let diff = Math.abs(actual[index] - expected[index]);
+        let absExpected = Math.abs(expected[index]);
+        let relError = diff / absExpected;
+
+        if (diff >
+            Math.max(absErrorThreshold, relErrorThreshold * absExpected)) {
+          if (diff > maxAbsError) {
+            maxAbsErrorIndex = index;
+            maxAbsError = diff;
+          }
+
+          if (!isNaN(relError) && relError > maxRelError) {
+            maxRelErrorIndex = index;
+            maxRelError = relError;
+          }
+
+          errors[index] = diff;
+        }
+      }
+
+      let numberOfErrors = Object.keys(errors).length;
+      let maxAllowedErrorDetail = JSON.stringify({
+        absoluteThreshold: absErrorThreshold,
+        relativeThreshold: relErrorThreshold
+      });
+
+      if (numberOfErrors === 0) {
+        // The assertion was successful.
+        passDetail = '${actual} equals ${expected} with an element-wise ' +
+            'tolerance of ' + maxAllowedErrorDetail + '.';
+      } else {
+        // Failed. Prepare the detailed failure log.
+        passed = false;
+        failDetail = '${actual} does not equal ${expected} with an ' +
+            'element-wise tolerance of ' + maxAllowedErrorDetail + '.\n';
+
+        // Print out actual, expected, absolute error, and relative error.
+        let counter = 0;
+        failDetail += '\tIndex\tActual\t\t\tExpected\t\tAbsError' +
+            '\t\tRelError\t\tTest threshold';
+        let printedIndices = [];
+        for (let index in errors) {
+          failDetail +=
+              '\n' +
+              _formatFailureEntry(
+                  index, actual[index], expected[index], errors[index],
+                  _closeToThreshold(
+                      absErrorThreshold, relErrorThreshold, expected[index]));
+
+          printedIndices.push(index);
+          if (++counter > this._options.numberOfErrors) {
+            failDetail +=
+                '\n\t...and ' + (numberOfErrors - counter) + ' more errors.';
+            break;
+          }
+        }
+
+        // Finalize the error log: print out the location of both the maxAbs
+        // error and the maxRel error so we can adjust thresholds appropriately
+        // in the test.
+        failDetail += '\n' +
+            '\tMax AbsError of ' + maxAbsError.toExponential(16) +
+            ' at index of ' + maxAbsErrorIndex + '.\n';
+        if (printedIndices.find(element => {
+              return element == maxAbsErrorIndex;
+            }) === undefined) {
+          // Print an entry for this index if we haven't already.
+          failDetail +=
+              _formatFailureEntry(
+                  maxAbsErrorIndex, actual[maxAbsErrorIndex],
+                  expected[maxAbsErrorIndex], errors[maxAbsErrorIndex],
+                  _closeToThreshold(
+                      absErrorThreshold, relErrorThreshold,
+                      expected[maxAbsErrorIndex])) +
+              '\n';
+        }
+        failDetail += '\tMax RelError of ' + maxRelError.toExponential(16) +
+            ' at index of ' + maxRelErrorIndex + '.\n';
+        if (printedIndices.find(element => {
+              return element == maxRelErrorIndex;
+            }) === undefined) {
+          // Print an entry for this index if we haven't already.
+          failDetail +=
+              _formatFailureEntry(
+                  maxRelErrorIndex, actual[maxRelErrorIndex],
+                  expected[maxRelErrorIndex], errors[maxRelErrorIndex],
+                  _closeToThreshold(
+                      absErrorThreshold, relErrorThreshold,
+                      expected[maxRelErrorIndex])) +
+              '\n';
+        }
+      }
+
+      return this._assert(passed, passDetail, failDetail);
+    }
+
+    /**
+     * A temporary escape hat for printing an in-task message. The description
+     * for the |actual| is required to get the message printed properly.
+     *
+     * TODO(hongchan): remove this method when the transition from the old Audit
+     * to the new Audit is completed.
+     * @example
+     *   should(true, 'The message is').message('truthful!', 'false!');
+     *
+     * @result
+     *   "PASS   The message is truthful!"
+     */
+    message(passDetail, failDetail) {
+      return this._assert(
+          this._actual, '${actual} ' + passDetail, '${actual} ' + failDetail);
+    }
+
+    /**
+     * Check if |expected| property is truly owned by |actual| object.
+     *
+     * @example
+     *   should(BaseAudioContext.prototype,
+     *          'BaseAudioContext.prototype').haveOwnProperty('createGain');
+     *
+     * @result
+     *   "PASS   BaseAudioContext.prototype has an own property of
+     *       'createGain'."
+     */
+    haveOwnProperty() {
+      this._processArguments(arguments);
+
+      return this._assert(
+          this._actual.hasOwnProperty(this._expected),
+          '${actual} has an own property of "${expected}".',
+          '${actual} does not own the property of "${expected}".');
+    }
+
+
+    /**
+     * Check if |expected| property is not owned by |actual| object.
+     *
+     * @example
+     *   should(BaseAudioContext.prototype,
+     *          'BaseAudioContext.prototype')
+     *       .notHaveOwnProperty('startRendering');
+     *
+     * @result
+     *   "PASS   BaseAudioContext.prototype does not have an own property of
+     *       'startRendering'."
+     */
+    notHaveOwnProperty() {
+      this._processArguments(arguments);
+
+      return this._assert(
+          !this._actual.hasOwnProperty(this._expected),
+          '${actual} does not have an own property of "${expected}".',
+          '${actual} has an own the property of "${expected}".')
+    }
+
+
+    /**
+     * Check if an object is inherited from a class. This looks up the entire
+     * prototype chain of a given object and tries to find a match.
+     *
+     * @example
+     *   should(sourceNode, 'A buffer source node')
+     *       .inheritFrom('AudioScheduledSourceNode');
+     *
+     * @result
+     *   "PASS   A buffer source node inherits from 'AudioScheduledSourceNode'."
+     */
+    inheritFrom() {
+      this._processArguments(arguments);
+
+      let prototypes = [];
+      let currentPrototype = Object.getPrototypeOf(this._actual);
+      while (currentPrototype) {
+        prototypes.push(currentPrototype.constructor.name);
+        currentPrototype = Object.getPrototypeOf(currentPrototype);
+      }
+
+      return this._assert(
+          prototypes.includes(this._expected),
+          '${actual} inherits from "${expected}".',
+          '${actual} does not inherit from "${expected}".');
+    }
+  }
+
+
+  // Task Class state enum.
+  const TaskState = {PENDING: 0, STARTED: 1, FINISHED: 2};
+
+
+  /**
+   * @class Task
+   * @description WebAudio testing task. Managed by TaskRunner.
+   */
+  class Task {
+    /**
+     * Task constructor.
+     * @param  {Object} taskRunner Reference of associated task runner.
+     * @param  {String||Object} taskLabel Task label if a string is given. This
+     *                                    parameter can be a dictionary with the
+     *                                    following fields.
+     * @param  {String} taskLabel.label Task label.
+     * @param  {String} taskLabel.description Description of task.
+     * @param  {Function} taskFunction Task function to be performed.
+     * @return {Object} Task object.
+     */
+    constructor(taskRunner, taskLabel, taskFunction) {
+      this._taskRunner = taskRunner;
+      this._taskFunction = taskFunction;
+
+      if (typeof taskLabel === 'string') {
+        this._label = taskLabel;
+        this._description = null;
+      } else if (typeof taskLabel === 'object') {
+        if (typeof taskLabel.label !== 'string') {
+          _throwException('Task.constructor:: task label must be string.');
+        }
+        this._label = taskLabel.label;
+        this._description = (typeof taskLabel.description === 'string') ?
+            taskLabel.description :
+            null;
+      } else {
+        _throwException(
+            'Task.constructor:: task label must be a string or ' +
+            'a dictionary.');
+      }
+
+      this._state = TaskState.PENDING;
+      this._result = true;
+
+      this._totalAssertions = 0;
+      this._failedAssertions = 0;
+    }
+
+    get label() {
+      return this._label;
+    }
+
+    get state() {
+      return this._state;
+    }
+
+    get result() {
+      return this._result;
+    }
+
+    // Start the assertion chain.
+    should(actual, actualDescription) {
+      // If no argument is given, we cannot proceed. Halt.
+      if (arguments.length === 0)
+        _throwException('Task.should:: requires at least 1 argument.');
+
+      return new Should(this, actual, actualDescription);
+    }
+
+    // Run this task. |this| task will be passed into the user-supplied test
+    // task function.
+    run(harnessTest) {
+      this._state = TaskState.STARTED;
+      this._harnessTest = harnessTest;
+      // Print out the task entry with label and description.
+      _logPassed(
+          '> [' + this._label + '] ' +
+          (this._description ? this._description : ''));
+
+      return new Promise((resolve, reject) => {
+        this._resolve = resolve;
+        this._reject = reject;
+        let result = this._taskFunction(this, this.should.bind(this));
+        if (result && typeof result.then === "function") {
+          result.then(() => this.done()).catch(reject);
+        }
+      });
+    }
+
+    // Update the task success based on the individual assertion/test inside.
+    update(subTask) {
+      // After one of tests fails within a task, the result is irreversible.
+      if (subTask.result === false) {
+        this._result = false;
+        this._failedAssertions++;
+      }
+
+      this._totalAssertions++;
+    }
+
+    // Finish the current task and start the next one if available.
+    done() {
+      assert_equals(this._state, TaskState.STARTED)
+      this._state = TaskState.FINISHED;
+
+      let message = '< [' + this._label + '] ';
+
+      if (this._result) {
+        message += 'All assertions passed. (total ' + this._totalAssertions +
+            ' assertions)';
+        _logPassed(message);
+      } else {
+        message += this._failedAssertions + ' out of ' + this._totalAssertions +
+            ' assertions were failed.'
+        _logFailed(message);
+      }
+
+      this._resolve();
+    }
+
+    // Runs |subTask| |time| milliseconds later. |setTimeout| is not allowed in
+    // WPT linter, so a thin wrapper around the harness's |step_timeout| is
+    // used here.  Returns a Promise which is resolved after |subTask| runs.
+    timeout(subTask, time) {
+      return new Promise(resolve => {
+        this._harnessTest.step_timeout(() => {
+          let result = subTask();
+          if (result && typeof result.then === "function") {
+            // Chain rejection directly to the harness test Promise, to report
+            // the rejection against the subtest even when the caller of
+            // timeout does not handle the rejection.
+            result.then(resolve, this._reject());
+          } else {
+            resolve();
+          }
+        }, time);
+      });
+    }
+
+    isPassed() {
+      return this._state === TaskState.FINISHED && this._result;
+    }
+
+    toString() {
+      return '"' + this._label + '": ' + this._description;
+    }
+  }
+
+
+  /**
+   * @class TaskRunner
+   * @description WebAudio testing task runner. Manages tasks.
+   */
+  class TaskRunner {
+    constructor() {
+      this._tasks = {};
+      this._taskSequence = [];
+
+      // Configure testharness.js for the async operation.
+      setup(new Function(), {explicit_done: true});
+    }
+
+    _finish() {
+      let numberOfFailures = 0;
+      for (let taskIndex in this._taskSequence) {
+        let task = this._tasks[this._taskSequence[taskIndex]];
+        numberOfFailures += task.result ? 0 : 1;
+      }
+
+      let prefix = '# AUDIT TASK RUNNER FINISHED: ';
+      if (numberOfFailures > 0) {
+        _logFailed(
+            prefix + numberOfFailures + ' out of ' + this._taskSequence.length +
+            ' tasks were failed.');
+      } else {
+        _logPassed(
+            prefix + this._taskSequence.length + ' tasks ran successfully.');
+      }
+
+      return Promise.resolve();
+    }
+
+    // |taskLabel| can be either a string or a dictionary. See Task constructor
+    // for the detail.  If |taskFunction| returns a thenable, then the task
+    // is considered complete when the thenable is fulfilled; otherwise the
+    // task must be completed with an explicit call to |task.done()|.
+    define(taskLabel, taskFunction) {
+      let task = new Task(this, taskLabel, taskFunction);
+      if (this._tasks.hasOwnProperty(task.label)) {
+        _throwException('Audit.define:: Duplicate task definition.');
+        return;
+      }
+      this._tasks[task.label] = task;
+      this._taskSequence.push(task.label);
+    }
+
+    // Start running all the tasks scheduled. Multiple task names can be passed
+    // to execute them sequentially. Zero argument will perform all defined
+    // tasks in the order of definition.
+    run() {
+      // Display the beginning of the test suite.
+      _logPassed('# AUDIT TASK RUNNER STARTED.');
+
+      // If the argument is specified, override the default task sequence with
+      // the specified one.
+      if (arguments.length > 0) {
+        this._taskSequence = [];
+        for (let i = 0; i < arguments.length; i++) {
+          let taskLabel = arguments[i];
+          if (!this._tasks.hasOwnProperty(taskLabel)) {
+            _throwException('Audit.run:: undefined task.');
+          } else if (this._taskSequence.includes(taskLabel)) {
+            _throwException('Audit.run:: duplicate task request.');
+          } else {
+            this._taskSequence.push(taskLabel);
+          }
+        }
+      }
+
+      if (this._taskSequence.length === 0) {
+        _throwException('Audit.run:: no task to run.');
+        return;
+      }
+
+      for (let taskIndex in this._taskSequence) {
+        let task = this._tasks[this._taskSequence[taskIndex]];
+        // Some tests assume that tasks run in sequence, which is provided by
+        // promise_test().
+        promise_test((t) => task.run(t), `Executing "${task.label}"`);
+      }
+
+      // Schedule a summary report on completion.
+      promise_test(() => this._finish(), "Audit report");
+
+      // From testharness.js. The harness now need not wait for more subtests
+      // to be added.
+      _testharnessDone();
+    }
+  }
+
+  /**
+   * Load file from a given URL and pass ArrayBuffer to the following promise.
+   * @param  {String} fileUrl file URL.
+   * @return {Promise}
+   *
+   * @example
+   *   Audit.loadFileFromUrl('resources/my-sound.ogg').then((response) => {
+   *       audioContext.decodeAudioData(response).then((audioBuffer) => {
+   *           // Do something with AudioBuffer.
+   *       });
+   *   });
+   */
+  function loadFileFromUrl(fileUrl) {
+    return new Promise((resolve, reject) => {
+      let xhr = new XMLHttpRequest();
+      xhr.open('GET', fileUrl, true);
+      xhr.responseType = 'arraybuffer';
+
+      xhr.onload = () => {
+        // |status = 0| is a workaround for the run_web_test.py server. We are
+        // speculating the server quits the transaction prematurely without
+        // completing the request.
+        if (xhr.status === 200 || xhr.status === 0) {
+          resolve(xhr.response);
+        } else {
+          let errorMessage = 'loadFile: Request failed when loading ' +
+              fileUrl + '. ' + xhr.statusText + '. (status = ' + xhr.status +
+              ')';
+          if (reject) {
+            reject(errorMessage);
+          } else {
+            new Error(errorMessage);
+          }
+        }
+      };
+
+      xhr.onerror = (event) => {
+        let errorMessage =
+            'loadFile: Network failure when loading ' + fileUrl + '.';
+        if (reject) {
+          reject(errorMessage);
+        } else {
+          new Error(errorMessage);
+        }
+      };
+
+      xhr.send();
+    });
+  }
+
+  /**
+   * @class Audit
+   * @description A WebAudio layout test task manager.
+   * @example
+   *   let audit = Audit.createTaskRunner();
+   *   audit.define('first-task', function (task, should) {
+   *     should(someValue).beEqualTo(someValue);
+   *     task.done();
+   *   });
+   *   audit.run();
+   */
+  return {
+
+    /**
+     * Creates an instance of Audit task runner.
+     * @param {Object}  options                     Options for task runner.
+     * @param {Boolean} options.requireResultFile   True if the test suite
+     *                                              requires explicit text
+     *                                              comparison with the expected
+     *                                              result file.
+     */
+    createTaskRunner: function(options) {
+      if (options && options.requireResultFile == true) {
+        _logError(
+            'this test requires the explicit comparison with the ' +
+            'expected result when it runs with run_web_tests.py.');
+      }
+
+      return new TaskRunner();
+    },
+
+    /**
+     * Load file from a given URL and pass ArrayBuffer to the following promise.
+     * See |loadFileFromUrl| method for the detail.
+     */
+    loadFileFromUrl: loadFileFromUrl
+
+  };
+
+})();
diff --git a/testing/web-platform/tests/webaudio/resources/biquad-filters.js b/testing/web-platform/tests/webaudio/resources/biquad-filters.js
new file mode 100644
index 0000000000..467436326a
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/resources/biquad-filters.js
@@ -0,0 +1,376 @@
+// A biquad filter has a z-transform of
+// H(z) = (b0 + b1 / z + b2 / z^2) / (1 + a1 / z + a2 / z^2)
+//
+// The formulas for the various filters were taken from
+// http://www.musicdsp.org/files/Audio-EQ-Cookbook.txt.
+
+
+// Lowpass filter.
+function createLowpassFilter(freq, q, gain) {
+  let b0;
+  let b1;
+  let b2;
+  let a0;
+  let a1;
+  let a2;
+
+  if (freq == 1) {
+    // The formula below works, except for roundoff.  When freq = 1,
+    // the filter is just a wire, so hardwire the coefficients.
+    b0 = 1;
+    b1 = 0;
+    b2 = 0;
+    a0 = 1;
+    a1 = 0;
+    a2 = 0;
+  } else {
+    let theta = Math.PI * freq;
+    let alpha = Math.sin(theta) / (2 * Math.pow(10, q / 20));
+    let cosw = Math.cos(theta);
+    let beta = (1 - cosw) / 2;
+
+    b0 = beta;
+    b1 = 2 * beta;
+    b2 = beta;
+    a0 = 1 + alpha;
+    a1 = -2 * cosw;
+    a2 = 1 - alpha;
+  }
+
+  return normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2);
+}
+
+function createHighpassFilter(freq, q, gain) {
+  let b0;
+  let b1;
+  let b2;
+  let a0;
+  let a1;
+  let a2;
+
+  if (freq == 1) {
+    // The filter is 0
+    b0 = 0;
+    b1 = 0;
+    b2 = 0;
+    a0 = 1;
+    a1 = 0;
+    a2 = 0;
+  } else if (freq == 0) {
+    // The filter is 1.  Computation of coefficients below is ok, but
+    // there's a pole at 1 and a zero at 1, so round-off could make
+    // the filter unstable.
+    b0 = 1;
+    b1 = 0;
+    b2 = 0;
+    a0 = 1;
+    a1 = 0;
+    a2 = 0;
+  } else {
+    let theta = Math.PI * freq;
+    let alpha = Math.sin(theta) / (2 * Math.pow(10, q / 20));
+    let cosw = Math.cos(theta);
+    let beta = (1 + cosw) / 2;
+
+    b0 = beta;
+    b1 = -2 * beta;
+    b2 = beta;
+    a0 = 1 + alpha;
+    a1 = -2 * cosw;
+    a2 = 1 - alpha;
+  }
+
+  return normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2);
+}
+
+function normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2) {
+  let scale = 1 / a0;
+
+  return {
+    b0: b0 * scale,
+    b1: b1 * scale,
+    b2: b2 * scale,
+    a1: a1 * scale,
+    a2: a2 * scale
+  };
+}
+
+function createBandpassFilter(freq, q, gain) {
+  let b0;
+  let b1;
+  let b2;
+  let a0;
+  let a1;
+  let a2;
+  let coef;
+
+  if (freq > 0 && freq < 1) {
+    let w0 = Math.PI * freq;
+    if (q > 0) {
+      let alpha = Math.sin(w0) / (2 * q);
+      let k = Math.cos(w0);
+
+      b0 = alpha;
+      b1 = 0;
+      b2 = -alpha;
+      a0 = 1 + alpha;
+      a1 = -2 * k;
+      a2 = 1 - alpha;
+
+      coef = normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2);
+    } else {
+      // q = 0, and frequency is not 0 or 1.  The above formula has a
+      // divide by zero problem.  The limit of the z-transform as q
+      // approaches 0 is 1, so set the filter that way.
+      coef = {b0: 1, b1: 0, b2: 0, a1: 0, a2: 0};
+    }
+  } else {
+    // When freq = 0 or 1, the z-transform is identically 0,
+    // independent of q.
+    coef = { b0: 0, b1: 0, b2: 0, a1: 0, a2: 0 }
+  }
+
+  return coef;
+}
+
+function createLowShelfFilter(freq, q, gain) {
+  // q not used
+  let b0;
+  let b1;
+  let b2;
+  let a0;
+  let a1;
+  let a2;
+  let coef;
+
+  let S = 1;
+  let A = Math.pow(10, gain / 40);
+
+  if (freq == 1) {
+    // The filter is just a constant gain
+    coef = {b0: A * A, b1: 0, b2: 0, a1: 0, a2: 0};
+  } else if (freq == 0) {
+    // The filter is 1
+    coef = {b0: 1, b1: 0, b2: 0, a1: 0, a2: 0};
+  } else {
+    let w0 = Math.PI * freq;
+    let alpha = 1 / 2 * Math.sin(w0) * Math.sqrt((A + 1 / A) * (1 / S - 1) + 2);
+    let k = Math.cos(w0);
+    let k2 = 2 * Math.sqrt(A) * alpha;
+    let Ap1 = A + 1;
+    let Am1 = A - 1;
+
+    b0 = A * (Ap1 - Am1 * k + k2);
+    b1 = 2 * A * (Am1 - Ap1 * k);
+    b2 = A * (Ap1 - Am1 * k - k2);
+    a0 = Ap1 + Am1 * k + k2;
+    a1 = -2 * (Am1 + Ap1 * k);
+    a2 = Ap1 + Am1 * k - k2;
+    coef = normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2);
+  }
+
+  return coef;
+}
+
+function createHighShelfFilter(freq, q, gain) {
+  // q not used
+  let b0;
+  let b1;
+  let b2;
+  let a0;
+  let a1;
+  let a2;
+  let coef;
+
+  let A = Math.pow(10, gain / 40);
+
+  if (freq == 1) {
+    // When freq = 1, the z-transform is 1
+    coef = {b0: 1, b1: 0, b2: 0, a1: 0, a2: 0};
+  } else if (freq > 0) {
+    let w0 = Math.PI * freq;
+    let S = 1;
+    let alpha = 0.5 * Math.sin(w0) * Math.sqrt((A + 1 / A) * (1 / S - 1) + 2);
+    let k = Math.cos(w0);
+    let k2 = 2 * Math.sqrt(A) * alpha;
+    let Ap1 = A + 1;
+    let Am1 = A - 1;
+
+    b0 = A * (Ap1 + Am1 * k + k2);
+    b1 = -2 * A * (Am1 + Ap1 * k);
+    b2 = A * (Ap1 + Am1 * k - k2);
+    a0 = Ap1 - Am1 * k + k2;
+    a1 = 2 * (Am1 - Ap1 * k);
+    a2 = Ap1 - Am1 * k - k2;
+
+    coef = normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2);
+  } else {
+    // When freq = 0, the filter is just a gain
+    coef = {b0: A * A, b1: 0, b2: 0, a1: 0, a2: 0};
+  }
+
+  return coef;
+}
+
+function createPeakingFilter(freq, q, gain) {
+  let b0;
+  let b1;
+  let b2;
+  let a0;
+  let a1;
+  let a2;
+  let coef;
+
+  let A = Math.pow(10, gain / 40);
+
+  if (freq > 0 && freq < 1) {
+    if (q > 0) {
+      let w0 = Math.PI * freq;
+      let alpha = Math.sin(w0) / (2 * q);
+      let k = Math.cos(w0);
+
+      b0 = 1 + alpha * A;
+      b1 = -2 * k;
+      b2 = 1 - alpha * A;
+      a0 = 1 + alpha / A;
+      a1 = -2 * k;
+      a2 = 1 - alpha / A;
+
+      coef = normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2);
+    } else {
+      // q = 0, we have a divide by zero problem in the formulas
+      // above.  But if we look at the z-transform, we see that the
+      // limit as q approaches 0 is A^2.
+      coef = {b0: A * A, b1: 0, b2: 0, a1: 0, a2: 0};
+    }
+  } else {
+    // freq = 0 or 1, the z-transform is 1
+    coef = {b0: 1, b1: 0, b2: 0, a1: 0, a2: 0};
+  }
+
+  return coef;
+}
+
+function createNotchFilter(freq, q, gain) {
+  let b0;
+  let b1;
+  let b2;
+  let a0;
+  let a1;
+  let a2;
+  let coef;
+
+  if (freq > 0 && freq < 1) {
+    if (q > 0) {
+      let w0 = Math.PI * freq;
+      let alpha = Math.sin(w0) / (2 * q);
+      let k = Math.cos(w0);
+
+      b0 = 1;
+      b1 = -2 * k;
+      b2 = 1;
+      a0 = 1 + alpha;
+      a1 = -2 * k;
+      a2 = 1 - alpha;
+      coef = normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2);
+    } else {
+      // When q = 0, we get a divide by zero above.  The limit of the
+      // z-transform as q approaches 0 is 0, so set the coefficients
+      // appropriately.
+      coef = {b0: 0, b1: 0, b2: 0, a1: 0, a2: 0};
+    }
+  } else {
+    // When freq = 0 or 1, the z-transform is 1
+    coef = {b0: 1, b1: 0, b2: 0, a1: 0, a2: 0};
+  }
+
+  return coef;
+}
+
+function createAllpassFilter(freq, q, gain) {
+  let b0;
+  let b1;
+  let b2;
+  let a0;
+  let a1;
+  let a2;
+  let coef;
+
+  if (freq > 0 && freq < 1) {
+    if (q > 0) {
+      let w0 = Math.PI * freq;
+      let alpha = Math.sin(w0) / (2 * q);
+      let k = Math.cos(w0);
+
+      b0 = 1 - alpha;
+      b1 = -2 * k;
+      b2 = 1 + alpha;
+      a0 = 1 + alpha;
+      a1 = -2 * k;
+      a2 = 1 - alpha;
+      coef = normalizeFilterCoefficients(b0, b1, b2, a0, a1, a2);
+    } else {
+      // q = 0
+      coef = {b0: -1, b1: 0, b2: 0, a1: 0, a2: 0};
+    }
+  } else {
+    coef = {b0: 1, b1: 0, b2: 0, a1: 0, a2: 0};
+  }
+
+  return coef;
+}
+
+function filterData(filterCoef, signal, len) {
+  let y = new Array(len);
+  let b0 = filterCoef.b0;
+  let b1 = filterCoef.b1;
+  let b2 = filterCoef.b2;
+  let a1 = filterCoef.a1;
+  let a2 = filterCoef.a2;
+
+  // Prime the pump. (Assumes the signal has length >= 2!)
+  y[0] = b0 * signal[0];
+  y[1] = b0 * signal[1] + b1 * signal[0] - a1 * y[0];
+
+  // Filter all of the signal that we have.
+  for (let k = 2; k < Math.min(signal.length, len); ++k) {
+    y[k] = b0 * signal[k] + b1 * signal[k - 1] + b2 * signal[k - 2] -
+        a1 * y[k - 1] - a2 * y[k - 2];
+  }
+
+  // If we need to filter more, but don't have any signal left,
+  // assume the signal is zero.
+  for (let k = signal.length; k < len; ++k) {
+    y[k] = -a1 * y[k - 1] - a2 * y[k - 2];
+  }
+
+  return y;
+}
+
+// Map the filter type name to a function that computes the filter coefficents
+// for the given filter type.
+let filterCreatorFunction = {
+  'lowpass': createLowpassFilter,
+  'highpass': createHighpassFilter,
+  'bandpass': createBandpassFilter,
+  'lowshelf': createLowShelfFilter,
+  'highshelf': createHighShelfFilter,
+  'peaking': createPeakingFilter,
+  'notch': createNotchFilter,
+  'allpass': createAllpassFilter
+};
+
+let filterTypeName = {
+  'lowpass': 'Lowpass filter',
+  'highpass': 'Highpass filter',
+  'bandpass': 'Bandpass filter',
+  'lowshelf': 'Lowshelf filter',
+  'highshelf': 'Highshelf filter',
+  'peaking': 'Peaking filter',
+  'notch': 'Notch filter',
+  'allpass': 'Allpass filter'
+};
+
+function createFilter(filterType, freq, q, gain) {
+  return filterCreatorFunction[filterType](freq, q, gain);
+}
diff --git a/testing/web-platform/tests/webaudio/resources/biquad-testing.js b/testing/web-platform/tests/webaudio/resources/biquad-testing.js
new file mode 100644
index 0000000000..7f90a1f72b
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/resources/biquad-testing.js
@@ -0,0 +1,172 @@
+// Globals, to make testing and debugging easier.
+let context;
+let filter;
+let signal;
+let renderedBuffer;
+let renderedData;
+
+// Use a power of two to eliminate round-off in converting frame to time
+let sampleRate = 32768;
+let pulseLengthFrames = .1 * sampleRate;
+
+// Maximum allowed error for the test to succeed.  Experimentally determined.
+let maxAllowedError = 5.9e-8;
+
+// This must be large enough so that the filtered result is essentially zero.
+// See comments for createTestAndRun.  This must be a whole number of frames.
+let timeStep = Math.ceil(.1 * sampleRate) / sampleRate;
+
+// Maximum number of filters we can process (mostly for setting the
+// render length correctly.)
+let maxFilters = 5;
+
+// How long to render.  Must be long enough for all of the filters we
+// want to test.
+let renderLengthSeconds = timeStep * (maxFilters + 1);
+
+let renderLengthSamples = Math.round(renderLengthSeconds * sampleRate);
+
+// Number of filters that will be processed.
+let nFilters;
+
+function createImpulseBuffer(context, length) {
+  let impulse = context.createBuffer(1, length, context.sampleRate);
+  let data = impulse.getChannelData(0);
+  for (let k = 1; k < data.length; ++k) {
+    data[k] = 0;
+  }
+  data[0] = 1;
+
+  return impulse;
+}
+
+
+function createTestAndRun(context, filterType, testParameters) {
+  // To test the filters, we apply a signal (an impulse) to each of
+  // the specified filters, with each signal starting at a different
+  // time.  The output of the filters is summed together at the
+  // output.  Thus for filter k, the signal input to the filter
+  // starts at time k * timeStep.  For this to work well, timeStep
+  // must be large enough for the output of each filter to have
+  // decayed to zero with timeStep seconds.  That way the filter
+  // outputs don't interfere with each other.
+
+  let filterParameters = testParameters.filterParameters;
+  nFilters = Math.min(filterParameters.length, maxFilters);
+
+  signal = new Array(nFilters);
+  filter = new Array(nFilters);
+
+  impulse = createImpulseBuffer(context, pulseLengthFrames);
+
+  // Create all of the signal sources and filters that we need.
+  for (let k = 0; k < nFilters; ++k) {
+    signal[k] = context.createBufferSource();
+    signal[k].buffer = impulse;
+
+    filter[k] = context.createBiquadFilter();
+    filter[k].type = filterType;
+    filter[k].frequency.value =
+        context.sampleRate / 2 * filterParameters[k].cutoff;
+    filter[k].detune.value = (filterParameters[k].detune === undefined) ?
+        0 :
+        filterParameters[k].detune;
+    filter[k].Q.value = filterParameters[k].q;
+    filter[k].gain.value = filterParameters[k].gain;
+
+    signal[k].connect(filter[k]);
+    filter[k].connect(context.destination);
+
+    signal[k].start(timeStep * k);
+  }
+
+  return context.startRendering().then(buffer => {
+    checkFilterResponse(buffer, filterType, testParameters);
+  });
+}
+
+function addSignal(dest, src, destOffset) {
+  // Add src to dest at the given dest offset.
+  for (let k = destOffset, j = 0; k < dest.length, j < src.length; ++k, ++j) {
+    dest[k] += src[j];
+  }
+}
+
+function generateReference(filterType, filterParameters) {
+  let result = new Array(renderLengthSamples);
+  let data = new Array(renderLengthSamples);
+  // Initialize the result array and data.
+  for (let k = 0; k < result.length; ++k) {
+    result[k] = 0;
+    data[k] = 0;
+  }
+  // Make data an impulse.
+  data[0] = 1;
+
+  for (let k = 0; k < nFilters; ++k) {
+    // Filter an impulse
+    let detune = (filterParameters[k].detune === undefined) ?
+        0 :
+        filterParameters[k].detune;
+    let frequency = filterParameters[k].cutoff *
+        Math.pow(2, detune / 1200);  // Apply detune, converting from Cents.
+
+    let filterCoef = createFilter(
+        filterType, frequency, filterParameters[k].q, filterParameters[k].gain);
+    let y = filterData(filterCoef, data, renderLengthSamples);
+
+    // Accumulate this filtered data into the final output at the desired
+    // offset.
+    addSignal(result, y, timeToSampleFrame(timeStep * k, sampleRate));
+  }
+
+  return result;
+}
+
+function checkFilterResponse(renderedBuffer, filterType, testParameters) {
+  let filterParameters = testParameters.filterParameters;
+  let maxAllowedError = testParameters.threshold;
+  let should = testParameters.should;
+
+  renderedData = renderedBuffer.getChannelData(0);
+
+  reference = generateReference(filterType, filterParameters);
+
+  let len = Math.min(renderedData.length, reference.length);
+
+  let success = true;
+
+  // Maximum error between rendered data and expected data
+  let maxError = 0;
+
+  // Sample offset where the maximum error occurred.
+  let maxPosition = 0;
+
+  // Number of infinities or NaNs that occurred in the rendered data.
+  let invalidNumberCount = 0;
+
+  should(nFilters, 'Number of filters tested')
+      .beEqualTo(filterParameters.length);
+
+  // Compare the rendered signal with our reference, keeping
+  // track of the maximum difference (and the offset of the max
+  // difference.)  Check for bad numbers in the rendered output
+  // too.  There shouldn't be any.
+  for (let k = 0; k < len; ++k) {
+    let err = Math.abs(renderedData[k] - reference[k]);
+    if (err > maxError) {
+      maxError = err;
+      maxPosition = k;
+    }
+    if (!isValidNumber(renderedData[k])) {
+      ++invalidNumberCount;
+    }
+  }
+
+  should(
+      invalidNumberCount, 'Number of non-finite values in the rendered output')
+      .beEqualTo(0);
+
+  should(maxError, 'Max error in ' + filterTypeName[filterType] + ' response')
+      .beLessThanOrEqualTo(maxAllowedError);
+}
diff --git a/testing/web-platform/tests/webaudio/resources/convolution-testing.js b/testing/web-platform/tests/webaudio/resources/convolution-testing.js
new file mode 100644
index 0000000000..c976f86c78
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/resources/convolution-testing.js
@@ -0,0 +1,168 @@
+let sampleRate = 44100.0;
+
+let renderLengthSeconds = 8;
+let pulseLengthSeconds = 1;
+let pulseLengthFrames = pulseLengthSeconds * sampleRate;
+
+function createSquarePulseBuffer(context, sampleFrameLength) {
+  let audioBuffer =
+      context.createBuffer(1, sampleFrameLength, context.sampleRate);
+
+  let n = audioBuffer.length;
+  let data = audioBuffer.getChannelData(0);
+
+  for (let i = 0; i < n; ++i)
+    data[i] = 1;
+
+  return audioBuffer;
+}
+
+// The triangle buffer holds the expected result of the convolution.
+// It linearly ramps up from 0 to its maximum value (at the center)
+// then linearly ramps down to 0.  The center value corresponds to the
+// point where the two square pulses overlap the most.
+function createTrianglePulseBuffer(context, sampleFrameLength) {
+  let audioBuffer =
+      context.createBuffer(1, sampleFrameLength, context.sampleRate);
+
+  let n = audioBuffer.length;
+  let halfLength = n / 2;
+  let data = audioBuffer.getChannelData(0);
+
+  for (let i = 0; i < halfLength; ++i)
+    data[i] = i + 1;
+
+  for (let i = halfLength; i < n; ++i)
+    data[i] = n - i - 1;
+
+  return audioBuffer;
+}
+
+function log10(x) {
+  return Math.log(x) / Math.LN10;
+}
+
+function linearToDecibel(x) {
+  return 20 * log10(x);
+}
+
+// Verify that the rendered result is very close to the reference
+// triangular pulse.
+function checkTriangularPulse(rendered, reference, should) {
+  let match = true;
+  let maxDelta = 0;
+  let valueAtMaxDelta = 0;
+  let maxDeltaIndex = 0;
+
+  for (let i = 0; i < reference.length; ++i) {
+    let diff = rendered[i] - reference[i];
+    let x = Math.abs(diff);
+    if (x > maxDelta) {
+      maxDelta = x;
+      valueAtMaxDelta = reference[i];
+      maxDeltaIndex = i;
+    }
+  }
+
+  // allowedDeviationFraction was determined experimentally.  It
+  // is the threshold of the relative error at the maximum
+  // difference between the true triangular pulse and the
+  // rendered pulse.
+  let allowedDeviationDecibels = -124.41;
+  let maxDeviationDecibels = linearToDecibel(maxDelta / valueAtMaxDelta);
+
+  should(
+      maxDeviationDecibels,
+      'Deviation (in dB) of triangular portion of convolution')
+      .beLessThanOrEqualTo(allowedDeviationDecibels);
+
+  return match;
+}
+
+// Verify that the rendered data is close to zero for the first part
+// of the tail.
+function checkTail1(data, reference, breakpoint, should) {
+  let isZero = true;
+  let tail1Max = 0;
+
+  for (let i = reference.length; i < reference.length + breakpoint; ++i) {
+    let mag = Math.abs(data[i]);
+    if (mag > tail1Max) {
+      tail1Max = mag;
+    }
+  }
+
+  // Let's find the peak of the reference (even though we know a
+  // priori what it is).
+  let refMax = 0;
+  for (let i = 0; i < reference.length; ++i) {
+    refMax = Math.max(refMax, Math.abs(reference[i]));
+  }
+
+  // This threshold is experimentally determined by examining the
+  // value of tail1MaxDecibels.
+  let threshold1 = -129.7;
+
+  let tail1MaxDecibels = linearToDecibel(tail1Max / refMax);
+  should(tail1MaxDecibels, 'Deviation in first part of tail of convolutions')
+      .beLessThanOrEqualTo(threshold1);
+
+  return isZero;
+}
+
+// Verify that the second part of the tail of the convolution is
+// exactly zero.
+function checkTail2(data, reference, breakpoint, should) {
+  let isZero = true;
+  let tail2Max = 0;
+  // For the second part of the tail, the maximum value should be
+  // exactly zero.
+  let threshold2 = 0;
+  for (let i = reference.length + breakpoint; i < data.length; ++i) {
+    if (Math.abs(data[i]) > 0) {
+      isZero = false;
+      break;
+    }
+  }
+
+  should(isZero, 'Rendered signal after tail of convolution is silent')
+      .beTrue();
+
+  return isZero;
+}
+
+function checkConvolvedResult(renderedBuffer, trianglePulse, should) {
+  let referenceData = trianglePulse.getChannelData(0);
+  let renderedData = renderedBuffer.getChannelData(0);
+
+  let success = true;
+
+  // Verify the triangular pulse is actually triangular.
+
+  success =
+      success && checkTriangularPulse(renderedData, referenceData, should);
+
+  // Make sure that portion after convolved portion is totally
+  // silent.  But round-off prevents this from being completely
+  // true.  At the end of the triangle, it should be close to
+  // zero.  If we go farther out, it should be even closer and
+  // eventually zero.
+
+  // For the tail of the convolution (where the result would be
+  // theoretically zero), we partition the tail into two
+  // parts.  The first is the at the beginning of the tail,
+  // where we tolerate a small but non-zero value.  The second part is
+  // farther along the tail where the result should be zero.
+
+  // breakpoint is the point dividing the first two tail parts
+  // we're looking at.  Experimentally determined.
+  let breakpoint = 12800;
+
+  success =
+      success && checkTail1(renderedData, referenceData, breakpoint, should);
+
+  success =
+      success && checkTail2(renderedData, referenceData, breakpoint, should);
+
+  should(success, 'Test signal convolved').message('correctly', 'incorrectly');
+}
diff --git a/testing/web-platform/tests/webaudio/resources/delay-testing.js b/testing/web-platform/tests/webaudio/resources/delay-testing.js
new file mode 100644
index 0000000000..9033da6730
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/resources/delay-testing.js
@@ -0,0 +1,66 @@
+let sampleRate = 44100.0;
+
+let renderLengthSeconds = 4;
+let delayTimeSeconds = 0.5;
+let toneLengthSeconds = 2;
+
+function createToneBuffer(context, frequency, numberOfCycles, sampleRate) {
+  let duration = numberOfCycles / frequency;
+  let sampleFrameLength = duration * sampleRate;
+
+  let audioBuffer = context.createBuffer(1, sampleFrameLength, sampleRate);
+
+  let n = audioBuffer.length;
+  let data = audioBuffer.getChannelData(0);
+
+  for (let i = 0; i < n; ++i)
+    data[i] = Math.sin(frequency * 2.0 * Math.PI * i / sampleRate);
+
+  return audioBuffer;
+}
+
+function checkDelayedResult(renderedBuffer, toneBuffer, should) {
+  let sourceData = toneBuffer.getChannelData(0);
+  let renderedData = renderedBuffer.getChannelData(0);
+
+  let delayTimeFrames = delayTimeSeconds * sampleRate;
+  let toneLengthFrames = toneLengthSeconds * sampleRate;
+
+  let success = true;
+
+  let n = renderedBuffer.length;
+
+  for (let i = 0; i < n; ++i) {
+    if (i < delayTimeFrames) {
+      // Check that initial portion is 0 (since signal is delayed).
+      if (renderedData[i] != 0) {
+        should(
+            renderedData[i], 'Initial portion expected to be 0 at frame ' + i)
+            .beEqualTo(0);
+        success = false;
+        break;
+      }
+    } else if (i >= delayTimeFrames && i < delayTimeFrames + toneLengthFrames) {
+      // Make sure that the tone data is delayed by exactly the expected number
+      // of frames.
+      let j = i - delayTimeFrames;
+      if (renderedData[i] != sourceData[j]) {
+        should(renderedData[i], 'Actual data at frame ' + i)
+            .beEqualTo(sourceData[j]);
+        success = false;
+        break;
+      }
+    } else {
+      // Make sure we have silence after the delayed tone.
+      if (renderedData[i] != 0) {
+        should(renderedData[j], 'Final portion at frame ' + i).beEqualTo(0);
+        success = false;
+        break;
+      }
+    }
+  }
+
+  should(
+      success, 'Delaying test signal by ' + delayTimeSeconds + ' sec was done')
+      .message('correctly', 'incorrectly')
+}
diff --git a/testing/web-platform/tests/webaudio/resources/distance-model-testing.js b/testing/web-platform/tests/webaudio/resources/distance-model-testing.js
new file mode 100644
index 0000000000..f8a6cf940a
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/resources/distance-model-testing.js
@@ -0,0 +1,196 @@
+// Use a power of two to eliminate round-off when converting frames to time and
+// vice versa.
+let sampleRate = 32768;
+
+// How many panner nodes to create for the test.
+let nodesToCreate = 100;
+
+// Time step when each panner node starts.  Make sure it starts on a frame
+// boundary.
+let timeStep = Math.floor(0.001 * sampleRate) / sampleRate;
+
+// Make sure we render long enough to get all of our nodes.
+let renderLengthSeconds = timeStep * (nodesToCreate + 1);
+
+// Length of an impulse signal.
+let pulseLengthFrames = Math.round(timeStep * sampleRate);
+
+// Globals to make debugging a little easier.
+let context;
+let impulse;
+let bufferSource;
+let panner;
+let position;
+let time;
+
+// For the record, these distance formulas were taken from the OpenAL
+// spec
+// (http://connect.creativelabs.com/openal/Documentation/OpenAL%201.1%20Specification.pdf),
+// not the code.  The Web Audio spec follows the OpenAL formulas.
+
+function linearDistance(panner, x, y, z) {
+  let distance = Math.sqrt(x * x + y * y + z * z);
+  distance = Math.min(distance, panner.maxDistance);
+  let rolloff = panner.rolloffFactor;
+  let gain =
+      (1 -
+       rolloff * (distance - panner.refDistance) /
+           (panner.maxDistance - panner.refDistance));
+
+  return gain;
+}
+
+function inverseDistance(panner, x, y, z) {
+  let distance = Math.sqrt(x * x + y * y + z * z);
+  distance = Math.min(distance, panner.maxDistance);
+  let rolloff = panner.rolloffFactor;
+  let gain = panner.refDistance /
+      (panner.refDistance + rolloff * (distance - panner.refDistance));
+
+  return gain;
+}
+
+function exponentialDistance(panner, x, y, z) {
+  let distance = Math.sqrt(x * x + y * y + z * z);
+  distance = Math.min(distance, panner.maxDistance);
+  let rolloff = panner.rolloffFactor;
+  let gain = Math.pow(distance / panner.refDistance, -rolloff);
+
+  return gain;
+}
+
+// Map the distance model to the function that implements the model
+let distanceModelFunction = {
+  'linear': linearDistance,
+  'inverse': inverseDistance,
+  'exponential': exponentialDistance
+};
+
+function createGraph(context, distanceModel, nodeCount) {
+  bufferSource = new Array(nodeCount);
+  panner = new Array(nodeCount);
+  position = new Array(nodeCount);
+  time = new Array(nodesToCreate);
+
+  impulse = createImpulseBuffer(context, pulseLengthFrames);
+
+  // Create all the sources and panners.
+  //
+  // We MUST use the EQUALPOWER panning model so that we can easily
+  // figure out the gain introduced by the panner.
+  //
+  // We want to stay in the middle of the panning range, which means
+  // we want to stay on the z-axis.  If we don't, then the effect of
+  // panning model will be much more complicated.  We're not testing
+  // the panner, but the distance model, so we want the panner effect
+  // to be simple.
+  //
+  // The panners are placed at a uniform intervals between the panner
+  // reference distance and the panner max distance.  The source is
+  // also started at regular intervals.
+  for (let k = 0; k < nodeCount; ++k) {
+    bufferSource[k] = context.createBufferSource();
+    bufferSource[k].buffer = impulse;
+
+    panner[k] = context.createPanner();
+    panner[k].panningModel = 'equalpower';
+    panner[k].distanceModel = distanceModel;
+
+    let distanceStep =
+        (panner[k].maxDistance - panner[k].refDistance) / nodeCount;
+    position[k] = distanceStep * k + panner[k].refDistance;
+    panner[k].setPosition(0, 0, position[k]);
+
+    bufferSource[k].connect(panner[k]);
+    panner[k].connect(context.destination);
+
+    time[k] = k * timeStep;
+    bufferSource[k].start(time[k]);
+  }
+}
+
+// distanceModel should be the distance model string like
+// "linear", "inverse", or "exponential".
+function createTestAndRun(context, distanceModel, should) {
+  // To test the distance models, we create a number of panners at
+  // uniformly spaced intervals on the z-axis.  Each of these are
+  // started at equally spaced time intervals.  After rendering the
+  // signals, we examine where each impulse is located and the
+  // attenuation of the impulse.  The attenuation is compared
+  // against our expected attenuation.
+
+  createGraph(context, distanceModel, nodesToCreate);
+
+  return context.startRendering().then(
+      buffer => checkDistanceResult(buffer, distanceModel, should));
+}
+
+// The gain caused by the EQUALPOWER panning model, if we stay on the
+// z axis, with the default orientations.
+function equalPowerGain() {
+  return Math.SQRT1_2;
+}
+
+function checkDistanceResult(renderedBuffer, model, should) {
+  renderedData = renderedBuffer.getChannelData(0);
+
+  // The max allowed error between the actual gain and the expected
+  // value.  This is determined experimentally.  Set to 0 to see
+  // what the actual errors are.
+  let maxAllowedError = 2.2720e-6;
+
+  let success = true;
+
+  // Number of impulses we found in the rendered result.
+  let impulseCount = 0;
+
+  // Maximum relative error in the gain of the impulses.
+  let maxError = 0;
+
+  // Array of locations of the impulses that were not at the
+  // expected location.  (Contains the actual and expected frame
+  // of the impulse.)
+  let impulsePositionErrors = new Array();
+
+  // Step through the rendered data to find all the non-zero points
+  // so we can find where our distance-attenuated impulses are.
+  // These are tested against the expected attenuations at that
+  // distance.
+  for (let k = 0; k < renderedData.length; ++k) {
+    if (renderedData[k] != 0) {
+      // Convert from string to index.
+      let distanceFunction = distanceModelFunction[model];
+      let expected =
+          distanceFunction(panner[impulseCount], 0, 0, position[impulseCount]);
+
+      // Adjust for the center-panning of the EQUALPOWER panning
+      // model that we're using.
+      expected *= equalPowerGain();
+
+      let error = Math.abs(renderedData[k] - expected) / Math.abs(expected);
+
+      maxError = Math.max(maxError, Math.abs(error));
+
+      should(renderedData[k]).beCloseTo(expected, {threshold: maxAllowedError});
+
+      // Keep track of any impulses that aren't where we expect them
+      // to be.
+      let expectedOffset = timeToSampleFrame(time[impulseCount], sampleRate);
+      if (k != expectedOffset) {
+        impulsePositionErrors.push({actual: k, expected: expectedOffset});
+      }
+      ++impulseCount;
+    }
+  }
+  should(impulseCount, 'Number of impulses').beEqualTo(nodesToCreate);
+
+  should(maxError, 'Max error in distance gains')
+      .beLessThanOrEqualTo(maxAllowedError);
+
+  // Display any timing errors that we found.
+  if (impulsePositionErrors.length > 0) {
+    let actual = impulsePositionErrors.map(x => x.actual);
+    let expected = impulsePositionErrors.map(x => x.expected);
+    should(actual, 'Actual impulse positions found').beEqualToArray(expected);
+  }
+}
diff --git a/testing/web-platform/tests/webaudio/resources/merger-testing.js b/testing/web-platform/tests/webaudio/resources/merger-testing.js
new file mode 100644
index 0000000000..4477ec0a1f
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/resources/merger-testing.js
@@ -0,0 +1,24 @@
+// This file is for the audiochannelmerger-* layout tests.
+// Requires |audio-testing.js| to work properly.
+
+function testMergerInput(should, config) {
+  let context = new OfflineAudioContext(config.numberOfChannels, 128, 44100);
+  let merger = context.createChannelMerger(config.numberOfChannels);
+  let source = context.createBufferSource();
+  source.buffer = createConstantBuffer(context, 128, config.testBufferContent);
+
+  // Connect the output of source into the specified input of merger.
+  if (config.mergerInputIndex)
+    source.connect(merger, 0, config.mergerInputIndex);
+  else
+    source.connect(merger);
+  merger.connect(context.destination);
+  source.start();
+
+  return context.startRendering().then(function(buffer) {
+    let prefix = config.testBufferContent.length + '-channel source: ';
+    for (let i = 0; i < config.numberOfChannels; i++)
+      should(buffer.getChannelData(i), prefix + 'Channel #' + i)
+          .beConstantValueOf(config.expected[i]);
+  });
+}
diff --git a/testing/web-platform/tests/webaudio/resources/mix-testing.js b/testing/web-platform/tests/webaudio/resources/mix-testing.js
new file mode 100644
index 0000000000..63c8e1aca6
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/resources/mix-testing.js
@@ -0,0 +1,23 @@
+let toneLengthSeconds = 1;
+
+// Create a buffer with multiple channels.
+// The signal frequency in each channel is the multiple of that in the first
+// channel.
+function createToneBuffer(context, frequency, duration, numberOfChannels) {
+  let sampleRate = context.sampleRate;
+  let sampleFrameLength = duration * sampleRate;
+
+  let audioBuffer =
+      context.createBuffer(numberOfChannels, sampleFrameLength, sampleRate);
+
+  let n = audioBuffer.length;
+
+  for (let k = 0; k < numberOfChannels; ++k) {
+    let data = audioBuffer.getChannelData(k);
+
+    for (let i = 0; i < n; ++i)
+      data[i] = Math.sin(frequency * (k + 1) * 2.0 * Math.PI * i / sampleRate);
+  }
+
+  return audioBuffer;
+}
diff --git a/testing/web-platform/tests/webaudio/resources/mixing-rules.js b/testing/web-platform/tests/webaudio/resources/mixing-rules.js
new file mode 100644
index 0000000000..e06a1468a3
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/resources/mixing-rules.js
@@ -0,0 +1,350 @@
+// Utilities for mixing rule testing.
+// http://webaudio.github.io/web-audio-api/#channel-up-mixing-and-down-mixing
+
+
+/**
+ * Create an n-channel buffer, with all sample data zero except for a shifted
+ * impulse. The impulse position depends on the channel index. For example, for
+ * a 4-channel buffer:
+ *  channel 0: 1 0 0 0 0 0 0 0
+ *  channel 1: 0 1 0 0 0 0 0 0
+ *  channel 2: 0 0 1 0 0 0 0 0
+ *  channel 3: 0 0 0 1 0 0 0 0
+ * @param  {AudioContext} context     Associated AudioContext.
+ * @param  {Number} numberOfChannels  Number of channels of test buffer.
+ * @param  {Number} frameLength       Buffer length in frames.
+ * @return {AudioBuffer}
+ */
+function createShiftedImpulseBuffer(context, numberOfChannels, frameLength) {
+  let shiftedImpulseBuffer =
+      context.createBuffer(numberOfChannels, frameLength, context.sampleRate);
+  for (let channel = 0; channel < numberOfChannels; ++channel) {
+    let data = shiftedImpulseBuffer.getChannelData(channel);
+    data[channel] = 1;
+  }
+
+  return shiftedImpulseBuffer;
+}
+
+/**
+ * Create a string that displays the content of AudioBuffer.
+ * @param  {AudioBuffer} audioBuffer  AudioBuffer object to stringify.
+ * @param  {Number} frameLength       Number of frames to be printed.
+ * @param  {Number} frameOffset       Starting frame position for printing.
+ * @return {String}
+ */
+function stringifyBuffer(audioBuffer, frameLength, frameOffset) {
+  frameOffset = (frameOffset || 0);
+
+  let stringifiedBuffer = '';
+  for (let channel = 0; channel < audioBuffer.numberOfChannels; ++channel) {
+    let channelData = audioBuffer.getChannelData(channel);
+    for (let i = 0; i < frameLength; ++i)
+      stringifiedBuffer += channelData[i + frameOffset] + ' ';
+    stringifiedBuffer += '\n';
+  }
+
+  return stringifiedBuffer;
+}
+
+/**
+ * Compute number of channels from the connection.
+ * http://webaudio.github.io/web-audio-api/#dfn-computednumberofchannels
+ * @param  {String} connections         A string specifies the connection. For
+ *                                      example, the string "128" means 3
+ *                                      connections, having 1, 2, and 8 channels
+ *                                      respectively.
+ * @param  {Number} channelCount        Channel count.
+ * @param  {String} channelCountMode    Channel count mode.
+ * @return {Number}                     Computed number of channels.
+ */
+function computeNumberOfChannels(connections, channelCount, channelCountMode) {
+  if (channelCountMode == 'explicit')
+    return channelCount;
+
+  // Must have at least one channel.
+  let computedNumberOfChannels = 1;
+
+  // Compute "computedNumberOfChannels" based on all the connections.
+  for (let i = 0; i < connections.length; ++i) {
+    let connectionNumberOfChannels = parseInt(connections[i]);
+    computedNumberOfChannels =
+        Math.max(computedNumberOfChannels, connectionNumberOfChannels);
+  }
+
+  if (channelCountMode == 'clamped-max')
+    computedNumberOfChannels = Math.min(computedNumberOfChannels, channelCount);
+
+  return computedNumberOfChannels;
+}
+
+/**
+ * Apply up/down-mixing (in-place summing) based on 'speaker' interpretation.
+ * @param  {AudioBuffer} input          Input audio buffer.
+ * @param  {AudioBuffer} output         Output audio buffer.
+ */
+function speakersSum(input, output) {
+  if (input.length != output.length) {
+    throw '[mixing-rules.js] speakerSum(): buffer lengths mismatch (input: ' +
+        input.length + ', output: ' + output.length + ')';
+  }
+
+  if (input.numberOfChannels === output.numberOfChannels) {
+    for (let channel = 0; channel < output.numberOfChannels; ++channel) {
+      let inputChannel = input.getChannelData(channel);
+      let outputChannel = output.getChannelData(channel);
+      for (let i = 0; i < outputChannel.length; i++)
+        outputChannel[i] += inputChannel[i];
+    }
+  } else if (input.numberOfChannels < output.numberOfChannels) {
+    processUpMix(input, output);
+  } else {
+    processDownMix(input, output);
+  }
+}
+
+/**
+ * In-place summing to |output| based on 'discrete' channel interpretation.
+ * @param  {AudioBuffer} input          Input audio buffer.
+ * @param  {AudioBuffer} output         Output audio buffer.
+ */
+function discreteSum(input, output) {
+  if (input.length != output.length) {
+    throw '[mixing-rules.js] speakerSum(): buffer lengths mismatch (input: ' +
+        input.length + ', output: ' + output.length + ')';
+  }
+
+  let numberOfChannels =
+      Math.min(input.numberOfChannels, output.numberOfChannels)
+
+          for (let channel = 0; channel < numberOfChannels; ++channel) {
+    let inputChannel = input.getChannelData(channel);
+    let outputChannel = output.getChannelData(channel);
+    for (let i = 0; i < outputChannel.length; i++)
+      outputChannel[i] += inputChannel[i];
+  }
+}
+
+/**
+ * Perform up-mix by in-place summing to |output| buffer.
+ * @param  {AudioBuffer} input          Input audio buffer.
+ * @param  {AudioBuffer} output         Output audio buffer.
+ */
+function processUpMix(input, output) {
+  let numberOfInputChannels = input.numberOfChannels;
+  let numberOfOutputChannels = output.numberOfChannels;
+  let i, length = output.length;
+
+  // Up-mixing: 1 -> 2, 1 -> 4
+  //   output.L += input
+  //   output.R += input
+  //   output.SL += 0 (in the case of 1 -> 4)
+  //   output.SR += 0 (in the case of 1 -> 4)
+  if ((numberOfInputChannels === 1 && numberOfOutputChannels === 2) ||
+      (numberOfInputChannels === 1 && numberOfOutputChannels === 4)) {
+    let inputChannel = input.getChannelData(0);
+    let outputChannel0 = output.getChannelData(0);
+    let outputChannel1 = output.getChannelData(1);
+    for (i = 0; i < length; i++) {
+      outputChannel0[i] += inputChannel[i];
+      outputChannel1[i] += inputChannel[i];
+    }
+
+    return;
+  }
+
+  // Up-mixing: 1 -> 5.1
+  //   output.L += 0
+  //   output.R += 0
+  //   output.C += input
+  //   output.LFE += 0
+  //   output.SL += 0
+  //   output.SR += 0
+  if (numberOfInputChannels == 1 && numberOfOutputChannels == 6) {
+    let inputChannel = input.getChannelData(0);
+    let outputChannel2 = output.getChannelData(2);
+    for (i = 0; i < length; i++)
+      outputChannel2[i] += inputChannel[i];
+
+    return;
+  }
+
+  // Up-mixing: 2 -> 4, 2 -> 5.1
+  //   output.L += input.L
+  //   output.R += input.R
+  //   output.C += 0 (in the case of 2 -> 5.1)
+  //   output.LFE += 0 (in the case of 2 -> 5.1)
+  //   output.SL += 0
+  //   output.SR += 0
+  if ((numberOfInputChannels === 2 && numberOfOutputChannels === 4) ||
+      (numberOfInputChannels === 2 && numberOfOutputChannels === 6)) {
+    let inputChannel0 = input.getChannelData(0);
+    let inputChannel1 = input.getChannelData(1);
+    let outputChannel0 = output.getChannelData(0);
+    let outputChannel1 = output.getChannelData(1);
+    for (i = 0; i < length; i++) {
+      outputChannel0[i] += inputChannel0[i];
+      outputChannel1[i] += inputChannel1[i];
+    }
+
+    return;
+  }
+
+  // Up-mixing: 4 -> 5.1
+  //   output.L += input.L
+  //   output.R += input.R
+  //   output.C += 0
+  //   output.LFE += 0
+  //   output.SL += input.SL
+  //   output.SR += input.SR
+  if (numberOfInputChannels === 4 && numberOfOutputChannels === 6) {
+    let inputChannel0 = input.getChannelData(0);    // input.L
+    let inputChannel1 = input.getChannelData(1);    // input.R
+    let inputChannel2 = input.getChannelData(2);    // input.SL
+    let inputChannel3 = input.getChannelData(3);    // input.SR
+    let outputChannel0 = output.getChannelData(0);  // output.L
+    let outputChannel1 = output.getChannelData(1);  // output.R
+    let outputChannel4 = output.getChannelData(4);  // output.SL
+    let outputChannel5 = output.getChannelData(5);  // output.SR
+    for (i = 0; i < length; i++) {
+      outputChannel0[i] += inputChannel0[i];
+      outputChannel1[i] += inputChannel1[i];
+      outputChannel4[i] += inputChannel2[i];
+      outputChannel5[i] += inputChannel3[i];
+    }
+
+    return;
+  }
+
+  // All other cases, fall back to the discrete sum.
+  discreteSum(input, output);
+}
+
+/**
+ * Perform down-mix by in-place summing to |output| buffer.
+ * @param  {AudioBuffer} input          Input audio buffer.
+ * @param  {AudioBuffer} output         Output audio buffer.
+ */
+function processDownMix(input, output) {
+  let numberOfInputChannels = input.numberOfChannels;
+  let numberOfOutputChannels = output.numberOfChannels;
+  let i, length = output.length;
+
+  // Down-mixing: 2 -> 1
+  //   output += 0.5 * (input.L + input.R)
+  if (numberOfInputChannels === 2 && numberOfOutputChannels === 1) {
+    let inputChannel0 = input.getChannelData(0);  // input.L
+    let inputChannel1 = input.getChannelData(1);  // input.R
+    let outputChannel0 = output.getChannelData(0);
+    for (i = 0; i < length; i++)
+      outputChannel0[i] += 0.5 * (inputChannel0[i] + inputChannel1[i]);
+
+    return;
+  }
+
+  // Down-mixing: 4 -> 1
+  //   output += 0.25 * (input.L + input.R + input.SL + input.SR)
+  if (numberOfInputChannels === 4 && numberOfOutputChannels === 1) {
+    let inputChannel0 = input.getChannelData(0);  // input.L
+    let inputChannel1 = input.getChannelData(1);  // input.R
+    let inputChannel2 = input.getChannelData(2);  // input.SL
+    let inputChannel3 = input.getChannelData(3);  // input.SR
+    let outputChannel0 = output.getChannelData(0);
+    for (i = 0; i < length; i++) {
+      outputChannel0[i] += 0.25 *
+          (inputChannel0[i] + inputChannel1[i] + inputChannel2[i] +
+           inputChannel3[i]);
+    }
+
+    return;
+  }
+
+  // Down-mixing: 5.1 -> 1
+  //   output += sqrt(1/2) * (input.L + input.R) + input.C
+  //            + 0.5 * (input.SL + input.SR)
+  if (numberOfInputChannels === 6 && numberOfOutputChannels === 1) {
+    let inputChannel0 = input.getChannelData(0);  // input.L
+    let inputChannel1 = input.getChannelData(1);  // input.R
+    let inputChannel2 = input.getChannelData(2);  // input.C
+    let inputChannel4 = input.getChannelData(4);  // input.SL
+    let inputChannel5 = input.getChannelData(5);  // input.SR
+    let outputChannel0 = output.getChannelData(0);
+    let scaleSqrtHalf = Math.sqrt(0.5);
+    for (i = 0; i < length; i++) {
+      outputChannel0[i] +=
+          scaleSqrtHalf * (inputChannel0[i] + inputChannel1[i]) +
+          inputChannel2[i] + 0.5 * (inputChannel4[i] + inputChannel5[i]);
+    }
+
+    return;
+  }
+
+  // Down-mixing: 4 -> 2
+  //   output.L += 0.5 * (input.L + input.SL)
+  //   output.R += 0.5 * (input.R + input.SR)
+  if (numberOfInputChannels == 4 && numberOfOutputChannels == 2) {
+    let inputChannel0 = input.getChannelData(0);    // input.L
+    let inputChannel1 = input.getChannelData(1);    // input.R
+    let inputChannel2 = input.getChannelData(2);    // input.SL
+    let inputChannel3 = input.getChannelData(3);    // input.SR
+    let outputChannel0 = output.getChannelData(0);  // output.L
+    let outputChannel1 = output.getChannelData(1);  // output.R
+    for (i = 0; i < length; i++) {
+      outputChannel0[i] += 0.5 * (inputChannel0[i] + inputChannel2[i]);
+      outputChannel1[i] += 0.5 * (inputChannel1[i] + inputChannel3[i]);
+    }
+
+    return;
+  }
+
+  // Down-mixing: 5.1 -> 2
+  //   output.L += input.L + sqrt(1/2) * (input.C + input.SL)
+  //   output.R += input.R + sqrt(1/2) * (input.C + input.SR)
+  if (numberOfInputChannels == 6 && numberOfOutputChannels == 2) {
+    let inputChannel0 = input.getChannelData(0);    // input.L
+    let inputChannel1 = input.getChannelData(1);    // input.R
+    let inputChannel2 = input.getChannelData(2);    // input.C
+    let inputChannel4 = input.getChannelData(4);    // input.SL
+    let inputChannel5 = input.getChannelData(5);    // input.SR
+    let outputChannel0 = output.getChannelData(0);  // output.L
+    let outputChannel1 = output.getChannelData(1);  // output.R
+    let scaleSqrtHalf = Math.sqrt(0.5);
+    for (i = 0; i < length; i++) {
+      outputChannel0[i] += inputChannel0[i] +
+          scaleSqrtHalf * (inputChannel2[i] + inputChannel4[i]);
+      outputChannel1[i] += inputChannel1[i] +
+          scaleSqrtHalf * (inputChannel2[i] + inputChannel5[i]);
+    }
+
+    return;
+  }
+
+  // Down-mixing: 5.1 -> 4
+  //   output.L += input.L + sqrt(1/2) * input.C
+  //   output.R += input.R + sqrt(1/2) * input.C
+  //   output.SL += input.SL
+  //   output.SR += input.SR
+  if (numberOfInputChannels === 6 && numberOfOutputChannels === 4) {
+    let inputChannel0 = input.getChannelData(0);    // input.L
+    let inputChannel1 = input.getChannelData(1);    // input.R
+    let inputChannel2 = input.getChannelData(2);    // input.C
+    let inputChannel4 = input.getChannelData(4);    // input.SL
+    let inputChannel5 = input.getChannelData(5);    // input.SR
+    let outputChannel0 = output.getChannelData(0);  // output.L
+    let outputChannel1 = output.getChannelData(1);  // output.R
+    let outputChannel2 = output.getChannelData(2);  // output.SL
+    let outputChannel3 = output.getChannelData(3);  // output.SR
+    let scaleSqrtHalf = Math.sqrt(0.5);
+    for (i = 0; i < length; i++) {
+      outputChannel0[i] += inputChannel0[i] + scaleSqrtHalf * inputChannel2[i];
+      outputChannel1[i] += inputChannel1[i] + scaleSqrtHalf * inputChannel2[i];
+      outputChannel2[i] += inputChannel4[i];
+      outputChannel3[i] += inputChannel5[i];
+    }
+
+    return;
+  }
+
+  // All other cases, fall back to the discrete sum.
+  discreteSum(input, output);
+}
diff --git a/testing/web-platform/tests/webaudio/resources/note-grain-on-testing.js b/testing/web-platform/tests/webaudio/resources/note-grain-on-testing.js
new file mode 100644
index 0000000000..ad0631670d
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/resources/note-grain-on-testing.js
@@ -0,0 +1,165 @@
+// Use a power of two to eliminate round-off converting from frames to time.
+let sampleRate = 32768;
+
+// How many grains to play.
+let numberOfTests = 100;
+
+// Duration of each grain to be played.  Make a whole number of frames
+let duration = Math.floor(0.01 * sampleRate) / sampleRate;
+
+// A little extra bit of silence between grain boundaries.  Must be a whole
+// number of frames.
+let grainGap = Math.floor(0.005 * sampleRate) / sampleRate;
+
+// Time step between the start of each grain.  We need to add a little
+// bit of silence so we can detect grain boundaries
+let timeStep = duration + grainGap;
+
+// Time step between the start for each grain.  Must be a whole number of
+// frames.
+let grainOffsetStep = Math.floor(0.001 * sampleRate) / sampleRate;
+
+// How long to render to cover all of the grains.
+let renderTime = (numberOfTests + 1) * timeStep;
+
+let context;
+let renderedData;
+
+// Create a buffer containing the data that we want.  The function f
+// returns the desired value at sample frame k.
+function createSignalBuffer(context, f) {
+  // Make sure the buffer has enough data for all of the possible
+  // grain offsets and durations.  The additional 1 is for any
+  // round-off errors.
+  let signalLength =
+      Math.floor(1 + sampleRate * (numberOfTests * grainOffsetStep + duration));
+
+  let buffer = context.createBuffer(2, signalLength, sampleRate);
+  let data = buffer.getChannelData(0);
+
+  for (let k = 0; k < signalLength; ++k) {
+    data[k] = f(k);
+  }
+
+  return buffer;
+}
+
+// From the data array, find the start and end sample frame for each
+// grain.  This depends on the data having 0's between grain, and
+// that the grain is always strictly non-zero.
+function findStartAndEndSamples(data) {
+  let nSamples = data.length;
+
+  let startTime = [];
+  let endTime = [];
+  let lookForStart = true;
+
+  // Look through the rendered data to find the start and stop
+  // times of each grain.
+  for (let k = 0; k < nSamples; ++k) {
+    if (lookForStart) {
+      // Find a non-zero point and record the start.  We're not
+      // concerned with the value in this test, only that the
+      // grain started here.
+      if (renderedData[k]) {
+        startTime.push(k);
+        lookForStart = false;
+      }
+    } else {
+      // Find a zero and record the end of the grain.
+      if (!renderedData[k]) {
+        endTime.push(k);
+        lookForStart = true;
+      }
+    }
+  }
+
+  return {start: startTime, end: endTime};
+}
+
+function playGrain(context, source, time, offset, duration) {
+  let bufferSource = context.createBufferSource();
+
+  bufferSource.buffer = source;
+  bufferSource.connect(context.destination);
+  bufferSource.start(time, offset, duration);
+}
+
+// Play out all grains.  Returns a object containing two arrays, one
+// for the start time and one for the grain offset time.
+function playAllGrains(context, source, numberOfNotes) {
+  let startTimes = new Array(numberOfNotes);
+  let offsets = new Array(numberOfNotes);
+
+  for (let k = 0; k < numberOfNotes; ++k) {
+    let timeOffset = k * timeStep;
+    let grainOffset = k * grainOffsetStep;
+
+    playGrain(context, source, timeOffset, grainOffset, duration);
+    startTimes[k] = timeOffset;
+    offsets[k] = grainOffset;
+  }
+
+  return {startTimes: startTimes, grainOffsetTimes: offsets};
+}
+
+// Verify that the start and end frames for each grain match our
+// expected start and end frames.
+function verifyStartAndEndFrames(startEndFrames, should) {
+  let startFrames = startEndFrames.start;
+  let endFrames = startEndFrames.end;
+
+  // Count of how many grains started at the incorrect time.
+  let errorCountStart = 0;
+
+  // Count of how many grains ended at the incorrect time.
+  let errorCountEnd = 0;
+
+  should(
+      startFrames.length == endFrames.length, 'Found all grain starts and ends')
+      .beTrue();
+
+  should(startFrames.length, 'Number of start frames').beEqualTo(numberOfTests);
+  should(endFrames.length, 'Number of end frames').beEqualTo(numberOfTests);
+
+  // Examine the start and stop times to see if they match our
+  // expectations.
+  for (let k = 0; k < startFrames.length; ++k) {
+    let expectedStart = timeToSampleFrame(k * timeStep, sampleRate);
+    // The end point is the duration.
+    let expectedEnd = expectedStart +
+        grainLengthInSampleFrames(k * grainOffsetStep, duration, sampleRate);
+
+    if (startFrames[k] != expectedStart)
+      ++errorCountStart;
+    if (endFrames[k] != expectedEnd)
+      ++errorCountEnd;
+
+    should([startFrames[k], endFrames[k]], 'Pulse ' + k + ' boundary')
+        .beEqualToArray([expectedStart, expectedEnd]);
+  }
+
+  // Check that all the grains started or ended at the correct time.
+  if (!errorCountStart) {
+    should(
+        startFrames.length, 'Number of grains that started at the correct time')
+        .beEqualTo(numberOfTests);
+  } else {
+    should(
+        errorCountStart,
+        'Number of grains out of ' + numberOfTests +
+            'that started at the wrong time')
+        .beEqualTo(0);
+  }
+
+  if (!errorCountEnd) {
+    should(endFrames.length, 'Number of grains that ended at the correct time')
+        .beEqualTo(numberOfTests);
+  } else {
+    should(
+        errorCountEnd,
+        'Number of grains out of ' + numberOfTests +
+            ' that ended at the wrong time')
+        .beEqualTo(0);
+  }
+}
diff --git a/testing/web-platform/tests/webaudio/resources/panner-formulas.js b/testing/web-platform/tests/webaudio/resources/panner-formulas.js
new file mode 100644
index 0000000000..ae6f516668
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/resources/panner-formulas.js
@@ -0,0 +1,190 @@
+// For the record, these distance formulas were taken from the OpenAL
+// spec
+// (http://connect.creativelabs.com/openal/Documentation/OpenAL%201.1%20Specification.pdf),
+// not the code.  The Web Audio spec follows the OpenAL formulas.
+
+function linearDistance(panner, x, y, z) {
+  let distance = Math.sqrt(x * x + y * y + z * z);
+  let dref = Math.min(panner.refDistance, panner.maxDistance);
+  let dmax = Math.max(panner.refDistance, panner.maxDistance);
+  distance = Math.max(Math.min(distance, dmax), dref);
+  let rolloff = Math.max(Math.min(panner.rolloffFactor, 1), 0);
+  if (dref === dmax)
+    return 1 - rolloff;
+
+  let gain = (1 - rolloff * (distance - dref) / (dmax - dref));
+
+  return gain;
+}
+
+function inverseDistance(panner, x, y, z) {
+  let distance = Math.sqrt(x * x + y * y + z * z);
+  distance = Math.max(distance, panner.refDistance);
+  let rolloff = panner.rolloffFactor;
+  let gain = panner.refDistance /
+      (panner.refDistance +
+       rolloff * (Math.max(distance, panner.refDistance) - panner.refDistance));
+
+  return gain;
+}
+
+function exponentialDistance(panner, x, y, z) {
+  let distance = Math.sqrt(x * x + y * y + z * z);
+  distance = Math.max(distance, panner.refDistance);
+  let rolloff = panner.rolloffFactor;
+  let gain = Math.pow(distance / panner.refDistance, -rolloff);
+
+  return gain;
+}
+
+// Simple implementations of 3D vectors implemented as a 3-element array.
+
+// x - y
+function vec3Sub(x, y) {
+  let z = new Float32Array(3);
+  z[0] = x[0] - y[0];
+  z[1] = x[1] - y[1];
+  z[2] = x[2] - y[2];
+
+  return z;
+}
+
+// x/|x|
+function vec3Normalize(x) {
+  let mag = Math.hypot(...x);
+  return x.map(function(c) {
+    return c / mag;
+  });
+}
+
+// x == 0?
+function vec3IsZero(x) {
+  return x[0] === 0 && x[1] === 0 && x[2] === 0;
+}
+
+// Vector cross product
+function vec3Cross(u, v) {
+  let cross = new Float32Array(3);
+  cross[0] = u[1] * v[2] - u[2] * v[1];
+  cross[1] = u[2] * v[0] - u[0] * v[2];
+  cross[2] = u[0] * v[1] - u[1] * v[0];
+  return cross;
+}
+
+// Dot product
+function vec3Dot(x, y) {
+  return x[0] * y[0] + x[1] * y[1] + x[2] * y[2];
+}
+
+// a*x, for scalar a
+function vec3Scale(a, x) {
+  return x.map(function(c) {
+    return a * c;
+  });
+}
+
+function calculateAzimuth(source, listener, listenerForward, listenerUp) {
+  let sourceListener = vec3Sub(source, listener);
+
+  if (vec3IsZero(sourceListener))
+    return 0;
+
+  sourceListener = vec3Normalize(sourceListener);
+
+  let listenerRight = vec3Normalize(vec3Cross(listenerForward, listenerUp));
+  let listenerForwardNorm = vec3Normalize(listenerForward);
+
+  let up = vec3Cross(listenerRight, listenerForwardNorm);
+  let upProjection = vec3Dot(sourceListener, up);
+
+  let projectedSource =
+      vec3Normalize(vec3Sub(sourceListener, vec3Scale(upProjection, up)));
+
+  let azimuth =
+      180 / Math.PI * Math.acos(vec3Dot(projectedSource, listenerRight));
+
+  // Source in front or behind the listener
+  let frontBack = vec3Dot(projectedSource, listenerForwardNorm);
+  if (frontBack < 0)
+    azimuth = 360 - azimuth;
+
+  // Make azimuth relative to "front" and not "right" listener vector.
+  if (azimuth >= 0 && azimuth <= 270)
+    azimuth = 90 - azimuth;
+  else
+    azimuth = 450 - azimuth;
+
+  // We don't need elevation, so we're skipping that computation.
+  return azimuth;
+}
+
+// Map our position angle to the azimuth angle (in degrees).
+//
+// An angle of 0 corresponds to an azimuth of 90 deg; pi, to -90 deg.
+function angleToAzimuth(angle) {
+  return 90 - angle * 180 / Math.PI;
+}
+
+// The gain caused by the EQUALPOWER panning model
+function equalPowerGain(azimuth, numberOfChannels) {
+  let halfPi = Math.PI / 2;
+
+  if (azimuth < -90)
+    azimuth = -180 - azimuth;
+  else
+    azimuth = 180 - azimuth;
+
+  if (numberOfChannels == 1) {
+    let panPosition = (azimuth + 90) / 180;
+
+    let gainL = Math.cos(halfPi * panPosition);
+    let gainR = Math.sin(halfPi * panPosition);
+
+    return {left: gainL, right: gainR};
+  } else {
+    if (azimuth <= 0) {
+      let panPosition = (azimuth + 90) / 90;
+
+      let gainL = Math.cos(halfPi * panPosition);
+      let gainR = Math.sin(halfPi * panPosition);
+
+      return {left: gainL, right: gainR};
+    } else {
+      let panPosition = azimuth / 90;
+
+      let gainL = Math.cos(halfPi * panPosition);
+      let gainR = Math.sin(halfPi * panPosition);
+
+      return {left: gainL, right: gainR};
+    }
+  }
+}
+
+function applyPanner(azimuth, srcL, srcR, numberOfChannels) {
+  let length = srcL.length;
+  let outL = new Float32Array(length);
+  let outR = new Float32Array(length);
+
+  if (numberOfChannels == 1) {
+    for (let k = 0; k < length; ++k) {
+      let gains = equalPowerGain(azimuth[k], numberOfChannels);
+
+      outL[k] = srcL[k] * gains.left;
+      outR[k] = srcR[k] * gains.right;
+    }
+  } else {
+    for (let k = 0; k < length; ++k) {
+      let gains = equalPowerGain(azimuth[k], numberOfChannels);
+
+      if (azimuth[k] <= 0) {
+        outL[k] = srcL[k] + srcR[k] * gains.left;
+        outR[k] = srcR[k] * gains.right;
+      } else {
+        outL[k] = srcL[k] * gains.left;
+        outR[k] = srcR[k] + srcL[k] * gains.right;
+      }
+    }
+  }
+
+  return {left: outL, right: outR};
+}
diff --git a/testing/web-platform/tests/webaudio/resources/panner-model-testing.js b/testing/web-platform/tests/webaudio/resources/panner-model-testing.js
new file mode 100644
index 0000000000..4df3e17813
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/resources/panner-model-testing.js
@@ -0,0 +1,184 @@
+// Use a power of two to eliminate round-off when converting frames to time and
+// vice versa.
+let sampleRate = 32768;
+
+let numberOfChannels = 1;
+
+// Time step when each panner node starts.  Make sure it starts on a frame
+// boundary.
+let timeStep = Math.floor(0.001 * sampleRate) / sampleRate;
+
+// Length of the impulse signal.
+let pulseLengthFrames = Math.round(timeStep * sampleRate);
+
+// How many panner nodes to create for the test
+let nodesToCreate = 100;
+
+// Be sure we render long enough for all of our nodes.
+let renderLengthSeconds = timeStep * (nodesToCreate + 1);
+
+// These are global mostly for debugging.
+let context;
+let impulse;
+let bufferSource;
+let panner;
+let position;
+let time;
+
+let renderedBuffer;
+let renderedLeft;
+let renderedRight;
+
+function createGraph(context, nodeCount, positionSetter) {
+  bufferSource = new Array(nodeCount);
+  panner = new Array(nodeCount);
+  position = new Array(nodeCount);
+  time = new Array(nodeCount);
+  // Angle between panner locations.  (nodeCount - 1 because we want
+  // to include both 0 and 180 deg.
+  let angleStep = Math.PI / (nodeCount - 1);
+
+  if (numberOfChannels == 2) {
+    impulse = createStereoImpulseBuffer(context, pulseLengthFrames);
+  } else
+    impulse = createImpulseBuffer(context, pulseLengthFrames);
+
+  for (let k = 0; k < nodeCount; ++k) {
+    bufferSource[k] = context.createBufferSource();
+    bufferSource[k].buffer = impulse;
+
+    panner[k] = context.createPanner();
+    panner[k].panningModel = 'equalpower';
+    panner[k].distanceModel = 'linear';
+
+    let angle = angleStep * k;
+    position[k] = {angle: angle, x: Math.cos(angle), z: Math.sin(angle)};
+    positionSetter(panner[k], position[k].x, 0, position[k].z);
+
+    bufferSource[k].connect(panner[k]);
+    panner[k].connect(context.destination);
+
+    // Start the source
+    time[k] = k * timeStep;
+    bufferSource[k].start(time[k]);
+  }
+}
+
+function createTestAndRun(
+    context, should, nodeCount, numberOfSourceChannels, positionSetter) {
+  numberOfChannels = numberOfSourceChannels;
+
+  createGraph(context, nodeCount, positionSetter);
+
+  return context.startRendering().then(buffer => checkResult(buffer, should));
+}
+
+// Map our position angle to the azimuth angle (in degrees).
+//
+// An angle of 0 corresponds to an azimuth of 90 deg; pi, to -90 deg.
+function angleToAzimuth(angle) {
+  return 90 - angle * 180 / Math.PI;
+}
+
+// The gain caused by the EQUALPOWER panning model
+function equalPowerGain(angle) {
+  let azimuth = angleToAzimuth(angle);
+
+  if (numberOfChannels == 1) {
+    let panPosition = (azimuth + 90) / 180;
+
+    let gainL = Math.cos(0.5 * Math.PI * panPosition);
+    let gainR = Math.sin(0.5 * Math.PI * panPosition);
+
+    return {left: gainL, right: gainR};
+  } else {
+    if (azimuth <= 0) {
+      let panPosition = (azimuth + 90) / 90;
+
+      let gainL = 1 + Math.cos(0.5 * Math.PI * panPosition);
+      let gainR = Math.sin(0.5 * Math.PI * panPosition);
+
+      return {left: gainL, right: gainR};
+    } else {
+      let panPosition = azimuth / 90;
+
+      let gainL = Math.cos(0.5 * Math.PI * panPosition);
+      let gainR = 1 + Math.sin(0.5 * Math.PI * panPosition);
+
+      return {left: gainL, right: gainR};
+    }
+  }
+}
+
+function checkResult(renderedBuffer, should) {
+  renderedLeft = renderedBuffer.getChannelData(0);
+  renderedRight = renderedBuffer.getChannelData(1);
+
+  // The max error we allow between the rendered impulse and the
+  // expected value.  This value is experimentally determined.  Set
+  // to 0 to make the test fail to see what the actual error is.
+  let maxAllowedError = 1.1597e-6;
+
+  let success = true;
+
+  // Number of impulses found in the rendered result.
+  let impulseCount = 0;
+
+  // Max (relative) error and the index of the maxima for the left
+  // and right channels.
+  let maxErrorL = 0;
+  let maxErrorIndexL = 0;
+  let maxErrorR = 0;
+  let maxErrorIndexR = 0;
+
+  // Number of impulses that don't match our expected locations.
+  let timeCount = 0;
+
+  // Locations of where the impulses aren't at the expected locations.
+  let timeErrors = new Array();
+
+  for (let k = 0; k < renderedLeft.length; ++k) {
+    // We assume that the left and right channels start at the same instant.
+    if (renderedLeft[k] != 0 || renderedRight[k] != 0) {
+      // The expected gain for the left and right channels.
+      let pannerGain = equalPowerGain(position[impulseCount].angle);
+      let expectedL = pannerGain.left;
+      let expectedR = pannerGain.right;
+
+      // Absolute error in the gain.
+      let errorL = Math.abs(renderedLeft[k] - expectedL);
+      let errorR = Math.abs(renderedRight[k] - expectedR);
+
+      if (Math.abs(errorL) > maxErrorL) {
+        maxErrorL = Math.abs(errorL);
+        maxErrorIndexL = impulseCount;
+      }
+      if (Math.abs(errorR) > maxErrorR) {
+        maxErrorR = Math.abs(errorR);
+        maxErrorIndexR = impulseCount;
+      }
+
+      // Keep track of the impulses that didn't show up where we
+      // expected them to be.
+      let expectedOffset = timeToSampleFrame(time[impulseCount], sampleRate);
+      if (k != expectedOffset) {
+        timeErrors[timeCount] = {actual: k, expected: expectedOffset};
+        ++timeCount;
+      }
+      ++impulseCount;
+    }
+  }
+
+  should(impulseCount, 'Number of impulses found').beEqualTo(nodesToCreate);
+
+  should(
+      timeErrors.map(x => x.actual),
+      'Offsets of impulses at the wrong position')
+      .beEqualToArray(timeErrors.map(x => x.expected));
+
+  should(maxErrorL, 'Error in left channel gain values')
+      .beLessThanOrEqualTo(maxAllowedError);
+
+  should(maxErrorR, 'Error in right channel gain values')
+      .beLessThanOrEqualTo(maxAllowedError);
+}
diff --git a/testing/web-platform/tests/webaudio/resources/sin_440Hz_-6dBFS_1s.wav b/testing/web-platform/tests/webaudio/resources/sin_440Hz_-6dBFS_1s.wav
new file mode 100644
index 0000000000..f660c3c4b8
Binary files /dev/null and b/testing/web-platform/tests/webaudio/resources/sin_440Hz_-6dBFS_1s.wav differ
diff --git a/testing/web-platform/tests/webaudio/resources/start-stop-exceptions.js b/testing/web-platform/tests/webaudio/resources/start-stop-exceptions.js
new file mode 100644
index 0000000000..0d2ea12f6d
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/resources/start-stop-exceptions.js
@@ -0,0 +1,45 @@
+// Test that exceptions are throw for invalid values for start and
+// stop.
+function testStartStop(should, node, options) {
+  // Test non-finite values for start.  These should all throw a TypeError
+  const nonFiniteValues = [NaN, Infinity, -Infinity];
+
+  nonFiniteValues.forEach(time => {
+      should(() => {
+        node.start(time);
+      }, `start(${time})`)
+    .throw(TypeError);
+    });
+
+  should(() => {
+    node.stop();
+  }, 'Calling stop() before start()').throw(DOMException, 'InvalidStateError');
+
+  should(() => {
+    node.start(-1);
+  }, 'start(-1)').throw(RangeError);
+
+  if (options) {
+    options.forEach(test => {
+      should(() => {node.start(...test.args)},
+             'start(' + test.args + ')').throw(test.errorType);
+    });
+  }
+
+  node.start();
+  should(() => {
+    node.start();
+  }, 'Calling start() twice').throw(DOMException, 'InvalidStateError');
+  should(() => {
+    node.stop(-1);
+  }, 'stop(-1)').throw(RangeError);
+
+  // Test non-finite stop times
+  nonFiniteValues.forEach(time => {
+      should(() => {
+        node.stop(time);
+      }, `stop(${time})`)
+    .throw(TypeError);
+    });
+}
+
diff --git a/testing/web-platform/tests/webaudio/resources/stereopanner-testing.js b/testing/web-platform/tests/webaudio/resources/stereopanner-testing.js
new file mode 100644
index 0000000000..6ea5eb6269
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/resources/stereopanner-testing.js
@@ -0,0 +1,205 @@
+let StereoPannerTest = (function() {
+
+  // Constants
+  let PI_OVER_TWO = Math.PI * 0.5;
+
+  // Use a power of two to eliminate any round-off when converting frames to
+  // time.
+  let gSampleRate = 32768;
+
+  // Time step when each panner node starts.  Make sure this is on a frame boundary.
+  let gTimeStep = Math.floor(0.001 * gSampleRate) / gSampleRate;
+
+  // How many panner nodes to create for the test
+  let gNodesToCreate = 100;
+
+  // Total render length for all of our nodes.
+  let gRenderLength = gTimeStep * (gNodesToCreate + 1) + gSampleRate;
+
+  // Calculates channel gains based on equal power panning model.
+  // See: http://webaudio.github.io/web-audio-api/#panning-algorithm
+  function getChannelGain(pan, numberOfChannels) {
+    // The internal panning clips the pan value between -1, 1.
+    pan = Math.min(Math.max(pan, -1), 1);
+    let gainL, gainR;
+    // Consider number of channels and pan value's polarity.
+    if (numberOfChannels == 1) {
+      let panRadian = (pan * 0.5 + 0.5) * PI_OVER_TWO;
+      gainL = Math.cos(panRadian);
+      gainR = Math.sin(panRadian);
+    } else {
+      let panRadian = (pan <= 0 ? pan + 1 : pan) * PI_OVER_TWO;
+      if (pan <= 0) {
+        gainL = 1 + Math.cos(panRadian);
+        gainR = Math.sin(panRadian);
+      } else {
+        gainL = Math.cos(panRadian);
+        gainR = 1 + Math.sin(panRadian);
+      }
+    }
+    return {gainL: gainL, gainR: gainR};
+  }
+
+
+  /**
+   * Test implementation class.
+   * @param {Object} options Test options
+   * @param {Object} options.description Test description
+   * @param {Object} options.numberOfInputChannels Number of input channels
+   */
+  function Test(should, options) {
+    // Primary test flag.
+    this.success = true;
+
+    this.should = should;
+    this.context = null;
+    this.prefix = options.prefix;
+    this.numberOfInputChannels = (options.numberOfInputChannels || 1);
+    switch (this.numberOfInputChannels) {
+      case 1:
+        this.description = 'Test for mono input';
+        break;
+      case 2:
+        this.description = 'Test for stereo input';
+        break;
+    }
+
+    // Onset time position of each impulse.
+    this.onsets = [];
+
+    // Pan position value of each impulse.
+    this.panPositions = [];
+
+    // Locations of where the impulses aren't at the expected locations.
+    this.errors = [];
+
+    // The index of the current impulse being verified.
+    this.impulseIndex = 0;
+
+    // The max error we allow between the rendered impulse and the
+    // expected value.  This value is experimentally determined.  Set
+    // to 0 to make the test fail to see what the actual error is.
+    this.maxAllowedError = 1.284318e-7;
+
+    // Max (absolute) error and the index of the maxima for the left
+    // and right channels.
+    this.maxErrorL = 0;
+    this.maxErrorR = 0;
+    this.maxErrorIndexL = 0;
+    this.maxErrorIndexR = 0;
+
+    // The maximum value to use for panner pan value. The value will range from
+    // -panLimit to +panLimit.
+    this.panLimit = 1.0625;
+  }
+
+
+  Test.prototype.init = function() {
+    this.context = new OfflineAudioContext(2, gRenderLength, gSampleRate);
+  };
+
+  // Prepare an audio graph for testing. Create multiple impulse generators and
+  // panner nodes, then play them sequentially while varying the pan position.
+  Test.prototype.prepare = function() {
+    let impulse;
+    let impulseLength = Math.round(gTimeStep * gSampleRate);
+    let sources = [];
+    let panners = [];
+
+    // Moves the pan value for each panner by pan step unit from -2 to 2.
+    // This is to check if the internal panning value is clipped properly.
+    let panStep = (2 * this.panLimit) / (gNodesToCreate - 1);
+
+    if (this.numberOfInputChannels === 1) {
+      impulse = createImpulseBuffer(this.context, impulseLength);
+    } else {
+      impulse = createStereoImpulseBuffer(this.context, impulseLength);
+    }
+
+    for (let i = 0; i < gNodesToCreate; i++) {
+      sources[i] = this.context.createBufferSource();
+      panners[i] = this.context.createStereoPanner();
+      sources[i].connect(panners[i]);
+      panners[i].connect(this.context.destination);
+      sources[i].buffer = impulse;
+      panners[i].pan.value = this.panPositions[i] = panStep * i - this.panLimit;
+
+      // Store the onset time position of impulse.
+      this.onsets[i] = gTimeStep * i;
+
+      sources[i].start(this.onsets[i]);
+    }
+  };
+
+
+  Test.prototype.verify = function() {
+    let chanL = this.renderedBufferL;
+    let chanR = this.renderedBufferR;
+    for (let i = 0; i < chanL.length; i++) {
+      // Left and right channels must start at the same instant.
+      if (chanL[i] !== 0 || chanR[i] !== 0) {
+        // Get amount of error between actual and expected gain.
+        let expected = getChannelGain(
+            this.panPositions[this.impulseIndex], this.numberOfInputChannels);
+        let errorL = Math.abs(chanL[i] - expected.gainL);
+        let errorR = Math.abs(chanR[i] - expected.gainR);
+
+        if (errorL > this.maxErrorL) {
+          this.maxErrorL = errorL;
+          this.maxErrorIndexL = this.impulseIndex;
+        }
+        if (errorR > this.maxErrorR) {
+          this.maxErrorR = errorR;
+          this.maxErrorIndexR = this.impulseIndex;
+        }
+
+        // Keep track of the impulses that didn't show up where we expected
+        // them to be.
+        let expectedOffset =
+            timeToSampleFrame(this.onsets[this.impulseIndex], gSampleRate);
+        if (i != expectedOffset) {
+          this.errors.push({actual: i, expected: expectedOffset});
+        }
+
+        this.impulseIndex++;
+      }
+    }
+  };
+
+
+  Test.prototype.showResult = function() {
+    this.should(this.impulseIndex, this.prefix + 'Number of impulses found')
+        .beEqualTo(gNodesToCreate);
+
+    this.should(
+            this.errors.length,
+            this.prefix + 'Number of impulse at the wrong offset')
+        .beEqualTo(0);
+
+    this.should(this.maxErrorL, this.prefix + 'Left channel error magnitude')
+        .beLessThanOrEqualTo(this.maxAllowedError);
+
+    this.should(this.maxErrorR, this.prefix + 'Right channel error magnitude')
+        .beLessThanOrEqualTo(this.maxAllowedError);
+  };
+
+  Test.prototype.run = function() {
+
+    this.init();
+    this.prepare();
+
+    return this.context.startRendering().then(renderedBuffer => {
+      this.renderedBufferL = renderedBuffer.getChannelData(0);
+      this.renderedBufferR = renderedBuffer.getChannelData(1);
+      this.verify();
+      this.showResult();
+    });
+  };
+
+  return {
+    create: function(should, options) {
+      return new Test(should, options);
+    }
+  };
+
+})();
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/processing-model/cycle-without-delay.html b/testing/web-platform/tests/webaudio/the-audio-api/processing-model/cycle-without-delay.html
new file mode 100644
index 0000000000..cab0f6ca8e
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/processing-model/cycle-without-delay.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html>
+<html class="a">
+  <head>
+    <title>Cycles without DelayNode in audio node graph</title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+  </head>
+  <body>
+    <script>
+      function doTest() {
+        var off = new OfflineAudioContext(1, 512, 48000);
+        var osc = new OscillatorNode(off);
+        var fb = new GainNode(off);
+        // zero delay feedback loop
+        osc.connect(fb).connect(fb).connect(off.destination);
+        osc.start(0);
+        return off.startRendering().then((b) => {
+          return Promise.resolve(b.getChannelData(0));
+        });
+      }
+
+      promise_test(() => {
+        return doTest().then(samples => {
+          var silent = true;
+          for (var i = 0; i < samples.length; i++) {
+            if (samples[i] != 0.0) {
+              silent = false;
+              break;
+            }
+          }
+          assert_true(silent);
+        });
+      }, 'Test that cycles that don\'t contain a DelayNode are muted');
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/processing-model/delay-time-clamping.html b/testing/web-platform/tests/webaudio/the-audio-api/processing-model/delay-time-clamping.html
new file mode 100644
index 0000000000..fa010df3cd
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/processing-model/delay-time-clamping.html
@@ -0,0 +1,43 @@
+<!DOCTYPE html>
+<html class="a">
+  <head>
+    <title>Delay time clamping in cycles</title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+  </head>
+  <body>
+    <script>
+      function doTest() {
+        let off = new OfflineAudioContext(1, 512, 48000);
+        let b = new AudioBuffer({sampleRate: off.sampleRate, length: 1});
+        b.getChannelData(0)[0] = 1;
+        let impulse = new AudioBufferSourceNode(off, {buffer: b});
+        impulse.start(0);
+        // This delayTime of 64 samples MUST be clamped to 128 samples when
+        // in a cycle.
+        let delay = new DelayNode(off, {delayTime: 64 / 48000});
+        let fb = new GainNode(off);
+        impulse.connect(fb).connect(delay).connect(fb).connect(off.destination);
+        return off.startRendering().then((b) => {
+          return Promise.resolve(b.getChannelData(0));
+        })
+      }
+
+      promise_test(() => {
+        return doTest().then(samples => {
+          for (var i = 0; i < samples.length; i++) {
+            if ((i % 128) != 0) {
+              assert_equals(
+                  samples[i], 0.0,
+                  'Non-silent audio found in between delayed impulses');
+            } else {
+              assert_equals(
+                  samples[i], 1.0,
+                  'Silent audio found instead of a delayed impulse');
+            }
+          }
+        });
+      }, 'Test that a DelayNode allows a feedback loop of a single rendering quantum');
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/processing-model/feedback-delay-time.html b/testing/web-platform/tests/webaudio/the-audio-api/processing-model/feedback-delay-time.html
new file mode 100644
index 0000000000..96c2eb0658
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/processing-model/feedback-delay-time.html
@@ -0,0 +1,42 @@
+<!DOCTYPE html>
+<html class="a">
+  <head>
+    <title>Feedback cycle with delay in audio node graph</title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+  </head>
+  <body>
+    <script>
+      function doTest() {
+        var off = new OfflineAudioContext(1, 512, 48000);
+        var b = off.createBuffer(1, 1, 48000);
+        b.getChannelData(0)[0] = 1;
+        var impulse = new AudioBufferSourceNode(off, {buffer: b});
+        impulse.start(0);
+        var delay = new DelayNode(off, {delayTime: 128 / 48000});
+        var fb = new GainNode(off);
+        impulse.connect(fb).connect(delay).connect(fb).connect(off.destination);
+        var samples;
+        return off.startRendering().then((b) => {
+          return Promise.resolve(b.getChannelData(0));
+        });
+      }
+
+      promise_test(() => {
+        return doTest().then(samples => {
+          for (var i = 0; i < samples.length; i++) {
+            if ((i % 128) != 0) {
+              assert_equals(
+                  samples[i], 0.0,
+                  'Non-silent audio found in between delayed impulses');
+            } else {
+              assert_equals(
+                  samples[i], 1.0,
+                  'Silent audio found instead of a delayed impulse');
+            }
+          }
+        });
+      }, 'Test that a DelayNode allows a feedback loop of a single rendering quantum');
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/ctor-analyser.html b/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/ctor-analyser.html
new file mode 100644
index 0000000000..a9aa483151
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/ctor-analyser.html
@@ -0,0 +1,183 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Constructor: AnalyserNode
+    </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, 'AnalyserNode', context);
+        task.done();
+      });
+
+      audit.define('default constructor', (task, should) => {
+        let prefix = 'node0';
+        let node = testDefaultConstructor(should, 'AnalyserNode', context, {
+          prefix: prefix,
+          numberOfInputs: 1,
+          numberOfOutputs: 1,
+          channelCount: 2,
+          channelCountMode: 'max',
+          channelInterpretation: 'speakers'
+        });
+
+        testDefaultAttributes(should, node, prefix, [
+          {name: 'fftSize', value: 2048},
+          {name: 'frequencyBinCount', value: 1024},
+          {name: 'minDecibels', value: -100}, {name: 'maxDecibels', value: -30},
+          {name: 'smoothingTimeConstant', value: 0.8}
+        ]);
+
+        task.done();
+      });
+
+      audit.define('test AudioNodeOptions', (task, should) => {
+        testAudioNodeOptions(should, context, 'AnalyserNode');
+        task.done();
+      });
+
+      audit.define('constructor with options', (task, should) => {
+        let options = {
+          fftSize: 32,
+          maxDecibels: 1,
+          minDecibels: -13,
+          // Choose a value that can be represented the same as a float and as a
+          // double.
+          smoothingTimeConstant: 0.125
+        };
+
+        let node;
+        should(
+            () => {
+              node = new AnalyserNode(context, options);
+            },
+            'node1 = new AnalyserNode(c, ' + JSON.stringify(options) + ')')
+            .notThrow();
+
+        should(node instanceof AnalyserNode, 'node1 instanceof AnalyserNode')
+            .beEqualTo(true);
+        should(node.fftSize, 'node1.fftSize').beEqualTo(options.fftSize);
+        should(node.maxDecibels, 'node1.maxDecibels')
+            .beEqualTo(options.maxDecibels);
+        should(node.minDecibels, 'node1.minDecibels')
+            .beEqualTo(options.minDecibels);
+        should(node.smoothingTimeConstant, 'node1.smoothingTimeConstant')
+            .beEqualTo(options.smoothingTimeConstant);
+
+        task.done();
+      });
+
+      audit.define('construct invalid options', (task, should) => {
+        let node;
+
+        should(
+            () => {
+              node = new AnalyserNode(context, {fftSize: 33});
+            },
+            'node = new AnalyserNode(c, { fftSize: 33 })')
+            .throw(DOMException, 'IndexSizeError');
+        should(
+            () => {
+              node = new AnalyserNode(context, {maxDecibels: -500});
+            },
+            'node = new AnalyserNode(c, { maxDecibels: -500 })')
+            .throw(DOMException, 'IndexSizeError');
+        should(
+            () => {
+              node = new AnalyserNode(context, {minDecibels: -10});
+            },
+            'node = new AnalyserNode(c, { minDecibels: -10 })')
+            .throw(DOMException, 'IndexSizeError');
+        should(
+            () => {
+              node = new AnalyserNode(context, {smoothingTimeConstant: 2});
+            },
+            'node = new AnalyserNode(c, { smoothingTimeConstant: 2 })')
+            .throw(DOMException, 'IndexSizeError');
+        should(function() {
+          node = new AnalyserNode(context, {frequencyBinCount: 33});
+        }, 'node = new AnalyserNode(c, { frequencyBinCount: 33 })').notThrow();
+        should(node.frequencyBinCount, 'node.frequencyBinCount')
+            .beEqualTo(1024);
+
+        task.done();
+      });
+
+      audit.define('setting min/max', (task, should) => {
+        let node;
+
+        // Recall the default values of minDecibels and maxDecibels are -100,
+        // and -30, respectively.  Setting both values in the constructor should
+        // not signal an error in any of the following cases.
+        let options = {minDecibels: -10, maxDecibels: 20};
+        should(
+            () => {
+              node = new AnalyserNode(context, options);
+            },
+            'node = new AnalyserNode(c, ' + JSON.stringify(options) + ')')
+            .notThrow();
+
+        options = {maxDecibels: 20, minDecibels: -10};
+        should(
+            () => {
+              node = new AnalyserNode(context, options);
+            },
+            'node = new AnalyserNode(c, ' + JSON.stringify(options) + ')')
+            .notThrow();
+
+        options = {minDecibels: -200, maxDecibels: -150};
+        should(
+            () => {
+              node = new AnalyserNode(context, options);
+            },
+            'node = new AnalyserNode(c, ' + JSON.stringify(options) + ')')
+            .notThrow();
+
+        options = {maxDecibels: -150, minDecibels: -200};
+        should(
+            () => {
+              node = new AnalyserNode(context, options);
+            },
+            'node = new AnalyserNode(c, ' + JSON.stringify(options) + ')')
+            .notThrow();
+
+        // But these should signal because minDecibel > maxDecibel
+        options = {maxDecibels: -150, minDecibels: -10};
+        should(
+            () => {
+              node = new AnalyserNode(context, options);
+            },
+            'node = new AnalyserNode(c, ' + JSON.stringify(options) + ')')
+            .throw(DOMException, 'IndexSizeError');
+
+        options = {minDecibels: -10, maxDecibels: -150};
+        should(
+            () => {
+              node = new AnalyserNode(context, options);
+            },
+            'node = new AnalyserNode(c, ' + JSON.stringify(options) + ')')
+            .throw(DOMException, 'IndexSizeError');
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/realtimeanalyser-basic.html b/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/realtimeanalyser-basic.html
new file mode 100644
index 0000000000..e176d6111e
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/realtimeanalyser-basic.html
@@ -0,0 +1,57 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      realtimeanalyser-basic.html
+    </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 context = 0;
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define('Basic AnalyserNode test', function(task, should) {
+        context = new AudioContext();
+        let analyser = context.createAnalyser();
+
+        should(analyser.numberOfInputs, 'Number of inputs for AnalyserNode')
+            .beEqualTo(1);
+
+        should(analyser.numberOfOutputs, 'Number of outputs for AnalyserNode')
+            .beEqualTo(1);
+
+        should(analyser.minDecibels, 'Default minDecibels value')
+            .beEqualTo(-100);
+
+        should(analyser.maxDecibels, 'Default maxDecibels value')
+            .beEqualTo(-30);
+
+        should(
+            analyser.smoothingTimeConstant,
+            'Default smoothingTimeConstant value')
+            .beEqualTo(0.8);
+
+        let expectedValue = -50 - (1 / 3);
+        analyser.minDecibels = expectedValue;
+
+        should(analyser.minDecibels, 'node.minDecibels = ' + expectedValue)
+            .beEqualTo(expectedValue);
+
+        expectedValue = -40 - (1 / 3);
+        analyser.maxDecibels = expectedValue;
+
+        should(analyser.maxDecibels, 'node.maxDecibels = ' + expectedValue)
+            .beEqualTo(expectedValue);
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/realtimeanalyser-fft-scaling.html b/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/realtimeanalyser-fft-scaling.html
new file mode 100644
index 0000000000..043bd5890a
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/realtimeanalyser-fft-scaling.html
@@ -0,0 +1,111 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      realtimeanalyser-fft-scaling.html
+    </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>
+    <div id="description"></div>
+    <div id="console"></div>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      // The number of analysers. We have analysers from size for each of the
+      // possible sizes of 2^5 to 2^15 for a total of 11.
+      let numberOfAnalysers = 11;
+      let sampleRate = 44100;
+      let nyquistFrequency = sampleRate / 2;
+
+      // Frequency of the sine wave test signal.  Should be high enough so that
+      // we get at least one full cycle for the 32-point FFT.  This should also
+      // be such that the frequency should be exactly in one of the FFT bins for
+      // each of the possible FFT sizes.
+      let oscFrequency = nyquistFrequency / 16;
+
+      // The actual peak values from each analyser.  Useful for examining the
+      // actual peak values.
+      let peakValue = new Array(numberOfAnalysers);
+
+      // For a 0dBFS sine wave, we would expect the FFT magnitude to be 0dB as
+      // well, but the analyzer node applies a Blackman window (to smooth the
+      // estimate).  This reduces the energy of the signal so the FFT peak is
+      // less than 0dB.  The threshold value given here was determined
+      // experimentally.
+      //
+      // See https://code.google.com/p/chromium/issues/detail?id=341596.
+      let peakThreshold = [
+        -14.43, -13.56, -13.56, -13.56, -13.56, -13.56, -13.56, -13.56, -13.56,
+        -13.56, -13.56
+      ];
+
+      function checkResult(order, analyser, should) {
+        return function() {
+          let index = order - 5;
+          let fftSize = 1 << order;
+          let fftData = new Float32Array(fftSize);
+          analyser.getFloatFrequencyData(fftData);
+
+          // Compute the frequency bin that should contain the peak.
+          let expectedBin =
+              analyser.frequencyBinCount * (oscFrequency / nyquistFrequency);
+
+          // Find the actual bin by finding the bin containing the peak.
+          let actualBin = 0;
+          peakValue[index] = -1000;
+          for (k = 0; k < analyser.frequencyBinCount; ++k) {
+            if (fftData[k] > peakValue[index]) {
+              actualBin = k;
+              peakValue[index] = fftData[k];
+            }
+          }
+
+          should(actualBin, (1 << order) + '-point FFT peak position')
+              .beEqualTo(expectedBin);
+
+          should(
+              peakValue[index], (1 << order) + '-point FFT peak value in dBFS')
+              .beGreaterThanOrEqualTo(peakThreshold[index]);
+        }
+      }
+
+      audit.define(
+          {
+            label: 'FFT scaling tests',
+            description: 'Test Scaling of FFT in AnalyserNode'
+          },
+          async function(task, should) {
+            let tests = [];
+            for (let k = 5; k <= 15; ++k)
+              await runTest(k, should);
+            task.done();
+          });
+
+      function runTest(order, should) {
+        let context = new OfflineAudioContext(1, 1 << order, sampleRate);
+        // Use a sine wave oscillator as the reference source signal.
+        let osc = context.createOscillator();
+        osc.type = 'sine';
+        osc.frequency.value = oscFrequency;
+        osc.connect(context.destination);
+
+        let analyser = context.createAnalyser();
+        // No smoothing to simplify the analysis of the result.
+        analyser.smoothingTimeConstant = 0;
+        analyser.fftSize = 1 << order;
+        osc.connect(analyser);
+
+        osc.start();
+        return context.startRendering().then(() => {
+          checkResult(order, analyser, should)();
+        });
+      }
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/realtimeanalyser-fft-sizing.html b/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/realtimeanalyser-fft-sizing.html
new file mode 100644
index 0000000000..7ee6a2237e
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/realtimeanalyser-fft-sizing.html
@@ -0,0 +1,54 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      realtimeanalyser-fft-sizing.html
+    </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 audit = Audit.createTaskRunner();
+
+      function doTest(fftSize, illegal, should) {
+        let c = new OfflineAudioContext(1, 1000, 44100);
+        let a = c.createAnalyser();
+        let message = 'Setting fftSize to ' + fftSize;
+        let tester = function() {
+          a.fftSize = fftSize;
+        };
+
+        if (illegal) {
+          should(tester, message).throw(DOMException, 'IndexSizeError');
+        } else {
+          should(tester, message).notThrow();
+        }
+      }
+
+      audit.define(
+          {
+            label: 'FFT size test',
+            description: 'Test that re-sizing the FFT arrays does not fail.'
+          },
+          function(task, should) {
+            doTest(-1, true, should);
+            doTest(0, true, should);
+            doTest(1, true, should);
+            for (let i = 2; i <= 0x20000; i *= 2) {
+              if (i >= 32 && i <= 32768)
+                doTest(i, false, should);
+              else
+                doTest(i, true, should);
+              doTest(i + 1, true, should);
+            }
+
+            task.done();
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/test-analyser-gain.html b/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/test-analyser-gain.html
new file mode 100644
index 0000000000..dff51a74c5
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/test-analyser-gain.html
@@ -0,0 +1,50 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <script src="/resources/testharness.js"></script>
+  <script src="/resources/testharnessreport.js"></script>
+  <script>
+promise_test(function() {
+  // fftSize <= bufferSize so that the time domain data is full of input after
+  // processing the buffer.
+  const fftSize = 32;
+  const bufferSize = 128;
+
+  var context = new OfflineAudioContext(1, bufferSize, 48000);
+
+  var analyser1 = context.createAnalyser();
+  analyser1.fftSize = fftSize;
+  analyser1.connect(context.destination);
+  var analyser2 = context.createAnalyser();
+  analyser2.fftSize = fftSize;
+
+  var gain = context.createGain();
+  gain.gain.value = 2.0;
+  gain.connect(analyser1);
+  gain.connect(analyser2);
+
+  // Create a DC input to make getFloatTimeDomainData() output consistent at
+  // any time.
+  var buffer = context.createBuffer(1, 1, context.sampleRate);
+  buffer.getChannelData(0)[0] = 1.0 / gain.gain.value;
+  var source = context.createBufferSource();
+  source.buffer = buffer;
+  source.loop = true;
+  source.connect(gain);
+  source.start();
+
+  return context.startRendering().then(function(buffer) {
+    assert_equals(buffer.getChannelData(0)[0], 1.0, "analyser1 output");
+
+    var data = new Float32Array(1);
+    analyser1.getFloatTimeDomainData(data);
+    assert_equals(data[0], 1.0, "analyser1 time domain data");
+    analyser2.getFloatTimeDomainData(data);
+    assert_equals(data[0], 1.0, "analyser2 time domain data");
+  });
+}, "Test effect of AnalyserNode on GainNode output");
+  </script>
+</head>
+</body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/test-analyser-minimum.html b/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/test-analyser-minimum.html
new file mode 100644
index 0000000000..ab0fe6b2d6
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/test-analyser-minimum.html
@@ -0,0 +1,43 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Test AnalyserNode when the input is silent</title>
+  <meta name="timeout" content="long">
+  <script src="/resources/testharness.js"></script>
+  <script src="/resources/testharnessreport.js"></script>
+  <script>
+    setup({ single_test: true });
+    var ac = new AudioContext();
+    var analyser = ac.createAnalyser();
+    var constant = ac.createConstantSource();
+    var sp = ac.createScriptProcessor(2048, 1, 1);
+
+    constant.offset.value = 0.0;
+
+    constant.connect(analyser).connect(ac.destination);
+
+    constant.connect(sp).connect(ac.destination);
+
+    var buf = new Float32Array(analyser.frequencyBinCount);
+    var iteration_count = 10;
+    sp.onaudioprocess = function() {
+      analyser.getFloatFrequencyData(buf);
+      var correct = true;
+      for (var i = 0; i < buf.length; i++) {
+        correct &= buf[i] == -Infinity;
+      }
+      assert_true(!!correct, "silent input process -Infinity in decibel bins");
+      if (!iteration_count--) {
+        sp.onaudioprocess = null;
+        constant.stop();
+        ac.close();
+        done();
+      }
+    };
+
+    constant.start();
+  </script>
+</head>
+</body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/test-analyser-output.html b/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/test-analyser-output.html
new file mode 100644
index 0000000000..43d56b8990
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/test-analyser-output.html
@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>AnalyserNode output</title>
+  <meta name="timeout" content="long">
+  <script src="/resources/testharness.js"></script>
+  <script src="/resources/testharnessreport.js"></script>
+  <script src="/webaudio/js/helpers.js"></script>
+  <script>
+setup({ single_test: true });
+
+var gTest = {
+  length: 2048,
+  numberOfChannels: 1,
+  createGraph: function(context) {
+    var source = context.createBufferSource();
+
+    var analyser = context.createAnalyser();
+
+    source.buffer = this.buffer;
+
+    source.connect(analyser);
+
+    source.start(0);
+    return analyser;
+  },
+  createExpectedBuffers: function(context) {
+    this.buffer = context.createBuffer(1, 2048, context.sampleRate);
+    for (var i = 0; i < 2048; ++i) {
+      this.buffer.getChannelData(0)[i] = Math.sin(
+        440 * 2 * Math.PI * i / context.sampleRate
+      );
+    }
+
+    return [this.buffer];
+  }
+};
+
+runTest("AnalyserNode output");
+  </script>
+</head>
+</body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/test-analyser-scale.html b/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/test-analyser-scale.html
new file mode 100644
index 0000000000..904b14bede
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/test-analyser-scale.html
@@ -0,0 +1,51 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Test AnalyserNode when the input is scaled</title>
+  <script src="/resources/testharness.js"></script>
+  <script src="/resources/testharnessreport.js"></script>
+  <script>
+    setup({ single_test: true });
+
+    var context = new AudioContext();
+
+    var gain = context.createGain();
+    var analyser = context.createAnalyser();
+    var osc = context.createOscillator();
+
+    osc.connect(gain);
+    gain.connect(analyser);
+
+    osc.start();
+
+    var array = new Uint8Array(analyser.frequencyBinCount);
+
+    function getAnalyserData() {
+      gain.gain.setValueAtTime(currentGain, context.currentTime);
+      analyser.getByteTimeDomainData(array);
+      var inrange = true;
+      var max = -1;
+      for (var i = 0; i < array.length; i++) {
+        if (array[i] > max) {
+          max = Math.abs(array[i] - 128);
+        }
+      }
+      if (max <= currentGain * 128) {
+        assert_true(true, "Analyser got scaled data for " + currentGain);
+        currentGain = tests.shift();
+        if (currentGain == undefined) {
+          done();
+          return;
+        }
+      }
+      requestAnimationFrame(getAnalyserData);
+    }
+
+    var tests = [1.0, 0.5, 0.0];
+    var currentGain = tests.shift();
+    requestAnimationFrame(getAnalyserData);
+  </script>
+</head>
+</body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/test-analysernode.html b/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/test-analysernode.html
new file mode 100644
index 0000000000..e8325388d1
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-analysernode-interface/test-analysernode.html
@@ -0,0 +1,237 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <script src="/resources/testharness.js"></script>
+  <script src="/resources/testharnessreport.js"></script>
+  <script>
+    function testNode() {
+      var context = new AudioContext();
+      var buffer = context.createBuffer(1, 2048, context.sampleRate);
+      for (var i = 0; i < 2048; ++i) {
+        buffer.getChannelData(0)[i] = Math.sin(
+          440 * 2 * Math.PI * i / context.sampleRate
+        );
+      }
+
+      var destination = context.destination;
+
+      var source = context.createBufferSource();
+
+      var analyser = context.createAnalyser();
+
+      source.buffer = buffer;
+
+      source.connect(analyser);
+      analyser.connect(destination);
+
+      assert_equals(
+        analyser.channelCount,
+        2,
+        "analyser node has 2 input channels by default"
+      );
+      assert_equals(
+        analyser.channelCountMode,
+        "max",
+        "Correct channelCountMode for the analyser node"
+      );
+      assert_equals(
+        analyser.channelInterpretation,
+        "speakers",
+        "Correct channelCountInterpretation for the analyser node"
+      );
+
+      assert_equals(
+        analyser.fftSize,
+        2048,
+        "Correct default value for fftSize"
+      );
+      assert_equals(
+        analyser.frequencyBinCount,
+        1024,
+        "Correct default value for frequencyBinCount"
+      );
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser.fftSize = 0;
+      });
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser.fftSize = 1;
+      });
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser.fftSize = 8;
+      });
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser.fftSize = 100;
+      }); // non-power of two
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser.fftSize = 2049;
+      });
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser.fftSize = 4097;
+      });
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser.fftSize = 8193;
+      });
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser.fftSize = 16385;
+      });
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser.fftSize = 32769;
+      });
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser.fftSize = 65536;
+      });
+      analyser.fftSize = 1024;
+      assert_equals(
+        analyser.frequencyBinCount,
+        512,
+        "Correct new value for frequencyBinCount"
+      );
+
+      assert_equals(
+        analyser.minDecibels,
+        -100,
+        "Correct default value for minDecibels"
+      );
+      assert_equals(
+        analyser.maxDecibels,
+        -30,
+        "Correct default value for maxDecibels"
+      );
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser.minDecibels = -30;
+      });
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser.minDecibels = -29;
+      });
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser.maxDecibels = -100;
+      });
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser.maxDecibels = -101;
+      });
+
+      assert_true(
+        Math.abs(analyser.smoothingTimeConstant - 0.8) < 0.001,
+        "Correct default value for smoothingTimeConstant"
+      );
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser.smoothingTimeConstant = -0.1;
+      });
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser.smoothingTimeConstant = 1.1;
+      });
+      analyser.smoothingTimeConstant = 0;
+      analyser.smoothingTimeConstant = 1;
+    }
+
+    function testConstructor() {
+      var context = new AudioContext();
+
+      var analyser = new AnalyserNode(context);
+      assert_equals(
+        analyser.channelCount,
+        2,
+        "analyser node has 2 input channels by default"
+      );
+      assert_equals(
+        analyser.channelCountMode,
+        "max",
+        "Correct channelCountMode for the analyser node"
+      );
+      assert_equals(
+        analyser.channelInterpretation,
+        "speakers",
+        "Correct channelCountInterpretation for the analyser node"
+      );
+
+      assert_equals(
+        analyser.fftSize,
+        2048,
+        "Correct default value for fftSize"
+      );
+      assert_equals(
+        analyser.frequencyBinCount,
+        1024,
+        "Correct default value for frequencyBinCount"
+      );
+      assert_equals(
+        analyser.minDecibels,
+        -100,
+        "Correct default value for minDecibels"
+      );
+      assert_equals(
+        analyser.maxDecibels,
+        -30,
+        "Correct default value for maxDecibels"
+      );
+      assert_true(
+        Math.abs(analyser.smoothingTimeConstant - 0.8) < 0.001,
+        "Correct default value for smoothingTimeConstant"
+      );
+
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser = new AnalyserNode(context, { fftSize: 0 });
+      });
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser = new AnalyserNode(context, { fftSize: 1 });
+      });
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser = new AnalyserNode(context, { fftSize: 8 });
+      });
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser = new AnalyserNode(context, { fftSize: 100 });
+      });
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser = new AnalyserNode(context, { fftSize: 2049 });
+      });
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser = new AnalyserNode(context, { fftSize: 4097 });
+      });
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser = new AnalyserNode(context, { fftSize: 8193 });
+      });
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser = new AnalyserNode(context, { fftSize: 16385 });
+      });
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser = new AnalyserNode(context, { fftSize: 32769 });
+      });
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser = new AnalyserNode(context, { fftSize: 65536 });
+      });
+      analyser = new AnalyserNode(context, { fftSize: 1024 });
+      assert_equals(
+        analyser.frequencyBinCount,
+        512,
+        "Correct new value for frequencyBinCount"
+      );
+
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser = new AnalyserNode(context, { minDecibels: -30 });
+      });
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser = new AnalyserNode(context, { minDecibels: -29 });
+      });
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser = new AnalyserNode(context, { maxDecibels: -100 });
+      });
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser = new AnalyserNode(context, { maxDecibels: -101 });
+      });
+
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser = new AnalyserNode(context, { smoothingTimeConstant: -0.1 });
+      });
+      assert_throws_dom("INDEX_SIZE_ERR", function() {
+        analyser = new AnalyserNode(context, { smoothingTimeConstant: -1.1 });
+      });
+      analyser = new AnalyserNode(context, { smoothingTimeConstant: 0 });
+      analyser = new AnalyserNode(context, { smoothingTimeConstant: 1 });
+    }
+    test(testNode, "Test AnalyserNode API");
+    test(testConstructor, "Test AnalyserNode's ctor API");
+  </script>
+</head>
+</body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/acquire-the-content.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/acquire-the-content.html
new file mode 100644
index 0000000000..659a69c866
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/acquire-the-content.html
@@ -0,0 +1,85 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>Test for AudioBuffer's "acquire the content" operation</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+const SAMPLERATE = 8000;
+const LENGTH = 128;
+
+var tests = {
+  "AudioBufferSourceNode setter set with non-null buffer": function(oac) {
+    var buf = oac.createBuffer(1, LENGTH, SAMPLERATE)
+    var bs = new AudioBufferSourceNode(oac);
+    var channelData = buf.getChannelData(0);
+    for (var i = 0; i < channelData.length; i++) {
+      channelData[i] = 1.0;
+    }
+    bs.buffer = buf;
+    bs.start(); // This acquires the content since buf is not null
+    for (var i = 0; i < channelData.length; i++) {
+      channelData[i] = 0.5;
+    }
+    allSamplesAtOne(buf, "reading back");
+    bs.connect(oac.destination);
+    return oac.startRendering();
+  },
+  "AudioBufferSourceNode buffer setter set with null" : (oac) => {
+    var buf = oac.createBuffer(1, LENGTH, SAMPLERATE)
+    var bs = new AudioBufferSourceNode(oac);
+    var channelData = buf.getChannelData(0);
+    for (var i = 0; i < channelData.length; i++) {
+      channelData[i] = 1.0;
+    }
+    bs.buffer = null;
+    bs.start(); // This does not acquire the content
+    bs.buffer = buf; // This does
+    for (var i = 0; i < channelData.length; i++) {
+      channelData[i] = 0.5;
+    }
+    allSamplesAtOne(buf, "reading back");
+    bs.connect(oac.destination);
+    return oac.startRendering();
+  },
+  "ConvolverNode": (oac) => {
+    var buf = oac.createBuffer(1, LENGTH, SAMPLERATE)
+    var impulse = oac.createBuffer(1, 1, SAMPLERATE)
+    var bs = new AudioBufferSourceNode(oac);
+    var convolver = new ConvolverNode(oac, {disableNormalization: true});
+
+    impulse.getChannelData(0)[0] = 1.0; // unit impulse function
+    convolver.buffer = impulse; // This does acquire the content
+    impulse.getChannelData(0)[0] = 0.5;
+
+    var channelData = buf.getChannelData(0);
+    for (var i = 0; i < channelData.length; i++) {
+      channelData[i] = 1.0;
+    }
+    bs.buffer = buf;
+    bs.start();
+
+    bs.connect(convolver).connect(oac.destination);
+    return oac.startRendering();
+  }
+};
+
+function allSamplesAtOne(audiobuffer, location) {
+  var buf = audiobuffer.getChannelData(0);
+  for (var i = 0; i < buf.length; i++) {
+    // The convolver can introduce a slight numerical error.
+    if (Math.abs(buf[i] - 1.0) > 0.0001) {
+      assert_true(false, `Invalid value at index ${i}, expecte close to 1.0, found ${buf[i]} when ${location}`)
+      return Promise.reject();
+    }
+  }
+  assert_true(true, `Buffer unmodified when ${location}.`);
+  return Promise.resolve();
+}
+
+for (const test of Object.keys(tests)) {
+  promise_test(async function(t) {
+    var buf = await tests[test](new OfflineAudioContext(1, LENGTH, SAMPLERATE));
+    return allSamplesAtOne(buf, "rendering");
+  }, test);
+};
+</script>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/audiobuffer-copy-channel.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/audiobuffer-copy-channel.html
new file mode 100644
index 0000000000..c0cd49d325
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/audiobuffer-copy-channel.html
@@ -0,0 +1,330 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Basic Functionality of AudioBuffer.copyFromChannel and
+      AudioBuffer.copyToChannel
+    </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">
+      // Define utility routines.
+
+      // Initialize the AudioBuffer |buffer| with a ramp signal on each channel.
+      // The ramp starts at channel number + 1.
+      function initializeAudioBufferRamp(buffer) {
+        for (let c = 0; c < buffer.numberOfChannels; ++c) {
+          let d = buffer.getChannelData(c);
+          for (let k = 0; k < d.length; ++k) {
+            d[k] = k + c + 1;
+          }
+        }
+      }
+
+      // Create a Float32Array of length |length| and initialize the array to
+      // -1.
+      function createInitializedF32Array(length) {
+        let x = new Float32Array(length);
+        for (let k = 0; k < length; ++k) {
+          x[k] = -1;
+        }
+        return x;
+      }
+
+      // Create a Float32Array of length |length| that is initialized to be a
+      // ramp starting at 1.
+      function createFloat32RampArray(length) {
+        let x = new Float32Array(length);
+        for (let k = 0; k < x.length; ++k) {
+          x[k] = k + 1;
+        }
+
+        return x;
+      }
+
+      // Test that the array |x| is a ramp starting at value |start| of length
+      // |length|, starting at |startIndex| in the array.  |startIndex| is
+      // optional and defaults to 0. Any other values must be -1.
+      function shouldBeRamp(
+          should, testName, x, startValue, length, startIndex) {
+        let k;
+        let startingIndex = startIndex || 0;
+        let expected = Array(x.length);
+
+        // Fill the expected array with the correct results.
+
+        // The initial part (if any) must be -1.
+        for (k = 0; k < startingIndex; ++k) {
+          expected[k] = -1;
+        }
+
+        // The second part should be a ramp starting with |startValue|
+        for (; k < startingIndex + length; ++k) {
+          expected[k] = startValue + k - startingIndex;
+        }
+
+        // The last part (if any) should be -1.
+        for (; k < x.length; ++k) {
+          expected[k] = -1;
+        }
+
+        should(x, testName, {numberOfArrayLog: 32}).beEqualToArray(expected);
+      }
+
+      let audit = Audit.createTaskRunner();
+
+      let context = new AudioContext();
+      // Temp array for testing exceptions for copyToChannel/copyFromChannel.
+      // The length is arbitrary.
+      let x = new Float32Array(8);
+
+      // Number of frames in the AudioBuffer for testing.  This is pretty
+      // arbitrary so choose a fairly small value.
+      let bufferLength = 16;
+
+      // Number of channels in the AudioBuffer.  Also arbitrary, but it should
+      // be greater than 1 for test coverage.
+      let numberOfChannels = 3;
+
+      // AudioBuffer that will be used for testing copyFrom and copyTo.
+      let buffer = context.createBuffer(
+          numberOfChannels, bufferLength, context.sampleRate);
+
+      let initialValues = Array(numberOfChannels);
+
+      // Initialize things
+      audit.define('initialize', (task, should) => {
+        // Initialize to -1.
+        initialValues.fill(-1);
+        should(initialValues, 'Initialized values').beConstantValueOf(-1)
+        task.done();
+      });
+
+      // Test that expected exceptions are signaled for copyFrom.
+      audit.define('copyFrom-exceptions', (task, should) => {
+        should(
+            AudioBuffer.prototype.copyFromChannel,
+            'AudioBuffer.prototype.copyFromChannel')
+            .exist();
+
+        should(
+            () => {
+              buffer = context.createBuffer(
+                  numberOfChannels, bufferLength, context.sampleRate);
+            },
+            '0: buffer = context.createBuffer(' + numberOfChannels + ', ' +
+                bufferLength + ', context.sampleRate)')
+            .notThrow();
+        should(() => {
+          buffer.copyFromChannel(null, 0);
+        }, '1: buffer.copyFromChannel(null, 0)').throw(TypeError);
+        should(() => {
+          buffer.copyFromChannel(context, 0);
+        }, '2: buffer.copyFromChannel(context, 0)').throw(TypeError);
+        should(() => {
+          buffer.copyFromChannel(x, -1);
+        }, '3: buffer.copyFromChannel(x, -1)').throw(DOMException, 'IndexSizeError');
+        should(
+            () => {
+              buffer.copyFromChannel(x, numberOfChannels);
+            },
+            '4: buffer.copyFromChannel(x, ' + numberOfChannels + ')')
+            .throw(DOMException, 'IndexSizeError');
+        ;
+        should(() => {
+          buffer.copyFromChannel(x, 0, -1);
+        }, '5: buffer.copyFromChannel(x, 0, -1)').notThrow();
+        should(
+            () => {
+              buffer.copyFromChannel(x, 0, bufferLength);
+            },
+            '6: buffer.copyFromChannel(x, 0, ' + bufferLength + ')')
+            .notThrow();
+
+        should(() => {
+          buffer.copyFromChannel(x, 3);
+        }, '7: buffer.copyFromChannel(x, 3)').throw(DOMException, 'IndexSizeError');
+
+        // See https://github.com/whatwg/html/issues/5380 for why not `new SharedArrayBuffer()`
+        // WebAssembly.Memory's size is in multiples of 64 KiB
+        const shared_buffer = new Float32Array(new WebAssembly.Memory({ shared:true, initial:1, maximum:1 }).buffer);
+        should(
+            () => {
+              buffer.copyFromChannel(shared_buffer, 0);
+            },
+            '8: buffer.copyFromChannel(SharedArrayBuffer view, 0)')
+            .throw(TypeError);
+
+        should(
+            () => {
+              buffer.copyFromChannel(shared_buffer, 0, 0);
+            },
+            '9: buffer.copyFromChannel(SharedArrayBuffer view, 0, 0)')
+            .throw(TypeError);
+
+        task.done();
+      });
+
+      // Test that expected exceptions are signaled for copyTo.
+      audit.define('copyTo-exceptions', (task, should) => {
+        should(
+            AudioBuffer.prototype.copyToChannel,
+            'AudioBuffer.prototype.copyToChannel')
+            .exist();
+        should(() => {
+          buffer.copyToChannel(null, 0);
+        }, '0: buffer.copyToChannel(null, 0)').throw(TypeError);
+        should(() => {
+          buffer.copyToChannel(context, 0);
+        }, '1: buffer.copyToChannel(context, 0)').throw(TypeError);
+        should(() => {
+          buffer.copyToChannel(x, -1);
+        }, '2: buffer.copyToChannel(x, -1)').throw(DOMException, 'IndexSizeError');
+        should(
+            () => {
+              buffer.copyToChannel(x, numberOfChannels);
+            },
+            '3: buffer.copyToChannel(x, ' + numberOfChannels + ')')
+            .throw(DOMException, 'IndexSizeError');
+        should(() => {
+          buffer.copyToChannel(x, 0, -1);
+        }, '4: buffer.copyToChannel(x, 0, -1)').notThrow();
+        should(
+            () => {
+              buffer.copyToChannel(x, 0, bufferLength);
+            },
+            '5: buffer.copyToChannel(x, 0, ' + bufferLength + ')')
+            .notThrow();
+
+        should(() => {
+          buffer.copyToChannel(x, 3);
+        }, '6: buffer.copyToChannel(x, 3)').throw(DOMException, 'IndexSizeError');
+
+        // See https://github.com/whatwg/html/issues/5380 for why not `new SharedArrayBuffer()`
+        // WebAssembly.Memory's size is in multiples of 64 KiB
+        const shared_buffer = new Float32Array(new WebAssembly.Memory({ shared:true, initial:1, maximum:1 }).buffer);
+        should(
+            () => {
+              buffer.copyToChannel(shared_buffer, 0);
+            },
+            '7: buffer.copyToChannel(SharedArrayBuffer view, 0)')
+            .throw(TypeError);
+
+        should(
+            () => {
+              buffer.copyToChannel(shared_buffer, 0, 0);
+            },
+            '8: buffer.copyToChannel(SharedArrayBuffer view, 0, 0)')
+            .throw(TypeError);
+
+        task.done();
+      });
+
+      // Test copyFromChannel
+      audit.define('copyFrom-validate', (task, should) => {
+        // Initialize the AudioBuffer to a ramp for testing copyFrom.
+        initializeAudioBufferRamp(buffer);
+
+        // Test copyFrom operation with a short destination array, filling the
+        // destination completely.
+        for (let c = 0; c < numberOfChannels; ++c) {
+          let dst8 = createInitializedF32Array(8);
+          buffer.copyFromChannel(dst8, c);
+          shouldBeRamp(
+              should, 'buffer.copyFromChannel(dst8, ' + c + ')', dst8, c + 1, 8)
+        }
+
+        // Test copyFrom operation with a short destination array using a
+        // non-zero start index that still fills the destination completely.
+        for (let c = 0; c < numberOfChannels; ++c) {
+          let dst8 = createInitializedF32Array(8);
+          buffer.copyFromChannel(dst8, c, 1);
+          shouldBeRamp(
+              should, 'buffer.copyFromChannel(dst8, ' + c + ', 1)', dst8, c + 2,
+              8)
+        }
+
+        // Test copyFrom operation with a short destination array using a
+        // non-zero start index that does not fill the destinatiom completely.
+        // The extra elements should be unchanged.
+        for (let c = 0; c < numberOfChannels; ++c) {
+          let dst8 = createInitializedF32Array(8);
+          let startInChannel = bufferLength - 5;
+          buffer.copyFromChannel(dst8, c, startInChannel);
+          shouldBeRamp(
+              should,
+              'buffer.copyFromChannel(dst8, ' + c + ', ' + startInChannel + ')',
+              dst8, c + 1 + startInChannel, bufferLength - startInChannel);
+        }
+
+        // Copy operation with the destination longer than the buffer, leaving
+        // the trailing elements of the destination untouched.
+        for (let c = 0; c < numberOfChannels; ++c) {
+          let dst26 = createInitializedF32Array(bufferLength + 10);
+          buffer.copyFromChannel(dst26, c);
+          shouldBeRamp(
+              should, 'buffer.copyFromChannel(dst26, ' + c + ')', dst26, c + 1,
+              bufferLength);
+        }
+
+        task.done();
+      });
+
+      // Test copyTo
+      audit.define('copyTo-validate', (task, should) => {
+        // Create a source consisting of a ramp starting at 1, longer than the
+        // AudioBuffer
+        let src = createFloat32RampArray(bufferLength + 10);
+
+        // Test copyTo with AudioBuffer shorter than Float32Array. The
+        // AudioBuffer should be completely filled with the Float32Array.
+        should(
+            () => {
+              buffer =
+                  createConstantBuffer(context, bufferLength, initialValues);
+            },
+            'buffer = createConstantBuffer(context, ' + bufferLength + ', [' +
+                initialValues + '])')
+            .notThrow();
+
+        for (let c = 0; c < numberOfChannels; ++c) {
+          buffer.copyToChannel(src, c);
+          shouldBeRamp(
+              should, 'buffer.copyToChannel(src, ' + c + ')',
+              buffer.getChannelData(c), 1, bufferLength);
+        }
+
+        // Test copyTo with AudioBuffer longer than the Float32Array.  The tail
+        // of the AudioBuffer should be unchanged.
+        buffer = createConstantBuffer(context, bufferLength, initialValues);
+        let src10 = createFloat32RampArray(10);
+        for (let c = 0; c < numberOfChannels; ++c) {
+          buffer.copyToChannel(src10, c);
+          shouldBeRamp(
+              should, 'buffer.copyToChannel(src10, ' + c + ')',
+              buffer.getChannelData(c), 1, 10);
+        }
+
+        // Test copyTo with non-default startInChannel.  Part of the AudioBuffer
+        // should filled with the beginning and end sections untouched.
+        buffer = createConstantBuffer(context, bufferLength, initialValues);
+        for (let c = 0; c < numberOfChannels; ++c) {
+          let startInChannel = 5;
+          buffer.copyToChannel(src10, c, startInChannel);
+
+          shouldBeRamp(
+              should,
+              'buffer.copyToChannel(src10, ' + c + ', ' + startInChannel + ')',
+              buffer.getChannelData(c), 1, src10.length, startInChannel);
+        }
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/audiobuffer-getChannelData.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/audiobuffer-getChannelData.html
new file mode 100644
index 0000000000..612a91cf4e
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/audiobuffer-getChannelData.html
@@ -0,0 +1,66 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test AudioBuffer.getChannelData() Returns the Same Object
+    </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/audioparam-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let sampleRate = 48000;
+      let renderDuration = 0.5;
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define('buffer-eq', (task, should) => {
+        // Verify that successive calls to getChannelData return the same
+        // buffer.
+        let context = new AudioContext();
+        let channelCount = 2;
+        let frameLength = 1000;
+        let buffer =
+            context.createBuffer(channelCount, frameLength, context.sampleRate);
+
+        for (let c = 0; c < channelCount; ++c) {
+          let a = buffer.getChannelData(c);
+          let b = buffer.getChannelData(c);
+
+          let message = 'buffer.getChannelData(' + c + ')';
+          should(a === b, message + ' === ' + message).beEqualTo(true);
+        }
+
+        task.done();
+      });
+
+      audit.define('buffer-not-eq', (task, should) => {
+        let context = new AudioContext();
+        let channelCount = 2;
+        let frameLength = 1000;
+        let buffer1 =
+            context.createBuffer(channelCount, frameLength, context.sampleRate);
+        let buffer2 =
+            context.createBuffer(channelCount, frameLength, context.sampleRate);
+        let success = true;
+
+        for (let c = 0; c < channelCount; ++c) {
+          let a = buffer1.getChannelData(c);
+          let b = buffer2.getChannelData(c);
+
+          let message = 'getChannelData(' + c + ')';
+          should(a === b, 'buffer1.' + message + ' === buffer2.' + message)
+                  .beEqualTo(false) &&
+              success;
+        }
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/audiobuffer-reuse.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/audiobuffer-reuse.html
new file mode 100644
index 0000000000..dabe323cbe
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/audiobuffer-reuse.html
@@ -0,0 +1,36 @@
+<!doctype html>
+<meta charset="utf-8">
+<title>AudioBuffer can be reused between AudioBufferSourceNodes</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+function render_audio_context() {
+  let sampleRate = 44100;
+  let context = new OfflineAudioContext(
+      2, sampleRate *  0.1, sampleRate);
+  let buf = context.createBuffer(1, 0.1 * sampleRate, context.sampleRate);
+  let data = buf.getChannelData(0);
+  data[0] = 0.5;
+  data[1] = 0.25;
+  let b1 = context.createBufferSource();
+  b1.buffer = buf;
+  b1.start();
+  let b2 = context.createBufferSource();
+  b2.buffer = buf;
+  b2.start();
+  let merger = context.createChannelMerger(2);
+  b1.connect(merger, 0, 0);
+  b2.connect(merger, 0, 1);
+  merger.connect(context.destination);
+  return context.startRendering();
+}
+promise_test(function() {
+  return render_audio_context()
+    .then(function(buffer) {
+      assert_equals(buffer.getChannelData(0)[0], 0.5);
+      assert_equals(buffer.getChannelData(1)[0], 0.5);
+      assert_equals(buffer.getChannelData(0)[1], 0.25);
+      assert_equals(buffer.getChannelData(1)[1], 0.25);
+    });
+}, "AudioBuffer can be reused between AudioBufferSourceNodes");
+</script>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/audiobuffer.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/audiobuffer.html
new file mode 100644
index 0000000000..a2c4581c4e
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/audiobuffer.html
@@ -0,0 +1,71 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      audiobuffer.html
+    </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 sampleRate = 44100.0
+      let lengthInSeconds = 2;
+      let numberOfChannels = 4;
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define('Basic tests for AudioBuffer', function(task, should) {
+        let context = new AudioContext();
+        let buffer = context.createBuffer(
+            numberOfChannels, sampleRate * lengthInSeconds, sampleRate);
+
+        // Just for printing out a message describing what "buffer" is in the
+        // following tests.
+        should(
+            true,
+            'buffer = context.createBuffer(' + numberOfChannels + ', ' +
+                (sampleRate * lengthInSeconds) + ', ' + sampleRate + ')')
+            .beTrue();
+
+        should(buffer.sampleRate, 'buffer.sampleRate').beEqualTo(sampleRate);
+
+        should(buffer.length, 'buffer.length')
+            .beEqualTo(sampleRate * lengthInSeconds);
+
+        should(buffer.duration, 'buffer.duration').beEqualTo(lengthInSeconds);
+
+        should(buffer.numberOfChannels, 'buffer.numberOfChannels')
+            .beEqualTo(numberOfChannels);
+
+        for (let index = 0; index < buffer.numberOfChannels; ++index) {
+          should(
+              buffer.getChannelData(index) instanceof window.Float32Array,
+              'buffer.getChannelData(' + index +
+                  ') instanceof window.Float32Array')
+              .beTrue();
+        }
+
+        should(
+            function() {
+              buffer.getChannelData(buffer.numberOfChannels);
+            },
+            'buffer.getChannelData(' + buffer.numberOfChannels + ')')
+            .throw(DOMException, 'IndexSizeError');
+
+        let buffer2 = context.createBuffer(1, 1000, 24576);
+        let expectedDuration = 1000 / 24576;
+
+        should(
+            buffer2.duration, 'context.createBuffer(1, 1000, 24576).duration')
+            .beEqualTo(expectedDuration);
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/crashtests/copyFromChannel-bufferOffset-1.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/crashtests/copyFromChannel-bufferOffset-1.html
new file mode 100644
index 0000000000..564317f7de
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/crashtests/copyFromChannel-bufferOffset-1.html
@@ -0,0 +1,11 @@
+<html>
+<head>
+  <title>Test large bufferOffset in copyFromChannel()</title>
+</head>
+<script>
+  const a = new AudioBuffer({length: 0x51986, sampleRate: 44100});
+  const b = new Float32Array(0x10);
+  a.getChannelData(0); // to avoid zero data optimization
+  a.copyFromChannel(b, 0, 0x1523c7cc)
+</script>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/crashtests/copyToChannel-bufferOffset-1.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/crashtests/copyToChannel-bufferOffset-1.html
new file mode 100644
index 0000000000..999925a983
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/crashtests/copyToChannel-bufferOffset-1.html
@@ -0,0 +1,10 @@
+<html>
+<head>
+  <title>Test large bufferOffset in copyToChannel()</title>
+</head>
+<script>
+  const a = new AudioBuffer({length: 0x10, sampleRate: 44100});
+  const b = new Float32Array(0x51986);
+  a.copyToChannel(b, 0, 0x40004000)
+</script>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/ctor-audiobuffer.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/ctor-audiobuffer.html
new file mode 100644
index 0000000000..fbe6e42e31
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffer-interface/ctor-audiobuffer.html
@@ -0,0 +1,236 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Constructor: AudioBuffer
+    </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) => {
+        should(() => {
+          new AudioBuffer();
+        }, 'new AudioBuffer()').throw(TypeError);
+        should(() => {
+          new AudioBuffer(1);
+        }, 'new AudioBuffer(1)').throw(TypeError);
+        should(() => {
+          new AudioBuffer(Date, 42);
+        }, 'new AudioBuffer(Date, 42)').throw(TypeError);
+
+        task.done();
+      });
+
+      audit.define('required options', (task, should) => {
+        let buffer;
+
+        // The length and sampleRate attributes are required; all others are
+        // optional.
+        should(() => {
+          new AudioBuffer({});
+        }, 'buffer = new AudioBuffer({})').throw(TypeError);
+
+        should(() => {
+          new AudioBuffer({length: 1});
+        }, 'buffer = new AudioBuffer({length: 1})').throw(TypeError);
+
+        should(() => {
+          new AudioBuffer({sampleRate: 48000});
+        }, 'buffer = new AudioBuffer({sampleRate: 48000})').throw(TypeError);
+
+        should(() => {
+          buffer = new AudioBuffer({numberOfChannels: 1});
+        }, 'buffer = new AudioBuffer({numberOfChannels: 1}').throw(TypeError);
+
+        // Length and sampleRate are required, but others are optional.
+        should(
+            () => {
+              buffer =
+                  new AudioBuffer({length: 21, sampleRate: context.sampleRate});
+            },
+            'buffer0 = new AudioBuffer({length: 21, sampleRate: ' +
+                context.sampleRate + '}')
+            .notThrow();
+        // Verify the buffer has the correct values.
+        should(buffer.numberOfChannels, 'buffer0.numberOfChannels')
+            .beEqualTo(1);
+        should(buffer.length, 'buffer0.length').beEqualTo(21);
+        should(buffer.sampleRate, 'buffer0.sampleRate')
+            .beEqualTo(context.sampleRate);
+
+        should(
+            () => {
+              buffer = new AudioBuffer(
+                  {numberOfChannels: 3, length: 1, sampleRate: 48000});
+            },
+            'buffer1 = new AudioBuffer(' +
+                '{numberOfChannels: 3, length: 1, sampleRate: 48000})')
+            .notThrow();
+        // Verify the buffer has the correct values.
+        should(buffer.numberOfChannels, 'buffer1.numberOfChannels')
+            .beEqualTo(3);
+        should(buffer.length, 'buffer1.length').beEqualTo(1);
+        should(buffer.sampleRate, 'buffer1.sampleRate').beEqualTo(48000);
+
+        task.done();
+      });
+
+      audit.define('invalid option values', (task, should) => {
+        let options = {numberOfChannels: 0, length: 1, sampleRate: 16000};
+        should(
+            () => {
+              let buffer = new AudioBuffer(options);
+            },
+            'new AudioBuffer(' + JSON.stringify(options) + ')')
+            .throw(DOMException, 'NotSupportedError');
+
+        options = {numberOfChannels: 99, length: 0, sampleRate: 16000};
+        should(
+            () => {
+              let buffer = new AudioBuffer(options);
+            },
+            'new AudioBuffer(' + JSON.stringify(options) + ')')
+            .throw(DOMException, 'NotSupportedError');
+
+        options = {numberOfChannels: 1, length: 0, sampleRate: 16000};
+        should(
+            () => {
+              let buffer = new AudioBuffer(options);
+            },
+            'new AudioBuffer(' + JSON.stringify(options) + ')')
+            .throw(DOMException, 'NotSupportedError');
+
+        options = {numberOfChannels: 1, length: 1, sampleRate: 100};
+        should(
+            () => {
+              let buffer = new AudioBuffer(options);
+            },
+            'new AudioBuffer(' + JSON.stringify(options) + ')')
+            .throw(DOMException, 'NotSupportedError');
+
+        task.done();
+      });
+
+      audit.define('default constructor', (task, should) => {
+        let buffer;
+
+        let options = {numberOfChannels: 5, length: 17, sampleRate: 16000};
+        should(
+            () => {
+              buffer = new AudioBuffer(options);
+            },
+            'buffer = new AudioBuffer(' + JSON.stringify(options) + ')')
+            .notThrow();
+
+        should(buffer.numberOfChannels, 'buffer.numberOfChannels')
+            .beEqualTo(options.numberOfChannels);
+        should(buffer.length, 'buffer.length').beEqualTo(options.length);
+        should(buffer.sampleRate, 'buffer.sampleRate').beEqualTo(16000);
+
+        task.done();
+      });
+
+      audit.define('valid constructor', (task, should) => {
+        let buffer;
+
+        let options = {numberOfChannels: 3, length: 42, sampleRate: 54321};
+
+        let message = 'new AudioBuffer(' + JSON.stringify(options) + ')';
+        should(() => {
+          buffer = new AudioBuffer(options);
+        }, message).notThrow();
+
+        should(buffer.numberOfChannels, 'buffer.numberOfChannels')
+            .beEqualTo(options.numberOfChannels);
+
+        should(buffer.length, 'buffer.length').beEqualTo(options.length);
+
+        should(buffer.sampleRate, 'buffer.sampleRate')
+            .beEqualTo(options.sampleRate);
+
+        // Verify that we actually got the right number of channels
+        for (let k = 0; k < options.numberOfChannels; ++k) {
+          let data;
+          let message = 'buffer.getChannelData(' + k + ')';
+          should(() => {
+            data = buffer.getChannelData(k);
+          }, message).notThrow();
+
+          should(data.length, message + ' length').beEqualTo(options.length);
+        }
+
+        should(
+            () => {
+              buffer.getChannelData(options.numberOfChannels);
+            },
+            'buffer.getChannelData(' + options.numberOfChannels + ')')
+            .throw(DOMException, 'IndexSizeError');
+
+        task.done();
+      });
+
+      audit.define('multiple contexts', (task, should) => {
+        // Test that an AudioBuffer can be used for different contexts.
+        let buffer =
+            new AudioBuffer({length: 128, sampleRate: context.sampleRate});
+
+        // Don't use getChannelData here because we want to be able to use
+        // |data| to compare the final results of playing out this buffer.  (If
+        // we did, |data| gets detached when the sources play.)
+        let data = new Float32Array(buffer.length);
+        for (let k = 0; k < data.length; ++k)
+          data[k] = 1 + k;
+        buffer.copyToChannel(data, 0);
+
+        let c1 = new OfflineAudioContext(1, 128, context.sampleRate);
+        let c2 = new OfflineAudioContext(1, 128, context.sampleRate);
+
+        let s1 = new AudioBufferSourceNode(c1, {buffer: buffer});
+        let s2 = new AudioBufferSourceNode(c2, {buffer: buffer});
+
+        s1.connect(c1.destination);
+        s2.connect(c2.destination);
+
+        s1.start();
+        s2.start();
+
+        Promise
+            .all([
+              c1.startRendering().then(function(resultBuffer) {
+                return resultBuffer;
+              }),
+              c2.startRendering().then(function(resultBuffer) {
+                return resultBuffer;
+              }),
+            ])
+            .then(resultBuffers => {
+              let c1ResultValue = should(resultBuffers[0].getChannelData(0), 'c1 result')
+                  .beEqualToArray(data);
+              let c2ResultValue = should(resultBuffers[1].getChannelData(0), 'c2 result')
+                  .beEqualToArray(data);
+              should(
+                  c1ResultValue && c2ResultValue,
+                  'AudioBuffer shared between two different contexts')
+                  .message('correctly', 'incorrectly');
+              task.done();
+            });
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/active-processing.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/active-processing.https.html
new file mode 100644
index 0000000000..7b8c1295c6
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/active-processing.https.html
@@ -0,0 +1,100 @@
+<!doctype html>
+<html>
+  <head>
+    <title>
+      Test Active Processing for AudioBufferSourceNode
+    </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 audit = Audit.createTaskRunner();
+
+      // Arbitrary sample rate. And we only new a few blocks for rendering to
+      // see if things are working.
+      let sampleRate = 8000;
+      let renderLength = 10 * RENDER_QUANTUM_FRAMES;
+
+      // Offline context used for the tests.
+      let context;
+
+      // Number of channels for the AudioBufferSource. Fairly arbitrary, but
+      // should be more than 2.
+      let numberOfChannels = 7;
+
+      // Number of frames in the AudioBuffer.  Fairly arbitrary, but should
+      // probablybe more than one render quantum and significantly less than
+      // |renderLength|.
+      let bufferFrames = 131;
+
+      let filePath =
+          '../the-audioworklet-interface/processors/input-count-processor.js';
+
+      audit.define('Setup graph', (task, should) => {
+        context =
+            new OfflineAudioContext(numberOfChannels, renderLength, sampleRate);
+
+        should(
+            context.audioWorklet.addModule(filePath).then(() => {
+              let buffer = new AudioBuffer({
+                numberOfChannels: numberOfChannels,
+                length: bufferFrames,
+                sampleRate: context.sampleRate
+              });
+
+              src = new AudioBufferSourceNode(context, {buffer: buffer});
+              let counter = new AudioWorkletNode(context, 'counter');
+
+              src.connect(counter).connect(context.destination);
+              src.start();
+            }),
+            'AudioWorklet and graph construction')
+            .beResolved()
+            .then(() => task.done());
+      });
+
+      audit.define('verify count change', (task, should) => {
+        context.startRendering()
+            .then(renderedBuffer => {
+              let output = renderedBuffer.getChannelData(0);
+
+              // Find the first time the number of channels changes to 0.
+              let countChangeIndex = output.findIndex(x => x == 0);
+
+              // Verify that the count did change.  If it didn't there's a bug
+              // in the implementation, or it takes longer than the render
+              // length to change.  For the latter case, increase the render
+              // length, but it can't be arbitrarily large.  The change needs to
+              // happen at some reasonable time after the source stops.
+              should(countChangeIndex >= 0, 'Number of channels changed')
+                  .beTrue();
+              should(
+                  countChangeIndex, 'Index where input channel count changed')
+                  .beLessThanOrEqualTo(renderLength);
+
+              // Verify the number of channels at the beginning matches the
+              // number of channels in the AudioBuffer.
+              should(
+                  output.slice(0, countChangeIndex),
+                  `Number of channels in input[0:${countChangeIndex - 1}]`)
+                  .beConstantValueOf(numberOfChannels);
+
+              // Verify that after the source has stopped, the number of
+              // channels is 0.
+              should(
+                  output.slice(countChangeIndex),
+                  `Number of channels in input[${countChangeIndex}:]`)
+                  .beConstantValueOf(0);
+            })
+            .then(() => task.done());
+      });
+
+      audit.run();
+    </script>
+
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-basic.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-basic.html
new file mode 100644
index 0000000000..6ce7eb0c10
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-basic.html
@@ -0,0 +1,37 @@
+<!doctype html>
+<html>
+  <head>
+    <title>
+      Basic Test of AudioBufferSourceNode
+    </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/start-stop-exceptions.js"></script>
+  </head>
+    <script id="layout-test-code">
+      let sampleRate = 44100;
+      let renderLengthSeconds = 0.25;
+
+      let oscTypes = ['sine', 'square', 'sawtooth', 'triangle', 'custom'];
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define('start/stop exceptions', (task, should) => {
+        // We're not going to render anything, so make it simple
+        let context = new OfflineAudioContext(1, 1, sampleRate);
+        let node = new AudioBufferSourceNode(context);
+
+        testStartStop(should, node, [
+          {args: [0, -1], errorType: RangeError},
+          {args: [0, 0, -1], errorType: RangeError}
+        ]);
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  <body>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-channels.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-channels.html
new file mode 100644
index 0000000000..f3f16c4c64
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-channels.html
@@ -0,0 +1,97 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      audiobuffersource-channels.html
+    </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 audit = Audit.createTaskRunner();
+      let context;
+      let source;
+
+      audit.define(
+          {
+            label: 'validate .buffer',
+            description:
+                'Validatation of AudioBuffer in .buffer attribute setter'
+          },
+          function(task, should) {
+            context = new AudioContext();
+            source = context.createBufferSource();
+
+            // Make sure we can't set to something which isn't an AudioBuffer.
+            should(function() {
+              source.buffer = 57;
+            }, 'source.buffer = 57').throw(TypeError);
+
+            // It's ok to set the buffer to null.
+            should(function() {
+              source.buffer = null;
+            }, 'source.buffer = null').notThrow();
+
+            // Set the buffer to a valid AudioBuffer
+            let buffer =
+                new AudioBuffer({length: 128, sampleRate: context.sampleRate});
+
+            should(function() {
+              source.buffer = buffer;
+            }, 'source.buffer = buffer').notThrow();
+
+            // The buffer has been set; we can't set it again.
+            should(function() {
+              source.buffer =
+                  new AudioBuffer({length: 128, sampleRate: context.sampleRate})
+            }, 'source.buffer = new buffer').throw(DOMException, 'InvalidStateError');
+
+            // The buffer has been set; it's ok to set it to null.
+            should(function() {
+              source.buffer = null;
+            }, 'source.buffer = null again').notThrow();
+
+            // The buffer was already set (and set to null).  Can't set it
+            // again.
+            should(function() {
+              source.buffer = buffer;
+            }, 'source.buffer = buffer again').throw(DOMException, 'InvalidStateError');
+
+            // But setting to null is ok.
+            should(function() {
+            }, 'source.buffer = null after setting to null').notThrow();
+
+            // Check that mono buffer can be set.
+            should(function() {
+              let monoBuffer =
+                  context.createBuffer(1, 1024, context.sampleRate);
+              let testSource = context.createBufferSource();
+              testSource.buffer = monoBuffer;
+            }, 'Setting source with mono buffer').notThrow();
+
+            // Check that stereo buffer can be set.
+            should(function() {
+              let stereoBuffer =
+                  context.createBuffer(2, 1024, context.sampleRate);
+              let testSource = context.createBufferSource();
+              testSource.buffer = stereoBuffer;
+            }, 'Setting source with stereo buffer').notThrow();
+
+            // Check buffers with more than two channels.
+            for (let i = 3; i < 10; ++i) {
+              should(function() {
+                let buffer = context.createBuffer(i, 1024, context.sampleRate);
+                let testSource = context.createBufferSource();
+                testSource.buffer = buffer;
+              }, 'Setting source with ' + i + ' channels buffer').notThrow();
+            }
+            task.done();
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-duration-loop.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-duration-loop.html
new file mode 100644
index 0000000000..abb8983cc0
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-duration-loop.html
@@ -0,0 +1,52 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test AudioBufferSourceNode With Looping And Duration
+    </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 audit = Audit.createTaskRunner();
+      audit.define('loop with duration', (task, should) => {
+        // Create the context
+        let context = new OfflineAudioContext(1, 4096, 48000);
+
+        // Create the sample buffer and fill the second half with 1
+        let buffer = context.createBuffer(1, 2048, context.sampleRate);
+        for (let i = 1024; i < 2048; i++) {
+          buffer.getChannelData(0)[i] = 1;
+        }
+
+        // Create the source and set its value
+        let source = context.createBufferSource();
+        source.loop = true;
+        source.loopStart = 1024 / context.sampleRate;
+        source.loopEnd = 2048 / context.sampleRate;
+        source.buffer = buffer;
+        source.connect(context.destination);
+        source.start(0, 1024 / context.sampleRate, 2048 / context.sampleRate);
+        // Expectations
+        let expected = new Float32Array(4096);
+        for (let i = 0; i < 2048; i++) {
+          expected[i] = 1;
+        }
+        // Render it!
+        context.startRendering()
+            .then(function(audioBuffer) {
+              should(
+                  audioBuffer.getChannelData(0), 'audioBuffer.getChannelData')
+                  .beEqualToArray(expected);
+            })
+            .then(task.done());
+      });
+
+      audit.run();
+
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-ended.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-ended.html
new file mode 100644
index 0000000000..b9922f61ef
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-ended.html
@@ -0,0 +1,40 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      audiobuffersource-ended.html
+    </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/audiobuffersource-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      let context;
+      let source;
+
+      audit.define(
+          'AudioBufferSourceNode calls its onended EventListener',
+          function(task, should) {
+            let sampleRate = 44100.0;
+            let numberOfFrames = 32;
+            context = new OfflineAudioContext(1, numberOfFrames, sampleRate);
+            source = context.createBufferSource();
+            source.buffer = createTestBuffer(context, numberOfFrames);
+            source.connect(context.destination);
+            source.onended = function() {
+              should(true, 'source.onended called').beTrue();
+              task.done();
+            };
+            source.start(0);
+            context.startRendering();
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-grain.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-grain.html
new file mode 100644
index 0000000000..f554304a21
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-grain.html
@@ -0,0 +1,71 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Start Grain with Delayed Buffer Setting
+    </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 audit = Audit.createTaskRunner();
+      let context;
+      let source;
+      let buffer;
+      let renderedData;
+
+      let sampleRate = 44100;
+
+      let testDurationSec = 1;
+      let testDurationSamples = testDurationSec * sampleRate;
+      let startTime = 0.9 * testDurationSec;
+
+      audit.define(
+          'Test setting the source buffer after starting the grain',
+          function(task, should) {
+            context =
+                new OfflineAudioContext(1, testDurationSamples, sampleRate);
+
+            buffer = createConstantBuffer(context, testDurationSamples, 1);
+            source = context.createBufferSource();
+            source.connect(context.destination);
+
+            // Start the source BEFORE we set the buffer. The grain offset and
+            // duration aren't important, as long as we specify some offset.
+            source.start(startTime, .1);
+            source.buffer = buffer;
+
+            // Render it!
+            context.startRendering()
+                .then(function(buffer) {
+                  checkResult(buffer, should);
+                })
+                .then(task.done.bind(task));
+            ;
+          });
+
+      function checkResult(buffer, should) {
+        let success = false;
+
+        renderedData = buffer.getChannelData(0);
+
+        // Check that the rendered data is not all zeroes.  Any non-zero data
+        // means the test passed.
+        let startFrame = Math.round(startTime * sampleRate);
+        for (k = 0; k < renderedData.length; ++k) {
+          if (renderedData[k]) {
+            success = true;
+            break;
+          }
+        }
+
+        should(success, 'Buffer was played').beTrue();
+      }
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-multi-channels.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-multi-channels.html
new file mode 100644
index 0000000000..4e0de21e96
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-multi-channels.html
@@ -0,0 +1,78 @@
+<!DOCTYPE html>
+<!--
+Test AudioBufferSourceNode supports 5.1 channel.
+-->
+<html>
+  <head>
+    <title>
+      audiobuffersource-multi-channels.html
+    </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/mix-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+      let context;
+      let expectedAudio;
+
+      audit.define('initialize', (task, should) => {
+        // Create offline audio context
+        let sampleRate = 44100.0;
+        should(() => {
+          context = new OfflineAudioContext(
+              6, sampleRate * toneLengthSeconds, sampleRate);
+        }, 'Creating context for testing').notThrow();
+        should(
+          Audit
+            .loadFileFromUrl('resources/audiobuffersource-multi-channels-expected.wav')
+            .then(arrayBuffer => {
+              context.decodeAudioData(arrayBuffer).then(audioBuffer => {
+                expectedAudio = audioBuffer;
+                task.done();
+              }).catch(error => {
+                assert_unreached("Could not decode audio data due to " + error.message);
+              })
+            })
+          , 'Fetching expected audio').beResolved();
+      });
+
+      audit.define(
+          {label: 'test', description: 'AudioBufferSource with 5.1 buffer'},
+          (task, should) => {
+            let toneBuffer =
+                createToneBuffer(context, 440, toneLengthSeconds, 6);
+
+            let source = context.createBufferSource();
+            source.buffer = toneBuffer;
+
+            source.connect(context.destination);
+            source.start(0);
+
+            context.startRendering()
+                .then(renderedAudio => {
+                  // Compute a threshold based on the maximum error, |maxUlp|,
+                  // in ULP. This is experimentally determined. Assuming that
+                  // the reference file is a 16-bit wav file, the max values in
+                  // the wave file are +/- 32768.
+                  let maxUlp = 1;
+                  let threshold = maxUlp / 32768;
+                  for (let k = 0; k < renderedAudio.numberOfChannels; ++k) {
+                    should(
+                        renderedAudio.getChannelData(k),
+                        'Rendered audio for channel ' + k)
+                        .beCloseToArray(
+                            expectedAudio.getChannelData(k),
+                            {absoluteThreshold: threshold});
+                  }
+                })
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-null.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-null.html
new file mode 100644
index 0000000000..b5b1ec0c3d
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-null.html
@@ -0,0 +1,59 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test ABSN Outputs Silence if buffer is null
+    </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>
+      const audit = Audit.createTaskRunner();
+
+      audit.define('ABSN with null buffer', (task, should) => {
+        // Create test context.  Length and sampleRate are pretty arbitrary, but
+        // we don't need either to be very large.
+        const context = new OfflineAudioContext(
+            {numberOfChannels: 1, length: 1024, sampleRate: 8192});
+
+        // Just create a constant buffer for testing.  Anything will do as long
+        // as the buffer contents are not identically zero.
+        const audioBuffer =
+            new AudioBuffer({length: 10, sampleRate: context.sampleRate});
+        const audioBufferSourceNode = new AudioBufferSourceNode(context);
+
+        audioBuffer.getChannelData(0).fill(1);
+
+        // These two tests are mostly for the informational messages to show
+        // what's happening.  They should never fail!
+        should(() => {
+          audioBufferSourceNode.buffer = audioBuffer;
+        }, 'Setting ABSN.buffer to AudioBuffer').notThrow();
+
+        // This is the important part.  Setting the buffer to null after setting
+        // it to something else should cause the source to produce silence.
+        should(() => {
+          audioBufferSourceNode.buffer = null;
+        }, 'Setting ABSN.buffer = null').notThrow();
+
+        audioBufferSourceNode.start(0);
+        audioBufferSourceNode.connect(context.destination);
+
+        context.startRendering()
+            .then(buffer => {
+              // Since the buffer is null, the output of the source should be
+              // silence.
+              should(buffer.getChannelData(0), 'ABSN output')
+                  .beConstantValueOf(0);
+            })
+            .then(() => task.done());
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-one-sample-loop.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-one-sample-loop.html
new file mode 100644
index 0000000000..af1454a5a9
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-one-sample-loop.html
@@ -0,0 +1,47 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test AudioBufferSourceNode With Looping a Single-Sample Buffer
+    </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 audit = Audit.createTaskRunner();
+
+      let sampleRate = 44100;
+      let testDurationSamples = 1000;
+
+      audit.define('one-sample-loop', function(task, should) {
+        // Create the offline context for the test.
+        let context =
+            new OfflineAudioContext(1, testDurationSamples, sampleRate);
+
+        // Create the single sample buffer
+        let buffer = createConstantBuffer(context, 1, 1);
+
+        // Create the source and connect it to the destination
+        let source = context.createBufferSource();
+        source.buffer = buffer;
+        source.loop = true;
+        source.connect(context.destination);
+        source.start();
+
+        // Render it!
+        context.startRendering()
+            .then(function(audioBuffer) {
+              should(audioBuffer.getChannelData(0), 'Rendered data')
+                  .beConstantValueOf(1);
+            })
+            .then(task.done.bind(task));
+        ;
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-playbackrate-zero.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-playbackrate-zero.html
new file mode 100644
index 0000000000..5624054e32
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-playbackrate-zero.html
@@ -0,0 +1,116 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      audiobuffersource-playbackrate-zero.html
+    </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">
+      // Sample rate should be power of 128 to observe the change of AudioParam
+      // at the beginning of rendering quantum. (playbackRate is k-rate) This is
+      // the minimum sample rate in the valid sample rate range.
+      let sampleRate = 8192;
+
+      // The render duration in seconds, and the length in samples.
+      let renderDuration = 1.0;
+      let renderLength = renderDuration * sampleRate;
+
+      let context = new OfflineAudioContext(1, renderLength, sampleRate);
+      let audit = Audit.createTaskRunner();
+
+
+      // Task: Render the actual buffer and compare with the reference.
+      audit.define('synthesize-verify', (task, should) => {
+        let ramp = context.createBufferSource();
+        let rampBuffer = createLinearRampBuffer(context, renderLength);
+        ramp.buffer = rampBuffer;
+
+        ramp.connect(context.destination);
+        ramp.start();
+
+        // Leave the playbackRate as 1 for the first half, then change it
+        // to zero at the exact half. The zero playback rate should hold the
+        // sample value of the buffer index at the moment. (sample-and-hold)
+        ramp.playbackRate.setValueAtTime(1.0, 0.0);
+        ramp.playbackRate.setValueAtTime(0.0, renderDuration / 2);
+
+        context.startRendering()
+            .then(function(renderedBuffer) {
+              let data = renderedBuffer.getChannelData(0);
+              let rampData = rampBuffer.getChannelData(0);
+              let half = rampData.length / 2;
+              let passed = true;
+              let i;
+
+              for (i = 1; i < rampData.length; i++) {
+                if (i < half) {
+                  // Before the half position, the actual should match with the
+                  // original ramp data.
+                  if (data[i] !== rampData[i]) {
+                    passed = false;
+                    break;
+                  }
+                } else {
+                  // From the half position, the actual value should not change.
+                  if (data[i] !== rampData[half]) {
+                    passed = false;
+                    break;
+                  }
+                }
+              }
+
+              should(passed, 'The zero playbackRate')
+                  .message(
+                      'held the sample value correctly',
+                      'should hold the sample value. ' +
+                          'Expected ' + rampData[half] + ' but got ' + data[i] +
+                          ' at the index ' + i);
+            })
+            .then(() => task.done());
+      });
+
+      audit.define('subsample start with playback rate 0', (task, should) => {
+        let context = new OfflineAudioContext(1, renderLength, sampleRate);
+        let rampBuffer = new AudioBuffer(
+            {length: renderLength, sampleRate: context.sampleRate});
+        let data = new Float32Array(renderLength);
+        let startValue = 5;
+        for (let k = 0; k < data.length; ++k) {
+          data[k] = k + startValue;
+        }
+        rampBuffer.copyToChannel(data, 0);
+
+        let src = new AudioBufferSourceNode(
+            context, {buffer: rampBuffer, playbackRate: 0});
+
+        src.connect(context.destination);
+
+        // Purposely start the source between frame boundaries
+        let startFrame = 27.3;
+        src.start(startFrame / context.sampleRate);
+
+        context.startRendering()
+            .then(audioBuffer => {
+              let actualStartFrame = Math.ceil(startFrame);
+              let audio = audioBuffer.getChannelData(0);
+
+              should(
+                  audio.slice(0, actualStartFrame),
+                  `output[0:${actualStartFrame - 1}]`)
+                  .beConstantValueOf(0);
+              should(
+                  audio.slice(actualStartFrame), `output[${actualStartFrame}:]`)
+                  .beConstantValueOf(startValue);
+            })
+            .then(() => task.done());
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-start.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-start.html
new file mode 100644
index 0000000000..19331954b0
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiobuffersource-start.html
@@ -0,0 +1,174 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      audiobuffersource-start.html
+    </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/audiobuffersource-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      // The following test cases assume an AudioBuffer of length 8 whose PCM
+      // data is a linear ramp, 0, 1, 2, 3,...
+
+      let tests = [
+
+        {
+          description:
+              'start(when): implicitly play whole buffer from beginning to end',
+          offsetFrame: 'none',
+          durationFrames: 'none',
+          renderFrames: 16,
+          playbackRate: 1,
+          expected: [0, 1, 2, 3, 4, 5, 6, 7, 0, 0, 0, 0, 0, 0, 0, 0]
+        },
+
+        {
+          description:
+              'start(when, 0): play whole buffer from beginning to end explicitly giving offset of 0',
+          offsetFrame: 0,
+          durationFrames: 'none',
+          renderFrames: 16,
+          playbackRate: 1,
+          expected: [0, 1, 2, 3, 4, 5, 6, 7, 0, 0, 0, 0, 0, 0, 0, 0]
+        },
+
+        {
+          description:
+              'start(when, 0, 8_frames): play whole buffer from beginning to end explicitly giving offset of 0 and duration of 8 frames',
+          offsetFrame: 0,
+          durationFrames: 8,
+          renderFrames: 16,
+          playbackRate: 1,
+          expected: [0, 1, 2, 3, 4, 5, 6, 7, 0, 0, 0, 0, 0, 0, 0, 0]
+        },
+
+        {
+          description:
+              'start(when, 4_frames): play with explicit non-zero offset',
+          offsetFrame: 4,
+          durationFrames: 'none',
+          renderFrames: 16,
+          playbackRate: 1,
+          expected: [4, 5, 6, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+        },
+
+        {
+          description:
+              'start(when, 4_frames, 4_frames): play with explicit non-zero offset and duration',
+          offsetFrame: 4,
+          durationFrames: 4,
+          renderFrames: 16,
+          playbackRate: 1,
+          expected: [4, 5, 6, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+        },
+
+        {
+          description:
+              'start(when, 7_frames): play with explicit non-zero offset near end of buffer',
+          offsetFrame: 7,
+          durationFrames: 1,
+          renderFrames: 16,
+          playbackRate: 1,
+          expected: [7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+        },
+
+        {
+          description:
+              'start(when, 8_frames): play with explicit offset at end of buffer',
+          offsetFrame: 8,
+          durationFrames: 0,
+          renderFrames: 16,
+          playbackRate: 1,
+          expected: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+        },
+
+        {
+          description:
+              'start(when, 9_frames): play with explicit offset past end of buffer',
+          offsetFrame: 8,
+          durationFrames: 0,
+          renderFrames: 16,
+          playbackRate: 1,
+          expected: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+        },
+
+        // When the duration exceeds the buffer, just play to the end of the
+        // buffer. (This is different from the case when we're looping, which is
+        // tested in loop-comprehensive.)
+        {
+          description:
+              'start(when, 0, 15_frames): play with whole buffer, with long duration (clipped)',
+          offsetFrame: 0,
+          durationFrames: 15,
+          renderFrames: 16,
+          playbackRate: 1,
+          expected: [0, 1, 2, 3, 4, 5, 6, 7, 0, 0, 0, 0, 0, 0, 0, 0]
+        },
+
+        // Enable test when AudioBufferSourceNode hack is fixed:
+        // https://bugs.webkit.org/show_bug.cgi?id=77224 { description:
+        // "start(when, 3_frames, 3_frames): play a middle section with explicit
+        // offset and duration",
+        //   offsetFrame: 3, durationFrames: 3, renderFrames: 16, playbackRate:
+        //   1, expected: [4,5,6,7,0,0,0,0,0,0,0,0,0,0,0,0] },
+
+      ];
+
+      let sampleRate = 44100;
+      let buffer;
+      let bufferFrameLength = 8;
+      let testSpacingFrames = 32;
+      let testSpacingSeconds = testSpacingFrames / sampleRate;
+      let totalRenderLengthFrames = tests.length * testSpacingFrames;
+
+      function runLoopTest(context, testNumber, test) {
+        let source = context.createBufferSource();
+
+        source.buffer = buffer;
+        source.playbackRate.value = test.playbackRate;
+
+        source.connect(context.destination);
+
+        // Render each test one after the other, spaced apart by
+        // testSpacingSeconds.
+        let startTime = testNumber * testSpacingSeconds;
+
+        if (test.offsetFrame == 'none' && test.durationFrames == 'none') {
+          source.start(startTime);
+        } else if (test.durationFrames == 'none') {
+          let offset = test.offsetFrame / context.sampleRate;
+          source.start(startTime, offset);
+        } else {
+          let offset = test.offsetFrame / context.sampleRate;
+          let duration = test.durationFrames / context.sampleRate;
+          source.start(startTime, offset, duration);
+        }
+      }
+
+      audit.define(
+          'Tests AudioBufferSourceNode start()', function(task, should) {
+            // Create offline audio context.
+            let context =
+                new OfflineAudioContext(1, totalRenderLengthFrames, sampleRate);
+            buffer = createTestBuffer(context, bufferFrameLength);
+
+            for (let i = 0; i < tests.length; ++i)
+              runLoopTest(context, i, tests[i]);
+
+            context.startRendering().then(function(audioBuffer) {
+              checkAllTests(audioBuffer, should);
+              task.done();
+            });
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiosource-onended.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiosource-onended.html
new file mode 100644
index 0000000000..20ef4a1c63
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiosource-onended.html
@@ -0,0 +1,101 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Onended Event Listener
+    </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 sampleRate = 44100;
+      let renderLengthSeconds = 1;
+      let renderLengthFrames = renderLengthSeconds * sampleRate;
+
+      // Length of the source buffer.  Anything less than the render length is
+      // fine.
+      let sourceBufferLengthFrames = renderLengthFrames / 8;
+      // When to stop the oscillator.  Anything less than the render time is
+      // fine.
+      let stopTime = renderLengthSeconds / 8;
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define('absn-set-onended', (task, should) => {
+        // Test that the onended event for an AudioBufferSourceNode is fired
+        // when it is set directly.
+        let context =
+            new OfflineAudioContext(1, renderLengthFrames, sampleRate);
+        let buffer = context.createBuffer(
+            1, sourceBufferLengthFrames, context.sampleRate);
+        let source = context.createBufferSource();
+        source.buffer = buffer;
+        source.connect(context.destination);
+        source.onended = function(e) {
+          should(
+              true, 'AudioBufferSource.onended called when ended set directly')
+              .beEqualTo(true);
+        };
+        source.start();
+        context.startRendering().then(() => task.done());
+      });
+
+      audit.define('absn-add-listener', (task, should) => {
+        // Test that the onended event for an AudioBufferSourceNode is fired
+        // when addEventListener is used to set the handler.
+        let context =
+            new OfflineAudioContext(1, renderLengthFrames, sampleRate);
+        let buffer = context.createBuffer(
+            1, sourceBufferLengthFrames, context.sampleRate);
+        let source = context.createBufferSource();
+        source.buffer = buffer;
+        source.connect(context.destination);
+        source.addEventListener('ended', function(e) {
+          should(
+              true,
+              'AudioBufferSource.onended called when using addEventListener')
+              .beEqualTo(true);
+        });
+        source.start();
+        context.startRendering().then(() => task.done());
+      });
+
+      audit.define('osc-set-onended', (task, should) => {
+        // Test that the onended event for an OscillatorNode is fired when it is
+        // set directly.
+        let context =
+            new OfflineAudioContext(1, renderLengthFrames, sampleRate);
+        let source = context.createOscillator();
+        source.connect(context.destination);
+        source.onended = function(e) {
+          should(true, 'Oscillator.onended called when ended set directly')
+              .beEqualTo(true);
+        };
+        source.start();
+        source.stop(stopTime);
+        context.startRendering().then(() => task.done());
+      });
+
+      audit.define('osc-add-listener', (task, should) => {
+        // Test that the onended event for an OscillatorNode is fired when
+        // addEventListener is used to set the handler.
+        let context =
+            new OfflineAudioContext(1, renderLengthFrames, sampleRate);
+        let source = context.createOscillator();
+        source.connect(context.destination);
+        source.addEventListener('ended', function(e) {
+          should(true, 'Oscillator.onended called when using addEventListener')
+              .beEqualTo(true);
+        });
+        source.start();
+        source.stop(stopTime);
+        context.startRendering().then(() => task.done());
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiosource-time-limits.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiosource-time-limits.html
new file mode 100644
index 0000000000..3ac9c05938
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/audiosource-time-limits.html
@@ -0,0 +1,74 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Scheduled Sources with Huge Time Limits
+    </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/audioparam-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let sampleRate = 48000;
+      let renderFrames = 1000;
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define('buffersource: huge stop time', (task, should) => {
+        // We only need to generate a small number of frames for this test.
+        let context = new OfflineAudioContext(1, renderFrames, sampleRate);
+        let src = context.createBufferSource();
+
+        // Constant source of amplitude 1, looping.
+        src.buffer = createConstantBuffer(context, 1, 1);
+        src.loop = true;
+
+        // Create the graph and go!
+        let endTime = 1e300;
+        src.connect(context.destination);
+        src.start();
+        src.stop(endTime);
+
+        context.startRendering()
+            .then(function(resultBuffer) {
+              let result = resultBuffer.getChannelData(0);
+              should(
+                  result, 'Output from AudioBufferSource.stop(' + endTime + ')')
+                  .beConstantValueOf(1);
+            })
+            .then(() => task.done());
+      });
+
+
+      audit.define('oscillator: huge stop time', (task, should) => {
+        // We only need to generate a small number of frames for this test.
+        let context = new OfflineAudioContext(1, renderFrames, sampleRate);
+        let src = context.createOscillator();
+
+        // Create the graph and go!
+        let endTime = 1e300;
+        src.connect(context.destination);
+        src.start();
+        src.stop(endTime);
+
+        context.startRendering()
+            .then(function(resultBuffer) {
+              let result = resultBuffer.getChannelData(0);
+              // The buffer should not be empty.  Just find the max and verify
+              // that it's not zero.
+              let max = Math.max.apply(null, result);
+              should(
+                  max, 'Peak amplitude from oscillator.stop(' + endTime + ')')
+                  .beGreaterThan(0);
+            })
+            .then(() => task.done());
+      });
+
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/buffer-resampling.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/buffer-resampling.html
new file mode 100644
index 0000000000..c181ceb8e0
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/buffer-resampling.html
@@ -0,0 +1,101 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Test Extrapolation at end of AudibBuffer in an AudioBufferSourceNode</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>
+      let audit = Audit.createTaskRunner();
+
+      const sampleRate = 48000;
+
+      // For testing we only need a few render quanta.
+      const renderSamples = 512
+
+      // Sample rate for our buffers.  This is the lowest sample rate that is
+      // required to be supported.
+      const bufferRate = 8000;
+
+      // Number of samples in each AudioBuffer; this is fairly arbitrary but
+      // should be less than a render quantum.
+      const bufferLength = 30;
+
+      // Frequency of the sine wave for testing.
+      const frequency = 440;
+
+      audit.define(
+          {
+            label: 'interpolate',
+            description: 'Interpolation of AudioBuffers to context sample rate'
+          },
+          (task, should) => {
+            // The first channel is for the interpolated signal, and the second
+            // channel is for the reference signal from an oscillator.
+            let context = new OfflineAudioContext({
+              numberOfChannels: 2,
+              length: renderSamples,
+              sampleRate: sampleRate
+            });
+
+            let merger = new ChannelMergerNode(
+                context, {numberOfChannels: context.destination.channelCount});
+            merger.connect(context.destination);
+
+            // Create a set of AudioBuffers which are samples from a pure sine
+            // wave with frequency |frequency|.
+            const nBuffers = Math.floor(context.length / bufferLength);
+            const omega = 2 * Math.PI * frequency / bufferRate;
+
+            let frameNumber = 0;
+            let startTime = 0;
+
+            for (let k = 0; k < nBuffers; ++k) {
+              //          let buffer = context.createBuffer(1, bufferLength,
+              //          bufferRate);
+              let buffer = new AudioBuffer(
+                  {length: bufferLength, sampleRate: bufferRate});
+              let data = buffer.getChannelData(0);
+              for (let n = 0; n < bufferLength; ++n) {
+                data[n] = Math.sin(omega * frameNumber);
+                ++frameNumber;
+              }
+              // Create a source using this buffer and start it at the end of
+              // the previous buffer.
+              let src = new AudioBufferSourceNode(context, {buffer: buffer});
+
+              src.connect(merger, 0, 0);
+              src.start(startTime);
+              startTime += buffer.duration;
+            }
+
+            // Create the reference sine signal using an oscillator.
+            let osc = new OscillatorNode(
+                context, {type: 'sine', frequency: frequency});
+            osc.connect(merger, 0, 1);
+            osc.start(0);
+
+            context.startRendering()
+                .then(audioBuffer => {
+                  let actual = audioBuffer.getChannelData(0);
+                  let expected = audioBuffer.getChannelData(1);
+
+                  should(actual, 'Interpolated sine wave')
+                      .beCloseToArray(expected, {absoluteThreshold: 9.0348e-2});
+
+                  // Compute SNR between them.
+                  let snr = 10 * Math.log10(computeSNR(actual, expected));
+
+                  should(snr, `SNR (${snr.toPrecision(4)} dB)`)
+                      .beGreaterThanOrEqualTo(37.17);
+                })
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/ctor-audiobuffersource.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/ctor-audiobuffersource.html
new file mode 100644
index 0000000000..c1c3203451
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/ctor-audiobuffersource.html
@@ -0,0 +1,116 @@
+<!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>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/note-grain-on-play.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/note-grain-on-play.html
new file mode 100644
index 0000000000..37c4462add
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/note-grain-on-play.html
@@ -0,0 +1,121 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      note-grain-on-play.html
+    </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/note-grain-on-testing.js"></script>
+  </head>
+  <body>
+    <div id="description"></div>
+    <div id="console"></div>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      // To test noteGrainOn, a single ramp signal is created.
+      // Various sections of the ramp are rendered by noteGrainOn() at
+      // different times, and we verify that the actual output
+      // consists of the correct section of the ramp at the correct
+      // time.
+
+      let linearRampBuffer;
+
+      // Array of the grain offset used for each ramp played.
+      let grainOffsetTime = [];
+
+      // Verify the received signal is a ramp from the correct section
+      // of our ramp signal.
+      function verifyGrain(renderedData, startFrame, endFrame, grainIndex) {
+        let grainOffsetFrame =
+            timeToSampleFrame(grainOffsetTime[grainIndex], sampleRate);
+        let grainFrameLength = endFrame - startFrame;
+        let ramp = linearRampBuffer.getChannelData(0);
+        let isCorrect = true;
+
+        let expected;
+        let actual;
+        let frame;
+
+        for (let k = 0; k < grainFrameLength; ++k) {
+          if (renderedData[startFrame + k] != ramp[grainOffsetFrame + k]) {
+            expected = ramp[grainOffsetFrame + k];
+            actual = renderedData[startFrame + k];
+            frame = startFrame + k;
+            isCorrect = false;
+            break;
+          }
+        }
+        return {
+          verified: isCorrect,
+          expected: expected,
+          actual: actual,
+          frame: frame
+        };
+      }
+
+      function checkResult(buffer, should) {
+        renderedData = buffer.getChannelData(0);
+        let nSamples = renderedData.length;
+
+        // Number of grains that we found that have incorrect data.
+        let invalidGrainDataCount = 0;
+
+        let startEndFrames = findStartAndEndSamples(renderedData);
+
+        // Verify the start and stop times.  Not strictly needed for
+        // this test, but it's useful to know that if the ramp data
+        // appears to be incorrect.
+        verifyStartAndEndFrames(startEndFrames, should);
+
+        // Loop through each of the rendered grains and check that
+        // each grain contains our expected ramp.
+        for (let k = 0; k < startEndFrames.start.length; ++k) {
+          // Verify that the rendered data matches the expected
+          // section of our ramp signal.
+          let result = verifyGrain(
+              renderedData, startEndFrames.start[k], startEndFrames.end[k], k);
+          should(result.verified, 'Pulse ' + k + ' contained the expected data')
+              .beTrue();
+        }
+        should(
+            invalidGrainDataCount,
+            'Number of grains that did not contain the expected data')
+            .beEqualTo(0);
+      }
+
+      audit.define(
+          {
+            label: 'note-grain-on-play',
+            description: 'Test noteGrainOn offset rendering'
+          },
+          function(task, should) {
+            // Create offline audio context.
+            context =
+                new OfflineAudioContext(2, sampleRate * renderTime, sampleRate);
+
+            // Create a linear ramp for testing noteGrainOn.
+            linearRampBuffer = createSignalBuffer(context, function(k) {
+              // Want the ramp to start
+              // with 1, not 0.
+              return k + 1;
+            });
+
+            let grainInfo =
+                playAllGrains(context, linearRampBuffer, numberOfTests);
+
+            grainOffsetTime = grainInfo.grainOffsetTimes;
+
+            context.startRendering().then(function(audioBuffer) {
+              checkResult(audioBuffer, should);
+              task.done();
+            });
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/note-grain-on-timing.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/note-grain-on-timing.html
new file mode 100644
index 0000000000..0db297b42c
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/note-grain-on-timing.html
@@ -0,0 +1,47 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      note-grain-on-timing.html
+    </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/note-grain-on-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      let squarePulseBuffer;
+
+      function checkResult(buffer, should) {
+        renderedData = buffer.getChannelData(0);
+        let nSamples = renderedData.length;
+        let startEndFrames = findStartAndEndSamples(renderedData);
+
+        verifyStartAndEndFrames(startEndFrames, should);
+      }
+
+      audit.define('Test timing of noteGrainOn', function(task, should) {
+        // Create offline audio context.
+        context =
+            new OfflineAudioContext(2, sampleRate * renderTime, sampleRate);
+
+        squarePulseBuffer = createSignalBuffer(context, function(k) {
+          return 1
+        });
+
+        playAllGrains(context, squarePulseBuffer, numberOfTests);
+
+        context.startRendering().then(function(audioBuffer) {
+          checkResult(audioBuffer, should);
+          task.done();
+        });
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/resources/audiobuffersource-multi-channels-expected.wav b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/resources/audiobuffersource-multi-channels-expected.wav
new file mode 100644
index 0000000000..ab9d5fe5a9
Binary files /dev/null and b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/resources/audiobuffersource-multi-channels-expected.wav differ
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/sample-accurate-scheduling.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/sample-accurate-scheduling.html
new file mode 100644
index 0000000000..5fafd024ee
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/sample-accurate-scheduling.html
@@ -0,0 +1,110 @@
+<!DOCTYPE html>
+<!--
+Tests that we are able to schedule a series of notes to playback with sample-accuracy.
+We use an impulse so we can tell exactly where the rendering is happening.
+-->
+<html>
+  <head>
+    <title>
+      sample-accurate-scheduling.html
+    </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/buffer-loader.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      let sampleRate = 44100.0;
+      let lengthInSeconds = 4;
+
+      let context = 0;
+      let bufferLoader = 0;
+      let impulse;
+
+      // See if we can render at exactly these sample offsets.
+      let sampleOffsets = [0, 3, 512, 517, 1000, 1005, 20000, 21234, 37590];
+
+      function createImpulse() {
+        // An impulse has a value of 1 at time 0, and is otherwise 0.
+        impulse = context.createBuffer(2, 512, sampleRate);
+        let sampleDataL = impulse.getChannelData(0);
+        let sampleDataR = impulse.getChannelData(1);
+        sampleDataL[0] = 1.0;
+        sampleDataR[0] = 1.0;
+      }
+
+      function playNote(time) {
+        let bufferSource = context.createBufferSource();
+        bufferSource.buffer = impulse;
+        bufferSource.connect(context.destination);
+        bufferSource.start(time);
+      }
+
+      function checkSampleAccuracy(buffer, should) {
+        let bufferDataL = buffer.getChannelData(0);
+        let bufferDataR = buffer.getChannelData(1);
+
+        let impulseCount = 0;
+        let badOffsetCount = 0;
+
+        // Left and right channels must be the same.
+        should(bufferDataL, 'Content of left and right channels match and')
+            .beEqualToArray(bufferDataR);
+
+        // Go through every sample and make sure it's 0, except at positions in
+        // sampleOffsets.
+        for (let i = 0; i < buffer.length; ++i) {
+          if (bufferDataL[i] != 0) {
+            // Make sure this index is  in sampleOffsets
+            let found = false;
+            for (let j = 0; j < sampleOffsets.length; ++j) {
+              if (sampleOffsets[j] == i) {
+                found = true;
+                break;
+              }
+            }
+            ++impulseCount;
+            should(found, 'Non-zero sample found at sample offset ' + i)
+                .beTrue();
+            if (!found) {
+              ++badOffsetCount;
+            }
+          }
+        }
+
+        should(impulseCount, 'Number of impulses found')
+            .beEqualTo(sampleOffsets.length);
+
+        if (impulseCount == sampleOffsets.length) {
+          should(badOffsetCount, 'bad offset').beEqualTo(0);
+        }
+      }
+
+      audit.define(
+          {label: 'test', description: 'Test sample-accurate scheduling'},
+          function(task, should) {
+
+            // Create offline audio context.
+            context = new OfflineAudioContext(
+                2, sampleRate * lengthInSeconds, sampleRate);
+            createImpulse();
+
+            for (let i = 0; i < sampleOffsets.length; ++i) {
+              let timeInSeconds = sampleOffsets[i] / sampleRate;
+              playNote(timeInSeconds);
+            }
+
+            context.startRendering().then(function(buffer) {
+              checkSampleAccuracy(buffer, should);
+              task.done();
+            });
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/sub-sample-buffer-stitching.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/sub-sample-buffer-stitching.html
new file mode 100644
index 0000000000..3700bfa8ce
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/sub-sample-buffer-stitching.html
@@ -0,0 +1,133 @@
+<!doctype html>
+<html>
+  <head>
+    <title>
+      Test Sub-Sample Accurate Stitching of ABSNs
+    </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>
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {
+            label: 'buffer-stitching-1',
+            description: 'Subsample buffer stitching, same rates'
+          },
+          (task, should) => {
+            const sampleRate = 44100;
+            const bufferRate = 44100;
+            const bufferLength = 30;
+
+            // Experimentally determined thresholds.  DO NOT relax these values
+            // to far from these values to make the tests pass.
+            const errorThreshold = 9.0957e-5;
+            const snrThreshold = 85.580;
+
+            // Informative message
+            should(sampleRate, 'Test 1: context.sampleRate')
+                .beEqualTo(sampleRate);
+            testBufferStitching(sampleRate, bufferRate, bufferLength)
+                .then(resultBuffer => {
+                  const actual = resultBuffer.getChannelData(0);
+                  const expected = resultBuffer.getChannelData(1);
+                  should(
+                      actual,
+                      `Stitched sine-wave buffers at sample rate ${bufferRate}`)
+                      .beCloseToArray(
+                          expected, {absoluteThreshold: errorThreshold});
+                  const SNR = 10 * Math.log10(computeSNR(actual, expected));
+                  should(SNR, `SNR (${SNR} dB)`)
+                      .beGreaterThanOrEqualTo(snrThreshold);
+                })
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: 'buffer-stitching-2',
+            description: 'Subsample buffer stitching, different rates'
+          },
+          (task, should) => {
+            const sampleRate = 44100;
+            const bufferRate = 43800;
+            const bufferLength = 30;
+
+            // Experimentally determined thresholds.  DO NOT relax these values
+            // to far from these values to make the tests pass.
+            const errorThreshold = 3.8986e-3;
+            const snrThreshold = 65.737;
+
+            // Informative message
+            should(sampleRate, 'Test 2: context.sampleRate')
+                .beEqualTo(sampleRate);
+            testBufferStitching(sampleRate, bufferRate, bufferLength)
+                .then(resultBuffer => {
+                  const actual = resultBuffer.getChannelData(0);
+                  const expected = resultBuffer.getChannelData(1);
+                  should(
+                      actual,
+                      `Stitched sine-wave buffers at sample rate ${bufferRate}`)
+                      .beCloseToArray(
+                          expected, {absoluteThreshold: errorThreshold});
+                  const SNR = 10 * Math.log10(computeSNR(actual, expected));
+                  should(SNR, `SNR (${SNR} dB)`)
+                      .beGreaterThanOrEqualTo(snrThreshold);
+                })
+                .then(() => task.done());
+          });
+
+      audit.run();
+
+      // Create graph to test stitching of consecutive ABSNs.  The context rate
+      // is |sampleRate|, and the buffers have a fixed length of |bufferLength|
+      // and rate of |bufferRate|.  The |bufferRate| should not be too different
+      // from |sampleRate| because of interpolation of the buffer to the context
+      // rate.
+      function testBufferStitching(sampleRate, bufferRate, bufferLength) {
+        // The context for testing.  Channel 0 contains the output from
+        // stitching all the buffers together, and channel 1 contains the
+        // expected output.
+        const context = new OfflineAudioContext(
+            {numberOfChannels: 2, length: sampleRate, sampleRate: sampleRate});
+
+        const merger = new ChannelMergerNode(
+            context, {numberOfInputs: context.destination.channelCount});
+
+        merger.connect(context.destination);
+
+        // The reference is a sine wave at 440 Hz.
+        const ref = new OscillatorNode(context, {frequency: 440, type: 'sine'});
+        ref.connect(merger, 0, 1);
+        ref.start();
+
+        // The test signal is a bunch of short AudioBufferSources containing
+        // bits of a sine wave.
+        let waveSignal = new Float32Array(context.length);
+        const omega = 2 * Math.PI / bufferRate * ref.frequency.value;
+        for (let k = 0; k < context.length; ++k) {
+          waveSignal[k] = Math.sin(omega * k);
+        }
+
+        // Slice the sine wave into many little buffers to be assigned to ABSNs
+        // that are started at the appropriate times to produce a final sine
+        // wave.
+        for (let k = 0; k < context.length; k += bufferLength) {
+          const buffer =
+              new AudioBuffer({length: bufferLength, sampleRate: bufferRate});
+          buffer.copyToChannel(waveSignal.slice(k, k + bufferLength), 0);
+
+          const src = new AudioBufferSourceNode(context, {buffer: buffer});
+          src.connect(merger, 0, 0);
+          src.start(k / bufferRate);
+        }
+
+        return context.startRendering();
+      }
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/sub-sample-scheduling.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/sub-sample-scheduling.html
new file mode 100644
index 0000000000..8c627f90f2
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiobuffersourcenode-interface/sub-sample-scheduling.html
@@ -0,0 +1,423 @@
+<!doctype html>
+<html>
+  <head>
+    <title>
+      Test Sub-Sample Accurate Scheduling for ABSN
+    </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>
+      // Power of two so there's no roundoff converting from integer frames to
+      // time.
+      let sampleRate = 32768;
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define('sub-sample accurate start', (task, should) => {
+        // There are two channels, one for each source.  Only need to render
+        // quanta for this test.
+        let context = new OfflineAudioContext(
+            {numberOfChannels: 2, length: 8192, sampleRate: sampleRate});
+        let merger = new ChannelMergerNode(
+            context, {numberOfInputs: context.destination.channelCount});
+
+        merger.connect(context.destination);
+
+        // Use a simple linear ramp for the sources with integer steps starting
+        // at 1 to make it easy to verify and test that have sub-sample accurate
+        // start.  Ramp starts at 1 so we can easily tell when the source
+        // starts.
+        let rampBuffer = new AudioBuffer(
+            {length: context.length, sampleRate: context.sampleRate});
+        let r = rampBuffer.getChannelData(0);
+        for (let k = 0; k < r.length; ++k) {
+          r[k] = k + 1;
+        }
+
+        const src0 = new AudioBufferSourceNode(context, {buffer: rampBuffer});
+        const src1 = new AudioBufferSourceNode(context, {buffer: rampBuffer});
+
+        // Frame where sources should start. This is pretty arbitrary, but one
+        // should be close to an integer and the other should be close to the
+        // next integer.  We do this to catch the case where rounding of the
+        // start frame is being done.  Rounding is incorrect.
+        const startFrame = 33;
+        const startFrame0 = startFrame + 0.1;
+        const startFrame1 = startFrame + 0.9;
+
+        src0.connect(merger, 0, 0);
+        src1.connect(merger, 0, 1);
+
+        src0.start(startFrame0 / context.sampleRate);
+        src1.start(startFrame1 / context.sampleRate);
+
+        context.startRendering()
+            .then(audioBuffer => {
+              const output0 = audioBuffer.getChannelData(0);
+              const output1 = audioBuffer.getChannelData(1);
+
+              // Compute the expected output by interpolating the ramp buffer of
+              // the sources if they started at the given frame.
+              const ramp = rampBuffer.getChannelData(0);
+              const expected0 = interpolateRamp(ramp, startFrame0);
+              const expected1 = interpolateRamp(ramp, startFrame1);
+
+              // Verify output0 has the correct values
+
+              // For information only
+              should(startFrame0, 'src0 start frame').beEqualTo(startFrame0);
+
+              // Output must be zero before the source start frame, and it must
+              // be interpolated correctly after the start frame.  The
+              // absoluteThreshold below is currently set for Chrome which does
+              // linear interpolation.  This needs to be updated eventually if
+              // other browsers do not user interpolation.
+              should(
+                  output0.slice(0, startFrame + 1), `output0[0:${startFrame}]`)
+                  .beConstantValueOf(0);
+              should(
+                  output0.slice(startFrame + 1, expected0.length),
+                  `output0[${startFrame + 1}:${expected0.length - 1}]`)
+                  .beCloseToArray(
+                      expected0.slice(startFrame + 1), {absoluteThreshold: 0});
+
+              // Verify output1 has the correct values.  Same approach as for
+              // output0.
+              should(startFrame1, 'src1 start frame').beEqualTo(startFrame1);
+
+              should(
+                  output1.slice(0, startFrame + 1), `output1[0:${startFrame}]`)
+                  .beConstantValueOf(0);
+              should(
+                  output1.slice(startFrame + 1, expected1.length),
+                  `output1[${startFrame + 1}:${expected1.length - 1}]`)
+                  .beCloseToArray(
+                      expected1.slice(startFrame + 1), {absoluteThreshold: 0});
+            })
+            .then(() => task.done());
+      });
+
+      audit.define('sub-sample accurate stop', (task, should) => {
+        // There are threes channesl, one for each source.  Only need to render
+        // quanta for this test.
+        let context = new OfflineAudioContext(
+            {numberOfChannels: 3, length: 128, sampleRate: sampleRate});
+        let merger = new ChannelMergerNode(
+            context, {numberOfInputs: context.destination.channelCount});
+
+        merger.connect(context.destination);
+
+        // The source can be as simple constant for this test.
+        let buffer = new AudioBuffer(
+            {length: context.length, sampleRate: context.sampleRate});
+        buffer.getChannelData(0).fill(1);
+
+        const src0 = new AudioBufferSourceNode(context, {buffer: buffer});
+        const src1 = new AudioBufferSourceNode(context, {buffer: buffer});
+        const src2 = new AudioBufferSourceNode(context, {buffer: buffer});
+
+        // Frame where sources should start. This is pretty arbitrary, but one
+        // should be an integer, one should be close to an integer and the other
+        // should be close to the next integer.  This is to catch the case where
+        // rounding is used for the end frame.  Rounding is incorrect.
+        const endFrame = 33;
+        const endFrame1 = endFrame + 0.1;
+        const endFrame2 = endFrame + 0.9;
+
+        src0.connect(merger, 0, 0);
+        src1.connect(merger, 0, 1);
+        src2.connect(merger, 0, 2);
+
+        src0.start(0);
+        src1.start(0);
+        src2.start(0);
+        src0.stop(endFrame / context.sampleRate);
+        src1.stop(endFrame1 / context.sampleRate);
+        src2.stop(endFrame2 / context.sampleRate);
+
+        context.startRendering()
+          .then(audioBuffer => {
+            let actual0 = audioBuffer.getChannelData(0);
+            let actual1 = audioBuffer.getChannelData(1);
+            let actual2 = audioBuffer.getChannelData(2);
+
+            // Just verify that we stopped at the right time.
+
+            // This is case where the end frame is an integer.  Since the first
+            // output ends on an exact frame, the output must be zero at that
+            // frame number.  We print the end frame for information only; it
+            // makes interpretation of the rest easier.
+            should(endFrame - 1, 'src0 end frame')
+              .beEqualTo(endFrame - 1);
+            should(actual0[endFrame - 1], `output0[${endFrame - 1}]`)
+              .notBeEqualTo(0);
+            should(actual0.slice(endFrame),
+                   `output0[${endFrame}:]`)
+              .beConstantValueOf(0);
+
+            // The case where the end frame is just a little above an integer.
+            // The output must not be zero just before the end and must be zero
+            // after.
+            should(endFrame1, 'src1 end frame')
+              .beEqualTo(endFrame1);
+            should(actual1[endFrame], `output1[${endFrame}]`)
+              .notBeEqualTo(0);
+            should(actual1.slice(endFrame + 1),
+                   `output1[${endFrame + 1}:]`)
+              .beConstantValueOf(0);
+
+            // The case where the end frame is just a little below an integer.
+            // The output must not be zero just before the end and must be zero
+            // after.
+            should(endFrame2, 'src2 end frame')
+              .beEqualTo(endFrame2);
+            should(actual2[endFrame], `output2[${endFrame}]`)
+              .notBeEqualTo(0);
+            should(actual2.slice(endFrame + 1),
+                   `output2[${endFrame + 1}:]`)
+              .beConstantValueOf(0);
+          })
+          .then(() => task.done());
+      });
+
+      audit.define('sub-sample-grain', (task, should) => {
+        let context = new OfflineAudioContext(
+            {numberOfChannels: 2, length: 128, sampleRate: sampleRate});
+
+        let merger = new ChannelMergerNode(
+            context, {numberOfInputs: context.destination.channelCount});
+
+        merger.connect(context.destination);
+
+        // The source can be as simple constant for this test.
+        let buffer = new AudioBuffer(
+            {length: context.length, sampleRate: context.sampleRate});
+        buffer.getChannelData(0).fill(1);
+
+        let src0 = new AudioBufferSourceNode(context, {buffer: buffer});
+        let src1 = new AudioBufferSourceNode(context, {buffer: buffer});
+
+        src0.connect(merger, 0, 0);
+        src1.connect(merger, 0, 1);
+
+        // Start a short grain.
+        const src0StartGrain = 3.1;
+        const src0EndGrain = 37.2;
+        src0.start(
+            src0StartGrain / context.sampleRate, 0,
+            (src0EndGrain - src0StartGrain) / context.sampleRate);
+
+        const src1StartGrain = 5.8;
+        const src1EndGrain = 43.9;
+        src1.start(
+            src1StartGrain / context.sampleRate, 0,
+            (src1EndGrain - src1StartGrain) / context.sampleRate);
+
+        context.startRendering()
+            .then(audioBuffer => {
+              let output0 = audioBuffer.getChannelData(0);
+              let output1 = audioBuffer.getChannelData(1);
+
+              let expected = new Float32Array(context.length);
+
+              // Compute the expected output for output0 and verify the actual
+              // output matches.
+              expected.fill(1);
+              for (let k = 0; k <= Math.floor(src0StartGrain); ++k) {
+                expected[k] = 0;
+              }
+              for (let k = Math.ceil(src0EndGrain); k < expected.length; ++k) {
+                expected[k] = 0;
+              }
+
+              verifyGrain(should, output0, {
+                startGrain: src0StartGrain,
+                endGrain: src0EndGrain,
+                sourceName: 'src0',
+                outputName: 'output0'
+              });
+
+              verifyGrain(should, output1, {
+                startGrain: src1StartGrain,
+                endGrain: src1EndGrain,
+                sourceName: 'src1',
+                outputName: 'output1'
+              });
+            })
+            .then(() => task.done());
+      });
+
+      audit.define(
+          'sub-sample accurate start with playbackRate', (task, should) => {
+            // There are two channels, one for each source.  Only need to render
+            // quanta for this test.
+            let context = new OfflineAudioContext(
+                {numberOfChannels: 2, length: 8192, sampleRate: sampleRate});
+            let merger = new ChannelMergerNode(
+                context, {numberOfInputs: context.destination.channelCount});
+
+            merger.connect(context.destination);
+
+            // Use a simple linear ramp for the sources with integer steps
+            // starting at 1 to make it easy to verify and test that have
+            // sub-sample accurate start.  Ramp starts at 1 so we can easily
+            // tell when the source starts.
+            let buffer = new AudioBuffer(
+                {length: context.length, sampleRate: context.sampleRate});
+            let r = buffer.getChannelData(0);
+            for (let k = 0; k < r.length; ++k) {
+              r[k] = k + 1;
+            }
+
+            // Two sources with different playback rates
+            const src0 = new AudioBufferSourceNode(
+                context, {buffer: buffer, playbackRate: .25});
+            const src1 = new AudioBufferSourceNode(
+                context, {buffer: buffer, playbackRate: 4});
+
+            // Frame where sources start.  Pretty arbitrary but should not be an
+            // integer.
+            const startFrame = 17.8;
+
+            src0.connect(merger, 0, 0);
+            src1.connect(merger, 0, 1);
+
+            src0.start(startFrame / context.sampleRate);
+            src1.start(startFrame / context.sampleRate);
+
+            context.startRendering()
+                .then(audioBuffer => {
+                  const output0 = audioBuffer.getChannelData(0);
+                  const output1 = audioBuffer.getChannelData(1);
+
+                  const frameBefore = Math.floor(startFrame);
+                  const frameAfter = frameBefore + 1;
+
+                  // Informative message so we know what the following output
+                  // indices really mean.
+                  should(startFrame, 'Source start frame')
+                      .beEqualTo(startFrame);
+
+                  // Verify the output
+
+                  // With a startFrame of 17.8, the first output is at frame 18,
+                  // but the actual start is at 17.8.  So we would interpolate
+                  // the output 0.2 fraction of the way between 17.8 and 18, for
+                  // an output of 1.2 for our ramp.  But the playback rate is
+                  // 0.25, so we're really only 1/4 as far along as we think so
+                  // the output is .2*0.25 of the way between 1 and 2 or 1.05.
+
+                  const ramp0 = buffer.getChannelData(0)[0];
+                  const ramp1 = buffer.getChannelData(0)[1];
+
+                  const src0Output = ramp0 +
+                      (ramp1 - ramp0) * (frameAfter - startFrame) *
+                          src0.playbackRate.value;
+
+                  let playbackMessage =
+                      `With playbackRate ${src0.playbackRate.value}:`;
+
+                  should(
+                      output0[frameBefore],
+                      `${playbackMessage} output0[${frameBefore}]`)
+                      .beEqualTo(0);
+                  should(
+                      output0[frameAfter],
+                      `${playbackMessage} output0[${frameAfter}]`)
+                      .beCloseTo(src0Output, {threshold: 4.542e-8});
+
+                  const src1Output = ramp0 +
+                      (ramp1 - ramp0) * (frameAfter - startFrame) *
+                          src1.playbackRate.value;
+
+                  playbackMessage =
+                      `With playbackRate ${src1.playbackRate.value}:`;
+
+                  should(
+                      output1[frameBefore],
+                      `${playbackMessage} output1[${frameBefore}]`)
+                      .beEqualTo(0);
+                  should(
+                      output1[frameAfter],
+                      `${playbackMessage} output1[${frameAfter}]`)
+                      .beCloseTo(src1Output, {threshold: 4.542e-8});
+                })
+                .then(() => task.done());
+          });
+
+      audit.run();
+
+      // Given an input ramp in |rampBuffer|, interpolate the signal assuming
+      // this ramp is used for an ABSN that starts at frame |startFrame|, which
+      // is not necessarily an integer.  For simplicity we just use linear
+      // interpolation here.  The interpolation is not part of the spec but
+      // this should be pretty close to whatever interpolation is being done.
+      function interpolateRamp(rampBuffer, startFrame) {
+        // |start| is the last zero sample before the ABSN actually starts.
+        const start = Math.floor(startFrame);
+        // One less than the rampBuffer because we can't linearly interpolate
+        // the last frame.
+        let result = new Float32Array(rampBuffer.length - 1);
+
+        for (let k = 0; k <= start; ++k) {
+          result[k] = 0;
+        }
+
+        // Now start linear interpolation.
+        let frame = startFrame;
+        let index = 1;
+        for (let k = start + 1; k < result.length; ++k) {
+          let s0 = rampBuffer[index];
+          let s1 = rampBuffer[index - 1];
+          let delta = frame - k;
+          let s = s1 - delta * (s0 - s1);
+          result[k] = s;
+          ++frame;
+          ++index;
+        }
+
+        return result;
+      }
+
+      function verifyGrain(should, output, options) {
+        let {startGrain, endGrain, sourceName, outputName} = options;
+        let expected = new Float32Array(output.length);
+        // Compute the expected output for output and verify the actual
+        // output matches.
+        expected.fill(1);
+        for (let k = 0; k <= Math.floor(startGrain); ++k) {
+          expected[k] = 0;
+        }
+        for (let k = Math.ceil(endGrain); k < expected.length; ++k) {
+          expected[k] = 0;
+        }
+
+        should(startGrain, `${sourceName} grain start`).beEqualTo(startGrain);
+        should(endGrain - startGrain, `${sourceName} grain duration`)
+            .beEqualTo(endGrain - startGrain);
+        should(endGrain, `${sourceName} grain end`).beEqualTo(endGrain);
+        should(output, outputName).beEqualToArray(expected);
+        should(
+            output[Math.floor(startGrain)],
+            `${outputName}[${Math.floor(startGrain)}]`)
+            .beEqualTo(0);
+        should(
+            output[1 + Math.floor(startGrain)],
+            `${outputName}[${1 + Math.floor(startGrain)}]`)
+            .notBeEqualTo(0);
+        should(
+            output[Math.floor(endGrain)],
+            `${outputName}[${Math.floor(endGrain)}]`)
+            .notBeEqualTo(0);
+        should(
+            output[1 + Math.floor(endGrain)],
+            `${outputName}[${1 + Math.floor(endGrain)}]`)
+            .beEqualTo(0);
+      }
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-detached-execution-context.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-detached-execution-context.html
new file mode 100644
index 0000000000..a83fa1dbe6
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-detached-execution-context.html
@@ -0,0 +1,31 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Testing behavior of AudioContext after execution context is detached
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      const audit = Audit.createTaskRunner();
+
+      audit.define('decoding-on-detached-iframe', (task, should) => {
+        const iframe =
+            document.createElementNS("http://www.w3.org/1999/xhtml", "iframe");
+        document.body.appendChild(iframe);
+        let context = new iframe.contentWindow.AudioContext();
+        document.body.removeChild(iframe);
+
+        should(context.decodeAudioData(new ArrayBuffer(1)),
+               'decodeAudioData() upon a detached iframe')
+            .beRejectedWith('InvalidStateError')
+            .then(() => task.done());
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-getoutputtimestamp-cross-realm.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-getoutputtimestamp-cross-realm.html
new file mode 100644
index 0000000000..5889faf7cc
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-getoutputtimestamp-cross-realm.html
@@ -0,0 +1,32 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Testing AudioContext.getOutputTimestamp() method (cross-realm)
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      const audit = Audit.createTaskRunner();
+
+      audit.define("getoutputtimestamp-cross-realm", function(task, should) {
+        const mainContext = new AudioContext();
+        return task.timeout(() => {
+          const iframe = document.createElement("iframe");
+          document.body.append(iframe);
+          const iframeContext = new iframe.contentWindow.AudioContext();
+
+          should(mainContext.getOutputTimestamp().performanceTime, "mainContext's performanceTime")
+            .beGreaterThan(iframeContext.getOutputTimestamp().performanceTime, "iframeContext's performanceTime");
+          should(iframeContext.getOutputTimestamp.call(mainContext).performanceTime, "mainContext's performanceTime (via iframeContext's method)")
+            .beCloseTo(mainContext.getOutputTimestamp().performanceTime, "mainContext's performanceTime", { threshold: 0.01 });
+        }, 1000);
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-getoutputtimestamp.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-getoutputtimestamp.html
new file mode 100644
index 0000000000..952f38b1ed
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-getoutputtimestamp.html
@@ -0,0 +1,33 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Testing AudioContext.getOutputTimestamp() method
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      audit.define('getoutputtimestamp-initial-values', function(task, should) {
+        let context = new AudioContext;
+        let timestamp = context.getOutputTimestamp();
+
+        should(timestamp.contextTime, 'timestamp.contextTime').exist();
+        should(timestamp.performanceTime, 'timestamp.performanceTime').exist();
+
+        should(timestamp.contextTime, 'timestamp.contextTime')
+            .beGreaterThanOrEqualTo(0);
+        should(timestamp.performanceTime, 'timestamp.performanceTime')
+            .beGreaterThanOrEqualTo(0);
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-not-fully-active.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-not-fully-active.html
new file mode 100644
index 0000000000..e4f6001eda
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-not-fully-active.html
@@ -0,0 +1,94 @@
+<!doctype html>
+<title>Test AudioContext construction when document is not fully active</title>
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script src="/common/get-host-info.sub.js"></script>
+<body></body>
+<script>
+const dir = location.pathname.replace(/\/[^\/]*$/, '/');
+const helper = dir + 'resources/not-fully-active-helper.sub.html?childsrc=';
+const remote_helper = get_host_info().HTTP_NOTSAMESITE_ORIGIN + helper;
+const blank_url = get_host_info().ORIGIN + '/common/blank.html';
+
+const load_content = (frame, src) => {
+  if (src == undefined) {
+    frame.srcdoc = '<html></html>';
+  } else {
+    frame.src = src;
+  }
+  return new Promise(resolve => frame.onload = () => resolve(frame));
+};
+const append_iframe = (src) => {
+  const frame = document.createElement('iframe');
+  document.body.appendChild(frame);
+  return load_content(frame, src);
+};
+const remote_op = (win, op) => {
+  win.postMessage(op, '*');
+  return new Promise(resolve => window.onmessage = e => {
+    if (e.data == 'DONE ' + op) resolve();
+  });
+};
+const test_constructor_throws = async (win, deactivate) => {
+  const {AudioContext, DOMException} = win;
+  await deactivate();
+  assert_throws_dom("InvalidStateError", DOMException,
+                    () => new AudioContext());
+};
+
+promise_test(async () => {
+  const frame = await append_iframe();
+  return test_constructor_throws(frame.contentWindow, () => frame.remove());
+}, "removed frame");
+promise_test(async () => {
+  const frame = await append_iframe();
+  return test_constructor_throws(frame.contentWindow,
+                                 () => load_content(frame));
+}, "navigated frame");
+promise_test(async () => {
+  const frame = await append_iframe(helper + blank_url);
+  const inner = frame.contentWindow.frames[0];
+  return test_constructor_throws(inner, () => frame.remove());
+}, "frame in removed frame");
+promise_test(async () => {
+  const frame = await append_iframe(helper + blank_url);
+  const inner = frame.contentWindow.frames[0];
+  return test_constructor_throws(inner, () => load_content(frame));
+}, "frame in navigated frame");
+promise_test(async () => {
+  const frame = await append_iframe(remote_helper + blank_url);
+  const inner = frame.contentWindow.frames[0];
+  return test_constructor_throws(inner, () => frame.remove());
+}, "frame in removed remote-site frame");
+promise_test(async () => {
+  const frame = await append_iframe(remote_helper + blank_url);
+  const inner = frame.contentWindow.frames[0];
+  return test_constructor_throws(inner, () => load_content(frame));
+}, "frame in navigated remote-site frame");
+promise_test(async () => {
+  const outer = (await append_iframe(remote_helper + blank_url)).contentWindow;
+  const inner = outer.frames[0];
+  return test_constructor_throws(inner,
+                                 () => remote_op(outer, 'REMOVE FRAME'));
+}, "removed frame in remote-site frame");
+promise_test(async () => {
+  const outer = (await append_iframe(remote_helper + blank_url)).contentWindow;
+  const inner = outer.frames[0];
+  return test_constructor_throws(inner,
+                                 () => remote_op(outer, 'NAVIGATE FRAME'));
+}, "navigated frame in remote-site frame");
+promise_test(async () => {
+  const url = remote_helper + helper + blank_url;
+  const outer = (await append_iframe(url)).contentWindow;
+  const inner = outer.frames[0].frames[0];
+  return test_constructor_throws(inner,
+                                 () => remote_op(outer, 'REMOVE FRAME'));
+}, "frame in removed remote-site frame in remote-site frame");
+promise_test(async () => {
+  const url = remote_helper + helper + blank_url;
+  const outer = (await append_iframe(url)).contentWindow;
+  const inner = outer.frames[0].frames[0];
+  return test_constructor_throws(inner,
+                                 () => remote_op(outer, 'NAVIGATE FRAME'));
+}, "frame in navigated remote-site frame in remote-site frame");
+</script>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-sinkid-constructor.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-sinkid-constructor.https.html
new file mode 100644
index 0000000000..2dedd6cd36
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-sinkid-constructor.https.html
@@ -0,0 +1,122 @@
+<!DOCTYPE html>
+<head>
+<title>Test AudioContext constructor with sinkId options</title>
+</head>
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script>
+"use strict";
+
+let outputDeviceList = null;
+let firstDeviceId = null;
+
+navigator.mediaDevices.getUserMedia({audio: true}).then(() => {
+  navigator.mediaDevices.enumerateDevices().then((deviceList) => {
+    outputDeviceList =
+        deviceList.filter(({kind}) => kind === 'audiooutput');
+    assert_greater_than(outputDeviceList.length, 1,
+                        'the system must have more than 1 device.');
+    firstDeviceId = outputDeviceList[1].deviceId;
+
+    // Run async tests concurrently.
+    async_test(t => testDefaultSinkId(t),
+               'Setting sinkId to the empty string at construction should ' +
+               'succeed.');
+    async_test(t => testValidSinkId(t),
+               'Setting sinkId with a valid device identifier at ' +
+               'construction should succeed.');
+    async_test(t => testAudioSinkOptions(t),
+               'Setting sinkId with an AudioSinkOptions at construction ' +
+               'should succeed.');
+    async_test(t => testExceptions(t),
+               'Invalid sinkId arguments should throw an appropriate ' +
+               'exception.')
+  });
+});
+
+// 1.2.1. AudioContext constructor
+// https://webaudio.github.io/web-audio-api/#AudioContext-constructors
+
+// Step 10.1.1. If sinkId is equal to [[sink ID]], abort these substeps.
+const testDefaultSinkId = (t) => {
+  // The initial `sinkId` is the empty string. This will cause the same value
+  // check.
+  const audioContext = new AudioContext({sinkId: ''});
+  audioContext.addEventListener('statechange', () => {
+    t.step(() => {
+      assert_equals(audioContext.sinkId, '');
+      assert_equals(audioContext.state, 'running');
+    });
+    audioContext.close();
+    t.done();
+  }, {once: true});
+};
+
+// Step 10.1.2~3: See "Validating sinkId" tests below.
+
+// Step 10.1.4. If sinkId is a type of DOMString, set [[sink ID]] to sinkId and
+// abort these substeps.
+const testValidSinkId = (t) => {
+  const audioContext = new AudioContext({sinkId: firstDeviceId});
+  audioContext.addEventListener('statechange', () => {
+    t.step(() => {
+      assert_true(audioContext.sinkId === firstDeviceId,
+                  'the context sinkId should match the given sinkId.');
+    });
+    audioContext.close();
+    t.done();
+  }, {once: true});
+  t.step_timeout(t.unreached_func('onstatechange not fired or assert failed'),
+                 100);
+};
+
+// Step 10.1.5. If sinkId is a type of AudioSinkOptions, set [[sink ID]] to a
+// new instance of AudioSinkInfo created with the value of type of sinkId.
+const testAudioSinkOptions = (t) => {
+  const audioContext = new AudioContext({sinkId: {type: 'none'}});
+  // The only signal we can use for the sinkId change after construction is
+  // `statechange` event.
+  audioContext.addEventListener('statechange', () => {
+    t.step(() => {
+      assert_equals(typeof audioContext.sinkId, 'object');
+      assert_equals(audioContext.sinkId.type, 'none');
+    });
+    audioContext.close();
+    t.done();
+  }, {once: true});
+  t.step_timeout(t.unreached_func('onstatechange not fired or assert failed'),
+                 100);
+};
+
+// 1.2.4. Validating sinkId
+// https://webaudio.github.io/web-audio-api/#validating-sink-identifier
+
+// Step 3. If document is not allowed to use the feature identified by
+// "speaker-selection", return a new DOMException whose name is
+// "NotAllowedError".
+// TODO: Due to the lack of implementation, this step is not tested.
+
+const testExceptions = (t) => {
+  t.step(() => {
+    // The wrong AudioSinkOption.type should cause a TypeError.
+    assert_throws_js(TypeError, () => {
+      const audioContext = new AudioContext({sinkId: {type: 'something_else'}});
+      audioContext.close();
+    }, 'An invalid AudioSinkOptions.type value should throw a TypeError ' +
+       'exception.');
+  });
+
+  t.step(() => {
+    // Step 4. If sinkIdArg is a type of DOMString but it is not equal to the
+    // empty string or it does not match any audio output device identified by
+    // the result that would be provided by enumerateDevices(), return a new
+    // DOMException whose name is "NotFoundError".
+    assert_throws_dom('NotFoundError', () => {
+      const audioContext = new AudioContext({sinkId: 'some_random_device_id'});
+      audioContext.close();
+    }, 'An invalid device identifier should throw a NotFoundError exception.');
+  });
+  t.done();
+};
+</script>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-sinkid-setsinkid.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-sinkid-setsinkid.https.html
new file mode 100644
index 0000000000..61d2586bfb
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-sinkid-setsinkid.https.html
@@ -0,0 +1,122 @@
+<!DOCTYPE html>
+<head>
+<title>Test AudioContext.setSinkId() method</title>
+</head>
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script>
+"use strict";
+
+const audioContext = new AudioContext();
+let outputDeviceList = null;
+let firstDeviceId = null;
+
+// Setup: Get permission via getUserMedia() and a list of audio output devices.
+promise_setup(async t => {
+  await navigator.mediaDevices.getUserMedia({ audio: true });
+  const deviceList = await navigator.mediaDevices.enumerateDevices();
+  outputDeviceList =
+      deviceList.filter(({kind}) => kind === 'audiooutput');
+  assert_greater_than(outputDeviceList.length, 1,
+                      'the system must have more than 1 device.');
+  firstDeviceId = outputDeviceList[1].deviceId;
+}, 'Get permission via getUserMedia() and a list of audio output devices.');
+
+
+// 1.2.3. AudioContext.setSinkId() method
+// https://webaudio.github.io/web-audio-api/#dom-audiocontext-setsinkid-domstring-or-audiosinkoptions-sinkid
+
+promise_test(async t => {
+  t.step(() => {
+    // The default value of `sinkId` is the empty string.
+    assert_equals(audioContext.sinkId, '');
+  });
+  t.done();
+}, 'setSinkId() with a valid device identifier should succeeded.');
+
+promise_test(async t => {
+  // Change to the first non-default device in the list.
+  await audioContext.setSinkId(firstDeviceId);
+  t.step(() => {
+    // If both `sinkId` and [[sink ID]] are a type of DOMString, and they are
+    // equal to each other, resolve the promise immediately.
+    assert_equals(typeof audioContext.sinkId, 'string');
+    assert_equals(audioContext.sinkId, firstDeviceId);
+  });
+  return audioContext.setSinkId(firstDeviceId);
+}, 'setSinkId() with the same sink ID should resolve immediately.');
+
+promise_test(async t => {
+  // If sinkId is a type of AudioSinkOptions and [[sink ID]] is a type of
+  // AudioSinkInfo, and type in sinkId and type in [[sink ID]] are equal,
+  // resolve the promise immediately.
+  await audioContext.setSinkId({type: 'none'});
+  t.step(() => {
+    assert_equals(typeof audioContext.sinkId, 'object');
+    assert_equals(audioContext.sinkId.type, 'none');
+  });
+  return audioContext.setSinkId({type: 'none'});
+}, 'setSinkId() with the same AudioSinkOptions.type value should resolve ' +
+   'immediately.');
+
+// 1.2.4. Validating sinkId
+// https://webaudio.github.io/web-audio-api/#validating-sink-identifier
+
+// Step 3. If document is not allowed to use the feature identified by
+// "speaker-selection", return a new DOMException whose name is
+// "NotAllowedError".
+// TODO: Due to the lack of implementation, this step is not tested.
+
+// The wrong AudioSinkOption.type should cause a TypeError.
+promise_test(t =>
+    promise_rejects_js(t, TypeError,
+                       audioContext.setSinkId({type: 'something_else'})),
+    'setSinkId() should fail with TypeError on an invalid ' +
+    'AudioSinkOptions.type value.');
+
+// Step 4. If sinkId is a type of DOMString but it is not equal to the empty
+// string or it does not match any audio output device identified by the result
+// that would be provided by enumerateDevices(), return a new DOMException whose
+// name is "NotFoundError".
+promise_test(t =>
+    promise_rejects_dom(t, 'NotFoundError',
+                        audioContext.setSinkId('some_random_device_id')),
+    'setSinkId() should fail with NotFoundError on an invalid device ' +
+    'identifier.');
+
+// setSinkId invoked from closed AudioContext should throw InvalidStateError
+// DOMException.
+promise_test(async t => {
+  await audioContext.close();
+  t.step(() => {
+    assert_equals(audioContext.state, 'closed');
+  });
+  promise_rejects_dom(t, 'InvalidStateError',
+                      audioContext.setSinkId('some_random_device_id'))
+},'setSinkId() should fail with InvalidStateError when calling from a' +
+  'stopped AudioContext');
+
+// setSinkId invoked from detached document should throw InvalidStateError
+// DOMException.
+promise_test(async t => {
+  const iframe = document.createElementNS("http://www.w3.org/1999/xhtml", "iframe");
+  document.body.appendChild(iframe);
+  let iframeAudioContext = new iframe.contentWindow.AudioContext();
+  document.body.removeChild(iframe);
+  promise_rejects_dom(t, 'InvalidStateError',
+                      iframeAudioContext.setSinkId('some_random_device_id'));
+},'setSinkId() should fail with InvalidStateError when calling from a' +
+  'detached document');
+
+// Pending setSinkId() promises should be rejected with a
+// DOMException of InvalidStateError when the context is closed.
+// See: crbug.com/1408376
+promise_test(async t => {
+  const audioContext = new AudioContext();
+  promise_rejects_dom(t, 'InvalidStateError',
+                      audioContext.setSinkId('some_random_device_id'));
+  await audioContext.close();
+},'pending setSinkId() should be rejected with InvalidStateError when' +
+  'AudioContext is closed');
+</script>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-sinkid-state-change.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-sinkid-state-change.https.html
new file mode 100644
index 0000000000..c22f69c18d
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-sinkid-state-change.https.html
@@ -0,0 +1,83 @@
+<!DOCTYPE html>
+<head>
+<title>Test AudioContext.setSinkId() state change</title>
+</head>
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script>
+"use strict";
+
+const audioContext = new AudioContext();
+let outputDeviceList = null;
+let firstDeviceId = null;
+
+// Setup: Get permission via getUserMedia() and a list of audio output devices.
+promise_setup(async t => {
+  await navigator.mediaDevices.getUserMedia({ audio: true });
+  const deviceList = await navigator.mediaDevices.enumerateDevices();
+  outputDeviceList =
+      deviceList.filter(({kind}) => kind === 'audiooutput');
+  assert_greater_than(outputDeviceList.length, 1,
+                      'the system must have more than 1 device.');
+  firstDeviceId = outputDeviceList[1].deviceId;
+}, 'Get permission via getUserMedia() and a list of audio output devices.');
+
+// Test the sink change when from a suspended context.
+promise_test(async t => {
+  let events = [];
+  await audioContext.suspend();
+
+  // Step 6. Set wasRunning to false if the [[rendering thread state]] on the
+  // AudioContext is "suspended".
+  assert_equals(audioContext.state, 'suspended');
+
+  // Step 11.5. Fire an event named sinkchange at the associated AudioContext.
+  audioContext.onsinkchange = t.step_func(() => {
+    events.push('sinkchange');
+    assert_equals(audioContext.sinkId, firstDeviceId);
+  });
+
+  await audioContext.setSinkId(firstDeviceId);
+  assert_equals(events[0], 'sinkchange');
+  t.done();
+}, 'Calling setSinkId() on a suspended AudioContext should fire only sink ' +
+   'change events.');
+
+// Test the sink change when from a running context.
+promise_test(async t => {
+  let events = [];
+  await audioContext.resume();
+
+  // Step 9. If wasRunning is true:
+  assert_equals(audioContext.state, 'running');
+
+  // Step 9.2.1. Set the state attribute of the AudioContext to "suspended".
+  // Fire an event named statechange at the associated AudioContext.
+  audioContext.onstatechange = t.step_func(() => {
+    events.push('statechange:suspended');
+    assert_equals(audioContext.state, 'suspended');
+  });
+
+  // Step 11.5. Fire an event named sinkchange at the associated AudioContext.
+  audioContext.onsinkchange = t.step_func(() => {
+    events.push('sinkchange');
+    assert_equals(audioContext.sinkId, firstDeviceId);
+  });
+
+  // Step 12.2. Set the state attribute of the AudioContext to "running".
+  // Fire an event named statechange at the associated AudioContext.
+  audioContext.onstatechange = t.step_func(() => {
+    events.push('statechange:running');
+    assert_equals(audioContext.state, 'running');
+  });
+
+  await audioContext.setSinkId(firstDeviceId);
+  assert_equals(events.length, 3);
+  assert_equals(events[0], 'statechange:suspended');
+  assert_equals(events[1], 'sinkchange');
+  assert_equals(events[2], 'statechange:running');
+  t.done();
+}, 'Calling setSinkId() on a running AudioContext should fire both state ' +
+   'and sink change events.');
+</script>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-suspend-resume-close.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-suspend-resume-close.html
new file mode 100644
index 0000000000..192317dda2
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-suspend-resume-close.html
@@ -0,0 +1,406 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script type="module">
+"use strict";
+
+function tryToCreateNodeOnClosedContext(ctx) {
+  assert_equals(ctx.state, "closed", "The context is in closed state");
+
+  [
+    { name: "createBufferSource" },
+    {
+      name: "createMediaStreamDestination",
+      onOfflineAudioContext: false,
+    },
+    { name: "createScriptProcessor" },
+    { name: "createStereoPanner" },
+    { name: "createAnalyser" },
+    { name: "createGain" },
+    { name: "createDelay" },
+    { name: "createBiquadFilter" },
+    { name: "createWaveShaper" },
+    { name: "createPanner" },
+    { name: "createConvolver" },
+    { name: "createChannelSplitter" },
+    { name: "createChannelMerger" },
+    { name: "createDynamicsCompressor" },
+    { name: "createOscillator" },
+    {
+      name: "createMediaElementSource",
+      args: [new Audio()],
+      onOfflineAudioContext: false,
+    },
+    {
+      name: "createMediaStreamSource",
+      args: [new AudioContext().createMediaStreamDestination().stream],
+      onOfflineAudioContext: false,
+    },
+  ].forEach(function (e) {
+    if (
+      e.onOfflineAudioContext == false &&
+      ctx instanceof OfflineAudioContext
+    ) {
+      return;
+    }
+
+    try {
+      ctx[e.name].apply(ctx, e.args);
+    } catch (err) {
+      assert_true(false, "unexpected exception thrown for " + e.name);
+    }
+  });
+}
+
+function loadFile(url, callback) {
+  return new Promise((resolve) => {
+    var xhr = new XMLHttpRequest();
+    xhr.open("GET", url, true);
+    xhr.responseType = "arraybuffer";
+    xhr.onload = function () {
+      resolve(xhr.response);
+    };
+    xhr.send();
+  });
+}
+
+// createBuffer, createPeriodicWave and decodeAudioData should work on a context
+// that has `state` == "closed"
+async function tryLegalOpeerationsOnClosedContext(ctx) {
+  assert_equals(ctx.state, "closed", "The context is in closed state");
+
+  [
+    { name: "createBuffer", args: [1, 44100, 44100] },
+    {
+      name: "createPeriodicWave",
+      args: [new Float32Array(10), new Float32Array(10)],
+    },
+  ].forEach(function (e) {
+    try {
+      ctx[e.name].apply(ctx, e.args);
+    } catch (err) {
+      assert_true(false, "unexpected exception thrown");
+    }
+  });
+  var buf = await loadFile("/webaudio/resources/sin_440Hz_-6dBFS_1s.wav");
+  return ctx
+    .decodeAudioData(buf)
+    .then(function (decodedBuf) {
+      assert_true(
+        true,
+        "decodeAudioData on a closed context should work, it did."
+      );
+    })
+    .catch(function (e) {
+      assert_true(
+        false,
+        "decodeAudioData on a closed context should work, it did not"
+      );
+    });
+}
+
+// Test that MediaStreams that are the output of a suspended AudioContext are
+// producing silence
+// ac1 produce a sine fed to a MediaStreamAudioDestinationNode
+// ac2 is connected to ac1 with a MediaStreamAudioSourceNode, and check that
+// there is silence when ac1 is suspended
+async function testMultiContextOutput() {
+  var ac1 = new AudioContext(),
+    ac2 = new AudioContext();
+
+  await new Promise((resolve) => (ac1.onstatechange = resolve));
+
+  ac1.onstatechange = null;
+  await ac1.suspend();
+  assert_equals(ac1.state, "suspended", "ac1 is suspended");
+  var osc1 = ac1.createOscillator(),
+    mediaStreamDestination1 = ac1.createMediaStreamDestination();
+
+  var mediaStreamAudioSourceNode2 = ac2.createMediaStreamSource(
+      mediaStreamDestination1.stream
+    ),
+    sp2 = ac2.createScriptProcessor(),
+    silentBuffersInARow = 0;
+
+  osc1.connect(mediaStreamDestination1);
+  mediaStreamAudioSourceNode2.connect(sp2);
+  osc1.start();
+
+  let e = await new Promise((resolve) => (sp2.onaudioprocess = resolve));
+
+  while (true) {
+    let e = await new Promise(
+      (resolve) => (sp2.onaudioprocess = resolve)
+    );
+    var input = e.inputBuffer.getChannelData(0);
+    var silent = true;
+    for (var i = 0; i < input.length; i++) {
+      if (input[i] != 0.0) {
+        silent = false;
+      }
+    }
+
+    if (silent) {
+      silentBuffersInARow++;
+      if (silentBuffersInARow == 10) {
+        assert_true(
+          true,
+          "MediaStreams produce silence when their input is blocked."
+        );
+        break;
+      }
+    } else {
+      assert_equals(
+        silentBuffersInARow,
+        0,
+        "No non silent buffer inbetween silent buffers."
+      );
+    }
+  }
+
+  sp2.onaudioprocess = null;
+  ac1.close();
+  ac2.close();
+}
+
+// Test that there is no buffering between contexts when connecting a running
+// AudioContext to a suspended AudioContext. Gecko's ScriptProcessorNode does some
+// buffering internally, so we ensure this by using a very very low frequency
+// on a sine, and oberve that the phase has changed by a big enough margin.
+async function testMultiContextInput() {
+  var ac1 = new AudioContext(),
+    ac2 = new AudioContext();
+
+  await new Promise((resolve) => (ac1.onstatechange = resolve));
+  ac1.onstatechange = null;
+
+  var osc1 = ac1.createOscillator(),
+    mediaStreamDestination1 = ac1.createMediaStreamDestination(),
+    sp1 = ac1.createScriptProcessor();
+
+  var mediaStreamAudioSourceNode2 = ac2.createMediaStreamSource(
+      mediaStreamDestination1.stream
+    ),
+    sp2 = ac2.createScriptProcessor(),
+    eventReceived = 0;
+
+  osc1.frequency.value = 0.0001;
+  osc1.connect(mediaStreamDestination1);
+  osc1.connect(sp1);
+  mediaStreamAudioSourceNode2.connect(sp2);
+  osc1.start();
+
+  var e = await new Promise((resolve) => (sp2.onaudioprocess = resolve));
+  var inputBuffer1 = e.inputBuffer.getChannelData(0);
+  sp2.value = inputBuffer1[inputBuffer1.length - 1];
+  await ac2.suspend();
+  await ac2.resume();
+
+  while (true) {
+    var e = await new Promise(
+      (resolve) => (sp2.onaudioprocess = resolve)
+    );
+    var inputBuffer = e.inputBuffer.getChannelData(0);
+    if (eventReceived++ == 3) {
+      var delta = Math.abs(inputBuffer[1] - sp2.value),
+        theoreticalIncrement =
+          (2048 * 3 * Math.PI * 2 * osc1.frequency.value) /
+          ac1.sampleRate;
+      assert_true(
+        delta >= theoreticalIncrement,
+        "Buffering did not occur when the context was suspended (delta:" +
+          delta +
+          " increment: " +
+          theoreticalIncrement +
+          ")"
+      );
+      break;
+    }
+  }
+  ac1.close();
+  ac2.close();
+  sp1.onaudioprocess = null;
+  sp2.onaudioprocess = null;
+}
+
+// Take an AudioContext, make sure it switches to running when the audio starts
+// flowing, and then, call suspend, resume and close on it, tracking its state.
+async function testAudioContext() {
+  var ac = new AudioContext();
+  assert_equals(
+    ac.state,
+    "suspended",
+    "AudioContext should start in suspended state."
+  );
+  var stateTracker = {
+    previous: ac.state,
+    // no promise for the initial suspended -> running
+    initial: { handler: false },
+    suspend: { promise: false, handler: false },
+    resume: { promise: false, handler: false },
+    close: { promise: false, handler: false },
+  };
+
+  await new Promise((resolve) => (ac.onstatechange = resolve));
+
+  assert_true(
+    stateTracker.previous == "suspended" && ac.state == "running",
+    'AudioContext should switch to "running" when the audio hardware is' +
+      " ready."
+  );
+
+  stateTracker.previous = ac.state;
+  stateTracker.initial.handler = true;
+
+  let promise_statechange_suspend = new Promise((resolve) => {
+    ac.onstatechange = resolve;
+  }).then(() => {
+    stateTracker.suspend.handler = true;
+  });
+  await ac.suspend();
+  assert_true(
+    !stateTracker.suspend.handler,
+    "Promise should be resolved before the callback."
+  );
+  assert_equals(
+    ac.state,
+    "suspended",
+    'AudioContext should switch to "suspended" when the audio stream is ' +
+      "suspended."
+  );
+  await promise_statechange_suspend;
+  stateTracker.previous = ac.state;
+
+  let promise_statechange_resume = new Promise((resolve) => {
+    ac.onstatechange = resolve;
+  }).then(() => {
+    stateTracker.resume.handler = true;
+  });
+  await ac.resume();
+  assert_true(
+    !stateTracker.resume.handler,
+    "Promise should be resolved before the callback."
+  );
+  assert_equals(
+    ac.state,
+    "running",
+    'AudioContext should switch to "running" when the audio stream is ' +
+      "resumed."
+  );
+  await promise_statechange_resume;
+  stateTracker.previous = ac.state;
+
+  let promise_statechange_close = new Promise((resolve) => {
+    ac.onstatechange = resolve;
+  }).then(() => {
+    stateTracker.close.handler = true;
+  });
+  await ac.close();
+  assert_true(
+    !stateTracker.close.handler,
+    "Promise should be resolved before the callback."
+  );
+  assert_equals(
+    ac.state,
+    "closed",
+    'AudioContext should switch to "closed" when the audio stream is ' +
+      "closed."
+  );
+  await promise_statechange_close;
+  stateTracker.previous = ac.state;
+
+  tryToCreateNodeOnClosedContext(ac);
+  await tryLegalOpeerationsOnClosedContext(ac);
+}
+
+async function testOfflineAudioContext() {
+  var o = new OfflineAudioContext(1, 44100, 44100);
+  assert_equals(
+    o.state,
+    "suspended",
+    "OfflineAudioContext should start in suspended state."
+  );
+
+  var previousState = o.state,
+    finishedRendering = false;
+
+  o.startRendering().then(function (buffer) {
+    finishedRendering = true;
+  });
+
+  await new Promise((resolve) => (o.onstatechange = resolve));
+
+  assert_true(
+    previousState == "suspended" && o.state == "running",
+    "onstatechanged" +
+      "handler is called on state changed, and the new state is running"
+  );
+  previousState = o.state;
+  await new Promise((resolve) => (o.onstatechange = resolve));
+  assert_true(
+    previousState == "running" && o.state == "closed",
+    "onstatechanged handler is called when rendering finishes, " +
+      "and the new state is closed"
+  );
+  assert_true(
+    finishedRendering,
+    "The Promise that is resolved when the rendering is " +
+      "done should be resolved earlier than the state change."
+  );
+  previousState = o.state;
+  function afterRenderingFinished() {
+    assert_true(
+      false,
+      "There should be no transition out of the closed state."
+    );
+  }
+  o.onstatechange = afterRenderingFinished;
+
+  tryToCreateNodeOnClosedContext(o);
+  await tryLegalOpeerationsOnClosedContext(o);
+}
+
+async function testSuspendResumeEventLoop() {
+  var ac = new AudioContext();
+  var source = ac.createBufferSource();
+  source.buffer = ac.createBuffer(1, 44100, 44100);
+  await new Promise((resolve) => (ac.onstatechange = resolve));
+  ac.onstatechange = null;
+  assert_true(ac.state == "running", "initial state is running");
+  await ac.suspend();
+  source.start();
+  ac.resume();
+  await new Promise((resolve) => (source.onended = resolve));
+  assert_true(true, "The AudioContext did resume");
+}
+
+function testResumeInStateChangeForResumeCallback() {
+  return new Promise((resolve) => {
+    var ac = new AudioContext();
+    ac.onstatechange = function () {
+      ac.resume().then(() => {
+        assert_true(true, "resume promise resolved as expected.");
+        resolve();
+      });
+    };
+  });
+}
+
+var tests = [
+  testOfflineAudioContext,
+  testMultiContextOutput,
+  testMultiContextInput,
+  testSuspendResumeEventLoop,
+  testResumeInStateChangeForResumeCallback,
+  testAudioContext,
+];
+
+tests.forEach(function (f) {
+  promise_test(f, f.name);
+});
+    </script>
+  </head>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-suspend-resume.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-suspend-resume.html
new file mode 100644
index 0000000000..ff3daebf39
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontext-suspend-resume.html
@@ -0,0 +1,145 @@
+<!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('suspended');
+            should(context.resume(), 'context.resume')
+                .beResolved()
+                .then(() => {
+                  should(context.state, 'context.state after resume')
+                      .beEqualTo('running');
+                })
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontextoptions.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontextoptions.html
new file mode 100644
index 0000000000..136abedaa8
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/audiocontextoptions.html
@@ -0,0 +1,215 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test AudioContextOptions
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let context;
+      let defaultLatency;
+      let interactiveLatency;
+      let balancedLatency;
+      let playbackLatency;
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {
+            label: 'test-audiocontextoptions-latencyHint-basic',
+            description: 'Test creating contexts with basic latencyHint types.'
+          },
+          function(task, should) {
+            let closingPromises = [];
+
+            // Verify that an AudioContext can be created with default options.
+            should(function() {
+              context = new AudioContext()
+            }, 'context = new AudioContext()').notThrow();
+
+            should(context.sampleRate,
+              `context.sampleRate (${context.sampleRate} Hz)`).beGreaterThan(0);
+
+            defaultLatency = context.baseLatency;
+            should(defaultLatency, 'default baseLatency').beGreaterThanOrEqualTo(0);
+
+            // Verify that an AudioContext can be created with the expected
+            // latency types.
+            should(
+                function() {
+                  context = new AudioContext({'latencyHint': 'interactive'})
+                },
+                'context = new AudioContext({\'latencyHint\': \'interactive\'})')
+                .notThrow();
+
+            interactiveLatency = context.baseLatency;
+            should(interactiveLatency, 'interactive baseLatency')
+                .beEqualTo(defaultLatency);
+            closingPromises.push(context.close());
+
+            should(
+                function() {
+                  context = new AudioContext({'latencyHint': 'balanced'})
+                },
+                'context = new AudioContext({\'latencyHint\': \'balanced\'})')
+                .notThrow();
+
+            balancedLatency = context.baseLatency;
+            should(balancedLatency, 'balanced baseLatency')
+                .beGreaterThanOrEqualTo(interactiveLatency);
+            closingPromises.push(context.close());
+
+            should(
+                function() {
+                  context = new AudioContext({'latencyHint': 'playback'})
+                },
+                'context = new AudioContext({\'latencyHint\': \'playback\'})')
+                .notThrow();
+
+            playbackLatency = context.baseLatency;
+            should(playbackLatency, 'playback baseLatency')
+                .beGreaterThanOrEqualTo(balancedLatency);
+            closingPromises.push(context.close());
+
+            Promise.all(closingPromises).then(function() {
+              task.done();
+            });
+          });
+
+      audit.define(
+          {
+            label: 'test-audiocontextoptions-latencyHint-double',
+            description:
+                'Test creating contexts with explicit latencyHint values.'
+          },
+          function(task, should) {
+            let closingPromises = [];
+
+            // Verify too small exact latency clamped to 'interactive'
+            should(
+                function() {
+                  context =
+                      new AudioContext({'latencyHint': interactiveLatency / 2})
+                },
+                'context = new AudioContext({\'latencyHint\': ' +
+                    'interactiveLatency/2})')
+                .notThrow();
+            should(context.baseLatency, 'double-constructor baseLatency small')
+                .beLessThanOrEqualTo(interactiveLatency);
+            closingPromises.push(context.close());
+
+            // Verify that exact latency in range works as expected
+            let validLatency = (interactiveLatency + playbackLatency) / 2;
+            should(
+                function() {
+                  context = new AudioContext({'latencyHint': validLatency})
+                },
+                'context = new AudioContext({\'latencyHint\': validLatency})')
+                .notThrow();
+            should(
+                context.baseLatency, 'double-constructor baseLatency inrange 1')
+                .beGreaterThanOrEqualTo(interactiveLatency);
+            should(
+                context.baseLatency, 'double-constructor baseLatency inrange 2')
+                .beLessThanOrEqualTo(playbackLatency);
+            closingPromises.push(context.close());
+
+            // Verify too big exact latency clamped to some value
+            let context1;
+            let context2;
+            should(function() {
+              context1 =
+                  new AudioContext({'latencyHint': playbackLatency * 10});
+              context2 =
+                  new AudioContext({'latencyHint': playbackLatency * 20});
+            }, 'creating two high latency contexts').notThrow();
+            should(context1.baseLatency, 'high latency context baseLatency')
+                .beEqualTo(context2.baseLatency);
+            should(context1.baseLatency, 'high latency context baseLatency')
+                .beGreaterThanOrEqualTo(interactiveLatency);
+            closingPromises.push(context1.close());
+            closingPromises.push(context2.close());
+
+            // Verify that invalid latencyHint values are rejected.
+            should(
+                function() {
+                  context = new AudioContext({'latencyHint': 'foo'})
+                },
+                'context = new AudioContext({\'latencyHint\': \'foo\'})')
+                .throw(TypeError);
+
+            // Verify that no extra options can be passed into the
+            // AudioContextOptions.
+            should(
+                function() {
+                  context = new AudioContext('latencyHint')
+                },
+                'context = new AudioContext(\'latencyHint\')')
+                .throw(TypeError);
+
+            Promise.all(closingPromises).then(function() {
+              task.done();
+            });
+          });
+
+      audit.define(
+          {
+            label: 'test-audiocontextoptions-sampleRate',
+            description:
+                'Test creating contexts with non-default sampleRate values.'
+          },
+          function(task, should) {
+            // A sampleRate of 1 is unlikely to be supported on any browser,
+            // test that this rate is rejected.
+            should(
+                () => {
+                  context = new AudioContext({sampleRate: 1})
+                },
+                'context = new AudioContext({sampleRate: 1})')
+                .throw(DOMException, 'NotSupportedError');
+
+            // A sampleRate of 1,000,000 is unlikely to be supported on any
+            // browser, test that this rate is also rejected.
+            should(
+                () => {
+                  context = new AudioContext({sampleRate: 1000000})
+                },
+                'context = new AudioContext({sampleRate: 1000000})')
+                .throw(DOMException, 'NotSupportedError');
+            // A negative sample rate should not be accepted
+            should(
+                () => {
+                  context = new AudioContext({sampleRate: -1})
+                },
+                'context = new AudioContext({sampleRate: -1})')
+                .throw(DOMException, 'NotSupportedError');
+            // A null sample rate should not be accepted
+            should(
+                () => {
+                  context = new AudioContext({sampleRate: 0})
+                },
+                'context = new AudioContext({sampleRate: 0})')
+                .throw(DOMException, 'NotSupportedError');
+
+            should(
+                () => {
+                  context = new AudioContext({sampleRate: 24000})
+                },
+                'context = new AudioContext({sampleRate: 24000})')
+                .notThrow();
+            should(
+                context.sampleRate, 'sampleRate inrange')
+                .beEqualTo(24000);
+
+            context.close();
+            task.done();
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/constructor-allowed-to-start.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/constructor-allowed-to-start.html
new file mode 100644
index 0000000000..f866b5f7a1
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/constructor-allowed-to-start.html
@@ -0,0 +1,25 @@
+<!doctype html>
+<title>AudioContext state around "allowed to start" in constructor</title>
+<link rel=help href=https://webaudio.github.io/web-audio-api/#dom-audiocontext-audiocontext>
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script src=/resources/testdriver.js></script>
+<script src=/resources/testdriver-vendor.js></script>
+<script>
+setup({ single_test: true });
+test_driver.bless("audio playback", () => {
+  const ctx = new AudioContext();
+  // Immediately after the constructor the state is "suspended" because the
+  // control message to start processing has just been sent, but the state
+  // should change soon.
+  assert_equals(ctx.state, "suspended", "initial state");
+  ctx.onstatechange = () => {
+    assert_equals(ctx.state, "running", "state after statechange event");
+    // Now create another context and ensure it starts out in the "suspended"
+    // state too, ensuring it's not synchronously "running".
+    const ctx2 = new AudioContext();
+    assert_equals(ctx2.state, "suspended", "initial state of 2nd context");
+    done();
+  };
+});
+</script>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/crashtests/currentTime-after-discard.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/crashtests/currentTime-after-discard.html
new file mode 100644
index 0000000000..8c74bd0aa1
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/crashtests/currentTime-after-discard.html
@@ -0,0 +1,14 @@
+<html>
+<head>
+  <title>
+    Test currentTime after browsing context discard
+  </title>
+</head>
+<script>
+  const frame = document.createElement('frame');
+  document.documentElement.appendChild(frame);
+  const ctx = new frame.contentWindow.AudioContext();
+  frame.remove();
+  ctx.currentTime;
+</script>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/processing-after-resume.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/processing-after-resume.https.html
new file mode 100644
index 0000000000..e000ab124f
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/processing-after-resume.https.html
@@ -0,0 +1,55 @@
+<!doctype html>
+<title>Test consistency of processing after resume()</title>
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script>
+const get_node_and_reply = (context) => {
+  const node = new AudioWorkletNode(context, 'port-processor');
+  return new Promise((resolve) => {
+    node.port.onmessage = (event) => resolve({node: node, reply: event.data});
+  });
+};
+const ping_for_reply = (node) => {
+  return new Promise((resolve) => {
+    node.port.onmessage = (event) => resolve(event.data);
+    node.port.postMessage('ping');
+  });
+};
+const assert_consistent = (constructReply, pong, expectedPongTime, name) => {
+  const blockSize = 128;
+  assert_equals(pong.timeStamp, expectedPongTime, `${name} pong time`);
+  assert_equals(pong.processCallCount * blockSize,
+                pong.currentFrame - constructReply.currentFrame,
+                `${name} processed frame count`);
+};
+const modulePath = '/webaudio/the-audio-api/' +
+    'the-audioworklet-interface/processors/port-processor.js';
+
+promise_test(async () => {
+  const realtime = new AudioContext();
+  await realtime.audioWorklet.addModule(modulePath);
+  await realtime.suspend();
+  const timeBeforeResume = realtime.currentTime;
+  // Two AudioWorkletNodes are constructed.
+  // node1 is constructed before and node2 after the resume() call.
+  const construct1 = get_node_and_reply(realtime);
+  const resume = realtime.resume();
+  const construct2 = get_node_and_reply(realtime);
+  const {node: node1, reply: constructReply1} = await construct1;
+  assert_equals(constructReply1.timeStamp, timeBeforeResume,
+                'construct time before resume');
+  const {node: node2, reply: constructReply2} = await construct2;
+  assert_greater_than_equal(constructReply2.timeStamp, timeBeforeResume,
+                'construct time after resume');
+  await resume;
+  // Suspend the context to freeze time and check that the processing for each
+  // node matches the elapsed time.
+  await realtime.suspend();
+  const timeAfterSuspend = realtime.currentTime;
+  const pong1 = await ping_for_reply(node1);
+  const pong2 = await ping_for_reply(node2);
+  assert_consistent(constructReply1, pong1, timeAfterSuspend, 'node1');
+  assert_consistent(constructReply2, pong2, timeAfterSuspend, 'node2');
+  assert_equals(pong1.currentFrame, pong2.currentFrame, 'currentFrame matches');
+});
+</script>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/promise-methods-after-discard.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/promise-methods-after-discard.html
new file mode 100644
index 0000000000..2fb3c5a50b
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/promise-methods-after-discard.html
@@ -0,0 +1,28 @@
+<!doctype html>
+<title>Test for rejected promises from methods on an AudioContext in a
+  discarded browsing context</title>
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<body></body>
+<script>
+let context;
+let childDOMException;
+setup(() => {
+  const frame = document.createElement('iframe');
+  document.body.appendChild(frame);
+  context = new frame.contentWindow.AudioContext();
+  childDOMException = frame.contentWindow.DOMException;
+  frame.remove();
+});
+
+promise_test((t) => promise_rejects_dom(t, 'InvalidStateError',
+                                        childDOMException, context.suspend()),
+             'suspend()');
+promise_test((t) => promise_rejects_dom(t, 'InvalidStateError',
+                                        childDOMException, context.resume()),
+             'resume()');
+promise_test((t) => promise_rejects_dom(t, 'InvalidStateError',
+                                        childDOMException, context.close()),
+             'close()');
+// decodeAudioData() is tested in audiocontext-detached-execution-context.html
+</script>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/resources/not-fully-active-helper.sub.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/resources/not-fully-active-helper.sub.html
new file mode 100644
index 0000000000..2654a2a504
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/resources/not-fully-active-helper.sub.html
@@ -0,0 +1,22 @@
+<!doctype html>
+<html>
+<iframe src="{{GET[childsrc]}}">
+</iframe>
+<script>
+const frame = document.getElementsByTagName('iframe')[0];
+const reply = op => window.parent.postMessage('DONE ' + op, '*');
+
+window.onmessage = e => {
+  switch (e.data) {
+  case 'REMOVE FRAME':
+    frame.remove();
+    reply(e.data);
+    break;
+  case 'NAVIGATE FRAME':
+    frame.srcdoc = '<html></html>';
+    frame.onload = () => reply(e.data);
+    break;
+  }
+};
+</script>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/suspend-after-construct.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/suspend-after-construct.html
new file mode 100644
index 0000000000..596a825c3d
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/suspend-after-construct.html
@@ -0,0 +1,72 @@
+<!doctype html>
+<title>Test AudioContext state updates with suspend() shortly after
+  construction</title>
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script>
+// A separate async_test is used for tracking state change counts so that it
+// can report excess changes after the promise_test for the iteration has
+// completed.
+const changeCountingTest = async_test('State change counting');
+
+const doTest = async (testCount) => {
+  const ctx = new AudioContext();
+  // Explicitly resume to get a promise to indicate whether the context
+  // successfully started running.
+  const resume = ctx.resume();
+  const suspend = ctx.suspend();
+  let stateChangesDone = new Promise((resolve) => {
+    ctx.onstatechange = () => {
+      ++ctx.stateChangeCount;
+      changeCountingTest.step(() => {
+        assert_less_than_equal(ctx.stateChangeCount,
+                               ctx.expectedStateChangeCount,
+                               `ctx ${testCount} state change count.`);
+        assert_equals(ctx.state, ctx.expectedState, `ctx ${testCount} state`);
+      });
+      if (ctx.stateChangeCount == ctx.totalStateChangeCount) {
+        resolve();
+      }
+    };
+  });
+  ctx.stateChangeCount = 0;
+  ctx.expectedStateChangeCount = 1;
+  ctx.expectedState = 'running';
+  ctx.totalStateChangeCount = 2;
+  let resumeState = 'pending';
+  resume.then(() => {
+    resumeState = 'fulfilled';
+    assert_equals(ctx.state, 'running', 'state on resume fulfilled.');
+  }).catch(() => {
+    // The resume() promise may be rejected if "Attempt to acquire system
+    // resources" fails.  The spec does not discuss the possibility of a
+    // subsequent suspend causing such a failure, but accept this as a
+    // reasonable behavior.
+    resumeState = 'rejected';
+    assert_equals(ctx.state, 'suspended', 'state on resume rejected.');
+    assert_equals(ctx.stateChangeCount, 0);
+    ctx.expectedStateChangeCount = 0;
+    stateChangesDone = Promise.resolve();
+  });
+  suspend.then(() => {
+    assert_not_equals(resumeState, 'pending',
+                      'resume promise should settle before suspend promise.')
+    if (resumeState == 'fulfilled') {
+      ++ctx.expectedStateChangeCount;
+    }
+    ctx.expectedState = 'suspended';
+    assert_equals(ctx.state, 'suspended', 'state on suspend fulfilled.');
+  });
+  await resume;
+  await suspend;
+  await stateChangesDone;
+};
+
+// Repeat the test because Gecko uses different code when there is more than
+// one AudioContext.  The third run provides time to check that no further
+// state changes from the second run are pending.
+for (const testCount of [1, 2, 3]) {
+  promise_test(() => { return doTest(testCount); }, `Iteration ${testCount}`);
+}
+promise_test(async () => changeCountingTest.done(), 'Stop waiting');
+</script>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/suspend-with-navigation.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/suspend-with-navigation.html
new file mode 100644
index 0000000000..b9328ae95d
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audiocontext-interface/suspend-with-navigation.html
@@ -0,0 +1,65 @@
+<!doctype html>
+<meta name="timeout" content="long">
+<title>AudioContext.suspend() with navigation</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="/common/utils.js"></script>
+<script src="/common/dispatcher/dispatcher.js"></script>
+<script src="/html/browsers/browsing-the-web/back-forward-cache/resources/helper.sub.js"></script>
+<script>
+'use strict';
+runBfcacheTest({
+  funcBeforeNavigation: async () => {
+    window.promise_event = (target, name) => {
+      return new Promise(resolve => target[`on${name}`] = resolve);
+    };
+    window.promise_source_ended = (audioCtx) => {
+      const source = new ConstantSourceNode(audioCtx);
+      source.start(0);
+      source.stop(audioCtx.currentTime + 1/audioCtx.sampleRate);
+      return promise_event(source, "ended");
+    };
+
+    window.suspended_ctx = new AudioContext();
+    // Perform the equivalent of test_driver.bless() to request a user gesture
+    // for when the test is run from a browser.  test_driver would need to be
+    // able to postMessage() to the test context, which is not available due
+    // to window.open() being called with noopener (for back/forward cache).
+    // Audio autoplay is expected to be allowed when run through webdriver
+    // from `wpt run`.
+    let button = document.createElement('button');
+    button.innerHTML = 'This test requires user interaction.<br />' +
+      'Please click here to allow AudioContext.';
+    document.body.appendChild(button);
+    button.addEventListener('click', () => {
+      document.body.removeChild(button);
+      suspended_ctx.resume();
+    }, {once: true});
+    // Wait for user gesture, if required.
+    await suspended_ctx.resume();
+    await suspended_ctx.suspend();
+    window.ended_promise = promise_source_ended(suspended_ctx);
+  },
+  funcAfterAssertion: async (pageA) => {
+    const state = await pageA.execute_script(() => suspended_ctx.state);
+    assert_equals(state, 'suspended', 'state after back()');
+    const first_ended = await pageA.execute_script(async () => {
+      // Wait for an ended event from a running AudioContext to provide enough
+      // time to check that the ended event has not yet been dispatched from
+      // the suspended ctx.
+      const running_ctx = new AudioContext();
+      await running_ctx.resume();
+      return Promise.race([
+        ended_promise.then(() => 'suspended_ctx'),
+        promise_source_ended(running_ctx).then(() => 'running_ctx'),
+      ]);
+    });
+    assert_equals(first_ended, 'running_ctx',
+                  'AudioContext of first ended event');
+    await pageA.execute_script(() => {
+      window.suspended_ctx.resume();
+      return ended_promise;
+    });
+  },
+}, 'suspend() with navigation');
+</script>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-channel-rules.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-channel-rules.html
new file mode 100644
index 0000000000..9067e6869b
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-channel-rules.html
@@ -0,0 +1,278 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      audionode-channel-rules.html
+    </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/mixing-rules.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+      let context = 0;
+      // Use a power of two to eliminate round-off converting frames to time.
+      let sampleRate = 32768;
+      let renderNumberOfChannels = 8;
+      let singleTestFrameLength = 8;
+      let testBuffers;
+
+      // A list of connections to an AudioNode input, each of which is to be
+      // used in one or more specific test cases.  Each element in the list is a
+      // string, with the number of connections corresponding to the length of
+      // the string, and each character in the string is from '1' to '8'
+      // representing a 1 to 8 channel connection (from an AudioNode output).
+
+      // For example, the string "128" means 3 connections, having 1, 2, and 8
+      // channels respectively.
+
+      let connectionsList = [
+        '1', '2', '3', '4', '5', '6', '7', '8', '11', '12', '14', '18', '111',
+        '122', '123', '124', '128'
+      ];
+
+      // A list of mixing rules, each of which will be tested against all of the
+      // connections in connectionsList.
+      let mixingRulesList = [
+        {
+          channelCount: 2,
+          channelCountMode: 'max',
+          channelInterpretation: 'speakers'
+        },
+        {
+          channelCount: 4,
+          channelCountMode: 'clamped-max',
+          channelInterpretation: 'speakers'
+        },
+
+        // Test up-down-mix to some explicit speaker layouts.
+        {
+          channelCount: 1,
+          channelCountMode: 'explicit',
+          channelInterpretation: 'speakers'
+        },
+        {
+          channelCount: 2,
+          channelCountMode: 'explicit',
+          channelInterpretation: 'speakers'
+        },
+        {
+          channelCount: 4,
+          channelCountMode: 'explicit',
+          channelInterpretation: 'speakers'
+        },
+        {
+          channelCount: 6,
+          channelCountMode: 'explicit',
+          channelInterpretation: 'speakers'
+        },
+
+        {
+          channelCount: 2,
+          channelCountMode: 'max',
+          channelInterpretation: 'discrete'
+        },
+        {
+          channelCount: 4,
+          channelCountMode: 'clamped-max',
+          channelInterpretation: 'discrete'
+        },
+        {
+          channelCount: 4,
+          channelCountMode: 'explicit',
+          channelInterpretation: 'discrete'
+        },
+        {
+          channelCount: 8,
+          channelCountMode: 'explicit',
+          channelInterpretation: 'discrete'
+        },
+      ];
+
+      let numberOfTests = mixingRulesList.length * connectionsList.length;
+
+      // Print out the information for an individual test case.
+      function printTestInformation(
+          testNumber, actualBuffer, expectedBuffer, frameLength, frameOffset) {
+        let actual = stringifyBuffer(actualBuffer, frameLength);
+        let expected =
+            stringifyBuffer(expectedBuffer, frameLength, frameOffset);
+        debug('TEST CASE #' + testNumber + '\n');
+        debug('actual channels:\n' + actual);
+        debug('expected channels:\n' + expected);
+      }
+
+      function scheduleTest(
+          testNumber, connections, channelCount, channelCountMode,
+          channelInterpretation) {
+        let mixNode = context.createGain();
+        mixNode.channelCount = channelCount;
+        mixNode.channelCountMode = channelCountMode;
+        mixNode.channelInterpretation = channelInterpretation;
+        mixNode.connect(context.destination);
+
+        for (let i = 0; i < connections.length; ++i) {
+          let connectionNumberOfChannels =
+              connections.charCodeAt(i) - '0'.charCodeAt(0);
+
+          let source = context.createBufferSource();
+          // Get a buffer with the right number of channels, converting from
+          // 1-based to 0-based index.
+          let buffer = testBuffers[connectionNumberOfChannels - 1];
+          source.buffer = buffer;
+          source.connect(mixNode);
+
+          // Start at the right offset.
+          let sampleFrameOffset = testNumber * singleTestFrameLength;
+          let time = sampleFrameOffset / sampleRate;
+          source.start(time);
+        }
+      }
+
+      function checkTestResult(
+          renderedBuffer, testNumber, connections, channelCount,
+          channelCountMode, channelInterpretation, should) {
+        let s = 'connections: ' + connections + ', ' + channelCountMode;
+
+        // channelCount is ignored in "max" mode.
+        if (channelCountMode == 'clamped-max' ||
+            channelCountMode == 'explicit') {
+          s += '(' + channelCount + ')';
+        }
+
+        s += ', ' + channelInterpretation;
+
+        let computedNumberOfChannels = computeNumberOfChannels(
+            connections, channelCount, channelCountMode);
+
+        // Create a zero-initialized silent AudioBuffer with
+        // computedNumberOfChannels.
+        let destBuffer = context.createBuffer(
+            computedNumberOfChannels, singleTestFrameLength,
+            context.sampleRate);
+
+        // Mix all of the connections into the destination buffer.
+        for (let i = 0; i < connections.length; ++i) {
+          let connectionNumberOfChannels =
+              connections.charCodeAt(i) - '0'.charCodeAt(0);
+          let sourceBuffer =
+              testBuffers[connectionNumberOfChannels - 1];  // convert from
+                                                            // 1-based to
+                                                            // 0-based index
+
+          if (channelInterpretation == 'speakers') {
+            speakersSum(sourceBuffer, destBuffer);
+          } else if (channelInterpretation == 'discrete') {
+            discreteSum(sourceBuffer, destBuffer);
+          } else {
+            alert('Invalid channel interpretation!');
+          }
+        }
+
+        // Use this when debugging mixing rules.
+        // printTestInformation(testNumber, renderedBuffer, destBuffer,
+        // singleTestFrameLength, sampleFrameOffset);
+
+        // Validate that destBuffer matches the rendered output.  We need to
+        // check the rendered output at a specific sample-frame-offset
+        // corresponding to the specific test case we're checking for based on
+        // testNumber.
+
+        let sampleFrameOffset = testNumber * singleTestFrameLength;
+        for (let c = 0; c < renderNumberOfChannels; ++c) {
+          let renderedData = renderedBuffer.getChannelData(c);
+          for (let frame = 0; frame < singleTestFrameLength; ++frame) {
+            let renderedValue = renderedData[frame + sampleFrameOffset];
+
+            let expectedValue = 0;
+            if (c < destBuffer.numberOfChannels) {
+              let expectedData = destBuffer.getChannelData(c);
+              expectedValue = expectedData[frame];
+            }
+
+            // We may need to add an epsilon in the comparison if we add more
+            // test vectors.
+            if (renderedValue != expectedValue) {
+              let message = s + 'rendered: ' + renderedValue +
+                  ' expected: ' + expectedValue + ' channel: ' + c +
+                  ' frame: ' + frame;
+              // testFailed(s);
+              should(renderedValue, s).beEqualTo(expectedValue);
+              return;
+            }
+          }
+        }
+
+        should(true, s).beTrue();
+      }
+
+      function checkResult(buffer, should) {
+        // Sanity check result.
+        should(buffer.length, 'Rendered number of frames')
+            .beEqualTo(numberOfTests * singleTestFrameLength);
+        should(buffer.numberOfChannels, 'Rendered number of channels')
+            .beEqualTo(renderNumberOfChannels);
+
+        // Check all the tests.
+        let testNumber = 0;
+        for (let m = 0; m < mixingRulesList.length; ++m) {
+          let mixingRules = mixingRulesList[m];
+          for (let i = 0; i < connectionsList.length; ++i, ++testNumber) {
+            checkTestResult(
+                buffer, testNumber, connectionsList[i],
+                mixingRules.channelCount, mixingRules.channelCountMode,
+                mixingRules.channelInterpretation, should);
+          }
+        }
+      }
+
+      audit.define(
+          {label: 'test', description: 'Channel mixing rules for AudioNodes'},
+          function(task, should) {
+
+            // Create 8-channel offline audio context.  Each test will render 8
+            // sample-frames starting at sample-frame position testNumber * 8.
+            let totalFrameLength = numberOfTests * singleTestFrameLength;
+            context = new OfflineAudioContext(
+                renderNumberOfChannels, totalFrameLength, sampleRate);
+
+            // Set destination to discrete mixing.
+            context.destination.channelCount = renderNumberOfChannels;
+            context.destination.channelCountMode = 'explicit';
+            context.destination.channelInterpretation = 'discrete';
+
+            // Create test buffers from 1 to 8 channels.
+            testBuffers = new Array();
+            for (let i = 0; i < renderNumberOfChannels; ++i) {
+              testBuffers[i] = createShiftedImpulseBuffer(
+                  context, i + 1, singleTestFrameLength);
+            }
+
+            // Schedule all the tests.
+            let testNumber = 0;
+            for (let m = 0; m < mixingRulesList.length; ++m) {
+              let mixingRules = mixingRulesList[m];
+              for (let i = 0; i < connectionsList.length; ++i, ++testNumber) {
+                scheduleTest(
+                    testNumber, connectionsList[i], mixingRules.channelCount,
+                    mixingRules.channelCountMode,
+                    mixingRules.channelInterpretation);
+              }
+            }
+
+            // Render then check results.
+            // context.oncomplete = checkResult;
+            context.startRendering().then(buffer => {
+              checkResult(buffer, should);
+              task.done();
+            });
+            ;
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-connect-method-chaining.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-connect-method-chaining.html
new file mode 100644
index 0000000000..02caea667b
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-connect-method-chaining.html
@@ -0,0 +1,165 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      audionode-connect-method-chaining.html
+    </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">
+      // AudioNode dictionary with associated arguments.
+      let nodeDictionary = [
+        {name: 'Analyser'}, {name: 'BiquadFilter'}, {name: 'BufferSource'},
+        {name: 'ChannelMerger', args: [6]},
+        {name: 'ChannelSplitter', args: [6]}, {name: 'Convolver'},
+        {name: 'Delay', args: []}, {name: 'DynamicsCompressor'}, {name: 'Gain'},
+        {name: 'Oscillator'}, {name: 'Panner'},
+        {name: 'ScriptProcessor', args: [512, 1, 1]}, {name: 'StereoPanner'},
+        {name: 'WaveShaper'}
+      ];
+
+
+      function verifyReturnedNode(should, config) {
+        should(
+            config.destination === config.returned,
+            'The return value of ' + config.desc + ' matches the destination ' +
+                config.returned.constructor.name)
+            .beEqualTo(true);
+      }
+
+      // Test utility for batch method checking: in order to test 3 method
+      // signatures, so we create 3 dummy destinations.
+      // 1) .connect(GainNode)
+      // 2) .connect(BiquadFilterNode, output)
+      // 3) .connect(ChannelMergerNode, output, input)
+      function testConnectMethod(context, should, options) {
+        let source =
+            context['create' + options.name].apply(context, options.args);
+        let sourceName = source.constructor.name;
+
+        let destination1 = context.createGain();
+        verifyReturnedNode(should, {
+          source: source,
+          destination: destination1,
+          returned: source.connect(destination1),
+          desc: sourceName + '.connect(' + destination1.constructor.name + ')'
+        });
+
+        let destination2 = context.createBiquadFilter();
+        verifyReturnedNode(should, {
+          source: source,
+          destination: destination2,
+          returned: source.connect(destination2, 0),
+          desc:
+              sourceName + '.connect(' + destination2.constructor.name + ', 0)'
+        });
+
+        let destination3 = context.createChannelMerger();
+        verifyReturnedNode(should, {
+          source: source,
+          destination: destination3,
+          returned: source.connect(destination3, 0, 1),
+          desc: sourceName + '.connect(' + destination3.constructor.name +
+              ', 0, 1)'
+        });
+      }
+
+
+      let audit = Audit.createTaskRunner();
+
+      // Task: testing entries from the dictionary.
+      audit.define('from-dictionary', (task, should) => {
+        let context = new AudioContext();
+
+        for (let i = 0; i < nodeDictionary.length; i++)
+          testConnectMethod(context, should, nodeDictionary[i]);
+
+        task.done();
+      });
+
+      // Task: testing Media* nodes.
+      audit.define('media-group', (task, should) => {
+        let context = new AudioContext();
+
+        // Test MediaElementSourceNode needs an <audio> element.
+        let mediaElement = document.createElement('audio');
+        testConnectMethod(
+            context, should,
+            {name: 'MediaElementSource', args: [mediaElement]});
+
+        // MediaStreamAudioDestinationNode has no output so it connect method
+        // chaining isn't possible.
+
+        // MediaStreamSourceNode requires 'stream' object to be constructed,
+        // which is a part of MediaStreamDestinationNode.
+        let streamDestination = context.createMediaStreamDestination();
+        let stream = streamDestination.stream;
+        testConnectMethod(
+            context, should, {name: 'MediaStreamSource', args: [stream]});
+
+        task.done();
+      });
+
+      // Task: test the exception thrown by invalid operation.
+      audit.define('invalid-operation', (task, should) => {
+        let contextA = new AudioContext();
+        let contextB = new AudioContext();
+        let gain1 = contextA.createGain();
+        let gain2 = contextA.createGain();
+
+        // Test if the first connection throws correctly. The first gain node
+        // does not have the second output, so it should throw.
+        should(function() {
+          gain1.connect(gain2, 1).connect(contextA.destination);
+        }, 'Connecting with an invalid output').throw(DOMException, 'IndexSizeError');
+
+        // Test if the second connection throws correctly. The contextB's
+        // destination is not compatible with the nodes from contextA, thus the
+        // first connection succeeds but the second one should throw.
+        should(
+            function() {
+              gain1.connect(gain2).connect(contextB.destination);
+            },
+            'Connecting to a node from the different context')
+            .throw(DOMException, 'InvalidAccessError');
+
+        task.done();
+      });
+
+      // Task: verify if the method chaining actually works.
+      audit.define('verification', (task, should) => {
+        // We pick the lowest sample rate allowed to run the test efficiently.
+        let context = new OfflineAudioContext(1, 128, 8000);
+
+        let constantBuffer = createConstantBuffer(context, 1, 1.0);
+
+        let source = context.createBufferSource();
+        source.buffer = constantBuffer;
+        source.loop = true;
+
+        let gain1 = context.createGain();
+        gain1.gain.value = 0.5;
+        let gain2 = context.createGain();
+        gain2.gain.value = 0.25;
+
+        source.connect(gain1).connect(gain2).connect(context.destination);
+        source.start();
+
+        context.startRendering()
+            .then(function(buffer) {
+              should(
+                  buffer.getChannelData(0),
+                  'The output of chained connection of gain nodes')
+                  .beConstantValueOf(0.125);
+            })
+            .then(() => task.done());
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-connect-order.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-connect-order.html
new file mode 100644
index 0000000000..eca15dedfa
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-connect-order.html
@@ -0,0 +1,77 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      audionode-connect-order.html
+    </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 audit = Audit.createTaskRunner();
+      let sampleRate = 44100.0;
+      let renderLengthSeconds = 0.125;
+      let delayTimeSeconds = 0.1;
+
+      function createSinWaveBuffer(context, lengthInSeconds, frequency) {
+        let audioBuffer =
+            context.createBuffer(1, lengthInSeconds * sampleRate, sampleRate);
+
+        let n = audioBuffer.length;
+        let data = audioBuffer.getChannelData(0);
+
+        for (let i = 0; i < n; ++i) {
+          data[i] = Math.sin(frequency * 2 * Math.PI * i / sampleRate);
+        }
+
+        return audioBuffer;
+      }
+
+      audit.define(
+          {
+            label: 'Test connections',
+            description:
+                'AudioNode connection order doesn\'t trigger assertion errors'
+          },
+          function(task, should) {
+            // Create offline audio context.
+            let context = new OfflineAudioContext(
+                1, sampleRate * renderLengthSeconds, sampleRate);
+            let toneBuffer =
+                createSinWaveBuffer(context, renderLengthSeconds, 880);
+
+            let bufferSource = context.createBufferSource();
+            bufferSource.buffer = toneBuffer;
+            bufferSource.connect(context.destination);
+
+            let delay = context.createDelay();
+            delay.delayTime.value = delayTimeSeconds;
+
+            // We connect delay node to gain node before anything is connected
+            // to delay node itself.  We do this because we try to trigger the
+            // ASSERT which might be fired due to AudioNode connection order,
+            // especially when gain node and delay node is involved e.g.
+            // https://bugs.webkit.org/show_bug.cgi?id=76685.
+
+            should(() => {
+              let gain = context.createGain();
+              gain.connect(context.destination);
+              delay.connect(gain);
+            }, 'Connecting nodes').notThrow();
+
+            bufferSource.start(0);
+
+            let promise = context.startRendering();
+
+            should(promise, 'OfflineContext startRendering()')
+                .beResolved()
+                .then(task.done.bind(task));
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-connect-return-value.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-connect-return-value.html
new file mode 100644
index 0000000000..3af44fb7af
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-connect-return-value.html
@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<title>Test the return value of connect when connecting two AudioNodes</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+test(function(t) {
+  var context = new OfflineAudioContext(1, 1, 44100);
+  var g1 = context.createGain();
+  var g2 = context.createGain();
+  var rv = g1.connect(g2);
+  assert_equals(rv, g2);
+  var rv = g1.connect(g2);
+  assert_equals(rv, g2);
+}, "connect should return the node connected to.");
+</script>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-disconnect-audioparam.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-disconnect-audioparam.html
new file mode 100644
index 0000000000..0b09edd4a7
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-disconnect-audioparam.html
@@ -0,0 +1,221 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      audionode-disconnect-audioparam.html
+    </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 renderQuantum = 128;
+
+      let sampleRate = 44100;
+      let renderDuration = 0.5;
+      let disconnectTime = 0.5 * renderDuration;
+
+      let audit = Audit.createTaskRunner();
+
+      // Calculate the index for disconnection.
+      function getDisconnectIndex(disconnectTime) {
+        let disconnectIndex = disconnectTime * sampleRate;
+        disconnectIndex = renderQuantum *
+            Math.floor((disconnectIndex + renderQuantum - 1) / renderQuantum);
+        return disconnectIndex;
+      }
+
+      // Get the index of value change.
+      function getValueChangeIndex(array, targetValue) {
+        return array.findIndex(function(element, index) {
+          if (element === targetValue)
+            return true;
+        });
+      }
+
+      // Task 1: test disconnect(AudioParam) method.
+      audit.define('disconnect(AudioParam)', (task, should) => {
+        // Creates a buffer source with value [1] and then connect it to two
+        // gain nodes in series. The output of the buffer source is lowered by
+        // half
+        // (* 0.5) and then connected to two |.gain| AudioParams in each gain
+        // node.
+        //
+        //  (1) bufferSource => gain1 => gain2
+        //  (2) bufferSource => half => gain1.gain
+        //  (3) half => gain2.gain
+        //
+        // This graph should produce the output of 2.25 (= 1 * 1.5 * 1.5). After
+        // disconnecting (3), it should produce 1.5.
+        let context =
+            new OfflineAudioContext(1, renderDuration * sampleRate, sampleRate);
+        let source = context.createBufferSource();
+        let buffer1ch = createConstantBuffer(context, 1, 1);
+        let half = context.createGain();
+        let gain1 = context.createGain();
+        let gain2 = context.createGain();
+
+        source.buffer = buffer1ch;
+        source.loop = true;
+        half.gain.value = 0.5;
+
+        source.connect(gain1);
+        gain1.connect(gain2);
+        gain2.connect(context.destination);
+        source.connect(half);
+
+        // Connecting |half| to both |gain1.gain| and |gain2.gain| amplifies the
+        // signal by 2.25 (= 1.5 * 1.5) because each gain node amplifies the
+        // signal by 1.5 (= 1.0 + 0.5).
+        half.connect(gain1.gain);
+        half.connect(gain2.gain);
+
+        source.start();
+
+        // Schedule the disconnection at the half of render duration.
+        context.suspend(disconnectTime).then(function() {
+          half.disconnect(gain2.gain);
+          context.resume();
+        });
+
+        context.startRendering()
+            .then(function(buffer) {
+              let channelData = buffer.getChannelData(0);
+              let disconnectIndex = getDisconnectIndex(disconnectTime);
+              let valueChangeIndex = getValueChangeIndex(channelData, 1.5);
+
+              // Expected values are: 1 * 1.5 * 1.5 -> 1 * 1.5 = [2.25, 1.5]
+              should(channelData, 'Channel #0').containValues([2.25, 1.5]);
+              should(valueChangeIndex, 'The index of value change')
+                  .beEqualTo(disconnectIndex);
+            })
+            .then(() => task.done());
+      });
+
+      // Task 2: test disconnect(AudioParam, output) method.
+      audit.define('disconnect(AudioParam, output)', (task, should) => {
+        // Create a 2-channel buffer source with [1, 2] in each channel and
+        // make a serial connection through gain1 and gain 2. The make the
+        // buffer source half with a gain node and connect it to a 2-output
+        // splitter. Connect each output to 2 gain AudioParams respectively.
+        //
+        //    (1) bufferSource => gain1 => gain2
+        //    (2) bufferSource => half => splitter(2)
+        //    (3) splitter#0 => gain1.gain
+        //    (4) splitter#1 => gain2.gain
+        //
+        // This graph should produce 3 (= 1 * 1.5 * 2) and 6 (= 2 * 1.5 * 2) for
+        // each channel. After disconnecting (4), it should output 1.5 and 3.
+        let context =
+            new OfflineAudioContext(2, renderDuration * sampleRate, sampleRate);
+        let source = context.createBufferSource();
+        let buffer2ch = createConstantBuffer(context, 1, [1, 2]);
+        let splitter = context.createChannelSplitter(2);
+        let half = context.createGain();
+        let gain1 = context.createGain();
+        let gain2 = context.createGain();
+
+        source.buffer = buffer2ch;
+        source.loop = true;
+        half.gain.value = 0.5;
+
+        source.connect(gain1);
+        gain1.connect(gain2);
+        gain2.connect(context.destination);
+
+        // |source| originally is [1, 2] but it becomes [0.5, 1] after 0.5 gain.
+        // Each splitter's output will be applied to |gain1.gain| and
+        // |gain2.gain| respectively in an additive fashion.
+        source.connect(half);
+        half.connect(splitter);
+
+        // This amplifies the signal by 1.5. (= 1.0 + 0.5)
+        splitter.connect(gain1.gain, 0);
+
+        // This amplifies the signal by 2. (= 1.0 + 1.0)
+        splitter.connect(gain2.gain, 1);
+
+        source.start();
+
+        // Schedule the disconnection at the half of render duration.
+        context.suspend(disconnectTime).then(function() {
+          splitter.disconnect(gain2.gain, 1);
+          context.resume();
+        });
+
+        context.startRendering()
+            .then(function(buffer) {
+              let channelData0 = buffer.getChannelData(0);
+              let channelData1 = buffer.getChannelData(1);
+
+              let disconnectIndex = getDisconnectIndex(disconnectTime);
+              let valueChangeIndexCh0 = getValueChangeIndex(channelData0, 1.5);
+              let valueChangeIndexCh1 = getValueChangeIndex(channelData1, 3);
+
+              // Expected values are: 1 * 1.5 * 2 -> 1 * 1.5 = [3, 1.5]
+              should(channelData0, 'Channel #0').containValues([3, 1.5]);
+              should(
+                  valueChangeIndexCh0,
+                  'The index of value change in channel #0')
+                  .beEqualTo(disconnectIndex);
+
+              // Expected values are: 2 * 1.5 * 2 -> 2 * 1.5 = [6, 3]
+              should(channelData1, 'Channel #1').containValues([6, 3]);
+              should(
+                  valueChangeIndexCh1,
+                  'The index of value change in channel #1')
+                  .beEqualTo(disconnectIndex);
+            })
+            .then(() => task.done());
+      });
+
+      // Task 3: exception checks.
+      audit.define('exceptions', (task, should) => {
+        let context = new AudioContext();
+        let gain1 = context.createGain();
+        let splitter = context.createChannelSplitter(2);
+        let gain2 = context.createGain();
+        let gain3 = context.createGain();
+
+        // Connect a splitter to gain nodes and merger so we can test the
+        // possible ways of disconnecting the nodes to verify that appropriate
+        // exceptions are thrown.
+        gain1.connect(splitter);
+        splitter.connect(gain2.gain, 0);
+        splitter.connect(gain3.gain, 1);
+        gain2.connect(gain3);
+        gain3.connect(context.destination);
+
+        // gain1 is not connected to gain3.gain. Exception should be thrown.
+        should(
+            function() {
+              gain1.disconnect(gain3.gain);
+            },
+            'gain1.disconnect(gain3.gain)')
+            .throw(DOMException, 'InvalidAccessError');
+
+        // When the output index is good but the destination is invalid.
+        should(
+            function() {
+              splitter.disconnect(gain1.gain, 1);
+            },
+            'splitter.disconnect(gain1.gain, 1)')
+            .throw(DOMException, 'InvalidAccessError');
+
+        // When both arguments are wrong, throw IndexSizeError first.
+        should(
+            function() {
+              splitter.disconnect(gain1.gain, 2);
+            },
+            'splitter.disconnect(gain1.gain, 2)')
+            .throw(DOMException, 'IndexSizeError');
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-disconnect.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-disconnect.html
new file mode 100644
index 0000000000..65b93222d1
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-disconnect.html
@@ -0,0 +1,298 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      audionode-disconnect.html
+    </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 audit = Audit.createTaskRunner();
+
+      // Task 1: test disconnect() method.
+      audit.define('disconnect()', (task, should) => {
+
+        // Connect a source to multiple gain nodes, each connected to the
+        // destination. Then disconnect the source. The expected output should
+        // be all zeros since the source was disconnected.
+        let context = new OfflineAudioContext(1, 128, 44100);
+        let source = context.createBufferSource();
+        let buffer1ch = createConstantBuffer(context, 128, [1]);
+        let gain1 = context.createGain();
+        let gain2 = context.createGain();
+        let gain3 = context.createGain();
+
+        source.buffer = buffer1ch;
+
+        source.connect(gain1);
+        source.connect(gain2);
+        source.connect(gain3);
+        gain1.connect(context.destination);
+        gain2.connect(context.destination);
+        gain3.connect(context.destination);
+        source.start();
+
+        // This disconnects everything.
+        source.disconnect();
+
+        context.startRendering()
+            .then(function(buffer) {
+
+              // With everything disconnected, the result should be zero.
+              should(buffer.getChannelData(0), 'Channel #0')
+                  .beConstantValueOf(0);
+
+            })
+            .then(() => task.done());
+      });
+
+      // Task 2: test disconnect(output) method.
+      audit.define('disconnect(output)', (task, should) => {
+
+        // Create multiple connections from each output of a ChannelSplitter
+        // to a gain node. Then test if disconnecting a single output of
+        // splitter is actually disconnected.
+        let context = new OfflineAudioContext(1, 128, 44100);
+        let source = context.createBufferSource();
+        let buffer3ch = createConstantBuffer(context, 128, [1, 2, 3]);
+        let splitter = context.createChannelSplitter(3);
+        let sum = context.createGain();
+
+        source.buffer = buffer3ch;
+
+        source.connect(splitter);
+        splitter.connect(sum, 0);
+        splitter.connect(sum, 1);
+        splitter.connect(sum, 2);
+        sum.connect(context.destination);
+        source.start();
+
+        // This disconnects the second output.
+        splitter.disconnect(1);
+
+        context.startRendering()
+            .then(function(buffer) {
+
+              // The rendered channel should contain 4. (= 1 + 0 + 3)
+              should(buffer.getChannelData(0), 'Channel #0')
+                  .beConstantValueOf(4);
+
+            })
+            .then(() => task.done());
+      });
+
+      // Task 3: test disconnect(AudioNode) method.
+      audit.define('disconnect(AudioNode)', (task, should) => {
+
+        // Connect a source to multiple gain nodes. Then test if disconnecting a
+        // single destination selectively works correctly.
+        let context = new OfflineAudioContext(1, 128, 44100);
+        let source = context.createBufferSource();
+        let buffer1ch = createConstantBuffer(context, 128, [1]);
+        let gain1 = context.createGain();
+        let gain2 = context.createGain();
+        let gain3 = context.createGain();
+        let orphan = context.createGain();
+
+        source.buffer = buffer1ch;
+
+        source.connect(gain1);
+        source.connect(gain2);
+        source.connect(gain3);
+        gain1.connect(context.destination);
+        gain2.connect(context.destination);
+        gain3.connect(context.destination);
+        source.start();
+
+        source.disconnect(gain2);
+
+        context.startRendering()
+            .then(function(buffer) {
+
+              // The |sum| gain node should produce value 2. (1 + 0 + 1 = 2)
+              should(buffer.getChannelData(0), 'Channel #0')
+                  .beConstantValueOf(2);
+
+            })
+            .then(() => task.done());
+      });
+
+      // Task 4: test disconnect(AudioNode, output) method.
+      audit.define('disconnect(AudioNode, output)', (task, should) => {
+
+        // Connect a buffer with 2 channels with each containing 1 and 2
+        // respectively to a ChannelSplitter, then connect the splitter to 2
+        // gain nodes as shown below:
+        //   (1) splitter#0 => gain1
+        //   (2) splitter#0 => gain2
+        //   (3) splitter#1 => gain2
+        // Then disconnect (2) and verify if the selective disconnection on a
+        // specified output of the destination node works correctly.
+        let context = new OfflineAudioContext(1, 128, 44100);
+        let source = context.createBufferSource();
+        let buffer2ch = createConstantBuffer(context, 128, [1, 2]);
+        let splitter = context.createChannelSplitter(2);
+        let gain1 = context.createGain();
+        let gain2 = context.createGain();
+
+        source.buffer = buffer2ch;
+
+        source.connect(splitter);
+        splitter.connect(gain1, 0);  // gain1 gets channel 0.
+        splitter.connect(gain2, 0);  // gain2 sums channel 0 and 1.
+        splitter.connect(gain2, 1);
+        gain1.connect(context.destination);
+        gain2.connect(context.destination);
+        source.start();
+
+        splitter.disconnect(gain2, 0);  // Now gain2 gets [2]
+
+        context.startRendering()
+            .then(function(buffer) {
+
+              // The sum of gain1 and gain2 should produce value 3. (= 1 + 2)
+              should(buffer.getChannelData(0), 'Channel #0')
+                  .beConstantValueOf(3);
+
+            })
+            .then(() => task.done());
+      });
+
+      // Task 5: test disconnect(AudioNode, output, input) method.
+      audit.define('disconnect(AudioNode, output, input)', (task, should) => {
+
+        // Create a 3-channel buffer with [1, 2, 3] in each channel and then
+        // pass it through a splitter and a merger. Each input/output of the
+        // splitter and the merger is connected in a sequential order as shown
+        // below.
+        //   (1) splitter#0 => merger#0
+        //   (2) splitter#1 => merger#1
+        //   (3) splitter#2 => merger#2
+        // Then disconnect (3) and verify if each channel contains [1] and [2]
+        // respectively.
+        let context = new OfflineAudioContext(3, 128, 44100);
+        let source = context.createBufferSource();
+        let buffer3ch = createConstantBuffer(context, 128, [1, 2, 3]);
+        let splitter = context.createChannelSplitter(3);
+        let merger = context.createChannelMerger(3);
+
+        source.buffer = buffer3ch;
+
+        source.connect(splitter);
+        splitter.connect(merger, 0, 0);
+        splitter.connect(merger, 1, 1);
+        splitter.connect(merger, 2, 2);
+        merger.connect(context.destination);
+        source.start();
+
+        splitter.disconnect(merger, 2, 2);
+
+        context.startRendering()
+            .then(function(buffer) {
+
+              // Each channel should have 1, 2, and 0 respectively.
+              should(buffer.getChannelData(0), 'Channel #0')
+                  .beConstantValueOf(1);
+              should(buffer.getChannelData(1), 'Channel #1')
+                  .beConstantValueOf(2);
+              should(buffer.getChannelData(2), 'Channel #2')
+                  .beConstantValueOf(0);
+
+            })
+            .then(() => task.done());
+      });
+
+      // Task 6: exception checks.
+      audit.define('exceptions', (task, should) => {
+        let context = new OfflineAudioContext(2, 128, 44100);
+        let gain1 = context.createGain();
+        let splitter = context.createChannelSplitter(2);
+        let merger = context.createChannelMerger(2);
+        let gain2 = context.createGain();
+        let gain3 = context.createGain();
+
+        // Connect a splitter to gain nodes and merger so we can test the
+        // possible ways of disconnecting the nodes to verify that appropriate
+        // exceptions are thrown.
+        gain1.connect(splitter);
+        splitter.connect(gain2, 0);
+        splitter.connect(gain3, 1);
+        splitter.connect(merger, 0, 0);
+        splitter.connect(merger, 1, 1);
+        gain2.connect(gain3);
+        gain3.connect(context.destination);
+        merger.connect(context.destination);
+
+        // There is no output #2. An exception should be thrown.
+        should(function() {
+          splitter.disconnect(2);
+        }, 'splitter.disconnect(2)').throw(DOMException, 'IndexSizeError');
+
+        // Disconnecting the output already disconnected should not throw.
+        should(function() {
+          splitter.disconnect(1);
+          splitter.disconnect(1);
+        }, 'Disconnecting a connection twice').notThrow();
+
+        // gain1 is not connected gain2. An exception should be thrown.
+        should(function() {
+          gain1.disconnect(gain2);
+        }, 'gain1.disconnect(gain2)').throw(DOMException, 'InvalidAccessError');
+
+        // gain1 and gain3 are not connected. An exception should be thrown.
+        should(function() {
+          gain1.disconnect(gain3);
+        }, 'gain1.disconnect(gain3)').throw(DOMException, 'InvalidAccessError');
+
+        // There is no output #2 in the splitter. An exception should be thrown.
+        should(function() {
+          splitter.disconnect(gain2, 2);
+        }, 'splitter.disconnect(gain2, 2)').throw(DOMException, 'IndexSizeError');
+
+        // The splitter and gain1 are not connected. An exception should be
+        // thrown.
+        should(function() {
+          splitter.disconnect(gain1, 0);
+        }, 'splitter.disconnect(gain1, 0)').throw(DOMException, 'InvalidAccessError');
+
+        // The splitter output #0 and the gain3 output #0 are not connected. An
+        // exception should be thrown.
+        should(function() {
+          splitter.disconnect(gain3, 0, 0);
+        }, 'splitter.disconnect(gain3, 0, 0)').throw(DOMException, 'InvalidAccessError');
+
+        // The output index is out of bound. An exception should be thrown.
+        should(function() {
+          splitter.disconnect(merger, 3, 0);
+        }, 'splitter.disconnect(merger, 3, 0)').throw(DOMException, 'IndexSizeError');
+
+        task.done();
+      });
+
+      audit.define('disabled-outputs', (task, should) => {
+        // See crbug.com/656652
+        let context = new OfflineAudioContext(2, 1024, 44100);
+        let g1 = context.createGain();
+        let g2 = context.createGain();
+        g1.connect(g2);
+        g1.disconnect(g2);
+        let g3 = context.createGain();
+        g2.connect(g3);
+        g1.connect(g2);
+        context.startRendering()
+            .then(function() {
+              // If we make it here, we passed.
+              should(true, 'Disabled outputs handled')
+                  .message('correctly', 'inccorrectly');
+            })
+            .then(() => task.done());
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-iframe.window.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-iframe.window.js
new file mode 100644
index 0000000000..89bdf2aa98
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode-iframe.window.js
@@ -0,0 +1,14 @@
+test(function() {
+  const iframe =
+      document.createElementNS('http://www.w3.org/1999/xhtml', 'iframe');
+  document.body.appendChild(iframe);
+
+  // Create AudioContext and AudioNode from iframe
+  const context = new iframe.contentWindow.AudioContext();
+  const source = context.createOscillator();
+  source.connect(context.destination);
+
+  // AudioContext should be put closed state after iframe destroyed
+  document.body.removeChild(iframe);
+  assert_equals(context.state, 'closed');
+}, 'Call a constructor from iframe page and then destroy the iframe');
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode.html
new file mode 100644
index 0000000000..0b57d27e8e
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/audionode.html
@@ -0,0 +1,93 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      audionode.html
+    </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>
+    <div id="description"></div>
+    <div id="console"></div>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      let context = 0;
+      let context2 = 0;
+      let context3 = 0;
+
+      audit.define(
+          {label: 'test', description: 'Basic tests for AudioNode API.'},
+          function(task, should) {
+
+            context = new AudioContext();
+            window.audioNode = context.createBufferSource();
+
+            // Check input and output numbers of AudioSourceNode.
+            should(audioNode.numberOfInputs, 'AudioBufferSource.numberOfInputs')
+                .beEqualTo(0);
+            should(
+                audioNode.numberOfOutputs, 'AudioBufferSource.numberOfOutputs')
+                .beEqualTo(1);
+
+            // Check input and output numbers of AudioDestinationNode
+            should(
+                context.destination.numberOfInputs,
+                'AudioContext.destination.numberOfInputs')
+                .beEqualTo(1);
+            should(
+                context.destination.numberOfOutputs,
+                'AudioContext.destination.numberOfOutputs')
+                .beEqualTo(0);
+
+            // Try calling connect() method with illegal values.
+            should(
+                () => audioNode.connect(0, 0, 0), 'audioNode.connect(0, 0, 0)')
+                .throw(TypeError);
+            should(
+                () => audioNode.connect(null, 0, 0),
+                'audioNode.connect(null, 0, 0)')
+                .throw(TypeError);
+            should(
+                () => audioNode.connect(context.destination, 5, 0),
+                'audioNode.connect(context.destination, 5, 0)')
+                .throw(DOMException, 'IndexSizeError');
+            should(
+                () => audioNode.connect(context.destination, 0, 5),
+                'audioNode.connect(context.destination, 0, 5)')
+                .throw(DOMException, 'IndexSizeError');
+
+            should(
+                () => audioNode.connect(context.destination, 0, 0),
+                'audioNode.connect(context.destination, 0, 0)')
+                .notThrow();
+
+            // Create a new context and try to connect the other context's node
+            // to this one.
+            context2 = new AudioContext();
+            should(
+                () => window.audioNode.connect(context2.destination),
+                'Connecting a node to a different context')
+                .throw(DOMException, 'InvalidAccessError');
+
+            // 3-arg AudioContext doesn't create an offline context anymore.
+            should(
+                () => context3 = new AudioContext(1, 44100, 44100),
+                'context3 = new AudioContext(1, 44100, 44100)')
+                .throw(TypeError);
+
+            // Ensure it is an EventTarget
+            should(
+                audioNode instanceof EventTarget, 'AudioNode is an EventTarget')
+                .beTrue();
+
+            task.done();
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/channel-mode-interp-basic.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/channel-mode-interp-basic.html
new file mode 100644
index 0000000000..35cfca8e4e
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/channel-mode-interp-basic.html
@@ -0,0 +1,66 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Setting of channelCountMode and channelInterpretation
+    </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">
+      // Fairly arbitrary sample rate and number of frames, except the number of
+      // frames should be more than a few render quantums.
+      let sampleRate = 16000;
+      let renderFrames = 10 * 128;
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define('interp', (task, should) => {
+        let context = new OfflineAudioContext(1, renderFrames, sampleRate);
+        let node = context.createGain();
+
+        // Set a new interpretation and verify that it changed.
+        node.channelInterpretation = 'discrete';
+        let value = node.channelInterpretation;
+        should(value, 'node.channelInterpretation').beEqualTo('discrete');
+        node.connect(context.destination);
+
+        context.startRendering()
+            .then(function(buffer) {
+              // After rendering, the value should have been changed.
+              should(
+                  node.channelInterpretation,
+                  'After rendering node.channelInterpretation')
+                  .beEqualTo('discrete');
+            })
+            .then(() => task.done());
+      });
+
+      audit.define('mode', (task, should) => {
+        let context = new OfflineAudioContext(1, renderFrames, sampleRate);
+        let node = context.createGain();
+
+        // Set a new mode and verify that it changed.
+        node.channelCountMode = 'explicit';
+        let value = node.channelCountMode;
+        should(value, 'node.channelCountMode').beEqualTo('explicit');
+        node.connect(context.destination);
+
+        context.startRendering()
+            .then(function(buffer) {
+              // After rendering, the value should have been changed.
+              should(
+                  node.channelCountMode,
+                  'After rendering node.channelCountMode')
+                  .beEqualTo('explicit');
+            })
+            .then(() => task.done());
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/different-contexts.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/different-contexts.html
new file mode 100644
index 0000000000..f763d34787
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audionode-interface/different-contexts.html
@@ -0,0 +1,101 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Connections and disconnections with different contexts
+    </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>
+      let audit = Audit.createTaskRunner();
+
+      // Different contexts to be used for testing.
+      let c1;
+      let c2;
+
+      audit.define(
+          {label: 'setup', description: 'Contexts for testing'},
+          (task, should) => {
+            should(() => {c1 = new AudioContext()}, 'c1 = new AudioContext()')
+                .notThrow();
+            should(() => {c2 = new AudioContext()}, 'c2 = new AudioContext()')
+                .notThrow();
+            task.done();
+          });
+
+      audit.define(
+          {label: 'Test 1', description: 'Connect nodes between contexts'},
+          (task, should) => {
+            let g1;
+            let g2;
+            should(
+                () => {g1 = new GainNode(c1)}, 'Test 1: g1 = new GainNode(c1)')
+                .notThrow();
+            should(
+                () => {g2 = new GainNode(c2)}, 'Test 1: g2 = new GainNode(c2)')
+                .notThrow();
+            should(() => {g2.connect(g1)}, 'Test 1: g2.connect(g1)')
+                .throw(DOMException, 'InvalidAccessError');
+            task.done();
+          });
+
+      audit.define(
+          {label: 'Test 2', description: 'Connect AudioParam between contexts'},
+          (task, should) => {
+            let g1;
+            let g2;
+            should(
+                () => {g1 = new GainNode(c1)}, 'Test 2: g1 = new GainNode(c1)')
+                .notThrow();
+            should(
+                () => {g2 = new GainNode(c2)}, 'Test 2: g2 = new GainNode(c2)')
+                .notThrow();
+            should(() => {g2.connect(g1.gain)}, 'Test 2: g2.connect(g1.gain)')
+                .throw(DOMException, 'InvalidAccessError');
+            task.done();
+          });
+
+      audit.define(
+          {label: 'Test 3', description: 'Disconnect nodes between contexts'},
+          (task, should) => {
+            let g1;
+            let g2;
+            should(
+                () => {g1 = new GainNode(c1)}, 'Test 3: g1 = new GainNode(c1)')
+                .notThrow();
+            should(
+                () => {g2 = new GainNode(c2)}, 'Test 3: g2 = new GainNode(c2)')
+                .notThrow();
+            should(() => {g2.disconnect(g1)}, 'Test 3: g2.disconnect(g1)')
+                .throw(DOMException, 'InvalidAccessError');
+            task.done();
+          });
+
+      audit.define(
+          {
+            label: 'Test 4',
+            description: 'Disconnect AudioParam between contexts'
+          },
+          (task, should) => {
+            let g1;
+            let g2;
+            should(
+                () => {g1 = new GainNode(c1)}, 'Test 4: g1 = new GainNode(c1)')
+                .notThrow();
+            should(
+                () => {g2 = new GainNode(c2)}, 'Test 4: g2 = new GainNode(c2)')
+                .notThrow();
+            should(
+                () => {g2.disconnect(g1.gain)}, 'Test 4: g2.connect(g1.gain)')
+                .throw(DOMException, 'InvalidAccessError');
+            task.done();
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/adding-events.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/adding-events.html
new file mode 100644
index 0000000000..ab527b6695
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/adding-events.html
@@ -0,0 +1,144 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Adding Events</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/audio-param.js"></script>
+  </head>
+
+  <body>
+    <script>
+      let audit = Audit.createTaskRunner();
+
+      // Arbitrary power of two to eliminate round-off in computing time from
+      // frame.
+      const sampleRate = 8192;
+
+      audit.define(
+          {
+            label: 'linearRamp',
+            description: 'Insert linearRamp after running for some time'
+          },
+          (task, should) => {
+            testInsertion(should, {
+              method: 'linearRampToValueAtTime',
+              prefix: 'linearRamp'
+            }).then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: 'expoRamp',
+            description: 'Insert expoRamp after running for some time'
+          },
+          (task, should) => {
+            testInsertion(should, {
+              method: 'exponentialRampToValueAtTime',
+              prefix: 'expoRamp'
+            }).then(() => task.done());
+          });
+
+      // Test insertion of an event in the middle of rendering.
+      //
+      // options dictionary:
+      //   method - automation method to test
+      //   prefix - string to use for prefixing messages
+      function testInsertion(should, options) {
+        let {method, prefix} = options;
+
+        // Channel 0 is the output for the test, and channel 1 is the
+        // reference output.
+        let context = new OfflineAudioContext(
+            {numberOfChannels: 2, length: sampleRate, sampleRate: sampleRate});
+        let merger = new ChannelMergerNode(
+            context, {numberOfChannels: context.destination.channelCount});
+
+        merger.connect(context.destination);
+
+        // Initial value and final values of the source node
+        let initialValue = 1;
+        let finalValue = 2;
+
+        // Set up the node for the automations under test
+        let src = new ConstantSourceNode(context, {offset: initialValue});
+        src.connect(merger, 0, 0);
+
+        // Set initial event to occur at this time.  Keep it in the first
+        // render quantum.
+        const initialEventTime = 64 / context.sampleRate;
+        should(
+            () => src.offset.setValueAtTime(initialValue, initialEventTime),
+            `${prefix}: setValueAtTime(${initialValue}, ${initialEventTime})`)
+            .notThrow();
+
+        // Let time pass and then add a new event with time in the future.
+        let insertAtFrame = 512;
+        let insertTime = insertAtFrame / context.sampleRate;
+        let automationEndFrame = 1024 + 64;
+        let automationEndTime = automationEndFrame / context.sampleRate;
+        context.suspend(insertTime)
+            .then(() => {
+              should(
+                  () => src.offset[method](finalValue, automationEndTime),
+                  `${prefix}: At time ${insertTime} scheduling ${method}(${
+                      finalValue}, ${automationEndTime})`)
+                  .notThrow();
+            })
+            .then(() => context.resume());
+
+        // Set up graph for the reference result.  Automate the source with
+        // the events scheduled from the beginning.  Let the gain node
+        // simulate the insertion of the event above.  This is done by
+        // setting the gain to 1 at the insertion time.
+        let srcRef = new ConstantSourceNode(context, {offset: 1});
+        let g = new GainNode(context, {gain: 0});
+        srcRef.connect(g).connect(merger, 0, 1);
+        srcRef.offset.setValueAtTime(initialValue, initialEventTime);
+        srcRef.offset[method](finalValue, automationEndTime);
+
+        // Allow everything through after |insertFrame| frames.
+        g.gain.setValueAtTime(1, insertTime);
+
+        // Go!
+        src.start();
+        srcRef.start();
+
+        return context.startRendering().then(audioBuffer => {
+          let actual = audioBuffer.getChannelData(0);
+          let expected = audioBuffer.getChannelData(1);
+
+          // Verify that the output is 1 until we reach
+          // insertAtFrame. Ignore the expected data because that always
+          // produces 1.
+          should(
+              actual.slice(0, insertAtFrame),
+              `${prefix}: output[0:${insertAtFrame - 1}]`)
+              .beConstantValueOf(initialValue);
+
+          // Verify ramp is correct by comparing it to the expected
+          // data.
+          should(
+              actual.slice(
+                  insertAtFrame, automationEndFrame - insertAtFrame + 1),
+              `${prefix}: output[${insertAtFrame}:${
+                  automationEndFrame - insertAtFrame}]`)
+              .beCloseToArray(
+                  expected.slice(
+                      insertAtFrame, automationEndFrame - insertAtFrame + 1),
+                  {absoluteThreshold: 0, numberOfArrayElements: 0});
+
+          // Verify final output has the expected value
+          should(
+              actual.slice(automationEndFrame),
+              `${prefix}: output[${automationEndFrame}:]`)
+              .beConstantValueOf(finalValue);
+        })
+      }
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-cancel-and-hold.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-cancel-and-hold.html
new file mode 100644
index 0000000000..0a8e7a7f2f
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-cancel-and-hold.html
@@ -0,0 +1,855 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test CancelValuesAndHoldAtTime
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audio-param.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 sampleRate = 48000;
+      let renderDuration = 0.5;
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {label: 'cancelTime', description: 'Test Invalid Values'},
+          (task, should) => {
+            let context = new OfflineAudioContext({
+              numberOfChannels: 1,
+              length: 1,
+              sampleRate: 8000
+            });
+
+            let src = new ConstantSourceNode(context);
+            src.connect(context.destination);
+
+            should(
+                () => src.offset.cancelAndHoldAtTime(-1),
+                'cancelAndHoldAtTime(-1)')
+                .throw(RangeError);
+
+            // These are TypeErrors because |cancelTime| is a
+            // double, not unrestricted double.
+            should(
+                () => src.offset.cancelAndHoldAtTime(NaN),
+                'cancelAndHoldAtTime(NaN)')
+                .throw(TypeError);
+
+            should(
+                () => src.offset.cancelAndHoldAtTime(Infinity),
+                'cancelAndHoldAtTime(Infinity)')
+                .throw(TypeError);
+
+            task.done();
+          });
+
+      // The first few tasks test the cancellation of each relevant automation
+      // function.  For the test, a simple linear ramp from 0 to 1 is used to
+      // start things off.  Then the automation to be tested is scheduled and
+      // cancelled.
+
+      audit.define(
+          {label: 'linear', description: 'Cancel linearRampToValueAtTime'},
+          function(task, should) {
+            cancelTest(should, linearRampTest('linearRampToValueAtTime'), {
+              valueThreshold: 8.3998e-5,
+              curveThreshold: 5.9605e-5
+            }).then(task.done.bind(task));
+          });
+
+      audit.define(
+          {label: 'exponential', description: 'Cancel exponentialRampAtTime'},
+          function(task, should) {
+            // Cancel an exponential ramp.  The thresholds are experimentally
+            // determined.
+            cancelTest(should, function(g, v0, t0, cancelTime) {
+              // Initialize values to 0.
+              g[0].gain.setValueAtTime(0, 0);
+              g[1].gain.setValueAtTime(0, 0);
+              // Schedule a short linear ramp to start things off.
+              g[0].gain.linearRampToValueAtTime(v0, t0);
+              g[1].gain.linearRampToValueAtTime(v0, t0);
+
+              // After the linear ramp, schedule an exponential ramp to the end.
+              // (This is the event that will be be cancelled.)
+              let v1 = 0.001;
+              let t1 = renderDuration;
+
+              g[0].gain.exponentialRampToValueAtTime(v1, t1);
+              g[1].gain.exponentialRampToValueAtTime(v1, t1);
+
+              expectedConstant = Math.fround(
+                  v0 * Math.pow(v1 / v0, (cancelTime - t0) / (t1 - t0)));
+              return {
+                expectedConstant: expectedConstant,
+                autoMessage: 'exponentialRampToValue(' + v1 + ', ' + t1 + ')',
+                summary: 'exponentialRampToValueAtTime',
+              };
+            }, {
+              valueThreshold: 1.8664e-6,
+              curveThreshold: 5.9605e-8
+            }).then(task.done.bind(task));
+          });
+
+      audit.define(
+          {label: 'setTarget', description: 'Cancel setTargetAtTime'},
+          function(task, should) {
+            // Cancel a setTarget event.
+            cancelTest(should, function(g, v0, t0, cancelTime) {
+              // Initialize values to 0.
+              g[0].gain.setValueAtTime(0, 0);
+              g[1].gain.setValueAtTime(0, 0);
+              // Schedule a short linear ramp to start things off.
+              g[0].gain.linearRampToValueAtTime(v0, t0);
+              g[1].gain.linearRampToValueAtTime(v0, t0);
+
+              // At the end of the linear ramp, schedule a setTarget.  (This is
+              // the event that will be cancelled.)
+              let v1 = 0;
+              let t1 = t0;
+              let timeConstant = 0.05;
+
+              g[0].gain.setTargetAtTime(v1, t1, timeConstant);
+              g[1].gain.setTargetAtTime(v1, t1, timeConstant);
+
+              expectedConstant = Math.fround(
+                  v1 + (v0 - v1) * Math.exp(-(cancelTime - t0) / timeConstant));
+              return {
+                expectedConstant: expectedConstant,
+                autoMessage: 'setTargetAtTime(' + v1 + ', ' + t1 + ', ' +
+                    timeConstant + ')',
+                summary: 'setTargetAtTime',
+              };
+            }, {
+              valueThreshold: 4.5267e-7,  // 1.1317e-7,
+              curveThreshold: 0
+            }).then(task.done.bind(task));
+          });
+
+      audit.define(
+          {label: 'setValueCurve', description: 'Cancel setValueCurveAtTime'},
+          function(task, should) {
+            // Cancel a setValueCurve event.
+            cancelTest(should, function(g, v0, t0, cancelTime) {
+              // Initialize values to 0.
+              g[0].gain.setValueAtTime(0, 0);
+              g[1].gain.setValueAtTime(0, 0);
+              // Schedule a short linear ramp to start things off.
+              g[0].gain.linearRampToValueAtTime(v0, t0);
+              g[1].gain.linearRampToValueAtTime(v0, t0);
+
+              // After the linear ramp, schedule a setValuesCurve. (This is the
+              // event that will be cancelled.)
+              let v1 = 0;
+              let duration = renderDuration - t0;
+
+              // For simplicity, a 2-point curve so we get a linear interpolated
+              // result.
+              let curve = Float32Array.from([v0, 0]);
+
+              g[0].gain.setValueCurveAtTime(curve, t0, duration);
+              g[1].gain.setValueCurveAtTime(curve, t0, duration);
+
+              let index =
+                  Math.floor((curve.length - 1) / duration * (cancelTime - t0));
+
+              let curvePointsPerFrame =
+                  (curve.length - 1) / duration / sampleRate;
+              let virtualIndex =
+                  (cancelTime - t0) * sampleRate * curvePointsPerFrame;
+
+              let delta = virtualIndex - index;
+              expectedConstant = curve[0] + (curve[1] - curve[0]) * delta;
+              return {
+                expectedConstant: expectedConstant,
+                autoMessage: 'setValueCurveAtTime([' + curve + '], ' + t0 +
+                    ', ' + duration + ')',
+                summary: 'setValueCurveAtTime',
+              };
+            }, {
+              valueThreshold: 9.5368e-9,
+              curveThreshold: 0
+            }).then(task.done.bind(task));
+          });
+
+      audit.define(
+          {
+            label: 'setValueCurve after end',
+            description: 'Cancel setValueCurveAtTime after the end'
+          },
+          function(task, should) {
+            cancelTest(should, function(g, v0, t0, cancelTime) {
+              // Initialize values to 0.
+              g[0].gain.setValueAtTime(0, 0);
+              g[1].gain.setValueAtTime(0, 0);
+              // Schedule a short linear ramp to start things off.
+              g[0].gain.linearRampToValueAtTime(v0, t0);
+              g[1].gain.linearRampToValueAtTime(v0, t0);
+
+              // After the linear ramp, schedule a setValuesCurve. (This is the
+              // event that will be cancelled.)  Make sure the curve ends before
+              // the cancellation time.
+              let v1 = 0;
+              let duration = cancelTime - t0 - 0.125;
+
+              // For simplicity, a 2-point curve so we get a linear interpolated
+              // result.
+              let curve = Float32Array.from([v0, 0]);
+
+              g[0].gain.setValueCurveAtTime(curve, t0, duration);
+              g[1].gain.setValueCurveAtTime(curve, t0, duration);
+
+              expectedConstant = curve[1];
+              return {
+                expectedConstant: expectedConstant,
+                autoMessage: 'setValueCurveAtTime([' + curve + '], ' + t0 +
+                    ', ' + duration + ')',
+                summary: 'setValueCurveAtTime',
+              };
+            }, {
+              valueThreshold: 0,
+              curveThreshold: 0
+            }).then(task.done.bind(task));
+          });
+
+      // Special case where we schedule a setTarget and there is no earlier
+      // automation event.  This tests that we pick up the starting point
+      // correctly from the last setting of the AudioParam value attribute.
+
+
+      audit.define(
+          {
+            label: 'initial setTarget',
+            description: 'Cancel with initial setTargetAtTime'
+          },
+          function(task, should) {
+            cancelTest(should, function(g, v0, t0, cancelTime) {
+              let v1 = 0;
+              let timeConstant = 0.1;
+              g[0].gain.value = 1;
+              g[0].gain.setTargetAtTime(v1, t0, timeConstant);
+              g[1].gain.value = 1;
+              g[1].gain.setTargetAtTime(v1, t0, timeConstant);
+
+              let expectedConstant = Math.fround(
+                  v1 + (v0 - v1) * Math.exp(-(cancelTime - t0) / timeConstant));
+
+              return {
+                expectedConstant: expectedConstant,
+                autoMessage: 'setTargetAtTime(' + v1 + ', ' + t0 + ', ' +
+                    timeConstant + ')',
+                summary: 'Initial setTargetAtTime',
+              };
+            }, {
+              valueThreshold: 3.1210e-6,
+              curveThreshold: 0
+            }).then(task.done.bind(task));
+          });
+
+      // Test automations scheduled after the call to cancelAndHoldAtTime.
+      // Very similar to the above tests, but we also schedule an event after
+      // cancelAndHoldAtTime and verify that curve after cancellation has
+      // the correct values.
+
+      audit.define(
+          {
+            label: 'post cancel: Linear',
+            description: 'LinearRamp after cancelling'
+          },
+          function(task, should) {
+            // Run the cancel test using a linearRamp as the event to be
+            // cancelled. Then schedule another linear ramp after the
+            // cancellation.
+            cancelTest(
+                should,
+                linearRampTest('Post cancellation linearRampToValueAtTime'),
+                {valueThreshold: 8.3998e-5, curveThreshold: 5.9605e-8},
+                function(g, cancelTime, expectedConstant) {
+                  // Schedule the linear ramp on g[0], and do the same for g[2],
+                  // using the starting point given by expectedConstant.
+                  let v2 = 2;
+                  let t2 = cancelTime + 0.125;
+                  g[0].gain.linearRampToValueAtTime(v2, t2);
+                  g[2].gain.setValueAtTime(expectedConstant, cancelTime);
+                  g[2].gain.linearRampToValueAtTime(v2, t2);
+                  return {
+                    constantEndTime: cancelTime,
+                    message: 'Post linearRamp(' + v2 + ', ' + t2 + ')'
+                  };
+                })
+                .then(task.done.bind(task));
+          });
+
+      audit.define(
+          {
+            label: 'post cancel: Exponential',
+            description: 'ExponentialRamp after cancelling'
+          },
+          function(task, should) {
+            // Run the cancel test using a linearRamp as the event to be
+            // cancelled. Then schedule an exponential ramp after the
+            // cancellation.
+            cancelTest(
+                should,
+                linearRampTest('Post cancel exponentialRampToValueAtTime'),
+                {valueThreshold: 8.3998e-5, curveThreshold: 5.9605e-8},
+                function(g, cancelTime, expectedConstant) {
+                  // Schedule the exponential ramp on g[0], and do the same for
+                  // g[2], using the starting point given by expectedConstant.
+                  let v2 = 2;
+                  let t2 = cancelTime + 0.125;
+                  g[0].gain.exponentialRampToValueAtTime(v2, t2);
+                  g[2].gain.setValueAtTime(expectedConstant, cancelTime);
+                  g[2].gain.exponentialRampToValueAtTime(v2, t2);
+                  return {
+                    constantEndTime: cancelTime,
+                    message: 'Post exponentialRamp(' + v2 + ', ' + t2 + ')'
+                  };
+                })
+                .then(task.done.bind(task));
+          });
+
+      audit.define('post cancel: ValueCurve', function(task, should) {
+        // Run the cancel test using a linearRamp as the event to be cancelled.
+        // Then schedule a setValueCurve after the cancellation.
+        cancelTest(
+            should, linearRampTest('Post cancel setValueCurveAtTime'),
+            {valueThreshold: 8.3998e-5, curveThreshold: 5.9605e-8},
+            function(g, cancelTime, expectedConstant) {
+              // Schedule the exponential ramp on g[0], and do the same for
+              // g[2], using the starting point given by expectedConstant.
+              let t2 = cancelTime + 0.125;
+              let duration = 0.125;
+              let curve = Float32Array.from([.125, 2]);
+              g[0].gain.setValueCurveAtTime(curve, t2, duration);
+              g[2].gain.setValueAtTime(expectedConstant, cancelTime);
+              g[2].gain.setValueCurveAtTime(curve, t2, duration);
+              return {
+                constantEndTime: cancelTime,
+                message: 'Post setValueCurve([' + curve + '], ' + t2 + ', ' +
+                    duration + ')',
+                errorThreshold: 8.3998e-5
+              };
+            })
+            .then(task.done.bind(task));
+      });
+
+      audit.define('post cancel: setTarget', function(task, should) {
+        // Run the cancel test using a linearRamp as the event to be cancelled.
+        // Then schedule a setTarget after the cancellation.
+        cancelTest(
+            should, linearRampTest('Post cancel setTargetAtTime'),
+            {valueThreshold: 8.3998e-5, curveThreshold: 5.9605e-8},
+            function(g, cancelTime, expectedConstant) {
+              // Schedule the exponential ramp on g[0], and do the same for
+              // g[2], using the starting point given by expectedConstant.
+              let v2 = 0.125;
+              let t2 = cancelTime + 0.125;
+              let timeConstant = 0.1;
+              g[0].gain.setTargetAtTime(v2, t2, timeConstant);
+              g[2].gain.setValueAtTime(expectedConstant, cancelTime);
+              g[2].gain.setTargetAtTime(v2, t2, timeConstant);
+              return {
+                constantEndTime: cancelTime + 0.125,
+                message: 'Post setTargetAtTime(' + v2 + ', ' + t2 + ', ' +
+                    timeConstant + ')',
+                errorThreshold: 8.4037e-5
+              };
+            })
+            .then(task.done.bind(task));
+      });
+
+      audit.define('post cancel: setValue', function(task, should) {
+        // Run the cancel test using a linearRamp as the event to be cancelled.
+        // Then schedule a setTarget after the cancellation.
+        cancelTest(
+            should, linearRampTest('Post cancel setValueAtTime'),
+            {valueThreshold: 8.3998e-5, curveThreshold: 5.9605e-8},
+            function(g, cancelTime, expectedConstant) {
+              // Schedule the exponential ramp on g[0], and do the same for
+              // g[2], using the starting point given by expectedConstant.
+              let v2 = 0.125;
+              let t2 = cancelTime + 0.125;
+              g[0].gain.setValueAtTime(v2, t2);
+              g[2].gain.setValueAtTime(expectedConstant, cancelTime);
+              g[2].gain.setValueAtTime(v2, t2);
+              return {
+                constantEndTime: cancelTime + 0.125,
+                message: 'Post setValueAtTime(' + v2 + ', ' + t2 + ')'
+              };
+            })
+            .then(task.done.bind(task));
+      });
+
+      audit.define('cancel future setTarget', (task, should) => {
+        const context =
+            new OfflineAudioContext(1, renderDuration * sampleRate, sampleRate);
+        const src = new ConstantSourceNode(context);
+        src.connect(context.destination);
+
+        src.offset.setValueAtTime(0.5, 0);
+        src.offset.setTargetAtTime(0, 0.75 * renderDuration, 0.1);
+        // Now cancel the effect of the setTarget.
+        src.offset.cancelAndHoldAtTime(0.5 * renderDuration);
+
+        src.start();
+        context.startRendering()
+            .then(buffer => {
+              let actual = buffer.getChannelData(0);
+              // Because the setTarget was cancelled, the output should be a
+              // constant.
+              should(actual, 'After cancelling future setTarget event, output')
+                  .beConstantValueOf(0.5);
+            })
+            .then(task.done.bind(task));
+      });
+
+      audit.define('cancel setTarget now', (task, should) => {
+        const context =
+            new OfflineAudioContext(1, renderDuration * sampleRate, sampleRate);
+        const src = new ConstantSourceNode(context);
+        src.connect(context.destination);
+
+        src.offset.setValueAtTime(0.5, 0);
+        src.offset.setTargetAtTime(0, 0.5 * renderDuration, 0.1);
+        // Now cancel the effect of the setTarget.
+        src.offset.cancelAndHoldAtTime(0.5 * renderDuration);
+
+        src.start();
+        context.startRendering()
+            .then(buffer => {
+              let actual = buffer.getChannelData(0);
+              // Because the setTarget was cancelled, the output should be a
+              // constant.
+              should(
+                  actual,
+                  'After cancelling setTarget event starting now, output')
+                  .beConstantValueOf(0.5);
+            })
+            .then(task.done.bind(task));
+      });
+
+      audit.define('cancel future setValueCurve', (task, should) => {
+        const context =
+            new OfflineAudioContext(1, renderDuration * sampleRate, sampleRate);
+        const src = new ConstantSourceNode(context);
+        src.connect(context.destination);
+
+        src.offset.setValueAtTime(0.5, 0);
+        src.offset.setValueCurveAtTime([-1, 1], 0.75 * renderDuration, 0.1);
+        // Now cancel the effect of the setTarget.
+        src.offset.cancelAndHoldAtTime(0.5 * renderDuration);
+
+        src.start();
+        context.startRendering()
+            .then(buffer => {
+              let actual = buffer.getChannelData(0);
+              // Because the setTarget was cancelled, the output should be a
+              // constant.
+              should(
+                  actual, 'After cancelling future setValueCurve event, output')
+                  .beConstantValueOf(0.5);
+            })
+            .then(task.done.bind(task));
+      });
+
+      audit.define('cancel setValueCurve now', (task, should) => {
+        const context =
+            new OfflineAudioContext(1, renderDuration * sampleRate, sampleRate);
+        const src = new ConstantSourceNode(context);
+        src.connect(context.destination);
+
+        src.offset.setValueAtTime(0.5, 0);
+        src.offset.setValueCurveAtTime([-1, 1], 0.5 * renderDuration, 0.1);
+        // Now cancel the effect of the setTarget.
+        src.offset.cancelAndHoldAtTime(0.5 * renderDuration);
+
+        src.start();
+        context.startRendering()
+            .then(buffer => {
+              let actual = buffer.getChannelData(0);
+              // Because the setTarget was cancelled, the output should be a
+              // constant.
+              should(
+                  actual,
+                  'After cancelling current setValueCurve event starting now, output')
+                  .beConstantValueOf(0.5);
+            })
+            .then(task.done.bind(task));
+      });
+
+      audit.define(
+        {
+          label: 'linear, cancel, linear, cancel, linear',
+          description: 'Schedules 3 linear ramps, cancelling 2 of them, '
+            + 'so that we end up with 2 cancel events next to each other'
+        },
+        (task, should) => {
+          cancelTest2(
+            should,
+            linearRampTest('1st linearRamp'),
+            {valueThreshold: 0, curveThreshold: 5.9605e-8},
+            (g, cancelTime, expectedConstant, cancelTime2) => {
+              // Ramp from first cancel time to the end will be cancelled at
+              // second cancel time.
+              const v1 = expectedConstant;
+              const t1 = cancelTime;
+              const v2 = 2;
+              const t2 = renderDuration;
+              g[0].gain.linearRampToValueAtTime(v2, t2);
+              g[2].gain.setValueAtTime(v1, t1);
+              g[2].gain.linearRampToValueAtTime(v2, t2);
+
+              const expectedConstant2 =
+                audioParamLinearRamp(cancelTime2, v1, t1, v2, t2);
+
+              return {
+                constantEndTime: cancelTime,
+                message: `2nd linearRamp(${v2}, ${t2})`,
+                expectedConstant2
+              };
+            },
+            (g, cancelTime2, expectedConstant2) => {
+              // Ramp from second cancel time to the end.
+              const v3 = 0;
+              const t3 = renderDuration;
+              g[0].gain.linearRampToValueAtTime(v3, t3);
+              g[3].gain.setValueAtTime(expectedConstant2, cancelTime2);
+              g[3].gain.linearRampToValueAtTime(v3, t3);
+              return {
+                constantEndTime2: cancelTime2,
+                message2: `3rd linearRamp(${v3}, ${t3})`,
+              };
+            })
+            .then(() => task.done());
+        });
+
+      audit.run();
+
+      // Common function for doing a linearRamp test.  This just does a linear
+      // ramp from 0 to v0 at from time 0 to t0.  Then another linear ramp is
+      // scheduled from v0 to 0 from time t0 to t1.  This is the ramp that is to
+      // be cancelled.
+      function linearRampTest(message) {
+        return function(g, v0, t0, cancelTime) {
+          g[0].gain.setValueAtTime(0, 0);
+          g[1].gain.setValueAtTime(0, 0);
+          g[0].gain.linearRampToValueAtTime(v0, t0);
+          g[1].gain.linearRampToValueAtTime(v0, t0);
+
+          let v1 = 0;
+          let t1 = renderDuration;
+          g[0].gain.linearRampToValueAtTime(v1, t1);
+          g[1].gain.linearRampToValueAtTime(v1, t1);
+
+          expectedConstant =
+              Math.fround(v0 + (v1 - v0) * (cancelTime - t0) / (t1 - t0));
+
+          return {
+            expectedConstant: expectedConstant,
+            autoMessage:
+                message + ': linearRampToValue(' + v1 + ', ' + t1 + ')',
+            summary: message,
+          };
+        }
+      }
+
+      // Run the cancellation test. A set of automations is created and
+      // canceled.
+      //
+      // |testerFunction| is a function that generates the automation to be
+      // tested.  It is given an array of 3 gain nodes, the value and time of an
+      // initial linear ramp, and the time where the cancellation should occur.
+      // The function must do the automations for the first two gain nodes.  It
+      // must return a dictionary with |expectedConstant| being the value at the
+      // cancellation time, |autoMessage| for message to describe the test, and
+      // |summary| for general summary message to be printed at the end of the
+      // test.
+      //
+      // |thresholdOptions| is a property bag that specifies the error threshold
+      // to use. |thresholdOptions.valueThreshold| is the error threshold for
+      // comparing the actual constant output after cancelling to the expected
+      // value.  |thresholdOptions.curveThreshold| is the error threshold for
+      // comparing the actual and expected automation curves before the
+      // cancelation point.
+      //
+      // For cancellation tests, |postCancelTest| is a function that schedules
+      // some automation after the cancellation.  It takes 3 arguments: an array
+      // of the gain nodes, the cancellation time, and the expected value at the
+      // cancellation time.  This function must return a dictionary consisting
+      // of |constantEndtime| indicating when the held constant from
+      // cancellation stops being constant, |message| giving a summary of what
+      // automation is being used, and |errorThreshold| that is the error
+      // threshold between the expected curve and the actual curve.
+      //
+      function cancelTest(
+          should, testerFunction, thresholdOptions, postCancelTest) {
+        // Create a context with three channels.  Channel 0 is the test channel
+        // containing the actual output that includes the cancellation of
+        // events.  Channel 1 is the expected data upto the cancellation so we
+        // can verify the cancellation produced the correct result.  Channel 2
+        // is for verifying events inserted after the cancellation so we can
+        // verify that automations are correctly generated after the
+        // cancellation point.
+        let context =
+            new OfflineAudioContext(3, renderDuration * sampleRate, sampleRate);
+
+        // Test source is a constant signal
+        let src = context.createBufferSource();
+        src.buffer = createConstantBuffer(context, 1, 1);
+        src.loop = true;
+
+        // We'll do the automation tests with three gain nodes.  One (g0) will
+        // have cancelAndHoldAtTime and the other (g1) will not.  g1 is
+        // used as the expected result for that automation up to the
+        // cancellation point.  They should be the same.  The third node (g2) is
+        // used for testing automations inserted after the cancellation point,
+        // if any.  g2 is the expected result from the cancellation point to the
+        // end of the test.
+
+        let g0 = context.createGain();
+        let g1 = context.createGain();
+        let g2 = context.createGain();
+        let v0 = 1;
+        let t0 = 0.01;
+
+        let cancelTime = renderDuration / 2;
+
+        // Test automation here.  The tester function is responsible for setting
+        // up the gain nodes with the desired automation for testing.
+        autoResult = testerFunction([g0, g1, g2], v0, t0, cancelTime);
+        let expectedConstant = autoResult.expectedConstant;
+        let autoMessage = autoResult.autoMessage;
+        let summaryMessage = autoResult.summary;
+
+        // Cancel scheduled events somewhere in the middle of the test
+        // automation.
+        g0.gain.cancelAndHoldAtTime(cancelTime);
+
+        let constantEndTime;
+        if (postCancelTest) {
+          postResult =
+              postCancelTest([g0, g1, g2], cancelTime, expectedConstant);
+          constantEndTime = postResult.constantEndTime;
+        }
+
+        // Connect everything together (with a merger to make a two-channel
+        // result).  Channel 0 is the test (with cancelAndHoldAtTime) and
+        // channel 1 is the reference (without cancelAndHoldAtTime).
+        // Channel 1 is used to verify that everything up to the cancellation
+        // has the correct values.
+        src.connect(g0);
+        src.connect(g1);
+        src.connect(g2);
+        let merger = context.createChannelMerger(3);
+        g0.connect(merger, 0, 0);
+        g1.connect(merger, 0, 1);
+        g2.connect(merger, 0, 2);
+        merger.connect(context.destination);
+
+        // Go!
+        src.start();
+
+        return context.startRendering().then(function(buffer) {
+          let actual = buffer.getChannelData(0);
+          let expected = buffer.getChannelData(1);
+
+          // The actual output should be a constant from the cancel time to the
+          // end.  We use the last value of the actual output as the constant,
+          // but we also want to compare that with what we thought it should
+          // really be.
+
+          let cancelFrame = Math.ceil(cancelTime * sampleRate);
+
+          // Verify that the curves up to the cancel time are "identical".  The
+          // should be but round-off may make them differ slightly due to the
+          // way cancelling is done.
+          let endFrame = Math.floor(cancelTime * sampleRate);
+          should(
+              actual.slice(0, endFrame),
+              autoMessage + ' up to time ' + cancelTime)
+              .beCloseToArray(
+                  expected.slice(0, endFrame),
+                  {absoluteThreshold: thresholdOptions.curveThreshold});
+
+          // Verify the output after the cancellation is a constant.
+          let actualTail;
+          let constantEndFrame;
+
+          if (postCancelTest) {
+            constantEndFrame = Math.ceil(constantEndTime * sampleRate);
+            actualTail = actual.slice(cancelFrame, constantEndFrame);
+          } else {
+            actualTail = actual.slice(cancelFrame);
+          }
+
+          let actualConstant = actual[cancelFrame];
+
+          should(
+              actualTail,
+              'Cancelling ' + autoMessage + ' at time ' + cancelTime)
+              .beConstantValueOf(actualConstant);
+
+          // Verify that the constant is the value we expect.
+          should(
+              actualConstant,
+              'Expected value for cancelling ' + autoMessage + ' at time ' +
+                  cancelTime)
+              .beCloseTo(
+                  expectedConstant,
+                  {threshold: thresholdOptions.valueThreshold});
+
+          // Verify the curve after the constantEndTime matches our
+          // expectations.
+          if (postCancelTest) {
+            let c2 = buffer.getChannelData(2);
+            should(actual.slice(constantEndFrame), postResult.message)
+                .beCloseToArray(
+                    c2.slice(constantEndFrame),
+                    {absoluteThreshold: postResult.errorThreshold || 0});
+          }
+        });
+      }
+
+      // Similar to cancelTest, but does 2 cancels.
+      function cancelTest2(
+          should, testerFunction, thresholdOptions,
+          postCancelTest, postCancelTest2) {
+        // Channel 0: Actual output that includes the cancellation of events.
+        // Channel 1: Expected data up to the first cancellation.
+        // Channel 2: Expected data from 1st cancellation to 2nd cancellation.
+        // Channel 3: Expected data from 2nd cancellation to the end.
+        const context =
+          new OfflineAudioContext(4, renderDuration * sampleRate, sampleRate);
+
+        const src = context.createConstantSource();
+
+        // g0: Actual gain which will have cancelAndHoldAtTime called on it
+        // twice.
+        // g1: Expected gain from start to the 1st cancel.
+        // g2: Expected gain from 1st cancel to the 2nd cancel.
+        // g3: Expected gain from the 2nd cancel to the end.
+        const g0 = context.createGain();
+        const g1 = context.createGain();
+        const g2 = context.createGain();
+        const g3 = context.createGain();
+        const v0 = 1;
+        const t0 = 0.01;
+
+        const cancelTime1 = renderDuration * 0.5;
+        const cancelTime2 = renderDuration * 0.75;
+
+        // Run testerFunction to generate the 1st ramp.
+        const {
+          expectedConstant, autoMessage, summaryMessage} =
+            testerFunction([g0, g1, g2], v0, t0, cancelTime1);
+
+        // 1st cancel, cancelling the 1st ramp.
+        g0.gain.cancelAndHoldAtTime(cancelTime1);
+
+        // Run postCancelTest to generate the 2nd ramp.
+        const {
+          constantEndTime, message, errorThreshold = 0, expectedConstant2} =
+            postCancelTest(
+              [g0, g1, g2], cancelTime1, expectedConstant, cancelTime2);
+
+        // 2nd cancel, cancelling the 2nd ramp.
+        g0.gain.cancelAndHoldAtTime(cancelTime2);
+
+        // Run postCancelTest2 to generate the 3rd ramp.
+        const {constantEndTime2, message2} =
+          postCancelTest2([g0, g1, g2, g3], cancelTime2, expectedConstant2);
+
+        // Connect everything together
+        src.connect(g0);
+        src.connect(g1);
+        src.connect(g2);
+        src.connect(g3);
+        const merger = context.createChannelMerger(4);
+        g0.connect(merger, 0, 0);
+        g1.connect(merger, 0, 1);
+        g2.connect(merger, 0, 2);
+        g3.connect(merger, 0, 3);
+        merger.connect(context.destination);
+
+        // Go!
+        src.start();
+
+        return context.startRendering().then(function (buffer) {
+          const actual = buffer.getChannelData(0);
+          const expected1 = buffer.getChannelData(1);
+          const expected2 = buffer.getChannelData(2);
+          const expected3 = buffer.getChannelData(3);
+
+          const cancelFrame1 = Math.ceil(cancelTime1 * sampleRate);
+          const cancelFrame2 = Math.ceil(cancelTime2 * sampleRate);
+
+          const constantEndFrame1 = Math.ceil(constantEndTime * sampleRate);
+          const constantEndFrame2 = Math.ceil(constantEndTime2 * sampleRate);
+
+          const actualTail1 = actual.slice(cancelFrame1, constantEndFrame1);
+          const actualTail2 = actual.slice(cancelFrame2, constantEndFrame2);
+
+          const actualConstant1 = actual[cancelFrame1];
+          const actualConstant2 = actual[cancelFrame2];
+
+          // Verify first section curve
+          should(
+            actual.slice(0, cancelFrame1),
+            autoMessage + ' up to time ' + cancelTime1)
+            .beCloseToArray(
+              expected1.slice(0, cancelFrame1),
+              {absoluteThreshold: thresholdOptions.curveThreshold});
+
+          // Verify that a value was held after 1st cancel
+          should(
+            actualTail1,
+            'Cancelling ' + autoMessage + ' at time ' + cancelTime1)
+            .beConstantValueOf(actualConstant1);
+
+          // Verify that held value after 1st cancel was correct
+          should(
+            actualConstant1,
+            'Expected value for cancelling ' + autoMessage + ' at time ' +
+            cancelTime1)
+            .beCloseTo(
+              expectedConstant,
+              {threshold: thresholdOptions.valueThreshold});
+
+          // Verify middle section curve
+          should(actual.slice(constantEndFrame1, cancelFrame2), message)
+            .beCloseToArray(
+              expected2.slice(constantEndFrame1, cancelFrame2),
+              {absoluteThreshold: errorThreshold});
+
+          // Verify that a value was held after 2nd cancel
+          should(
+            actualTail2,
+            'Cancelling ' + message + ' at time ' + cancelTime2)
+            .beConstantValueOf(actualConstant2);
+
+          // Verify that held value after 2nd cancel was correct
+          should(
+            actualConstant2,
+            'Expected value for cancelling ' + message + ' at time ' +
+            cancelTime2)
+            .beCloseTo(
+              expectedConstant2,
+              {threshold: thresholdOptions.valueThreshold});
+
+          // Verify end section curve
+          should(actual.slice(constantEndFrame2), message2)
+            .beCloseToArray(
+              expected3.slice(constantEndFrame2),
+              {absoluteThreshold: errorThreshold || 0});
+        });
+      }
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-close.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-close.html
new file mode 100644
index 0000000000..b5555b0137
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-close.html
@@ -0,0 +1,161 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Test AudioParam events very close in time</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>
+      const audit = Audit.createTaskRunner();
+
+      // Largest sample rate that is required to be supported and is a power of
+      // two, to eliminate round-off as much as possible.
+      const sampleRate = 65536;
+
+      // Only need one render quantum for testing.
+      const testFrames = 128;
+
+      // Largest representable single-float number
+      const floatMax = Math.fround(3.4028234663852886e38);
+
+      // epspos is the smallest x such that 1 + x != 1
+      const epspos = 1.1102230246251568e-16;
+      // epsneg is the smallest x such that 1 - x != 1
+      const epsneg = 5.551115123125784e-17;
+
+      audit.define(
+          {label: 'no-nan', description: 'NaN does not occur'},
+          (task, should) => {
+            const context = new OfflineAudioContext({
+              numberOfChannels: 1,
+              sampleRate: sampleRate,
+              length: testFrames
+            });
+
+            const src0 = new ConstantSourceNode(context, {offset: 0});
+
+            // This should always succeed.  We just want to print out a message
+            // that |src0| is a constant source node for the following
+            // processing.
+            should(src0, 'src0 = new ConstantSourceNode(context, {offset: 0})')
+                .beEqualTo(src0);
+
+            src0.connect(context.destination);
+
+            // Values for the first event (setValue).  |time1| MUST be 0.
+            const time1 = 0;
+            const value1 = 10;
+
+            // Values for the second event (linearRamp).  |value2| must be huge,
+            // and |time2| must be small enough that 1/|time2| overflows a
+            // single float. This value is the least positive single float.
+            const value2 = floatMax;
+            const time2 = 1.401298464324817e-45;
+
+            // These should always succeed; the messages are just informational
+            // to show the events that we scheduled.
+            should(
+                src0.offset.setValueAtTime(value1, time1),
+                `src0.offset.setValueAtTime(${value1}, ${time1})`)
+                .beEqualTo(src0.offset);
+            should(
+                src0.offset.linearRampToValueAtTime(value2, time2),
+                `src0.offset.linearRampToValueAtTime(${value2}, ${time2})`)
+                .beEqualTo(src0.offset);
+
+            src0.start();
+
+            context.startRendering()
+                .then(buffer => {
+                  const output = buffer.getChannelData(0);
+
+                  // Since time1 = 0, the output at frame 0 MUST be value1.
+                  should(output[0], 'output[0]').beEqualTo(value1);
+
+                  // Since time2 < 1, output from frame 1 and later must be a
+                  // constant.
+                  should(output.slice(1), 'output[1]')
+                      .beConstantValueOf(value2);
+                })
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {label: 'interpolation', description: 'Interpolation of linear ramp'},
+          (task, should) => {
+            const context = new OfflineAudioContext({
+              numberOfChannels: 1,
+              sampleRate: sampleRate,
+              length: testFrames
+            });
+
+            const src1 = new ConstantSourceNode(context, {offset: 0});
+
+            // This should always succeed.  We just want to print out a message
+            // that |src1| is a constant source node for the following
+            // processing.
+            should(src1, 'src1 = new ConstantSourceNode(context, {offset: 0})')
+                .beEqualTo(src1);
+
+            src1.connect(context.destination);
+
+            const frame = 1;
+
+            // These time values are arranged so that time1 < frame/sampleRate <
+            // time2.  This means we need to interpolate to get a value at given
+            // frame.
+            //
+            // The values are not so important, but |value2| should be huge.
+            const time1 = frame * (1 - epsneg) / context.sampleRate;
+            const value1 = 1e15;
+
+            const time2 = frame * (1 + epspos) / context.sampleRate;
+            const value2 = floatMax;
+
+            should(
+                src1.offset.setValueAtTime(value1, time1),
+                `src1.offset.setValueAtTime(${value1}, ${time1})`)
+                .beEqualTo(src1.offset);
+            should(
+                src1.offset.linearRampToValueAtTime(value2, time2),
+                `src1.offset.linearRampToValueAtTime(${value2}, ${time2})`)
+                .beEqualTo(src1.offset);
+
+            src1.start();
+
+            context.startRendering()
+                .then(buffer => {
+                  const output = buffer.getChannelData(0);
+
+                  // Sanity check
+                  should(time2 - time1, 'Event time difference')
+                      .notBeEqualTo(0);
+
+                  // Because 0 < time1 < 1, output must be 0 at time 0.
+                  should(output[0], 'output[0]').beEqualTo(0);
+
+                  // Because time1 < 1/sampleRate < time2, we need to
+                  // interpolate the value between these times to determine the
+                  // output at frame 1.
+                  const t = frame / context.sampleRate;
+                  const v = value1 +
+                      (value2 - value1) * (t - time1) / (time2 - time1);
+
+                  should(output[1], 'output[1]').beCloseTo(v, {threshold: 0});
+
+                  // Because 1 < time2 < 2, the output at frame 2 and higher is
+                  // constant.
+                  should(output.slice(2), 'output[2:]')
+                      .beConstantValueOf(value2);
+                })
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-connect-audioratesignal.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-connect-audioratesignal.html
new file mode 100644
index 0000000000..b0455f86bc
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-connect-audioratesignal.html
@@ -0,0 +1,103 @@
+<!DOCTYPE html>
+<!--
+Tests that an audio-rate signal (AudioNode output) can be connected to an
+AudioParam.  Specifically, this tests that an audio-rate signal coming from an
+AudioBufferSourceNode playing an AudioBuffer containing a specific curve can be
+connected to an AudioGainNode's .gain attribute (an AudioParam).  Another
+AudioBufferSourceNode will be the audio source having its gain changed.  We load
+this one with an AudioBuffer containing a constant value of 1.  Thus it's easy
+to check that the resultant signal should be equal to the gain-scaling curve.
+-->
+<html>
+  <head>
+    <title>
+      audioparam-connect-audioratesignal.html
+    </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 audit = Audit.createTaskRunner();
+
+      let sampleRate = 44100.0;
+      let lengthInSeconds = 1;
+
+      let context = 0;
+      let constantOneBuffer = 0;
+      let linearRampBuffer = 0;
+
+      function checkResult(renderedBuffer, should) {
+        let renderedData = renderedBuffer.getChannelData(0);
+        let expectedData = linearRampBuffer.getChannelData(0);
+        let n = renderedBuffer.length;
+
+        should(n, 'Rendered signal length').beEqualTo(linearRampBuffer.length);
+
+        // Check that the rendered result exactly matches the buffer used to
+        // control gain.  This is because we're changing the gain of a signal
+        // having constant value 1.
+        let success = true;
+        for (let i = 0; i < n; ++i) {
+          if (renderedData[i] != expectedData[i]) {
+            success = false;
+            break;
+          }
+        }
+
+        should(
+            success,
+            'Rendered signal exactly matches the audio-rate gain changing signal')
+            .beTrue();
+      }
+
+      audit.define('test', function(task, should) {
+        let sampleFrameLength = sampleRate * lengthInSeconds;
+
+        // Create offline audio context.
+        context = new OfflineAudioContext(1, sampleFrameLength, sampleRate);
+
+        // Create buffer used by the source which will have its gain controlled.
+        constantOneBuffer = createConstantBuffer(context, sampleFrameLength, 1);
+
+        // Create buffer used to control gain.
+        linearRampBuffer = createLinearRampBuffer(context, sampleFrameLength);
+
+        // Create the two sources.
+
+        let constantSource = context.createBufferSource();
+        constantSource.buffer = constantOneBuffer;
+
+        let gainChangingSource = context.createBufferSource();
+        gainChangingSource.buffer = linearRampBuffer;
+
+        // Create a gain node controlling the gain of constantSource and make
+        // the connections.
+        let gainNode = context.createGain();
+
+        // Intrinsic baseline gain of zero.
+        gainNode.gain.value = 0;
+
+        constantSource.connect(gainNode);
+        gainNode.connect(context.destination);
+
+        // Connect an audio-rate signal to control the .gain AudioParam.
+        // This is the heart of what is being tested.
+        gainChangingSource.connect(gainNode.gain);
+
+        // Start both sources at time 0.
+        constantSource.start(0);
+        gainChangingSource.start(0);
+
+        context.startRendering().then(buffer => {
+          checkResult(buffer, should);
+          task.done();
+        });
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-exceptional-values.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-exceptional-values.html
new file mode 100644
index 0000000000..982731d338
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-exceptional-values.html
@@ -0,0 +1,240 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      audioparam-exceptional-values.html
+    </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 audit = Audit.createTaskRunner();
+
+      // Context to use for all of the tests.  The context isn't used for any
+      // processing; just need one for creating a gain node, which is used for
+      // all the tests.
+      let context;
+
+      // For these values, AudioParam methods should throw a Typeerror because
+      // they are not finite values.
+      let nonFiniteValues = [Infinity, -Infinity, NaN];
+
+      audit.define('initialize', (task, should) => {
+        should(() => {
+          // Context for testing.  Rendering isn't done, so any valid values can
+          // be used here so might as well make them small.
+          context = new OfflineAudioContext(1, 1, 8000);
+        }, 'Creating context for testing').notThrow();
+
+        task.done();
+      });
+
+      audit.define(
+          {
+            label: 'test value',
+            description: 'Test non-finite arguments for AudioParam value'
+          },
+          (task, should) => {
+            let gain = context.createGain();
+
+            // Default method for generating the arguments for an automation
+            // method for testing the value of the automation.
+            let defaultFuncArg = (value) => [value, 1];
+
+            // Test the value parameter
+            doTests(should, gain, TypeError, nonFiniteValues, [
+              {automationName: 'setValueAtTime', funcArg: defaultFuncArg}, {
+                automationName: 'linearRampToValueAtTime',
+                funcArg: defaultFuncArg
+              },
+              {
+                automationName: 'exponentialRampToValueAtTime',
+                funcArg: defaultFuncArg
+              },
+              {
+                automationName: 'setTargetAtTime',
+                funcArg: (value) => [value, 1, 1]
+              }
+            ]);
+            task.done();
+          });
+
+      audit.define(
+          {
+            label: 'test time',
+            description: 'Test non-finite arguments for AudioParam time'
+          },
+          (task, should) => {
+            let gain = context.createGain();
+
+            // Default method for generating the arguments for an automation
+            // method for testing the time parameter of the automation.
+            let defaultFuncArg = (startTime) => [1, startTime];
+
+            // Test the time parameter
+            doTests(should, gain, TypeError, nonFiniteValues, [
+              {automationName: 'setValueAtTime', funcArg: defaultFuncArg},
+              {
+                automationName: 'linearRampToValueAtTime',
+                funcArg: defaultFuncArg
+              },
+              {
+                automationName: 'exponentialRampToValueAtTime',
+                funcArg: defaultFuncArg
+              },
+              // Test start time for setTarget
+              {
+                automationName: 'setTargetAtTime',
+                funcArg: (startTime) => [1, startTime, 1]
+              },
+              // Test time constant for setTarget
+              {
+                automationName: 'setTargetAtTime',
+                funcArg: (timeConstant) => [1, 1, timeConstant]
+              },
+            ]);
+
+            task.done();
+          });
+
+      audit.define(
+          {
+            label: 'test setValueCurve',
+            description: 'Test non-finite arguments for setValueCurveAtTime'
+          },
+          (task, should) => {
+            let gain = context.createGain();
+
+            // Just an array for use by setValueCurveAtTime. The length and
+            // contents of the array are not important.
+            let curve = new Float32Array(3);
+
+            doTests(should, gain, TypeError, nonFiniteValues, [
+              {
+                automationName: 'setValueCurveAtTime',
+                funcArg: (startTime) => [curve, startTime, 1]
+              },
+            ]);
+
+            // Non-finite values for the curve should signal an error
+            doTests(
+                should, gain, TypeError,
+                [[1, 2, Infinity, 3], [1, NaN, 2, 3]], [{
+                  automationName: 'setValueCurveAtTime',
+                  funcArg: (c) => [c, 1, 1]
+                }]);
+
+            task.done();
+          });
+
+      audit.define(
+          {
+            label: 'special cases 1',
+            description: 'Test exceptions for finite values'
+          },
+          (task, should) => {
+            let gain = context.createGain();
+
+            // Default method for generating the arguments for an automation
+            // method for testing the time parameter of the automation.
+            let defaultFuncArg = (startTime) => [1, startTime];
+
+            // Test the time parameter
+            let curve = new Float32Array(3);
+            doTests(should, gain, RangeError, [-1], [
+              {automationName: 'setValueAtTime', funcArg: defaultFuncArg},
+              {
+                automationName: 'linearRampToValueAtTime',
+                funcArg: defaultFuncArg
+              },
+              {
+                automationName: 'exponentialRampToValueAtTime',
+                funcArg: defaultFuncArg
+              },
+              {
+                automationName: 'setTargetAtTime',
+                funcArg: (startTime) => [1, startTime, 1]
+              },
+              // Test time constant
+              {
+                automationName: 'setTargetAtTime',
+                funcArg: (timeConstant) => [1, 1, timeConstant]
+              },
+              // startTime and duration for setValueCurve
+              {
+                automationName: 'setValueCurveAtTime',
+                funcArg: (startTime) => [curve, startTime, 1]
+              },
+              {
+                automationName: 'setValueCurveAtTime',
+                funcArg: (duration) => [curve, 1, duration]
+              },
+            ]);
+
+            // Two final tests for setValueCurve: duration must be strictly
+            // positive.
+            should(
+                () => gain.gain.setValueCurveAtTime(curve, 1, 0),
+                'gain.gain.setValueCurveAtTime(curve, 1, 0)')
+                .throw(RangeError);
+            should(
+                () => gain.gain.setValueCurveAtTime(curve, 1, -1),
+                'gain.gain.setValueCurveAtTime(curve, 1, -1)')
+                .throw(RangeError);
+
+            task.done();
+          });
+
+      audit.define(
+          {
+            label: 'special cases 2',
+            description: 'Test special cases for expeonentialRamp'
+          },
+          (task, should) => {
+            let gain = context.createGain();
+
+            doTests(should, gain, RangeError, [0, -1e-100, 1e-100], [{
+                      automationName: 'exponentialRampToValueAtTime',
+                      funcArg: (value) => [value, 1]
+                    }]);
+
+            task.done();
+          });
+
+      audit.run();
+
+      // Run test over the set of values in |testValues| for all of the
+      // automation methods in |testMethods|.  The expected error type is
+      // |errorName|. |testMethods| is an array of dictionaries with attributes
+      // |automationName| giving the name of the automation method to be tested
+      // and |funcArg| being a function of one parameter that produces an array
+      // that will be used as the argument to the automation method.
+      function doTests(should, node, errorName, testValues, testMethods) {
+        testValues.forEach(value => {
+          testMethods.forEach(method => {
+            let args = method.funcArg(value);
+            let message = 'gain.gain.' + method.automationName + '(' +
+                argString(args) + ')';
+            should(() => node.gain[method.automationName](...args), message)
+                .throw(errorName);
+          });
+        });
+      }
+
+      // Specialized printer for automation arguments so that messages make
+      // sense.  We assume the first element is either a number or an array.  If
+      // it's an array, there are always three elements, and we want to print
+      // out the brackets for the array argument.
+      function argString(arg) {
+        if (typeof(arg[0]) === 'number') {
+          return arg.toString();
+        }
+
+        return '[' + arg[0] + '],' + arg[1] + ',' + arg[2];
+      }
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-exponentialRampToValueAtTime.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-exponentialRampToValueAtTime.html
new file mode 100644
index 0000000000..bec4c1286b
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-exponentialRampToValueAtTime.html
@@ -0,0 +1,63 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test AudioParam.exponentialRampToValueAtTime
+    </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/audioparam-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      // Play a long DC signal out through an AudioGainNode, and call
+      // setValueAtTime() and exponentialRampToValueAtTime() at regular
+      // intervals to set the starting and ending values for an exponential
+      // ramp.  Each time interval has a ramp with a different starting and
+      // ending value so that there is a discontinuity at each time interval
+      // boundary.  The discontinuity is for testing timing.  Also, we alternate
+      // between an increasing and decreasing ramp for each interval.
+
+      // Number of tests to run.
+      let numberOfTests = 100;
+
+      // Max allowed difference between the rendered data and the expected
+      // result.
+      let maxAllowedError = 1.222e-5;
+
+      // The AudioGainNode starts with this value instead of the default value.
+      let initialValue = 100;
+
+      // Set the gain node value to the specified value at the specified time.
+      function setValue(value, time) {
+        gainNode.gain.setValueAtTime(value, time);
+      }
+
+      // Generate an exponential ramp ending at time |endTime| with an ending
+      // value of |value|.
+      function generateRamp(value, startTime, endTime){
+          // |startTime| is ignored because the exponential ramp
+          // uses the value from the setValueAtTime() call above.
+          gainNode.gain.exponentialRampToValueAtTime(value, endTime)}
+
+      audit.define(
+          {
+            label: 'test',
+            description:
+                'AudioParam exponentialRampToValueAtTime() functionality'
+          },
+          function(task, should) {
+            createAudioGraphAndTest(
+                task, should, numberOfTests, initialValue, setValue,
+                generateRamp, 'exponentialRampToValueAtTime()', maxAllowedError,
+                createExponentialRampArray);
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-large-endtime.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-large-endtime.html
new file mode 100644
index 0000000000..d8f38eeba0
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-large-endtime.html
@@ -0,0 +1,73 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      AudioParam with Huge End Time
+    </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 sampleRate = 48000;
+      // Render for some small (but fairly arbitrary) time.
+      let renderDuration = 0.125;
+      // Any huge time value that won't fit in a size_t (2^64 on a 64-bit
+      // machine).
+      let largeTime = 1e300;
+
+      let audit = Audit.createTaskRunner();
+
+      // See crbug.com/582701.  Create an audioparam with a huge end time and
+      // verify that to automation is run.  We don't care about the actual
+      // results, just that it runs.
+
+      // Test linear ramp with huge end time
+      audit.define('linearRamp', (task, should) => {
+        let graph = createGraph();
+        graph.gain.gain.linearRampToValueAtTime(0.1, largeTime);
+
+        graph.source.start();
+        graph.context.startRendering()
+            .then(function(buffer) {
+              should(true, 'linearRampToValue(0.1, ' + largeTime + ')')
+                  .message('successfully rendered', 'unsuccessfully rendered');
+            })
+            .then(() => task.done());
+      });
+
+      // Test exponential ramp with huge end time
+      audit.define('exponentialRamp', (task, should) => {
+        let graph = createGraph();
+        graph.gain.gain.exponentialRampToValueAtTime(.1, largeTime);
+
+        graph.source.start();
+        graph.context.startRendering()
+            .then(function(buffer) {
+              should(true, 'exponentialRampToValue(0.1, ' + largeTime + ')')
+                  .message('successfully rendered', 'unsuccessfully rendered');
+            })
+            .then(() => task.done());
+      });
+
+      audit.run();
+
+      // Create the graph and return the context, the source, and the gain node.
+      function createGraph() {
+        let context =
+            new OfflineAudioContext(1, renderDuration * sampleRate, sampleRate);
+        let src = context.createBufferSource();
+        src.buffer = createConstantBuffer(context, 1, 1);
+        src.loop = true;
+        let gain = context.createGain();
+        src.connect(gain);
+        gain.connect(context.destination);
+        gain.gain.setValueAtTime(1, 0.1 / sampleRate);
+
+        return {context: context, gain: gain, source: src};
+      }
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-linearRampToValueAtTime.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-linearRampToValueAtTime.html
new file mode 100644
index 0000000000..509c254d92
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-linearRampToValueAtTime.html
@@ -0,0 +1,60 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test AudioParam.linearRampToValueAtTime
+    </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/audioparam-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      // Play a long DC signal out through an AudioGainNode, and call
+      // setValueAtTime() and linearRampToValueAtTime() at regular intervals to
+      // set the starting and ending values for a linear ramp. Each time
+      // interval has a ramp with a different starting and ending value so that
+      // there is a discontinuity at each time interval boundary.  The
+      // discontinuity is for testing timing.  Also, we alternate between an
+      // increasing and decreasing ramp for each interval.
+
+      // Number of tests to run.
+      let numberOfTests = 100;
+
+      // Max allowed difference between the rendered data and the expected
+      // result.
+      let maxAllowedError = 1.865e-6;
+
+      // Set the gain node value to the specified value at the specified time.
+      function setValue(value, time) {
+        gainNode.gain.setValueAtTime(value, time);
+      }
+
+      // Generate a linear ramp ending at time |endTime| with an ending value of
+      // |value|.
+      function generateRamp(value, startTime, endTime){
+          // |startTime| is ignored because the linear ramp uses the value from
+          // the
+          // setValueAtTime() call above.
+          gainNode.gain.linearRampToValueAtTime(value, endTime)}
+
+      audit.define(
+          {
+            label: 'test',
+            description: 'AudioParam linearRampToValueAtTime() functionality'
+          },
+          function(task, should) {
+            createAudioGraphAndTest(
+                task, should, numberOfTests, 1, setValue, generateRamp,
+                'linearRampToValueAtTime()', maxAllowedError,
+                createLinearRampArray);
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-method-chaining.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-method-chaining.html
new file mode 100644
index 0000000000..ffe46035fd
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-method-chaining.html
@@ -0,0 +1,143 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      audioparam-method-chaining.html
+    </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/audioparam-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let sampleRate = 8000;
+
+      // Create a dummy array for setValueCurveAtTime method.
+      let curveArray = new Float32Array([5.0, 6.0]);
+
+      // AudioNode dictionary with associated dummy arguments.
+      let methodDictionary = [
+        {name: 'setValueAtTime', args: [1.0, 0.0]},
+        {name: 'linearRampToValueAtTime', args: [2.0, 1.0]},
+        {name: 'exponentialRampToValueAtTime', args: [3.0, 2.0]},
+        {name: 'setTargetAtTime', args: [4.0, 2.0, 0.5]},
+        {name: 'setValueCurveAtTime', args: [curveArray, 5.0, 1.0]},
+        {name: 'cancelScheduledValues', args: [6.0]}
+      ];
+
+      let audit = Audit.createTaskRunner();
+
+      // Task: testing entries from the dictionary.
+      audit.define('from-dictionary', (task, should) => {
+        let context = new AudioContext();
+
+        methodDictionary.forEach(function(method) {
+          let sourceParam = context.createGain().gain;
+          should(
+              sourceParam === sourceParam[method.name](...method.args),
+              'The return value of ' + sourceParam.constructor.name + '.' +
+                  method.name + '()' +
+                  ' matches the source AudioParam')
+              .beEqualTo(true);
+
+        });
+
+        task.done();
+      });
+
+      // Task: test method chaining with invalid operation.
+      audit.define('invalid-operation', (task, should) => {
+        let context = new OfflineAudioContext(1, sampleRate, sampleRate);
+        let osc = context.createOscillator();
+        let amp1 = context.createGain();
+        let amp2 = context.createGain();
+
+        osc.connect(amp1);
+        osc.connect(amp2);
+        amp1.connect(context.destination);
+        amp2.connect(context.destination);
+
+        // The first operation fails with an exception, thus the second one
+        // should not have effect on the parameter value. Instead, it should
+        // maintain the default value of 1.0.
+        should(
+            function() {
+              amp1.gain.setValueAtTime(0.25, -1.0)
+                  .linearRampToValueAtTime(2.0, 1.0);
+            },
+            'Calling setValueAtTime() with a negative end time')
+            .throw(RangeError);
+
+        // The first operation succeeds but the second fails due to zero target
+        // value for the exponential ramp. Thus only the first should have
+        // effect on the parameter value, setting the value to 0.5.
+        should(
+            function() {
+              amp2.gain.setValueAtTime(0.5, 0.0).exponentialRampToValueAtTime(
+                  0.0, 1.0);
+            },
+            'Calling exponentialRampToValueAtTime() with a zero target value')
+            .throw(RangeError);
+
+        osc.start();
+        osc.stop(1.0);
+
+        context.startRendering()
+            .then(function(buffer) {
+              should(amp1.gain.value, 'The gain value of the first gain node')
+                  .beEqualTo(1.0);
+              should(amp2.gain.value, 'The gain value of the second gain node')
+                  .beEqualTo(0.5);
+            })
+            .then(() => task.done());
+      });
+
+      // Task: verify if the method chaining actually works. Create an arbitrary
+      // envelope and compare the result with the expected one created by JS
+      // code.
+      audit.define('verification', (task, should) => {
+        let context = new OfflineAudioContext(1, sampleRate * 4, sampleRate);
+        let constantBuffer = createConstantBuffer(context, 1, 1.0);
+
+        let source = context.createBufferSource();
+        source.buffer = constantBuffer;
+        source.loop = true;
+
+        let envelope = context.createGain();
+
+        source.connect(envelope);
+        envelope.connect(context.destination);
+
+        envelope.gain.setValueAtTime(0.0, 0.0)
+            .linearRampToValueAtTime(1.0, 1.0)
+            .exponentialRampToValueAtTime(0.5, 2.0)
+            .setTargetAtTime(0.001, 2.0, 0.5);
+
+        source.start();
+
+        context.startRendering()
+            .then(function(buffer) {
+              let expectedEnvelope =
+                  createLinearRampArray(0.0, 1.0, 0.0, 1.0, sampleRate);
+              expectedEnvelope.push(...createExponentialRampArray(
+                  1.0, 2.0, 1.0, 0.5, sampleRate));
+              expectedEnvelope.push(...createExponentialApproachArray(
+                  2.0, 4.0, 0.5, 0.001, sampleRate, 0.5));
+
+              // There are slight differences between JS implementation of
+              // AudioParam envelope and the internal implementation. (i.e.
+              // double/float and rounding up) The error threshold is adjusted
+              // empirically through the local testing.
+              should(buffer.getChannelData(0), 'The rendered envelope')
+                  .beCloseToArray(
+                      expectedEnvelope, {absoluteThreshold: 4.0532e-6});
+            })
+            .then(() => task.done());
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-nominal-range.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-nominal-range.html
new file mode 100644
index 0000000000..517fc6e956
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-nominal-range.html
@@ -0,0 +1,497 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test AudioParam Nominal Range Values
+    </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">
+      // Some arbitrary sample rate for the offline context.
+      let sampleRate = 48000;
+
+      // The actual contexts to use.  Generally use the offline context for
+      // testing except for the media nodes which require an AudioContext.
+      let offlineContext;
+      let audioContext;
+
+      // The set of all methods that we've tested for verifying that we tested
+      // all of the necessary objects.
+      let testedMethods = new Set();
+
+      // The most positive single float value (the value just before infinity).
+      // Be careful when changing this value!  Javascript only uses double
+      // floats, so the value here should be the max single-float value,
+      // converted directly to a double-float value.  This also depends on
+      // Javascript reading this value and producing the desired double-float
+      // value correctly.
+      let mostPositiveFloat = 3.4028234663852886e38;
+
+      let audit = Audit.createTaskRunner();
+
+      // Array describing the tests that should be run.  |testOfflineConfigs| is
+      // for tests that can use an offline context. |testOnlineConfigs| is for
+      // tests that need to use an online context.  Offline contexts are
+      // preferred when possible.
+      let testOfflineConfigs = [
+        {
+          // The name of the method to create the particular node to be tested.
+          creator: 'createGain',
+
+          // Any args to pass to the creator function.
+          args: [],
+
+          // The min/max limits for each AudioParam of the node.  This is a
+          // dictionary whose keys are
+          // the names of each AudioParam in the node.  Don't define this if the
+          // node doesn't have any
+          // AudioParam attributes.
+          limits: {
+            gain: {
+              // The expected min and max values for this AudioParam.
+              minValue: -mostPositiveFloat,
+              maxValue: mostPositiveFloat
+            }
+          }
+        },
+        {
+          creator: 'createDelay',
+          // Just specify a non-default value for the maximum delay so we can
+          // make sure the limits are
+          // set correctly.
+          args: [1.5],
+          limits: {delayTime: {minValue: 0, maxValue: 1.5}}
+        },
+        {
+          creator: 'createBufferSource',
+          args: [],
+          limits: {
+            playbackRate:
+                {minValue: -mostPositiveFloat, maxValue: mostPositiveFloat},
+            detune: {minValue: -mostPositiveFloat, maxValue: mostPositiveFloat}
+          }
+        },
+        {
+          creator: 'createStereoPanner',
+          args: [],
+          limits: {pan: {minValue: -1, maxValue: 1}}
+        },
+        {
+          creator: 'createDynamicsCompressor',
+          args: [],
+          // Do not set limits for reduction;  it's currently an AudioParam but
+          // should be a float.
+          // So let the test fail for reduction.  When reduction is changed,
+          // this test will then
+          // correctly pass.
+          limits: {
+            threshold: {minValue: -100, maxValue: 0},
+            knee: {minValue: 0, maxValue: 40},
+            ratio: {minValue: 1, maxValue: 20},
+            attack: {minValue: 0, maxValue: 1},
+            release: {minValue: 0, maxValue: 1}
+          }
+        },
+        {
+          creator: 'createBiquadFilter',
+          args: [],
+          limits: {
+            gain: {
+              minValue: -mostPositiveFloat,
+              // This complicated expression is used to get all the arithmetic
+              // to round to the correct single-precision float value for the
+              // desired max.  This also assumes that the implication computes
+              // the limit as 40 * log10f(std::numeric_limits<float>::max()).
+              maxValue:
+                  Math.fround(40 * Math.fround(Math.log10(mostPositiveFloat)))
+            },
+            Q: {minValue: -mostPositiveFloat, maxValue: mostPositiveFloat},
+            frequency: {minValue: 0, maxValue: sampleRate / 2},
+            detune: {
+              minValue: -Math.fround(1200 * Math.log2(mostPositiveFloat)),
+              maxValue: Math.fround(1200 * Math.log2(mostPositiveFloat))
+            }
+          }
+        },
+        {
+          creator: 'createOscillator',
+          args: [],
+          limits: {
+            frequency: {minValue: -sampleRate / 2, maxValue: sampleRate / 2},
+            detune: {
+              minValue: -Math.fround(1200 * Math.log2(mostPositiveFloat)),
+              maxValue: Math.fround(1200 * Math.log2(mostPositiveFloat))
+            }
+          }
+        },
+        {
+          creator: 'createPanner',
+          args: [],
+          limits: {
+            positionX: {
+              minValue: -mostPositiveFloat,
+              maxValue: mostPositiveFloat,
+            },
+            positionY: {
+              minValue: -mostPositiveFloat,
+              maxValue: mostPositiveFloat,
+            },
+            positionZ: {
+              minValue: -mostPositiveFloat,
+              maxValue: mostPositiveFloat,
+            },
+            orientationX: {
+              minValue: -mostPositiveFloat,
+              maxValue: mostPositiveFloat,
+            },
+            orientationY: {
+              minValue: -mostPositiveFloat,
+              maxValue: mostPositiveFloat,
+            },
+            orientationZ: {
+              minValue: -mostPositiveFloat,
+              maxValue: mostPositiveFloat,
+            }
+          },
+        },
+        {
+          creator: 'createConstantSource',
+          args: [],
+          limits: {
+            offset: {minValue: -mostPositiveFloat, maxValue: mostPositiveFloat}
+          }
+        },
+        // These nodes don't have AudioParams, but we want to test them anyway.
+        // Any arguments for the
+        // constructor are pretty much arbitrary; they just need to be valid.
+        {
+          creator: 'createBuffer',
+          args: [1, 1, sampleRate],
+        },
+        {creator: 'createIIRFilter', args: [[1, 2], [1, .9]]},
+        {
+          creator: 'createWaveShaper',
+          args: [],
+        },
+        {
+          creator: 'createConvolver',
+          args: [],
+        },
+        {
+          creator: 'createAnalyser',
+          args: [],
+        },
+        {
+          creator: 'createScriptProcessor',
+          args: [0],
+        },
+        {
+          creator: 'createPeriodicWave',
+          args: [Float32Array.from([0, 0]), Float32Array.from([1, 0])],
+        },
+        {
+          creator: 'createChannelSplitter',
+          args: [],
+        },
+        {
+          creator: 'createChannelMerger',
+          args: [],
+        },
+      ];
+
+      let testOnlineConfigs = [
+        {creator: 'createMediaElementSource', args: [new Audio()]},
+        {creator: 'createMediaStreamDestination', args: []}
+        // Can't currently test MediaStreamSource because we're using an offline
+        // context.
+      ];
+
+      // Create the contexts so we can use it in the following test.
+      audit.define('initialize', (task, should) => {
+        // Just any context so that we can create the nodes.
+        should(() => {
+          offlineContext = new OfflineAudioContext(1, 1, sampleRate);
+        }, 'Create offline context for tests').notThrow();
+        should(() => {
+          onlineContext = new AudioContext();
+        }, 'Create online context for tests').notThrow();
+        task.done();
+      });
+
+      // Create a task for each entry in testOfflineConfigs
+      for (let test in testOfflineConfigs) {
+        let config = testOfflineConfigs[test]
+        audit.define('Offline ' + config.creator, (function(c) {
+                       return (task, should) => {
+                         let node = offlineContext[c.creator](...c.args);
+                         testLimits(should, c.creator, node, c.limits);
+                         task.done();
+                       };
+                     })(config));
+      }
+
+      for (let test in testOnlineConfigs) {
+        let config = testOnlineConfigs[test]
+        audit.define('Online ' + config.creator, (function(c) {
+                       return (task, should) => {
+                         let node = onlineContext[c.creator](...c.args);
+                         testLimits(should, c.creator, node, c.limits);
+                         task.done();
+                       };
+                     })(config));
+      }
+
+      // Test the AudioListener params that were added for the automated Panner
+      audit.define('AudioListener', (task, should) => {
+        testLimits(should, '', offlineContext.listener, {
+          positionX: {
+            minValue: -mostPositiveFloat,
+            maxValue: mostPositiveFloat,
+          },
+          positionY: {
+            minValue: -mostPositiveFloat,
+            maxValue: mostPositiveFloat,
+          },
+          positionZ: {
+            minValue: -mostPositiveFloat,
+            maxValue: mostPositiveFloat,
+          },
+          forwardX: {
+            minValue: -mostPositiveFloat,
+            maxValue: mostPositiveFloat,
+          },
+          forwardY: {
+            minValue: -mostPositiveFloat,
+            maxValue: mostPositiveFloat,
+          },
+          forwardZ: {
+            minValue: -mostPositiveFloat,
+            maxValue: mostPositiveFloat,
+          },
+          upX: {
+            minValue: -mostPositiveFloat,
+            maxValue: mostPositiveFloat,
+          },
+          upY: {
+            minValue: -mostPositiveFloat,
+            maxValue: mostPositiveFloat,
+          },
+          upZ: {
+            minValue: -mostPositiveFloat,
+            maxValue: mostPositiveFloat,
+          }
+        });
+        task.done();
+      });
+
+      // Verify that we have tested all the create methods available on the
+      // context.
+      audit.define('verifyTests', (task, should) => {
+        let allNodes = new Set();
+        // Create the set of all "create" methods from the context.
+        for (let method in offlineContext) {
+          if (typeof offlineContext[method] === 'function' &&
+              method.substring(0, 6) === 'create') {
+            allNodes.add(method);
+          }
+        }
+
+        // Compute the difference between the set of all create methods on the
+        // context and the set of tests that we've run.
+        let diff = new Set([...allNodes].filter(x => !testedMethods.has(x)));
+
+        // Can't currently test a MediaStreamSourceNode, so remove it from the
+        // diff set.
+        diff.delete('createMediaStreamSource');
+
+        // It's a test failure if we didn't test all of the create methods in
+        // the context (except createMediaStreamSource, of course).
+        let output = [];
+        if (diff.size) {
+          for (let item of diff)
+            output.push(' ' + item.substring(6));
+        }
+
+        should(output.length === 0, 'Number of nodes not tested')
+            .message(': 0', ': ' + output);
+
+        task.done();
+      });
+
+      // Simple test of a few automation methods to verify we get warnings.
+      audit.define('automation', (task, should) => {
+        // Just use a DelayNode for testing because the audio param has finite
+        // limits.
+        should(() => {
+          let d = offlineContext.createDelay();
+
+          // The console output should have the warnings that we're interested
+          // in.
+          d.delayTime.setValueAtTime(-1, 0);
+          d.delayTime.linearRampToValueAtTime(2, 1);
+          d.delayTime.exponentialRampToValueAtTime(3, 2);
+          d.delayTime.setTargetAtTime(-1, 3, .1);
+          d.delayTime.setValueCurveAtTime(
+              Float32Array.from([.1, .2, 1.5, -1]), 4, .1);
+        }, 'Test automations (check console logs)').notThrow();
+        task.done();
+      });
+
+      audit.run();
+
+      // Is |object| an AudioParam?  We determine this by checking the
+      // constructor name.
+      function isAudioParam(object) {
+        return object && object.constructor.name === 'AudioParam';
+      }
+
+      // Does |limitOptions| exist and does it have valid values for the
+      // expected min and max values?
+      function hasValidLimits(limitOptions) {
+        return limitOptions && (typeof limitOptions.minValue === 'number') &&
+            (typeof limitOptions.maxValue === 'number');
+      }
+
+      // Check the min and max values for the AudioParam attribute named
+      // |paramName| for the |node|. The expected limits is given by the
+      // dictionary |limits|.  If some test fails, add the name of the failed
+      function validateAudioParamLimits(should, node, paramName, limits) {
+        let nodeName = node.constructor.name;
+        let parameter = node[paramName];
+        let prefix = nodeName + '.' + paramName;
+
+        let success = true;
+        if (hasValidLimits(limits[paramName])) {
+          // Verify that the min and max values for the parameter are correct.
+          let isCorrect = should(parameter.minValue, prefix + '.minValue')
+                              .beEqualTo(limits[paramName].minValue);
+          isCorrect = should(parameter.maxValue, prefix + '.maxValue')
+                          .beEqualTo(limits[paramName].maxValue) &&
+              isCorrect;
+
+          // Verify that the min and max attributes are read-only.  |testValue|
+          // MUST be a number that can be represented exactly the same way as
+          // both a double and single float.  A small integer works nicely.
+          const testValue = 42;
+          parameter.minValue = testValue;
+          let isReadOnly;
+          isReadOnly =
+              should(parameter.minValue, `${prefix}.minValue = ${testValue}`)
+                  .notBeEqualTo(testValue);
+
+          should(isReadOnly, prefix + '.minValue is read-only').beEqualTo(true);
+
+          isCorrect = isReadOnly && isCorrect;
+
+          parameter.maxValue = testValue;
+          isReadOnly =
+              should(parameter.maxValue, `${prefix}.maxValue = ${testValue}`)
+                  .notBeEqualTo(testValue);
+          should(isReadOnly, prefix + '.maxValue is read-only').beEqualTo(true);
+
+          isCorrect = isReadOnly && isCorrect;
+
+          // Now try to set the parameter outside the nominal range.
+          let newValue = 2 * limits[paramName].minValue - 1;
+
+          let isClipped = true;
+          let clippingTested = false;
+          // If the new value is beyond float the largest single-precision
+          // float, skip the test because Chrome throws an error.
+          if (newValue >= -mostPositiveFloat) {
+            parameter.value = newValue;
+            clippingTested = true;
+            isClipped =
+                should(
+                    parameter.value, 'Set ' + prefix + '.value = ' + newValue)
+                    .beEqualTo(parameter.minValue) &&
+                isClipped;
+          }
+
+          newValue = 2 * limits[paramName].maxValue + 1;
+
+          if (newValue <= mostPositiveFloat) {
+            parameter.value = newValue;
+            clippingTested = true;
+            isClipped =
+                should(
+                    parameter.value, 'Set ' + prefix + '.value = ' + newValue)
+                    .beEqualTo(parameter.maxValue) &&
+                isClipped;
+          }
+
+          if (clippingTested) {
+            should(
+                isClipped,
+                prefix + ' was clipped to lie within the nominal range')
+                .beEqualTo(true);
+          }
+
+          isCorrect = isCorrect && isClipped;
+
+          success = isCorrect && success;
+        } else {
+          // Test config didn't specify valid limits.  Fail this test!
+          should(
+              clippingTested,
+              'Limits for ' + nodeName + '.' + paramName +
+                  ' were correctly defined')
+              .beEqualTo(false);
+
+          success = false;
+        }
+
+        return success;
+      }
+
+      // Test all of the AudioParams for |node| using the expected values in
+      // |limits|. |creatorName| is the name of the method to create the node,
+      // and is used to keep trakc of which tests we've run.
+      function testLimits(should, creatorName, node, limits) {
+        let nodeName = node.constructor.name;
+        testedMethods.add(creatorName);
+
+        let success = true;
+
+        // List of all of the AudioParams that were tested.
+        let audioParams = [];
+
+        // List of AudioParams that failed the test.
+        let incorrectParams = [];
+
+        // Look through all of the keys for the node and extract just the
+        // AudioParams
+        Object.keys(node.__proto__).forEach(function(paramName) {
+          if (isAudioParam(node[paramName])) {
+            audioParams.push(paramName);
+            let isValid = validateAudioParamLimits(
+                should, node, paramName, limits, incorrectParams);
+            if (!isValid)
+              incorrectParams.push(paramName);
+
+            success = isValid && success;
+          }
+        });
+
+        // Print an appropriate message depending on whether there were
+        // AudioParams defined or not.
+        if (audioParams.length) {
+          let message =
+              'Nominal ranges for AudioParam(s) of ' + node.constructor.name;
+          should(success, message)
+              .message('are correct', 'are incorrect for: ' + +incorrectParams);
+          return success;
+        } else {
+          should(!limits, nodeName)
+              .message(
+                  'has no AudioParams as expected',
+                  'has no AudioParams but test expected ' + limits);
+        }
+      }
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-setTargetAtTime.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-setTargetAtTime.html
new file mode 100644
index 0000000000..faf00c007b
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-setTargetAtTime.html
@@ -0,0 +1,61 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test AudioParam.setTargetAtTime
+    </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/audioparam-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      // Play a long DC signal out through an AudioGainNode, and call
+      // setValueAtTime() and setTargetAtTime at regular intervals to set the
+      // starting value and the target value. Each time interval has a ramp with
+      // a different starting and target value so that there is a discontinuity
+      // at each time interval boundary. The discontinuity is for testing
+      // timing.  Also, we alternate between an increasing and decreasing ramp
+      // for each interval.
+
+      // Number of tests to run.
+      let numberOfTests = 100;
+
+      // Max allowed difference between the rendered data and the expected
+      // result.
+      let maxAllowedError = 6.5683e-4
+
+      // The AudioGainNode starts with this value instead of the default value.
+      let initialValue = 100;
+
+      // Set the gain node value to the specified value at the specified time.
+      function setValue(value, time) {
+        gainNode.gain.setValueAtTime(value, time);
+      }
+
+      // Generate an exponential approach starting at |startTime| with a target
+      // value of |value|.
+      function automation(value, startTime, endTime){
+          // endTime is not used for setTargetAtTime.
+          gainNode.gain.setTargetAtTime(value, startTime, timeConstant)}
+
+      audit.define(
+          {
+            label: 'test',
+            description: 'AudioParam setTargetAtTime() functionality.'
+          },
+          function(task, should) {
+            createAudioGraphAndTest(
+                task, should, numberOfTests, initialValue, setValue, automation,
+                'setTargetAtTime()', maxAllowedError,
+                createExponentialApproachArray);
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-setValueAtTime.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-setValueAtTime.html
new file mode 100644
index 0000000000..ab2edfd009
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-setValueAtTime.html
@@ -0,0 +1,57 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      audioparam-setValueAtTime.html
+    </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/audioparam-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      // Play a long DC signal out through an AudioGainNode, and call
+      // setValueAtTime() at regular intervals to set the value for the duration
+      // of the interval.  Each time interval has different value so that there
+      // is a discontinuity at each time interval boundary.  The discontinuity
+      // is for testing timing.
+
+      // Number of tests to run.
+      let numberOfTests = 100;
+
+      // Max allowed difference between the rendered data and the expected
+      // result.
+      let maxAllowedError = 6e-8;
+
+      // Set the gain node value to the specified value at the specified time.
+      function setValue(value, time) {
+        gainNode.gain.setValueAtTime(value, time);
+      }
+
+      // For testing setValueAtTime(), we don't need to do anything for
+      // automation. because the value at the beginning of the interval is set
+      // by setValue and it remains constant for the duration, which is what we
+      // want.
+      function automation(value, startTime, endTime) {
+        // Do nothing.
+      }
+
+      audit.define(
+          {
+            label: 'test',
+            description: 'AudioParam setValueAtTime() functionality.'
+          },
+          function(task, should) {
+            createAudioGraphAndTest(
+                task, should, numberOfTests, 1, setValue, automation,
+                'setValueAtTime()', maxAllowedError, createConstantArray);
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-setValueCurve-exceptions.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-setValueCurve-exceptions.html
new file mode 100644
index 0000000000..ed0c15fb9b
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-setValueCurve-exceptions.html
@@ -0,0 +1,426 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Exceptions from setValueCurveAtTime
+    </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 sampleRate = 48000;
+      // Some short duration because we don't need to run the test for very
+      // long.
+      let testDurationSec = 0.125;
+      let testDurationFrames = testDurationSec * sampleRate;
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define('setValueCurve', (task, should) => {
+        let context =
+            new OfflineAudioContext(1, testDurationFrames, sampleRate);
+        let g = context.createGain();
+        let curve = new Float32Array(2);
+
+        // Start time and duration for setValueCurveAtTime
+        let curveStartTime = 0.1 * testDurationSec;
+        let duration = 0.1 * testDurationSec;
+
+        // Some time that is known to be during the setValueCurveTime interval.
+        let automationTime = curveStartTime + duration / 2;
+
+        should(
+            () => {
+              g.gain.setValueCurveAtTime(curve, curveStartTime, duration);
+            },
+            'setValueCurveAtTime(curve, ' + curveStartTime + ', ' + duration +
+                ')')
+            .notThrow();
+
+        should(
+            function() {
+              g.gain.setValueAtTime(1, automationTime);
+            },
+            'setValueAtTime(1, ' + automationTime + ')')
+            .throw(DOMException, 'NotSupportedError');
+
+        should(
+            function() {
+              g.gain.linearRampToValueAtTime(1, automationTime);
+            },
+            'linearRampToValueAtTime(1, ' + automationTime + ')')
+            .throw(DOMException, 'NotSupportedError');
+
+        should(
+            function() {
+              g.gain.exponentialRampToValueAtTime(1, automationTime);
+            },
+            'exponentialRampToValueAtTime(1, ' + automationTime + ')')
+            .throw(DOMException, 'NotSupportedError');
+
+        should(
+            function() {
+              g.gain.setTargetAtTime(1, automationTime, 1);
+            },
+            'setTargetAtTime(1, ' + automationTime + ', 1)')
+            .throw(DOMException, 'NotSupportedError');
+
+        should(
+            function() {
+              g.gain.setValueAtTime(1, curveStartTime + 1.1 * duration);
+            },
+            'setValueAtTime(1, ' + (curveStartTime + 1.1 * duration) + ')')
+            .notThrow();
+
+        task.done();
+      });
+
+      audit.define('value setter', (task, should) => {
+        let context =
+            new OfflineAudioContext(1, testDurationFrames, sampleRate);
+        let g = context.createGain();
+        let curve = new Float32Array(2);
+
+        // Start time and duration for setValueCurveAtTime
+        let curveStartTime = 0.;
+        let duration = 0.2 * testDurationSec;
+
+        // Some time that is known to be during the setValueCurveTime interval.
+        let automationTime = 0.;
+
+        should(
+            () => {
+              g.gain.setValueCurveAtTime(curve, curveStartTime, duration);
+            },
+            'setValueCurveAtTime(curve, ' + curveStartTime + ', ' + duration +
+                ')')
+            .notThrow();
+
+        should(
+            function() {
+              g.gain.value = 0.;
+            },
+            'value setter')
+            .throw(DOMException, 'NotSupportedError');
+
+        task.done();
+      });
+
+      audit.define('automations', (task, should) => {
+        let context =
+            new OfflineAudioContext(1, testDurationFrames, sampleRate);
+        let g = context.createGain();
+
+        let curve = new Float32Array(2);
+        // Start time and duration for setValueCurveAtTime
+        let startTime = 0;
+        let timeInterval = testDurationSec / 10;
+        let time;
+
+        startTime += timeInterval;
+        should(() => {
+          g.gain.linearRampToValueAtTime(1, startTime);
+        }, 'linearRampToValueAtTime(1, ' + startTime + ')').notThrow();
+
+        startTime += timeInterval;
+        should(() => {
+          g.gain.exponentialRampToValueAtTime(1, startTime);
+        }, 'exponentialRampToValueAtTime(1, ' + startTime + ')').notThrow();
+
+        startTime += timeInterval;
+        should(() => {
+          g.gain.setTargetAtTime(1, startTime, 0.1);
+        }, 'setTargetAtTime(1, ' + startTime + ', 0.1)').notThrow();
+
+        startTime += timeInterval;
+        should(() => {
+          g.gain.setValueCurveAtTime(curve, startTime, 0.1);
+        }, 'setValueCurveAtTime(curve, ' + startTime + ', 0.1)').notThrow();
+
+        // Now try to setValueCurve that overlaps each of the above automations
+        startTime = timeInterval / 2;
+
+        for (let k = 0; k < 4; ++k) {
+          time = startTime + timeInterval * k;
+          should(
+              () => {
+                g.gain.setValueCurveAtTime(curve, time, 0.01);
+              },
+              'setValueCurveAtTime(curve, ' + time + ', 0.01)')
+              .throw(DOMException, 'NotSupportedError');
+        }
+
+        // Elements of setValueCurve should be finite.
+        should(
+            () => {
+              g.gain.setValueCurveAtTime(
+                  Float32Array.from([NaN, NaN]), time, 0.01);
+            },
+            'setValueCurveAtTime([NaN, NaN], ' + time + ', 0.01)')
+            .throw(TypeError);
+
+        should(
+            () => {
+              g.gain.setValueCurveAtTime(
+                  Float32Array.from([1, Infinity]), time, 0.01);
+            },
+            'setValueCurveAtTime([1, Infinity], ' + time + ', 0.01)')
+            .throw(TypeError);
+
+        let d = context.createDelay();
+        // Check that we get warnings for out-of-range values and also throw for
+        // non-finite values.
+        should(
+            () => {
+              d.delayTime.setValueCurveAtTime(
+                  Float32Array.from([1, 5]), time, 0.01);
+            },
+            'delayTime.setValueCurveAtTime([1, 5], ' + time + ', 0.01)')
+            .notThrow();
+
+        should(
+            () => {
+              d.delayTime.setValueCurveAtTime(
+                  Float32Array.from([1, 5, Infinity]), time, 0.01);
+            },
+            'delayTime.setValueCurveAtTime([1, 5, Infinity], ' + time +
+                ', 0.01)')
+            .throw(TypeError);
+
+        // One last test that prints out lots of digits for the time.
+        time = Math.PI / 100;
+        should(
+            () => {
+              g.gain.setValueCurveAtTime(curve, time, 0.01);
+            },
+            'setValueCurveAtTime(curve, ' + time + ', 0.01)')
+            .throw(DOMException, 'NotSupportedError');
+
+        task.done();
+      });
+
+      audit.define('catch-exception', (task, should) => {
+        // Verify that the curve isn't inserted into the time line even if we
+        // catch the exception.
+        let context =
+            new OfflineAudioContext(1, testDurationFrames, sampleRate);
+        let gain = context.createGain();
+        let source = context.createBufferSource();
+        let buffer = context.createBuffer(1, 1, context.sampleRate);
+        buffer.getChannelData(0)[0] = 1;
+        source.buffer = buffer;
+        source.loop = true;
+
+        source.connect(gain);
+        gain.connect(context.destination);
+
+        gain.gain.setValueAtTime(1, 0);
+        try {
+          // The value curve has an invalid element. This automation shouldn't
+          // be inserted into the timeline at all.
+          gain.gain.setValueCurveAtTime(
+              Float32Array.from([0, NaN]), 128 / context.sampleRate, .5);
+        } catch (e) {
+        };
+        source.start();
+
+        context.startRendering()
+            .then(function(resultBuffer) {
+              // Since the setValueCurve wasn't inserted, the output should be
+              // exactly 1 for the entire duration.
+              should(
+                  resultBuffer.getChannelData(0),
+                  'Handled setValueCurve exception so output')
+                  .beConstantValueOf(1);
+
+            })
+            .then(() => task.done());
+      });
+
+      audit.define('start-end', (task, should) => {
+        let context =
+            new OfflineAudioContext(1, testDurationFrames, sampleRate);
+        let g = context.createGain();
+        let curve = new Float32Array(2);
+
+        // Verify that a setValueCurve can start at the end of an automation.
+        let time = 0;
+        let timeInterval = testDurationSec / 50;
+        should(() => {
+          g.gain.setValueAtTime(1, time);
+        }, 'setValueAtTime(1, ' + time + ')').notThrow();
+
+        time += timeInterval;
+        should(() => {
+          g.gain.linearRampToValueAtTime(0, time);
+        }, 'linearRampToValueAtTime(0, ' + time + ')').notThrow();
+
+        // setValueCurve starts at the end of the linear ramp. This should be
+        // fine.
+        should(
+            () => {
+              g.gain.setValueCurveAtTime(curve, time, timeInterval);
+            },
+            'setValueCurveAtTime(..., ' + time + ', ' + timeInterval + ')')
+            .notThrow();
+
+        // exponentialRamp ending one interval past the setValueCurve should be
+        // fine.
+        time += 2 * timeInterval;
+        should(() => {
+          g.gain.exponentialRampToValueAtTime(1, time);
+        }, 'exponentialRampToValueAtTime(1, ' + time + ')').notThrow();
+
+        // setValueCurve starts at the end of the exponential ramp. This should
+        // be fine.
+        should(
+            () => {
+              g.gain.setValueCurveAtTime(curve, time, timeInterval);
+            },
+            'setValueCurveAtTime(..., ' + time + ', ' + timeInterval + ')')
+            .notThrow();
+
+        // setValueCurve at the end of the setValueCurve should be fine.
+        time += timeInterval;
+        should(
+            () => {
+              g.gain.setValueCurveAtTime(curve, time, timeInterval);
+            },
+            'setValueCurveAtTime(..., ' + time + ', ' + timeInterval + ')')
+            .notThrow();
+
+        // setValueAtTime at the end of setValueCurve should be fine.
+        time += timeInterval;
+        should(() => {
+          g.gain.setValueAtTime(0, time);
+        }, 'setValueAtTime(0, ' + time + ')').notThrow();
+
+        // setValueCurve at the end of setValueAtTime should be fine.
+        should(
+            () => {
+              g.gain.setValueCurveAtTime(curve, time, timeInterval);
+            },
+            'setValueCurveAtTime(..., ' + time + ', ' + timeInterval + ')')
+            .notThrow();
+
+        // setTarget starting at the end of setValueCurve should be fine.
+        time += timeInterval;
+        should(() => {
+          g.gain.setTargetAtTime(1, time, 1);
+        }, 'setTargetAtTime(1, ' + time + ', 1)').notThrow();
+
+        task.done();
+      });
+
+      audit.define('curve overlap', (task, should) => {
+        let context =
+            new OfflineAudioContext(1, testDurationFrames, sampleRate);
+        let g = context.createGain();
+        let startTime = 5;
+        let startTimeLater = 10;
+        let startTimeEarlier = 2.5;
+        let curveDuration = 10;
+        let curveDurationShorter = 5;
+        let curve = [1, 2, 3];
+
+        // An initial curve event
+        should(
+            () => {
+              g.gain.setValueCurveAtTime(curve, startTime, curveDuration);
+            },
+            `g.gain.setValueCurveAtTime([${curve}], ${startTime}, ${curveDuration})`)
+            .notThrow();
+
+        // Check that an exception is thrown when trying to overlap two curves,
+        // in various ways
+
+        // Same start time and end time (curve exactly overlapping)
+        should(
+            () => {
+              g.gain.setValueCurveAtTime(curve, startTime, curveDuration);
+            },
+            `second g.gain.setValueCurveAtTime([${curve}], ${startTime}, ${curveDuration})`)
+            .throw(DOMException, 'NotSupportedError');
+        // Same start time, shorter end time
+        should(
+            () => {
+              g.gain.setValueCurveAtTime(curve, startTime, curveDurationShorter);
+            },
+            `g.gain.setValueCurveAtTime([${curve}], ${startTime}, ${curveDurationShorter})`)
+            .throw(DOMException, 'NotSupportedError');
+        // Earlier start time, end time after the start time an another curve
+        should(
+            () => {
+              g.gain.setValueCurveAtTime(curve, startTimeEarlier, curveDuration);
+            },
+            `g.gain.setValueCurveAtTime([${curve}], ${startTimeEarlier}, ${curveDuration})`)
+            .throw(DOMException, 'NotSupportedError');
+        // Start time after the start time of the other curve, but earlier than
+        // its end.
+        should(
+            () => {
+              g.gain.setValueCurveAtTime(curve, startTimeLater, curveDuration);
+            },
+            `g.gain.setValueCurveAtTime([${curve}], ${startTimeLater}, ${curveDuration})`)
+            .throw(DOMException, 'NotSupportedError');
+
+        // New event wholly contained inside existing event
+        should(
+            () => {
+              g.gain.setValueCurveAtTime(curve, startTime + 1, curveDuration - 1);
+            },
+            `g.gain.setValueCurveAtTime([${curve}], ${startTime+1}, ${curveDuration-1})`)
+            .throw(DOMException, 'NotSupportedError');
+        // Old event completely contained inside new event
+        should(
+            () => {
+              g.gain.setValueCurveAtTime(curve, startTime - 1, curveDuration + 1);
+            },
+            `g.gain.setValueCurveAtTime([${curve}], ${startTime-1}, ${curveDuration+1})`)
+            .throw(DOMException, 'NotSupportedError');
+        // Setting an event exactly at the end of the curve should work.
+        should(
+            () => {
+              g.gain.setValueAtTime(1.0, startTime + curveDuration);
+            },
+            `g.gain.setValueAtTime(1.0, ${startTime + curveDuration})`)
+            .notThrow();
+
+        task.done();
+      });
+
+      audit.define('curve lengths', (task, should) => {
+        let context =
+            new OfflineAudioContext(1, testDurationFrames, sampleRate);
+        let g = context.createGain();
+        let time = 0;
+
+        // Check for invalid curve lengths
+        should(
+            () => {
+              g.gain.setValueCurveAtTime(Float32Array.from([]), time, 0.01);
+            },
+            'setValueCurveAtTime([], ' + time + ', 0.01)')
+            .throw(DOMException, 'InvalidStateError');
+
+        should(
+            () => {
+              g.gain.setValueCurveAtTime(Float32Array.from([1]), time, 0.01);
+            },
+            'setValueCurveAtTime([1], ' + time + ', 0.01)')
+            .throw(DOMException, 'InvalidStateError');
+
+        should(() => {
+          g.gain.setValueCurveAtTime(Float32Array.from([1, 2]), time, 0.01);
+        }, 'setValueCurveAtTime([1,2], ' + time + ', 0.01)').notThrow();
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-setValueCurveAtTime.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-setValueCurveAtTime.html
new file mode 100644
index 0000000000..de8406244b
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-setValueCurveAtTime.html
@@ -0,0 +1,71 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test AudioParam.setValueCurveAtTime
+    </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/audioparam-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      // Play a long DC signal out through an AudioGainNode and for each time
+      // interval call setValueCurveAtTime() to set the values for the duration
+      // of the interval.  Each curve is a sine wave, and we assume that the
+      // time interval is not an exact multiple of the period. This causes a
+      // discontinuity between time intervals which is used to test timing.
+
+      // Number of tests to run.
+      let numberOfTests = 20;
+
+      // Max allowed difference between the rendered data and the expected
+      // result. Because of the linear interpolation, the rendered curve isn't
+      // exactly the same as the reference.  This value is experimentally
+      // determined.
+      let maxAllowedError = 3.7194e-6;
+
+      // The amplitude of the sine wave.
+      let sineAmplitude = 1;
+
+      // Frequency of the sine wave.
+      let freqHz = 440;
+
+      // Curve to use for setValueCurveAtTime().
+      let curve;
+
+      // Sets the curve data for the entire time interval.
+      function automation(value, startTime, endTime) {
+        gainNode.gain.setValueCurveAtTime(
+            curve, startTime, endTime - startTime);
+      }
+
+      audit.define(
+          {
+            label: 'test',
+            description: 'AudioParam setValueCurveAtTime() functionality.'
+          },
+          function(task, should) {
+            // The curve of values to use.
+            curve = createSineWaveArray(
+                timeInterval, freqHz, sineAmplitude, sampleRate);
+
+            createAudioGraphAndTest(
+                task, should, numberOfTests, sineAmplitude,
+                function(k) {
+                  // Don't need to set the value.
+                },
+                automation, 'setValueCurveAtTime()', maxAllowedError,
+                createReferenceSineArray,
+                2 * Math.PI * sineAmplitude * freqHz / sampleRate,
+                differenceErrorMetric);
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-summingjunction.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-summingjunction.html
new file mode 100644
index 0000000000..9084942f70
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/audioparam-summingjunction.html
@@ -0,0 +1,120 @@
+<!DOCTYPE html>
+<!--
+Tests that multiple audio-rate signals (AudioNode outputs) can be connected to an AudioParam
+and that these signals are summed, along with the AudioParams intrinsic value.
+-->
+<html>
+  <head>
+    <title>
+      audioparam-summingjunction.html
+    </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/mix-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      let sampleRate = 44100.0;
+      let lengthInSeconds = 1;
+
+      let context = 0;
+
+      // Buffers used by the two gain controlling sources.
+      let linearRampBuffer;
+      let toneBuffer;
+      let toneFrequency = 440;
+
+      // Arbitrary non-zero value.
+      let baselineGain = 5;
+
+      // Allow for a small round-off error.
+      let maxAllowedError = 1e-6;
+
+      function checkResult(renderedBuffer, should) {
+        let renderedData = renderedBuffer.getChannelData(0);
+
+        // Get buffer data from the two sources used to control gain.
+        let linearRampData = linearRampBuffer.getChannelData(0);
+        let toneData = toneBuffer.getChannelData(0);
+
+        let n = renderedBuffer.length;
+
+        should(n, 'Rendered signal length').beEqualTo(linearRampBuffer.length);
+
+        // Check that the rendered result exactly matches the sum of the
+        // intrinsic gain plus the two sources used to control gain. This is
+        // because we're changing the gain of a signal having constant value 1.
+        let success = true;
+        for (let i = 0; i < n; ++i) {
+          let expectedValue = baselineGain + linearRampData[i] + toneData[i];
+          let error = Math.abs(expectedValue - renderedData[i]);
+
+          if (error > maxAllowedError) {
+            success = false;
+            break;
+          }
+        }
+
+        should(
+            success,
+            'Rendered signal matches sum of two audio-rate gain changing signals plus baseline gain')
+            .beTrue();
+      }
+
+      audit.define('test', function(task, should) {
+        let sampleFrameLength = sampleRate * lengthInSeconds;
+
+        // Create offline audio context.
+        context = new OfflineAudioContext(1, sampleFrameLength, sampleRate);
+
+        // Create buffer used by the source which will have its gain controlled.
+        let constantOneBuffer =
+            createConstantBuffer(context, sampleFrameLength, 1);
+        let constantSource = context.createBufferSource();
+        constantSource.buffer = constantOneBuffer;
+
+        // Create 1st buffer used to control gain (a linear ramp).
+        linearRampBuffer = createLinearRampBuffer(context, sampleFrameLength);
+        let gainSource1 = context.createBufferSource();
+        gainSource1.buffer = linearRampBuffer;
+
+        // Create 2st buffer used to control gain (a simple sine wave tone).
+        toneBuffer =
+            createToneBuffer(context, toneFrequency, lengthInSeconds, 1);
+        let gainSource2 = context.createBufferSource();
+        gainSource2.buffer = toneBuffer;
+
+        // Create a gain node controlling the gain of constantSource and make
+        // the connections.
+        let gainNode = context.createGain();
+
+        // Intrinsic baseline gain.
+        // This gain value should be summed with gainSource1 and gainSource2.
+        gainNode.gain.value = baselineGain;
+
+        constantSource.connect(gainNode);
+        gainNode.connect(context.destination);
+
+        // Connect two audio-rate signals to control the .gain AudioParam.
+        gainSource1.connect(gainNode.gain);
+        gainSource2.connect(gainNode.gain);
+
+        // Start all sources at time 0.
+        constantSource.start(0);
+        gainSource1.start(0);
+        gainSource2.start(0);
+
+        context.startRendering().then(buffer => {
+          checkResult(buffer, should);
+          task.done();
+        });
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/automation-rate-testing.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/automation-rate-testing.js
new file mode 100644
index 0000000000..43279f91d6
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/automation-rate-testing.js
@@ -0,0 +1,155 @@
+// Test k-rate vs a-rate AudioParams.
+//
+// |options| describes how the testing of the AudioParam should be done:
+//
+//   sourceNodeName: name of source node to use for testing; defaults to
+//                   'OscillatorNode'.  If set to 'none', then no source node
+//                   is created for testing and it is assumed that the AudioNode
+//                   under test are sources and need to be started.
+//   verifyPieceWiseConstant: if true, verify that the k-rate output is
+//                            piecewise constant for each render quantum.
+//   nodeName:  name of the AudioNode to be tested
+//   nodeOptions:  options to be used in the AudioNode constructor
+//
+//   prefix: Prefix for all output messages (to make them unique for
+//           testharness)
+//
+//   rateSettings: A vector of dictionaries specifying how to set the automation
+//                 rate(s):
+//       name: Name of the AudioParam
+//       value: The automation rate for the AudioParam given by |name|.
+//
+//   automations: A vector of dictionaries specifying how to automate each
+//                AudioParam:
+//       name: Name of the AudioParam
+//
+//       methods: A vector of dictionaries specifying the automation methods to
+//                be used for testing:
+//           name: Automation method to call
+//           options: Arguments for the automation method
+//
+// Testing is somewhat rudimentary.  We create two nodes of the same type.  One
+// node uses the default automation rates for each AudioParam (expecting them to
+// be a-rate).  The second node sets the automation rate of AudioParams to
+// "k-rate".  The set is speciified by |options.rateSettings|.
+//
+// For both of these nodes, the same set of automation methods (given by
+// |options.automations|) is applied.  A simple oscillator is connected to each
+// node which in turn are connected to different channels of an offline context.
+// Channel 0 is the k-rate node output; channel 1, the a-rate output; and
+// channel 3, the difference between the outputs.
+//
+// Success is declared if the difference signal is not exactly zero.  This means
+// the the automations did different things, as expected.
+//
+// The promise from |startRendering| is returned.
+function doTest(context, should, options) {
+  let merger = new ChannelMergerNode(
+      context, {numberOfInputs: context.destination.channelCount});
+  merger.connect(context.destination);
+
+  let src = null;
+
+  // Skip creating a source to drive the graph if |sourceNodeName| is 'none'.
+  // If |sourceNodeName| is given, use that, else default to OscillatorNode.
+  if (options.sourceNodeName !== 'none') {
+    src = new window[options.sourceNodeName || 'OscillatorNode'](context);
+  }
+
+  let kRateNode = new window[options.nodeName](context, options.nodeOptions);
+  let aRateNode = new window[options.nodeName](context, options.nodeOptions);
+  let inverter = new GainNode(context, {gain: -1});
+
+  // Set kRateNode filter to use k-rate params.
+  options.rateSettings.forEach(setting => {
+    kRateNode[setting.name].automationRate = setting.value;
+    // Mostly for documentation in the output.  These should always
+    // pass.
+    should(
+        kRateNode[setting.name].automationRate,
+        `${options.prefix}: Setting ${
+                                      setting.name
+                                    }.automationRate to "${setting.value}"`)
+        .beEqualTo(setting.value);
+  });
+
+  // Run through all automations for each node separately. (Mostly to keep
+  // output of automations together.)
+  options.automations.forEach(param => {
+    param.methods.forEach(method => {
+      // Most for documentation in the output.  These should never throw.
+      let message = `${param.name}.${method.name}(${method.options})`
+      should(() => {
+        kRateNode[param.name][method.name](...method.options);
+      }, options.prefix + ': k-rate node: ' + message).notThrow();
+    });
+  });
+  options.automations.forEach(param => {
+    param.methods.forEach(method => {
+      // Most for documentation in the output.  These should never throw.
+      let message = `${param.name}.${method.name}(${method.options})`
+      should(() => {
+        aRateNode[param.name][method.name](...method.options);
+      }, options.prefix + ': a-rate node:' + message).notThrow();
+    });
+  });
+
+  // Connect the source, if specified.
+  if (src) {
+    src.connect(kRateNode);
+    src.connect(aRateNode);
+  }
+
+  // The k-rate result is channel 0, and the a-rate result is channel 1.
+  kRateNode.connect(merger, 0, 0);
+  aRateNode.connect(merger, 0, 1);
+
+  // Compute the difference between the a-rate and k-rate results and send
+  // that to channel 2.
+  kRateNode.connect(merger, 0, 2);
+  aRateNode.connect(inverter).connect(merger, 0, 2);
+
+  if (src) {
+    src.start();
+  } else {
+    // If there's no source, then assume the test nodes are sources and start
+    // them.
+    kRateNode.start();
+    aRateNode.start();
+  }
+
+  return context.startRendering().then(renderedBuffer => {
+    let kRateOutput = renderedBuffer.getChannelData(0);
+    let aRateOutput = renderedBuffer.getChannelData(1);
+    let diff = renderedBuffer.getChannelData(2);
+
+    // Some informative messages to print out values of the k-rate and
+    // a-rate outputs.  These should always pass.
+    should(
+        kRateOutput, `${options.prefix}: Output of k-rate ${options.nodeName}`)
+        .beEqualToArray(kRateOutput);
+    should(
+        aRateOutput, `${options.prefix}: Output of a-rate ${options.nodeName}`)
+        .beEqualToArray(aRateOutput);
+
+    // The real test.  If k-rate AudioParam is working correctly, the
+    // k-rate result MUST differ from the a-rate result.
+    should(
+        diff,
+        `${
+           options.prefix
+         }: Difference between a-rate and k-rate ${options.nodeName}`)
+        .notBeConstantValueOf(0);
+
+    if (options.verifyPieceWiseConstant) {
+      // Verify that the output from the k-rate parameter is step-wise
+      // constant.
+      for (let k = 0; k < kRateOutput.length; k += 128) {
+        should(
+            kRateOutput.slice(k, k + 128),
+            `${options.prefix} k-rate output [${k}: ${k + 127}]`)
+            .beConstantValueOf(kRateOutput[k]);
+      }
+    }
+  });
+}
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/automation-rate.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/automation-rate.html
new file mode 100644
index 0000000000..a3c11994bb
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/automation-rate.html
@@ -0,0 +1,167 @@
+<!doctype html>
+<html>
+  <head>
+    <title>AudioParam.automationRate tests</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>
+      // For each node that has an AudioParam, verify that the default
+      // |automationRate| has the expected value and that we can change it or
+      // throw an error if it can't be changed.
+
+      // Any valid sample rate is fine; we don't actually render anything in the
+      // tests.
+      let sampleRate = 8000;
+
+      let audit = Audit.createTaskRunner();
+
+      // Array of tests.  Each test is a dictonary consisting of the name of the
+      // node and an array specifying the AudioParam's of the node.  This array
+      // in turn gives the name of the AudioParam, the default value for the
+      // |automationRate|, and whether it is fixed (isFixed).
+      const tests = [
+        {
+          nodeName: 'AudioBufferSourceNode',
+          audioParams: [
+            {name: 'detune', defaultRate: 'k-rate', isFixed: true},
+            {name: 'playbackRate', defaultRate: 'k-rate', isFixed: true}
+          ]
+        },
+        {
+          nodeName: 'BiquadFilterNode',
+          audioParams: [
+            {name: 'frequency', defaultRate: 'a-rate', isFixed: false},
+            {name: 'detune', defaultRate: 'a-rate', isFixed: false},
+            {name: 'Q', defaultRate: 'a-rate', isFixed: false},
+            {name: 'gain', defaultRate: 'a-rate', isFixed: false},
+          ]
+        },
+        {
+          nodeName: 'ConstantSourceNode',
+          audioParams: [{name: 'offset', defaultRate: 'a-rate', isFixed: false}]
+        },
+        {
+          nodeName: 'DelayNode',
+          audioParams:
+              [{name: 'delayTime', defaultRate: 'a-rate', isFixed: false}]
+        },
+        {
+          nodeName: 'DynamicsCompressorNode',
+          audioParams: [
+            {name: 'threshold', defaultRate: 'k-rate', isFixed: true},
+            {name: 'knee', defaultRate: 'k-rate', isFixed: true},
+            {name: 'ratio', defaultRate: 'k-rate', isFixed: true},
+            {name: 'attack', defaultRate: 'k-rate', isFixed: true},
+            {name: 'release', defaultRate: 'k-rate', isFixed: true}
+          ]
+        },
+        {
+          nodeName: 'GainNode',
+          audioParams: [{name: 'gain', defaultRate: 'a-rate', isFixed: false}]
+        },
+        {
+          nodeName: 'OscillatorNode',
+          audioParams: [
+            {name: 'frequency', defaultRate: 'a-rate', isFixed: false},
+            {name: 'detune', defaultRate: 'a-rate', isFixed: false}
+          ]
+        },
+        {
+          nodeName: 'PannerNode',
+          audioParams: [
+            {name: 'positionX', defaultRate: 'a-rate', isFixed: false},
+            {name: 'positionY', defaultRate: 'a-rate', isFixed: false},
+            {name: 'positionZ', defaultRate: 'a-rate', isFixed: false},
+            {name: 'orientationX', defaultRate: 'a-rate', isFixed: false},
+            {name: 'orientationY', defaultRate: 'a-rate', isFixed: false},
+            {name: 'orientationZ', defaultRate: 'a-rate', isFixed: false},
+          ]
+        },
+        {
+          nodeName: 'StereoPannerNode',
+          audioParams: [{name: 'pan', defaultRate: 'a-rate', isFixed: false}]
+        },
+      ];
+
+      tests.forEach(test => {
+        // Define a separate test for each test entry.
+        audit.define(test.nodeName, (task, should) => {
+          let context = new OfflineAudioContext(
+              {length: sampleRate, sampleRate: sampleRate});
+          // Construct the node and test each AudioParam of the node.
+          let node = new window[test.nodeName](context);
+          test.audioParams.forEach(param => {
+            testAudioParam(
+                should, {nodeName: test.nodeName, node: node, param: param});
+          });
+
+          task.done();
+        });
+      });
+
+      // AudioListener needs it's own special test since it's not a node.
+      audit.define('AudioListener', (task, should) => {
+        let context = new OfflineAudioContext(
+            {length: sampleRate, sampleRate: sampleRate});
+
+        [{name: 'positionX', defaultRate: 'a-rate', isFixed: false},
+         {name: 'positionY', defaultRate: 'a-rate', isFixed: false},
+         {name: 'positionZ', defaultRate: 'a-rate', isFixed: false},
+         {name: 'forwardX', defaultRate: 'a-rate', isFixed: false},
+         {name: 'forwardY', defaultRate: 'a-rate', isFixed: false},
+         {name: 'forwardZ', defaultRate: 'a-rate', isFixed: false},
+         {name: 'upX', defaultRate: 'a-rate', isFixed: false},
+         {name: 'upY', defaultRate: 'a-rate', isFixed: false},
+         {name: 'upZ', defaultRate: 'a-rate', isFixed: false},
+        ].forEach(param => {
+          testAudioParam(should, {
+            nodeName: 'AudioListener',
+            node: context.listener,
+            param: param
+          });
+        });
+        task.done();
+      });
+
+      audit.run();
+
+      function testAudioParam(should, options) {
+        let param = options.param;
+        let audioParam = options.node[param.name];
+        let defaultRate = param.defaultRate;
+
+        // Verify that the default value is correct.
+        should(
+            audioParam.automationRate,
+            `Default ${options.nodeName}.${param.name}.automationRate`)
+            .beEqualTo(defaultRate);
+
+        // Try setting the rate to a different rate.  If the |automationRate|
+        // is fixed, expect an error.  Otherwise, expect no error and expect
+        // the value is changed to the new value.
+        let newRate = defaultRate === 'a-rate' ? 'k-rate' : 'a-rate';
+        let setMessage = `Set ${
+                                options.nodeName
+                              }.${param.name}.automationRate to "${newRate}"`
+
+        if (param.isFixed) {
+          should(() => audioParam.automationRate = newRate, setMessage)
+              .throw(DOMException, 'InvalidStateError');
+        }
+        else {
+          should(() => audioParam.automationRate = newRate, setMessage)
+              .notThrow();
+          should(
+              audioParam.automationRate,
+              `${options.nodeName}.${param.name}.automationRate`)
+              .beEqualTo(newRate);
+        }
+      }
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/cancel-scheduled-values.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/cancel-scheduled-values.html
new file mode 100644
index 0000000000..ac1da8cd51
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/cancel-scheduled-values.html
@@ -0,0 +1,155 @@
+<!doctype html>
+<html>
+  <head>
+    <title>
+      cancelScheduledValues
+    </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>
+      let sampleRate = 8000;
+      let renderFrames = 8000;
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {label: 'cancel-time', description: 'handle cancelTime values'},
+          (task, should) => {
+            let context = new OfflineAudioContext({
+              numberOfChannels: 1,
+              length: renderFrames,
+              sampleRate: sampleRate
+            });
+
+            let src = new ConstantSourceNode(context);
+            src.connect(context.destination);
+
+            should(
+                () => src.offset.cancelScheduledValues(-1),
+                'cancelScheduledValues(-1)')
+                .throw(RangeError);
+
+            // These are TypeErrors because |cancelTime| is a
+            // double, not unrestricted double.
+            should(
+                () => src.offset.cancelScheduledValues(NaN),
+                'cancelScheduledValues(NaN)')
+                .throw(TypeError);
+
+            should(
+                () => src.offset.cancelScheduledValues(Infinity),
+                'cancelScheduledValues(Infinity)')
+                .throw(TypeError);
+
+            task.done();
+          });
+
+      audit.define(
+          {label: 'cancel1', description: 'cancel setValueCurve'},
+          (task, should) => {
+            let context = new OfflineAudioContext({
+              numberOfChannels: 1,
+              length: renderFrames,
+              sampleRate: sampleRate
+            });
+
+            let src = new ConstantSourceNode(context);
+            let gain = new GainNode(context);
+            src.connect(gain).connect(context.destination);
+
+            // Initial time and value for first automation (setValue)
+            let time0 = 0;
+            let value0 = 0.5;
+
+            // Time and duration of the setValueCurve. We'll also schedule a
+            // setValue at the same time.
+            let value1 = 1.5;
+            let curveStartTime = 0.25;
+            let curveDuration = 0.25;
+
+            // Time at which to cancel events
+            let cancelTime = 0.3;
+
+            // Time and value for event added after cancelScheduledValues has
+            // been called.
+            let time2 = curveStartTime + curveDuration / 2;
+            let value2 = 3;
+
+            // Self-consistency checks for the test.
+            should(cancelTime, 'cancelTime is after curve start')
+                .beGreaterThan(curveStartTime);
+            should(cancelTime, 'cancelTime is before curve ends')
+                .beLessThan(curveStartTime + curveDuration);
+
+            // These assertions are just to show what's happening
+            should(
+                () => gain.gain.setValueAtTime(value0, time0),
+                `gain.gain.setValueAtTime(${value0}, ${time0})`)
+                .notThrow();
+            // setValue at the sime time as the curve, to test that this event
+            // wasn't rmeoved.
+            should(
+                () => gain.gain.setValueAtTime(value1, curveStartTime),
+                `gain.gain.setValueAtTime(${value1}, ${curveStartTime})`)
+                .notThrow();
+
+            should(
+                () => gain.gain.setValueCurveAtTime(
+                    [1, -1], curveStartTime, curveDuration),
+                `gain.gain.setValueCurveAtTime(..., ${curveStartTime}, ${
+                    curveDuration})`)
+                .notThrow();
+
+            // An event after the curve to verify this is removed.
+            should(
+                () => gain.gain.setValueAtTime(
+                    99, curveStartTime + curveDuration),
+                `gain.gain.setValueAtTime(99, ${
+                    curveStartTime + curveDuration})`)
+                .notThrow();
+
+            // Cancel events now.
+            should(
+                () => gain.gain.cancelScheduledValues(cancelTime),
+                `gain.gain.cancelScheduledValues(${cancelTime})`)
+                .notThrow();
+
+            // Simple check that the setValueCurve is gone, by scheduling
+            // something in the middle of the (now deleted) event
+            should(
+                () => gain.gain.setValueAtTime(value2, time2),
+                `gain.gain.setValueAtTime(${value2}, ${time2})`)
+                .notThrow();
+
+            src.start();
+            context.startRendering()
+                .then(buffer => {
+                  let audio = buffer.getChannelData(0);
+
+                  // After canceling events, verify that the outputs have the
+                  // desired values.
+                  let curveFrame = curveStartTime * context.sampleRate;
+                  should(
+                      audio.slice(0, curveFrame), `output[0:${curveFrame - 1}]`)
+                      .beConstantValueOf(value0);
+
+                  let time2Frame = time2 * context.sampleRate;
+                  should(
+                      audio.slice(curveFrame, time2Frame),
+                      `output[${curveFrame}:${time2Frame - 1}]`)
+                      .beConstantValueOf(value1);
+
+                  should(audio.slice(time2Frame), `output[${time2Frame}:]`)
+                      .beConstantValueOf(value2);
+                })
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/event-insertion.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/event-insertion.html
new file mode 100644
index 0000000000..b846f982ab
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/event-insertion.html
@@ -0,0 +1,411 @@
+<!doctype html>
+<html>
+  <head>
+    <title>
+      Test Handling of Event Insertion
+    </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/audio-param.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      // Use a power of two for the sample rate so there's no round-off in
+      // computing time from frame.
+      let sampleRate = 16384;
+
+      audit.define(
+          {label: 'Insert same event at same time'}, (task, should) => {
+            // Context for testing.
+            let context = new OfflineAudioContext(
+                {length: 16384, sampleRate: sampleRate});
+
+            // The source node to use.  Automations will be scheduled here.
+            let src = new ConstantSourceNode(context, {offset: 0});
+            src.connect(context.destination);
+
+            // An array of tests to be done.  Each entry specifies the event
+            // type and the event time.  The events are inserted in the order
+            // given (in |values|), and the second event should be inserted
+            // after the first one, as required by the spec.
+            let testCases = [
+              {
+                event: 'setValueAtTime',
+                frame: RENDER_QUANTUM_FRAMES,
+                values: [99, 1],
+                outputTestFrame: RENDER_QUANTUM_FRAMES,
+                expectedOutputValue: 1
+              },
+              {
+                event: 'linearRampToValueAtTime',
+                frame: 2 * RENDER_QUANTUM_FRAMES,
+                values: [99, 2],
+                outputTestFrame: 2 * RENDER_QUANTUM_FRAMES,
+                expectedOutputValue: 2
+              },
+              {
+                event: 'exponentialRampToValueAtTime',
+                frame: 3 * RENDER_QUANTUM_FRAMES,
+                values: [99, 3],
+                outputTestFrame: 3 * RENDER_QUANTUM_FRAMES,
+                expectedOutputValue: 3
+              },
+              {
+                event: 'setValueCurveAtTime',
+                frame: 3 * RENDER_QUANTUM_FRAMES,
+                values: [[3, 4]],
+                extraArgs: RENDER_QUANTUM_FRAMES / context.sampleRate,
+                outputTestFrame: 4 * RENDER_QUANTUM_FRAMES,
+                expectedOutputValue: 4
+              },
+              {
+                event: 'setValueAtTime',
+                frame: 5 * RENDER_QUANTUM_FRAMES - 1,
+                values: [99, 1, 5],
+                outputTestFrame: 5 * RENDER_QUANTUM_FRAMES,
+                expectedOutputValue: 5
+              }
+            ];
+
+            testCases.forEach(entry => {
+              entry.values.forEach(value => {
+                let eventTime = entry.frame / context.sampleRate;
+                let message = eventToString(
+                    entry.event, value, eventTime, entry.extraArgs);
+                // This is mostly to print out the event that is getting
+                // inserted.  It should never ever throw.
+                should(() => {
+                  src.offset[entry.event](value, eventTime, entry.extraArgs);
+                }, message).notThrow();
+              });
+            });
+
+            src.start();
+
+            context.startRendering()
+                .then(audioBuffer => {
+                  let audio = audioBuffer.getChannelData(0);
+
+                  // Look through the test cases to figure out what the correct
+                  // output values should be.
+                  testCases.forEach(entry => {
+                    let expected = entry.expectedOutputValue;
+                    let frame = entry.outputTestFrame;
+                    let time = frame / context.sampleRate;
+                    should(
+                        audio[frame], `Output at frame ${frame} (time ${time})`)
+                        .beEqualTo(expected);
+                  });
+                })
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: 'Linear + Expo',
+            description: 'Different events at same time'
+          },
+          (task, should) => {
+            // Should be a linear ramp up to the event time, and after a
+            // constant value because the exponential ramp has ended.
+            let testCase = [
+              {event: 'linearRampToValueAtTime', value: 2, relError: 0},
+              {event: 'setValueAtTime', value: 99},
+              {event: 'exponentialRampToValueAtTime', value: 3},
+            ];
+            let eventFrame = 2 * RENDER_QUANTUM_FRAMES;
+            let prefix = 'Linear+Expo: ';
+
+            testEventInsertion(prefix, should, eventFrame, testCase)
+                .then(expectConstant(prefix, should, eventFrame, testCase))
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: 'Expo + Linear',
+            description: 'Different events at same time',
+          },
+          (task, should) => {
+            // Should be an exponential ramp up to the event time, and after a
+            // constant value because the linear ramp has ended.
+            let testCase = [
+              {
+                event: 'exponentialRampToValueAtTime',
+                value: 3,
+                relError: 4.2533e-6
+              },
+              {event: 'setValueAtTime', value: 99},
+              {event: 'linearRampToValueAtTime', value: 2},
+            ];
+            let eventFrame = 2 * RENDER_QUANTUM_FRAMES;
+            let prefix = 'Expo+Linear: ';
+
+            testEventInsertion(prefix, should, eventFrame, testCase)
+                .then(expectConstant(prefix, should, eventFrame, testCase))
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: 'Linear + SetTarget',
+            description: 'Different events at same time',
+          },
+          (task, should) => {
+            // Should be a linear ramp up to the event time, and then a
+            // decaying value.
+            let testCase = [
+              {event: 'linearRampToValueAtTime', value: 3, relError: 0},
+              {event: 'setValueAtTime', value: 100},
+              {event: 'setTargetAtTime', value: 0, extraArgs: 0.1},
+            ];
+            let eventFrame = 2 * RENDER_QUANTUM_FRAMES;
+            let prefix = 'Linear+SetTarget: ';
+
+            testEventInsertion(prefix, should, eventFrame, testCase)
+                .then(audioBuffer => {
+                  let audio = audioBuffer.getChannelData(0);
+                  let prefix = 'Linear+SetTarget: ';
+                  let eventTime = eventFrame / sampleRate;
+                  let expectedValue = methodMap[testCase[0].event](
+                      (eventFrame - 1) / sampleRate, 1, 0, testCase[0].value,
+                      eventTime);
+                  should(
+                      audio[eventFrame - 1],
+                      prefix +
+                          `At time ${
+                                     (eventFrame - 1) / sampleRate
+                                   } (frame ${eventFrame - 1}) output`)
+                      .beCloseTo(
+                          expectedValue,
+                          {threshold: testCase[0].relError || 0});
+
+                  // The setValue should have taken effect
+                  should(
+                      audio[eventFrame],
+                      prefix +
+                          `At time ${eventTime} (frame ${eventFrame}) output`)
+                      .beEqualTo(testCase[1].value);
+
+                  // The final event is setTarget.  Compute the expected output.
+                  let actual = audio.slice(eventFrame);
+                  let expected = new Float32Array(actual.length);
+                  for (let k = 0; k < expected.length; ++k) {
+                    let t = (eventFrame + k) / sampleRate;
+                    expected[k] = audioParamSetTarget(
+                        t, testCase[1].value, eventTime, testCase[2].value,
+                        testCase[2].extraArgs);
+                  }
+                  should(
+                      actual,
+                      prefix +
+                          `At time ${eventTime} (frame ${
+                                                         eventFrame
+                                                       }) and later`)
+                      .beCloseToArray(expected, {relativeThreshold: 2.6694e-7});
+                })
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: 'Multiple linear ramps at the same time',
+            description: 'Verify output'
+          },
+          (task, should) => {
+            testMultipleSameEvents(should, {
+              method: 'linearRampToValueAtTime',
+              prefix: 'Multiple linear ramps: ',
+              threshold: 0
+            }).then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: 'Multiple exponential ramps at the same time',
+            description: 'Verify output'
+          },
+          (task, should) => {
+            testMultipleSameEvents(should, {
+              method: 'exponentialRampToValueAtTime',
+              prefix: 'Multiple exponential ramps: ',
+              threshold: 5.3924e-7
+            }).then(() => task.done());
+          });
+
+      audit.run();
+
+      // Takes a list of |testCases| consisting of automation methods and
+      // schedules them to occur at |eventFrame|. |prefix| is a prefix for
+      // messages produced by |should|.
+      //
+      // Each item in |testCases| is a dictionary with members:
+      //   event     - the name of automation method to be inserted,
+      //   value     - the value for the event,
+      //   extraArgs - extra arguments if the event needs more than the value
+      //               and time (such as setTargetAtTime).
+      function testEventInsertion(prefix, should, eventFrame, testCases) {
+        let context = new OfflineAudioContext(
+            {length: 4 * RENDER_QUANTUM_FRAMES, sampleRate: sampleRate});
+
+        // The source node to use.  Automations will be scheduled here.
+        let src = new ConstantSourceNode(context, {offset: 0});
+        src.connect(context.destination);
+
+        // Initialize value to 1 at the beginning.
+        src.offset.setValueAtTime(1, 0);
+
+        // Test automations have this event time.
+        let eventTime = eventFrame / context.sampleRate;
+
+        // Sanity check that context is long enough for the test
+        should(
+            eventFrame < context.length,
+            prefix + 'Context length is long enough for the test')
+            .beTrue();
+
+        // Automations to be tested.  The first event should be the actual
+        // output up to the event time.  The last event should be the final
+        // output from the event time and onwards.
+        testCases.forEach(entry => {
+          should(
+              () => {
+                src.offset[entry.event](
+                    entry.value, eventTime, entry.extraArgs);
+              },
+              prefix +
+                  eventToString(
+                      entry.event, entry.value, eventTime, entry.extraArgs))
+              .notThrow();
+        });
+
+        src.start();
+
+        return context.startRendering();
+      }
+
+      // Verify output of test where the final value of the automation is
+      // expected to be constant.
+      function expectConstant(prefix, should, eventFrame, testCases) {
+        return audioBuffer => {
+          let audio = audioBuffer.getChannelData(0);
+
+          let eventTime = eventFrame / sampleRate;
+
+          // Compute the expected value of the first automation one frame before
+          // the event time.  This is a quick check that the correct automation
+          // was done.
+          let expectedValue = methodMap[testCases[0].event](
+              (eventFrame - 1) / sampleRate, 1, 0, testCases[0].value,
+              eventTime);
+          should(
+              audio[eventFrame - 1],
+              prefix +
+                  `At time ${
+                             (eventFrame - 1) / sampleRate
+                           } (frame ${eventFrame - 1}) output`)
+              .beCloseTo(expectedValue, {threshold: testCases[0].relError});
+
+          // The last event scheduled is expected to set the value for all
+          // future times.  Verify that the output has the expected value.
+          should(
+              audio.slice(eventFrame),
+              prefix +
+                  `At time ${eventTime} (frame ${
+                                                 eventFrame
+                                               }) and later, output`)
+              .beConstantValueOf(testCases[testCases.length - 1].value);
+        };
+      }
+
+      // Test output when two events of the same time are scheduled at the same
+      // time.
+      function testMultipleSameEvents(should, options) {
+        let {method, prefix, threshold} = options;
+
+        // Context for testing.
+        let context =
+            new OfflineAudioContext({length: 16384, sampleRate: sampleRate});
+
+        let src = new ConstantSourceNode(context);
+        src.connect(context.destination);
+
+        let initialValue = 1;
+
+        // Informative print
+        should(() => {
+          src.offset.setValueAtTime(initialValue, 0);
+        }, prefix + `setValueAtTime(${initialValue}, 0)`).notThrow();
+
+        let frame = 64;
+        let time = frame / context.sampleRate;
+        let values = [2, 7, 10];
+
+        // Schedule two events of the same type at the same time, but with
+        // different values.
+
+        values.forEach(value => {
+          // Informative prints to show what we're doing in this test.
+          should(
+              () => {
+                src.offset[method](value, time);
+              },
+              prefix +
+                  eventToString(
+                      method,
+                      value,
+                      time,
+                      ))
+              .notThrow();
+        })
+
+        src.start();
+
+        return context.startRendering().then(audioBuffer => {
+          let actual = audioBuffer.getChannelData(0);
+
+          // The output should be a ramp from time 0 to the event time.  But we
+          // only verify the value just before the event time, which should be
+          // fairly close to values[0].  (But compute the actual expected value
+          // to be sure.)
+          let expected = methodMap[method](
+              (frame - 1) / context.sampleRate, initialValue, 0, values[0],
+              time);
+          should(actual[frame - 1], prefix + `Output at frame ${frame - 1}`)
+              .beCloseTo(expected, {threshold: threshold, precision: 3});
+
+          // Any other values shouldn't show up in the output.  Only the value
+          // from last event should appear.  We only check the value at the
+          // event time.
+          should(
+              actual[frame], prefix + `Output at frame ${frame} (${time} sec)`)
+              .beEqualTo(values[values.length - 1]);
+        });
+      }
+
+      // Convert an automation method to a string for printing.
+      function eventToString(method, value, time, extras) {
+        let string = method + '(';
+        string += (value instanceof Array) ? `[${value}]` : value;
+        string += ', ' + time;
+        if (extras) {
+          string += ', ' + extras;
+        }
+        string += ')';
+        return string;
+      }
+
+      // Map between the automation method name and a function that computes the
+      // output value of the automation method.
+      const methodMap = {
+        linearRampToValueAtTime: audioParamLinearRamp,
+        exponentialRampToValueAtTime: audioParamExponentialRamp,
+        setValueAtTime: (t, v) => v
+      };
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-audiobuffersource-connections.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-audiobuffersource-connections.html
new file mode 100644
index 0000000000..0b94bd70f9
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-audiobuffersource-connections.html
@@ -0,0 +1,164 @@
+<!doctype html>
+<html>
+  <head>
+    <title>k-rate AudioParams with inputs for AudioBufferSourceNode</title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+    <script src="/webaudio/resources/audit-util.js"></script>
+  </head>
+
+  <body>
+    <script>
+      let audit = Audit.createTaskRunner();
+
+      // Fairly abitrary sampleRate and somewhat duration
+      const sampleRate = 8000;
+      const testDuration = 0.25;
+
+      [['playbackRate', [1, 0], [2, testDuration]],
+       ['detune', [-1200, 0], [1200, testDuration]]]
+          .forEach(param => {
+            audit.define(
+                {label: param[0], description: `AudioBufferSource ${param[0]}`},
+                async (task, should) => {
+                  await doTest(should, {
+                    prefix: task.label,
+                    paramName: param[0],
+                    startValue: param[1],
+                    endValue: param[2]
+                  });
+                  task.done();
+                });
+          });
+
+      audit.run();
+
+      async function doTest(should, options) {
+        // Test k-rate automation of AudioBufferSourceNode with connected
+        // input.
+        //
+        // A reference source node is created with an automation on the
+        // selected AudioParam. For simplicity, we just use a linear ramp from
+        // the minValue to the maxValue of the AudioParam.
+        //
+        // The test node has an input signal connected to the AudioParam.  This
+        // input signal is created to match the automation on the reference
+        // node.
+        //
+        // Finally, the output from the two nodes must be identical if k-rate
+        // inputs are working correctly.
+        //
+        // Options parameter is a dictionary with the following required
+        // members:
+        //   prefix    - prefix to use for the messages.
+        //   paramName - Name of the AudioParam to be tested
+
+        let {prefix, paramName, startValue, endValue} = options;
+
+        let context = new OfflineAudioContext({
+          numberOfChannels: 2,
+          sampleRate: sampleRate,
+          length: testDuration * sampleRate
+        });
+
+        let merger = new ChannelMergerNode(
+            context, {numberOfInputs: context.destination.channelCount});
+        merger.connect(context.destination);
+
+        // Linear ramp to use for the buffer sources
+        let ramp = createLinearRampBuffer(context, context.length);
+
+        // Create the reference and test nodes.
+        let refNode;
+        let tstNode;
+
+        const nodeOptions = {buffer: ramp};
+
+        should(
+            () => refNode = new AudioBufferSourceNode(context, nodeOptions),
+            `${prefix}: refNode = new AudioBufferSourceNode(context, ${
+                JSON.stringify(nodeOptions)})`)
+            .notThrow();
+
+        should(
+            () => tstNode = new AudioBufferSourceNode(context, nodeOptions),
+            `${prefix}: tstNode = new AudioBufferSourceNode(context, ${
+                JSON.stringify(nodeOptions)})`)
+            .notThrow();
+
+
+        // Automate the AudioParam of the reference node with a linear ramp
+        should(
+            () => refNode[paramName].setValueAtTime(...startValue),
+            `${prefix}: refNode[${paramName}].setValueAtTime(${
+                startValue[0]}, ${startValue[1]})`)
+            .notThrow();
+
+        should(
+            () => refNode[paramName].linearRampToValueAtTime(...endValue),
+            `${prefix}: refNode[${paramName}].linearRampToValueAtTime(${
+                endValue[0]}, ${endValue[1]})`)
+            .notThrow();
+
+
+        // Create the input node and automate it so that it's output when added
+        // to the intrinsic value of the AudioParam we get the same values as
+        // the automations on the reference node.
+
+        // Compute the start and end values based on the defaultValue of the
+        // param and the desired startValue and endValue.  The input is added to
+        // the intrinsic value of the AudioParam, so we need to account for
+        // that.
+
+        let mod;
+        should(
+            () => mod = new ConstantSourceNode(context, {offset: 0}),
+            `${prefix}: mod = new ConstantSourceNode(context, {offset: 0})`)
+            .notThrow();
+
+        let modStart = startValue[0] - refNode[paramName].defaultValue;
+        let modEnd = endValue[0] - refNode[paramName].defaultValue;
+        should(
+            () => mod.offset.setValueAtTime(modStart, startValue[1]),
+            `${prefix}: mod.offset.setValueAtTime(${modStart}, ${
+                startValue[1]})`)
+            .notThrow();
+        should(
+            () => mod.offset.linearRampToValueAtTime(modEnd, endValue[1]),
+            `${prefix}: mod.offset.linearRampToValueAtTime(${modEnd}, ${
+                endValue[1]})`)
+            .notThrow();
+
+        // Connect up everything.
+        should(
+            () => mod.connect(tstNode[paramName]),
+            `${prefix}: mod.connect(tstNode[${paramName}])`)
+            .notThrow();
+
+        refNode.connect(merger, 0, 0);
+        tstNode.connect(merger, 0, 1);
+
+        // Go!
+        refNode.start();
+        tstNode.start();
+        mod.start();
+
+        const buffer = await context.startRendering();
+        let expected = buffer.getChannelData(0);
+        let actual = buffer.getChannelData(1);
+
+        // Quick sanity check that output isn't zero.  This means we messed up
+        // the connections or automations or the buffer source.
+        should(expected, `Expected k-rate ${paramName} AudioParam with input`)
+            .notBeConstantValueOf(0);
+        should(actual, `Actual k-rate ${paramName} AudioParam with input`)
+            .notBeConstantValueOf(0);
+
+        // The expected and actual results must be EXACTLY the same.
+        should(actual, `k-rate ${paramName} AudioParam with input`)
+            .beCloseToArray(expected, {absoluteThreshold: 0});
+      }
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-audioworklet-connections.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-audioworklet-connections.https.html
new file mode 100644
index 0000000000..4d2eb40d55
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-audioworklet-connections.https.html
@@ -0,0 +1,77 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Test k-rate AudioParams with inputs for AudioWorkletNode</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>
+      const audit = Audit.createTaskRunner();
+
+      // Use the worklet gain node to test k-rate parameters.
+      const filePath =
+          '../the-audioworklet-interface/processors/gain-processor.js';
+
+      // Context for testing
+      let context;
+
+      audit.define('Create Test Worklet', (task, should) => {
+        // Arbitrary sample rate and duration.
+        const sampleRate = 8000;
+
+        // Only new a few render quanta to verify things are working.
+        const testDuration = 4 * 128 / sampleRate;
+
+        context = new OfflineAudioContext({
+          numberOfChannels: 3,
+          sampleRate: sampleRate,
+          length: testDuration * sampleRate
+        });
+
+        should(
+            context.audioWorklet.addModule(filePath),
+            'Construction of AudioWorklet')
+            .beResolved()
+            .then(() => task.done());
+      });
+
+      audit.define('AudioWorklet k-rate AudioParam', async (task, should) => {
+        let src = new ConstantSourceNode(context);
+        let kRateNode = new AudioWorkletNode(context, 'gain');
+        src.connect(kRateNode).connect(context.destination);
+
+        let kRateParam = kRateNode.parameters.get('gain');
+        kRateParam.automationRate = 'k-rate';
+        kRateParam.value = 0;
+
+        let mod = new ConstantSourceNode(context);
+        mod.offset.setValueAtTime(0, 0);
+        mod.offset.linearRampToValueAtTime(
+            10, context.length / context.sampleRate);
+        mod.connect(kRateParam);
+
+        mod.start();
+        src.start();
+
+        const audioBuffer = await context.startRendering();
+        let output = audioBuffer.getChannelData(0);
+
+        // Verify that the output isn't constantly zero.
+        should(output, 'output').notBeConstantValueOf(0);
+        // Verify that the output from the worklet is step-wise
+        // constant.
+        for (let k = 0; k < output.length; k += 128) {
+          should(output.slice(k, k + 128), ` k-rate output [${k}: ${k + 127}]`)
+              .beConstantValueOf(output[k]);
+        }
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-audioworklet.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-audioworklet.https.html
new file mode 100644
index 0000000000..e891da6da2
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-audioworklet.https.html
@@ -0,0 +1,79 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Test k-rate AudioParam of AudioWorkletNode</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>
+      const audit = Audit.createTaskRunner();
+
+      // Use the worklet gain node to test k-rate parameters.
+      const filePath =
+          '../the-audioworklet-interface/processors/gain-processor.js';
+
+      // Context for testing
+      let context;
+
+      audit.define('Create Test Worklet', (task, should) => {
+
+        // Arbitrary sample rate and duration.
+        const sampleRate = 8000;
+
+        // Only new a few render quanta to verify things are working.
+        const testDuration = 4 * 128 / sampleRate;
+
+        context = new OfflineAudioContext({
+          numberOfChannels: 3,
+          sampleRate: sampleRate,
+          length: testDuration * sampleRate
+        });
+
+        should(
+            context.audioWorklet.addModule(filePath),
+            'Construction of AudioWorklet')
+            .beResolved()
+            .then(() => task.done());
+      });
+
+      audit.define('AudioWorklet k-rate AudioParam', (task, should) => {
+        let src = new ConstantSourceNode(context);
+
+        let kRateNode = new AudioWorkletNode(context, 'gain');
+
+        src.connect(kRateNode).connect(context.destination);
+
+        let kRateParam = kRateNode.parameters.get('gain');
+        kRateParam.automationRate = 'k-rate';
+
+        // Automate the gain
+        kRateParam.setValueAtTime(0, 0);
+        kRateParam.linearRampToValueAtTime(
+            10, context.length / context.sampleRate);
+
+        src.start();
+
+        context.startRendering()
+            .then(audioBuffer => {
+              let output = audioBuffer.getChannelData(0);
+
+              // Verify that the output from the worklet is step-wise
+              // constant.
+              for (let k = 0; k < output.length; k += 128) {
+                should(
+                    output.slice(k, k + 128),
+                    ` k-rate output [${k}: ${k + 127}]`)
+                    .beConstantValueOf(output[k]);
+              }
+            })
+            .then(() => task.done());
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-biquad-connection.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-biquad-connection.html
new file mode 100644
index 0000000000..ab9df8740f
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-biquad-connection.html
@@ -0,0 +1,456 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Test k-rate AudioParam Inputs for BiquadFilterNode</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>
+      // sampleRate and duration are fairly arbitrary.  We use low values to
+      // limit the complexity of the test.
+      let sampleRate = 8192;
+      let testDuration = 0.5;
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {label: 'Frequency AudioParam', description: 'k-rate input works'},
+          async (task, should) => {
+            // Test frequency AudioParam using a lowpass filter whose bandwidth
+            // is initially larger than the oscillator frequency.  Then automate
+            // the frequency to 0 so that the output of the filter is 0 (because
+            // the cutoff is 0).
+            let oscFrequency = 440;
+
+            let options = {
+              sampleRate: sampleRate,
+              paramName: 'frequency',
+              oscFrequency: oscFrequency,
+              testDuration: testDuration,
+              filterOptions: {type: 'lowpass', frequency: 0},
+              autoStart:
+                  {method: 'setValueAtTime', args: [2 * oscFrequency, 0]},
+              autoEnd: {
+                method: 'linearRampToValueAtTime',
+                args: [0, testDuration / 4]
+              }
+            };
+
+            let buffer = await doTest(should, options);
+            let expected = buffer.getChannelData(0);
+            let actual = buffer.getChannelData(1);
+            let halfLength = expected.length / 2;
+
+            // Sanity check.  The expected output should not be zero for
+            // the first half, but should be zero for the second half
+            // (because the filter bandwidth is exactly 0).
+            const prefix = 'Expected k-rate frequency with automation';
+
+            should(
+                expected.slice(0, halfLength),
+                `${prefix} output[0:${halfLength - 1}]`)
+                .notBeConstantValueOf(0);
+            should(
+                expected.slice(expected.length),
+                `${prefix} output[${halfLength}:]`)
+                .beConstantValueOf(0);
+
+            // Outputs should be the same.  Break the message into two
+            // parts so we can see the expected outputs.
+            checkForSameOutput(should, options.paramName, actual, expected);
+
+            task.done();
+          });
+
+      audit.define(
+          {label: 'Q AudioParam', description: 'k-rate input works'},
+          async (task, should) => {
+            // Test Q AudioParam.  Use a bandpass filter whose center frequency
+            // is fairly far from the oscillator frequency.  Then start with a Q
+            // value of 0 (so everything goes through) and then increase Q to
+            // some large value such that the out-of-band signals are basically
+            // cutoff.
+            let frequency = 440;
+            let oscFrequency = 4 * frequency;
+
+            let options = {
+              sampleRate: sampleRate,
+              oscFrequency: oscFrequency,
+              testDuration: testDuration,
+              paramName: 'Q',
+              filterOptions: {type: 'bandpass', frequency: frequency, Q: 0},
+              autoStart: {method: 'setValueAtTime', args: [0, 0]},
+              autoEnd: {
+                method: 'linearRampToValueAtTime',
+                args: [100, testDuration / 4]
+              }
+            };
+
+            const buffer = await doTest(should, options);
+            let expected = buffer.getChannelData(0);
+            let actual = buffer.getChannelData(1);
+
+            // Outputs should be the same
+            checkForSameOutput(should, options.paramName, actual, expected);
+
+            task.done();
+          });
+
+      audit.define(
+          {label: 'Gain AudioParam', description: 'k-rate input works'},
+          async (task, should) => {
+            // Test gain AudioParam.  Use a peaking filter with a large Q so the
+            // peak is narrow with a center frequency the same as the oscillator
+            // frequency.  Start with a gain of 0 so everything goes through and
+            // then ramp the gain down to -100 so that the oscillator is
+            // filtered out.
+            let oscFrequency = 4 * 440;
+
+            let options = {
+              sampleRate: sampleRate,
+              oscFrequency: oscFrequency,
+              testDuration: testDuration,
+              paramName: 'gain',
+              filterOptions:
+                  {type: 'peaking', frequency: oscFrequency, Q: 100, gain: 0},
+              autoStart: {method: 'setValueAtTime', args: [0, 0]},
+              autoEnd: {
+                method: 'linearRampToValueAtTime',
+                args: [-100, testDuration / 4]
+              }
+            };
+
+            const buffer = await doTest(should, options);
+            let expected = buffer.getChannelData(0);
+            let actual = buffer.getChannelData(1);
+
+            // Outputs should be the same
+            checkForSameOutput(should, options.paramName, actual, expected);
+
+            task.done();
+          });
+
+      audit.define(
+          {label: 'Detune AudioParam', description: 'k-rate input works'},
+          async (task, should) => {
+            // Test detune AudioParam.  The basic idea is the same as the
+            // frequency test above, but insteda of automating the frequency, we
+            // automate the detune value so that initially the filter cutuff is
+            // unchanged and then changing the detune until the cutoff goes to 1
+            // Hz, which would cause the oscillator to be filtered out.
+            let oscFrequency = 440;
+            let filterFrequency = 5 * oscFrequency;
+
+            // For a detune value d, the computed frequency, fc, of the filter
+            // is fc = f*2^(d/1200), where f is the frequency of the filter.  Or
+            // d = 1200*log2(fc/f).  Compute the detune value to produce a final
+            // cutoff frequency of 1 Hz.
+            let detuneEnd = 1200 * Math.log2(1 / filterFrequency);
+
+            let options = {
+              sampleRate: sampleRate,
+              oscFrequency: oscFrequency,
+              testDuration: testDuration,
+              paramName: 'detune',
+              filterOptions: {
+                type: 'lowpass',
+                frequency: filterFrequency,
+                detune: 0,
+                gain: 0
+              },
+              autoStart: {method: 'setValueAtTime', args: [0, 0]},
+              autoEnd: {
+                method: 'linearRampToValueAtTime',
+                args: [detuneEnd, testDuration / 4]
+              }
+            };
+
+            const buffer = await doTest(should, options);
+            let expected = buffer.getChannelData(0);
+            let actual = buffer.getChannelData(1);
+
+            // Outputs should be the same
+            checkForSameOutput(should, options.paramName, actual, expected);
+
+            task.done();
+          });
+
+      audit.define('All k-rate inputs', async (task, should) => {
+        // Test the case where all AudioParams are set to k-rate with an input
+        // to each AudioParam.  Similar to the above tests except all the params
+        // are k-rate.
+        let testFrames = testDuration * sampleRate;
+        let context = new OfflineAudioContext(
+            {numberOfChannels: 2, sampleRate: sampleRate, length: testFrames});
+
+        let merger = new ChannelMergerNode(
+            context, {numberOfInputs: context.destination.channelCount});
+        merger.connect(context.destination);
+
+        let src = new OscillatorNode(context);
+
+        // The peaking filter uses all four AudioParams, so this is the node to
+        // test.
+        let filterOptions =
+            {type: 'peaking', frequency: 0, detune: 0, gain: 0, Q: 0};
+        let refNode;
+        should(
+            () => refNode = new BiquadFilterNode(context, filterOptions),
+            `Create: refNode = new BiquadFilterNode(context, ${
+                JSON.stringify(filterOptions)})`)
+            .notThrow();
+
+        let tstNode;
+        should(
+            () => tstNode = new BiquadFilterNode(context, filterOptions),
+            `Create: tstNode = new BiquadFilterNode(context, ${
+                JSON.stringify(filterOptions)})`)
+            .notThrow();
+        ;
+
+        // Make all the AudioParams k-rate.
+        ['frequency', 'Q', 'gain', 'detune'].forEach(param => {
+          should(
+              () => refNode[param].automationRate = 'k-rate',
+              `Set rate: refNode[${param}].automationRate = 'k-rate'`)
+              .notThrow();
+          should(
+              () => tstNode[param].automationRate = 'k-rate',
+              `Set rate: tstNode[${param}].automationRate = 'k-rate'`)
+              .notThrow();
+        });
+
+        // One input for each AudioParam.
+        let mod = {};
+        ['frequency', 'Q', 'gain', 'detune'].forEach(param => {
+          should(
+              () => mod[param] = new ConstantSourceNode(context, {offset: 0}),
+              `Create: mod[${
+                  param}] = new ConstantSourceNode(context, {offset: 0})`)
+              .notThrow();
+          ;
+          should(
+              () => mod[param].offset.automationRate = 'a-rate',
+              `Set rate: mod[${param}].offset.automationRate = 'a-rate'`)
+              .notThrow();
+        });
+
+        // Set up automations for refNode.  We want to start the filter with
+        // parameters that let the oscillator signal through more or less
+        // untouched.  Then change the filter parameters to filter out the
+        // oscillator.  What happens in between doesn't reall matter for this
+        // test.  Hence, set the initial parameters with a center frequency well
+        // above the oscillator and a Q and gain of 0 to pass everthing.
+        [['frequency', [4 * src.frequency.value, 0]], ['Q', [0, 0]],
+         ['gain', [0, 0]], ['detune', [4 * 1200, 0]]]
+            .forEach(param => {
+              should(
+                  () => refNode[param[0]].setValueAtTime(...param[1]),
+                  `Automate 0: refNode.${param[0]}.setValueAtTime(${
+                      param[1][0]}, ${param[1][1]})`)
+                  .notThrow();
+              should(
+                  () => mod[param[0]].offset.setValueAtTime(...param[1]),
+                  `Automate 0: mod[${param[0]}].offset.setValueAtTime(${
+                      param[1][0]}, ${param[1][1]})`)
+                  .notThrow();
+            });
+
+        // Now move the filter frequency to the oscillator frequency with a high
+        // Q and very low gain to remove the oscillator signal.
+        [['frequency', [src.frequency.value, testDuration / 4]],
+         ['Q', [40, testDuration / 4]], ['gain', [-100, testDuration / 4]], [
+           'detune', [0, testDuration / 4]
+         ]].forEach(param => {
+          should(
+              () => refNode[param[0]].linearRampToValueAtTime(...param[1]),
+              `Automate 1: refNode[${param[0]}].linearRampToValueAtTime(${
+                  param[1][0]}, ${param[1][1]})`)
+              .notThrow();
+          should(
+              () => mod[param[0]].offset.linearRampToValueAtTime(...param[1]),
+              `Automate 1: mod[${param[0]}].offset.linearRampToValueAtTime(${
+                  param[1][0]}, ${param[1][1]})`)
+              .notThrow();
+        });
+
+        // Connect everything
+        src.connect(refNode).connect(merger, 0, 0);
+        src.connect(tstNode).connect(merger, 0, 1);
+
+        src.start();
+        for (let param in mod) {
+          should(
+              () => mod[param].connect(tstNode[param]),
+              `Connect: mod[${param}].connect(tstNode.${param})`)
+              .notThrow();
+        }
+
+        for (let param in mod) {
+          should(() => mod[param].start(), `Start: mod[${param}].start()`)
+              .notThrow();
+        }
+
+        const buffer = await context.startRendering();
+        let expected = buffer.getChannelData(0);
+        let actual = buffer.getChannelData(1);
+
+        // Sanity check that the output isn't all zeroes.
+        should(actual, 'All k-rate AudioParams').notBeConstantValueOf(0);
+        should(actual, 'All k-rate AudioParams').beCloseToArray(expected, {
+          absoluteThreshold: 0
+        });
+
+        task.done();
+      });
+
+      audit.run();
+
+      async function doTest(should, options) {
+        // Test that a k-rate AudioParam with an input reads the input value and
+        // is actually k-rate.
+        //
+        // A refNode is created with an automation timeline.  This is the
+        // expected output.
+        //
+        // The testNode is the same, but it has a node connected to the k-rate
+        // AudioParam.  The input to the node is an a-rate ConstantSourceNode
+        // whose output is automated in exactly the same was as the refNode.  If
+        // the test passes, the outputs of the two nodes MUST match exactly.
+
+        // The options argument MUST contain the following members:
+        //   sampleRate - the sample rate for the offline context
+        //   testDuration - duration of the offline context, in sec.
+        //   paramName  - the name of the AudioParam to be tested
+        //   oscFrequency - frequency of oscillator source
+        //   filterOptions - options used to construct the BiquadFilterNode
+        //   autoStart     - information about how to start the automation
+        //   autoEnd       - information about how to end the automation
+        //
+        //   The autoStart and autoEnd options are themselves dictionaries with
+        //   the following required members:
+        //     method - name of the automation method to be applied
+        //     args   - array of arguments to be supplied to the method.
+        let {
+          sampleRate,
+          paramName,
+          oscFrequency,
+          autoStart,
+          autoEnd,
+          testDuration,
+          filterOptions
+        } = options;
+
+        let testFrames = testDuration * sampleRate;
+        let context = new OfflineAudioContext(
+            {numberOfChannels: 2, sampleRate: sampleRate, length: testFrames});
+
+        let merger = new ChannelMergerNode(
+            context, {numberOfInputs: context.destination.channelCount});
+        merger.connect(context.destination);
+
+        // Any calls to |should| are meant to be informational so we can see
+        // what nodes are created and the automations used.
+        let src;
+
+        // Create the source.
+        should(
+            () => {
+              src = new OscillatorNode(context, {frequency: oscFrequency});
+            },
+            `${paramName}: new OscillatorNode(context, {frequency: ${
+                oscFrequency}})`)
+            .notThrow();
+
+        // The refNode automates the AudioParam with k-rate automations, no
+        // inputs.
+        let refNode;
+        should(
+            () => {
+              refNode = new BiquadFilterNode(context, filterOptions);
+            },
+            `Reference BiquadFilterNode(c, ${JSON.stringify(filterOptions)})`)
+            .notThrow();
+
+        refNode[paramName].automationRate = 'k-rate';
+
+        // Set up automations for the reference node.
+        should(
+            () => {
+              refNode[paramName][autoStart.method](...autoStart.args);
+            },
+            `refNode.${paramName}.${autoStart.method}(${autoStart.args})`)
+            .notThrow();
+        should(
+            () => {
+              refNode[paramName][autoEnd.method](...autoEnd.args);
+            },
+            `refNode.${paramName}.${autoEnd.method}.(${autoEnd.args})`)
+            .notThrow();
+
+        // The tstNode does the same automation, but it comes from the input
+        // connected to the AudioParam.
+        let tstNode;
+        should(
+            () => {
+              tstNode = new BiquadFilterNode(context, filterOptions);
+            },
+            `Test BiquadFilterNode(context, ${JSON.stringify(filterOptions)})`)
+            .notThrow();
+        tstNode[paramName].automationRate = 'k-rate';
+
+        // Create the input to the AudioParam of the test node.  The output of
+        // this node MUST have the same set of automations as the reference
+        // node, and MUST be a-rate to make sure we're handling k-rate inputs
+        // correctly.
+        let mod = new ConstantSourceNode(context);
+        mod.offset.automationRate = 'a-rate';
+        should(
+            () => {
+              mod.offset[autoStart.method](...autoStart.args);
+            },
+            `${paramName}: mod.offset.${autoStart.method}(${autoStart.args})`)
+            .notThrow();
+        should(
+            () => {
+              mod.offset[autoEnd.method](...autoEnd.args);
+            },
+            `${paramName}: mod.offset.${autoEnd.method}(${autoEnd.args})`)
+            .notThrow();
+
+        // Create graph
+        mod.connect(tstNode[paramName]);
+        src.connect(refNode).connect(merger, 0, 0);
+        src.connect(tstNode).connect(merger, 0, 1);
+
+        // Run!
+        src.start();
+        mod.start();
+        return context.startRendering();
+      }
+
+      function checkForSameOutput(should, paramName, actual, expected) {
+        let halfLength = expected.length / 2;
+
+        // Outputs should be the same.  We break the check into halves so we can
+        // see the expected outputs.  Mostly for a simple visual check that the
+        // output from the second half is small because the tests generally try
+        // to filter out the signal so that the last half of the output is
+        // small.
+        should(
+            actual.slice(0, halfLength),
+            `k-rate ${paramName} with input: output[0,${halfLength}]`)
+            .beCloseToArray(
+                expected.slice(0, halfLength), {absoluteThreshold: 0});
+        should(
+            actual.slice(halfLength),
+            `k-rate ${paramName} with input: output[${halfLength}:]`)
+            .beCloseToArray(expected.slice(halfLength), {absoluteThreshold: 0});
+      }
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-biquad.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-biquad.html
new file mode 100644
index 0000000000..85ae4f175f
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-biquad.html
@@ -0,0 +1,111 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Test k-rate AudioParams of BiquadFilterNode</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="automation-rate-testing.js"></script>
+  </head>
+
+  <body>
+    <script>
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {task: 'BiquadFilter-0', label: 'Biquad k-rate AudioParams (all)'},
+          (task, should) => {
+            // Arbitrary sample rate and duration.
+            let sampleRate = 8000;
+            let testDuration = 1;
+            let context = new OfflineAudioContext({
+              numberOfChannels: 3,
+              sampleRate: sampleRate,
+              length: testDuration * sampleRate
+            });
+
+            doTest(context, should, {
+              nodeName: 'BiquadFilterNode',
+              nodeOptions: {type: 'lowpass'},
+              prefix: 'All k-rate params',
+              // Set all AudioParams to k-rate
+              rateSettings: [
+                {name: 'Q', value: 'k-rate'},
+                {name: 'detune', value: 'k-rate'},
+                {name: 'frequency', value: 'k-rate'},
+                {name: 'gain', value: 'k-rate'},
+              ],
+              // Automate just the frequency
+              automations: [{
+                name: 'frequency',
+                methods: [
+                  {name: 'setValueAtTime', options: [350, 0]}, {
+                    name: 'linearRampToValueAtTime',
+                    options: [0, testDuration]
+                  }
+                ]
+              }]
+            }).then(() => task.done());
+          });
+
+      // Define a test where we verify that a k-rate audio param produces
+      // different results from an a-rate audio param for each of the audio
+      // params of a biquad.
+      //
+      // Each entry gives the name of the AudioParam, an initial value to be
+      // used with setValueAtTime, and a final value to be used with
+      // linearRampToValueAtTime. (See |doTest| for details as well.)
+
+      [{name: 'Q',
+        initial: 1,
+        final: 10
+       },
+       {name: 'detune',
+        initial: 0,
+        final: 1200
+       },
+       {name: 'frequency',
+        initial: 350,
+        final: 0
+       },
+       {name: 'gain',
+        initial: 10,
+        final: 0
+       }].forEach(paramProperty => {
+        audit.define('Biquad k-rate ' + paramProperty.name, (task, should) => {
+          // Arbitrary sample rate and duration.
+          let sampleRate = 8000;
+          let testDuration = 1;
+          let context = new OfflineAudioContext({
+            numberOfChannels: 3,
+            sampleRate: sampleRate,
+            length: testDuration * sampleRate
+          });
+
+          doTest(context, should, {
+            nodeName: 'BiquadFilterNode',
+            nodeOptions: {type: 'peaking', Q: 1, gain: 10},
+            prefix: `k-rate ${paramProperty.name}`,
+            // Just set the frequency to k-rate
+            rateSettings: [
+              {name: paramProperty.name, value: 'k-rate'},
+            ],
+            // Automate just the given AudioParam
+            automations: [{
+              name: paramProperty.name,
+              methods: [
+                {name: 'setValueAtTime', options: [paramProperty.initial, 0]}, {
+                  name: 'linearRampToValueAtTime',
+                  options: [paramProperty.final, testDuration]
+                }
+              ]
+            }]
+          }).then(() => task.done());
+        });
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-connections.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-connections.html
new file mode 100644
index 0000000000..730f03e561
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-connections.html
@@ -0,0 +1,139 @@
+<!doctype html>
+<html>
+  <head>
+    <title>k-rate AudioParams with Inputs</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>
+      let audit = Audit.createTaskRunner();
+
+      // Must be power of two to eliminate round-off
+      const sampleRate = 8192;
+
+      // Arbitrary duration that doesn't need to be too long to verify k-rate
+      // automations.  Probably should be at least a few render quanta.
+      const testDuration = 8 * RENDER_QUANTUM_FRAMES / sampleRate;
+
+      // Test k-rate GainNode.gain is k-rate
+      audit.define(
+          {label: 'Gain', description: 'k-rate GainNode.gain'},
+          (task, should) => {
+            let context = new OfflineAudioContext({
+              numberOfChannels: 2,
+              sampleRate: sampleRate,
+              length: testDuration * sampleRate
+            });
+
+            let merger = new ChannelMergerNode(
+                context, {numberOfInputs: context.destination.channelCount});
+            merger.connect(context.destination);
+
+            let src = new ConstantSourceNode(context);
+
+            createTestSubGraph(context, src, merger, 'GainNode', 'gain');
+
+            src.start();
+            context.startRendering()
+                .then(buffer => {
+                  let actual = buffer.getChannelData(0);
+                  let expected = buffer.getChannelData(1);
+
+                  for (let k = 0; k < actual.length;
+                       k += RENDER_QUANTUM_FRAMES) {
+                    should(
+                        actual.slice(k, k + RENDER_QUANTUM_FRAMES),
+                        `gain[${k}:${k + RENDER_QUANTUM_FRAMES}]`)
+                        .beConstantValueOf(expected[k]);
+                  }
+                })
+                .then(() => task.done());
+          });
+
+      // Test k-rate StereoPannerNode.pan is k-rate
+      audit.define(
+          {label: 'StereoPanner', description: 'k-rate StereoPannerNode.pan'},
+          (task, should) => {
+            let context = new OfflineAudioContext({
+              numberOfChannels: 2,
+              sampleRate: sampleRate,
+              length: testDuration * sampleRate
+            });
+            let merger = new ChannelMergerNode(
+                context, {numberOfInputs: context.destination.channelCount});
+            merger.connect(context.destination);
+
+            let src = new ConstantSourceNode(context);
+
+            createTestSubGraph(
+                context, src, merger, 'StereoPannerNode', 'pan', {
+                  testModSetup: node => {
+                    node.offset.setValueAtTime(-1, 0);
+                    node.offset.linearRampToValueAtTime(1, testDuration);
+                  }
+                });
+
+            src.start();
+            context.startRendering()
+                .then(buffer => {
+                  let actual = buffer.getChannelData(0);
+                  let expected = buffer.getChannelData(1);
+
+                  for (let k = 0; k < actual.length; k += 128) {
+                    should(actual.slice(k, k + 128), `pan[${k}:${k + 128}]`)
+                        .beConstantValueOf(expected[k]);
+                  }
+                })
+                .then(() => task.done());
+          });
+
+      audit.run();
+
+      function createTestSubGraph(
+          context, src, merger, nodeName, paramName, options) {
+        // The test node which has its AudioParam set up for k-rate autmoations.
+        let tstNode = new window[nodeName](context);
+
+        if (options && options.setups) {
+          options.setups(tstNode);
+        }
+        tstNode[paramName].automationRate = 'k-rate';
+
+        // Modulating signal for the test node.  Just a linear ramp. This is
+        // connected to the AudioParam of the tstNode.
+        let tstMod = new ConstantSourceNode(context);
+        if (options && options.testModSetup) {
+          options.testModSetup(tstMod);
+        } else {
+          tstMod.offset.linearRampToValueAtTime(context.length, testDuration);
+        }
+
+        tstMod.connect(tstNode[paramName]);
+        src.connect(tstNode).connect(merger, 0, 0);
+
+        // The ref node is the same type of node as the test node, but uses
+        // a-rate automation.  However, the modulating signal is k-rate.  This
+        // causes the input to the audio param to be constant over a render,
+        // which is basically the same as making the audio param be k-rate.
+        let refNode = new window[nodeName](context);
+        let refMod = new ConstantSourceNode(context);
+        refMod.offset.automationRate = 'k-rate';
+        if (options && options.testModSetup) {
+          options.testModSetup(refMod);
+        } else {
+          refMod.offset.linearRampToValueAtTime(context.length, testDuration);
+        }
+
+        refMod.connect(refNode[paramName]);
+        src.connect(refNode).connect(merger, 0, 1);
+
+        tstMod.start();
+        refMod.start();
+      }
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-constant-source.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-constant-source.html
new file mode 100644
index 0000000000..0bea5c91f8
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-constant-source.html
@@ -0,0 +1,176 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Test k-rate AudioParam of ConstantSourceNode</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="automation-rate-testing.js"></script>
+  </head>
+
+  <body>
+    <script>
+      let audit = Audit.createTaskRunner();
+
+      audit.define('ConstantSource k-rate offset', (task, should) => {
+        // Arbitrary sample rate and duration.
+        let sampleRate = 8000;
+
+        // Only new a few render quanta to verify things are working.
+        let testDuration = 4 * 128 / sampleRate;
+
+        let context = new OfflineAudioContext({
+          numberOfChannels: 3,
+          sampleRate: sampleRate,
+          length: testDuration * sampleRate
+        });
+
+        doTest(context, should, {
+          sourceNodeName: 'none',
+          verifyPieceWiseConstant: true,
+          nodeName: 'ConstantSourceNode',
+          prefix: 'k-rate offset',
+          rateSettings: [{name: 'offset', value: 'k-rate'}],
+          automations: [{
+            name: 'offset',
+            methods: [
+              {name: 'setValueAtTime', options: [0, 0]}, {
+                name: 'linearRampToValueAtTime',
+                options: [10, testDuration]
+              }
+            ]
+          }]
+        }).then(() => task.done());
+      });
+
+      // Parameters for the For the following tests.
+
+      // Must be power of two to eliminate round-off
+      const sampleRate8k = 8192;
+
+      // Arbitrary duration that doesn't need to be too long to verify k-rate
+      // automations.  Probably should be at least a few render quanta.
+      const testDuration = 8 * RENDER_QUANTUM_FRAMES / sampleRate8k;
+
+      // Basic test that k-rate ConstantSourceNode.offset is k-rate.  This is
+      // the basis for all of the following tests, so make sure it's right.
+      audit.define(
+          {
+            label: 'ConstantSourceNode.offset k-rate automation',
+            description:
+                'Explicitly test ConstantSourceNode.offset k-rate automation is k-rate'
+          },
+          (task, should) => {
+            let context = new OfflineAudioContext({
+              numberOfChannels: 2,
+              sampleRate: sampleRate8k,
+              length: testDuration * sampleRate8k
+            });
+            let merger = new ChannelMergerNode(
+                context, {numberOfInputs: context.destination.channelCount});
+            merger.connect(context.destination);
+
+            // k-rate ConstantSource.offset using a linear ramp starting at 0
+            // and incrementing by 1 for each frame.
+            let src = new ConstantSourceNode(context, {offset: 0});
+            src.offset.automationRate = 'k-rate';
+
+            src.offset.setValueAtTime(0, 0);
+            src.offset.linearRampToValueAtTime(context.length, testDuration);
+
+            src.connect(merger, 0, 0);
+
+            src.start();
+
+            // a-rate ConstantSource using the same ramp as above.
+            let refSrc = new ConstantSourceNode(context, {offset: 0});
+
+            refSrc.offset.setValueAtTime(0, 0);
+            refSrc.offset.linearRampToValueAtTime(context.length, testDuration);
+
+            refSrc.connect(merger, 0, 1);
+
+            refSrc.start();
+
+            context.startRendering()
+                .then(buffer => {
+                  let actual = buffer.getChannelData(0);
+                  let expected = buffer.getChannelData(1);
+
+                  for (let k = 0; k < actual.length;
+                       k += RENDER_QUANTUM_FRAMES) {
+                    // Verify that the k-rate output is constant over the render
+                    // and that it matches the value of the a-rate value at the
+                    // beginning of the render.
+                    should(
+                        actual.slice(k, k + RENDER_QUANTUM_FRAMES),
+                        `k-rate ConstantSource.offset:  output[${k}:${
+                            k + RENDER_QUANTUM_FRAMES}]`)
+                        .beConstantValueOf(expected[k]);
+                  }
+                })
+                .then(() => task.done());
+          });
+
+      // This test verifies that a k-rate input to the ConstantSourceNode.offset
+      // works just as if we set the AudioParam to be k-rate.  This is the basis
+      // of the following tests, so make sure it works.
+      audit.define(
+          {
+            label: 'ConstantSource.offset',
+            description: 'Verify k-rate automation matches k-rate input'
+          },
+          (task, should) => {
+            let context = new OfflineAudioContext({
+              numberOfChannels: 2,
+              sampleRate: sampleRate8k,
+              length: testDuration * sampleRate8k
+            });
+
+            let merger = new ChannelMergerNode(
+                context, {numberOfInputs: context.destination.channelCount});
+            merger.connect(context.destination);
+
+            let tstSrc = new ConstantSourceNode(context);
+            let tstMod = new ConstantSourceNode(context);
+            tstSrc.offset.automationRate = 'k-rate';
+            tstMod.offset.linearRampToValueAtTime(context.length, testDuration);
+
+            tstMod.connect(tstSrc.offset)
+            tstSrc.connect(merger, 0, 0);
+
+            let refSrc = new ConstantSourceNode(context);
+            let refMod = new ConstantSourceNode(context);
+            refMod.offset.linearRampToValueAtTime(context.length, testDuration);
+            refMod.offset.automationRate = 'k-rate';
+
+            refMod.connect(refSrc.offset);
+            refSrc.connect(merger, 0, 1);
+
+            tstSrc.start();
+            tstMod.start();
+            refSrc.start();
+            refMod.start();
+
+            context.startRendering()
+                .then(buffer => {
+                  let actual = buffer.getChannelData(0);
+                  let expected = buffer.getChannelData(1);
+
+                  for (let k = 0; k < context.length;
+                       k += RENDER_QUANTUM_FRAMES) {
+                    should(
+                        actual.slice(k, k + RENDER_QUANTUM_FRAMES),
+                        `ConstantSource.offset k-rate input: output[${k}:${
+                            k + RENDER_QUANTUM_FRAMES}]`)
+                        .beConstantValueOf(expected[k]);
+                  }
+                })
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-delay-connections.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-delay-connections.html
new file mode 100644
index 0000000000..fcf66f2e3e
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-delay-connections.html
@@ -0,0 +1,156 @@
+<!doctype html>
+<html>
+  <head>
+    <title>k-rate AudioParams with inputs for DelayNode</title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+    <script src="/webaudio/resources/audit-util.js"></script>
+  </head>
+
+  <body>
+    <script>
+      let audit = Audit.createTaskRunner();
+
+      // Power-of-two to eliminate round-off in computing time and frames, but
+      // is otherwise arbitrary.
+      const sampleRate = 8192;
+
+      // Arbitrary duration except it must be greater than or equal to 1.
+      const testDuration = 1.5;
+
+      audit.define(
+          {label: 'delayTime', description: `DelayNode delayTime k-rate input`},
+          async (task, should) => {
+            // Two channels:  0 = test result, 1 = expected result.
+            let context = new OfflineAudioContext({
+              numberOfChannels: 2,
+              sampleRate: sampleRate,
+              length: testDuration * sampleRate
+            });
+
+            let merger = new ChannelMergerNode(
+                context, {numberOfInputs: context.destination.channelCount});
+            merger.connect(context.destination);
+
+            // Test the DelayNode by having a reference node (refNode) that uses
+            // k-rate automations of delayTime. The test node (testNode) sets
+            // delayTime to k-rate with a connected input that has the same
+            // automation vlaues as the reference node.  The test passes if the
+            // output from each node is identical to each other.
+
+            // Just some non-constant source.
+            let src = new OscillatorNode(context);
+
+            // The end value and time for the linear ramp.  These values are
+            // chosen so that the delay advances faster than real time.
+            let endValue = 1.125;
+            let endTime = 1;
+
+            let refNode;
+
+            should(
+                () => refNode = new DelayNode(context),
+                `refNode = new DelayNode(context)`)
+                .notThrow();
+
+            should(
+                () => refNode.delayTime.automationRate = 'k-rate',
+                `refNode.delayTime.automationRate = 'k-rate'`)
+                .notThrow();
+
+            should(
+                () => refNode.delayTime.setValueAtTime(0, 0),
+                `refNode.delayTime.setValueAtTime(0, 0)`)
+                .notThrow();
+
+            should(
+                () => refNode.delayTime.linearRampToValueAtTime(
+                    endValue, endTime),
+                `refNode.delayTime.linearRampToValueAtTime(${endValue}, ${
+                    endTime})`)
+                .notThrow();
+
+            let testNode;
+
+            should(
+                () => testNode = new DelayNode(context),
+                `testNode = new DelayNode(context)`)
+                .notThrow();
+
+            should(
+                () => testNode.delayTime.automationRate = 'k-rate',
+                `testNode.delayTime.automationRate = 'k-rate'`)
+                .notThrow();
+
+            let testMod;
+
+            should(
+                () => testMod = new ConstantSourceNode(context),
+                `testMod = new ConstantSourceNode(context)`)
+                .notThrow();
+
+            should(
+                () => testMod.offset.setValueAtTime(0, 0),
+                `testMod.offset.setValueAtTime(0, 0)`)
+                .notThrow();
+
+            should(
+                () => testMod.offset.linearRampToValueAtTime(endValue, endTime),
+                `testMod.offset.linearRampToValueAtTime(${endValue}, ${
+                    endTime})`)
+                .notThrow();
+
+            should(
+                () => testMod.connect(testNode.delayTime),
+                `testMod.connect(testNode.delayTime)`)
+                .notThrow();
+
+            // Connect up everything and go!
+            src.connect(testNode).connect(merger, 0, 0);
+            src.connect(refNode).connect(merger, 0, 1);
+
+            src.start();
+            testMod.start();
+
+            const buffer = await context.startRendering();
+            let expected = buffer.getChannelData(0);
+            let actual = buffer.getChannelData(1);
+
+            // Quick sanity check that output isn't zero.  This means we messed
+            // up the connections or automations or the buffer source.
+            should(expected, `Expected k-rate delayTime AudioParam with input`)
+                .notBeConstantValueOf(0);
+            should(actual, `Actual k-rate delayTime AudioParam with input`)
+                .notBeConstantValueOf(0);
+
+            // Quick sanity check.  The amount of delay after one render is
+            // endValue * 128 / sampleRate.  But after 1 render, time has
+            // advanced 128/sampleRate.  Hence, the delay exceeds the time by
+            // (endValue - 1)*128/sampleRate sec or (endValue - 1)*128 frames.
+            // This means the output must be EXACTLY zero for this many frames
+            // in the second render.
+            let zeroFrames = (endValue - 1) * RENDER_QUANTUM_FRAMES;
+            should(
+                actual.slice(
+                    RENDER_QUANTUM_FRAMES, RENDER_QUANTUM_FRAMES + zeroFrames),
+                `output[${RENDER_QUANTUM_FRAMES}, ${
+                    RENDER_QUANTUM_FRAMES + zeroFrames - 1}]`)
+                .beConstantValueOf(0);
+            should(
+                actual.slice(
+                    RENDER_QUANTUM_FRAMES + zeroFrames,
+                    2 * RENDER_QUANTUM_FRAMES),
+                `output[${RENDER_QUANTUM_FRAMES + zeroFrames}, ${
+                    2 * RENDER_QUANTUM_FRAMES - 1}]`)
+                .notBeConstantValueOf(0);
+
+            // The expected and actual results must be EXACTLY the same.
+            should(actual, `k-rate delayTime AudioParam with input`)
+                .beCloseToArray(expected, {absoluteThreshold: 0});
+          });
+
+      audit.run();
+    </script>
+  </body>
+  </html>
\ No newline at end of file
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-delay.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-delay.html
new file mode 100644
index 0000000000..5465c39430
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-delay.html
@@ -0,0 +1,49 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Test k-rate AudioParam of DelayNode</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="automation-rate-testing.js"></script>
+  </head>
+
+  <body>
+    <script>
+      let audit = Audit.createTaskRunner();
+
+      audit.define('Test k-rate DelayNode', (task, should) => {
+        // Arbitrary sample rate and duration.
+        let sampleRate = 8000;
+        let testDuration = 1;
+        let context = new OfflineAudioContext({
+          numberOfChannels: 3,
+          sampleRate: sampleRate,
+          length: testDuration * sampleRate
+        });
+
+
+        doTest(context, should, {
+          nodeName: 'DelayNode',
+          nodeOptions: null,
+          prefix: 'DelayNode',
+          // Set all AudioParams to k-rate
+          rateSettings: [{name: 'delayTime', value: 'k-rate'}],
+          // Automate just the frequency
+          automations: [{
+            name: 'delayTime',
+            methods: [
+              {name: 'setValueAtTime', options: [0, 0]}, {
+                name: 'linearRampToValueAtTime',
+                options: [.5, testDuration]
+              }
+            ]
+          }]
+        }).then(() => task.done());
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-dynamics-compressor-connections.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-dynamics-compressor-connections.html
new file mode 100644
index 0000000000..c1755cd155
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-dynamics-compressor-connections.html
@@ -0,0 +1,145 @@
+<!doctype html>
+<html>
+  <head>
+    <title>k-rate AudioParams with inputs for DynamicsCompressorNode</title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+    <script src="/webaudio/resources/audit-util.js"></script>
+  </head>
+
+  <body>
+    <script>
+      let audit = Audit.createTaskRunner();
+
+      // Fairly abitrary sampleRate and somewhat duration
+      const sampleRate = 48000;
+      const testDuration = 0.25;
+
+      ['attack', 'knee', 'ratio', 'release', 'threshold'].forEach(param => {
+        audit.define(
+            {label: param, description: `Dynamics compressor ${param}`},
+            async (task, should) => {
+              await doTest(should, {prefix: task.label, paramName: param});
+              task.done();
+            });
+      });
+
+      audit.run();
+
+      async function doTest(should, options) {
+        // Test k-rate automation of DynamicsCompressorNode with connected
+        // input.
+        //
+        // A reference compressor node is created with an automation on the
+        // selected AudioParam. For simplicity, we just use a linear ramp from
+        // the minValue to the maxValue of the AudioParam.
+        //
+        // The test node has an input signal connected to the AudioParam.  This
+        // input signal is created to match the automation on the reference
+        // node.
+        //
+        // Finally, the output from the two nodes must be identical if k-rate
+        // inputs are working correctly.
+        //
+        // Options parameter is a dictionary with the following required
+        // members:
+        //   prefix    - prefix to use for the messages.
+        //   paramName - Name of the AudioParam to be tested
+
+        let {prefix, paramName} = options;
+
+        let context = new OfflineAudioContext({
+          numberOfChannels: 2,
+          sampleRate: sampleRate,
+          length: testDuration * sampleRate
+        });
+
+        let merger = new ChannelMergerNode(
+            context, {numberOfInputs: context.destination.channelCount});
+        merger.connect(context.destination);
+
+        // Use an oscillator for the source.  Pretty arbitrary parameters.
+        let src =
+            new OscillatorNode(context, {type: 'sawtooth', frequency: 440});
+
+        // Create the reference and test nodes.
+        let refNode;
+        let tstNode;
+
+        should(
+            () => refNode = new DynamicsCompressorNode(context),
+            `${prefix}: refNode = new DynamicsCompressorNode(context)`)
+            .notThrow();
+
+        let tstOptions = {};
+        tstOptions[paramName] = refNode[paramName].minValue;
+        should(
+            () => tstNode = new DynamicsCompressorNode(context, tstOptions),
+            `${prefix}: tstNode = new DynamicsCompressorNode(context, ${
+                JSON.stringify(tstOptions)})`)
+            .notThrow();
+
+
+        // Automate the AudioParam of the reference node with a linear ramp
+        should(
+            () => refNode[paramName].setValueAtTime(
+                refNode[paramName].minValue, 0),
+            `${prefix}: refNode[${paramName}].setValueAtTime(refNode[${
+                paramName}].minValue, 0)`)
+            .notThrow();
+
+        should(
+            () => refNode[paramName].linearRampToValueAtTime(
+                refNode[paramName].maxValue, testDuration),
+            `${prefix}: refNode[${paramName}].linearRampToValueAtTime(refNode[${
+                paramName}].minValue, ${testDuration})`)
+            .notThrow();
+
+
+        // Create the input node and automate it so that it's output when added
+        // to the intrinsic value of the AudioParam we get the same values as
+        // the automations on the ference node.  We need to do it this way
+        // because the ratio AudioParam has a nominal range of [1, 20] so we
+        // can't just set the value to 0, which is what we'd normally do.
+        let mod;
+        should(
+            () => mod = new ConstantSourceNode(context, {offset: 0}),
+            `${prefix}: mod = new ConstantSourceNode(context, {offset: 0})`)
+            .notThrow();
+        let endValue =
+            refNode[paramName].maxValue - refNode[paramName].minValue;
+        should(
+            () => mod.offset.setValueAtTime(0, 0),
+            `${prefix}: mod.offset.setValueAtTime(0, 0)`)
+            .notThrow();
+        should(
+            () => mod.offset.linearRampToValueAtTime(endValue, testDuration),
+            `${prefix}: mod.offset.linearRampToValueAtTime(${endValue}, ${
+                testDuration})`)
+            .notThrow();
+
+        // Connect up everything.
+        should(
+            () => mod.connect(tstNode[paramName]),
+            `${prefix}: mod.connect(tstNode[${paramName}])`)
+            .notThrow();
+
+        src.connect(refNode).connect(merger, 0, 0);
+        src.connect(tstNode).connect(merger, 0, 1);
+
+        // Go!
+        src.start();
+        mod.start();
+
+        const buffer = await context.startRendering();
+        let expected = buffer.getChannelData(0);
+        let actual = buffer.getChannelData(1);
+
+        // The expected and actual results must be EXACTLY the same.
+        should(actual, `k-rate ${paramName} AudioParam with input`)
+            .beCloseToArray(expected, {absoluteThreshold: 0});
+      }
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-gain.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-gain.html
new file mode 100644
index 0000000000..887d9f78db
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-gain.html
@@ -0,0 +1,47 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Test k-rate AudioParam of GainNode</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="automation-rate-testing.js"></script>
+  </head>
+
+  <body>
+    <script>
+      let audit = Audit.createTaskRunner();
+
+      audit.define('Test k-rate GainNode', (task, should) => {
+        // Arbitrary sample rate and duration.
+        let sampleRate = 8000;
+        let testDuration = 1;
+        let context = new OfflineAudioContext({
+          numberOfChannels: 3,
+          sampleRate: sampleRate,
+          length: testDuration * sampleRate
+        });
+
+
+        doTest(context, should, {
+          nodeName: 'GainNode',
+          nodeOptions: null,
+          prefix: 'GainNode',
+          // Set AudioParam to k-rate
+          rateSettings: [{name: 'gain', value: 'k-rate'}],
+          // Automate
+          automations: [{
+            name: 'gain',
+            methods: [
+              {name: 'setValueAtTime', options: [1, 0]},
+              {name: 'linearRampToValueAtTime', options: [0, testDuration]}
+            ]
+          }]
+        }).then(() => task.done());
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-oscillator-connections.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-oscillator-connections.html
new file mode 100644
index 0000000000..475b364367
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-oscillator-connections.html
@@ -0,0 +1,578 @@
+<!doctype html>
+<html>
+  <head>
+    <title>
+      k-rate AudioParams with inputs for OscillatorNode
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+    <script src="/webaudio/resources/audit-util.js"></script>
+  </head>
+
+  <body>
+    <script>
+      let audit = Audit.createTaskRunner();
+
+      // Sample rate must be a power of two to eliminate round-off when
+      // computing time from frames and vice versa.  Using a non-power of two
+      // will work, but the thresholds below will not be zero.  They're probably
+      // closer to 1e-5 or so, but if everything is working correctly, the
+      // outputs really should be exactly equal.
+      const sampleRate = 8192;
+
+      // Fairly arbitrary but short duration to limit runtime.
+      const testFrames = 5 * RENDER_QUANTUM_FRAMES;
+      const testDuration = testFrames / sampleRate;
+
+      audit.define(
+          {label: 'Test 1', description: 'k-rate frequency input'},
+          async (task, should) => {
+            // Test that an input to the frequency AudioParam set to k-rate
+            // works.
+
+            // Fairly arbitrary start and end frequencies for the automation.
+            const freqStart = 100;
+            const freqEnd = 2000;
+
+            let refSetup = (context) => {
+              let srcRef = new OscillatorNode(context, {frequency: 0});
+
+              should(
+                  () => srcRef.frequency.automationRate = 'k-rate',
+                  `${task.label}: srcRef.frequency.automationRate = 'k-rate'`)
+                  .notThrow();
+              should(
+                  () => srcRef.frequency.setValueAtTime(freqStart, 0),
+                  `${task.label}: srcRef.frequency.setValueAtTime(${
+                      freqStart}, 0)`)
+                  .notThrow();
+              should(
+                  () => srcRef.frequency.linearRampToValueAtTime(
+                      freqEnd, testDuration),
+                  `${task.label}: srcRef.frequency.linearRampToValueAtTime(${
+                      freqEnd}, ${testDuration})`)
+                  .notThrow();
+
+              return srcRef;
+            };
+
+            let testSetup = (context) => {
+              let srcTest = new OscillatorNode(context, {frequency: 0});
+              should(
+                  () => srcTest.frequency.automationRate = 'k-rate',
+                  `${task.label}: srcTest.frequency.automationRate = 'k-rate'`)
+                  .notThrow();
+
+              return srcTest;
+            };
+
+            let modSetup = (context) => {
+              let mod = new ConstantSourceNode(context, {offset: 0});
+
+              should(
+                  () => mod.offset.setValueAtTime(freqStart, 0),
+                  `${task.label}: modFreq.offset.setValueAtTime(${
+                      freqStart}, 0)`)
+                  .notThrow();
+              should(
+                  () =>
+                      mod.offset.linearRampToValueAtTime(freqEnd, testDuration),
+                  `${task.label}: modFreq.offset.linearRampToValueAtTime(${
+                      freqEnd}, ${testDuration})`)
+                  .notThrow();
+
+              // This node is going to be connected to the frequency AudioParam.
+              return {frequency: mod};
+            };
+
+            await testParams(should, {
+              prefix: task.label,
+              summary: 'k-rate frequency with input',
+              setupRefOsc: refSetup,
+              setupTestOsc: testSetup,
+              setupMod: modSetup
+            });
+
+            task.done();
+          });
+
+      audit.define(
+          {label: 'Test 2', description: 'k-rate detune input'},
+          async (task, should) => {
+            // Test that an input to the detune AudioParam set to k-rate works.
+            // Threshold experimentally determined.  It should be probably not
+            // be much larger than 5e-5. or something is not right.
+
+            // Fairly arbitrary start and end detune values for automation.
+            const detuneStart = 0;
+            const detuneEnd = 2000;
+
+            let refSetup = (context) => {
+              let srcRef = new OscillatorNode(context, {detune: 0});
+
+              should(
+                  () => srcRef.detune.automationRate = 'k-rate',
+                  `${task.label}: srcRef.detune.automationRate = 'k-rate'`)
+                  .notThrow();
+
+              should(
+                  () => srcRef.detune.setValueAtTime(detuneStart, 0),
+                  `${task.label}: srcRef.detune.setValueAtTime(${
+                      detuneStart}, 0)`)
+                  .notThrow();
+              should(
+                  () => srcRef.detune.linearRampToValueAtTime(
+                      detuneEnd, testDuration),
+                  `${task.label}: srcRef.detune.linearRampToValueAtTime(${
+                      detuneEnd}, ${testDuration})`)
+                  .notThrow();
+
+              return srcRef;
+            };
+
+            let testSetup = (context) => {
+              let srcTest = new OscillatorNode(context, {detune: 0});
+
+              should(
+                  () => srcTest.detune.automationRate = 'k-rate',
+                  `${task.label}: srcTest.detune.automationRate = 'k-rate'`)
+                  .notThrow();
+
+              return srcTest;
+            };
+
+            let modSetup = (context) => {
+              let mod = new ConstantSourceNode(context, {offset: 0});
+
+              should(
+                  () => mod.offset.setValueAtTime(detuneStart, 0),
+                  `${task.label}: modDetune.offset.setValueAtTime(${
+                      detuneStart}, 0)`)
+                  .notThrow();
+              should(
+                  () => mod.offset.linearRampToValueAtTime(
+                      detuneEnd, testDuration),
+                  `${task.label}: modDetune.offset.linearRampToValueAtTime(${
+                      detuneEnd}, ${testDuration})`)
+                  .notThrow();
+
+              return {detune: mod};
+            };
+
+            await testParams(should, {
+              prefix: task.label,
+              summary: 'k-rate detune with input',
+              setupRefOsc: refSetup,
+              setupTestOsc: testSetup,
+              setupMod: modSetup
+            });
+
+            task.done();
+          });
+
+      audit.define(
+          {
+            label: 'Test 3',
+            description: 'k-rate frequency input with a-rate detune'
+          },
+          async (task, should) => {
+            // Test OscillatorNode with a k-rate frequency with input and an
+            // a-rate detune iwth automations.
+
+            // Fairly arbitrary start and end values for the frequency and
+            // detune automations.
+            const freqStart = 100;
+            const freqEnd = 2000;
+            const detuneStart = 0;
+            const detuneEnd = -2000;
+
+            let refSetup = (context) => {
+              let node = new OscillatorNode(context, {frequency: 0});
+
+              // Set up k-rate frequency and a-rate detune
+              should(
+                  () => node.frequency.automationRate = 'k-rate',
+                  `${task.label}: srcRef.frequency.automationRate = 'k-rate'`)
+                  .notThrow();
+              should(
+                  () => node.frequency.setValueAtTime(freqStart, 0),
+                  `${task.label}: srcRef.frequency.setValueAtTime(${
+                      freqStart}, 0)`)
+                  .notThrow();
+              should(
+                  () => node.frequency.linearRampToValueAtTime(
+                      2000, testDuration),
+                  `${task.label}: srcRef.frequency.linearRampToValueAtTime(${
+                      freqEnd}, ${testDuration})`)
+                  .notThrow();
+              should(
+                  () => node.detune.setValueAtTime(detuneStart, 0),
+                  `${task.label}: srcRef.detune.setValueAtTime(${
+                      detuneStart}, 0)`)
+                  .notThrow();
+              should(
+                  () => node.detune.linearRampToValueAtTime(
+                      detuneEnd, testDuration),
+                  `${task.label}: srcRef.detune.linearRampToValueAtTime(${
+                      detuneEnd}, ${testDuration})`)
+                  .notThrow();
+
+              return node;
+            };
+
+            let testSetup = (context) => {
+              let node = new OscillatorNode(context, {frequency: 0});
+
+              should(
+                  () => node.frequency.automationRate = 'k-rate',
+                  `${task.label}: srcTest.frequency.automationRate = 'k-rate'`)
+                  .notThrow();
+              should(
+                  () => node.detune.setValueAtTime(detuneStart, 0),
+                  `${task.label}: srcTest.detune.setValueAtTime(${
+                      detuneStart}, 0)`)
+                  .notThrow();
+              should(
+                  () => node.detune.linearRampToValueAtTime(
+                      detuneEnd, testDuration),
+                  `${task.label}: srcTest.detune.linearRampToValueAtTime(${
+                      detuneEnd}, ${testDuration})`)
+                  .notThrow();
+
+              return node;
+            };
+
+            let modSetup = (context) => {
+              let mod = {};
+              mod['frequency'] = new ConstantSourceNode(context, {offset: 0});
+
+              should(
+                  () => mod['frequency'].offset.setValueAtTime(freqStart, 0),
+                  `${task.label}: modFreq.offset.setValueAtTime(${
+                      freqStart}, 0)`)
+                  .notThrow();
+
+              should(
+                  () => mod['frequency'].offset.linearRampToValueAtTime(
+                      2000, testDuration),
+                  `${task.label}: modFreq.offset.linearRampToValueAtTime(${
+                      freqEnd}, ${testDuration})`)
+                  .notThrow();
+
+              return mod;
+            };
+
+            await testParams(should, {
+              prefix: task.label,
+              summary: 'k-rate frequency input with a-rate detune',
+              setupRefOsc: refSetup,
+              setupTestOsc: testSetup,
+              setupMod: modSetup
+            });
+
+            task.done();
+          });
+
+      audit.define(
+          {
+            label: 'Test 4',
+            description: 'a-rate frequency with k-rate detune input'
+          },
+          async (task, should) => {
+            // Test OscillatorNode with an a-rate frequency with automations and
+            // a k-rate detune with input.
+
+            // Fairly arbitrary start and end values for the frequency and
+            // detune automations.
+            const freqStart = 100;
+            const freqEnd = 2000;
+            const detuneStart = 0;
+            const detuneEnd = -2000;
+
+            let refSetup = (context) => {
+              let node = new OscillatorNode(context, {detune: 0});
+
+              // Set up a-rate frequency and k-rate detune
+              should(
+                  () => node.frequency.setValueAtTime(freqStart, 0),
+                  `${task.label}: srcRef.frequency.setValueAtTime(${
+                      freqStart}, 0)`)
+                  .notThrow();
+              should(
+                  () => node.frequency.linearRampToValueAtTime(
+                      2000, testDuration),
+                  `${task.label}: srcRef.frequency.linearRampToValueAtTime(${
+                      freqEnd}, ${testDuration})`)
+                  .notThrow();
+              should(
+                  () => node.detune.automationRate = 'k-rate',
+                  `${task.label}: srcRef.detune.automationRate = 'k-rate'`)
+                  .notThrow();
+              should(
+                  () => node.detune.setValueAtTime(detuneStart, 0),
+                  `${task.label}: srcRef.detune.setValueAtTime(${
+                      detuneStart}, 0)`)
+                  .notThrow();
+              should(
+                  () => node.detune.linearRampToValueAtTime(
+                      detuneEnd, testDuration),
+                  `${task.label}: srcRef.detune.linearRampToValueAtTime(${
+                      detuneEnd}, ${testDuration})`)
+                  .notThrow();
+
+              return node;
+            };
+
+            let testSetup = (context) => {
+              let node = new OscillatorNode(context, {detune: 0});
+
+              should(
+                  () => node.detune.automationRate = 'k-rate',
+                  `${task.label}: srcTest.detune.automationRate = 'k-rate'`)
+                  .notThrow();
+              should(
+                  () => node.frequency.setValueAtTime(freqStart, 0),
+                  `${task.label}: srcTest.frequency.setValueAtTime(${
+                      freqStart}, 0)`)
+                  .notThrow();
+              should(
+                  () => node.frequency.linearRampToValueAtTime(
+                      freqEnd, testDuration),
+                  `${task.label}: srcTest.frequency.linearRampToValueAtTime(${
+                      freqEnd}, ${testDuration})`)
+                  .notThrow();
+
+              return node;
+            };
+
+            let modSetup = (context) => {
+              let mod = {};
+              const name = 'detune';
+
+              mod['detune'] = new ConstantSourceNode(context, {offset: 0});
+              should(
+                  () => mod[name].offset.setValueAtTime(detuneStart, 0),
+                  `${task.label}: modDetune.offset.setValueAtTime(${
+                      detuneStart}, 0)`)
+                  .notThrow();
+
+              should(
+                  () => mod[name].offset.linearRampToValueAtTime(
+                      detuneEnd, testDuration),
+                  `${task.label}: modDetune.offset.linearRampToValueAtTime(${
+                      detuneEnd}, ${testDuration})`)
+                  .notThrow();
+
+              return mod;
+            };
+
+            await testParams(should, {
+              prefix: task.label,
+              summary: 'k-rate detune input with a-rate frequency',
+              setupRefOsc: refSetup,
+              setupTestOsc: testSetup,
+              setupMod: modSetup
+            });
+
+            task.done();
+          });
+
+      audit.define(
+          {
+            label: 'Test 5',
+            description: 'k-rate inputs for frequency and detune'
+          },
+          async (task, should) => {
+            // Test OscillatorNode with k-rate frequency and detune with inputs
+            // on both.
+
+            // Fairly arbitrary start and end values for the frequency and
+            // detune automations.
+            const freqStart = 100;
+            const freqEnd = 2000;
+            const detuneStart = 0;
+            const detuneEnd = -2000;
+
+            let refSetup = (context) => {
+              let node = new OscillatorNode(context, {frequency: 0, detune: 0});
+
+              should(
+                  () => node.frequency.automationRate = 'k-rate',
+                  `${task.label}: srcRef.frequency.automationRate = 'k-rate'`)
+                  .notThrow();
+              should(
+                  () => node.frequency.setValueAtTime(freqStart, 0),
+                  `${task.label}: srcRef.setValueAtTime(${freqStart}, 0)`)
+                  .notThrow();
+              should(
+                  () => node.frequency.linearRampToValueAtTime(
+                      freqEnd, testDuration),
+                  `${task.label}: srcRef;.frequency.linearRampToValueAtTime(${
+                      freqEnd}, ${testDuration})`)
+                  .notThrow();
+              should(
+                  () => node.detune.automationRate = 'k-rate',
+                  `${task.label}: srcRef.detune.automationRate = 'k-rate'`)
+                  .notThrow();
+              should(
+                  () => node.detune.setValueAtTime(detuneStart, 0),
+                  `${task.label}: srcRef.detune.setValueAtTime(${
+                      detuneStart}, 0)`)
+                  .notThrow();
+              should(
+                  () => node.detune.linearRampToValueAtTime(
+                      detuneEnd, testDuration),
+                  `${task.label}: srcRef.detune.linearRampToValueAtTime(${
+                      detuneEnd}, ${testDuration})`)
+                  .notThrow();
+
+              return node;
+            };
+
+            let testSetup = (context) => {
+              let node = new OscillatorNode(context, {frequency: 0, detune: 0});
+
+              should(
+                  () => node.frequency.automationRate = 'k-rate',
+                  `${task.label}: srcTest.frequency.automationRate = 'k-rate'`)
+                  .notThrow();
+              should(
+                  () => node.detune.automationRate = 'k-rate',
+                  `${task.label}: srcTest.detune.automationRate = 'k-rate'`)
+                  .notThrow();
+
+              return node;
+            };
+
+            let modSetup = (context) => {
+              let modF = new ConstantSourceNode(context, {offset: 0});
+
+              should(
+                  () => modF.offset.setValueAtTime(freqStart, 0),
+                  `${task.label}: modFreq.offset.setValueAtTime(${
+                      freqStart}, 0)`)
+                  .notThrow();
+              should(
+                  () => modF.offset.linearRampToValueAtTime(
+                      freqEnd, testDuration),
+                  `${task.label}: modFreq.offset.linearRampToValueAtTime(${
+                      freqEnd}, ${testDuration})`)
+                  .notThrow();
+
+              let modD = new ConstantSourceNode(context, {offset: 0});
+
+              should(
+                  () => modD.offset.setValueAtTime(detuneStart, 0),
+                  `${task.label}: modDetune.offset.setValueAtTime(${
+                      detuneStart}, 0)`)
+                  .notThrow();
+              should(
+                  () => modD.offset.linearRampToValueAtTime(
+                      detuneEnd, testDuration),
+                  `${task.label}: modDetune.offset.linearRampToValueAtTime(${
+                      detuneEnd}, ${testDuration})`)
+                  .notThrow();
+
+              return {frequency: modF, detune: modD};
+            };
+
+            await testParams(should, {
+              prefix: task.label,
+              summary: 'k-rate inputs for both frequency and detune',
+              setupRefOsc: refSetup,
+              setupTestOsc: testSetup,
+              setupMod: modSetup
+            });
+
+            task.done();
+          });
+
+      audit.run();
+
+      async function testParams(should, options) {
+        // Test a-rate and k-rate AudioParams of an OscillatorNode.
+        //
+        // |options| should be a dictionary with these members:
+        //   prefix       - prefix to use for messages
+        //   summary      - message to be printed with the final results
+        //   setupRefOsc  - function returning the reference oscillator
+        //   setupTestOsc - function returning the test oscillator
+        //   setupMod     - function returning nodes to be connected to the
+        //   AudioParams.
+        //
+        // |setupRefOsc| and |setupTestOsc| are given the context and each
+        // method is expected to create an OscillatorNode with the appropriate
+        // automations for testing.  The constructed OscillatorNode is returned.
+        //
+        // The reference oscillator
+        // should automate the desired AudioParams at the appropriate automation
+        // rate, and the output is the expected result.
+        //
+        // The test oscillator should set up the AudioParams but expect the
+        // AudioParam(s) have an input that matches the automation for the
+        // reference oscillator.
+        //
+        // |setupMod| must create one or two ConstantSourceNodes with exactly
+        // the same automations as used for the reference oscillator.  This node
+        // is used as the input to an AudioParam of the test oscillator.  This
+        // function returns a dictionary whose members are named 'frequency' and
+        // 'detune'.  The name indicates which AudioParam the constant source
+        // node should be connected to.
+
+        // Two channels: 0 = reference signal, 1 = test signal
+        let context = new OfflineAudioContext({
+          numberOfChannels: 2,
+          sampleRate: sampleRate,
+          length: testDuration * sampleRate
+        });
+
+        let merger = new ChannelMergerNode(
+            context, {numberOfInputs: context.destination.channelCount});
+        merger.connect(context.destination);
+
+        // The reference oscillator.
+        let srcRef = options.setupRefOsc(context);
+
+        // The test oscillator.
+        let srcTest = options.setupTestOsc(context);
+
+        // Inputs to AudioParam.
+        let mod = options.setupMod(context);
+
+        if (mod['frequency']) {
+          should(
+              () => mod['frequency'].connect(srcTest.frequency),
+              `${options.prefix}: modFreq.connect(srcTest.frequency)`)
+              .notThrow();
+          mod['frequency'].start()
+        }
+
+        if (mod['detune']) {
+          should(
+              () => mod['detune'].connect(srcTest.detune),
+              `${options.prefix}: modDetune.connect(srcTest.detune)`)
+              .notThrow();
+          mod['detune'].start()
+        }
+
+        srcRef.connect(merger, 0, 0);
+        srcTest.connect(merger, 0, 1);
+
+        srcRef.start();
+        srcTest.start();
+
+        let buffer = await context.startRendering();
+        let expected = buffer.getChannelData(0);
+        let actual = buffer.getChannelData(1);
+
+        // The output of the reference and test oscillator should be
+        // exactly equal because the AudioParam values should be exactly
+        // equal.
+        should(actual, options.summary).beCloseToArray(expected, {
+          absoluteThreshold: 0
+        });
+      }
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-oscillator.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-oscillator.html
new file mode 100644
index 0000000000..6803f55eab
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-oscillator.html
@@ -0,0 +1,88 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Test k-rate AudioParams of OscillatorNode</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>
+      let audit = Audit.createTaskRunner();
+
+      // Arbitrary sample rate and duration.
+      let sampleRate = 8000;
+
+      // Only new a few render quanta to verify things are working.
+      let testDuration = 4 * 128 / sampleRate;
+
+      [{name: 'detune', initial: 0, final: 1200}, {
+        name: 'frequency',
+        initial: 440,
+        final: sampleRate / 2
+      }].forEach(paramProperty => {
+        audit.define(
+            'Oscillator k-rate ' + paramProperty.name, (task, should) => {
+              let context = new OfflineAudioContext({
+                numberOfChannels: 3,
+                sampleRate: sampleRate,
+                length: testDuration * sampleRate
+              });
+
+              let merger = new ChannelMergerNode(
+                  context, {numberOfInputs: context.destination.channelCount});
+              merger.connect(context.destination);
+              let inverter = new GainNode(context, {gain: -1});
+              inverter.connect(merger, 0, 2);
+
+              let kRateNode = new OscillatorNode(context);
+              let aRateNode = new OscillatorNode(context);
+
+              kRateNode.connect(merger, 0, 0);
+              aRateNode.connect(merger, 0, 1);
+
+              kRateNode.connect(merger, 0, 2);
+              aRateNode.connect(inverter);
+
+              // Set the rate
+              kRateNode[paramProperty.name].automationRate = 'k-rate';
+
+              // Automate the offset
+              kRateNode[paramProperty.name].setValueAtTime(
+                  paramProperty.initial, 0);
+              kRateNode[paramProperty.name].linearRampToValueAtTime(
+                  paramProperty.final, testDuration);
+
+              aRateNode[paramProperty.name].setValueAtTime(
+                  paramProperty.initial, 0);
+              aRateNode[paramProperty.name].linearRampToValueAtTime(
+                  paramProperty.final, testDuration);
+
+              kRateNode.start();
+              aRateNode.start();
+
+              context.startRendering()
+                  .then(audioBuffer => {
+                    let kRateOut = audioBuffer.getChannelData(0);
+                    let aRateOut = audioBuffer.getChannelData(1);
+                    let diff = audioBuffer.getChannelData(2);
+
+                    // Verify that the outputs are different.
+                    should(
+                        diff,
+                        'k-rate ' + paramProperty.name +
+                            ': Difference between a-rate and k-rate outputs')
+                        .notBeConstantValueOf(0);
+
+                  })
+                  .then(() => task.done());
+            });
+      });
+
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-panner-connections.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-panner-connections.html
new file mode 100644
index 0000000000..001cf63bd3
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-panner-connections.html
@@ -0,0 +1,238 @@
+<!doctype html>
+<html>
+  <head>
+    <title>
+      k-rate AudioParams with inputs for PannerNode
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+    <script src="/webaudio/resources/audit-util.js"></script>
+    </title>
+  </head>
+
+  <body>
+    <script>
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {label: 'Panner x', description: 'k-rate input'},
+          async (task, should) => {
+            await testPannerParams(should, {param: 'positionX'});
+            task.done();
+          });
+
+      audit.define(
+          {label: 'Panner y', description: 'k-rate input'},
+          async (task, should) => {
+            await testPannerParams(should, {param: 'positionY'});
+            task.done();
+          });
+
+      audit.define(
+          {label: 'Panner z', description: 'k-rate input'},
+          async (task, should) => {
+            await testPannerParams(should, {param: 'positionZ'});
+            task.done();
+          });
+
+      audit.define(
+          {label: 'Listener x', description: 'k-rate input'},
+          async (task, should) => {
+            await testListenerParams(should, {param: 'positionX'});
+            task.done();
+          });
+
+      audit.define(
+          {label: 'Listener y', description: 'k-rate input'},
+          async (task, should) => {
+            await testListenerParams(should, {param: 'positionY'});
+            task.done();
+          });
+
+      audit.define(
+          {label: 'Listener z', description: 'k-rate input'},
+          async (task, should) => {
+            await testListenerParams(should, {param: 'positionZ'});
+            task.done();
+          });
+
+      audit.run();
+
+      async function testPannerParams(should, options) {
+        // Arbitrary sample rate and duration.
+        const sampleRate = 8000;
+        const testFrames = 5 * RENDER_QUANTUM_FRAMES;
+        let testDuration = testFrames / sampleRate;
+        // Four channels needed because the first two are for the output of
+        // the reference panner, and the next two are for the test panner.
+        let context = new OfflineAudioContext({
+          numberOfChannels: 4,
+          sampleRate: sampleRate,
+          length: testDuration * sampleRate
+        });
+
+        let merger = new ChannelMergerNode(
+            context, {numberOfInputs: context.destination.channelCount});
+        merger.connect(context.destination);
+
+        // Create a stereo source out of two mono sources
+        let src0 = new ConstantSourceNode(context, {offset: 1});
+        let src1 = new ConstantSourceNode(context, {offset: 2});
+        let src = new ChannelMergerNode(context, {numberOfInputs: 2});
+        src0.connect(src, 0, 0);
+        src1.connect(src, 0, 1);
+
+        let finalPosition = 100;
+
+        // Reference panner node with k-rate AudioParam automations.  The
+        // output of this panner is the reference output.
+        let refNode = new PannerNode(context);
+        // Initialize the panner location to somewhat arbitrary values.
+        refNode.positionX.value = 1;
+        refNode.positionY.value = 50;
+        refNode.positionZ.value = -25;
+
+        // Set the AudioParam under test with the appropriate automations.
+        refNode[options.param].automationRate = 'k-rate';
+        refNode[options.param].setValueAtTime(1, 0);
+        refNode[options.param].linearRampToValueAtTime(
+            finalPosition, testDuration);
+        let refSplit = new ChannelSplitterNode(context, {numberOfOutputs: 2});
+
+        // Test panner node with k-rate AudioParam with inputs.
+        let tstNode = new PannerNode(context);
+        tstNode.positionX.value = 1;
+        tstNode.positionY.value = 50;
+        tstNode.positionZ.value = -25;
+        tstNode[options.param].value = 0;
+        tstNode[options.param].automationRate = 'k-rate';
+        let tstSplit = new ChannelSplitterNode(context, {numberOfOutputs: 2});
+
+        // The input to the AudioParam.  It must have the same automation
+        // sequence as used by refNode.  And must be a-rate to demonstrate
+        // the k-rate effect of the AudioParam.
+        let mod = new ConstantSourceNode(context, {offset: 0});
+        mod.offset.setValueAtTime(1, 0);
+        mod.offset.linearRampToValueAtTime(finalPosition, testDuration);
+
+        mod.connect(tstNode[options.param]);
+
+        src.connect(refNode).connect(refSplit);
+        src.connect(tstNode).connect(tstSplit);
+
+        refSplit.connect(merger, 0, 0);
+        refSplit.connect(merger, 1, 1);
+        tstSplit.connect(merger, 0, 2);
+        tstSplit.connect(merger, 1, 3);
+
+        mod.start();
+        src0.start();
+        src1.start();
+
+        const buffer = await context.startRendering();
+        let expected0 = buffer.getChannelData(0);
+        let expected1 = buffer.getChannelData(1);
+        let actual0 = buffer.getChannelData(2);
+        let actual1 = buffer.getChannelData(3);
+
+        should(expected0, `Panner: ${options.param}: Expected output channel 0`)
+            .notBeConstantValueOf(expected0[0]);
+        should(expected1, `${options.param}: Expected output channel 1`)
+            .notBeConstantValueOf(expected1[0]);
+
+        // Verify output is a stair step because positionX is k-rate,
+        // and no other AudioParam is changing.
+
+        for (let k = 0; k < testFrames; k += RENDER_QUANTUM_FRAMES) {
+          should(
+              actual0.slice(k, k + RENDER_QUANTUM_FRAMES),
+              `Panner: ${options.param}: Channel 0 output[${k}, ${
+                  k + RENDER_QUANTUM_FRAMES - 1}]`)
+              .beConstantValueOf(actual0[k]);
+        }
+
+        for (let k = 0; k < testFrames; k += RENDER_QUANTUM_FRAMES) {
+          should(
+              actual1.slice(k, k + RENDER_QUANTUM_FRAMES),
+              `Panner: ${options.param}: Channel 1 output[${k}, ${
+                  k + RENDER_QUANTUM_FRAMES - 1}]`)
+              .beConstantValueOf(actual1[k]);
+        }
+
+        should(actual0, `Panner: ${options.param}: Actual output channel 0`)
+            .beCloseToArray(expected0, {absoluteThreshold: 0});
+        should(actual1, `Panner: ${options.param}: Actual output channel 1`)
+            .beCloseToArray(expected1, {absoluteThreshold: 0});
+      }
+
+      async function testListenerParams(should, options) {
+        // Arbitrary sample rate and duration.
+        const sampleRate = 8000;
+        const testFrames = 5 * RENDER_QUANTUM_FRAMES;
+        let testDuration = testFrames / sampleRate;
+        // Four channels needed because the first two are for the output of
+        // the reference panner, and the next two are for the test panner.
+        let context = new OfflineAudioContext({
+          numberOfChannels: 2,
+          sampleRate: sampleRate,
+          length: testDuration * sampleRate
+        });
+
+        // Create a stereo source out of two mono sources
+        let src0 = new ConstantSourceNode(context, {offset: 1});
+        let src1 = new ConstantSourceNode(context, {offset: 2});
+        let src = new ChannelMergerNode(context, {numberOfInputs: 2});
+        src0.connect(src, 0, 0);
+        src1.connect(src, 0, 1);
+
+        let finalPosition = 100;
+
+        // Reference panner node with k-rate AudioParam automations.  The
+        // output of this panner is the reference output.
+        let panner = new PannerNode(context);
+        panner.positionX.value = 10;
+        panner.positionY.value = 50;
+        panner.positionZ.value = -25;
+
+        src.connect(panner);
+
+        let mod = new ConstantSourceNode(context, {offset: 0});
+        mod.offset.setValueAtTime(1, 0);
+        mod.offset.linearRampToValueAtTime(finalPosition, testDuration);
+
+        context.listener[options.param].automationRate = 'k-rate';
+        mod.connect(context.listener[options.param]);
+
+        panner.connect(context.destination);
+
+        src0.start();
+        src1.start();
+        mod.start();
+
+        const buffer = await context.startRendering();
+        let c0 = buffer.getChannelData(0);
+        let c1 = buffer.getChannelData(1);
+
+        // Verify output is a stair step because positionX is k-rate,
+        // and no other AudioParam is changing.
+
+        for (let k = 0; k < testFrames; k += RENDER_QUANTUM_FRAMES) {
+          should(
+              c0.slice(k, k + RENDER_QUANTUM_FRAMES),
+              `Listener: ${options.param}: Channel 0 output[${k}, ${
+                  k + RENDER_QUANTUM_FRAMES - 1}]`)
+              .beConstantValueOf(c0[k]);
+        }
+
+        for (let k = 0; k < testFrames; k += RENDER_QUANTUM_FRAMES) {
+          should(
+              c1.slice(k, k + RENDER_QUANTUM_FRAMES),
+              `Listener: ${options.param}: Channel 1 output[${k}, ${
+                  k + RENDER_QUANTUM_FRAMES - 1}]`)
+              .beConstantValueOf(c1[k]);
+        }
+      }
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-panner.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-panner.html
new file mode 100644
index 0000000000..60200b2471
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-panner.html
@@ -0,0 +1,178 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Test k-rate AudioParams of PannerNode</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="automation-rate-testing.js"></script>
+  </head>
+
+  <body>
+    <script>
+      let audit = Audit.createTaskRunner();
+
+      // Define a test where we verify that a k-rate audio param produces
+      // different results from an a-rate audio param for each of the audio
+      // params of a biquad.
+      //
+      // Each entry gives the name of the AudioParam, an initial value to be
+      // used with setValueAtTime, and a final value to be used with
+      // linearRampToValueAtTime. (See |doTest| for details as well.)
+
+      [{name: 'positionX', initial: 0, final: 1000},
+       {name: 'positionY', initial: 0, final: 1000},
+       {name: 'orientationX', initial: 1, final: 10},
+       {name: 'orientationY', initial: 1, final: 10},
+       {name: 'orientationZ', initial: 1, final: 10},
+      ].forEach(paramProperty => {
+        audit.define('Panner k-rate ' + paramProperty.name, (task, should) => {
+          // Arbitrary sample rate and duration.
+          let sampleRate = 8000;
+          let testDuration = 5 * 128 / sampleRate;
+          let context = new OfflineAudioContext({
+            numberOfChannels: 3,
+            sampleRate: sampleRate,
+            length: testDuration * sampleRate
+          });
+
+          doTest(context, should, {
+            sourceNodeName: 'ConstantSourceNode',
+            verifyPieceWiseConstant: true,
+            nodeName: 'PannerNode',
+            // Make the source directional so orientation matters, and set some
+            // defaults for the position and orientation so that we're not on an
+            // axis where the azimuth and elevation might be constant when
+            // moving one of the AudioParams.
+            nodeOptions: {
+              distanceModel: 'inverse',
+              coneOuterAngle: 360,
+              coneInnerAngle: 0,
+              positionX: 1,
+              positionY: 1,
+              positionZ: 1,
+              orientationX: 0,
+              orientationY: 1,
+              orientationZ: 1
+            },
+            prefix: `k-rate ${paramProperty.name}`,
+            // Just set the frequency to k-rate
+            rateSettings: [
+              {name: paramProperty.name, value: 'k-rate'},
+            ],
+            // Automate just the given AudioParam
+            automations: [{
+              name: paramProperty.name,
+              methods: [
+                {name: 'setValueAtTime', options: [paramProperty.initial, 0]}, {
+                  name: 'linearRampToValueAtTime',
+                  options: [paramProperty.final, testDuration]
+                }
+              ]
+            }]
+          }).then(() => task.done());
+        });
+      });
+
+      // Test k-rate automation of the listener.  The intial and final
+      // automation values are pretty arbitrary, except that they should be such
+      // that the panner and listener produces non-constant output.
+      [{name: 'positionX', initial: [1, 0], final: [1000, 1]},
+       {name: 'positionY', initial: [1, 0], final: [1000, 1]},
+       {name: 'positionZ', initial: [1, 0], final: [1000, 1]},
+       {name: 'forwardX', initial: [-1, 0], final: [1, 1]},
+       {name: 'forwardY', initial: [-1, 0], final: [1, 1]},
+       {name: 'forwardZ', initial: [-1, 0], final: [1, 1]},
+       {name: 'upX', initial: [-1, 0], final: [1000, 1]},
+       {name: 'upY', initial: [-1, 0], final: [1000, 1]},
+       {name: 'upZ', initial: [-1, 0], final: [1000, 1]},
+      ].forEach(paramProperty => {
+        audit.define(
+            'Listener k-rate ' + paramProperty.name, (task, should) => {
+              // Arbitrary sample rate and duration.
+              let sampleRate = 8000;
+              let testDuration = 5 * 128 / sampleRate;
+              let context = new OfflineAudioContext({
+                numberOfChannels: 1,
+                sampleRate: sampleRate,
+                length: testDuration * sampleRate
+              });
+
+              doListenerTest(context, should, {
+                param: paramProperty.name,
+                initial: paramProperty.initial,
+                final: paramProperty.final
+              }).then(() => task.done());
+            });
+      });
+
+      audit.run();
+
+      function doListenerTest(context, should, options) {
+        let src = new ConstantSourceNode(context);
+        let panner = new PannerNode(context, {
+          distanceModel: 'inverse',
+          coneOuterAngle: 360,
+          coneInnerAngle: 10,
+          positionX: 10,
+          positionY: 10,
+          positionZ: 10,
+          orientationX: 1,
+          orientationY: 1,
+          orientationZ: 1
+        });
+
+        src.connect(panner).connect(context.destination);
+
+        src.start();
+
+        let listener = context.listener;
+
+        // Set listener properties to "random" values so that motion on one of
+        // the attributes actually changes things relative to the panner
+        // location.  And the up and forward directions should have a simple
+        // relationship between them.
+        listener.positionX.value = -1;
+        listener.positionY.value = 1;
+        listener.positionZ.value = -1;
+        listener.forwardX.value = -1;
+        listener.forwardY.value = 1;
+        listener.forwardZ.value = -1;
+        // Make the up vector not parallel or perpendicular to the forward and
+        // position vectors so that automations of the up vector produce
+        // noticeable differences.
+        listener.upX.value = 1;
+        listener.upY.value = 1;
+        listener.upZ.value = 2;
+
+        let audioParam = listener[options.param];
+        audioParam.automationRate = 'k-rate';
+
+        let prefix = `Listener ${options.param}`;
+        should(audioParam.automationRate, prefix + '.automationRate')
+            .beEqualTo('k-rate');
+        should(() => {
+          audioParam.setValueAtTime(...options.initial);
+        }, prefix + `.setValueAtTime(${options.initial})`).notThrow();
+        should(() => {
+          audioParam.linearRampToValueAtTime(...options.final);
+        }, prefix + `.linearRampToValueAtTime(${options.final})`).notThrow();
+
+        return context.startRendering().then(renderedBuffer => {
+          let prefix = `Listener k-rate ${options.param}: `;
+          let output = renderedBuffer.getChannelData(0);
+          // Sanity check that the output isn't constant.
+          should(output, prefix + `Output`).notBeConstantValueOf(output[0]);
+
+          // Verify that the output is constant over each render quantum
+          for (let k = 0; k < output.length; k += 128) {
+            should(
+                output.slice(k, k + 128), prefix + `Output [${k}, ${k + 127}]`)
+                .beConstantValueOf(output[k]);
+          }
+        });
+      }
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-stereo-panner.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-stereo-panner.html
new file mode 100644
index 0000000000..06905b89c3
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-stereo-panner.html
@@ -0,0 +1,48 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Test k-rate AudioParam of StereoPannerNode</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="automation-rate-testing.js"></script>
+  </head>
+
+  <body>
+    <script>
+      let audit = Audit.createTaskRunner();
+
+      audit.define('Test k-rate StereoPannerNode', (task, should) => {
+        // Arbitrary sample rate and duration.
+        let sampleRate = 8000;
+        let testDuration = 1;
+        let context = new OfflineAudioContext({
+          numberOfChannels: 3,
+          sampleRate: sampleRate,
+          length: testDuration * sampleRate
+        });
+
+        doTest(context, should, {
+          nodeName: 'StereoPannerNode',
+          nodeOptions: null,
+          prefix: 'StereoPannerNode',
+          // Set all AudioParams to k-rate.
+          rateSettings: [{name: 'pan', value: 'k-rate'}],
+          // Automate just the frequency.
+          automations: [{
+            name: 'pan',
+            methods: [
+              {name: 'setValueAtTime', options: [0, 0]}, {
+                name: 'linearRampToValueAtTime',
+                options: [.5, testDuration]
+              }
+            ]
+          }]
+        }).then(() => task.done());
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/nan-param.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/nan-param.html
new file mode 100644
index 0000000000..e9b8f0accb
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/nan-param.html
@@ -0,0 +1,92 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Test Flushing of NaN to Zero in AudioParams</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>
+      let audit = Audit.createTaskRunner();
+
+      // See
+      // https://webaudio.github.io/web-audio-api/#computation-of-value.
+      //
+      // The computed value must replace NaN values in the output with
+      // the default value of the param.
+      audit.define('AudioParam NaN', async (task, should) => {
+        // For testing, we only need a small number of frames; and
+        // a low sample rate is perfectly fine.  Use two channels.
+        // The first channel is for the AudioParam output.  The
+        // second channel is for the AudioParam input.
+        let context = new OfflineAudioContext(
+            {numberOfChannels: 2, length: 256, sampleRate: 8192});
+        let merger = new ChannelMergerNode(
+            context, {numberOfInputs: context.destination.channelCount});
+        merger.connect(context.destination);
+
+        // A constant source with a huge value.
+        let mod = new ConstantSourceNode(context, {offset: 1e30});
+
+        // Gain nodes with a huge positive gain and huge negative
+        // gain.  Combined with the huge offset in |mod|, the
+        // output of the gain nodes are +Infinity and -Infinity.
+        let gainPos = new GainNode(context, {gain: 1e30});
+        let gainNeg = new GainNode(context, {gain: -1e30});
+
+        mod.connect(gainPos);
+        mod.connect(gainNeg);
+
+        // Connect these to the second merger channel. This is a
+        // sanity check that the AudioParam input really is NaN.
+        gainPos.connect(merger, 0, 1);
+        gainNeg.connect(merger, 0, 1);
+
+        // Source whose AudioParam is connected to the graph
+        // that produces NaN values.  Use a non-default value offset
+        // just in case something is wrong we get default for some
+        // other reason.
+        let src = new ConstantSourceNode(context, {offset: 100});
+
+        gainPos.connect(src.offset);
+        gainNeg.connect(src.offset);
+
+        // AudioParam output goes to channel 1 of the destination.
+        src.connect(merger, 0, 0);
+
+        // Let's go!
+        mod.start();
+        src.start();
+
+        let buffer = await context.startRendering();
+
+        let input = buffer.getChannelData(1);
+        let output = buffer.getChannelData(0);
+
+        // Have to test manually for NaN values in the input because
+        // NaN fails all comparisons.
+        let isNaN = true;
+        for (let k = 0; k < input.length; ++k) {
+          if (!Number.isNaN(input[k])) {
+            isNaN = false;
+            break;
+          }
+        }
+
+        should(isNaN, 'AudioParam input contains only NaN').beTrue();
+
+        // Output of the AudioParam should have all NaN values
+        // replaced by the default.
+        should(output, 'AudioParam output')
+            .beConstantValueOf(src.offset.defaultValue);
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/retrospective-exponentialRampToValueAtTime.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/retrospective-exponentialRampToValueAtTime.html
new file mode 100644
index 0000000000..c81c3ad23e
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/retrospective-exponentialRampToValueAtTime.html
@@ -0,0 +1,70 @@
+<!doctype html>
+<meta charset=utf-8>
+<html>
+  <head>
+    <title>Test exponentialRampToValue with end time in the past</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="retrospective-test.js"></script>
+  </head>
+  <body>
+    <script>
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {
+            label: 'test',
+            description: 'Test exponentialRampToValue with end time in the past'
+          },
+          (task, should) => {
+            let {context, source, test, reference} = setupRetrospectiveGraph();
+
+            // Suspend the context at this frame so we can synchronously set up
+            // automations.
+            const suspendFrame = 128;
+
+            context.suspend(suspendFrame / context.sampleRate)
+                .then(() => {
+                  // Call setTargetAtTime with a time in the past
+                  test.gain.exponentialRampToValueAtTime(
+                      0.1, 0.5 * context.currentTime);
+                  test.gain.exponentialRampToValueAtTime(0.9, 1.0);
+
+                  reference.gain.exponentialRampToValueAtTime(
+                      0.1, context.currentTime);
+                  reference.gain.exponentialRampToValueAtTime(0.9, 1.0);
+                })
+                .then(() => context.resume());
+
+            source.start();
+
+            context.startRendering()
+                .then(resultBuffer => {
+                  let testValue = resultBuffer.getChannelData(0);
+                  let referenceValue = resultBuffer.getChannelData(1);
+
+                  // Until the suspendFrame, both should be exactly equal to 1.
+                  should(
+                      testValue.slice(0, suspendFrame),
+                      `Test[0:${suspendFrame - 1}]`)
+                      .beConstantValueOf(1);
+                  should(
+                      referenceValue.slice(0, suspendFrame),
+                      `Reference[0:${suspendFrame - 1}]`)
+                      .beConstantValueOf(1);
+
+                  // After the suspendFrame, both should be equal (and not
+                  // constant)
+                  should(
+                      testValue.slice(suspendFrame), `Test[${suspendFrame}:]`)
+                      .beEqualToArray(referenceValue.slice(suspendFrame));
+                })
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/retrospective-linearRampToValueAtTime.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/retrospective-linearRampToValueAtTime.html
new file mode 100644
index 0000000000..9f5e55fe55
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/retrospective-linearRampToValueAtTime.html
@@ -0,0 +1,70 @@
+<!doctype html>
+<meta charset=utf-8>
+<html>
+  <head>
+    <title>Test linearRampToValue with end time in the past</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="retrospective-test.js"></script>
+  </head>
+  <body>
+    <script>
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {
+            label: 'test',
+            description: 'Test linearRampToValue with end time in the past'
+          },
+          (task, should) => {
+            let {context, source, test, reference} = setupRetrospectiveGraph();
+
+            // Suspend the context at this frame so we can synchronously set up
+            // automations.
+            const suspendFrame = 128;
+
+            context.suspend(suspendFrame / context.sampleRate)
+                .then(() => {
+                  // Call setTargetAtTime with a time in the past
+                  test.gain.linearRampToValueAtTime(
+                      0.1, 0.5 * context.currentTime);
+                  test.gain.linearRampToValueAtTime(0.9, 1.0);
+
+                  reference.gain.linearRampToValueAtTime(
+                      0.1, context.currentTime);
+                  reference.gain.linearRampToValueAtTime(0.9, 1.0);
+                })
+                .then(() => context.resume());
+
+            source.start();
+
+            context.startRendering()
+                .then(resultBuffer => {
+                  let testValue = resultBuffer.getChannelData(0);
+                  let referenceValue = resultBuffer.getChannelData(1);
+
+                  // Until the suspendFrame, both should be exactly equal to 1.
+                  should(
+                      testValue.slice(0, suspendFrame),
+                      `Test[0:${suspendFrame - 1}]`)
+                      .beConstantValueOf(1);
+                  should(
+                      referenceValue.slice(0, suspendFrame),
+                      `Reference[0:${suspendFrame - 1}]`)
+                      .beConstantValueOf(1);
+
+                  // After the suspendFrame, both should be equal (and not
+                  // constant)
+                  should(
+                      testValue.slice(suspendFrame), `Test[${suspendFrame}:]`)
+                      .beEqualToArray(referenceValue.slice(suspendFrame));
+                })
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/retrospective-setTargetAtTime.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/retrospective-setTargetAtTime.html
new file mode 100644
index 0000000000..41a37bdb91
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/retrospective-setTargetAtTime.html
@@ -0,0 +1,80 @@
+<!doctype html>
+<meta charset=utf-8>
+<html>
+  <head>
+    <title>Test setTargetAtTime with start time in the past</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>
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {
+            label: 'test',
+            description: 'Test setTargetAtTime with start time in the past'
+          },
+          (task, should) => {
+            // Use a sample rate that is a power of two to eliminate round-off
+            // in computing the currentTime.
+            let context = new OfflineAudioContext(2, 16384, 16384);
+            let source = new ConstantSourceNode(context);
+
+            // Suspend the context at this frame so we can synchronously set up
+            // automations.
+            const suspendFrame = 128;
+
+            let test = new GainNode(context);
+            let reference = new GainNode(context);
+
+            source.connect(test);
+            source.connect(reference);
+
+            let merger = new ChannelMergerNode(
+                context, {numberOfInputs: context.destination.channelCount});
+            test.connect(merger, 0, 0);
+            reference.connect(merger, 0, 1);
+
+            merger.connect(context.destination);
+
+            context.suspend(suspendFrame / context.sampleRate)
+                .then(() => {
+                  // Call setTargetAtTime with a time in the past
+                  test.gain.setTargetAtTime(0.1, 0.5*context.currentTime, 0.1);
+                  reference.gain.setTargetAtTime(0.1, context.currentTime, 0.1);
+                })
+                .then(() => context.resume());
+
+            source.start();
+
+            context.startRendering()
+                .then(resultBuffer => {
+                  let testValue = resultBuffer.getChannelData(0);
+                  let referenceValue = resultBuffer.getChannelData(1);
+
+                  // Until the suspendFrame, both should be exactly equal to 1.
+                  should(
+                      testValue.slice(0, suspendFrame),
+                      `Test[0:${suspendFrame - 1}]`)
+                      .beConstantValueOf(1);
+                  should(
+                      referenceValue.slice(0, suspendFrame),
+                      `Reference[0:${suspendFrame - 1}]`)
+                      .beConstantValueOf(1);
+
+                  // After the suspendFrame, both should be equal (and not
+                  // constant)
+                  should(
+                      testValue.slice(suspendFrame), `Test[${suspendFrame}:]`)
+                      .beEqualToArray(referenceValue.slice(suspendFrame));
+                })
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/retrospective-setValueAtTime.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/retrospective-setValueAtTime.html
new file mode 100644
index 0000000000..32cdc6307f
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/retrospective-setValueAtTime.html
@@ -0,0 +1,74 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Test setValueAtTime with startTime in the past</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="retrospective-test.js"></script>
+  </head>
+  <body>
+    <script>
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {
+            label: 'test',
+            description: 'Test setValueAtTime with startTime in the past'
+          },
+          (task, should) => {
+            let {context, source, test, reference} = setupRetrospectiveGraph();
+
+            // Suspend the context at this frame so we can synchronously set up
+            // automations.
+            const suspendFrame = 128;
+
+            // Use a ramp of slope 1 per frame to measure time.
+            // The end value is the extent of exact precision in single
+            // precision float.
+            const rampEnd = context.length - suspendFrame;
+            const rampEndSeconds = context.length / context.sampleRate;
+
+            context.suspend(suspendFrame / context.sampleRate)
+                .then(() => {
+                  // Call setValueAtTime with a time in the past
+                  test.gain.setValueAtTime(0.0, 0.5 * context.currentTime);
+                  test.gain.linearRampToValueAtTime(rampEnd, rampEndSeconds);
+
+                  reference.gain.setValueAtTime(0.0, context.currentTime);
+                  reference.gain.linearRampToValueAtTime(
+                      rampEnd, rampEndSeconds);
+                })
+                .then(() => context.resume());
+
+            source.start();
+
+            context.startRendering()
+                .then(resultBuffer => {
+                  let testValue = resultBuffer.getChannelData(0);
+                  let referenceValue = resultBuffer.getChannelData(1);
+
+                  // Until the suspendFrame, both should be exactly equal to 1.
+                  should(
+                      testValue.slice(0, suspendFrame),
+                      `Test[0:${suspendFrame - 1}]`)
+                      .beConstantValueOf(1);
+                  should(
+                      referenceValue.slice(0, suspendFrame),
+                      `Reference[0:${suspendFrame - 1}]`)
+                      .beConstantValueOf(1);
+
+                  // After the suspendFrame, both should be equal (and not
+                  // constant)
+                  should(
+                      testValue.slice(suspendFrame), `Test[${suspendFrame}:]`)
+                      .beEqualToArray(referenceValue.slice(suspendFrame));
+                })
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/retrospective-setValueCurveAtTime.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/retrospective-setValueCurveAtTime.html
new file mode 100644
index 0000000000..451b6ea829
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/retrospective-setValueCurveAtTime.html
@@ -0,0 +1,67 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Test SetValueCurve with start time in the past</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="retrospective-test.js"></script>
+  </head>
+  </body>
+    <script>
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {
+            label: 'test',
+            description: 'Test SetValueCurve with start time in the past'
+          },
+          (task, should) => {
+            let {context, source, test, reference} = setupRetrospectiveGraph();
+
+            // Suspend the context at this frame so we can synchronously set up
+            // automations.
+            const suspendFrame = 128;
+
+            context.suspend(suspendFrame / context.sampleRate)
+                .then(() => {
+                  // Call setValueAtTime with a time in the past
+                  test.gain.setValueCurveAtTime(
+                      new Float32Array([1.0, 0.1]), 0.5 * context.currentTime,
+                      1.0);
+                  reference.gain.setValueCurveAtTime(
+                      new Float32Array([1.0, 0.1]), context.currentTime, 1.0);
+                })
+                .then(() => context.resume());
+
+            source.start();
+
+            context.startRendering()
+                .then(resultBuffer => {
+                  let testValue = resultBuffer.getChannelData(0);
+                  let referenceValue = resultBuffer.getChannelData(1);
+
+                  // Until the suspendFrame, both should be exactly equal to 1.
+                  should(
+                      testValue.slice(0, suspendFrame),
+                      `Test[0:${suspendFrame - 1}]`)
+                      .beConstantValueOf(1);
+                  should(
+                      referenceValue.slice(0, suspendFrame),
+                      `Reference[0:${suspendFrame - 1}]`)
+                      .beConstantValueOf(1);
+
+                  // After the suspendFrame, both should be equal (and not
+                  // constant)
+                  should(
+                      testValue.slice(suspendFrame), `Test[${suspendFrame}:]`)
+                      .beEqualToArray(referenceValue.slice(suspendFrame));
+                })
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/retrospective-test.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/retrospective-test.js
new file mode 100644
index 0000000000..bbda190f09
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/retrospective-test.js
@@ -0,0 +1,29 @@
+// Create an audio graph on an offline context that consists of a
+// constant source and two gain nodes. One of the nodes is the node te
+// be tested and the other is the reference node.  The output from the
+// test node is in channel 0 of the offline context; the reference
+// node is in channel 1.
+//
+// Returns a dictionary with the context, source node, the test node,
+// and the reference node.
+function setupRetrospectiveGraph() {
+  // Use a sample rate that is a power of two to eliminate round-off
+  // in computing the currentTime.
+  let context = new OfflineAudioContext(2, 16384, 16384);
+  let source = new ConstantSourceNode(context);
+
+  let test = new GainNode(context);
+  let reference = new GainNode(context);
+
+  source.connect(test);
+  source.connect(reference);
+
+  let merger = new ChannelMergerNode(
+      context, {numberOfInputs: context.destination.channelCount});
+  test.connect(merger, 0, 0);
+  reference.connect(merger, 0, 1);
+
+  merger.connect(context.destination);
+
+  return {context: context, source: source, test: test, reference: reference};
+}
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/set-target-conv.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/set-target-conv.html
new file mode 100644
index 0000000000..2ed076cccf
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/set-target-conv.html
@@ -0,0 +1,93 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+  <head>
+    <title>Test convergence of setTargetAtTime</title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+    <script src='/webaudio/resources/audio-param.js'></script>
+  </head>
+
+  <body>
+    <script>
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {task: 'setTargetAtTime', label: 'convergence handled correctly'},
+          (task, should) => {
+            // Two channels:
+            //  0 - actual result
+            //  1 - expected result
+            const context = new OfflineAudioContext(
+                {numberOfChannels: 2, sampleRate: 8000, length: 8000});
+
+            const merger = new ChannelMergerNode(
+                context, {numberOfChannels: context.destination.channelCount});
+            merger.connect(context.destination);
+
+            // Construct test source that will have tha AudioParams being tested
+            // to verify that the AudioParams are working correctly.
+            let src;
+
+            should(
+                () => src = new ConstantSourceNode(context),
+                'src = new ConstantSourceNode(context)')
+                .notThrow();
+
+            src.connect(merger, 0, 0);
+            src.offset.setValueAtTime(1, 0);
+
+            const timeConstant = 0.01;
+
+            // testTime must be at least 10*timeConstant. Also, this must not
+            // lie on a render boundary.
+            const testTime = 0.15;
+            const rampEnd = testTime + 0.001;
+
+            should(
+                () => src.offset.setTargetAtTime(0.5, 0.01, timeConstant),
+                `src.offset.setTargetAtTime(0.5, 0.01, ${timeConstant})`)
+                .notThrow();
+            should(
+                () => src.offset.setValueAtTime(0.5, testTime),
+                `src.offset.setValueAtTime(0.5, ${testTime})`)
+                .notThrow();
+            should(
+                () => src.offset.linearRampToValueAtTime(1, rampEnd),
+                `src.offset.linearRampToValueAtTime(1, ${rampEnd})`)
+                .notThrow();
+
+            // The reference node that will generate the expected output.  We do
+            // the same automations, except we don't apply the setTarget
+            // automation.
+            const refSrc = new ConstantSourceNode(context);
+            refSrc.connect(merger, 0, 1);
+
+            refSrc.offset.setValueAtTime(0.5, 0);
+            refSrc.offset.setValueAtTime(0.5, testTime);
+            refSrc.offset.linearRampToValueAtTime(1, rampEnd);
+
+            src.start();
+            refSrc.start();
+
+            context.startRendering()
+                .then(audio => {
+                  const actual = audio.getChannelData(0);
+                  const expected = audio.getChannelData(1);
+
+                  // Just verify that the actual output matches the expected
+                  // starting a little bit before testTime.
+                  let testFrame =
+                      Math.floor(testTime * context.sampleRate) - 128;
+                  should(actual.slice(testFrame), `output[${testFrame}:]`)
+                      .beCloseToArray(
+                          expected.slice(testFrame),
+                          {relativeThreshold: 4.1724e-6});
+                })
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/setTargetAtTime-after-event-within-block.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/setTargetAtTime-after-event-within-block.html
new file mode 100644
index 0000000000..827aeeabd4
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/setTargetAtTime-after-event-within-block.html
@@ -0,0 +1,54 @@
+<!DOCTYPE html>
+<title>Test setTargetAtTime after an event in the same processing block</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+promise_test(function() {
+  const bufferSize = 179;
+  const valueStartOffset = 42;
+  const targetStartOffset = 53;
+  const sampleRate = 48000;
+  const scheduledValue = -0.5;
+
+  var context = new OfflineAudioContext(1, bufferSize, sampleRate);
+
+  var gain = context.createGain();
+  gain.gain.setValueAtTime(scheduledValue, valueStartOffset/sampleRate);
+  gain.gain.setTargetAtTime(scheduledValue, targetStartOffset/sampleRate,
+                            128/sampleRate);
+  gain.connect(context.destination);
+
+  // Apply unit DC signal to gain node.
+  var source = context.createBufferSource();
+  source.buffer =
+    function() {
+      var buffer = context.createBuffer(1, 1, context.sampleRate);
+      buffer.getChannelData(0)[0] = 1.0;
+      return buffer;
+    }();
+  source.loop = true;
+  source.start();
+  source.connect(gain);
+
+  return context.startRendering().
+    then(function(buffer) {
+      assert_equals(buffer.length, bufferSize, "output buffer length");
+      var output = buffer.getChannelData(0);
+      var i = 0;
+      for (; i < valueStartOffset; ++i) {
+        // "Its default value is 1."
+        assert_equals(output[i], 1.0, "default gain at sample " + i);
+      }
+      for (; i < buffer.length; ++i) {
+        // "If the next event (having time T1) after this SetValue event is
+        // not of type LinearRampToValue or ExponentialRampToValue, then, for
+        // T0≤t<T1: v(t)=V".
+        // "Start exponentially approaching the target value at the given time
+        // with a rate having the given time constant."
+        // The target is the same value, and so the SetValue value continues.
+        assert_equals(output[i], scheduledValue,
+                      "scheduled value at sample " + i);
+      }
+    });
+});
+</script>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/setValueAtTime-within-block.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/setValueAtTime-within-block.html
new file mode 100644
index 0000000000..36fde2b996
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioparam-interface/setValueAtTime-within-block.html
@@ -0,0 +1,48 @@
+<!DOCTYPE html>
+<title>Test setValueAtTime with start time not on a block boundary</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+promise_test(function() {
+  const bufferSize = 200;
+  const offset = 65;
+  const sampleRate = 48000;
+  const scheduledValue = -2.0;
+
+  var context = new OfflineAudioContext(1, bufferSize, sampleRate);
+
+  var gain = context.createGain();
+  gain.gain.setValueAtTime(scheduledValue, offset/sampleRate);
+  gain.connect(context.destination);
+
+  // Apply unit DC signal to gain node.
+  var source = context.createBufferSource();
+  source.buffer =
+    function() {
+      var buffer = context.createBuffer(1, 1, context.sampleRate);
+      buffer.getChannelData(0)[0] = 1.0;
+      return buffer;
+    }();
+  source.loop = true;
+  source.start();
+  source.connect(gain);
+
+  return context.startRendering().
+    then(function(buffer) {
+      assert_equals(buffer.length, bufferSize, "output buffer length");
+      var output = buffer.getChannelData(0);
+      var i = 0;
+      for (; i < offset; ++i) {
+        // "Its default value is 1."
+        assert_equals(output[i], 1.0, "default gain at sample " + i);
+      }
+      for (; i < buffer.length; ++i) {
+        // "If there are no more events after this SetValue event, then for
+        // t≥T0, v(t)=V, where T0 is the startTime parameter and V is the
+        // value parameter."
+        assert_equals(output[i], scheduledValue,
+                      "scheduled value at sample " + i);
+      }
+    });
+});
+</script>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-addmodule-resolution.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-addmodule-resolution.https.html
new file mode 100644
index 0000000000..dc324b22d6
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-addmodule-resolution.https.html
@@ -0,0 +1,61 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test the invocation order of AudioWorklet.addModule() and BaseAudioContext
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      setup(() => {
+        let sampleRate = 48000;
+        let realtimeContext = new AudioContext();
+        let offlineContext = new OfflineAudioContext(1, sampleRate, sampleRate);
+
+        let filePath = 'processors/dummy-processor.js';
+
+        // Test if the browser does not crash upon addModule() call after the
+        // realtime context construction.
+        audit.define(
+            {label: 'module-loading-after-realtime-context-creation'},
+            (task, should) => {
+              let dummyWorkletNode =
+                  new AudioWorkletNode(realtimeContext, 'dummy');
+              dummyWorkletNode.connect(realtimeContext.destination);
+              should(dummyWorkletNode instanceof AudioWorkletNode,
+                     '"dummyWorkletNode" is an instance of AudioWorkletNode ' +
+                     'from realtime context')
+                  .beTrue();
+              task.done();
+            });
+
+        // Test if the browser does not crash upon addModule() call after the
+        // offline context construction.
+        audit.define(
+            {label: 'module-loading-after-offline-context-creation'},
+            (task, should) => {
+              let dummyWorkletNode =
+                  new AudioWorkletNode(offlineContext, 'dummy');
+              dummyWorkletNode.connect(offlineContext.destination);
+              should(dummyWorkletNode instanceof AudioWorkletNode,
+                     '"dummyWorkletNode" is an instance of AudioWorkletNode ' +
+                     'from offline context')
+                  .beTrue();
+              task.done();
+            });
+
+        Promise.all([
+            realtimeContext.audioWorklet.addModule(filePath),
+            offlineContext.audioWorklet.addModule(filePath)
+          ]).then(() => {
+            audit.run();
+          });
+      });
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-audioparam-iterable.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-audioparam-iterable.https.html
new file mode 100644
index 0000000000..9e93f48ab8
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-audioparam-iterable.https.html
@@ -0,0 +1,205 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>
+      Test get parameterDescriptor as various iterables
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/js/helpers.js"></script>
+  </head>
+
+  <body>
+    <script id="params">
+      // A series of AudioParamDescriptors, copied one by one into various iterable
+      // data structures. This is used by both the processor side and the main
+      // thread side, so is in a different script tag.
+      const PARAMS = [
+        {
+          name: "a control-rate parameter",
+          defaultValue: 0.5,
+          minValue: 0,
+          maxValue: 1,
+          automationRate: "a-rate",
+        },
+        {
+          name: "你好",
+          defaultValue: 2.5,
+          minValue: 0,
+          maxValue: 7,
+          automationRate: "a-rate",
+        },
+        {
+          name: "🎶",
+          defaultValue: 8.5,
+          minValue: 0,
+          maxValue: 11115,
+          automationRate: "k-rate",
+        },
+      ];
+    </script>
+    <script id="processors" type="worklet">
+      registerProcessor("set",
+      class SetParamProcessor extends AudioWorkletProcessor {
+        static get parameterDescriptors() {
+          var s = new Set();
+          s.add(PARAMS[0]);
+          s.add(PARAMS[1]);
+          s.add(PARAMS[2]);
+          return s;
+        }
+        constructor() { super(); }
+        process() {
+        }
+      });
+
+      registerProcessor("array",
+      class ArrayParamProcessor extends AudioWorkletProcessor {
+        static get parameterDescriptors() {
+          return PARAMS;
+        }
+        constructor() { super(); }
+        process() { }
+      });
+
+      function* gen() {
+        yield PARAMS[0];
+        yield PARAMS[1];
+        yield PARAMS[2];
+      }
+      registerProcessor("generator",
+      class GeneratorParamProcessor extends AudioWorkletProcessor {
+        static get parameterDescriptors() {
+          return gen();
+        }
+        constructor() { super(); }
+        process() { }
+      });
+      // Test a processor that has a get parameterDescriptors, but it returns
+      // something that is not iterable.
+      try {
+        registerProcessor("invalid",
+        class InvalidParamProcessor extends AudioWorkletProcessor {
+          static get parameterDescriptors() {
+            return 4;
+          }
+          constructor() { super(); }
+          process() { }
+        });
+        throw "This should not have been reached.";
+      } catch (e) {
+        // unclear how to signal success here, but we can signal failure in the
+        // developer console
+        if (e.name != "TypeError") {
+          throw "This should be TypeError";
+        }
+      }
+      // Test a processor that has a get parameterDescriptors, with a duplicate
+      // param name something that is not iterable.
+      try {
+        registerProcessor("duplicate-param-name",
+        class DuplicateParamProcessor extends AudioWorkletProcessor {
+          static get parameterDescriptors() {
+            var p = {
+                name: "a",
+                defaultValue: 1,
+                minValue: 0,
+                maxValue: 1,
+                automationRate: "k-rate",
+            };
+            return [p,p];
+          }
+          constructor() { super(); }
+          process() { }
+        });
+        throw "This should not have been reached.";
+      } catch (e) {
+        // unclear how to signal success here, but we can signal failure in the
+        // developer console
+        if (e.name != "NotSupportedError") {
+          throw "This should be NotSupportedError";
+        }
+      }
+      // Test a processor that has a no get parameterDescriptors.
+      try {
+        registerProcessor("no-params",
+        class NoParamProcessor extends AudioWorkletProcessor {
+          constructor() { super(); }
+          process() { }
+        });
+      } catch (e) {
+        throw "Construction should have worked.";
+      }
+    </script>
+    <script>
+      setup({ explicit_done: true });
+      // Mangle the PARAMS object into a map that has the same shape as what an
+      // AudioWorkletNode.parameter property would
+      var PARAMS_MAP = new Map();
+      for (var param of PARAMS) {
+        var o = param;
+        var name = o.name;
+        delete o.name;
+        PARAMS_MAP.set(name, o);
+      }
+
+      // This compares `lhs` and `rhs`, that are two maplike with the same shape
+      // as PARAMS_MAP.
+      function compare(testname, lhs, rhs) {
+        equals(lhs.size, rhs.size, "Map match in size for " + testname);
+        var i = 0;
+        for (var [k, v] of lhs) {
+          is_true(rhs.has(k), testname + ": " + k + " exists in both maps");
+          var vrhs = rhs.get(k);
+          ["defaultValue", "minValue", "maxValue", "automationRate"].forEach(
+            paramKey => {
+              equals(
+                v[paramKey],
+                vrhs[paramKey],
+                `Values for ${k}.${paramKey} match for ${testname}`
+              );
+            }
+          );
+        }
+      }
+      var ac = new AudioContext();
+      var url = URLFromScriptsElements(["params", "processors"]);
+      ac.audioWorklet
+        .addModule(url)
+        .then(() => {
+              ["set", "array", "generator"].forEach(iterable => {
+                test(() => {
+                  var node = new AudioWorkletNode(ac, iterable);
+                  compare(iterable, node.parameters, PARAMS_MAP);
+                }, `Creating an AudioWorkletNode with a ${iterable} for
+                    parameter descriptor worked`);
+          });
+        })
+        .then(function() {
+          test(function() {
+            assert_throws_dom("InvalidStateError", function() {
+              new AudioWorkletNode(ac, "invalid");
+            });
+          }, `Attempting to create an AudioWorkletNode with an non
+              iterable for parameter descriptor should not work`);
+        })
+      .then(function() {
+        test(() => {
+          new AudioWorkletNode(ac, "no-params");
+        }, `Attempting to create an AudioWorkletNode from a processor
+            that does not have a parameterDescriptors getter should work`);
+      })
+      .then(function() {
+        test(function() {
+          assert_throws_dom("InvalidStateError", function() {
+            new AudioWorkletNode(ac, "duplicate-param-name");
+          });
+        }, `Attempting to create an AudioWorkletNode with two parameter
+            descriptor with the same name should not work`);
+      }).then(function() {
+        done();
+      });
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-audioparam-size.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-audioparam-size.https.html
new file mode 100644
index 0000000000..9578b26881
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-audioparam-size.https.html
@@ -0,0 +1,96 @@
+<!doctype html>
+<html>
+  <head>
+    <title>
+      Test AudioParam Array Size
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+    <script src="/webaudio/resources/audit-util.js"></script>
+  </head>
+
+  <body>
+    <script>
+      let audit = Audit.createTaskRunner();
+      let filePath = 'processors/param-size-processor.js';
+      let context;
+
+      // Use a power of two so there's no roundoff computing times from frames.
+      let sampleRate = 16384;
+
+      // Sets up AudioWorklet and OfflineAudioContext.
+      audit.define('Initializing AudioWorklet and Context', (task, should) => {
+        should(() => {
+          context = new OfflineAudioContext(
+              1, 10 * RENDER_QUANTUM_FRAMES, sampleRate);
+        }, 'Creating offline context for testing').notThrow();
+
+        should(
+            context.audioWorklet.addModule(filePath), 'Creating test worklet')
+            .beResolved()
+            .then(() => {
+              task.done();
+            });
+      });
+
+      audit.define('Verify Size of AudioParam Arrays', (task, should) => {
+        let node = new AudioWorkletNode(context, 'param-size');
+        let nodeParam = node.parameters.get('param');
+
+        node.connect(context.destination);
+
+        let renderQuantumDuration = RENDER_QUANTUM_FRAMES / context.sampleRate;
+
+        // Set up some automations, after one render quantum.  We want the first
+        // render not to have any automations, just to be sure we handle that
+        // case correctly.
+        context.suspend(renderQuantumDuration)
+            .then(() => {
+              let now = context.currentTime;
+
+              // Establish the first automation event.
+              nodeParam.setValueAtTime(1, now);
+              // The second render should be constant
+              nodeParam.setValueAtTime(0, now + renderQuantumDuration);
+              // The third render and part of the fourth is a linear ramp
+              nodeParam.linearRampToValueAtTime(
+                  1, now + 2.5 * renderQuantumDuration);
+              // Everything afterwards should be constant.
+            })
+            .then(() => context.resume());
+
+        context.startRendering()
+            .then(renderedBuffer => {
+              let data = renderedBuffer.getChannelData(0);
+
+              // The very first render quantum should be constant, so the array
+              // has length 1.
+              should(
+                  data.slice(0, RENDER_QUANTUM_FRAMES),
+                  'Render quantum 0: array size')
+                  .beConstantValueOf(1);
+
+              should(
+                  data.slice(RENDER_QUANTUM_FRAMES, 2 * RENDER_QUANTUM_FRAMES),
+                  'Render quantum 1: array size')
+                  .beConstantValueOf(1);
+
+              should(
+                  data.slice(
+                      2 * RENDER_QUANTUM_FRAMES, 4 * RENDER_QUANTUM_FRAMES),
+                  'Render quantum 2-3: array size')
+                  .beConstantValueOf(RENDER_QUANTUM_FRAMES);
+
+              should(
+                  data.slice(4 * RENDER_QUANTUM_FRAMES),
+                  'Remaining renders: array size')
+                  .beConstantValueOf(1);
+            })
+            .then(() => task.done());
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-audioparam.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-audioparam.https.html
new file mode 100644
index 0000000000..8e51470f64
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-audioparam.https.html
@@ -0,0 +1,85 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test AudioWorkletNode's basic AudioParam features
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      let sampleRate = 48000;
+      let renderLength = 48000 * 0.6;
+      let context;
+
+      let filePath = 'processors/gain-processor.js';
+
+      // Sets up AudioWorklet and OfflineAudioContext.
+      audit.define('Initializing AudioWorklet and Context', (task, should) => {
+        context = new OfflineAudioContext(1, renderLength, sampleRate);
+        context.audioWorklet.addModule(filePath).then(() => {
+          task.done();
+        });
+      });
+
+      // Verifies the functionality of AudioParam in AudioWorkletNode by
+      // comparing (canceling out) values from GainNode and AudioWorkletNode
+      // with simple gain computation code by AudioParam.
+      audit.define(
+          'Verifying AudioParam in AudioWorkletNode',
+          (task, should) => {
+            let constantSourceNode = new ConstantSourceNode(context);
+            let gainNode = new GainNode(context);
+            let inverterNode = new GainNode(context, {gain: -1});
+            let gainWorkletNode = new AudioWorkletNode(context, 'gain');
+            let gainWorkletParam = gainWorkletNode.parameters.get('gain');
+
+            // Test default value and setter/getter functionality.
+            should(gainWorkletParam.value,
+                   'Default gain value of gainWorkletNode')
+                .beEqualTo(Math.fround(0.707));
+            gainWorkletParam.value = 0.1;
+            should(gainWorkletParam.value,
+                   'Value of gainWorkletParam after setter = 0.1')
+                .beEqualTo(Math.fround(0.1));
+
+            constantSourceNode.connect(gainNode)
+                .connect(inverterNode)
+                .connect(context.destination);
+            constantSourceNode.connect(gainWorkletNode)
+                .connect(context.destination);
+
+            // With arbitrary times and values, test all possible AudioParam
+            // automations.
+            [gainNode.gain, gainWorkletParam].forEach((param) => {
+              param.setValueAtTime(0, 0);
+              param.linearRampToValueAtTime(1, 0.1);
+              param.exponentialRampToValueAtTime(0.5, 0.2);
+              param.setValueCurveAtTime([0, 2, 0.3], 0.2, 0.1);
+              param.setTargetAtTime(0.01, 0.4, 0.5);
+            });
+
+            // Test if the setter works correctly in the middle of rendering.
+            context.suspend(0.5).then(() => {
+              gainNode.gain.value = 1.5;
+              gainWorkletParam.value = 1.5;
+              context.resume();
+            });
+
+            constantSourceNode.start();
+            context.startRendering().then((renderedBuffer) => {
+              should(renderedBuffer.getChannelData(0),
+                     'The rendered buffer')
+                  .beConstantValueOf(0);
+              task.done();
+            });
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-messageport.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-messageport.https.html
new file mode 100644
index 0000000000..546bd1d0d0
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-messageport.https.html
@@ -0,0 +1,66 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test MessagePort in AudioWorkletNode and AudioWorkletProcessor
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      let context = new AudioContext();
+
+      let filePath = 'processors/port-processor.js';
+
+      // Creates an AudioWorkletNode and sets an EventHandler on MessagePort
+      // object. The associated PortProcessor will post a message upon its
+      // construction. Test if the message is received correctly.
+      audit.define(
+          'Test postMessage from AudioWorkletProcessor to AudioWorkletNode',
+          (task, should) => {
+            let porterWorkletNode =
+                new AudioWorkletNode(context, 'port-processor');
+
+            // Upon the creation of PortProcessor, it will post a message to the
+            // node with 'created' status.
+            porterWorkletNode.port.onmessage = (event) => {
+              should(event.data.state,
+                     'The initial message from PortProcessor')
+                  .beEqualTo('created');
+              task.done();
+            };
+          });
+
+      // PortProcessor is supposed to echo the message back to the
+      // AudioWorkletNode.
+      audit.define(
+          'Test postMessage from AudioWorkletNode to AudioWorkletProcessor',
+          (task, should) => {
+            let porterWorkletNode =
+                new AudioWorkletNode(context, 'port-processor');
+
+            porterWorkletNode.port.onmessage = (event) => {
+              // Ignore if the delivered message has |state|. This is already
+              // tested in the previous task.
+              if (event.data.state)
+                return;
+
+              should(event.data.message,
+                     'The response from PortProcessor')
+                  .beEqualTo('hello');
+              task.done();
+            };
+
+            porterWorkletNode.port.postMessage('hello');
+          });
+
+      context.audioWorklet.addModule(filePath).then(() => {
+        audit.run();
+      });
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-postmessage-sharedarraybuffer.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-postmessage-sharedarraybuffer.https.html
new file mode 100644
index 0000000000..a5dd004981
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-postmessage-sharedarraybuffer.https.html
@@ -0,0 +1,76 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test passing SharedArrayBuffer to an AudioWorklet
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      let context = new AudioContext();
+
+      let filePath = 'processors/sharedarraybuffer-processor.js';
+
+      audit.define(
+          'Test postMessage from AudioWorkletProcessor to AudioWorkletNode',
+          (task, should) => {
+            let workletNode =
+                new AudioWorkletNode(context, 'sharedarraybuffer-processor');
+
+            // After it is created, the worklet will send a new
+            // SharedArrayBuffer to the main thread.
+            //
+            // The worklet will then wait to receive a message from the main
+            // thread.
+            //
+            // When it receives the message, it will check whether it is a
+            // SharedArrayBuffer, and send this information back to the main
+            // thread.
+
+            workletNode.port.onmessage = (event) => {
+              let data = event.data;
+              switch (data.state) {
+                case 'created':
+                  should(
+                      data.sab instanceof SharedArrayBuffer,
+                      'event.data.sab from worklet is an instance of SharedArrayBuffer')
+                      .beTrue();
+
+                  // Send a SharedArrayBuffer back to the worklet.
+                  let sab = new SharedArrayBuffer(8);
+                  workletNode.port.postMessage(sab);
+                  break;
+
+                case 'received message':
+                  should(data.isSab, 'event.data from main thread is an instance of SharedArrayBuffer')
+                      .beTrue();
+                  task.done();
+                  break;
+
+                default:
+                  should(false,
+                         `Got unexpected message from worklet: ${data.state}`)
+                      .beTrue();
+                  task.done();
+                  break;
+              }
+            };
+
+            workletNode.port.onmessageerror = (event) => {
+              should(false, 'Got messageerror from worklet').beTrue();
+              task.done();
+            };
+          });
+
+      context.audioWorklet.addModule(filePath).then(() => {
+        audit.run();
+      });
+    </script>
+  </body>
+</html>
+
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-postmessage-sharedarraybuffer.https.html.headers b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-postmessage-sharedarraybuffer.https.html.headers
new file mode 100644
index 0000000000..63b60e490f
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-postmessage-sharedarraybuffer.https.html.headers
@@ -0,0 +1,2 @@
+Cross-Origin-Opener-Policy: same-origin
+Cross-Origin-Embedder-Policy: require-corp
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-registerprocessor-called-on-globalthis.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-registerprocessor-called-on-globalthis.https.html
new file mode 100644
index 0000000000..718cadffc7
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-registerprocessor-called-on-globalthis.https.html
@@ -0,0 +1,29 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test AudioWorkletGlobalScope's registerProcessor() called on globalThis
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      const audit = Audit.createTaskRunner();
+      const realtimeContext = new AudioContext();
+      const filePath = 'processors/dummy-processor-globalthis.js';
+
+      audit.define('registerprocessor-called-on-globalthis', (task, should) => {
+        realtimeContext.audioWorklet.addModule(filePath).then(() => {
+          const dummyWorkletNode = new AudioWorkletNode(realtimeContext, 'dummy-globalthis');
+          should(dummyWorkletNode instanceof AudioWorkletNode,
+            '"dummyWorkletNode" is an instance of AudioWorkletNode').beTrue();
+          task.done();
+        });
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-registerprocessor-dynamic.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-registerprocessor-dynamic.https.html
new file mode 100644
index 0000000000..de31f71427
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-registerprocessor-dynamic.https.html
@@ -0,0 +1,36 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test dynamic registerProcessor() calls in AudioWorkletGlobalScope
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+  </head>
+  <body>
+    <script>
+      const t = async_test('Dynamic registration in AudioWorkletGlobalScope');
+
+      const realtimeContext = new AudioContext();
+      const filePath = 'processors/dynamic-register-processor.js';
+
+      // Test if registering an AudioWorkletProcessor dynamically (after the
+      // initial module script loading) works correctly. In the construction of
+      // nodeB (along with ProcessorB), it registers ProcessorA's definition.
+      realtimeContext.audioWorklet.addModule(filePath).then(() => {
+        const nodeB = new AudioWorkletNode(realtimeContext, 'ProcessorB');
+        assert_true(nodeB instanceof AudioWorkletNode,
+                    'nodeB should be instance of AudioWorkletNode');
+        nodeB.port.postMessage({});
+        nodeB.port.onmessage = () => {
+          const nodeA = new AudioWorkletNode(realtimeContext, 'ProcessorA');
+          t.step(() => {
+            assert_true(nodeA instanceof AudioWorkletNode,
+                        'nodeA should be instance of AudioWorkletNode');
+          });
+          t.done();
+        };
+      });
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-suspend.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-suspend.https.html
new file mode 100644
index 0000000000..685546aeb5
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-suspend.https.html
@@ -0,0 +1,39 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test if activation of worklet thread does not resume context rendering.
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      const audit = Audit.createTaskRunner();
+      const context = new AudioContext();
+      const filePath = 'processors/dummy-processor.js';
+
+      context.suspend();
+
+      // Suspends the context right away and then activate worklet. The current
+      // time must not advance since the context is suspended.
+      audit.define(
+          {label: 'load-worklet-and-suspend'},
+          async (task, should) => {
+            await context.audioWorklet.addModule(filePath);
+            const suspendTime = context.currentTime;
+            const dummy = new AudioWorkletNode(context, 'dummy');
+            dummy.connect(context.destination);
+            return task.timeout(() => {
+              should(context.currentTime === suspendTime,
+                     'context.currentTime did not change after worklet started')
+                  .beTrue();
+              should(context.state, 'context.state').beEqualTo('suspended');
+            }, 500);
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-throw-onmessage.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-throw-onmessage.https.html
new file mode 100644
index 0000000000..3a480464e9
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworklet-throw-onmessage.https.html
@@ -0,0 +1,62 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>
+      Test the behaviour of AudioWorkletProcessor when an `onmessage` handler
+      throws.
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/js/helpers.js"></script>
+  </head>
+
+  <body>
+    <script id="processor" type="worklet">
+      registerProcessor("test-throw", class param extends AudioWorkletProcessor {
+        constructor() {
+          super()
+          this.i = 0;
+          this.port.onmessage = function(arg) {
+            throw "asdasd";
+          }
+        }
+        process(input, output, parameters) {
+          this.i++;
+          this.port.postMessage(this.i);
+          return true;
+        }
+      });
+    </script>
+    <script>
+      var latestIndexReceived = 0;
+      var node = null;
+      var ac = null;
+      promise_setup(function() {
+        ac = new AudioContext();
+        var url = URLFromScriptsElements(["processor"]);
+        return ac.audioWorklet.addModule(url).then(function() {
+          node = new AudioWorkletNode(ac, "test-throw");
+          node.port.onmessage = function(e) {
+            latestIndexReceived = parseInt(e.data);
+          };
+        });
+      });
+      promise_test(async t => {
+        var currentIndex = latestIndexReceived;
+        await t.step_wait(() => {
+          return latestIndexReceived > currentIndex;
+        }, "Process is still being called");
+
+        node.port.postMessage("asdasd"); // This throws on the processor side.
+        node.onprocessorerror = function() {
+          assert_true(false, "onprocessorerror must not be called.");
+        };
+        currentIndex = latestIndexReceived;
+        await t.step_wait(() => {
+          return latestIndexReceived > currentIndex + 2;
+        }, "Process is still being called");
+      }, `Throwing in an onmessage handler in the AudioWorkletGlobalScope shouldn't stop AudioWorkletProcessor`);
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletglobalscope-sample-rate.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletglobalscope-sample-rate.https.html
new file mode 100644
index 0000000000..84458d0aaa
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletglobalscope-sample-rate.https.html
@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test sampleRate in AudioWorkletGlobalScope
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      setup(() => {
+        let sampleRate = 48000;
+        let renderLength = 512;
+        let context = new OfflineAudioContext(1, renderLength, sampleRate);
+
+        let filePath = 'processors/one-pole-processor.js';
+
+        // Without rendering the context, attempt to access |sampleRate| in the
+        // global scope as soon as it is created.
+        audit.define(
+            'Query |sampleRate| upon AudioWorkletGlobalScope construction',
+            (task, should) => {
+              let onePoleFilterNode =
+                  new AudioWorkletNode(context, 'one-pole-filter');
+              let frequencyParam = onePoleFilterNode.parameters.get('frequency');
+
+              should(frequencyParam.maxValue,
+                     'frequencyParam.maxValue')
+                  .beEqualTo(0.5 * context.sampleRate);
+
+              task.done();
+            });
+
+        context.audioWorklet.addModule(filePath).then(() => {
+          audit.run();
+        });
+      });
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletglobalscope-timing-info.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletglobalscope-timing-info.https.html
new file mode 100644
index 0000000000..5f4bee7c53
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletglobalscope-timing-info.https.html
@@ -0,0 +1,59 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test currentTime and currentFrame in AudioWorkletGlobalScope
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      setup(() => {
+        let sampleRate = 48000;
+        let renderLength = 512;
+        let context = new OfflineAudioContext(1, renderLength, sampleRate);
+
+        let filePath = 'processors/timing-info-processor.js';
+
+        audit.define(
+            'Check the timing information from AudioWorkletProcessor',
+            (task, should) => {
+              let portWorkletNode =
+                  new AudioWorkletNode(context, 'timing-info-processor');
+              portWorkletNode.connect(context.destination);
+
+              // Suspend at render quantum boundary and check the timing
+              // information between the main thread and the rendering thread.
+              [0, 128, 256, 384].map((suspendFrame) => {
+                context.suspend(suspendFrame/sampleRate).then(() => {
+                  portWorkletNode.port.onmessage = (event) => {
+                    should(event.data.currentFrame,
+                           'currentFrame from the processor at ' + suspendFrame)
+                        .beEqualTo(suspendFrame);
+                    should(event.data.currentTime,
+                           'currentTime from the processor at '
+                               + context.currentTime)
+                        .beEqualTo(context.currentTime);
+                    context.resume();
+                  };
+
+                  portWorkletNode.port.postMessage('query-timing-info');
+                });
+              });
+
+              context.startRendering().then(() => {
+                task.done();
+              });
+            });
+
+        context.audioWorklet.addModule(filePath).then(() => {
+          audit.run();
+        });
+      });
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-automatic-pull.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-automatic-pull.https.html
new file mode 100644
index 0000000000..330b359f7d
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-automatic-pull.https.html
@@ -0,0 +1,73 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test AudioWorkletNode's automatic pull feature
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+    <script src="/webaudio/resources/audit-util.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      const audit = Audit.createTaskRunner();
+
+      // Arbitrary sample rate. Anything should work.
+      const sampleRate = 48000;
+      const renderLength = RENDER_QUANTUM_FRAMES * 2;
+      const channelCount = 1;
+      const filePath = 'processors/zero-output-processor.js';
+
+      const sourceOffset = 0.5;
+
+      // Connect a constant source node to the zero-output AudioWorkletNode.
+      // Then verify if it captures the data correctly.
+      audit.define('setup-worklet', (task, should) => {
+        const context =
+            new OfflineAudioContext(channelCount, renderLength, sampleRate);
+
+        context.audioWorklet.addModule(filePath).then(() => {
+          let testSource =
+              new ConstantSourceNode(context, { offset: sourceOffset });
+          let zeroOutputWorkletNode =
+              new AudioWorkletNode(context, 'zero-output-processor', {
+                numberOfInputs: 1,
+                numberOfOutputs: 0,
+                processorOptions: {
+                  bufferLength: renderLength,
+                  channeCount: channelCount
+                }
+              });
+
+          // Start the source and stop at the first render quantum.
+          testSource.connect(zeroOutputWorkletNode);
+          testSource.start();
+          testSource.stop(RENDER_QUANTUM_FRAMES/sampleRate);
+
+          zeroOutputWorkletNode.port.onmessage = (event) => {
+            // The |capturedBuffer| can be multichannel. Iterate through it.
+            for (let i = 0; i < event.data.capturedBuffer.length; ++i) {
+              let buffer = event.data.capturedBuffer[i];
+              // Split the captured buffer in half for the easier test.
+              should(buffer.subarray(0, RENDER_QUANTUM_FRAMES),
+                     'The first half of the captured buffer')
+                  .beConstantValueOf(sourceOffset);
+              should(buffer.subarray(RENDER_QUANTUM_FRAMES, renderLength),
+                     'The second half of the captured buffer')
+                  .beConstantValueOf(0);
+            }
+            task.done();
+          };
+
+          // Starts the rendering, but we don't need the rendered buffer from
+          // the context.
+          context.startRendering();
+        });
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
+
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-channel-count.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-channel-count.https.html
new file mode 100644
index 0000000000..11c237f19d
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-channel-count.https.html
@@ -0,0 +1,77 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test AudioWorkletNode's dynamic channel count feature
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+    <script src="/webaudio/resources/audit-util.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      // Arbitrary numbers used to align the test with render quantum boundary.
+      let sampleRate = RENDER_QUANTUM_FRAMES * 100;
+      let renderLength = RENDER_QUANTUM_FRAMES * 2;
+      let context;
+
+      let filePath = 'processors/gain-processor.js';
+
+      let testChannelValues = [1, 2, 3];
+
+      // Creates a 3-channel buffer and play with BufferSourceNode. The source
+      // goes through a bypass AudioWorkletNode (gain value of 1).
+      audit.define('setup-buffer-and-worklet', (task, should) => {
+        context = new OfflineAudioContext(testChannelValues.length,
+                                          renderLength,
+                                          sampleRate);
+
+        // Explicitly sets the destination channelCountMode and
+        // channelInterpretation to make sure the result does no mixing.
+        context.channeCountMode = 'explicit';
+        context.channelInterpretation = 'discrete';
+
+        context.audioWorklet.addModule(filePath).then(() => {
+          let testBuffer = createConstantBuffer(context, 1, testChannelValues);
+          let sourceNode = new AudioBufferSourceNode(context);
+          let gainWorkletNode = new AudioWorkletNode(context, 'gain');
+
+          gainWorkletNode.parameters.get('gain').value = 1.0;
+          sourceNode.connect(gainWorkletNode).connect(context.destination);
+
+          // Suspend the context at 128 sample frames and play the source with
+          // the assigned buffer.
+          context.suspend(RENDER_QUANTUM_FRAMES/sampleRate).then(() => {
+            sourceNode.buffer = testBuffer;
+            sourceNode.loop = true;
+            sourceNode.start();
+            context.resume();
+          });
+          task.done();
+        });
+      });
+
+      // Verifies if the rendered buffer has all zero for the first half (before
+      // 128 samples) and the expected values for the second half.
+      audit.define('verify-rendered-buffer', (task, should) => {
+          context.startRendering().then(renderedBuffer => {
+            testChannelValues.forEach((value, index) => {
+              let channelData = renderedBuffer.getChannelData(index);
+              should(channelData.subarray(0, RENDER_QUANTUM_FRAMES),
+                     'First half of Channel #' + index)
+                  .beConstantValueOf(0);
+              should(channelData.subarray(RENDER_QUANTUM_FRAMES, renderLength),
+                     'Second half of Channel #' + index)
+                  .beConstantValueOf(value);
+            });
+            task.done();
+          });
+        });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-construction.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-construction.https.html
new file mode 100644
index 0000000000..8b7704a781
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-construction.https.html
@@ -0,0 +1,53 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test the construction of AudioWorkletNode with real-time context
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      let realtimeContext = new AudioContext();
+
+      let filePath = 'processors/dummy-processor.js';
+
+      // Test if an exception is thrown correctly when AWN constructor is
+      // invoked before resolving |.addModule()| promise.
+      audit.define(
+          {label: 'construction-before-module-loading'},
+          (task, should) => {
+            should(() => new AudioWorkletNode(realtimeContext, 'dummy'),
+                   'Creating a node before loading a module should throw.')
+                .throw(DOMException, 'InvalidStateError');
+
+            task.done();
+          });
+
+      // Test the construction of AudioWorkletNode after the resolution of
+      // |.addModule()|. Also the constructor must throw an exception when
+      // a unregistered node name was given.
+      audit.define(
+          {label: 'construction-after-module-loading'},
+          (task, should) => {
+            realtimeContext.audioWorklet.addModule(filePath).then(() => {
+              let dummyWorkletNode =
+                  new AudioWorkletNode(realtimeContext, 'dummy');
+              should(dummyWorkletNode instanceof AudioWorkletNode,
+                     '"dummyWorkletNode" is an instance of AudioWorkletNode')
+                  .beTrue();
+              should(() => new AudioWorkletNode(realtimeContext, 'foobar'),
+                     'Unregistered name "foobar" must throw an exception.')
+                  .throw();
+              task.done();
+            });
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-constructor-options.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-constructor-options.https.html
new file mode 100644
index 0000000000..d3347d265e
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-constructor-options.https.html
@@ -0,0 +1,149 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test of AudioWorkletNodeOptions
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      const sampleRate = 48000;
+
+      const audit = Audit.createTaskRunner();
+      let context;
+
+      let filePath = 'processors/dummy-processor.js';
+
+      // Load script file and create a OfflineAudiocontext.
+      audit.define('setup', (task, should) => {
+        context = new OfflineAudioContext(1, 1, sampleRate);
+        context.audioWorklet.addModule(filePath).then(() => {
+          task.done();
+        });
+      });
+
+      // Test AudioWorkletNode construction without AudioWorkletNodeOptions.
+      audit.define('without-audio-node-options', (task, should) => {
+        let testNode;
+        should(
+            () => testNode = new AudioWorkletNode(context, 'dummy'),
+            'Creating AudioWOrkletNode without options')
+            .notThrow();
+        should(testNode instanceof AudioWorkletNode,
+               'testNode is instance of AudioWorkletNode').beEqualTo(true);
+        should(testNode.numberOfInputs,
+               'testNode.numberOfInputs (default)').beEqualTo(1);
+        should(testNode.numberOfOutputs,
+               'testNode.numberOfOutputs (default)').beEqualTo(1);
+        should(testNode.channelCount,
+               'testNode.channelCount (default)').beEqualTo(2);
+        should(testNode.channelCountMode,
+               'testNode.channelCountMode (default)').beEqualTo('max');
+        should(testNode.channelInterpretation,
+               'testNode.channelInterpretation (default)')
+            .beEqualTo('speakers');
+        task.done();
+      });
+
+      // Test AudioWorkletNode constructor with AudioNodeOptions.
+      audit.define('audio-node-options', (task, should) => {
+        const options = {
+          numberOfInputs: 7,
+          numberOfOutputs: 18,
+          channelCount: 4,
+          channelCountMode: 'clamped-max',
+          channelInterpretation: 'discrete'
+        };
+        const optionsString = JSON.stringify(options);
+
+        let testNode;
+        should(
+            () => testNode = new AudioWorkletNode(context, 'dummy', options),
+            'Creating AudioWOrkletNode with options: ' + optionsString)
+            .notThrow();
+        should(testNode.numberOfInputs,
+               'testNode.numberOfInputs').beEqualTo(options.numberOfInputs);
+        should(testNode.numberOfOutputs,
+               'testNode.numberOfOutputs').beEqualTo(options.numberOfOutputs);
+        should(testNode.channelCount,
+               'testNode.channelCount').beEqualTo(options.channelCount);
+        should(testNode.channelCountMode,
+               'testNode.channelCountMode').beEqualTo(options.channelCountMode);
+        should(testNode.channelInterpretation,
+               'testNode.channelInterpretation')
+            .beEqualTo(options.channelInterpretation);
+
+        task.done();
+      });
+
+      // Test AudioWorkletNode.channelCount.
+      audit.define('channel-count', (task, should) => {
+        const options1 = {channelCount: 17};
+        let testNode = new AudioWorkletNode(context, 'dummy', options1);
+        should(testNode.channelCount, 'testNode.channelCount')
+            .beEqualTo(options1.channelCount);
+
+        const options2 = {channelCount: 0};
+        should(
+            () => new AudioWorkletNode(context, 'dummy', options2),
+            'Creating AudioWorkletNode with channelCount 0')
+            .throw(DOMException, 'NotSupportedError');
+
+        const options3 = {channelCount: 33};
+        should(
+            () => new AudioWorkletNode(context, 'dummy', options3),
+            'Creating AudioWorkletNode with channelCount 33')
+            .throw(DOMException, 'NotSupportedError');
+
+        task.done();
+      });
+
+      // Test AudioWorkletNode.channelCountMode.
+      audit.define('channel-count-mode', (task, should) => {
+        const channelCountModes = ['max', 'clamped-max', 'explicit'];
+        channelCountModes.forEach((mode) => {
+          const options = {channelCountMode: mode};
+          let testNode = new AudioWorkletNode(context, 'dummy', options);
+          should(testNode.channelCountMode,
+                 'testNode.channelCountMode (set via options.' + mode + ')')
+              .beEqualTo(options.channelCountMode);
+        });
+
+        const options1 = {channelCountMode: 'foobar'};
+        should(
+            () => new AudioWorkletNode(context, 'dummy', options1),
+            'Creating AudioWorkletNode with channelCountMode "foobar"')
+            .throw(TypeError);
+
+        task.done();
+      });
+
+      // Test AudioWorkletNode.channelInterpretation.
+      audit.define('channel-interpretation', (task, should) => {
+        const channelInterpretations = ['speakers', 'discrete'];
+        channelInterpretations.forEach((interpretation) => {
+          const options = {channelInterpretation: interpretation};
+          let testNode = new AudioWorkletNode(context, 'dummy', options);
+          should(
+              testNode.channelInterpretation,
+              'testNode.channelInterpretation (set via options.' +
+                  interpretation + ')')
+              .beEqualTo(options.channelInterpretation);
+        });
+
+        const options1 = {channelInterpretation: 'foobar'};
+        should(
+            () => new AudioWorkletNode(context, 'dummy', options1),
+            'Creating AudioWorkletNode with channelInterpretation "foobar"')
+            .throw(TypeError);
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-disconnected-input.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-disconnected-input.https.html
new file mode 100644
index 0000000000..c58502af01
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-disconnected-input.https.html
@@ -0,0 +1,100 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test AudioWorkletNode's Disconnected Input Array Length
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+    <script src="/webaudio/resources/audit-util.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      // Arbitrary numbers used to align the test with render quantum boundary.
+      // The sample rate is a power of two to eliminate roundoff in computing
+      // the suspend time needed for the test.
+      let sampleRate = 16384;
+      let renderLength = 8 * RENDER_QUANTUM_FRAMES;
+      let context;
+
+      let filePath = 'processors/input-length-processor.js';
+
+      let testChannelValues = [1, 2, 3];
+
+      // Creates a 3-channel buffer and play with BufferSourceNode. The source
+      // goes through a bypass AudioWorkletNode (gain value of 1).
+      audit.define(
+          {
+            label: 'test',
+            description:
+                'Input array length should be zero for disconnected input'
+          },
+          (task, should) => {
+            context = new OfflineAudioContext({
+              numberOfChannels: 1,
+              length: renderLength,
+              sampleRate: sampleRate
+            });
+
+            context.audioWorklet.addModule(filePath).then(() => {
+              let sourceNode = new ConstantSourceNode(context);
+              let workletNode =
+                  new AudioWorkletNode(context, 'input-length-processor');
+
+              workletNode.connect(context.destination);
+
+              // Connect the source now.
+              let connectFrame = RENDER_QUANTUM_FRAMES;
+
+              context.suspend(connectFrame / sampleRate)
+                  .then(() => {
+                    sourceNode.connect(workletNode);
+                  })
+                  .then(() => context.resume());
+              ;
+
+              // Then disconnect the source after a few renders
+              let disconnectFrame = 3 * RENDER_QUANTUM_FRAMES;
+              context.suspend(disconnectFrame / sampleRate)
+                  .then(() => {
+                    sourceNode.disconnect(workletNode);
+                  })
+                  .then(() => context.resume());
+
+              sourceNode.start();
+              context.startRendering()
+                  .then(resultBuffer => {
+                    let data = resultBuffer.getChannelData(0);
+
+                    should(
+                        data.slice(0, connectFrame),
+                        'Before connecting the source: Input array length')
+                        .beConstantValueOf(0);
+
+                    // Find where the output is no longer 0.
+                    let nonZeroIndex = data.findIndex(x => x > 0);
+                    should(nonZeroIndex, 'First non-zero output')
+                        .beEqualTo(connectFrame);
+
+                    should(
+                        data.slice(
+                            nonZeroIndex,
+                            nonZeroIndex + (disconnectFrame - connectFrame)),
+                        'While source is connected: Input array length')
+                        .beConstantValueOf(RENDER_QUANTUM_FRAMES);
+                    should(
+                        data.slice(disconnectFrame),
+                        'After disconnecting the source: Input array length')
+                        .beConstantValueOf(0);
+                  })
+                  .then(() => task.done());
+            });
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-onerror.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-onerror.https.html
new file mode 100644
index 0000000000..95126a8c86
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-onerror.https.html
@@ -0,0 +1,58 @@
+<!DOCTYPE html>
+<title>Test onprocessorerror handler in AudioWorkletNode</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+let context = null;
+
+promise_setup(async () => {
+  const sampleRate = 48000;
+  const renderLength = sampleRate * 0.1;
+  context = new OfflineAudioContext(1, renderLength, sampleRate);
+
+  // Loads all processor definitions that are necessary for tests in this file.
+  await context.audioWorklet.addModule('./processors/error-processor.js');
+});
+
+promise_test(async () => {
+  const constructorErrorWorkletNode =
+      new AudioWorkletNode(context, 'constructor-error');
+  let error = await new Promise(resolve => {
+    constructorErrorWorkletNode.onprocessorerror = (e) => resolve(e);
+  });
+  assert_true(error instanceof ErrorEvent,
+      'onprocessorerror argument should be an ErrorEvent when ' +
+      'the constructor of AudioWorkletProcessor has an error.');
+}, 'Test if |onprocessorerror| is called for an exception thrown from the ' +
+    'processor constructor.');
+
+promise_test(async () => {
+  // An arbitrary Blob for testing. This is not deserializable on
+  // AudioWorkletGlobalScope.
+  const blob = new Blob([JSON.stringify({ hello: "world"}, null, 2)], {
+    type: "application/json",
+  });
+  const emptyErrorWorkletNode =
+      new AudioWorkletNode(context, 'empty-error', {processorOptions: {blob}});
+  let error = await new Promise(resolve => {
+    emptyErrorWorkletNode.onprocessorerror = (e) => resolve(e);
+  });
+  assert_true(error instanceof ErrorEvent,
+      'onprocessorerror argument should be an ErrorEvent when ' +
+      'the constructor of AudioWorkletProcessor has an error.');
+}, 'Test if |onprocessorerror| is called for a transfered object that cannot ' +
+   'be deserialized on the AudioWorkletGlobalScope.');
+
+promise_test(async () => {
+  const processErrorWorkletNode =
+      new AudioWorkletNode(context, 'process-error');
+  let error = await new Promise(resolve => {
+    processErrorWorkletNode.onprocessorerror = (e) => resolve(e);
+    // Need to start render to cause an exception in process().
+    context.startRendering();
+  });
+  assert_true(error instanceof ErrorEvent,
+      'onprocessorerror argument should be an ErrorEvent when the ' +
+      'process method of the AudioWorkletProcessor has an error.');
+}, 'Test if |onprocessorerror| is called upon failure of process() method.');
+</script>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-output-channel-count.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-output-channel-count.https.html
new file mode 100644
index 0000000000..8dafa2f811
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletnode-output-channel-count.https.html
@@ -0,0 +1,80 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test the construction of AudioWorkletNode with real-time context
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      const audit = Audit.createTaskRunner();
+      const context = new AudioContext();
+
+      setup(function () {
+        context.audioWorklet.addModule(
+          'processors/channel-count-processor.js').then(() => audit.run());
+
+        // Test if the output channe count dynamically changes if the input
+        // and output is 1.
+        audit.define(
+            {label: 'Dynamically change the channel count to if unspecified.'},
+            (task, should) => {
+              // Use arbitrary parameters for the test.
+              const buffer = new AudioBuffer({
+                numberOfChannels: 17,
+                length: 1,
+                sampleRate: context.sampleRate,
+              });
+              const source = new AudioBufferSourceNode(context);
+              source.buffer = buffer;
+
+              const node = new AudioWorkletNode(context, 'channel-count', {
+                numberOfInputs: 1,
+                numberOfOutputs: 1,
+              });
+
+              node.port.onmessage = (message) => {
+                const expected = message.data;
+                should(expected.outputChannel,
+                       'The expected output channel count').beEqualTo(17);
+                task.done();
+              };
+
+              // We need to make an actual connection becasue the channel count
+              // change happen when the rendering starts. It is to test if the
+              // channel count adapts to the upstream node correctly.
+              source.connect(node).connect(context.destination);
+              source.start();
+            });
+
+        // Test if outputChannelCount is honored as expected even if the input
+        // and output is 1.
+        audit.define(
+            {label: 'Givien outputChannelCount must be honored.'},
+            (task, should) => {
+              const node = new AudioWorkletNode(
+                  context, 'channel-count', {
+                    numberOfInputs: 1,
+                    numberOfOutputs: 1,
+                    outputChannelCount: [2],
+                  });
+
+              node.port.onmessage = (message) => {
+                const expected = message.data;
+                should(expected.outputChannel,
+                       'The expected output channel count').beEqualTo(2);
+                task.done();
+              };
+
+              // We need to make an actual connection becasue the channel count
+              // change might happen when the rendering starts. It is to test
+              // if the specified channel count is kept correctly.
+              node.connect(context.destination);
+            });
+      });
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletprocessor-options.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletprocessor-options.https.html
new file mode 100644
index 0000000000..ea840ed11a
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletprocessor-options.https.html
@@ -0,0 +1,77 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test cross-thread passing of AudioWorkletNodeOptions
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      const audit = Audit.createTaskRunner();
+      const context = new AudioContext();
+
+      let filePath = 'processors/option-test-processor.js';
+
+      // Create a OptionTestProcessor and feed |processorData| to it. The
+      // processor should echo the received data to the node's |onmessage|
+      // handler.
+      audit.define('valid-processor-data', (task, should) => {
+        context.audioWorklet.addModule(filePath).then(() => {
+          let processorOptions = {
+            description: 'foo',
+            payload: [0, 1, 2, 3]
+          };
+
+          let optionTestNode =
+              new AudioWorkletNode(context, 'option-test-processor', {
+                processorOptions: processorOptions
+              });
+
+          optionTestNode.port.onmessage = (event) => {
+            should(event.data.processorOptions.description,
+                   '|description| field in processorOptions from processor("' +
+                       event.data.processorOptions.description + '")')
+                .beEqualTo(processorOptions.description,
+                           'the field in node constructor options ("' +
+                           processorOptions.description + '")');
+            should(event.data.processorOptions.payload,
+                   '|payload| array in processorOptions from processor([' +
+                       event.data.processorOptions.payload + '])')
+                .beEqualToArray([0, 1, 2, 3],
+                                'the array in node constructor options ([' +
+                                event.data.processorOptions.payload + '])');
+            task.done();
+          };
+        });
+      });
+
+
+      // Passing empty option dictionary should work without a problem.
+      audit.define('empty-option', (task, should) => {
+        context.audioWorklet.addModule(filePath).then(() => {
+          let optionTestNode =
+              new AudioWorkletNode(context, 'option-test-processor');
+
+          optionTestNode.port.onmessage = (event) => {
+            should(Object.keys(event.data).length,
+                   'Number of properties in data from processor')
+                .beEqualTo(2);
+            should(event.data.numberOfInputs,
+                   '|numberOfInputs| field in data from processor')
+                .beEqualTo(1);
+            should(event.data.numberOfOutputs,
+                   '|numberOfOutputs| field in data from processor')
+                .beEqualToArray(1);
+            task.done();
+          };
+        });
+      });
+
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletprocessor-param-getter-overridden.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletprocessor-param-getter-overridden.https.html
new file mode 100644
index 0000000000..e3fb6e533d
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletprocessor-param-getter-overridden.https.html
@@ -0,0 +1,59 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test if AudioWorkletProcessor with invalid parameters array getter
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      // Arbitrarily determined. Any numbers should work.
+      let sampleRate = 16000;
+      let renderLength = 1280;
+      let context;
+      let filePath = 'processors/invalid-param-array-processor.js';
+
+      audit.define('Initializing AudioWorklet and Context', async (task) => {
+        context = new OfflineAudioContext(1, renderLength, sampleRate);
+        await context.audioWorklet.addModule(filePath);
+        task.done();
+      });
+
+      audit.define('Verifying AudioParam in AudioWorkletNode',
+          async (task, should) => {
+            let buffer = context.createBuffer(1, 2, context.sampleRate);
+            buffer.getChannelData(0)[0] = 1;
+
+            let source = new AudioBufferSourceNode(context);
+            source.buffer = buffer;
+            source.loop = true;
+            source.start();
+
+            let workletNode1 =
+                new AudioWorkletNode(context, 'invalid-param-array-1');
+            let workletNode2 =
+                new AudioWorkletNode(context, 'invalid-param-array-2');
+            workletNode1.connect(workletNode2).connect(context.destination);
+
+            // Manually invoke the param getter.
+            source.connect(workletNode2.parameters.get('invalidParam'));
+
+            const renderedBuffer = await context.startRendering();
+
+            // |workletNode2| should be no-op after the parameter getter is
+            // invoked. Therefore, the rendered result should be silent.
+            should(renderedBuffer.getChannelData(0), 'The rendered buffer')
+                .beConstantValueOf(0);
+            task.done();
+          }
+      );
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletprocessor-process-frozen-array.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletprocessor-process-frozen-array.https.html
new file mode 100644
index 0000000000..33627204a6
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletprocessor-process-frozen-array.https.html
@@ -0,0 +1,53 @@
+<!doctype html>
+<html>
+  <head>
+    <title>
+      Test given arrays within AudioWorkletProcessor.process() method
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+  </head>
+
+  <body>
+    <script>
+      const audit = Audit.createTaskRunner();
+      const filePath = 'processors/array-check-processor.js';
+      const context = new AudioContext();
+
+      // Test if the incoming arrays are frozen as expected.
+      audit.define('check-frozen-array', (task, should) => {
+        context.audioWorklet.addModule(filePath).then(() => {
+          const workletNode =
+              new AudioWorkletNode(context, 'array-frozen-processor');
+          workletNode.port.onmessage = (message) => {
+            const actual = message.data;
+            should(actual.isInputFrozen, '|inputs| is frozen').beTrue();
+            should(actual.isOutputFrozen, '|outputs| is frozen').beTrue();
+            task.done();
+          };
+        });
+      });
+
+      // The incoming arrays should not be transferred, but the associated
+      // ArrayBuffers can be transferred. See the `array-transfer-processor`
+      // definition for the details.
+      audit.define('transfer-frozen-array', (task, should) => {
+        const sourceNode = new ConstantSourceNode(context);
+        const workletNode =
+            new AudioWorkletNode(context, 'array-transfer-processor');
+        workletNode.port.onmessage = (message) => {
+          const actual = message.data;
+          if (actual.type === 'assertion')
+            should(actual.success, actual.message).beTrue();
+          if (actual.done)
+            task.done();
+        };
+        sourceNode.connect(workletNode);
+        sourceNode.start();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletprocessor-process-zero-outputs.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletprocessor-process-zero-outputs.https.html
new file mode 100644
index 0000000000..e1c19f0d75
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletprocessor-process-zero-outputs.https.html
@@ -0,0 +1,36 @@
+<!doctype html>
+<html>
+  <head>
+    <title>
+      Test if |outputs| argument is all zero in AudioWorkletProcessor.process()
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+  </head>
+
+  <body>
+    <script>
+      const audit = Audit.createTaskRunner();
+      const filePath = 'processors/zero-outputs-check-processor.js';
+      const context = new AudioContext();
+
+      // Test if the incoming arrays are frozen as expected.
+      audit.define('check-zero-outputs', (task, should) => {
+        context.audioWorklet.addModule(filePath).then(() => {
+          const workletNode =
+              new AudioWorkletNode(context, 'zero-outputs-check-processor');
+          workletNode.port.onmessage = (message) => {
+            const actual = message.data;
+            if (actual.type === 'assertion') {
+              should(actual.success, actual.message).beTrue();
+              task.done();
+            }
+          };
+        });
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletprocessor-promises.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletprocessor-promises.https.html
new file mode 100644
index 0000000000..079b57b959
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/audioworkletprocessor-promises.https.html
@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test micro task checkpoints in AudioWorkletGlobalScope
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+    <meta charset=utf-8>
+  </head>
+  <body>
+    <script id="layout-test-code">
+        promise_test(async () => {
+          const context = new AudioContext();
+
+          let filePath = 'processors/promise-processor.js';
+
+          await context.audioWorklet.addModule(filePath);
+          await context.suspend();
+          let node1 = new AudioWorkletNode(context, 'promise-processor');
+          let node2 = new AudioWorkletNode(context, 'promise-processor');
+
+          // Connecting to the destination is not strictly necessary in theory,
+          // but see
+          // https://bugs.chromium.org/p/chromium/issues/detail?id=1045926
+          // for why it is in practice.
+          node1.connect(node2).connect(context.destination);
+
+          await context.resume();
+
+          // The second node is the one that is going to receive the message,
+          // per spec: it is the second that will be processed, each time.
+          const e = await new Promise((resolve) => {
+            node2.port.onmessage = resolve;
+          });
+          context.close();
+          assert_equals(e.data, "ok",
+                      `Microtask checkpoints are performed
+                       in between render quantum`);
+        }, "test");
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/baseaudiocontext-audioworklet.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/baseaudiocontext-audioworklet.https.html
new file mode 100644
index 0000000000..4281f56379
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/baseaudiocontext-audioworklet.https.html
@@ -0,0 +1,30 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Checking BaseAudioContext.audioWorklet
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      let realtimeContext = new AudioContext();
+      let offlineContext = new OfflineAudioContext(1, 1, 44100);
+
+      // Test if AudioWorklet exists.
+      audit.define('Test if AudioWorklet exists', (task, should) => {
+        should(realtimeContext.audioWorklet instanceof AudioWorklet &&
+               offlineContext.audioWorklet instanceof AudioWorklet,
+               'BaseAudioContext.audioWorklet is an instance of AudioWorklet')
+            .beTrue();
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/extended-audioworkletnode-with-parameters.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/extended-audioworkletnode-with-parameters.https.html
new file mode 100644
index 0000000000..75f4aa4020
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/extended-audioworkletnode-with-parameters.https.html
@@ -0,0 +1,16 @@
+<!doctype html>
+<title>Test AudioWorkletNode subclass with parameters</title>
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script>
+class Extended extends AudioWorkletNode {}
+
+const modulePath = 'processors/gain-processor.js';
+
+promise_test(async () => {
+  const context = new AudioContext();
+  await context.audioWorklet.addModule(modulePath);
+  const node = new Extended(context, 'gain');
+  assert_equals(Object.getPrototypeOf(node), Extended.prototype);
+});
+</script>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/process-getter.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/process-getter.https.html
new file mode 100644
index 0000000000..a4c59123a1
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/process-getter.https.html
@@ -0,0 +1,23 @@
+<!doctype html>
+<title>Test use of 'process' getter for AudioWorkletProcessor callback</title>
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script>
+const do_test = async (node_name) => {
+  const context = new AudioContext();
+  const filePath = `processors/${node_name}-processor.js`;
+  await context.audioWorklet.addModule(filePath);
+  const node = new AudioWorkletNode(context, node_name);
+  const event = await new Promise((resolve) => {
+    node.port.onmessage = resolve;
+  });
+  assert_equals(event.data.message, "done");
+};
+
+// Includes testing for https://github.com/WebAudio/web-audio-api/pull/2104
+promise_test(async () => do_test('process-getter-test-prototype'),
+             "'process' getter on prototype");
+
+promise_test(async () => do_test('process-getter-test-instance'),
+             "'process' getter on instance");
+</script>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/process-parameters.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/process-parameters.https.html
new file mode 100644
index 0000000000..4c6a10dfab
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/process-parameters.https.html
@@ -0,0 +1,87 @@
+<!doctype html>
+<title>Test parameters of process() AudioWorkletProcessor callback</title>
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script>
+var context;
+promise_setup(async (t) => {
+  context = new AudioContext();
+  const filePath = 'processors/process-parameter-test-processor.js';
+  await context.audioWorklet.addModule(filePath);
+});
+
+const get_parameters = async (node, options) => {
+  const event = await new Promise((resolve) => {
+    node.port.onmessage = resolve;
+  });
+  const inputs = event.data.inputs;
+  assert_equals(inputs.length, options.numberOfInputs, 'inputs length');
+  const outputs = event.data.outputs;
+  assert_equals(outputs.length, options.numberOfOutputs, 'outputs length');
+  for (let port = 0; port < inputs.length; ++port) {
+    for (let channel = 0; channel < inputs[port].length; ++channel) {
+      assert_equals(inputs[port][channel].length, 128,
+                    `inputs[${port}][${channel}].length`);
+    }
+  }
+  for (let port = 0; port < outputs.length; ++port) {
+    for (let channel = 0; channel < outputs[port].length; ++channel) {
+      assert_equals(outputs[port][channel].length, 128,
+                    `outputs[${port}][${channel}].length`);
+    }
+  }
+  return event.data;
+};
+
+promise_test(async (t) => {
+  const options = {
+    numberOfInputs: 3,
+    numberOfOutputs: 0
+  };
+  // Connect a source so that one channel of one input is active.
+  context.suspend();
+  const source = new ConstantSourceNode(context);
+  source.start();
+  const merger = new ChannelMergerNode(context, {numberOfInputs: 2});
+  const active_channel_index = merger.numberOfInputs - 1;
+  source.connect(merger, 0, active_channel_index);
+  const node = new AudioWorkletNode(context, 'process-parameter-test', options);
+  const active_port_index = options.numberOfInputs - 1;
+  merger.connect(node, 0, active_port_index);
+  context.resume();
+  const {inputs} = await get_parameters(node, options);
+  for (let port = 0; port < inputs.length - 1; ++port) {
+    if (port != active_port_index) {
+      assert_equals(inputs[port].length, 0, `inputs[${port}].length`);
+    }
+  }
+  const active_input = inputs[active_port_index];
+  assert_equals(active_input.length, merger.numberOfInputs,
+                'active_input.length');
+  for (let channel = 0; channel < active_input.length; ++channel) {
+    let expected = channel == active_channel_index ? 1.0 : 0.0;
+    for (let sample = 0; sample < inputs.length; ++sample) {
+      assert_equals(active_input[channel][sample], expected,
+                    `active_input[${channel}][${sample}]`);
+    }
+  }
+}, '3 inputs; 0 outputs');
+
+promise_test(async (t) => {
+  const options = {
+    numberOfInputs: 0,
+    numberOfOutputs: 3
+  };
+  const node = new AudioWorkletNode(context, 'process-parameter-test', options);
+  const {outputs} = await get_parameters(node, options);
+  for (let port = 0; port < outputs.length; ++port) {
+    assert_equals(outputs[port].length, 1, `outputs[${port}].length`);
+    for (let channel = 0; channel < outputs[port].length; ++channel) {
+      for (let sample = 0; sample < outputs.length; ++sample) {
+        assert_equals(outputs[port][channel][sample], 0.0,
+                      `outputs[${port}][${channel}][${sample}]`);
+      }
+    }
+  }
+}, '0 inputs; 3 outputs');
+</script>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processor-construction-port.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processor-construction-port.https.html
new file mode 100644
index 0000000000..6f1aa59225
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processor-construction-port.https.html
@@ -0,0 +1,61 @@
+<!doctype html>
+<title>Test processor port assignment on processor callback function construction</title>
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script>
+// https://webaudio.github.io/web-audio-api/#AudioWorkletProcessor-instantiation
+
+const get_context_for_node_name = async (node_name) => {
+  const context = new AudioContext();
+  const filePath = `processors/construction-port-${node_name}.js`;
+  await context.audioWorklet.addModule(filePath);
+  return context;
+}
+
+const test_throws = async ({node_name, thrower} = {}) => {
+  const context = await get_context_for_node_name(node_name);
+  const node = new AudioWorkletNode(context, node_name);
+  const event = await new Promise((resolve) => {
+    node.port.onmessage = resolve;
+  });
+  assert_true(event.data.threw, `${thrower} should throw`);
+  assert_equals(event.data.errorName, "TypeError");
+  assert_true(event.data.isTypeError, "exception should be TypeError");
+};
+
+const throw_tests = [
+  {
+    test_name: 'super() after new AudioWorkletProcessor()',
+    node_name: 'super-after-new',
+    thrower: 'super()'
+  },
+  {
+    test_name: 'new AudioWorkletProcessor() after super()',
+    node_name: 'new-after-super',
+    thrower: 'new AudioWorkletProcessor()'
+  },
+  {
+    test_name: 'new AudioWorkletProcessor() after new AudioWorkletProcessor()',
+    node_name: 'new-after-new',
+    thrower: 'new AudioWorkletProcessor()'
+  }
+];
+for (const test_info of throw_tests) {
+  promise_test(async () => test_throws(test_info), test_info.test_name);
+}
+
+promise_test(async (t) => {
+  const node_name = 'singleton';
+  const context = await get_context_for_node_name(node_name);
+  const node1 = new AudioWorkletNode(context, node_name);
+  const node2 = new AudioWorkletNode(context, node_name);
+  node2.onmessage = t.unreached_func("node2 should not receive a message");
+  let count = 0;
+  await new Promise((resolve) => {
+    node1.port.onmessage = t.step_func((event) => {
+      assert_less_than(count, 2, "message count");
+      if (++count == 2) { resolve(); };
+    });
+  });
+}, 'Singleton AudioWorkletProcessor');
+</script>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/active-processing.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/active-processing.js
new file mode 100644
index 0000000000..ef497733ca
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/active-processing.js
@@ -0,0 +1,54 @@
+/**
+ * @class ActiveProcessingTester
+ * @extends AudioWorkletProcessor
+ *
+ * This processor class sends a message to its AudioWorkletNodew whenever the
+ * number of channels on the input changes.  The message includes the actual
+ * number of channels, the context time at which this occurred, and whether
+ * we're done processing or not.
+ */
+class ActiveProcessingTester extends AudioWorkletProcessor {
+  constructor(options) {
+    super(options);
+    this._lastChannelCount = 0;
+
+    // See if user specified a value for test duration.
+    if (options.hasOwnProperty('processorOptions') &&
+        options.processorOptions.hasOwnProperty('testDuration')) {
+      this._testDuration = options.processorOptions.testDuration;
+    } else {
+      this._testDuration = 5;
+    }
+
+    // Time at which we'll signal we're done, based on the requested
+    // |testDuration|
+    this._endTime = currentTime + this._testDuration;
+  }
+
+  process(inputs, outputs) {
+    const input = inputs[0];
+    const output = outputs[0];
+    const inputChannelCount = input.length;
+    const isFinished = currentTime > this._endTime;
+
+    // Send a message if we're done or the count changed.
+    if (isFinished || (inputChannelCount != this._lastChannelCount)) {
+      this.port.postMessage({
+        channelCount: inputChannelCount,
+        finished: isFinished,
+        time: currentTime
+      });
+      this._lastChannelCount = inputChannelCount;
+    }
+
+    // Just copy the input to the output for no particular reason.
+    for (let channel = 0; channel < input.length; ++channel) {
+      output[channel].set(input[channel]);
+    }
+
+    // When we're finished, this method no longer needs to be called.
+    return !isFinished;
+  }
+}
+
+registerProcessor('active-processing-tester', ActiveProcessingTester);
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/add-offset.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/add-offset.js
new file mode 100644
index 0000000000..d05056bd84
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/add-offset.js
@@ -0,0 +1,34 @@
+/*
+ * @class AddOffsetProcessor
+ * @extends AudioWorkletProcessor
+ *
+ * Just adds a fixed value to the input
+ */
+class AddOffsetProcessor extends AudioWorkletProcessor {
+  constructor(options) {
+    super();
+
+    this._offset = options.processorOptions.offset;
+  }
+
+  process(inputs, outputs) {
+    // This processor assumes the node has at least 1 input and 1 output.
+    let input = inputs[0];
+    let output = outputs[0];
+    let outputChannel = output[0];
+
+    if (input.length > 0) {
+      let inputChannel = input[0];
+      for (let k = 0; k < outputChannel.length; ++k)
+        outputChannel[k] = inputChannel[k] + this._offset;
+    } else {
+      // No input connected, so pretend it's silence and just fill the
+      // output with the offset value.
+      outputChannel.fill(this._offset);
+    }
+
+    return true;
+  }
+}
+
+registerProcessor('add-offset-processor', AddOffsetProcessor);
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/array-check-processor.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/array-check-processor.js
new file mode 100644
index 0000000000..d6eeff3d15
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/array-check-processor.js
@@ -0,0 +1,94 @@
+/**
+ * @class ArrayFrozenProcessor
+ * @extends AudioWorkletProcessor
+ */
+class ArrayFrozenProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this._messageSent = false;
+  }
+
+  process(inputs, outputs, parameters) {
+    const input = inputs[0];
+    const output = outputs[0];
+
+    if (!this._messageSent) {
+      this.port.postMessage({
+        inputLength: input.length,
+        isInputFrozen: Object.isFrozen(inputs) && Object.isFrozen(input),
+        outputLength: output.length,
+        isOutputFrozen: Object.isFrozen(outputs) && Object.isFrozen(output)
+      });
+      this._messageSent = true;
+    }
+
+    return false;
+  }
+}
+
+/**
+ * @class ArrayTransferProcessor
+ * @extends AudioWorkletProcessor
+ */
+class ArrayTransferProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this._messageSent = false;
+  }
+
+  process(inputs, outputs, parameters) {
+    const input = inputs[0];
+    const output = outputs[0];
+
+    if (!this._messageSent) {
+      try {
+        // Transferring Array objects should NOT work.
+        this.port.postMessage({
+          inputs, input, inputChannel: input[0],
+          outputs, output, outputChannel: output[0]
+        }, [inputs, input, inputs[0], outputs, output, output[0]]);
+        // Hence, the following must NOT be reached.
+        this.port.postMessage({
+          type: 'assertion',
+          success: false,
+          message: 'Transferring inputs/outputs, an individual input/output ' +
+              'array, or a channel Float32Array MUST fail, but succeeded.'
+        });
+      } catch (error) {
+        this.port.postMessage({
+          type: 'assertion',
+          success: true,
+          message: 'Transferring inputs/outputs, an individual input/output ' +
+              'array, or a channel Float32Array is not allowed as expected.'
+        });
+      }
+
+      try {
+        // Transferring ArrayBuffers should work.
+        this.port.postMessage(
+          {inputChannel: input[0], outputChannel: output[0]},
+          [input[0].buffer, output[0].buffer]);
+        this.port.postMessage({
+          type: 'assertion',
+          success: true,
+          message: 'Transferring ArrayBuffers was successful as expected.'
+        });
+      } catch (error) {
+        // This must NOT be reached.
+        this.port.postMessage({
+          type: 'assertion',
+          success: false,
+          message: 'Transferring ArrayBuffers unexpectedly failed.'
+        });
+      }
+
+      this.port.postMessage({done: true});
+      this._messageSent = true;
+    }
+
+    return false;
+  }
+}
+
+registerProcessor('array-frozen-processor', ArrayFrozenProcessor);
+registerProcessor('array-transfer-processor', ArrayTransferProcessor);
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/channel-count-processor.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/channel-count-processor.js
new file mode 100644
index 0000000000..556459f46b
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/channel-count-processor.js
@@ -0,0 +1,19 @@
+/**
+ * @class ChannelCountProcessor
+ * @extends AudioWorkletProcessor
+ */
+class ChannelCountProcessor extends AudioWorkletProcessor {
+  constructor(options) {
+    super(options);
+  }
+
+  process(inputs, outputs) {
+    this.port.postMessage({
+      inputChannel: inputs[0].length,
+      outputChannel: outputs[0].length
+    });
+    return false;
+  }
+}
+
+registerProcessor('channel-count', ChannelCountProcessor);
\ No newline at end of file
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/construction-port-new-after-new.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/construction-port-new-after-new.js
new file mode 100644
index 0000000000..d4c63f7775
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/construction-port-new-after-new.js
@@ -0,0 +1,16 @@
+class NewAfterNew extends AudioWorkletProcessor {
+  constructor() {
+    const processor = new AudioWorkletProcessor()
+    let message = {threw: false};
+    try {
+      new AudioWorkletProcessor();
+    } catch (e) {
+      message.threw = true;
+      message.errorName = e.name;
+      message.isTypeError = e instanceof TypeError;
+    }
+    processor.port.postMessage(message);
+    return processor;
+  }
+}
+registerProcessor("new-after-new", NewAfterNew);
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/construction-port-new-after-super.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/construction-port-new-after-super.js
new file mode 100644
index 0000000000..a6d4f0e2e8
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/construction-port-new-after-super.js
@@ -0,0 +1,15 @@
+class NewAfterSuper extends AudioWorkletProcessor {
+  constructor() {
+    super()
+    let message = {threw: false};
+    try {
+      new AudioWorkletProcessor()
+    } catch (e) {
+      message.threw = true;
+      message.errorName = e.name;
+      message.isTypeError = e instanceof TypeError;
+    }
+    this.port.postMessage(message);
+  }
+}
+registerProcessor("new-after-super", NewAfterSuper);
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/construction-port-singleton.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/construction-port-singleton.js
new file mode 100644
index 0000000000..c40b5a7179
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/construction-port-singleton.js
@@ -0,0 +1,16 @@
+let singleton;
+class Singleton extends AudioWorkletProcessor {
+  constructor() {
+    if (!singleton) {
+      singleton = new AudioWorkletProcessor();
+      singleton.process = function() {
+        this.port.postMessage({message: "process called"});
+        // This function will be called at most once for each AudioWorkletNode
+        // if the node has no input connections.
+        return false;
+      }
+    }
+    return singleton;
+  }
+}
+registerProcessor("singleton", Singleton);
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/construction-port-super-after-new.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/construction-port-super-after-new.js
new file mode 100644
index 0000000000..e447830c5f
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/construction-port-super-after-new.js
@@ -0,0 +1,16 @@
+class SuperAfterNew extends AudioWorkletProcessor {
+  constructor() {
+    const processor = new AudioWorkletProcessor()
+    let message = {threw: false};
+    try {
+      super();
+    } catch (e) {
+      message.threw = true;
+      message.errorName = e.name;
+      message.isTypeError = e instanceof TypeError;
+    }
+    processor.port.postMessage(message);
+    return processor;
+  }
+}
+registerProcessor("super-after-new", SuperAfterNew);
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/dummy-processor-globalthis.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/dummy-processor-globalthis.js
new file mode 100644
index 0000000000..d1b16cc9aa
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/dummy-processor-globalthis.js
@@ -0,0 +1,12 @@
+class DummyProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+  }
+
+  process(inputs, outputs, parameters) {
+    // Doesn't do anything here.
+    return true;
+  }
+}
+
+globalThis.registerProcessor('dummy-globalthis', DummyProcessor);
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/dummy-processor.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/dummy-processor.js
new file mode 100644
index 0000000000..11155d508c
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/dummy-processor.js
@@ -0,0 +1,18 @@
+/**
+ * @class DummyProcessor
+ * @extends AudioWorkletProcessor
+ *
+ * This processor class demonstrates the bare-bone structure of the processor.
+ */
+class DummyProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+  }
+
+  process(inputs, outputs, parameters) {
+    // Doesn't do anything here.
+    return true;
+  }
+}
+
+registerProcessor('dummy', DummyProcessor);
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/dynamic-register-processor.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/dynamic-register-processor.js
new file mode 100644
index 0000000000..5e825aebb4
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/dynamic-register-processor.js
@@ -0,0 +1,22 @@
+class ProcessorA extends AudioWorkletProcessor {
+  process() {
+    return true;
+  }
+}
+
+// ProcessorB registers ProcessorA upon the construction.
+class ProcessorB extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.port.onmessage = () => {
+      registerProcessor('ProcessorA', ProcessorA);
+      this.port.postMessage({});
+    };
+  }
+
+  process() {
+    return true;
+  }
+}
+
+registerProcessor('ProcessorB', ProcessorB);
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/error-processor.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/error-processor.js
new file mode 100644
index 0000000000..66ff5e2e25
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/error-processor.js
@@ -0,0 +1,40 @@
+/**
+ * @class ConstructorErrorProcessor
+ * @extends AudioWorkletProcessor
+ */
+class ConstructorErrorProcessor extends AudioWorkletProcessor {
+  constructor() {
+    throw 'ConstructorErrorProcessor: an error thrown from constructor.';
+  }
+
+  process() {
+    return true;
+  }
+}
+
+
+/**
+ * @class ProcessErrorProcessor
+ * @extends AudioWorkletProcessor
+ */
+class ProcessErrorProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+  }
+
+  process() {
+    throw 'ProcessErrorProcessor: an error throw from process method.';
+    return true;
+  }
+}
+
+
+/**
+ * @class EmptyErrorProcessor
+ * @extends AudioWorkletProcessor
+ */
+class EmptyErrorProcessor extends AudioWorkletProcessor { process() {} }
+
+registerProcessor('constructor-error', ConstructorErrorProcessor);
+registerProcessor('process-error', ProcessErrorProcessor);
+registerProcessor('empty-error', EmptyErrorProcessor);
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/gain-processor.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/gain-processor.js
new file mode 100644
index 0000000000..e9e130e374
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/gain-processor.js
@@ -0,0 +1,38 @@
+/**
+ * @class GainProcessor
+ * @extends AudioWorkletProcessor
+ *
+ * This processor class demonstrates the bare-bone structure of the processor.
+ */
+class GainProcessor extends AudioWorkletProcessor {
+  static get parameterDescriptors() {
+    return [
+      {name: 'gain', defaultValue: 0.707}
+    ];
+  }
+
+  constructor() {
+    super();
+  }
+
+  process(inputs, outputs, parameters) {
+    let input = inputs[0];
+    let output = outputs[0];
+    let gain = parameters.gain;
+    for (let channel = 0; channel < input.length; ++channel) {
+      let inputChannel = input[channel];
+      let outputChannel = output[channel];
+      if (gain.length === 1) {
+        for (let i = 0; i < inputChannel.length; ++i)
+          outputChannel[i] = inputChannel[i] * gain[0];
+      } else {
+        for (let i = 0; i < inputChannel.length; ++i)
+          outputChannel[i] = inputChannel[i] * gain[i];
+      }
+    }
+
+    return true;
+  }
+}
+
+registerProcessor('gain', GainProcessor);
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/input-count-processor.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/input-count-processor.js
new file mode 100644
index 0000000000..6d53ba84c7
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/input-count-processor.js
@@ -0,0 +1,22 @@
+/**
+ * @class CountProcessor
+ * @extends AudioWorkletProcessor
+ *
+ * This processor class just looks at the number of input channels on the first
+ * input and fills the first output channel with that value.
+ */
+class CountProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+  }
+
+  process(inputs, outputs, parameters) {
+    let input = inputs[0];
+    let output = outputs[0];
+    output[0].fill(input.length);
+
+    return true;
+  }
+}
+
+registerProcessor('counter', CountProcessor);
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/input-length-processor.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/input-length-processor.js
new file mode 100644
index 0000000000..be485f03e8
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/input-length-processor.js
@@ -0,0 +1,27 @@
+/**
+ * @class InputLengthProcessor
+ * @extends AudioWorkletProcessor
+ *
+ * This processor class just sets the output to the length of the
+ * input array for verifying that the input length changes when the
+ * input is disconnected.
+ */
+class InputLengthProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+  }
+
+  process(inputs, outputs, parameters) {
+    let input = inputs[0];
+    let output = outputs[0];
+
+    // Set output channel to the length of the input channel array.
+    // If the input is unconnected, set the value to zero.
+    const fillValue = input.length > 0 ? input[0].length : 0;
+    output[0].fill(fillValue);
+
+    return true;
+  }
+}
+
+registerProcessor('input-length-processor', InputLengthProcessor);
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/invalid-param-array-processor.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/invalid-param-array-processor.js
new file mode 100644
index 0000000000..e4a5dc39ba
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/invalid-param-array-processor.js
@@ -0,0 +1,47 @@
+/**
+ * @class InvalidParamArrayProcessor
+ * @extends AudioWorkletProcessor
+ *
+ * This processor intentionally returns an array with an invalid size when the
+ * processor's getter is queried.
+ */
+let singleton = undefined;
+let secondFetch = false;
+let useDescriptor = false;
+let processCounter = 0;
+
+class InvalidParamArrayProcessor extends AudioWorkletProcessor {
+  static get parameterDescriptors() {
+    if (useDescriptor)
+      return [{name: 'invalidParam'}];
+    useDescriptor = true;
+    return [];
+  }
+
+  constructor() {
+    super();
+    if (singleton === undefined)
+      singleton = this;
+    return singleton;
+  }
+
+  process(inputs, outputs, parameters) {
+    const output = outputs[0];
+    for (let channel = 0; channel < output.length; ++channel)
+      output[channel].fill(1);
+    return false;
+  }
+}
+
+// This overridden getter is invoked under the hood before process() gets
+// called. After this gets called, process() method above will be invalidated,
+// and mark the worklet node non-functional. (i.e. in an error state)
+Object.defineProperty(Object.prototype, 'invalidParam', {'get': () => {
+  if (secondFetch)
+    return new Float32Array(256);
+  secondFetch = true;
+  return new Float32Array(128);
+}});
+
+registerProcessor('invalid-param-array-1', InvalidParamArrayProcessor);
+registerProcessor('invalid-param-array-2', InvalidParamArrayProcessor);
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/one-pole-processor.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/one-pole-processor.js
new file mode 100644
index 0000000000..0bcc43f6f0
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/one-pole-processor.js
@@ -0,0 +1,49 @@
+/**
+ * @class OnePoleFilter
+ * @extends AudioWorkletProcessor
+ *
+ * A simple One-pole filter.
+ */
+
+class OnePoleFilter extends AudioWorkletProcessor {
+
+  // This gets evaluated as soon as the global scope is created.
+  static get parameterDescriptors() {
+    return [{
+      name: 'frequency',
+      defaultValue: 250,
+      minValue: 0,
+      maxValue: 0.5 * sampleRate
+    }];
+  }
+
+  constructor() {
+    super();
+    this.updateCoefficientsWithFrequency_(250);
+  }
+
+  updateCoefficientsWithFrequency_(frequency) {
+    this.b1_ = Math.exp(-2 * Math.PI * frequency / sampleRate);
+    this.a0_ = 1.0 - this.b1_;
+    this.z1_ = 0;
+  }
+
+  process(inputs, outputs, parameters) {
+    let input = inputs[0];
+    let output = outputs[0];
+    let frequency = parameters.frequency;
+    for (let channel = 0; channel < output.length; ++channel) {
+      let inputChannel = input[channel];
+      let outputChannel = output[channel];
+      for (let i = 0; i < outputChannel.length; ++i) {
+        this.updateCoefficientsWithFrequency_(frequency[i]);
+        this.z1_ = inputChannel[i] * this.a0_ + this.z1_ * this.b1_;
+        outputChannel[i] = this.z1_;
+      }
+    }
+
+    return true;
+  }
+}
+
+registerProcessor('one-pole-filter', OnePoleFilter);
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/option-test-processor.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/option-test-processor.js
new file mode 100644
index 0000000000..27e1da6325
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/option-test-processor.js
@@ -0,0 +1,19 @@
+/**
+ * @class OptionTestProcessor
+ * @extends AudioWorkletProcessor
+ *
+ * This processor class demonstrates the option passing feature by echoing the
+ * received |nodeOptions| back to the node.
+ */
+class OptionTestProcessor extends AudioWorkletProcessor {
+  constructor(nodeOptions) {
+    super();
+    this.port.postMessage(nodeOptions);
+  }
+
+  process() {
+    return true;
+  }
+}
+
+registerProcessor('option-test-processor', OptionTestProcessor);
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/param-size-processor.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/param-size-processor.js
new file mode 100644
index 0000000000..d7ce836500
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/param-size-processor.js
@@ -0,0 +1,30 @@
+/**
+ * @class ParamSizeProcessor
+ * @extends AudioWorkletProcessor
+ *
+ * This processor is a source node which basically outputs the size of the
+ * AudioParam array for each render quantum.
+ */
+
+class ParamSizeProcessor extends AudioWorkletProcessor {
+  static get parameterDescriptors() {
+    return [{name: 'param'}];
+  }
+
+  constructor() {
+    super();
+  }
+
+  process(inputs, outputs, parameters) {
+    let output = outputs[0];
+    let param = parameters.param;
+
+    for (let channel = 0; channel < output.length; ++channel) {
+      output[channel].fill(param.length);
+    }
+
+    return true;
+  }
+}
+
+registerProcessor('param-size', ParamSizeProcessor);
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/port-processor.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/port-processor.js
new file mode 100644
index 0000000000..8def5a61d7
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/port-processor.js
@@ -0,0 +1,34 @@
+/**
+ * @class PortProcessor
+ * @extends AudioWorkletProcessor
+ *
+ * This processor class demonstrates the message port functionality.
+ */
+class PortProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.port.onmessage = this.handleMessage.bind(this);
+    this.port.postMessage({
+      state: 'created',
+      timeStamp: currentTime,
+      currentFrame: currentFrame
+    });
+    this.processCallCount = 0;
+  }
+
+  handleMessage(event) {
+    this.port.postMessage({
+      message: event.data,
+      timeStamp: currentTime,
+      currentFrame: currentFrame,
+      processCallCount: this.processCallCount
+    });
+  }
+
+  process() {
+    ++this.processCallCount;
+    return true;
+  }
+}
+
+registerProcessor('port-processor', PortProcessor);
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/process-getter-test-instance-processor.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/process-getter-test-instance-processor.js
new file mode 100644
index 0000000000..b1434f54ba
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/process-getter-test-instance-processor.js
@@ -0,0 +1,44 @@
+/**
+ * @class ProcessGetterTestInstanceProcessor
+ * @extends AudioWorkletProcessor
+ *
+ * This processor class tests that a 'process' getter on an
+ * AudioWorkletProcessorConstructor instance is called at the right times.
+ */
+
+class ProcessGetterTestInstanceProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.getterCallCount = 0;
+    this.totalProcessCallCount = 0;
+    Object.defineProperty(this, 'process', { get: function() {
+      if (!(this instanceof ProcessGetterTestInstanceProcessor)) {
+        throw new Error('`process` getter called with bad `this`.');
+      }
+      ++this.getterCallCount;
+      let functionCallCount = 0;
+      return () => {
+        if (++functionCallCount > 1) {
+          const message = 'Closure of function returned from `process` getter' +
+              ' should be used for only one call.'
+          this.port.postMessage({message: message});
+          throw new Error(message);
+        }
+        if (++this.totalProcessCallCount < 2) {
+          return true; // Expect another getter call.
+        }
+        if (this.totalProcessCallCount != this.getterCallCount) {
+          const message =
+              'Getter should be called only once for each process() call.'
+          this.port.postMessage({message: message});
+          throw new Error(message);
+        }
+        this.port.postMessage({message: 'done'});
+        return false; // No more calls required.
+      };
+    }});
+  }
+}
+
+registerProcessor('process-getter-test-instance',
+                  ProcessGetterTestInstanceProcessor);
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/process-getter-test-prototype-processor.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/process-getter-test-prototype-processor.js
new file mode 100644
index 0000000000..cef5fa8b52
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/process-getter-test-prototype-processor.js
@@ -0,0 +1,55 @@
+/**
+ * @class ProcessGetterTestPrototypeProcessor
+ * @extends AudioWorkletProcessor
+ *
+ * This processor class tests that a 'process' getter on
+ * AudioWorkletProcessorConstructor is called at the right times.
+ */
+
+// Reporting errors during registerProcess() is awkward.
+// The occurrance of an error is flagged, so that a trial registration can be
+// performed and registration against the expected AudioWorkletNode name is
+// performed only if no errors are flagged during the trial registration.
+let error_flag = false;
+
+class ProcessGetterTestPrototypeProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.getterCallCount = 0;
+    this.totalProcessCallCount = 0;
+  }
+  get process() {
+    if (!(this instanceof ProcessGetterTestPrototypeProcessor)) {
+      error_flag = true;
+      throw new Error('`process` getter called with bad `this`.');
+    }
+    ++this.getterCallCount;
+    let functionCallCount = 0;
+    return () => {
+      if (++functionCallCount > 1) {
+        const message = 'Closure of function returned from `process` getter' +
+            ' should be used for only one call.'
+        this.port.postMessage({message: message});
+        throw new Error(message);
+      }
+      if (++this.totalProcessCallCount < 2) {
+        return true; // Expect another getter call.
+      }
+      if (this.totalProcessCallCount != this.getterCallCount) {
+        const message =
+            'Getter should be called only once for each process() call.'
+        this.port.postMessage({message: message});
+        throw new Error(message);
+      }
+      this.port.postMessage({message: 'done'});
+      return false; // No more calls required.
+    };
+  }
+}
+
+registerProcessor('trial-process-getter-test-prototype',
+                  ProcessGetterTestPrototypeProcessor);
+if (!error_flag) {
+  registerProcessor('process-getter-test-prototype',
+                    ProcessGetterTestPrototypeProcessor);
+}
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/process-parameter-test-processor.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/process-parameter-test-processor.js
new file mode 100644
index 0000000000..a300d3cdec
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/process-parameter-test-processor.js
@@ -0,0 +1,18 @@
+/**
+ * @class ProcessParameterTestProcessor
+ * @extends AudioWorkletProcessor
+ *
+ * This processor class forwards input and output parameters to its
+ * AudioWorkletNode.
+ */
+class ProcessParameterTestProcessor extends AudioWorkletProcessor {
+  process(inputs, outputs) {
+    this.port.postMessage({
+      inputs: inputs,
+      outputs: outputs
+    });
+    return false;
+  }
+}
+
+registerProcessor('process-parameter-test', ProcessParameterTestProcessor);
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/promise-processor.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/promise-processor.js
new file mode 100644
index 0000000000..6a8144b3cc
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/promise-processor.js
@@ -0,0 +1,40 @@
+/**
+ * @class PromiseProcessor
+ * @extends AudioWorkletProcessor
+ *
+ * This processor creates and resolves a promise in its `process` method. When
+ * the handler passed to `then()` is called, a counter that is global in the
+ * global scope is incremented. There are two copies of this
+ * AudioWorkletNode/Processor, so the counter should always be even in the
+ * process method of the AudioWorklet processing, since the Promise completion
+ * handler are resolved in between render quanta.
+ *
+ * After a few iterations of the test, one of the worklet posts back the string
+ * "ok" to the main thread, and the test is considered a success.
+ */
+var idx = 0;
+
+class PromiseProcessor extends AudioWorkletProcessor {
+  constructor(options) {
+    super(options);
+  }
+
+  process(inputs, outputs) {
+    if (idx % 2 != 0) {
+      this.port.postMessage("ko");
+      // Don't bother continuing calling process in this case, the test has
+      // already failed.
+      return false;
+    }
+    Promise.resolve().then(() => {
+      idx++;
+      if (idx == 100) {
+        this.port.postMessage("ok");
+      }
+    });
+    // Ensure process is called again.
+    return true;
+  }
+}
+
+registerProcessor('promise-processor', PromiseProcessor);
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/sharedarraybuffer-processor.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/sharedarraybuffer-processor.js
new file mode 100644
index 0000000000..2ccacccd4b
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/sharedarraybuffer-processor.js
@@ -0,0 +1,35 @@
+/**
+ * @class SharedArrayBufferProcessor
+ * @extends AudioWorkletProcessor
+ *
+ * This processor class demonstrates passing SharedArrayBuffers to and from
+ * workers.
+ */
+class SharedArrayBufferProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.port.onmessage = this.handleMessage.bind(this);
+    this.port.onmessageerror = this.handleMessageError.bind(this);
+    let sab = new SharedArrayBuffer(8);
+    this.port.postMessage({state: 'created', sab});
+  }
+
+  handleMessage(event) {
+    this.port.postMessage({
+      state: 'received message',
+      isSab: event.data instanceof SharedArrayBuffer
+    });
+  }
+
+  handleMessageError(event) {
+    this.port.postMessage({
+      state: 'received messageerror'
+    });
+  }
+
+  process() {
+    return true;
+  }
+}
+
+registerProcessor('sharedarraybuffer-processor', SharedArrayBufferProcessor);
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/timing-info-processor.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/timing-info-processor.js
new file mode 100644
index 0000000000..714e32dbb5
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/timing-info-processor.js
@@ -0,0 +1,25 @@
+/**
+ * @class TimingInfoProcessor
+ * @extends AudioWorkletProcessor
+ *
+ * This processor class is to test the timing information in AWGS.
+ */
+class TimingInfoProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.port.onmessage = this.echoMessage.bind(this);
+  }
+
+  echoMessage(event) {
+    this.port.postMessage({
+      currentTime: currentTime,
+      currentFrame: currentFrame
+    });
+  }
+
+  process() {
+    return true;
+  }
+}
+
+registerProcessor('timing-info-processor', TimingInfoProcessor);
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/zero-output-processor.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/zero-output-processor.js
new file mode 100644
index 0000000000..2d7399ca3b
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/zero-output-processor.js
@@ -0,0 +1,42 @@
+/**
+ * @class ZeroOutputProcessor
+ * @extends AudioWorkletProcessor
+ *
+ * This processor accumulates the incoming buffer and send the buffered data
+ * to the main thread when it reaches the specified frame length. The processor
+ * only supports the single input.
+ */
+
+const kRenderQuantumFrames = 128;
+
+class ZeroOutputProcessor extends AudioWorkletProcessor {
+  constructor(options) {
+    super();
+
+    this._framesRequested = options.processorOptions.bufferLength;
+    this._framesCaptured = 0;
+    this._buffer = [];
+    for (let i = 0; i < options.processorOptions.channeCount; ++i) {
+      this._buffer[i] = new Float32Array(this._framesRequested);
+    }
+  }
+
+  process(inputs) {
+    let input = inputs[0];
+    let startIndex = this._framesCaptured;
+    let endIndex = startIndex + kRenderQuantumFrames;
+    for (let i = 0; i < this._buffer.length; ++i) {
+      this._buffer[i].subarray(startIndex, endIndex).set(input[i]);
+    }
+    this._framesCaptured = endIndex;
+
+    if (this._framesCaptured >= this._framesRequested) {
+      this.port.postMessage({ capturedBuffer: this._buffer });
+      return false;
+    } else {
+      return true;
+    }
+  }
+}
+
+registerProcessor('zero-output-processor', ZeroOutputProcessor);
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/zero-outputs-check-processor.js b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/zero-outputs-check-processor.js
new file mode 100644
index 0000000000..f816e918a2
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/processors/zero-outputs-check-processor.js
@@ -0,0 +1,78 @@
+/**
+ * Returns true if a given AudioPort is completely filled with zero samples.
+ * "AudioPort" is a short-hand for FrozenArray<FrozenArray<Float32Array>>.
+ *
+ * @param {FrozenArray<FrozenArray<Float32Array>>} audioPort
+ * @returns bool
+ */
+function IsAllZero(audioPort) {
+  for (let busIndex = 0; busIndex < audioPort.length; ++busIndex) {
+    const audioBus = audioPort[busIndex];
+    for (let channelIndex = 0; channelIndex < audioBus.length; ++channelIndex) {
+      const audioChannel = audioBus[channelIndex];
+      for (let sample = 0; sample < audioChannel.length; ++sample) {
+        if (audioChannel[sample] != 0)
+          return false;
+      }
+    }
+  }
+  return true;
+}
+
+const kRenderQuantumFrames = 128;
+const kTestLengthInSec = 1.0;
+const kPulseDuration = 100;
+
+/**
+ * Checks the |outputs| argument of AudioWorkletProcessor.process() and
+ * send a message to an associated AudioWorkletNode. It needs to be all zero
+ * at all times.
+ *
+ * @class ZeroOutputsCheckProcessor
+ * @extends {AudioWorkletProcessor}
+ */
+class ZeroOutputsCheckProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.startTime = currentTime;
+    this.counter = 0;
+  }
+
+  process(inputs, outputs) {
+    if (!IsAllZero(outputs)) {
+      this.port.postMessage({
+        type: 'assertion',
+        success: false,
+        message: 'Unexpected Non-zero sample found in |outputs|.'
+      });
+      return false;
+    }
+
+    if (currentTime - this.startTime >= kTestLengthInSec) {
+      this.port.postMessage({
+        type: 'assertion',
+        success: true,
+        message: `|outputs| has been all zeros for ${kTestLengthInSec} ` +
+            'seconds as expected.'
+      });
+      return false;
+    }
+
+    // Every ~0.25 second (100 render quanta), switch between outputting white
+    // noise and just exiting without doing anything. (from crbug.com/1099756)
+    this.counter++;
+    if (Math.floor(this.counter / kPulseDuration) % 2 == 0)
+      return true;
+
+    let output = outputs[0];
+    for (let channel = 0; channel < output.length; ++channel) {
+      for (let sample = 0; sample < 128; sample++) {
+        output[channel][sample] = 0.1 * (Math.random() - 0.5);
+      }
+    }
+
+    return true;
+  }
+}
+
+registerProcessor('zero-outputs-check-processor', ZeroOutputsCheckProcessor);
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/simple-input-output.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/simple-input-output.https.html
new file mode 100644
index 0000000000..7b9e7f0ac3
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/simple-input-output.https.html
@@ -0,0 +1,90 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Test Simple AudioWorklet I/O</title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+    <script src="/webaudio/resources/audit-util.js"></script>
+  </head>
+
+  <body>
+    <script>
+      // Arbitrary sample rate
+      const sampleRate = 48000;
+
+      // The offset to be applied by the worklet to its inputs.
+      const offset = 1;
+
+      // Location of the worklet's code
+      const filePath = 'processors/add-offset.js';
+
+      let audit = Audit.createTaskRunner();
+
+      // Context to be used for the tests.
+      let context;
+
+      audit.define('Initialize worklet', (task, should) => {
+        // Two channels for testing.  Channel 0 is the output of the
+        // AudioWorklet.  Channel 1 is the oscillator so we can compare
+        // the outputs.
+        context = new OfflineAudioContext(
+            {numberOfChannels: 2, length: sampleRate, sampleRate: sampleRate});
+
+        // Load up the code for the worklet.
+        should(
+            context.audioWorklet.addModule(filePath),
+            'Creation of AudioWorklet')
+            .beResolved()
+            .then(() => task.done());
+      });
+
+      audit.define(
+          {label: 'test', description: 'Simple AudioWorklet I/O'},
+          (task, should) => {
+            let merger = new ChannelMergerNode(
+                context, {numberOfChannels: context.destination.channelCount});
+            merger.connect(context.destination);
+
+            let src = new OscillatorNode(context);
+
+            let worklet = new AudioWorkletNode(
+                context, 'add-offset-processor',
+                {processorOptions: {offset: offset}});
+
+            src.connect(worklet).connect(merger, 0, 0);
+            src.connect(merger, 0, 1);
+
+            // Start and stop the source.  The stop time is fairly arbitrary,
+            // but use a render quantum boundary for simplicity.
+            const stopFrame = RENDER_QUANTUM_FRAMES;
+            src.start(0);
+            src.stop(stopFrame / context.sampleRate);
+
+            context.startRendering()
+                .then(buffer => {
+                  let ch0 = buffer.getChannelData(0);
+                  let ch1 = buffer.getChannelData(1);
+
+                  let shifted = ch1.slice(0, stopFrame).map(x => x + offset);
+
+                  // The initial part of the output should be the oscillator
+                  // shifted by |offset|.
+                  should(
+                      ch0.slice(0, stopFrame),
+                      `AudioWorklet output[0:${stopFrame - 1}]`)
+                      .beCloseToArray(shifted, {absoluteThreshold: 0});
+
+                  // Output should be constant after the source has stopped.
+                  should(
+                      ch0.slice(stopFrame),
+                      `AudioWorklet output[${stopFrame}:]`)
+                      .beConstantValueOf(offset);
+                })
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/suspended-context-messageport.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/suspended-context-messageport.https.html
new file mode 100644
index 0000000000..f6fa6ddd98
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-audioworklet-interface/suspended-context-messageport.https.html
@@ -0,0 +1,51 @@
+<!doctype html>
+<title>Test MessagePort while AudioContext is not running</title>
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script>
+const get_node_and_message = (context) => {
+  const node = new AudioWorkletNode(context, 'port-processor');
+  return new Promise((resolve) => {
+    node.port.onmessage = (event) => resolve({node: node, event: event});
+  });
+};
+const ping_for_message = (node) => {
+  return new Promise((resolve) => {
+    node.port.onmessage = resolve;
+    node.port.postMessage('ping');
+  });
+};
+const modulePath = 'processors/port-processor.js';
+
+promise_test(async () => {
+  const realtime = new AudioContext();
+  await realtime.audioWorklet.addModule(modulePath);
+  await realtime.suspend();
+  const currentTime = realtime.currentTime;
+  let {node, event} = await get_node_and_message(realtime);
+  assert_equals(event.data.timeStamp, currentTime, 'created message time');
+  event = await ping_for_message(node);
+  assert_equals(event.data.timeStamp, currentTime, 'pong time');
+}, 'realtime suspended');
+
+let offline;
+promise_test(async () => {
+  offline = new OfflineAudioContext({length: 128 + 1, sampleRate: 16384});
+  await offline.audioWorklet.addModule(modulePath);
+  assert_equals(offline.currentTime, 0, 'time before start');
+  let {node, event} = await get_node_and_message(offline);
+  assert_equals(event.data.timeStamp, 0, 'created time before start');
+  event = await ping_for_message(node);
+  assert_equals(event.data.timeStamp, 0, 'pong time before start');
+}, 'offline before start');
+
+promise_test(async () => {
+  await offline.startRendering();
+  const expected = 2 * 128 / offline.sampleRate;
+  assert_equals(offline.currentTime, expected, 'time on complete');
+  let {node, event} = await get_node_and_message(offline);
+  assert_equals(event.data.timeStamp, expected, "created time on complete");
+  event = await ping_for_message(node);
+  assert_equals(event.data.timeStamp, expected, "pong time on complete");
+}, 'offline on complete');
+</script>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-allpass.html b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-allpass.html
new file mode 100644
index 0000000000..86618f9e46
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-allpass.html
@@ -0,0 +1,42 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      biquad-allpass.html
+    </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/biquad-filters.js"></script>
+    <script src="/webaudio/resources/biquad-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {label: 'test', description: 'Biquad allpass filter'},
+          function(task, should) {
+
+            // Create offline audio context.
+            let context = new OfflineAudioContext(
+                2, sampleRate * renderLengthSeconds, sampleRate);
+
+            let filterParameters = [
+              {cutoff: 0, q: 10, gain: 1},
+              {cutoff: 1, q: 10, gain: 1},
+              {cutoff: .5, q: 0, gain: 1},
+              {cutoff: 0.25, q: 10, gain: 1},
+            ];
+            createTestAndRun(context, 'allpass', {
+              should: should,
+              threshold: 3.9337e-8,
+              filterParameters: filterParameters
+            }).then(task.done.bind(task));
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-automation.html b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-automation.html
new file mode 100644
index 0000000000..d459d16fb1
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-automation.html
@@ -0,0 +1,406 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Biquad Automation Test
+    </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/biquad-filters.js"></script>
+    <script src="/webaudio/resources/audioparam-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      // Don't need to run these tests at high sampling rate, so just use a low
+      // one to reduce memory usage and complexity.
+      let sampleRate = 16000;
+
+      // How long to render for each test.
+      let renderDuration = 0.25;
+      // Where to end the automations.  Fairly arbitrary, but must end before
+      // the renderDuration.
+      let automationEndTime = renderDuration / 2;
+
+      let audit = Audit.createTaskRunner();
+
+      // The definition of the linear ramp automation function.
+      function linearRamp(t, v0, v1, t0, t1) {
+        return v0 + (v1 - v0) * (t - t0) / (t1 - t0);
+      }
+
+      // Generate the filter coefficients for the specified filter using the
+      // given parameters for the given duration.  |filterTypeFunction| is a
+      // function that returns the filter coefficients for one set of
+      // parameters.  |parameters| is a property bag that contains the start and
+      // end values (as an array) for each of the biquad attributes.  The
+      // properties are |freq|, |Q|, |gain|, and |detune|.  |duration| is the
+      // number of seconds for which the coefficients are generated.
+      //
+      // A property bag with properties |b0|, |b1|, |b2|, |a1|, |a2|.  Each
+      // propery is an array consisting of the coefficients for the time-varying
+      // biquad filter.
+      function generateFilterCoefficients(
+          filterTypeFunction, parameters, duration) {
+        let renderEndFrame = Math.ceil(renderDuration * sampleRate);
+        let endFrame = Math.ceil(duration * sampleRate);
+        let nCoef = renderEndFrame;
+        let b0 = new Float64Array(nCoef);
+        let b1 = new Float64Array(nCoef);
+        let b2 = new Float64Array(nCoef);
+        let a1 = new Float64Array(nCoef);
+        let a2 = new Float64Array(nCoef);
+
+        let k = 0;
+        // If the property is not given, use the defaults.
+        let freqs = parameters.freq || [350, 350];
+        let qs = parameters.Q || [1, 1];
+        let gains = parameters.gain || [0, 0];
+        let detunes = parameters.detune || [0, 0];
+
+        for (let frame = 0; frame <= endFrame; ++frame) {
+          // Apply linear ramp at frame |frame|.
+          let f =
+              linearRamp(frame / sampleRate, freqs[0], freqs[1], 0, duration);
+          let q = linearRamp(frame / sampleRate, qs[0], qs[1], 0, duration);
+          let g =
+              linearRamp(frame / sampleRate, gains[0], gains[1], 0, duration);
+          let d = linearRamp(
+              frame / sampleRate, detunes[0], detunes[1], 0, duration);
+
+          // Compute actual frequency parameter
+          f = f * Math.pow(2, d / 1200);
+
+          // Compute filter coefficients
+          let coef = filterTypeFunction(f / (sampleRate / 2), q, g);
+          b0[k] = coef.b0;
+          b1[k] = coef.b1;
+          b2[k] = coef.b2;
+          a1[k] = coef.a1;
+          a2[k] = coef.a2;
+          ++k;
+        }
+
+        // Fill the rest of the arrays with the constant value to the end of
+        // the rendering duration.
+        b0.fill(b0[endFrame], endFrame + 1);
+        b1.fill(b1[endFrame], endFrame + 1);
+        b2.fill(b2[endFrame], endFrame + 1);
+        a1.fill(a1[endFrame], endFrame + 1);
+        a2.fill(a2[endFrame], endFrame + 1);
+
+        return {b0: b0, b1: b1, b2: b2, a1: a1, a2: a2};
+      }
+
+      // Apply the given time-varying biquad filter to the given signal,
+      // |signal|.  |coef| should be the time-varying coefficients of the
+      // filter, as returned by |generateFilterCoefficients|.
+      function timeVaryingFilter(signal, coef) {
+        let length = signal.length;
+        // Use double precision for the internal computations.
+        let y = new Float64Array(length);
+
+        // Prime the pump. (Assumes the signal has length >= 2!)
+        y[0] = coef.b0[0] * signal[0];
+        y[1] =
+            coef.b0[1] * signal[1] + coef.b1[1] * signal[0] - coef.a1[1] * y[0];
+
+        for (let n = 2; n < length; ++n) {
+          y[n] = coef.b0[n] * signal[n] + coef.b1[n] * signal[n - 1] +
+              coef.b2[n] * signal[n - 2];
+          y[n] -= coef.a1[n] * y[n - 1] + coef.a2[n] * y[n - 2];
+        }
+
+        // But convert the result to single precision for comparison.
+        return y.map(Math.fround);
+      }
+
+      // Configure the audio graph using |context|.  Returns the biquad filter
+      // node and the AudioBuffer used for the source.
+      function configureGraph(context, toneFrequency) {
+        // The source is just a simple sine wave.
+        let src = context.createBufferSource();
+        let b =
+            context.createBuffer(1, renderDuration * sampleRate, sampleRate);
+        let data = b.getChannelData(0);
+        let omega = 2 * Math.PI * toneFrequency / sampleRate;
+        for (let k = 0; k < data.length; ++k) {
+          data[k] = Math.sin(omega * k);
+        }
+        src.buffer = b;
+        let f = context.createBiquadFilter();
+        src.connect(f);
+        f.connect(context.destination);
+
+        src.start();
+
+        return {filter: f, source: b};
+      }
+
+      function createFilterVerifier(
+          should, filterCreator, threshold, parameters, input, message) {
+        return function(resultBuffer) {
+          let actual = resultBuffer.getChannelData(0);
+          let coefs = generateFilterCoefficients(
+              filterCreator, parameters, automationEndTime);
+
+          reference = timeVaryingFilter(input, coefs);
+
+          should(actual, message).beCloseToArray(reference, {
+            absoluteThreshold: threshold
+          });
+        };
+      }
+
+      // Automate just the frequency parameter.  A bandpass filter is used where
+      // the center frequency is swept across the source (which is a simple
+      // tone).
+      audit.define('automate-freq', (task, should) => {
+        let context =
+            new OfflineAudioContext(1, renderDuration * sampleRate, sampleRate);
+
+        // Center frequency of bandpass filter and also the frequency of the
+        // test tone.
+        let centerFreq = 10 * 440;
+
+        // Sweep the frequency +/- 5*440 Hz from the center.  This should cause
+        // the output to be low at the beginning and end of the test where the
+        // tone is outside the pass band of the filter, but high in the middle
+        // of the automation time where the tone is near the center of the pass
+        // band.  Make sure the frequency sweep stays inside the Nyquist
+        // frequency.
+        let parameters = {freq: [centerFreq - 5 * 440, centerFreq + 5 * 440]};
+        let graph = configureGraph(context, centerFreq);
+        let f = graph.filter;
+        let b = graph.source;
+
+        f.type = 'bandpass';
+        f.frequency.setValueAtTime(parameters.freq[0], 0);
+        f.frequency.linearRampToValueAtTime(
+            parameters.freq[1], automationEndTime);
+
+        context.startRendering()
+            .then(createFilterVerifier(
+                should, createBandpassFilter, 4.6455e-6, parameters,
+                b.getChannelData(0),
+                'Output of bandpass filter with frequency automation'))
+            .then(() => task.done());
+      });
+
+      // Automate just the Q parameter.  A bandpass filter is used where the Q
+      // of the filter is swept.
+      audit.define('automate-q', (task, should) => {
+        let context =
+            new OfflineAudioContext(1, renderDuration * sampleRate, sampleRate);
+
+        // The frequency of the test tone.
+        let centerFreq = 440;
+
+        // Sweep the Q paramter between 1 and 200.  This will cause the output
+        // of the filter to pass most of the tone at the beginning to passing
+        // less of the tone at the end.  This is because we set center frequency
+        // of the bandpass filter to be slightly off from the actual tone.
+        let parameters = {
+          Q: [1, 200],
+          // Center frequency of the bandpass filter is just 25 Hz above the
+          // tone frequency.
+          freq: [centerFreq + 25, centerFreq + 25]
+        };
+        let graph = configureGraph(context, centerFreq);
+        let f = graph.filter;
+        let b = graph.source;
+
+        f.type = 'bandpass';
+        f.frequency.value = parameters.freq[0];
+        f.Q.setValueAtTime(parameters.Q[0], 0);
+        f.Q.linearRampToValueAtTime(parameters.Q[1], automationEndTime);
+
+        context.startRendering()
+            .then(createFilterVerifier(
+                should, createBandpassFilter, 1.0133e-6, parameters,
+                b.getChannelData(0),
+                'Output of bandpass filter with Q automation'))
+            .then(() => task.done());
+      });
+
+      // Automate just the gain of the lowshelf filter.  A test tone will be in
+      // the lowshelf part of the filter.  The output will vary as the gain of
+      // the lowshelf is changed.
+      audit.define('automate-gain', (task, should) => {
+        let context =
+            new OfflineAudioContext(1, renderDuration * sampleRate, sampleRate);
+
+        // Frequency of the test tone.
+        let centerFreq = 440;
+
+        // Set the cutoff frequency of the lowshelf to be significantly higher
+        // than the test tone. Sweep the gain from 20 dB to -20 dB.  (We go from
+        // 20 to -20 to easily verify that the filter didn't go unstable.)
+        let parameters = {freq: [3500, 3500], gain: [20, -20]};
+        let graph = configureGraph(context, centerFreq);
+        let f = graph.filter;
+        let b = graph.source;
+
+        f.type = 'lowshelf';
+        f.frequency.value = parameters.freq[0];
+        f.gain.setValueAtTime(parameters.gain[0], 0);
+        f.gain.linearRampToValueAtTime(parameters.gain[1], automationEndTime);
+
+        context.startRendering()
+            .then(createFilterVerifier(
+                should, createLowShelfFilter, 2.7657e-5, parameters,
+                b.getChannelData(0),
+                'Output of lowshelf filter with gain automation'))
+            .then(() => task.done());
+      });
+
+      // Automate just the detune parameter.  Basically the same test as for the
+      // frequncy parameter but we just use the detune parameter to modulate the
+      // frequency parameter.
+      audit.define('automate-detune', (task, should) => {
+        let context =
+            new OfflineAudioContext(1, renderDuration * sampleRate, sampleRate);
+        let centerFreq = 10 * 440;
+        let parameters = {
+          freq: [centerFreq, centerFreq],
+          detune: [-10 * 1200, 10 * 1200]
+        };
+        let graph = configureGraph(context, centerFreq);
+        let f = graph.filter;
+        let b = graph.source;
+
+        f.type = 'bandpass';
+        f.frequency.value = parameters.freq[0];
+        f.detune.setValueAtTime(parameters.detune[0], 0);
+        f.detune.linearRampToValueAtTime(
+            parameters.detune[1], automationEndTime);
+
+        context.startRendering()
+            .then(createFilterVerifier(
+                should, createBandpassFilter, 3.1471e-5, parameters,
+                b.getChannelData(0),
+                'Output of bandpass filter with detune automation'))
+            .then(() => task.done());
+      });
+
+      // Automate all of the filter parameters at once.  This is a basic check
+      // that everything is working.  A peaking filter is used because it uses
+      // all of the parameters.
+      audit.define('automate-all', (task, should) => {
+        let context =
+            new OfflineAudioContext(1, renderDuration * sampleRate, sampleRate);
+        let graph = configureGraph(context, 10 * 440);
+        let f = graph.filter;
+        let b = graph.source;
+
+        // Sweep all of the filter parameters.  These are pretty much arbitrary.
+        let parameters = {
+          freq: [8000, 100],
+          Q: [f.Q.value, .0001],
+          gain: [f.gain.value, 20],
+          detune: [2400, -2400]
+        };
+
+        f.type = 'peaking';
+        // Set starting points for all parameters of the filter.  Start at 10
+        // kHz for the center frequency, and the defaults for Q and gain.
+        f.frequency.setValueAtTime(parameters.freq[0], 0);
+        f.Q.setValueAtTime(parameters.Q[0], 0);
+        f.gain.setValueAtTime(parameters.gain[0], 0);
+        f.detune.setValueAtTime(parameters.detune[0], 0);
+
+        // Linear ramp each parameter
+        f.frequency.linearRampToValueAtTime(
+            parameters.freq[1], automationEndTime);
+        f.Q.linearRampToValueAtTime(parameters.Q[1], automationEndTime);
+        f.gain.linearRampToValueAtTime(parameters.gain[1], automationEndTime);
+        f.detune.linearRampToValueAtTime(
+            parameters.detune[1], automationEndTime);
+
+        context.startRendering()
+            .then(createFilterVerifier(
+                should, createPeakingFilter, 6.2907e-4, parameters,
+                b.getChannelData(0),
+                'Output of peaking filter with automation of all parameters'))
+            .then(() => task.done());
+      });
+
+      // Test that modulation of the frequency parameter of the filter works.  A
+      // sinusoid of 440 Hz is the test signal that is applied to a bandpass
+      // biquad filter.  The frequency parameter of the filter is modulated by a
+      // sinusoid at 103 Hz, and the frequency modulation varies from 116 to 412
+      // Hz.  (This test was taken from the description in
+      // https://github.com/WebAudio/web-audio-api/issues/509#issuecomment-94731355)
+      audit.define('modulation', (task, should) => {
+        let context =
+            new OfflineAudioContext(1, renderDuration * sampleRate, sampleRate);
+
+        // Create a graph with the sinusoidal source at 440 Hz as the input to a
+        // biquad filter.
+        let graph = configureGraph(context, 440);
+        let f = graph.filter;
+        let b = graph.source;
+
+        f.type = 'bandpass';
+        f.Q.value = 5;
+        f.frequency.value = 264;
+
+        // Create the modulation source, a sinusoid with frequency 103 Hz and
+        // amplitude 148.  (The amplitude of 148 is added to the filter's
+        // frequency value of 264 to produce a sinusoidal modulation of the
+        // frequency parameter from 116 to 412 Hz.)
+        let mod = context.createBufferSource();
+        let mbuffer =
+            context.createBuffer(1, renderDuration * sampleRate, sampleRate);
+        let d = mbuffer.getChannelData(0);
+        let omega = 2 * Math.PI * 103 / sampleRate;
+        for (let k = 0; k < d.length; ++k) {
+          d[k] = 148 * Math.sin(omega * k);
+        }
+        mod.buffer = mbuffer;
+
+        mod.connect(f.frequency);
+
+        mod.start();
+        context.startRendering()
+            .then(function(resultBuffer) {
+              let actual = resultBuffer.getChannelData(0);
+              // Compute the filter coefficients using the mod sine wave
+
+              let endFrame = Math.ceil(renderDuration * sampleRate);
+              let nCoef = endFrame;
+              let b0 = new Float64Array(nCoef);
+              let b1 = new Float64Array(nCoef);
+              let b2 = new Float64Array(nCoef);
+              let a1 = new Float64Array(nCoef);
+              let a2 = new Float64Array(nCoef);
+
+              // Generate the filter coefficients when the frequency varies from
+              // 116 to 248 Hz using the 103 Hz sinusoid.
+              for (let k = 0; k < nCoef; ++k) {
+                let freq = f.frequency.value + d[k];
+                let c = createBandpassFilter(
+                    freq / (sampleRate / 2), f.Q.value, f.gain.value);
+                b0[k] = c.b0;
+                b1[k] = c.b1;
+                b2[k] = c.b2;
+                a1[k] = c.a1;
+                a2[k] = c.a2;
+              }
+              reference = timeVaryingFilter(
+                  b.getChannelData(0),
+                  {b0: b0, b1: b1, b2: b2, a1: a1, a2: a2});
+
+              should(
+                  actual,
+                  'Output of bandpass filter with sinusoidal modulation of bandpass center frequency')
+                  .beCloseToArray(reference, {absoluteThreshold: 3.9787e-5});
+            })
+            .then(() => task.done());
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-bandpass.html b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-bandpass.html
new file mode 100644
index 0000000000..166aa9b3cb
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-bandpass.html
@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      biquad-bandpass.html
+    </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/biquad-filters.js"></script>
+    <script src="/webaudio/resources/biquad-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {label: 'test', description: 'Biquad bandpass filter.'},
+          function(task, should) {
+
+            // Create offline audio context.
+            let context = new OfflineAudioContext(
+                2, sampleRate * renderLengthSeconds, sampleRate);
+
+            // The filters we want to test.
+            let filterParameters = [
+              {cutoff: 0, q: 0, gain: 1},
+              {cutoff: 1, q: 0, gain: 1},
+              {cutoff: 0.5, q: 0, gain: 1},
+              {cutoff: 0.25, q: 1, gain: 1},
+            ];
+
+            createTestAndRun(context, 'bandpass', {
+              should: should,
+              threshold: 2.2501e-8,
+              filterParameters: filterParameters
+            }).then(task.done.bind(task));
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-basic.html b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-basic.html
new file mode 100644
index 0000000000..441e98a251
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-basic.html
@@ -0,0 +1,134 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Basic BiquadFilterNode Properties
+    </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 sampleRate = 48000;
+      let testFrames = 100;
+
+      // Global context that can be used by the individual tasks. It must be
+      // defined by the initialize task.
+      let context;
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define('initialize', (task, should) => {
+        should(() => {
+          context = new OfflineAudioContext(1, testFrames, sampleRate);
+        }, 'Initialize context for testing').notThrow();
+        task.done();
+      });
+
+      audit.define('existence', (task, should) => {
+        should(context.createBiquadFilter, 'context.createBiquadFilter')
+            .exist();
+        task.done();
+      });
+
+      audit.define('parameters', (task, should) => {
+        // Create a really simple IIR filter. Doesn't much matter what.
+        let coef = Float32Array.from([1]);
+
+        let f = context.createBiquadFilter(coef, coef);
+
+        should(f.numberOfInputs, 'numberOfInputs').beEqualTo(1);
+        should(f.numberOfOutputs, 'numberOfOutputs').beEqualTo(1);
+        should(f.channelCountMode, 'channelCountMode').beEqualTo('max');
+        should(f.channelInterpretation, 'channelInterpretation')
+            .beEqualTo('speakers');
+
+        task.done();
+      });
+
+      audit.define('exceptions-createBiquadFilter', (task, should) => {
+        should(function() {
+          // Two args are required.
+          context.createBiquadFilter();
+        }, 'createBiquadFilter()').notThrow();
+
+        task.done();
+      });
+
+      audit.define('exceptions-getFrequencyData', (task, should) => {
+        // Create a really simple IIR filter. Doesn't much matter what.
+        let coef = Float32Array.from([1]);
+
+        let f = context.createBiquadFilter(coef, coef);
+
+        should(
+            function() {
+              // frequencyHz can't be null.
+              f.getFrequencyResponse(
+                  null, new Float32Array(1), new Float32Array(1));
+            },
+            'getFrequencyResponse(' +
+                'null, ' +
+                'new Float32Array(1), ' +
+                'new Float32Array(1))')
+            .throw(TypeError);
+
+        should(
+            function() {
+              // magResponse can't be null.
+              f.getFrequencyResponse(
+                  new Float32Array(1), null, new Float32Array(1));
+            },
+            'getFrequencyResponse(' +
+                'new Float32Array(1), ' +
+                'null, ' +
+                'new Float32Array(1))')
+            .throw(TypeError);
+
+        should(
+            function() {
+              // phaseResponse can't be null.
+              f.getFrequencyResponse(
+                  new Float32Array(1), new Float32Array(1), null);
+            },
+            'getFrequencyResponse(' +
+                'new Float32Array(1), ' +
+                'new Float32Array(1), ' +
+                'null)')
+            .throw(TypeError);
+
+        should(
+            function() {
+              // magResponse array must the same length as frequencyHz
+              f.getFrequencyResponse(
+                  new Float32Array(10), new Float32Array(1),
+                  new Float32Array(20));
+            },
+            'getFrequencyResponse(' +
+                'new Float32Array(10), ' +
+                'new Float32Array(1), ' +
+                'new Float32Array(20))')
+            .throw(DOMException, 'InvalidAccessError');
+
+        should(
+            function() {
+              // phaseResponse array must be the same length as frequencyHz
+              f.getFrequencyResponse(
+                  new Float32Array(10), new Float32Array(20),
+                  new Float32Array(1));
+            },
+            'getFrequencyResponse(' +
+                'new Float32Array(10), ' +
+                'new Float32Array(20), ' +
+                'new Float32Array(1))')
+            .throw(DOMException, 'InvalidAccessError');
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-getFrequencyResponse.html b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-getFrequencyResponse.html
new file mode 100644
index 0000000000..23222e4df9
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-getFrequencyResponse.html
@@ -0,0 +1,394 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test BiquadFilter getFrequencyResponse() functionality
+    </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/biquad-filters.js"></script>
+    <script src="/webaudio/resources/biquad-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      // Test the frequency response of a biquad filter.  We compute the
+      // frequency response for a simple peaking biquad filter and compare it
+      // with the expected frequency response.  The actual filter used doesn't
+      // matter since we're testing getFrequencyResponse and not the actual
+      // filter output. The filters are extensively tested in other biquad
+      // tests.
+
+      // The magnitude response of the biquad filter.
+      let magResponse;
+
+      // The phase response of the biquad filter.
+      let phaseResponse;
+
+      // Number of frequency samples to take.
+      let numberOfFrequencies = 1000;
+
+      // The filter parameters.
+      let filterCutoff = 1000;  // Hz.
+      let filterQ = 1;
+      let filterGain = 5;  // Decibels.
+
+      // The magnitudes and phases of the reference frequency response.
+      let expectedMagnitudes;
+      let expectedPhases;
+
+      // Convert frequency in Hz to a normalized frequency between 0 to 1 with 1
+      // corresponding to the Nyquist frequency.
+      function normalizedFrequency(freqHz, sampleRate) {
+        let nyquist = sampleRate / 2;
+        return freqHz / nyquist;
+      }
+
+      // Get the filter response at a (normalized) frequency |f| for the filter
+      // with coefficients |coef|.
+      function getResponseAt(coef, f) {
+        let b0 = coef.b0;
+        let b1 = coef.b1;
+        let b2 = coef.b2;
+        let a1 = coef.a1;
+        let a2 = coef.a2;
+
+        // H(z) = (b0 + b1 / z + b2 / z^2) / (1 + a1 / z + a2 / z^2)
+        //
+        // Compute H(exp(i * pi * f)).  No native complex numbers in javascript,
+        // so break H(exp(i * pi * // f)) in to the real and imaginary parts of
+        // the numerator and denominator.  Let omega = pi * f. Then the
+        // numerator is
+        //
+        // b0 + b1 * cos(omega) + b2 * cos(2 * omega) - i * (b1 * sin(omega) +
+        // b2 * sin(2 * omega))
+        //
+        // and the denominator is
+        //
+        // 1 + a1 * cos(omega) + a2 * cos(2 * omega) - i * (a1 * sin(omega) + a2
+        // * sin(2 * omega))
+        //
+        // Compute the magnitude and phase from the real and imaginary parts.
+
+        let omega = Math.PI * f;
+        let numeratorReal =
+            b0 + b1 * Math.cos(omega) + b2 * Math.cos(2 * omega);
+        let numeratorImag = -(b1 * Math.sin(omega) + b2 * Math.sin(2 * omega));
+        let denominatorReal =
+            1 + a1 * Math.cos(omega) + a2 * Math.cos(2 * omega);
+        let denominatorImag =
+            -(a1 * Math.sin(omega) + a2 * Math.sin(2 * omega));
+
+        let magnitude = Math.sqrt(
+            (numeratorReal * numeratorReal + numeratorImag * numeratorImag) /
+            (denominatorReal * denominatorReal +
+             denominatorImag * denominatorImag));
+        let phase = Math.atan2(numeratorImag, numeratorReal) -
+            Math.atan2(denominatorImag, denominatorReal);
+
+        if (phase >= Math.PI) {
+          phase -= 2 * Math.PI;
+        } else if (phase <= -Math.PI) {
+          phase += 2 * Math.PI;
+        }
+
+        return {magnitude: magnitude, phase: phase};
+      }
+
+      // Compute the reference frequency response for the biquad filter |filter|
+      // at the frequency samples given by |frequencies|.
+      function frequencyResponseReference(filter, frequencies) {
+        let sampleRate = filter.context.sampleRate;
+        let normalizedFreq =
+            normalizedFrequency(filter.frequency.value, sampleRate);
+        let filterCoefficients = createFilter(
+            filter.type, normalizedFreq, filter.Q.value, filter.gain.value);
+
+        let magnitudes = [];
+        let phases = [];
+
+        for (let k = 0; k < frequencies.length; ++k) {
+          let response = getResponseAt(
+              filterCoefficients,
+              normalizedFrequency(frequencies[k], sampleRate));
+          magnitudes.push(response.magnitude);
+          phases.push(response.phase);
+        }
+
+        return {magnitudes: magnitudes, phases: phases};
+      }
+
+      // Compute a set of linearly spaced frequencies.
+      function createFrequencies(nFrequencies, sampleRate) {
+        let frequencies = new Float32Array(nFrequencies);
+        let nyquist = sampleRate / 2;
+        let freqDelta = nyquist / nFrequencies;
+
+        for (let k = 0; k < nFrequencies; ++k) {
+          frequencies[k] = k * freqDelta;
+        }
+
+        return frequencies;
+      }
+
+      function linearToDecibels(x) {
+        if (x) {
+          return 20 * Math.log(x) / Math.LN10;
+        } else {
+          return -1000;
+        }
+      }
+
+      function decibelsToLinear(x) {
+        return Math.pow(10, x/20);
+      }
+
+      // Look through the array and find any NaN or infinity. Returns the index
+      // of the first occurence or -1 if none.
+      function findBadNumber(signal) {
+        for (let k = 0; k < signal.length; ++k) {
+          if (!isValidNumber(signal[k])) {
+            return k;
+          }
+        }
+        return -1;
+      }
+
+      // Compute absolute value of the difference between phase angles, taking
+      // into account the wrapping of phases.
+      function absolutePhaseDifference(x, y) {
+        let diff = Math.abs(x - y);
+
+        if (diff > Math.PI) {
+          diff = 2 * Math.PI - diff;
+        }
+        return diff;
+      }
+
+      // Compare the frequency response with our expected response.
+      //
+      //   should - The |should| method provided by audit.define
+      //   filter - The filter node used in the test
+      //   frequencies - array of frequencies provided to |getFrequencyResponse|
+      //   magResponse - mag response from |getFrequencyResponse|
+      //   phaseResponse - phase response from |getFrequencyResponse|
+      //   maxAllowedMagError - error threshold for mag response, in dB
+      //   maxAllowedPhaseError - error threshold for phase response, in rad.
+      function compareResponses(
+          should, filter, frequencies, magResponse, phaseResponse,
+          maxAllowedMagError, maxAllowedPhaseError) {
+        let expectedResponse = frequencyResponseReference(filter, frequencies);
+
+        expectedMagnitudes = expectedResponse.magnitudes;
+        expectedPhases = expectedResponse.phases;
+
+        let n = magResponse.length;
+        let badResponse = false;
+
+        let maxMagError = -1;
+        let maxMagErrorIndex = -1;
+
+        let k;
+        let hasBadNumber;
+
+        hasBadNumber = findBadNumber(magResponse);
+        badResponse =
+            !should(
+                 hasBadNumber >= 0 ? 1 : 0,
+                 filter.type +
+                     ': Number of non-finite values in magnitude response')
+                 .beEqualTo(0);
+
+        hasBadNumber = findBadNumber(phaseResponse);
+        badResponse =
+            !should(
+                 hasBadNumber >= 0 ? 1 : 0,
+                 filter.type + ': Number of non-finte values in phase response')
+                 .beEqualTo(0);
+
+        // These aren't testing the implementation itself.  Instead, these are
+        // sanity checks on the reference.  Failure here does not imply an error
+        // in the implementation.
+        hasBadNumber = findBadNumber(expectedMagnitudes);
+        badResponse =
+            !should(
+                 hasBadNumber >= 0 ? 1 : 0,
+                 filter.type +
+                     ': Number of non-finite values in the expected magnitude response')
+                 .beEqualTo(0);
+
+        hasBadNumber = findBadNumber(expectedPhases);
+        badResponse =
+            !should(
+                 hasBadNumber >= 0 ? 1 : 0,
+                 filter.type +
+                     ': Number of non-finite values in expected phase response')
+                 .beEqualTo(0);
+
+        // If we found a NaN or infinity, the following tests aren't very
+        // helpful, especially for NaN. We run them anyway, after printing a
+        // warning message.
+        should(
+            !badResponse,
+            filter.type +
+                ': Actual and expected results contained only finite values')
+            .beTrue();
+
+        for (k = 0; k < n; ++k) {
+          let error = Math.abs(
+              linearToDecibels(magResponse[k]) -
+              linearToDecibels(expectedMagnitudes[k]));
+          if (error > maxMagError) {
+            maxMagError = error;
+            maxMagErrorIndex = k;
+          }
+        }
+
+        should(
+            linearToDecibels(maxMagError),
+            filter.type + ': Max error (' + linearToDecibels(maxMagError) +
+                ' dB) of magnitude response at frequency ' +
+                frequencies[maxMagErrorIndex] + ' Hz')
+            .beLessThanOrEqualTo(linearToDecibels(maxAllowedMagError));
+        let maxPhaseError = -1;
+        let maxPhaseErrorIndex = -1;
+
+        for (k = 0; k < n; ++k) {
+          let error =
+              absolutePhaseDifference(phaseResponse[k], expectedPhases[k]);
+          if (error > maxPhaseError) {
+            maxPhaseError = error;
+            maxPhaseErrorIndex = k;
+          }
+        }
+
+        should(
+            radToDegree(maxPhaseError),
+            filter.type + ': Max error (' + radToDegree(maxPhaseError) +
+                ' deg) in phase response at frequency ' +
+                frequencies[maxPhaseErrorIndex] + ' Hz')
+            .beLessThanOrEqualTo(radToDegree(maxAllowedPhaseError));
+      }
+
+      function radToDegree(rad) {
+        // Radians to degrees
+        return rad * 180 / Math.PI;
+      }
+
+      // Test the getFrequencyResponse for each of filter types.  Each entry in
+      // this array is a dictionary with these elements:
+      //
+      //   type:  filter type to be tested
+      //   maxErrorInMagnitude:  Allowed error in computed magnitude response
+      //   maxErrorInPhase:      Allowed error in computed magnitude phase
+      [{
+        type: 'lowpass',
+        maxErrorInMagnitude: decibelsToLinear(-73.0178),
+        maxErrorInPhase: 8.04360e-6
+      },
+       {
+         type: 'highpass',
+         maxErrorInMagnitude: decibelsToLinear(-117.5461),
+         maxErrorInPhase: 6.9691e-6
+       },
+       {
+         type: 'bandpass',
+         maxErrorInMagnitude: decibelsToLinear(-79.0139),
+         maxErrorInPhase: 4.9371e-6
+       },
+       {
+         type: 'lowshelf',
+         maxErrorInMagnitude: decibelsToLinear(-120.4038),
+         maxErrorInPhase: 4.0724e-6
+       },
+       {
+         type: 'highshelf',
+         maxErrorInMagnitude: decibelsToLinear(-120, 1303),
+         maxErrorInPhase: 4.0724e-6
+       },
+       {
+         type: 'peaking',
+         maxErrorInMagnitude: decibelsToLinear(-119.1176),
+         maxErrorInPhase: 6.4724e-8
+       },
+       {
+         type: 'notch',
+         maxErrorInMagnitude: decibelsToLinear(-87.0808),
+         maxErrorInPhase: 6.6300e-6
+       },
+       {
+         type: 'allpass',
+         maxErrorInMagnitude: decibelsToLinear(-265.3517),
+         maxErrorInPhase: 1.3260e-5
+       }].forEach(test => {
+        audit.define(
+            {label: test.type, description: 'Frequency response'},
+            (task, should) => {
+              let context = new AudioContext();
+
+              let filter = new BiquadFilterNode(context, {
+                type: test.type,
+                frequency: filterCutoff,
+                Q: filterQ,
+                gain: filterGain
+              });
+
+              let frequencies =
+                  createFrequencies(numberOfFrequencies, context.sampleRate);
+              magResponse = new Float32Array(numberOfFrequencies);
+              phaseResponse = new Float32Array(numberOfFrequencies);
+
+              filter.getFrequencyResponse(
+                  frequencies, magResponse, phaseResponse);
+              compareResponses(
+                  should, filter, frequencies, magResponse, phaseResponse,
+                  test.maxErrorInMagnitude, test.maxErrorInPhase);
+
+              task.done();
+            });
+      });
+
+      audit.define(
+          {
+            label: 'getFrequencyResponse',
+            description: 'Test out-of-bounds frequency values'
+          },
+          (task, should) => {
+            let context = new OfflineAudioContext(1, 1, sampleRate);
+            let filter = new BiquadFilterNode(context);
+
+            // Frequencies to test.  These are all outside the valid range of
+            // frequencies of 0 to Nyquist.
+            let freq = new Float32Array(2);
+            freq[0] = -1;
+            freq[1] = context.sampleRate / 2 + 1;
+
+            let mag = new Float32Array(freq.length);
+            let phase = new Float32Array(freq.length);
+
+            filter.getFrequencyResponse(freq, mag, phase);
+
+            // Verify that the returned magnitude and phase entries are alL NaN
+            // since the frequencies are outside the valid range
+            for (let k = 0; k < mag.length; ++k) {
+              should(mag[k],
+                  'Magnitude response at frequency ' + freq[k])
+                  .beNaN();
+            }
+
+            for (let k = 0; k < phase.length; ++k) {
+              should(phase[k],
+                  'Phase response at frequency ' + freq[k])
+                  .beNaN();
+            }
+
+            task.done();
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-highpass.html b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-highpass.html
new file mode 100644
index 0000000000..45c335bc4b
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-highpass.html
@@ -0,0 +1,42 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      biquad-highpass.html
+    </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/biquad-filters.js"></script>
+    <script src="/webaudio/resources/biquad-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {label: 'test', description: 'Biquad highpass filter'},
+          function(task, should) {
+            // Create offline audio context.
+            let context = new OfflineAudioContext(
+                2, sampleRate * renderLengthSeconds, sampleRate);
+
+            // The filters we want to test.
+            let filterParameters = [
+              {cutoff: 0, q: 1, gain: 1},
+              {cutoff: 1, q: 1, gain: 1},
+              {cutoff: 0.25, q: 1, gain: 1},
+            ];
+
+            createTestAndRun(context, 'highpass', {
+              should: should,
+              threshold: 1.5487e-8,
+              filterParameters: filterParameters
+            }).then(task.done.bind(task));
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-highshelf.html b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-highshelf.html
new file mode 100644
index 0000000000..345195f104
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-highshelf.html
@@ -0,0 +1,43 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      biquad-highshelf.html
+    </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/biquad-filters.js"></script>
+    <script src="/webaudio/resources/biquad-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {label: 'test', description: 'Biquad highshelf filter'},
+          function(task, should) {
+
+            // Create offline audio context.
+            let context = new OfflineAudioContext(
+                2, sampleRate * renderLengthSeconds, sampleRate);
+
+            // The filters we want to test.
+            let filterParameters = [
+              {cutoff: 0, q: 10, gain: 10},
+              {cutoff: 1, q: 10, gain: 10},
+              {cutoff: 0.25, q: 10, gain: 10},
+            ];
+
+            createTestAndRun(context, 'highshelf', {
+              should: should,
+              threshold: 6.2577e-8,
+              filterParameters: filterParameters
+            }).then(task.done.bind(task));
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-lowpass.html b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-lowpass.html
new file mode 100644
index 0000000000..d20786e36b
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-lowpass.html
@@ -0,0 +1,45 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      biquad-lowpass.html
+    </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/biquad-filters.js"></script>
+    <script src="/webaudio/resources/biquad-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {label: 'test', description: 'Biquad lowpass filter'},
+          function(task, should) {
+
+            // Create offline audio context.
+            let context = new OfflineAudioContext(
+                2, sampleRate * renderLengthSeconds, sampleRate);
+
+            // The filters we want to test.
+            let filterParameters = [
+              {cutoff: 0, q: 1, gain: 1},
+              {cutoff: 1, q: 1, gain: 1},
+              {cutoff: 0.25, q: 1, gain: 1},
+              {cutoff: 0.25, q: 1, gain: 1, detune: 100},
+              {cutoff: 0.01, q: 1, gain: 1, detune: -200},
+            ];
+
+            createTestAndRun(context, 'lowpass', {
+              should: should,
+              threshold: 9.7869e-8,
+              filterParameters: filterParameters
+            }).then(task.done.bind(task));
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-lowshelf.html b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-lowshelf.html
new file mode 100644
index 0000000000..ab76cefd4b
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-lowshelf.html
@@ -0,0 +1,43 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      biquad-lowshelf.html
+    </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/biquad-filters.js"></script>
+    <script src="/webaudio/resources/biquad-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {label: 'test', description: 'Biquad lowshelf filter'},
+          function(task, should) {
+
+            // Create offline audio context.
+            let context = new OfflineAudioContext(
+                2, sampleRate * renderLengthSeconds, sampleRate);
+
+            // The filters we want to test.
+            let filterParameters = [
+              {cutoff: 0, q: 10, gain: 10},
+              {cutoff: 1, q: 10, gain: 10},
+              {cutoff: 0.25, q: 10, gain: 10},
+            ];
+
+            createTestAndRun(context, 'lowshelf', {
+              should: should,
+              threshold: 3.8349e-8,
+              filterParameters: filterParameters
+            }).then(task.done.bind(task));
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-notch.html b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-notch.html
new file mode 100644
index 0000000000..98e6e6e02c
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-notch.html
@@ -0,0 +1,43 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      biquad-notch.html
+    </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/biquad-filters.js"></script>
+    <script src="/webaudio/resources/biquad-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {label: 'test', description: 'Biquad notch filter'},
+          function(task, should) {
+
+            // Create offline audio context.
+            let context = new OfflineAudioContext(
+                2, sampleRate * renderLengthSeconds, sampleRate);
+
+            let filterParameters = [
+              {cutoff: 0, q: 10, gain: 1},
+              {cutoff: 1, q: 10, gain: 1},
+              {cutoff: .5, q: 0, gain: 1},
+              {cutoff: 0.25, q: 10, gain: 1},
+            ];
+
+            createTestAndRun(context, 'notch', {
+              should: should,
+              threshold: 1.9669e-8,
+              filterParameters: filterParameters
+            }).then(task.done.bind(task));
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-peaking.html b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-peaking.html
new file mode 100644
index 0000000000..90b7c1546d
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-peaking.html
@@ -0,0 +1,46 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      biquad-peaking.html
+    </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/biquad-filters.js"></script>
+    <script src="/webaudio/resources/biquad-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {label: 'test', description: 'Biquad peaking filter'},
+          function(task, should) {
+
+            window.jsTestIsAsync = true;
+
+            // Create offline audio context.
+            let context = new OfflineAudioContext(
+                2, sampleRate * renderLengthSeconds, sampleRate);
+
+            // The filters we want to test.
+            let filterParameters = [
+              {cutoff: 0, q: 10, gain: 10},
+              {cutoff: 1, q: 10, gain: 10},
+              {cutoff: .5, q: 0, gain: 10},
+              {cutoff: 0.25, q: 10, gain: 10},
+            ];
+
+            createTestAndRun(context, 'peaking', {
+              should: should,
+              threshold: 5.8234e-8,
+              filterParameters: filterParameters
+            }).then(task.done.bind(task));
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-tail.html b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-tail.html
new file mode 100644
index 0000000000..3141bf7ff3
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquad-tail.html
@@ -0,0 +1,71 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Biquad Tail Output
+    </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 audit = Audit.createTaskRunner();
+
+      // A high sample rate shows the issue more clearly.
+      let sampleRate = 192000;
+      // Some short duration because we don't need to run the test for very
+      // long.
+      let testDurationSec = 0.5;
+      let testDurationFrames = testDurationSec * sampleRate;
+
+      // Amplitude experimentally determined to give a biquad output close to 1.
+      // (No attempt was made to produce exactly 1; it's not needed.)
+      let sourceAmplitude = 100;
+
+      // The output of the biquad filter should not change by more than this
+      // much between output samples.  Threshold was determined experimentally.
+      let glitchThreshold = 0.012968;
+
+      // Test that a Biquad filter doesn't have it's output terminated because
+      // the input has gone away.  Generally, when a source node is finished, it
+      // disconnects itself from any downstream nodes.  This is the correct
+      // behavior.  Nodes that have no inputs (disconnected) are generally
+      // assumed to output zeroes.  This is also desired behavior.  However,
+      // biquad filters have memory so they should not suddenly output zeroes
+      // when the input is disconnected.  This test checks to see if the output
+      // doesn't suddenly change to zero.
+      audit.define(
+          {label: 'test', description: 'Biquad Tail Output'},
+          function(task, should) {
+            let context =
+                new OfflineAudioContext(1, testDurationFrames, sampleRate);
+
+            // Create an impulse source.
+            let buffer = context.createBuffer(1, 1, context.sampleRate);
+            buffer.getChannelData(0)[0] = sourceAmplitude;
+            let source = context.createBufferSource();
+            source.buffer = buffer;
+
+            // Create the biquad filter. It doesn't really matter what kind, so
+            // the default filter type and parameters is fine.  Connect the
+            // source to it.
+            let biquad = context.createBiquadFilter();
+            source.connect(biquad);
+            biquad.connect(context.destination);
+
+            source.start();
+
+            context.startRendering().then(function(result) {
+              // There should be no large discontinuities in the output
+              should(result.getChannelData(0), 'Biquad output')
+                  .notGlitch(glitchThreshold);
+              task.done();
+            })
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquadfilternode-basic.html b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquadfilternode-basic.html
new file mode 100644
index 0000000000..7e71d07302
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/biquadfilternode-basic.html
@@ -0,0 +1,64 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      biquadfilternode-basic.html
+    </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 audit = Audit.createTaskRunner();
+
+      audit.define(
+          {label: 'test', description: 'Basic tests for BiquadFilterNode'},
+          function(task, should) {
+
+            let context = new AudioContext();
+            let filter = context.createBiquadFilter();
+
+            should(filter.numberOfInputs, 'Number of inputs').beEqualTo(1);
+
+            should(filter.numberOfOutputs, 'Number of outputs').beEqualTo(1);
+
+            should(filter.type, 'Default filter type').beEqualTo('lowpass');
+
+            should(filter.frequency.value, 'Default frequency value')
+                .beEqualTo(350);
+
+            should(filter.Q.value, 'Default Q value').beEqualTo(1);
+
+            should(filter.gain.value, 'Default gain value').beEqualTo(0);
+
+            // Check that all legal filter types can be set.
+            let filterTypeArray = [
+              {type: 'lowpass'}, {type: 'highpass'}, {type: 'bandpass'},
+              {type: 'lowshelf'}, {type: 'highshelf'}, {type: 'peaking'},
+              {type: 'notch'}, {type: 'allpass'}
+            ];
+
+            for (let i = 0; i < filterTypeArray.length; ++i) {
+              should(
+                  () => filter.type = filterTypeArray[i].type,
+                  'Setting filter.type to ' + filterTypeArray[i].type)
+                  .notThrow();
+              should(filter.type, 'Filter type is')
+                  .beEqualTo(filterTypeArray[i].type);
+            }
+
+
+            // Check that numerical values are no longer supported
+            filter.type = 99;
+            should(filter.type, 'Setting filter.type to (invalid) 99')
+                .notBeEqualTo(99);
+
+            task.done();
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/ctor-biquadfilter.html b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/ctor-biquadfilter.html
new file mode 100644
index 0000000000..e63479f985
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/ctor-biquadfilter.html
@@ -0,0 +1,86 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Constructor: BiquadFilter
+    </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, 'BiquadFilterNode', context);
+        task.done();
+      });
+
+      audit.define('default constructor', (task, should) => {
+        let prefix = 'node0';
+        let node = testDefaultConstructor(should, 'BiquadFilterNode', context, {
+          prefix: prefix,
+          numberOfInputs: 1,
+          numberOfOutputs: 1,
+          channelCount: 2,
+          channelCountMode: 'max',
+          channelInterpretation: 'speakers'
+        });
+
+        testDefaultAttributes(should, node, prefix, [
+          {name: 'type', value: 'lowpass'}, {name: 'Q', value: 1},
+          {name: 'detune', value: 0}, {name: 'frequency', value: 350},
+          {name: 'gain', value: 0.0}
+        ]);
+
+        task.done();
+      });
+
+      audit.define('test AudioNodeOptions', (task, should) => {
+        testAudioNodeOptions(should, context, 'BiquadFilterNode');
+        task.done();
+      });
+
+      audit.define('construct with options', (task, should) => {
+        let node;
+        let options = {
+          type: 'highpass',
+          frequency: 512,
+          detune: 1,
+          Q: 5,
+          gain: 3,
+        };
+
+        should(
+            () => {
+              node = new BiquadFilterNode(context, options);
+            },
+            'node = new BiquadFilterNode(..., ' + JSON.stringify(options) + ')')
+            .notThrow();
+
+        // Test that attributes are set according to the option values.
+        should(node.type, 'node.type').beEqualTo(options.type);
+        should(node.frequency.value, 'node.frequency.value')
+            .beEqualTo(options.frequency);
+        should(node.detune.value, 'node.detuen.value')
+            .beEqualTo(options.detune);
+        should(node.Q.value, 'node.Q.value').beEqualTo(options.Q);
+        should(node.gain.value, 'node.gain.value').beEqualTo(options.gain);
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/no-dezippering.html b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/no-dezippering.html
new file mode 100644
index 0000000000..79dc27035c
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-biquadfilternode-interface/no-dezippering.html
@@ -0,0 +1,288 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      biquad-bandpass.html
+    </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/biquad-filters.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      // In the tests below, the initial values are not important, except that
+      // we wanted them to be all different so that the output contains
+      // different values for the first few samples.  Otherwise, the actual
+      // values don't really matter.  A peaking filter is used because the
+      // frequency, Q, gain, and detune parameters are used by this filter.
+      //
+      // Also, for the changeList option, the times and new values aren't really
+      // important.  They just need to change so that we can verify that the
+      // outputs from the .value setter still matches the output from the
+      // corresponding setValueAtTime.
+      audit.define(
+          {label: 'Test 0', description: 'No dezippering for frequency'},
+          (task, should) => {
+            doTest(should, {
+              paramName: 'frequency',
+              initializer: {type: 'peaking', Q: 1, gain: 5},
+              changeList:
+                  [{quantum: 2, newValue: 800}, {quantum: 7, newValue: 200}],
+              threshold: 3.0399e-6
+            }).then(() => task.done());
+          });
+
+      audit.define(
+          {label: 'Test 1', description: 'No dezippering for detune'},
+          (task, should) => {
+            doTest(should, {
+              paramName: 'detune',
+              initializer:
+                  {type: 'peaking', frequency: 400, Q: 3, detune: 33, gain: 10},
+              changeList:
+                  [{quantum: 2, newValue: 1000}, {quantum: 5, newValue: -400}],
+              threshold: 4.0532e-6
+            }).then(() => task.done());
+          });
+
+      audit.define(
+          {label: 'Test 2', description: 'No dezippering for Q'},
+          (task, should) => {
+            doTest(should, {
+              paramName: 'Q',
+              initializer: {type: 'peaking', Q: 5},
+              changeList:
+                  [{quantum: 2, newValue: 10}, {quantum: 8, newValue: -10}]
+            }).then(() => task.done());
+          });
+
+      audit.define(
+          {label: 'Test 3', description: 'No dezippering for gain'},
+          (task, should) => {
+            doTest(should, {
+              paramName: 'gain',
+              initializer: {type: 'peaking', gain: 1},
+              changeList:
+                  [{quantum: 2, newValue: 5}, {quantum: 6, newValue: -.3}],
+              threshold: 1.9074e-6
+            }).then(() => task.done());
+          });
+
+      // This test compares the filter output against a JS implementation of the
+      // filter.  We're only testing a change in the frequency for a lowpass
+      // filter.  This assumes we don't need to test other AudioParam changes
+      // with JS code because any mistakes would be exposed in the tests above.
+      audit.define(
+          {
+            label: 'Test 4',
+            description: 'No dezippering of frequency vs JS filter'
+          },
+          (task, should) => {
+            // Channel 0 is the source, channel 1 is the filtered output.
+            let context = new OfflineAudioContext(2, 2048, 16384);
+
+            let merger = new ChannelMergerNode(
+                context, {numberOfInputs: context.destination.channelCount});
+            merger.connect(context.destination);
+
+            let src = new OscillatorNode(context);
+            let f = new BiquadFilterNode(context, {type: 'lowpass'});
+
+            // Remember the initial filter parameters.
+            let initialFilter = {
+              type: f.type,
+              frequency: f.frequency.value,
+              gain: f.gain.value,
+              detune: f.detune.value,
+              Q: f.Q.value
+            };
+
+            src.connect(merger, 0, 0);
+            src.connect(f).connect(merger, 0, 1);
+
+            // Apply the filter change at frame |changeFrame| with a new
+            // frequency value of |newValue|.
+            let changeFrame = 2 * RENDER_QUANTUM_FRAMES;
+            let newValue = 750;
+
+            context.suspend(changeFrame / context.sampleRate)
+                .then(() => f.frequency.value = newValue)
+                .then(() => context.resume());
+
+            src.start();
+
+            context.startRendering()
+                .then(audio => {
+                  let signal = audio.getChannelData(0);
+                  let actual = audio.getChannelData(1);
+
+                  // Get initial filter coefficients and updated coefficients
+                  let nyquistFreq = context.sampleRate / 2;
+                  let initialCoef = createFilter(
+                      initialFilter.type, initialFilter.frequency / nyquistFreq,
+                      initialFilter.Q, initialFilter.gain);
+
+                  let finalCoef = createFilter(
+                      f.type, f.frequency.value / nyquistFreq, f.Q.value,
+                      f.gain.value);
+
+                  let expected = new Float32Array(signal.length);
+
+                  // Filter the initial part of the signal.
+                  expected[0] =
+                      filterSample(signal[0], initialCoef, 0, 0, 0, 0);
+                  expected[1] = filterSample(
+                      signal[1], initialCoef, expected[0], 0, signal[0], 0);
+
+                  for (let k = 2; k < changeFrame; ++k) {
+                    expected[k] = filterSample(
+                        signal[k], initialCoef, expected[k - 1],
+                        expected[k - 2], signal[k - 1], signal[k - 2]);
+                  }
+
+                  // Filter the rest of the input with the new coefficients
+                  for (let k = changeFrame; k < signal.length; ++k) {
+                    expected[k] = filterSample(
+                        signal[k], finalCoef, expected[k - 1], expected[k - 2],
+                        signal[k - 1], signal[k - 2]);
+                  }
+
+                  // The JS filter should match the actual output.
+                  let match =
+                      should(actual, 'Output from ' + f.type + ' filter')
+                          .beCloseToArray(
+                              expected, {absoluteThreshold: 6.8546e-7});
+                  should(match, 'Output matches JS filter results').beTrue();
+                })
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {label: 'Test 5', description: 'Test with modulation'},
+          (task, should) => {
+            doTest(should, {
+              prefix: 'Modulation: ',
+              paramName: 'frequency',
+              initializer: {type: 'peaking', Q: 5, gain: 5},
+              modulation: true,
+              changeList:
+                  [{quantum: 2, newValue: 10}, {quantum: 8, newValue: -10}]
+            }).then(() => task.done());
+
+          });
+
+      audit.run();
+
+      // Run test, returning the promise from startRendering. |options|
+      // specifies the parameters for the test. |options.paramName| is the name
+      // of the AudioParam of the filter that is being tested.
+      // |options.initializer| is the initial value to be used in constructing
+      // the filter. |options.changeList| is an array consisting of dictionary
+      // with two members: |quantum| is the rendering quantum at which time we
+      // want to change the AudioParam value, and |newValue| is the value to be
+      // used.
+      function doTest(should, options) {
+        let paramName = options.paramName;
+        let newValue = options.newValue;
+        let prefix = options.prefix || '';
+
+        // Create offline audio context.  The sample rate should be a power of
+        // two to eliminate any round-off errors in computing the time at which
+        // to suspend the context for the parameter change.  The length is
+        // fairly arbitrary as long as it's big enough to the changeList
+        // values. There are two channels:  channel 0 is output for the filter
+        // under test, and channel 1 is the output of referencef filter.
+        let context = new OfflineAudioContext(2, 2048, 16384);
+
+        let merger = new ChannelMergerNode(
+            context, {numberOfInputs: context.destination.channelCount});
+        merger.connect(context.destination);
+
+        let src = new OscillatorNode(context);
+
+        // |f0| is the filter under test that will have its AudioParam value
+        // changed. |f1| is the reference filter that uses setValueAtTime to
+        // update the AudioParam value.
+        let f0 = new BiquadFilterNode(context, options.initializer);
+        let f1 = new BiquadFilterNode(context, options.initializer);
+
+        src.connect(f0).connect(merger, 0, 0);
+        src.connect(f1).connect(merger, 0, 1);
+
+        // Modulate the AudioParam with an input signal, if requested.
+        if (options.modulation) {
+          // The modulation signal is a sine wave with amplitude 1/3 the cutoff
+          // frequency of the test filter.  The amplitude is fairly arbitrary,
+          // but we want it to be a significant fraction of the cutoff so that
+          // the cutoff varies quite a bit in the test.
+          let mod =
+              new OscillatorNode(context, {type: 'sawtooth', frequency: 1000});
+          let modGain = new GainNode(context, {gain: f0.frequency.value / 3});
+          mod.connect(modGain);
+          modGain.connect(f0[paramName]);
+          modGain.connect(f1[paramName]);
+          mod.start();
+        }
+        // Output a message showing where we're starting from.
+        should(f0[paramName].value, prefix + `At time 0, ${paramName}`)
+            .beEqualTo(f0[paramName].value);
+
+        // Schedule all of the desired changes from |changeList|.
+        options.changeList.forEach(change => {
+          let changeTime =
+              change.quantum * RENDER_QUANTUM_FRAMES / context.sampleRate;
+          let value = change.newValue;
+
+          // Just output a message to show what we're doing.
+          should(value, prefix + `At time ${changeTime}, ${paramName}`)
+              .beEqualTo(value);
+
+          // Update the AudioParam value of each filter using setValueAtTime or
+          // the value setter.
+          f1[paramName].setValueAtTime(value, changeTime);
+          context.suspend(changeTime)
+              .then(() => f0[paramName].value = value)
+              .then(() => context.resume());
+        });
+
+        src.start();
+
+        return context.startRendering().then(audio => {
+          let actual = audio.getChannelData(0);
+          let expected = audio.getChannelData(1);
+
+          // The output from both filters MUST match exactly if dezippering has
+          // been properly removed.
+          let match = should(actual, `${prefix}Output from ${paramName} setter`)
+                          .beCloseToArray(
+                              expected, {absoluteThreshold: options.threshold});
+
+          // Just an extra message saying that what we're comparing, to make the
+          // output clearer. (Not really neceesary, but nice.)
+          should(
+              match,
+              `${prefix}Output from ${
+                                      paramName
+                                    } setter matches setValueAtTime output`)
+              .beTrue();
+        });
+      }
+
+      // Filter one sample:
+      //
+      //   y[n] = b0 * x[n] + b1*x[n-1] + b2*x[n-2] - a1*y[n-1] - a2*y[n-2]
+      //
+      // where |x| is x[n], |xn1| is x[n-1], |xn2| is x[n-2], |yn1| is y[n-1],
+      // and |yn2| is y[n-2].  |coef| is a dictonary of the filter coefficients
+      // |b0|, |b1|, |b2|, |a1|, and |a2|.
+      function filterSample(x, coef, yn1, yn2, xn1, xn2) {
+        return coef.b0 * x + coef.b1 * xn1 + coef.b2 * xn2 - coef.a1 * yn1 -
+            coef.a2 * yn2;
+      }
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-channelmergernode-interface/active-processing.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-channelmergernode-interface/active-processing.https.html
new file mode 100644
index 0000000000..9012526bdc
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-channelmergernode-interface/active-processing.https.html
@@ -0,0 +1,93 @@
+<!doctype html>
+<html>
+  <head>
+    <title>
+      Test Active Processing for ChannelMergerNode
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+  </head>
+
+  <body>
+    <script id="layout-test-code">
+      // AudioProcessor that sends a message to its AudioWorkletNode whenver the
+      // number of channels on its input changes.
+      let filePath =
+          '../the-audioworklet-interface/processors/active-processing.js';
+
+      const audit = Audit.createTaskRunner();
+
+      let context;
+
+      audit.define('initialize', (task, should) => {
+        // Create context and load the module
+        context = new AudioContext();
+        should(
+            context.audioWorklet.addModule(filePath),
+            'AudioWorklet module loading')
+            .beResolved()
+            .then(() => task.done());
+      });
+
+      audit.define('test', (task, should) => {
+        const src = new OscillatorNode(context);
+
+        // Number of inputs for the ChannelMergerNode.  Pretty arbitrary, but
+        // should not be 1.
+        const numberOfInputs = 7;
+        const merger =
+            new ChannelMergerNode(context, {numberOfInputs: numberOfInputs});
+
+        const testerNode =
+            new AudioWorkletNode(context, 'active-processing-tester', {
+              // Use as short a duration as possible to keep the test from
+              // taking too much time.
+              processorOptions: {testDuration: .5},
+            });
+
+        // Expected number of output channels from the merger node.  We should
+        // start with the number of inputs, because the source (oscillator) is
+        // actively processing.  When the source stops, the number of channels
+        // should change to 0.
+        const expectedValues = [numberOfInputs, 0];
+        let index = 0;
+
+        testerNode.port.onmessage = event => {
+          let count = event.data.channelCount;
+          let finished = event.data.finished;
+
+          // If we're finished, end testing.
+          if (finished) {
+            // Verify that we got the expected number of changes.
+            should(index, 'Number of distinct values')
+                .beEqualTo(expectedValues.length);
+
+            task.done();
+            return;
+          }
+
+          if (index < expectedValues.length) {
+            // Verify that the number of channels matches the expected number of
+            // channels.
+            should(count, `Test ${index}: Number of convolver output channels`)
+                .beEqualTo(expectedValues[index]);
+          }
+
+          ++index;
+        };
+
+        // Create the graph and go
+        src.connect(merger).connect(testerNode).connect(context.destination);
+        src.start();
+
+        // Stop the source after a short time so we can test that the channel
+        // merger changes to not actively processing and thus produces a single
+        // channel of silence.
+        src.stop(context.currentTime + .1);
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-channelmergernode-interface/audiochannelmerger-basic.html b/testing/web-platform/tests/webaudio/the-audio-api/the-channelmergernode-interface/audiochannelmerger-basic.html
new file mode 100644
index 0000000000..71a62f176f
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-channelmergernode-interface/audiochannelmerger-basic.html
@@ -0,0 +1,67 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      audiochannelmerger-basic.html
+    </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 audit = Audit.createTaskRunner();
+
+      // Task: Checking constraints in ChannelMergerNode.
+      audit.define('exceptions-channels', (task, should) => {
+        let context = new OfflineAudioContext(2, 128, 44100);
+        let merger;
+
+        should(function() {
+          merger = context.createChannelMerger();
+        }, 'context.createChannelMerger()').notThrow();
+
+        should(function() {
+          merger = context.createChannelMerger(0);
+        }, 'context.createChannelMerger(0)').throw(DOMException, 'IndexSizeError');
+
+        should(function() {
+          merger = context.createChannelMerger(32);
+        }, 'context.createChannelMerger(32)').notThrow();
+
+        // Can't create a channel merger with 33 channels because the audio
+        // context has a 32-channel-limit in Chrome.
+        should(function() {
+          merger = context.createChannelMerger(33);
+        }, 'context.createChannelMerger(33)').throw(DOMException, 'IndexSizeError');
+
+        task.done();
+      });
+
+      // Task: checking the channel-related properties have the correct value
+      // and can't be changed.
+      audit.define('exceptions-properties', (task, should) => {
+        let context = new OfflineAudioContext(2, 128, 44100);
+        let merger = context.createChannelMerger();
+
+        should(merger.channelCount, 'merger.channelCount').beEqualTo(1);
+
+        should(function() {
+          merger.channelCount = 3;
+        }, 'merger.channelCount = 3').throw(DOMException, 'InvalidStateError');
+
+        should(merger.channelCountMode, 'merger.channelCountMode')
+            .beEqualTo('explicit');
+
+        should(function() {
+          merger.channelCountMode = 'max';
+        }, 'merger.channelCountMode = "max"').throw(DOMException, 'InvalidStateError');
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-channelmergernode-interface/audiochannelmerger-disconnect.html b/testing/web-platform/tests/webaudio/the-audio-api/the-channelmergernode-interface/audiochannelmerger-disconnect.html
new file mode 100644
index 0000000000..ad74d5e004
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-channelmergernode-interface/audiochannelmerger-disconnect.html
@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      audiochannelmerger-disconnect.html
+    </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 renderQuantum = 128;
+
+      let numberOfChannels = 2;
+      let sampleRate = 44100;
+      let renderDuration = 0.5;
+      let disconnectTime = 0.5 * renderDuration;
+
+      let audit = Audit.createTaskRunner();
+
+      // Task: Check if the merger outputs a silent channel when an input is
+      // disconnected.
+      audit.define('silent-disconnect', (task, should) => {
+        let context = new OfflineAudioContext(
+            numberOfChannels, renderDuration * sampleRate, sampleRate);
+        let merger = context.createChannelMerger();
+        let source1 = context.createBufferSource();
+        let source2 = context.createBufferSource();
+
+        // Create and assign a constant buffer.
+        let bufferDCOffset = createConstantBuffer(context, 1, 1);
+        source1.buffer = source2.buffer = bufferDCOffset;
+        source1.loop = source2.loop = true;
+
+        // Connect the output of source into the 4th input of merger. The merger
+        // should produce 6 channel output.
+        source1.connect(merger, 0, 0);
+        source2.connect(merger, 0, 1);
+        merger.connect(context.destination);
+        source1.start();
+        source2.start();
+
+        // Schedule the disconnection of |source2| at the half of render
+        // duration.
+        context.suspend(disconnectTime).then(function() {
+          source2.disconnect();
+          context.resume();
+        });
+
+        context.startRendering()
+            .then(function(buffer) {
+              // The entire first channel of the output should be 1.
+              should(buffer.getChannelData(0), 'Channel #0')
+                  .beConstantValueOf(1);
+
+              // Calculate the first zero index in the second channel.
+              let channel1 = buffer.getChannelData(1);
+              let disconnectIndex = disconnectTime * sampleRate;
+              disconnectIndex = renderQuantum *
+                  Math.floor(
+                      (disconnectIndex + renderQuantum - 1) / renderQuantum);
+              let firstZeroIndex = channel1.findIndex(function(element, index) {
+                if (element === 0)
+                  return index;
+              });
+
+              // The second channel should contain 1, and 0 after the
+              // disconnection.
+              should(channel1, 'Channel #1').containValues([1, 0]);
+              should(
+                  firstZeroIndex, 'The index of first zero in the channel #1')
+                  .beEqualTo(disconnectIndex);
+            })
+            .then(() => task.done());
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-channelmergernode-interface/audiochannelmerger-input-non-default.html b/testing/web-platform/tests/webaudio/the-audio-api/the-channelmergernode-interface/audiochannelmerger-input-non-default.html
new file mode 100644
index 0000000000..6fe77ab763
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-channelmergernode-interface/audiochannelmerger-input-non-default.html
@@ -0,0 +1,79 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      audiochannelmerger-input-non-default.html
+    </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/merger-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+
+      // Task: Check if an inactive input renders a silent mono channel in the
+      // output.
+      audit.define('silent-channel', (task, should) => {
+        testMergerInput(should, {
+          numberOfChannels: 7,
+
+          // Create a mono source buffer filled with '1'.
+          testBufferContent: [1],
+
+          // Connect the output of source into the 7th input of merger.
+          mergerInputIndex: 6,
+
+          // 7th channel should be '1'.
+          expected: [0, 0, 0, 0, 0, 0, 1],
+        }).then(() => task.done());
+      });
+
+
+      // Task: Check if a stereo input is being down-mixed to mono channel
+      // correctly based on the mixing rule.
+      audit.define('stereo-down-mixing', (task, should) => {
+        testMergerInput(should, {
+          numberOfChannels: 7,
+
+          // Create a stereo buffer filled with '1' and '2' for left and right
+          // channels respectively.
+          testBufferContent: [1, 2],
+
+          // Connect the output of source into the 7th input of merger.
+          mergerInputIndex: 6,
+
+          // The result of summed and down-mixed stereo audio should be 1.5.
+          // (= 1 * 0.5 + 2 * 0.5)
+          expected: [0, 0, 0, 0, 0, 0, 1.5],
+        }).then(() => task.done());
+      });
+
+
+      // Task: Check if 3-channel input gets processed by the 'discrete' mixing
+      // rule.
+      audit.define('undefined-channel-layout', (task, should) => {
+        testMergerInput(should, {
+          numberOfChannels: 7,
+
+          // Create a 3-channel buffer filled with '1', '2', and '3'
+          // respectively.
+          testBufferContent: [1, 2, 3],
+
+          // Connect the output of source into the 7th input of merger.
+          mergerInputIndex: 6,
+
+          // The result of summed stereo audio should be 1 because 3-channel is
+          // not a canonical layout, so the input channel 2 and 3 should be
+          // dropped by 'discrete' mixing rule.
+          expected: [0, 0, 0, 0, 0, 0, 1],
+        }).then(() => task.done());
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-channelmergernode-interface/audiochannelmerger-input.html b/testing/web-platform/tests/webaudio/the-audio-api/the-channelmergernode-interface/audiochannelmerger-input.html
new file mode 100644
index 0000000000..66a70dcb3b
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-channelmergernode-interface/audiochannelmerger-input.html
@@ -0,0 +1,113 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      audiochannelmerger-input.html
+    </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/merger-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      // Task: Check if an inactive input renders a silent mono channel in the
+      // output.
+      audit.define('silent-channel', (task, should) => {
+        testMergerInput(should, {
+          numberOfChannels: 6,
+
+          // Create a mono source buffer filled with '1'.
+          testBufferContent: [1],
+
+          // Connect the output of source into the 4th input of merger.
+          mergerInputIndex: 3,
+
+          // All channels should contain 0, except channel 4 which should be 1.
+          expected: [0, 0, 0, 1, 0, 0],
+        }).then(() => task.done());
+      });
+
+
+      // Task: Check if a stereo input is being down-mixed to mono channel
+      // correctly based on the mixing rule.
+      audit.define('stereo-down-mixing', (task, should) => {
+        testMergerInput(should, {
+          numberOfChannels: 6,
+
+          // Create a stereo buffer filled with '1' and '2' for left and right
+          // channels respectively.
+          testBufferContent: [1, 2],
+
+          // Connect the output of source into the 1st input of merger.
+          mergerInputIndex: undefined,
+
+          // The result of summed and down-mixed stereo audio should be 1.5.
+          // (= 1 * 0.5 + 2 * 0.5)
+          expected: [1.5, 0, 0, 0, 0, 0],
+        }).then(() => task.done());
+      });
+
+
+      // Task: Check if 3-channel input gets processed by the 'discrete' mixing
+      // rule.
+      audit.define('undefined-channel-layout', (task, should) => {
+        testMergerInput(should, {
+          numberOfChannels: 6,
+
+          // Create a 3-channel buffer filled with '1', '2', and '3'
+          // respectively.
+          testBufferContent: [1, 2, 3],
+
+          // Connect the output of source into the 1st input of merger.
+          mergerInputIndex: undefined,
+
+          // The result of summed stereo audio should be 1 because 3-channel is
+          // not a canonical layout, so the input channel 2 and 3 should be
+          // dropped by 'discrete' mixing rule.
+          expected: [1, 0, 0, 0, 0, 0],
+        }).then(() => task.done());
+      });
+
+
+      // Task: Merging two inputs into a single stereo stream.
+      audit.define('merging-to-stereo', (task, should) => {
+
+        // For this test, the number of channel should be 2.
+        let context = new OfflineAudioContext(2, 128, 44100);
+        let merger = context.createChannelMerger();
+        let source1 = context.createBufferSource();
+        let source2 = context.createBufferSource();
+
+        // Create a DC offset buffer (mono) filled with 1 and assign it to BS
+        // nodes.
+        let positiveDCOffset = createConstantBuffer(context, 128, 1);
+        let negativeDCOffset = createConstantBuffer(context, 128, -1);
+        source1.buffer = positiveDCOffset;
+        source2.buffer = negativeDCOffset;
+
+        // Connect: BS#1 => merger_input#0, BS#2 => Inverter => merger_input#1
+        source1.connect(merger, 0, 0);
+        source2.connect(merger, 0, 1);
+        merger.connect(context.destination);
+        source1.start();
+        source2.start();
+
+        context.startRendering().then(function(buffer) {
+
+          // Channel#0 = 1, Channel#1 = -1
+          should(buffer.getChannelData(0), 'Channel #0').beConstantValueOf(1);
+          should(buffer.getChannelData(1), 'Channel #1').beConstantValueOf(-1);
+
+          task.done();
+        });
+      });
+
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-channelmergernode-interface/ctor-channelmerger.html b/testing/web-platform/tests/webaudio/the-audio-api/the-channelmergernode-interface/ctor-channelmerger.html
new file mode 100644
index 0000000000..0d6b45c56d
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-channelmergernode-interface/ctor-channelmerger.html
@@ -0,0 +1,112 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Constructor: ChannelMerger
+    </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, 'ChannelMergerNode', context);
+        task.done();
+      });
+
+      audit.define('default constructor', (task, should) => {
+        let prefix = 'node0';
+        let node =
+            testDefaultConstructor(should, 'ChannelMergerNode', context, {
+              prefix: prefix,
+              numberOfInputs: 6,
+              numberOfOutputs: 1,
+              channelCount: 1,
+              channelCountMode: 'explicit',
+              channelInterpretation: 'speakers'
+            });
+
+        task.done();
+      });
+
+      audit.define('test AudioNodeOptions', (task, should) => {
+        testAudioNodeOptions(should, context, 'ChannelMergerNode', {
+          channelCount: {
+            value: 1,
+            isFixed: true,
+            exceptionType: 'InvalidStateError'
+          },
+          channelCountMode: {
+            value: 'explicit',
+            isFixed: true,
+            exceptionType: 'InvalidStateError'
+          }
+        });
+        task.done();
+      });
+
+      audit.define('constructor options', (task, should) => {
+        let node;
+        let options = {
+          numberOfInputs: 3,
+          numberOfOutputs: 9,
+          channelInterpretation: 'discrete'
+        };
+
+        should(
+            () => {
+              node = new ChannelMergerNode(context, options);
+            },
+            'node1 = new ChannelMergerNode(context, ' +
+                JSON.stringify(options) + ')')
+            .notThrow();
+
+        should(node.numberOfInputs, 'node1.numberOfInputs')
+            .beEqualTo(options.numberOfInputs);
+        should(node.numberOfOutputs, 'node1.numberOfOutputs').beEqualTo(1);
+        should(node.channelInterpretation, 'node1.channelInterpretation')
+            .beEqualTo(options.channelInterpretation);
+
+        options = {numberOfInputs: 99};
+        should(
+            () => {
+              node = new ChannelMergerNode(context, options);
+            },
+            'new ChannelMergerNode(c, ' + JSON.stringify(options) + ')')
+            .throw(DOMException, 'IndexSizeError');
+
+        options = {channelCount: 3};
+        should(
+            () => {
+              node = new ChannelMergerNode(context, options);
+            },
+            'new ChannelMergerNode(c, ' + JSON.stringify(options) + ')')
+            .throw(DOMException, 'InvalidStateError');
+
+        options = {channelCountMode: 'max'};
+        should(
+            () => {
+              node = new ChannelMergerNode(context, options);
+            },
+            'new ChannelMergerNode(c, ' + JSON.stringify(options) + ')')
+            .throw(DOMException, 'InvalidStateError');
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-channelsplitternode-interface/audiochannelsplitter.html b/testing/web-platform/tests/webaudio/the-audio-api/the-channelsplitternode-interface/audiochannelsplitter.html
new file mode 100644
index 0000000000..954c71a96b
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-channelsplitternode-interface/audiochannelsplitter.html
@@ -0,0 +1,141 @@
+<!DOCTYPE html>
+<!--
+Tests that AudioChannelSplitter works correctly.
+-->
+<html>
+  <head>
+    <title>
+      audiochannelsplitter.html
+    </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 audit = Audit.createTaskRunner();
+
+      let sampleRate = 44100.0;
+      let lengthInSampleFrames = 512;
+
+      let context = 0;
+      let sourceBuffer;
+      let sourceNode;
+      let channelSplitter;
+      let channelMerger;
+
+      function createStereoBufferWithDCOffset(length, sampleRate, offset) {
+        let buffer = context.createBuffer(2, length, sampleRate);
+        let n = buffer.length;
+        let channelL = buffer.getChannelData(0);
+        let channelR = buffer.getChannelData(1);
+
+        for (let i = 0; i < n; ++i) {
+          channelL[i] = offset;
+          channelR[i] = -1.0 * offset;
+        }
+
+        return buffer;
+      }
+
+      // checkResult() checks that the rendered buffer is stereo and that the
+      // left channel is all -1 and right channel all +1. In other words, we've
+      // reversed the order of the two channels.
+      function checkResult(buffer, should) {
+        let success = true;
+
+        if (buffer.numberOfChannels == 2) {
+          let bufferDataL = buffer.getChannelData(0);
+          let bufferDataR = buffer.getChannelData(1);
+
+          success = should(bufferDataL, 'Left channel').beConstantValueOf(-1) &&
+              success;
+          success = should(bufferDataR, 'Right channel').beConstantValueOf(1) &&
+              success;
+        } else {
+          success = false;
+        }
+
+        should(success, 'Left and right channels were exchanged')
+            .message('correctly', 'incorrectly');
+      }
+
+      audit.define(
+          {
+            label: 'construction',
+            description: 'Construction of ChannelSplitterNode'
+          },
+          function(task, should) {
+
+            // Create stereo offline audio context.
+            context =
+                new OfflineAudioContext(2, lengthInSampleFrames, sampleRate);
+
+            let splitternode;
+            should(() => {
+              let splitternode = context.createChannelSplitter(0);
+            }, 'createChannelSplitter(0)').throw(DOMException, 'IndexSizeError');
+
+            should(() => {
+              splitternode = context.createChannelSplitter(33);
+            }, 'createChannelSplitter(33)').throw(DOMException, 'IndexSizeError');
+
+            should(() => {
+              splitternode = context.createChannelSplitter(32);
+            }, 'splitternode = context.createChannelSplitter(32)').notThrow();
+
+            should(splitternode.numberOfOutputs, 'splitternode.numberOfOutputs')
+                .beEqualTo(32);
+            should(splitternode.numberOfInputs, 'splitternode.numberOfInputs')
+                .beEqualTo(1)
+
+            should(() => {
+              splitternode = context.createChannelSplitter();
+            }, 'splitternode = context.createChannelSplitter()').notThrow();
+
+            should(splitternode.numberOfOutputs, 'splitternode.numberOfOutputs')
+                .beEqualTo(6);
+
+            task.done();
+          });
+
+      audit.define(
+          {
+            label: 'functionality',
+            description: 'Functionality of ChannelSplitterNode'
+          },
+          function(task, should) {
+
+            // Create a stereo buffer, with all +1 values in left channel, all
+            // -1 in right channel.
+            sourceBuffer = createStereoBufferWithDCOffset(
+                lengthInSampleFrames, sampleRate, 1);
+
+            sourceNode = context.createBufferSource();
+            sourceNode.buffer = sourceBuffer;
+
+            // Create a channel splitter and connect it so that it split the
+            // stereo stream into two mono streams.
+            channelSplitter = context.createChannelSplitter(2);
+            sourceNode.connect(channelSplitter);
+
+            // Create a channel merger to merge the output of channel splitter.
+            channelMerger = context.createChannelMerger();
+            channelMerger.connect(context.destination);
+
+            // When merging, exchange channel layout: left->right, right->left
+            channelSplitter.connect(channelMerger, 0, 1);
+            channelSplitter.connect(channelMerger, 1, 0);
+
+            sourceNode.start(0);
+
+            context.startRendering()
+                .then(buffer => checkResult(buffer, should))
+                .then(task.done.bind(task));
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-channelsplitternode-interface/ctor-channelsplitter.html b/testing/web-platform/tests/webaudio/the-audio-api/the-channelsplitternode-interface/ctor-channelsplitter.html
new file mode 100644
index 0000000000..b7165bac33
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-channelsplitternode-interface/ctor-channelsplitter.html
@@ -0,0 +1,115 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Constructor: ChannelSplitter
+    </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, 'ChannelSplitterNode', context);
+        task.done();
+      });
+
+      audit.define('default constructor', (task, should) => {
+        testDefaultConstructor(should, 'ChannelSplitterNode', context, {
+          prefix: 'node0',
+          numberOfInputs: 1,
+          numberOfOutputs: 6,
+          channelCount: 6,
+          channelCountMode: 'explicit',
+          channelInterpretation: 'discrete'
+        });
+
+        task.done();
+      });
+
+      audit.define('test AudioNodeOptions', (task, should) => {
+        testAudioNodeOptions(should, context, 'ChannelSplitterNode', {
+          channelCount: {
+            value: 6,
+            isFixed: true,
+            exceptionType: 'InvalidStateError'
+          },
+          channelCountMode: {
+            value: 'explicit',
+            isFixed: true,
+            exceptionType: 'InvalidStateError'
+          },
+          channelInterpretation: {
+            value: 'discrete',
+            isFixed: true,
+            exceptionType: 'InvalidStateError'
+          },
+        });
+        task.done();
+      });
+
+      audit.define('constructor options', (task, should) => {
+        let node;
+        let options = {
+          numberOfInputs: 3,
+          numberOfOutputs: 9,
+          channelInterpretation: 'discrete'
+        };
+
+        should(
+            () => {
+              node = new ChannelSplitterNode(context, options);
+            },
+            'node1 = new ChannelSplitterNode(context, ' +
+                JSON.stringify(options) + ')')
+            .notThrow();
+
+        should(node.numberOfInputs, 'node1.numberOfInputs').beEqualTo(1);
+        should(node.numberOfOutputs, 'node1.numberOfOutputs')
+            .beEqualTo(options.numberOfOutputs);
+        should(node.channelInterpretation, 'node1.channelInterpretation')
+            .beEqualTo(options.channelInterpretation);
+
+        options = {numberOfOutputs: 99};
+        should(
+            () => {
+              node = new ChannelSplitterNode(context, options);
+            },
+            'new ChannelSplitterNode(c, ' + JSON.stringify(options) + ')')
+            .throw(DOMException, 'IndexSizeError');
+
+        options = {channelCount: 3};
+        should(
+            () => {
+              node = new ChannelSplitterNode(context, options);
+            },
+            'new ChannelSplitterNode(c, ' + JSON.stringify(options) + ')')
+            .throw(DOMException, 'InvalidStateError');
+
+        options = {channelCountMode: 'max'};
+        should(
+            () => {
+              node = new ChannelSplitterNode(context, options);
+            },
+            'new ChannelSplitterNode(c, ' + JSON.stringify(options) + ')')
+            .throw(DOMException, 'InvalidStateError');
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-constantsourcenode-interface/constant-source-basic.html b/testing/web-platform/tests/webaudio/the-audio-api/the-constantsourcenode-interface/constant-source-basic.html
new file mode 100644
index 0000000000..4f925df5cd
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-constantsourcenode-interface/constant-source-basic.html
@@ -0,0 +1,85 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Basic ConstantSourceNode Tests
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="../../resources/audit-util.js"></script>
+    <script src="../../resources/audit.js"></script>
+    <script src="../../resources/start-stop-exceptions.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let context = new AudioContext();
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define('createConstantSource()', (task, should) => {
+        let node;
+        let prefix = 'Factory method: ';
+
+        should(() => {
+          node = context.createConstantSource();
+        }, prefix + 'node = context.createConstantSource()').notThrow();
+        should(
+            node instanceof ConstantSourceNode,
+            prefix + 'node instance of ConstantSourceNode')
+            .beEqualTo(true);
+
+        verifyNodeDefaults(should, node, prefix);
+
+        task.done();
+      });
+
+      audit.define('new ConstantSourceNode()', (task, should) => {
+        let node;
+        let prefix = 'Constructor: ';
+
+        should(() => {
+          node = new ConstantSourceNode(context);
+        }, prefix + 'node = new ConstantSourceNode()').notThrow();
+        should(
+            node instanceof ConstantSourceNode,
+            prefix + 'node instance of ConstantSourceNode')
+            .beEqualTo(true);
+
+
+        verifyNodeDefaults(should, node, prefix);
+
+        task.done();
+      });
+
+      audit.define('start/stop exceptions', (task, should) => {
+        let node = new ConstantSourceNode(context);
+
+        testStartStop(should, node);
+        task.done();
+      });
+
+      function verifyNodeDefaults(should, node, prefix) {
+        should(node.numberOfInputs, prefix + 'node.numberOfInputs')
+            .beEqualTo(0);
+        should(node.numberOfOutputs, prefix + 'node.numberOfOutputs')
+            .beEqualTo(1);
+        should(node.channelCount, prefix + 'node.channelCount').beEqualTo(2);
+        should(node.channelCountMode, prefix + 'node.channelCountMode')
+            .beEqualTo('max');
+        should(
+            node.channelInterpretation, prefix + 'node.channelInterpretation')
+            .beEqualTo('speakers');
+
+        should(node.offset.value, prefix + 'node.offset.value').beEqualTo(1);
+        should(node.offset.defaultValue, prefix + 'node.offset.defaultValue')
+            .beEqualTo(1);
+        should(node.offset.minValue, prefix + 'node.offset.minValue')
+            .beEqualTo(Math.fround(-3.4028235e38));
+        should(node.offset.maxValue, prefix + 'node.offset.maxValue')
+            .beEqualTo(Math.fround(3.4028235e38));
+      }
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-constantsourcenode-interface/constant-source-onended.html b/testing/web-platform/tests/webaudio/the-audio-api/the-constantsourcenode-interface/constant-source-onended.html
new file mode 100644
index 0000000000..64bc54f21b
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-constantsourcenode-interface/constant-source-onended.html
@@ -0,0 +1,38 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test ConstantSourceNode onended
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let sampleRate = 44100.0;
+      // Number of frames that the source will run; fairly arbitrary
+      let numberOfFrames = 32;
+      // Number of frames to render; arbitrary, but should be larger than
+      // numberOfFrames;
+      let renderFrames = 16 * numberOfFrames;
+
+      let context = new OfflineAudioContext(1, renderFrames, sampleRate);
+      let src = new ConstantSourceNode(context);
+      src.connect(context.destination);
+
+      let tester = async_test('ConstantSourceNode onended event fired');
+
+      src.onended = function() {
+        tester.step(function() {
+          assert_true(true, 'ConstantSourceNode.onended fired');
+        });
+        tester.done();
+      };
+
+      src.start();
+      src.stop(numberOfFrames / context.sampleRate);
+
+      context.startRendering();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-constantsourcenode-interface/constant-source-output.html b/testing/web-platform/tests/webaudio/the-audio-api/the-constantsourcenode-interface/constant-source-output.html
new file mode 100644
index 0000000000..5990376cff
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-constantsourcenode-interface/constant-source-output.html
@@ -0,0 +1,207 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test ConstantSourceNode Output
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="../../resources/audit-util.js"></script>
+    <script src="../../resources/audit.js"></script>
+    <script src="../../resources/audioparam-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let sampleRate = 48000;
+      let renderDuration = 0.125;
+      let renderFrames = sampleRate * renderDuration;
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define('constant source', (task, should) => {
+        // Verify a constant source outputs the correct (fixed) constant.
+        let context = new OfflineAudioContext(1, renderFrames, sampleRate);
+        let node = new ConstantSourceNode(context, {offset: 0.5});
+        node.connect(context.destination);
+        node.start();
+
+        context.startRendering()
+            .then(function(buffer) {
+              let actual = buffer.getChannelData(0);
+              let expected = new Float32Array(actual.length);
+              expected.fill(node.offset.value);
+
+              should(actual, 'Basic: ConstantSourceNode({offset: 0.5})')
+                  .beEqualToArray(expected);
+            })
+            .then(() => task.done());
+      });
+
+      audit.define('stop before start', (task, should) => {
+        let context = new OfflineAudioContext(1, renderFrames, sampleRate);
+        let node = new ConstantSourceNode(context, {offset: 1});
+        node.connect(context.destination);
+        node.start(61 / context.sampleRate);
+        node.stop(31 / context.sampleRate);
+
+        context.startRendering()
+            .then(function(buffer) {
+                let actual = buffer.getChannelData(0);
+                should(actual,
+                       "ConstantSourceNode with stop before " +
+                           "start must output silence")
+                  .beConstantValueOf(0);
+            })
+            .then(() => task.done());
+      });
+
+      audit.define('stop equal to start', (task, should) => {
+          let context = new OfflineAudioContext(1, renderFrames, sampleRate);
+          let node = new ConstantSourceNode(context, {offset: 1});
+          node.connect(context.destination);
+          node.start(31 / context.sampleRate);
+          node.stop(31 / context.sampleRate);
+
+          context.startRendering()
+              .then(function(buffer) {
+                  let actual = buffer.getChannelData(0);
+                  should(actual,
+                         "ConstantSourceNode with stop equal to start " +
+                             " must output silence")
+                      .beConstantValueOf(0);
+          })
+          .then(() => task.done());
+      });
+
+      audit.define('start/stop', (task, should) => {
+        // Verify a constant source starts and stops at the correct time and has
+        // the correct (fixed) value.
+        let context = new OfflineAudioContext(1, renderFrames, sampleRate);
+        let node = new ConstantSourceNode(context, {offset: 1});
+        node.connect(context.destination);
+
+        let startFrame = 10;
+        let stopFrame = 300;
+
+        node.start(startFrame / context.sampleRate);
+        node.stop(stopFrame / context.sampleRate);
+
+        context.startRendering()
+            .then(function(buffer) {
+              let actual = buffer.getChannelData(0);
+              let expected = new Float32Array(actual.length);
+              // The expected output is all 1s from start to stop time.
+              expected.fill(0);
+
+              for (let k = startFrame; k < stopFrame; ++k) {
+                expected[k] = node.offset.value;
+              }
+
+              let prefix = 'start/stop: ';
+              should(actual.slice(0, startFrame),
+                     prefix + 'ConstantSourceNode frames [0, ' +
+                       startFrame + ')')
+                  .beConstantValueOf(0);
+
+              should(actual.slice(startFrame, stopFrame),
+                     prefix + 'ConstantSourceNode frames [' +
+                         startFrame + ', ' + stopFrame + ')')
+                  .beConstantValueOf(1);
+
+              should(
+                  actual.slice(stopFrame),
+                  prefix + 'ConstantSourceNode frames [' + stopFrame +
+                      ', ' + renderFrames + ')')
+                  .beConstantValueOf(0);
+            })
+            .then(() => task.done());
+
+      });
+
+      audit.define('basic automation', (task, should) => {
+        // Verify that automation works as expected.
+        let context = new OfflineAudioContext(1, renderFrames, sampleRate);
+        let source = context.createConstantSource();
+        source.connect(context.destination);
+
+        let rampEndTime = renderDuration / 2;
+        source.offset.setValueAtTime(0.5, 0);
+        source.offset.linearRampToValueAtTime(1, rampEndTime);
+
+        source.start();
+
+        context.startRendering()
+            .then(function(buffer) {
+              let actual = buffer.getChannelData(0);
+              let expected = createLinearRampArray(
+                  0, rampEndTime, 0.5, 1, context.sampleRate);
+
+              let rampEndFrame = Math.ceil(rampEndTime * context.sampleRate);
+              let prefix = 'Automation: ';
+
+              should(actual.slice(0, rampEndFrame),
+                     prefix + 'ConstantSourceNode.linearRamp(1, 0.5)')
+                  .beCloseToArray(expected, {
+                    // Experimentally determined threshold.
+                    relativeThreshold: 7.1610e-7
+                  });
+
+              should(actual.slice(rampEndFrame),
+                     prefix + 'ConstantSourceNode after ramp')
+                .beConstantValueOf(1);
+            })
+            .then(() => task.done());
+      });
+
+      audit.define('connected audioparam', (task, should) => {
+        // Verify the constant source output with connected AudioParam produces
+        // the correct output.
+        let context = new OfflineAudioContext(2, renderFrames, sampleRate)
+        context.destination.channelInterpretation = 'discrete';
+        let source = new ConstantSourceNode(context, {offset: 1});
+        let osc = context.createOscillator();
+        let merger = context.createChannelMerger(2);
+        merger.connect(context.destination);
+
+        source.connect(merger, 0, 0);
+        osc.connect(merger, 0, 1);
+        osc.connect(source.offset);
+
+        osc.start();
+        let sourceStartFrame = 10;
+        source.start(sourceStartFrame / context.sampleRate);
+
+        context.startRendering()
+            .then(function(buffer) {
+              // Channel 0 and 1 should be identical, except channel 0 (the
+              // source) is silent at the beginning.
+              let actual = buffer.getChannelData(0);
+              let expected = buffer.getChannelData(1);
+              // The expected output should be oscillator + 1 because offset
+              // is 1.
+              expected = expected.map(x => 1 + x);
+              let prefix = 'Connected param: ';
+
+              // The initial part of the output should be silent because the
+              // source node hasn't started yet.
+              should(
+                  actual.slice(0, sourceStartFrame),
+                  prefix + 'ConstantSourceNode frames [0, ' + sourceStartFrame +
+                      ')')
+                  .beConstantValueOf(0);
+              // The rest of the output should be the same as the oscillator (in
+              // channel 1)
+              should(
+                  actual.slice(sourceStartFrame),
+                  prefix + 'ConstantSourceNode frames [' + sourceStartFrame +
+                      ', ' + renderFrames + ')')
+                  .beCloseToArray(expected.slice(sourceStartFrame), 0);
+
+            })
+            .then(() => task.done());
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-constantsourcenode-interface/ctor-constantsource.html b/testing/web-platform/tests/webaudio/the-audio-api/the-constantsourcenode-interface/ctor-constantsource.html
new file mode 100644
index 0000000000..ea4a65e146
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-constantsourcenode-interface/ctor-constantsource.html
@@ -0,0 +1,50 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Constructor: ConstantSource
+    </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, 'ConstantSourceNode', context);
+        task.done();
+      });
+
+      audit.define('default constructor', (task, should) => {
+        let prefix = 'node0';
+        let node =
+            testDefaultConstructor(should, 'ConstantSourceNode', context, {
+              prefix: prefix,
+              numberOfInputs: 0,
+              numberOfOutputs: 1,
+              channelCount: 2,
+              channelCountMode: 'max',
+              channelInterpretation: 'speakers'
+            });
+
+        testDefaultAttributes(
+            should, node, prefix, [{name: 'offset', value: 1}]);
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-constantsourcenode-interface/test-constantsourcenode.html b/testing/web-platform/tests/webaudio/the-audio-api/the-constantsourcenode-interface/test-constantsourcenode.html
new file mode 100644
index 0000000000..04f61106c1
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-constantsourcenode-interface/test-constantsourcenode.html
@@ -0,0 +1,135 @@
+<!doctype html>
+<meta charset=utf-8>
+<title>Test the ConstantSourceNode Interface</title>
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script>
+test(function(t) {
+  var ac = new AudioContext();
+
+  var csn = ac.createConstantSource();
+  assert_equals(csn.offset.value, 1.0, "Default offset is 1.0");
+
+  csn = new ConstantSourceNode(ac);
+  assert_equals(csn.offset.value, 1.0, "Default offset is 1.0");
+
+  csn = new ConstantSourceNode(ac, {offset: -0.25});
+  assert_equals(csn.offset.value, -0.25, "Offset can be set during construction");
+}, "ConstantSourceNode can be constructed");
+
+test(function(t) {
+  var ac = new AudioContext();
+
+  var csn = ac.createConstantSource();
+
+  assert_throws_dom("InvalidStateError", function() {
+    csn.stop(1);
+  }, "Start must be called before stop");
+
+  assert_throws_js(RangeError, function() {
+    csn.start(-1);
+  }, "When can not be negative");
+
+  csn.start(0);
+  assert_throws_js(RangeError, function() {
+    csn.stop(-1);
+  }, "When can not be negative");
+}, "ConstantSourceNode stop and start");
+
+async_test(function(t) {
+  var ac = new OfflineAudioContext(1, 2048, 44100);
+  var csn = ac.createConstantSource();
+  csn.connect(ac.destination);
+  csn.start()
+  csn.stop(1024/44100)
+  csn.onended = function(e) {
+    t.step(function() {
+      assert_equals(e.type, "ended", "Event type should be 'ended', received: " + e.type);
+    });
+    t.done();
+  }
+  ac.startRendering();
+}, "ConstantSourceNode onended event");
+
+async_test(function(t) {
+  var ac = new OfflineAudioContext(1, 2048, 44100);
+  var csn = ac.createConstantSource();
+  csn.connect(ac.destination);
+  csn.start(512/44100)
+  csn.stop(1024/44100)
+
+  ac.oncomplete = function(e) {
+    t.step(function() {
+      var result = e.renderedBuffer.getChannelData(0);
+      for (var i = 0; i < 2048; ++i) {
+        if (i >= 512 && i < 1024) {
+          assert_equals(result[i], 1.0, "sample " + i + " should equal 1.0");
+        } else {
+          assert_equals(result[i], 0.0, "sample " + i + " should equal 0.0");
+        }
+      }
+    });
+    t.done();
+  }
+
+  ac.startRendering();
+}, "ConstantSourceNode start and stop when work");
+
+async_test(function(t) {
+  var ac = new OfflineAudioContext(1, 2048, 44100);
+  var csn = ac.createConstantSource();
+  csn.offset.value = 0.25;
+  csn.connect(ac.destination);
+  csn.start()
+
+  ac.oncomplete = function(e) {
+    t.step(function() {
+      var result = e.renderedBuffer.getChannelData(0);
+      for (var i = 0; i < 2048; ++i) {
+        assert_equals(result[i], 0.25, "sample " + i + " should equal 0.25");
+      }
+    });
+    t.done();
+  }
+
+  ac.startRendering();
+}, "ConstantSourceNode with no automation");
+
+async_test(function(t) {
+  var ac = new OfflineAudioContext(1, 2048, 44100);
+
+  var timeConstant = 2.0;
+  var offsetStart = 0.25;
+  var offsetEnd = 0.1;
+
+  var csn = ac.createConstantSource();
+  csn.offset.value = offsetStart;
+  csn.offset.setTargetAtTime(offsetEnd, 1024/ac.sampleRate, timeConstant);
+  csn.connect(ac.destination);
+  csn.start()
+
+  ac.oncomplete = function(e) {
+    t.step(function() {
+      // create buffer with expected values
+      var buffer = ac.createBuffer(1, 2048, ac.sampleRate);
+      for (var i = 0; i < 2048; ++i) {
+        if (i < 1024) {
+          buffer.getChannelData(0)[i] = offsetStart;
+        } else {
+          time = (i-1024)/ac.sampleRate;
+          buffer.getChannelData(0)[i] = offsetEnd + (offsetStart - offsetEnd)*Math.exp(-time/timeConstant);
+        }
+      }
+
+      var result = e.renderedBuffer.getChannelData(0);
+      var expected = buffer.getChannelData(0);
+      for (var i = 0; i < 2048; ++i) {
+        assert_true(Math.abs(result[i] - expected[i]) < 1.342e-6, "sample " + i + " should equal " + expected[i]);
+      }
+    });
+    t.done();
+  }
+
+  ac.startRendering();
+}, "ConstantSourceNode with automation");
+</script>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/active-processing.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/active-processing.https.html
new file mode 100644
index 0000000000..0712d6bcce
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/active-processing.https.html
@@ -0,0 +1,93 @@
+<!doctype html>
+<html>
+  <head>
+    <title>
+      Test Active Processing for ConvolverNode
+    </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">
+      // AudioProcessor that sends a message to its AudioWorkletNode whenver the
+      // number of channels on its input changes.
+      let filePath =
+          '../the-audioworklet-interface/processors/active-processing.js';
+
+      const audit = Audit.createTaskRunner();
+
+      let context;
+
+      audit.define('initialize', (task, should) => {
+        // Create context and load the module
+        context = new AudioContext();
+        should(
+            context.audioWorklet.addModule(filePath),
+            'AudioWorklet module loading')
+            .beResolved()
+            .then(() => task.done());
+      });
+
+      audit.define('test', (task, should) => {
+        const src = new OscillatorNode(context);
+
+        const response = new AudioBuffer({numberOfChannels: 2, length: 150,
+        sampleRate: context.sampleRate});
+
+        const conv = new ConvolverNode(context, {buffer: response});
+
+        const testerNode =
+            new AudioWorkletNode(context, 'active-processing-tester', {
+              // Use as short a duration as possible to keep the test from
+              // taking too much time.
+              processorOptions: {testDuration: .5},
+            });
+
+        // Expected number of output channels from the convolver node.  We should
+        // start with the number of inputs, because the source (oscillator) is
+        // actively processing.  When the source stops, the number of channels
+        // should change to 0.
+        const expectedValues = [2, 0];
+        let index = 0;
+
+        testerNode.port.onmessage = event => {
+          let count = event.data.channelCount;
+          let finished = event.data.finished;
+
+          // If we're finished, end testing.
+          if (finished) {
+            // Verify that we got the expected number of changes.
+            should(index, 'Number of distinct values')
+                .beEqualTo(expectedValues.length);
+
+            task.done();
+            return;
+          }
+
+          if (index < expectedValues.length) {
+            // Verify that the number of channels matches the expected number of
+            // channels.
+            should(count, `Test ${index}: Number of convolver output channels`)
+                .beEqualTo(expectedValues[index]);
+          }
+
+          ++index;
+        };
+
+        // Create the graph and go
+        src.connect(conv).connect(testerNode).connect(context.destination);
+        src.start();
+
+        // Stop the source after a short time so we can test that the convolver
+        // changes to not actively processing and thus produces a single channel
+        // of silence.
+        src.stop(context.currentTime + .1);
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolution-mono-mono.html b/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolution-mono-mono.html
new file mode 100644
index 0000000000..570efebe22
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolution-mono-mono.html
@@ -0,0 +1,62 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      convolution-mono-mono.html
+    </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/convolution-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      // description("Tests ConvolverNode processing a mono channel with mono
+      // impulse response.");
+
+      // To test the convolver, we convolve two square pulses together to
+      // produce a triangular pulse.  To verify the result is correct we
+      // check several parts of the result.  First, we make sure the initial
+      // part of the result is zero (due to the latency in the convolver).
+      // Next, the triangular pulse should match the theoretical result to
+      // within some roundoff.  After the triangular pulse, the result
+      // should be exactly zero, but round-off prevents that.  We make sure
+      // the part after the pulse is sufficiently close to zero.  Finally,
+      // the result should be exactly zero because the inputs are exactly
+      // zero.
+      audit.define('test', function(task, should) {
+        // Create offline audio context.
+        let context = new OfflineAudioContext(
+            2, sampleRate * renderLengthSeconds, sampleRate);
+
+        let squarePulse = createSquarePulseBuffer(context, pulseLengthFrames);
+        let trianglePulse =
+            createTrianglePulseBuffer(context, 2 * pulseLengthFrames);
+
+        let bufferSource = context.createBufferSource();
+        bufferSource.buffer = squarePulse;
+
+        let convolver = context.createConvolver();
+        convolver.normalize = false;
+        convolver.buffer = squarePulse;
+
+        bufferSource.connect(convolver);
+        convolver.connect(context.destination);
+
+        bufferSource.start(0);
+
+        context.startRendering()
+            .then(buffer => {
+              checkConvolvedResult(buffer, trianglePulse, should);
+            })
+            .then(task.done.bind(task));
+        ;
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-cascade.html b/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-cascade.html
new file mode 100644
index 0000000000..20bdfbdf4e
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-cascade.html
@@ -0,0 +1,61 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Cascade of Mono Convolvers
+    </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 audit = Audit.createTaskRunner();
+
+      // Arbitrary sample rate and reasonably short duration
+      let sampleRate = 8000;
+      let duration = 0.25;
+      let renderFrames = duration * sampleRate;
+
+      audit.define(
+          {label: 'cascade-mono', description: 'Cascaded mono convolvers'},
+          (task, should) => {
+            // Cascade two convolvers with mono responses and verify that the
+            // output is not silent.
+            let context = new OfflineAudioContext(1, renderFrames, sampleRate);
+
+            let b0 =
+                new AudioBuffer({length: 5, sampleRate: context.sampleRate});
+            b0.getChannelData(0)[1] = 1;
+            let c0 = new ConvolverNode(
+                context, {disableNormalization: true, buffer: b0});
+
+            let b1 =
+                new AudioBuffer({length: 5, sampleRate: context.sampleRate});
+            b1.getChannelData(0)[2] = 1;
+
+            let c1 = new ConvolverNode(
+                context, {disableNormalization: true, buffer: b1});
+
+            let src = new OscillatorNode(context);
+
+            src.connect(c0).connect(c1).connect(context.destination);
+
+            src.start();
+
+            context.startRendering()
+                .then(audioBuffer => {
+                  // Just verify the output is not silent
+                  let audio = audioBuffer.getChannelData(0);
+
+                  should(audio, 'Output of cascaded mono convolvers')
+                      .notBeConstantValueOf(0);
+                })
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-channels.html b/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-channels.html
new file mode 100644
index 0000000000..ac4f198d7c
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-channels.html
@@ -0,0 +1,43 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Supported Number of Channels for ConvolverNode
+    </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 audit = Audit.createTaskRunner();
+
+      audit.define('channel-count-test', (task, should) => {
+        // Just need a context to create nodes on, so any allowed length and
+        // rate is ok.
+        let context = new OfflineAudioContext(1, 1, 48000);
+
+        let success = true;
+
+        for (let count = 1; count <= 32; ++count) {
+          let convolver = context.createConvolver();
+          let buffer = context.createBuffer(count, 1, context.sampleRate);
+          let message = 'ConvolverNode with buffer of ' + count + ' channels';
+
+          if (count == 1 || count == 2 || count == 4) {
+            // These are the only valid channel counts for the buffer.
+            should(() => convolver.buffer = buffer, message).notThrow();
+          } else {
+            should(() => convolver.buffer = buffer, message)
+                .throw(DOMException, 'NotSupportedError');
+          }
+        }
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-response-1-chan.html b/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-response-1-chan.html
new file mode 100644
index 0000000000..e239a5e86f
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-response-1-chan.html
@@ -0,0 +1,406 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Convolver Channel Outputs for Response with 1 channel
+    </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">
+      // Test various convolver configurations when the convolver response has
+      // one channel (mono).
+
+      // This is somewhat arbitrary.  It is the minimum value for which tests
+      // pass with both FFmpeg and KISS FFT implementations for 256 points.
+      // The value was similar for each implementation.
+      const absoluteThreshold = Math.pow(2, -21);
+
+      // Fairly arbitrary sample rate, except that we want the rate to be a
+      // power of two so that 1/sampleRate is exactly representable as a
+      // single-precision float.
+      let sampleRate = 8192;
+
+      // A fairly arbitrary number of frames, except the number of frames should
+      // be more than a few render quanta.
+      let renderFrames = 10 * 128;
+
+      let audit = Audit.createTaskRunner();
+
+      // Convolver response
+      let response;
+
+      audit.define(
+          {
+            label: 'initialize',
+            description: 'Convolver response with one channel'
+          },
+          (task, should) => {
+            // Convolver response
+            should(
+                () => {
+                  response = new AudioBuffer(
+                      {numberOfChannels: 1, length: 2, sampleRate: sampleRate});
+                  response.getChannelData(0)[1] = 1;
+                },
+                'new AudioBuffer({numberOfChannels: 1, length: 2, sampleRate: ' +
+                    sampleRate + '})')
+                .notThrow();
+
+            task.done();
+          });
+
+      audit.define(
+          {label: '1-channel input', description: 'produces 1-channel output'},
+          (task, should) => {
+            // Create a 3-channel context:  channel 0 = convolver under test,
+            // channel 1: test that convolver output is not stereo, channel 2:
+            // expected output.  The context MUST be discrete so that the
+            // channels don't get mixed in some unexpected way.
+            let context = new OfflineAudioContext(3, renderFrames, sampleRate);
+            context.destination.channelInterpretation = 'discrete';
+
+            let src = new OscillatorNode(context);
+            let conv = new ConvolverNode(
+                context, {disableNormalization: true, buffer: response});
+
+            // Splitter node to verify that the output of the convolver is mono.
+            // channelInterpretation must be 'discrete' so we don't do any
+            // mixing of the input to the node.
+            let splitter = new ChannelSplitterNode(
+                context,
+                {numberOfOutputs: 2, channelInterpretation: 'discrete'});
+
+            // Final merger to feed all of the individual channels into the
+            // destination.
+            let merger = new ChannelMergerNode(context, {numberOfInputs: 3});
+
+            src.connect(conv).connect(splitter);
+            splitter.connect(merger, 0, 0);
+            splitter.connect(merger, 1, 1);
+
+            // The convolver response is a 1-sample delay.  Use a delay node to
+            // implement this.
+            let delay =
+                new DelayNode(context, {delayTime: 1 / context.sampleRate});
+            src.connect(delay);
+            delay.connect(merger, 0, 2);
+
+            merger.connect(context.destination);
+
+            src.start();
+
+            context.startRendering()
+                .then(audioBuffer => {
+                  // Extract out the three channels
+                  let actual = audioBuffer.getChannelData(0);
+                  let c1 = audioBuffer.getChannelData(1);
+                  let expected = audioBuffer.getChannelData(2);
+
+                  // c1 is expected to be zero.
+                  should(c1, '1: Channel 1').beConstantValueOf(0);
+
+                  // The expected and actual results should be identical
+                  should(actual, 'Convolver output')
+                    .beCloseToArray(expected,
+                                    {absoluteThreshold: absoluteThreshold});
+                })
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {label: '2-channel input', description: 'produces 2-channel output'},
+          (task, should) => {
+            downMixTest({numberOfInputs: 2, prefix: '2'}, should)
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: '3-channel input',
+            description: '3->2 downmix producing 2-channel output'
+          },
+          (task, should) => {
+            downMixTest({numberOfInputs: 3, prefix: '3'}, should)
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: '4-channel input',
+            description: '4->2 downmix producing 2-channel output'
+          },
+          (task, should) => {
+            downMixTest({numberOfInputs: 4, prefix: '4'}, should)
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: '5.1-channel input',
+            description: '5.1->2 downmix producing 2-channel output'
+          },
+          (task, should) => {
+            // Scale tolerance by maximum amplitude expected in down-mix
+            // output.
+            let threshold = (1.0 + Math.sqrt(0.5) * 2) * absoluteThreshold;
+
+            downMixTest({numberOfInputs: 6, prefix: '5.1',
+                         absoluteThreshold: threshold}, should)
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: '3-channel input, explicit',
+            description: '3->2 explicit downmix producing 2-channel output'
+          },
+          (task, should) => {
+            downMixTest(
+                {
+                  channelCountMode: 'explicit',
+                  numberOfInputs: 3,
+                  prefix: '3 chan downmix explicit'
+                },
+                should)
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: '4-channel input, explicit',
+            description: '4->2 explicit downmix producing 2-channel output'
+          },
+          (task, should) => {
+            downMixTest(
+                {
+                  channelCountMode: 'explicit',
+                  numberOfInputs: 4,
+                  prefix: '4 chan downmix explicit'
+                },
+                should)
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: '5.1-channel input, explicit',
+            description: '5.1->2 explicit downmix producing 2-channel output'
+          },
+          (task, should) => {
+            // Scale tolerance by maximum amplitude expected in down-mix
+            // output.
+            let threshold = (1.0 + Math.sqrt(0.5) * 2) * absoluteThreshold;
+
+            downMixTest(
+                {
+                  channelCountMode: 'explicit',
+                  numberOfInputs: 6,
+                  prefix: '5.1 chan downmix explicit',
+                  absoluteThreshold: threshold
+                },
+                should)
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: 'mono-upmix-explicit',
+            description: '1->2 upmix, count mode explicit'
+          },
+          (task, should) => {
+            upMixTest(should, {channelCountMode: 'explicit'})
+                .then(buffer => {
+                  let length = buffer.length;
+                  let input = buffer.getChannelData(0);
+                  let out0 = buffer.getChannelData(1);
+                  let out1 = buffer.getChannelData(2);
+
+                  // The convolver is basically a one-sample delay.  Verify that
+                  // that each channel is delayed by one sample.
+                  should(out0.slice(1), '1->2 explicit upmix: channel 0')
+                      .beCloseToArray(
+                          input.slice(0, length - 1),
+                          {absoluteThreshold: absoluteThreshold});
+                  should(out1.slice(1), '1->2 explicit upmix: channel 1')
+                      .beCloseToArray(
+                          input.slice(0, length - 1),
+                          {absoluteThreshold: absoluteThreshold});
+                })
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: 'mono-upmix-clamped-max',
+            description: '1->2 upmix, count mode clamped-max'
+          },
+          (task, should) => {
+            upMixTest(should, {channelCountMode: 'clamped-max'})
+                .then(buffer => {
+                  let length = buffer.length;
+                  let input = buffer.getChannelData(0);
+                  let out0 = buffer.getChannelData(1);
+                  let out1 = buffer.getChannelData(2);
+
+                  // The convolver is basically a one-sample delay.  With a mono
+                  // input, the count set to 2, and a mode of 'clamped-max', the
+                  // output should be mono
+                  should(out0.slice(1), '1->2 clamped-max upmix: channel 0')
+                      .beCloseToArray(
+                          input.slice(0, length - 1),
+                          {absoluteThreshold: absoluteThreshold});
+                  should(out1, '1->2 clamped-max upmix: channel 1')
+                      .beConstantValueOf(0);
+                })
+                .then(() => task.done());
+          });
+
+      function downMixTest(options, should) {
+        // Create an 4-channel offline context.  The first two channels are for
+        // the stereo output of the convolver and the next two channels are for
+        // the reference stereo signal.
+        let context = new OfflineAudioContext(4, renderFrames, sampleRate);
+        context.destination.channelInterpretation = 'discrete';
+
+        // Create oscillators for use as the input.  The type and frequency is
+        // arbitrary except that oscillators must be different.
+        let src = new Array(options.numberOfInputs);
+        for (let k = 0; k < src.length; ++k) {
+          src[k] = new OscillatorNode(
+              context, {type: 'square', frequency: 440 + 220 * k});
+        }
+
+        // Merger to combine the oscillators into one output stream.
+        let srcMerger =
+            new ChannelMergerNode(context, {numberOfInputs: src.length});
+
+        for (let k = 0; k < src.length; ++k) {
+          src[k].connect(srcMerger, 0, k);
+        }
+
+        // Convolver under test.
+        let conv = new ConvolverNode(context, {
+          disableNormalization: true,
+          buffer: response,
+          channelCountMode: options.channelCountMode
+        });
+        srcMerger.connect(conv);
+
+        // Splitter to get individual channels of the convolver output so we can
+        // feed them (eventually) to the context in the right set of channels.
+        let splitter = new ChannelSplitterNode(context, {numberOfOutputs: 2});
+        conv.connect(splitter);
+
+        // Reference graph consists of a delay node to simulate the response of
+        // the convolver.  (The convolver response is designed this way.)
+        let delay = new DelayNode(context, {delayTime: 1 / context.sampleRate});
+
+        // Gain node to mix the sources to stereo in the desired way.  (Could be
+        // done in the delay node, but let's keep the mixing separated from the
+        // functionality.)
+        let gainMixer = new GainNode(
+            context, {channelCount: 2, channelCountMode: 'explicit'});
+        srcMerger.connect(gainMixer);
+
+        // Splitter to extract the channels of the reference signal.
+        let refSplitter =
+            new ChannelSplitterNode(context, {numberOfOutputs: 2});
+        gainMixer.connect(delay).connect(refSplitter);
+
+        // Final merger to bring back the individual channels from the convolver
+        // and the reference in the right order for the destination.
+        let finalMerger = new ChannelMergerNode(
+            context, {numberOfInputs: context.destination.channelCount});
+
+        // First two channels are for the convolver output, and the next two are
+        // for the reference.
+        splitter.connect(finalMerger, 0, 0);
+        splitter.connect(finalMerger, 1, 1);
+        refSplitter.connect(finalMerger, 0, 2);
+        refSplitter.connect(finalMerger, 1, 3);
+
+        finalMerger.connect(context.destination);
+
+        // Start the sources at last.
+        for (let k = 0; k < src.length; ++k) {
+          src[k].start();
+        }
+
+        return context.startRendering().then(audioBuffer => {
+          // Extract the various channels out
+          let actual0 = audioBuffer.getChannelData(0);
+          let actual1 = audioBuffer.getChannelData(1);
+          let expected0 = audioBuffer.getChannelData(2);
+          let expected1 = audioBuffer.getChannelData(3);
+
+          let threshold = options.absoluteThreshold ?
+              options.absoluteThreshold : absoluteThreshold;
+
+          // Verify that each output channel of the convolver matches
+          // the delayed signal from the reference
+          should(actual0, options.prefix + ': Channel 0')
+              .beCloseToArray(expected0, {absoluteThreshold: threshold});
+          should(actual1, options.prefix + ': Channel 1')
+              .beCloseToArray(expected1, {absoluteThreshold: threshold});
+        });
+      }
+
+      function upMixTest(should, options) {
+        // Offline context with 3 channels:  0 = source
+        // 1 = convolver output, left, 2 = convolver output, right.  Context
+        // destination must be discrete so that channels don't get mixed in
+        // unexpected ways.
+        let context = new OfflineAudioContext(3, renderFrames, sampleRate);
+        context.destination.channelInterpretation = 'discrete';
+
+        let merger = new ChannelMergerNode(
+            context, {numberOfInputs: context.destination.maxChannelCount});
+        merger.connect(context.destination);
+
+        let src = new OscillatorNode(context);
+
+        // Mono response for convolver.  Just a simple 1-frame delay.
+        let response =
+            new AudioBuffer({length: 2, sampleRate: context.sampleRate});
+        response.getChannelData(0)[1] = 1;
+
+        // Set mode to explicit and count to 2 so we manually force the
+        // convolver to produce stereo output.  Without this, it would be
+        // mono input with mono response, which produces a mono output.
+        let conv;
+
+        should(
+            () => {conv = new ConvolverNode(context, {
+                     buffer: response,
+                     disableNormalization: true,
+                     channelCount: 2,
+                     channelCountMode: options.channelCountMode
+                   })},
+            `new ConvolverNode({channelCountMode: '${
+                options.channelCountMode}'})`)
+            .notThrow();
+
+        // Split output of convolver into individual channels.
+        let convSplit = new ChannelSplitterNode(context, {numberOfOutputs: 2});
+
+        src.connect(conv);
+        conv.connect(convSplit);
+
+        // Connect signals to destination in the desired way.
+        src.connect(merger, 0, 0);
+        convSplit.connect(merger, 0, 1);
+        convSplit.connect(merger, 1, 2);
+
+        src.start();
+
+        return context.startRendering();
+      }
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-response-2-chan.html b/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-response-2-chan.html
new file mode 100644
index 0000000000..a73eb3f8ab
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-response-2-chan.html
@@ -0,0 +1,373 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Convolver Channel Outputs for Response with 2 channels
+    </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">
+      // Test various convolver configurations when the convolver response has
+      // a stereo response.
+
+      // This is somewhat arbitrary.  It is the minimum value for which tests
+      // pass with both FFmpeg and KISS FFT implementations for 256 points.
+      // The value was similar for each implementation.
+      const absoluteThreshold = Math.pow(2, -21);
+
+      // Fairly arbitrary sample rate, except that we want the rate to be a
+      // power of two so that 1/sampleRate is exactly representable as a
+      // single-precision float.
+      let sampleRate = 8192;
+
+      // A fairly arbitrary number of frames, except the number of frames should
+      // be more than a few render quanta.
+      let renderFrames = 10 * 128;
+
+      let audit = Audit.createTaskRunner();
+
+      // Convolver response
+      let response;
+
+      audit.define(
+          {
+            label: 'initialize',
+            description: 'Convolver response with one channel'
+          },
+          (task, should) => {
+            // Convolver response
+            should(
+                () => {
+                  response = new AudioBuffer(
+                      {numberOfChannels: 2, length: 4, sampleRate: sampleRate});
+                  // Each channel of the response is a simple impulse (with
+                  // different delay) so that we can use a DelayNode to simulate
+                  // the convolver output.  Channel k is delayed by k+1 frames.
+                  for (let k = 0; k < response.numberOfChannels; ++k) {
+                    response.getChannelData(k)[k + 1] = 1;
+                  }
+                },
+                'new AudioBuffer({numberOfChannels: 2, length: 4, sampleRate: ' +
+                    sampleRate + '})')
+                .notThrow();
+
+            task.done();
+          });
+
+      audit.define(
+          {label: '1-channel input', description: 'produces 2-channel output'},
+          (task, should) => {
+            stereoResponseTest({numberOfInputs: 1, prefix: '1'}, should)
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {label: '2-channel input', description: 'produces 2-channel output'},
+          (task, should) => {
+            stereoResponseTest({numberOfInputes: 2, prefix: '2'}, should)
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: '3-channel input',
+            description: '3->2 downmix producing 2-channel output'
+          },
+          (task, should) => {
+            stereoResponseTest({numberOfInputs: 3, prefix: '3'}, should)
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: '4-channel input',
+            description: '4->2 downmix producing 2-channel output'
+          },
+          (task, should) => {
+            stereoResponseTest({numberOfInputs: 4, prefix: '4'}, should)
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: '5.1-channel input',
+            description: '5.1->2 downmix producing 2-channel output'
+          },
+          (task, should) => {
+            // Scale tolerance by maximum amplitude expected in down-mix
+            // output.
+            let threshold = (1.0 + Math.sqrt(0.5) * 2) * absoluteThreshold;
+
+            stereoResponseTest({numberOfInputs: 6, prefix: '5.1',
+                                absoluteThreshold: threshold}, should)
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: '2-channel input, explicit mode',
+            description: 'produces 2-channel output'
+          },
+          (task, should) => {
+            stereoResponseExplicitTest(
+                {
+                  numberOfInputes: 2,
+                  prefix: '2-in explicit mode'
+                },
+                should)
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: '3-channel input explicit mode',
+            description: '3->1 downmix producing 2-channel output'
+          },
+          (task, should) => {
+            stereoResponseExplicitTest(
+                {
+                  numberOfInputs: 3,
+                  prefix: '3-in explicit'
+                },
+                should)
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: '4-channel input explicit mode',
+            description: '4->1 downmix producing 2-channel output'
+          },
+          (task, should) => {
+            stereoResponseExplicitTest(
+                {
+                  numberOfInputs: 4,
+                  prefix: '4-in explicit'
+                },
+                should)
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: '5.1-channel input explicit mode',
+            description: '5.1->1 downmix producing 2-channel output'
+          },
+          (task, should) => {
+            // Scale tolerance by maximum amplitude expected in down-mix
+            // output.
+            let threshold = (Math.sqrt(0.5) * 2 + 2.0) * absoluteThreshold;
+
+            stereoResponseExplicitTest(
+                {
+                  numberOfInputs: 6,
+                  prefix: '5.1-in explicit',
+                  absoluteThreshold: threshold
+                },
+                should)
+                .then(() => task.done());
+          });
+
+      function stereoResponseTest(options, should) {
+        // Create an 4-channel offline context.  The first two channels are for
+        // the stereo output of the convolver and the next two channels are for
+        // the reference stereo signal.
+        let context = new OfflineAudioContext(4, renderFrames, sampleRate);
+        context.destination.channelInterpretation = 'discrete';
+
+        // Create oscillators for use as the input.  The type and frequency is
+        // arbitrary except that oscillators must be different.
+        let src = new Array(options.numberOfInputs);
+        for (let k = 0; k < src.length; ++k) {
+          src[k] = new OscillatorNode(
+              context, {type: 'square', frequency: 440 + 220 * k});
+        }
+
+        // Merger to combine the oscillators into one output stream.
+        let srcMerger =
+            new ChannelMergerNode(context, {numberOfInputs: src.length});
+
+        for (let k = 0; k < src.length; ++k) {
+          src[k].connect(srcMerger, 0, k);
+        }
+
+        // Convolver under test.
+        let conv = new ConvolverNode(
+            context, {disableNormalization: true, buffer: response});
+        srcMerger.connect(conv);
+
+        // Splitter to get individual channels of the convolver output so we can
+        // feed them (eventually) to the context in the right set of channels.
+        let splitter = new ChannelSplitterNode(context, {numberOfOutputs: 2});
+        conv.connect(splitter);
+
+        // Reference graph consists of a delays node to simulate the response of
+        // the convolver.  (The convolver response is designed this way.)
+        let delay = new Array(2);
+        for (let k = 0; k < delay.length; ++k) {
+          delay[k] = new DelayNode(context, {
+            delayTime: (k + 1) / context.sampleRate,
+            channelCount: 1,
+            channelCountMode: 'explicit'
+          });
+        }
+
+        // Gain node to mix the sources to stereo in the desired way.  (Could be
+        // done in the delay node, but let's keep the mixing separated from the
+        // functionality.)
+        let gainMixer = new GainNode(
+            context, {channelCount: 2, channelCountMode: 'explicit'});
+        srcMerger.connect(gainMixer);
+
+        // Splitter to extract the channels of the reference signal.
+        let refSplitter =
+            new ChannelSplitterNode(context, {numberOfOutputs: 2});
+        gainMixer.connect(refSplitter);
+
+        // Connect each channel to the delay nodes
+        for (let k = 0; k < delay.length; ++k) {
+          refSplitter.connect(delay[k], k);
+        }
+
+        // Final merger to bring back the individual channels from the convolver
+        // and the reference in the right order for the destination.
+        let finalMerger = new ChannelMergerNode(
+            context, {numberOfInputs: context.destination.channelCount});
+
+        // First two channels are for the convolver output, and the next two are
+        // for the reference.
+        splitter.connect(finalMerger, 0, 0);
+        splitter.connect(finalMerger, 1, 1);
+        delay[0].connect(finalMerger, 0, 2);
+        delay[1].connect(finalMerger, 0, 3);
+
+        finalMerger.connect(context.destination);
+
+        // Start the sources at last.
+        for (let k = 0; k < src.length; ++k) {
+          src[k].start();
+        }
+
+        return context.startRendering().then(audioBuffer => {
+          // Extract the various channels out
+          let actual0 = audioBuffer.getChannelData(0);
+          let actual1 = audioBuffer.getChannelData(1);
+          let expected0 = audioBuffer.getChannelData(2);
+          let expected1 = audioBuffer.getChannelData(3);
+
+          let threshold = options.absoluteThreshold ?
+              options.absoluteThreshold : absoluteThreshold;
+
+          // Verify that each output channel of the convolver matches
+          // the delayed signal from the reference
+          should(actual0, options.prefix + ': Channel 0')
+              .beCloseToArray(expected0, {absoluteThreshold: threshold});
+          should(actual1, options.prefix + ': Channel 1')
+              .beCloseToArray(expected1, {absoluteThreshold: threshold});
+        });
+      }
+
+      function stereoResponseExplicitTest(options, should) {
+        // Create an 4-channel offline context.  The first two channels are for
+        // the stereo output of the convolver and the next two channels are for
+        // the reference stereo signal.
+        let context = new OfflineAudioContext(4, renderFrames, sampleRate);
+        context.destination.channelInterpretation = 'discrete';
+
+        // Create oscillators for use as the input.  The type and frequency is
+        // arbitrary except that oscillators must be different.
+        let src = new Array(options.numberOfInputs);
+        for (let k = 0; k < src.length; ++k) {
+          src[k] = new OscillatorNode(
+              context, {type: 'square', frequency: 440 + 220 * k});
+        }
+
+        // Merger to combine the oscillators into one output stream.
+        let srcMerger =
+            new ChannelMergerNode(context, {numberOfInputs: src.length});
+
+        for (let k = 0; k < src.length; ++k) {
+          src[k].connect(srcMerger, 0, k);
+        }
+
+        // Convolver under test.
+        let conv = new ConvolverNode(context, {
+          channelCount: 1,
+          channelCountMode: 'explicit',
+          disableNormalization: true,
+          buffer: response
+        });
+        srcMerger.connect(conv);
+
+        // Splitter to get individual channels of the convolver output so we can
+        // feed them (eventually) to the context in the right set of channels.
+        let splitter = new ChannelSplitterNode(context, {numberOfOutputs: 2});
+        conv.connect(splitter);
+
+        // Reference graph consists of a delays node to simulate the response of
+        // the convolver.  (The convolver response is designed this way.)
+        let delay = new Array(2);
+        for (let k = 0; k < delay.length; ++k) {
+          delay[k] = new DelayNode(context, {
+            delayTime: (k + 1) / context.sampleRate,
+            channelCount: 1,
+            channelCountMode: 'explicit'
+          });
+        }
+
+        // Gain node to mix the sources in the same way as the convolver.
+        let gainMixer = new GainNode(
+            context, {channelCount: 1, channelCountMode: 'explicit'});
+        srcMerger.connect(gainMixer);
+
+        // Connect each channel to the delay nodes
+        for (let k = 0; k < delay.length; ++k) {
+          gainMixer.connect(delay[k]);
+        }
+
+        // Final merger to bring back the individual channels from the convolver
+        // and the reference in the right order for the destination.
+        let finalMerger = new ChannelMergerNode(
+            context, {numberOfInputs: context.destination.channelCount});
+
+        // First two channels are for the convolver output, and the next two are
+        // for the reference.
+        splitter.connect(finalMerger, 0, 0);
+        splitter.connect(finalMerger, 1, 1);
+        delay[0].connect(finalMerger, 0, 2);
+        delay[1].connect(finalMerger, 0, 3);
+
+        finalMerger.connect(context.destination);
+
+        // Start the sources at last.
+        for (let k = 0; k < src.length; ++k) {
+          src[k].start();
+        }
+
+        return context.startRendering().then(audioBuffer => {
+          // Extract the various channels out
+          let actual0 = audioBuffer.getChannelData(0);
+          let actual1 = audioBuffer.getChannelData(1);
+          let expected0 = audioBuffer.getChannelData(2);
+          let expected1 = audioBuffer.getChannelData(3);
+
+          let threshold = options.absoluteThreshold ?
+              options.absoluteThreshold : absoluteThreshold;
+
+          // Verify that each output channel of the convolver matches
+          // the delayed signal from the reference
+          should(actual0, options.prefix + ': Channel 0')
+              .beCloseToArray(expected0, {absoluteThreshold: threshold});
+          should(actual1, options.prefix + ': Channel 1')
+              .beCloseToArray(expected1, {absoluteThreshold: threshold});
+        });
+      }
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-response-4-chan.html b/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-response-4-chan.html
new file mode 100644
index 0000000000..f188d87b71
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-response-4-chan.html
@@ -0,0 +1,508 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Convolver Channel Outputs for Response with 4 channels
+    </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">
+      // Test various convolver configurations when the convolver response has
+      // a four channels.
+
+      // This is somewhat arbitrary.  It is the minimum value for which tests
+      // pass with both FFmpeg and KISS FFT implementations for 256 points.
+      // The value was similar for each implementation.
+      const absoluteThreshold = 3 * Math.pow(2, -22);
+
+      // Fairly arbitrary sample rate, except that we want the rate to be a
+      // power of two so that 1/sampleRate is exactly representable as a
+      // single-precision float.
+      let sampleRate = 8192;
+
+      // A fairly arbitrary number of frames, except the number of frames should
+      // be more than a few render quanta.
+      let renderFrames = 10 * 128;
+
+      let audit = Audit.createTaskRunner();
+
+      // Convolver response
+      let response;
+
+      audit.define(
+          {
+            label: 'initialize',
+            description: 'Convolver response with one channel'
+          },
+          (task, should) => {
+            // Convolver response
+            should(
+                () => {
+                  response = new AudioBuffer(
+                      {numberOfChannels: 4, length: 8, sampleRate: sampleRate});
+                  // Each channel of the response is a simple impulse (with
+                  // different delay) so that we can use a DelayNode to simulate
+                  // the convolver output.  Channel k is delayed by k+1 frames.
+                  for (let k = 0; k < response.numberOfChannels; ++k) {
+                    response.getChannelData(k)[k + 1] = 1;
+                  }
+                },
+                'new AudioBuffer({numberOfChannels: 2, length: 4, sampleRate: ' +
+                    sampleRate + '})')
+                .notThrow();
+
+            task.done();
+          });
+
+      audit.define(
+          {label: '1-channel input', description: 'produces 2-channel output'},
+          (task, should) => {
+            fourChannelResponseTest({numberOfInputs: 1, prefix: '1'}, should)
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {label: '2-channel input', description: 'produces 2-channel output'},
+          (task, should) => {
+            fourChannelResponseTest({numberOfInputs: 2, prefix: '2'}, should)
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: '3-channel input',
+            description: '3->2 downmix producing 2-channel output'
+          },
+          (task, should) => {
+            fourChannelResponseTest({numberOfInputs: 3, prefix: '3'}, should)
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: '4-channel input',
+            description: '4->2 downmix producing 2-channel output'
+          },
+          (task, should) => {
+            fourChannelResponseTest({numberOfInputs: 4, prefix: '4'}, should)
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: '5.1-channel input',
+            description: '5.1->2 downmix producing 2-channel output'
+          },
+          (task, should) => {
+            // Scale tolerance by maximum amplitude expected in down-mix
+            // output.
+            let threshold = (1.0 + Math.sqrt(0.5) * 2) * absoluteThreshold;
+
+            fourChannelResponseTest({numberOfInputs: 6, prefix: '5.1',
+                                     absoluteThreshold: threshold}, should)
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: 'delayed buffer set',
+            description: 'Delayed set of 4-channel response'
+          },
+          (task, should) => {
+            // Don't really care about the output for this test.  It's to verify
+            // we don't crash in a debug build when setting the convolver buffer
+            // after creating the graph.
+            let context = new OfflineAudioContext(1, renderFrames, sampleRate);
+            let src = new OscillatorNode(context);
+            let convolver =
+                new ConvolverNode(context, {disableNormalization: true});
+            let buffer = new AudioBuffer({
+              numberOfChannels: 4,
+              length: 4,
+              sampleRate: context.sampleRate
+            });
+
+            // Impulse responses for the convolver aren't important, as long as
+            // it's not all zeroes.
+            for (let k = 0; k < buffer.numberOfChannels; ++k) {
+              buffer.getChannelData(k).fill(1);
+            }
+
+            src.connect(convolver).connect(context.destination);
+
+            // Set the buffer after a few render quanta have passed.  The actual
+            // value must be least one, but is otherwise arbitrary.
+            context.suspend(512 / context.sampleRate)
+                .then(() => convolver.buffer = buffer)
+                .then(() => context.resume());
+
+            src.start();
+            context.startRendering()
+                .then(audioBuffer => {
+                  // Just make sure output is not silent.
+                  should(
+                      audioBuffer.getChannelData(0),
+                      'Output with delayed setting of convolver buffer')
+                      .notBeConstantValueOf(0);
+                })
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: 'count 1, 2-channel in',
+            description: '2->1 downmix because channel count is 1'
+          },
+          (task, should) => {
+            channelCount1ExplicitTest(
+                {numberOfInputs: 1, prefix: 'Convolver count 1, stereo in'},
+                should)
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: 'count 1, 4-channel in',
+            description: '4->1 downmix because channel count is 1'
+          },
+          (task, should) => {
+            channelCount1ExplicitTest(
+                {numberOfInputs: 4, prefix: 'Convolver count 1, 4-channel in'},
+                should)
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: 'count 1, 5.1-channel in',
+            description: '5.1->1 downmix because channel count is 1'
+          },
+          (task, should) => {
+            channelCount1ExplicitTest(
+                {
+                  numberOfInputs: 6,
+                  prefix: 'Convolver count 1, 5.1 channel in'
+                },
+                should)
+                .then(() => task.done());
+          });
+
+      audit.run();
+
+      function fourChannelResponseTest(options, should) {
+        // Create an 4-channel offline context.  The first two channels are for
+        // the stereo output of the convolver and the next two channels are for
+        // the reference stereo signal.
+        let context = new OfflineAudioContext(4, renderFrames, sampleRate);
+        context.destination.channelInterpretation = 'discrete';
+
+        // Create oscillators for use as the input.  The type and frequency is
+        // arbitrary except that oscillators must be different.
+        let src = new Array(options.numberOfInputs);
+        for (let k = 0; k < src.length; ++k) {
+          src[k] = new OscillatorNode(
+              context, {type: 'square', frequency: 440 + 220 * k});
+        }
+
+        // Merger to combine the oscillators into one output stream.
+        let srcMerger =
+            new ChannelMergerNode(context, {numberOfInputs: src.length});
+
+        for (let k = 0; k < src.length; ++k) {
+          src[k].connect(srcMerger, 0, k);
+        }
+
+        // Convolver under test.
+        let conv = new ConvolverNode(
+            context, {disableNormalization: true, buffer: response});
+        srcMerger.connect(conv);
+
+        // Splitter to get individual channels of the convolver output so we can
+        // feed them (eventually) to the context in the right set of channels.
+        let splitter = new ChannelSplitterNode(context, {numberOfOutputs: 2});
+        conv.connect(splitter);
+
+        // Reference graph consists of a delays node to simulate the response of
+        // the convolver.  (The convolver response is designed this way.)
+        let delay = new Array(4);
+        for (let k = 0; k < delay.length; ++k) {
+          delay[k] = new DelayNode(context, {
+            delayTime: (k + 1) / context.sampleRate,
+            channelCount: 1,
+            channelCountMode: 'explicit'
+          });
+        }
+
+        // Gain node to mix the sources to stereo in the desired way.  (Could be
+        // done in the delay node, but let's keep the mixing separated from the
+        // functionality.)
+        let gainMixer = new GainNode(
+            context, {channelCount: 2, channelCountMode: 'explicit'});
+        srcMerger.connect(gainMixer);
+
+        // Splitter to extract the channels of the reference signal.
+        let refSplitter =
+            new ChannelSplitterNode(context, {numberOfOutputs: 2});
+        gainMixer.connect(refSplitter);
+
+        // Connect the left channel to the first two nodes and the right channel
+        // to the second two as required for "true" stereo matrix response.
+        for (let k = 0; k < 2; ++k) {
+          refSplitter.connect(delay[k], 0, 0);
+          refSplitter.connect(delay[k + 2], 1, 0);
+        }
+
+        // Gain nodes to sum the responses to stereo
+        let gain = new Array(2);
+        for (let k = 0; k < gain.length; ++k) {
+          gain[k] = new GainNode(context, {
+            channelCount: 1,
+            channelCountMode: 'explicit',
+            channelInterpretation: 'discrete'
+          });
+        }
+
+        delay[0].connect(gain[0]);
+        delay[2].connect(gain[0]);
+        delay[1].connect(gain[1]);
+        delay[3].connect(gain[1]);
+
+        // Final merger to bring back the individual channels from the convolver
+        // and the reference in the right order for the destination.
+        let finalMerger = new ChannelMergerNode(
+            context, {numberOfInputs: context.destination.channelCount});
+
+        // First two channels are for the convolver output, and the next two are
+        // for the reference.
+        splitter.connect(finalMerger, 0, 0);
+        splitter.connect(finalMerger, 1, 1);
+        gain[0].connect(finalMerger, 0, 2);
+        gain[1].connect(finalMerger, 0, 3);
+
+        finalMerger.connect(context.destination);
+
+        // Start the sources at last.
+        for (let k = 0; k < src.length; ++k) {
+          src[k].start();
+        }
+
+        return context.startRendering().then(audioBuffer => {
+          // Extract the various channels out
+          let actual0 = audioBuffer.getChannelData(0);
+          let actual1 = audioBuffer.getChannelData(1);
+          let expected0 = audioBuffer.getChannelData(2);
+          let expected1 = audioBuffer.getChannelData(3);
+
+          let threshold = options.absoluteThreshold ?
+              options.absoluteThreshold : absoluteThreshold;
+
+          // Verify that each output channel of the convolver matches
+          // the delayed signal from the reference
+          should(actual0, options.prefix + ': Channel 0')
+              .beCloseToArray(expected0, {absoluteThreshold: threshold});
+          should(actual1, options.prefix + ': Channel 1')
+              .beCloseToArray(expected1, {absoluteThreshold: threshold});
+        });
+      }
+
+      function fourChannelResponseExplicitTest(options, should) {
+        // Create an 4-channel offline context.  The first two channels are for
+        // the stereo output of the convolver and the next two channels are for
+        // the reference stereo signal.
+        let context = new OfflineAudioContext(4, renderFrames, sampleRate);
+        context.destination.channelInterpretation = 'discrete';
+
+        // Create oscillators for use as the input.  The type and frequency is
+        // arbitrary except that oscillators must be different.
+        let src = new Array(options.numberOfInputs);
+        for (let k = 0; k < src.length; ++k) {
+          src[k] = new OscillatorNode(
+              context, {type: 'square', frequency: 440 + 220 * k});
+        }
+
+        // Merger to combine the oscillators into one output stream.
+        let srcMerger =
+            new ChannelMergerNode(context, {numberOfInputs: src.length});
+
+        for (let k = 0; k < src.length; ++k) {
+          src[k].connect(srcMerger, 0, k);
+        }
+
+        // Convolver under test.
+        let conv = new ConvolverNode(
+            context, {disableNormalization: true, buffer: response});
+        srcMerger.connect(conv);
+
+        // Splitter to get individual channels of the convolver output so we can
+        // feed them (eventually) to the context in the right set of channels.
+        let splitter = new ChannelSplitterNode(context, {numberOfOutputs: 2});
+        conv.connect(splitter);
+
+        // Reference graph consists of a delays node to simulate the response of
+        // the convolver.  (The convolver response is designed this way.)
+        let delay = new Array(4);
+        for (let k = 0; k < delay.length; ++k) {
+          delay[k] = new DelayNode(context, {
+            delayTime: (k + 1) / context.sampleRate,
+            channelCount: 1,
+            channelCountMode: 'explicit'
+          });
+        }
+
+        // Gain node to mix the sources to stereo in the desired way.  (Could be
+        // done in the delay node, but let's keep the mixing separated from the
+        // functionality.)
+        let gainMixer = new GainNode(
+            context, {channelCount: 2, channelCountMode: 'explicit'});
+        srcMerger.connect(gainMixer);
+
+        // Splitter to extract the channels of the reference signal.
+        let refSplitter =
+            new ChannelSplitterNode(context, {numberOfOutputs: 2});
+        gainMixer.connect(refSplitter);
+
+        // Connect the left channel to the first two nodes and the right channel
+        // to the second two as required for "true" stereo matrix response.
+        for (let k = 0; k < 2; ++k) {
+          refSplitter.connect(delay[k], 0, 0);
+          refSplitter.connect(delay[k + 2], 1, 0);
+        }
+
+        // Gain nodes to sum the responses to stereo
+        let gain = new Array(2);
+        for (let k = 0; k < gain.length; ++k) {
+          gain[k] = new GainNode(context, {
+            channelCount: 1,
+            channelCountMode: 'explicit',
+            channelInterpretation: 'discrete'
+          });
+        }
+
+        delay[0].connect(gain[0]);
+        delay[2].connect(gain[0]);
+        delay[1].connect(gain[1]);
+        delay[3].connect(gain[1]);
+
+        // Final merger to bring back the individual channels from the convolver
+        // and the reference in the right order for the destination.
+        let finalMerger = new ChannelMergerNode(
+            context, {numberOfInputs: context.destination.channelCount});
+
+        // First two channels are for the convolver output, and the next two are
+        // for the reference.
+        splitter.connect(finalMerger, 0, 0);
+        splitter.connect(finalMerger, 1, 1);
+        gain[0].connect(finalMerger, 0, 2);
+        gain[1].connect(finalMerger, 0, 3);
+
+        finalMerger.connect(context.destination);
+
+        // Start the sources at last.
+        for (let k = 0; k < src.length; ++k) {
+          src[k].start();
+        }
+
+        return context.startRendering().then(audioBuffer => {
+          // Extract the various channels out
+          let actual0 = audioBuffer.getChannelData(0);
+          let actual1 = audioBuffer.getChannelData(1);
+          let expected0 = audioBuffer.getChannelData(2);
+          let expected1 = audioBuffer.getChannelData(3);
+
+          // Verify that each output channel of the convolver matches
+          // the delayed signal from the reference
+          should(actual0, options.prefix + ': Channel 0')
+              .beEqualToArray(expected0);
+          should(actual1, options.prefix + ': Channel 1')
+              .beEqualToArray(expected1);
+        });
+      }
+
+      function channelCount1ExplicitTest(options, should) {
+        // Create an 4-channel offline context.  The first two channels are
+        // for the stereo output of the convolver and the next two channels
+        // are for the reference stereo signal.
+        let context = new OfflineAudioContext(4, renderFrames, sampleRate);
+        context.destination.channelInterpretation = 'discrete';
+        // Final merger to bring back the individual channels from the
+        // convolver and the reference in the right order for the
+        // destination.
+        let finalMerger = new ChannelMergerNode(
+            context, {numberOfInputs: context.destination.channelCount});
+        finalMerger.connect(context.destination);
+
+        // Create source using oscillators
+        let src = new Array(options.numberOfInputs);
+        for (let k = 0; k < src.length; ++k) {
+          src[k] = new OscillatorNode(
+              context, {type: 'square', frequency: 440 + 220 * k});
+        }
+
+        // Merger to combine the oscillators into one output stream.
+        let srcMerger =
+            new ChannelMergerNode(context, {numberOfInputs: src.length});
+        for (let k = 0; k < src.length; ++k) {
+          src[k].connect(srcMerger, 0, k);
+        }
+
+        // Convolver under test
+        let conv = new ConvolverNode(context, {
+          channelCount: 1,
+          channelCountMode: 'explicit',
+          disableNormalization: true,
+          buffer: response
+        });
+        srcMerger.connect(conv);
+
+        // Splitter to extract the channels of the test signal.
+        let splitter = new ChannelSplitterNode(context, {numberOfOutputs: 2});
+        conv.connect(splitter);
+
+        // Reference convolver, with a gain node to do the desired mixing.  The
+        // gain node should do the same thing that the convolver under test
+        // should do.
+        let gain = new GainNode(
+            context, {channelCount: 1, channelCountMode: 'explicit'});
+        let convRef = new ConvolverNode(
+            context, {disableNormalization: true, buffer: response});
+
+        srcMerger.connect(gain).connect(convRef);
+
+        // Splitter to extract the channels of the reference signal.
+        let refSplitter =
+            new ChannelSplitterNode(context, {numberOfOutputs: 2});
+
+        convRef.connect(refSplitter);
+
+        // Merge all the channels into one
+        splitter.connect(finalMerger, 0, 0);
+        splitter.connect(finalMerger, 1, 1);
+        refSplitter.connect(finalMerger, 0, 2);
+        refSplitter.connect(finalMerger, 1, 3);
+
+        // Start sources and render!
+        for (let k = 0; k < src.length; ++k) {
+          src[k].start();
+        }
+
+        return context.startRendering().then(buffer => {
+          // The output from the test convolver should be identical to
+          // the reference result.
+          let testOut0 = buffer.getChannelData(0);
+          let testOut1 = buffer.getChannelData(1);
+          let refOut0 = buffer.getChannelData(2);
+          let refOut1 = buffer.getChannelData(3);
+
+          should(testOut0, `${options.prefix}: output 0`)
+              .beEqualToArray(refOut0);
+          should(testOut1, `${options.prefix}: output 1`)
+              .beEqualToArray(refOut1);
+        })
+      }
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-setBuffer-already-has-value.html b/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-setBuffer-already-has-value.html
new file mode 100644
index 0000000000..ce2d5fcfe9
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-setBuffer-already-has-value.html
@@ -0,0 +1,51 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      convolver-setBuffer-already-has-value.html
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      audit.define('test', (task, should) => {
+        let context = new AudioContext();
+        let audioBuffer = new AudioBuffer(
+          {numberOfChannels: 1, length: 1, sampleRate: context.sampleRate});
+        let convolver = context.createConvolver();
+        should(() => {
+          convolver.buffer = null;
+        }, 'Set buffer to null before set non-null').notThrow();
+
+        should(() => {
+          convolver.buffer = audioBuffer;
+        }, 'Set buffer first normally').notThrow();
+
+        should(() => {
+          convolver.buffer = audioBuffer;
+        }, 'Set buffer a second time').notThrow();
+
+        should(() => {
+          convolver.buffer = null;
+        }, 'Set buffer to null').notThrow();
+
+        should(() => {
+          convolver.buffer = null;
+        }, 'Set buffer to null again, to make sure').notThrow();
+
+        should(() => {
+          convolver.buffer = audioBuffer;
+        }, 'Set buffer to non-null to verify it is set')
+        .notThrow();
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-setBuffer-null.html b/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-setBuffer-null.html
new file mode 100644
index 0000000000..d35b8ec54b
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-setBuffer-null.html
@@ -0,0 +1,31 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      convolver-setBuffer-null.html
+    </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 audit = Audit.createTaskRunner();
+
+      audit.define('test', function(task, should) {
+        let context = new AudioContext();
+        let conv = context.createConvolver();
+
+        should(() => {
+          conv.buffer = null;
+        }, 'Setting ConvolverNode impulse response buffer to null').notThrow();
+        should(conv.buffer === null, 'conv.buffer === null').beTrue();
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-upmixing-1-channel-response.html b/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-upmixing-1-channel-response.html
new file mode 100644
index 0000000000..b0b3a5965e
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/convolver-upmixing-1-channel-response.html
@@ -0,0 +1,143 @@
+<!DOCTYPE html>
+<title>Test that up-mixing signals in ConvolverNode processing is linear</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+const EPSILON = 3.0 * Math.pow(2, -22);
+// sampleRate is a power of two so that delay times are exact in base-2
+// floating point arithmetic.
+const SAMPLE_RATE = 32768;
+// Length of stereo convolver input in frames (arbitrary):
+const STEREO_FRAMES = 256;
+// Length of mono signal in frames.  This is more than two blocks to ensure
+// that at least one block will be mono, even if interpolation in the
+// DelayNode means that stereo is output one block earlier and later than
+// if frames are delayed without interpolation.
+const MONO_FRAMES = 384;
+// Length of response buffer:
+const RESPONSE_FRAMES = 256;
+
+function test_linear_upmixing(channelInterpretation, initial_mono_frames)
+{
+  let stereo_input_end = initial_mono_frames + STEREO_FRAMES;
+  // Total length:
+  let length = stereo_input_end + RESPONSE_FRAMES + MONO_FRAMES + STEREO_FRAMES;
+  // The first two channels contain signal where some up-mixing occurs
+  // internally to a ConvolverNode when a stereo signal is added and removed.
+  // The last two channels are expected to contain the same signal, but mono
+  // and stereo signals are convolved independently before up-mixing the mono
+  // output to mix with the stereo output.
+  let context = new OfflineAudioContext({numberOfChannels: 4,
+                                         length: length,
+                                         sampleRate: SAMPLE_RATE});
+
+  let response = new AudioBuffer({numberOfChannels: 1,
+                                  length: RESPONSE_FRAMES,
+                                  sampleRate: context.sampleRate});
+
+  // Two stereo channel splitters will collect test and reference outputs.
+  let destinationMerger = new ChannelMergerNode(context, {numberOfInputs: 4});
+  destinationMerger.connect(context.destination);
+  let testSplitter =
+      new ChannelSplitterNode(context, {numberOfOutputs: 2});
+  let referenceSplitter =
+      new ChannelSplitterNode(context, {numberOfOutputs: 2});
+  testSplitter.connect(destinationMerger, 0, 0);
+  testSplitter.connect(destinationMerger, 1, 1);
+  referenceSplitter.connect(destinationMerger, 0, 2);
+  referenceSplitter.connect(destinationMerger, 1, 3);
+
+  // A GainNode mixes reference stereo and mono signals because up-mixing
+  // cannot be performed at a channel splitter.
+  let referenceGain = new GainNode(context);
+  referenceGain.connect(referenceSplitter);
+  referenceGain.channelInterpretation = channelInterpretation;
+
+  // The impulse response for convolution contains two impulses so as to test
+  // effects in at least two processing blocks.
+  response.getChannelData(0)[0] = 0.5;
+  response.getChannelData(0)[response.length - 1] = 0.5;
+
+  let testConvolver = new ConvolverNode(context, {disableNormalization: true,
+                                                  buffer: response});
+  testConvolver.channelInterpretation = channelInterpretation;
+  let referenceMonoConvolver = new ConvolverNode(context,
+                                                 {disableNormalization: true,
+                                                  buffer: response});
+  let referenceStereoConvolver = new ConvolverNode(context,
+                                                   {disableNormalization: true,
+                                                    buffer: response});
+  // No need to set referenceStereoConvolver.channelInterpretation because
+  // input is either silent or stereo.
+  testConvolver.connect(testSplitter);
+  // Mix reference convolver output.
+  referenceMonoConvolver.connect(referenceGain);
+  referenceStereoConvolver.connect(referenceGain);
+
+  // The DelayNode initially has a single channel of silence, which is used to
+  // switch the stereo signal in and out.  The output of the delay node is
+  // first mono silence (if there is a non-zero initial_mono_frames), then
+  // stereo, then mono silence, and finally stereo again.  maxDelayTime is
+  // used to generate the middle mono silence period from the initial silence
+  // in the DelayNode and then generate the final period of stereo from its
+  // initial input.
+  let maxDelayTime = (length - STEREO_FRAMES) / context.sampleRate;
+  let delay =
+      new DelayNode(context,
+                    {maxDelayTime: maxDelayTime,
+                     delayTime: initial_mono_frames / context.sampleRate});
+  // Schedule an increase in the delay to return to mono silence.
+  delay.delayTime.setValueAtTime(maxDelayTime,
+                                 stereo_input_end / context.sampleRate);
+  delay.connect(testConvolver);
+  delay.connect(referenceStereoConvolver);
+
+  let stereoMerger = new ChannelMergerNode(context, {numberOfInputs: 2});
+  stereoMerger.connect(delay);
+
+  // Three independent signals
+  let monoSignal = new OscillatorNode(context, {frequency: 440});
+  let leftSignal = new OscillatorNode(context, {frequency: 450});
+  let rightSignal = new OscillatorNode(context, {frequency: 460});
+  monoSignal.connect(testConvolver);
+  monoSignal.connect(referenceMonoConvolver);
+  leftSignal.connect(stereoMerger, 0, 0);
+  rightSignal.connect(stereoMerger, 0, 1);
+  monoSignal.start();
+  leftSignal.start();
+  rightSignal.start();
+
+  return context.startRendering().
+    then((buffer) => {
+      let maxDiff = -1.0;
+      let frameIndex = 0;
+      let channelIndex = 0;
+      for (let c = 0; c < 2; ++c) {
+        let testOutput = buffer.getChannelData(0 + c);
+        let referenceOutput = buffer.getChannelData(2 + c);
+        for (var i = 0; i < buffer.length; ++i) {
+          var diff = Math.abs(testOutput[i] - referenceOutput[i]);
+          if (diff > maxDiff) {
+            maxDiff = diff;
+            frameIndex = i;
+            channelIndex = c;
+          }
+        }
+      }
+      assert_approx_equals(buffer.getChannelData(0 + channelIndex)[frameIndex],
+                           buffer.getChannelData(2 + channelIndex)[frameIndex],
+                           EPSILON,
+                           `output at ${frameIndex} ` +
+                             `in channel ${channelIndex}` );
+    });
+}
+
+promise_test(() => test_linear_upmixing("speakers", MONO_FRAMES),
+             "speakers, initially mono");
+promise_test(() => test_linear_upmixing("discrete", MONO_FRAMES),
+             "discrete");
+// Gecko uses a separate path for "speakers" up-mixing when the convolver's
+// first input is stereo, so test that separately.
+promise_test(() => test_linear_upmixing("speakers", 0),
+             "speakers, initially stereo");
+</script>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/ctor-convolver.html b/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/ctor-convolver.html
new file mode 100644
index 0000000000..28a0fc1c3c
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/ctor-convolver.html
@@ -0,0 +1,186 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Constructor: Convolver
+    </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, 'ConvolverNode', context);
+        task.done();
+      });
+
+      audit.define('default constructor', (task, should) => {
+        let prefix = 'node0';
+        let node = testDefaultConstructor(should, 'ConvolverNode', context, {
+          prefix: prefix,
+          numberOfInputs: 1,
+          numberOfOutputs: 1,
+          channelCount: 2,
+          channelCountMode: 'clamped-max',
+          channelInterpretation: 'speakers'
+        });
+
+        testDefaultAttributes(
+            should, node, prefix,
+            [{name: 'normalize', value: true}, {name: 'buffer', value: null}]);
+
+        task.done();
+      });
+
+      audit.define('test AudioNodeOptions', (task, should) => {
+        // Can't use testAudioNodeOptions because the constraints for this node
+        // are not supported there.
+        let node;
+
+        // An array of tests.
+        [{
+          // Test that we can set the channel count to 1 or 2 and that other
+          // channel counts throw an error.
+          attribute: 'channelCount',
+          tests: [
+            {value: 1}, {value: 2}, {value: 0, error: 'NotSupportedError'},
+            {value: 3, error: 'NotSupportedError'},
+            {value: 99, error: 'NotSupportedError'}
+          ]
+        },
+         {
+           // Test channelCountMode.  A mode of "max" is illegal, but others are
+           // ok.  But also throw an error of unknown values.
+           attribute: 'channelCountMode',
+           tests: [
+             {value: 'clamped-max'}, {value: 'explicit'},
+             {value: 'max', error: 'NotSupportedError'},
+             {value: 'foobar', error: TypeError}
+           ]
+         },
+         {
+           // Test channelInterpretation can be set for valid values and an
+           // error is thrown for others.
+           attribute: 'channelInterpretation',
+           tests: [
+             {value: 'speakers'}, {value: 'discrete'},
+             {value: 'foobar', error: TypeError}
+           ]
+         }].forEach(entry => {
+          entry.tests.forEach(testItem => {
+            let options = {};
+            options[entry.attribute] = testItem.value;
+
+            const testFunction = () => {
+              node = new ConvolverNode(context, options);
+            };
+            const testDescription =
+                `new ConvolverNode(c, ${JSON.stringify(options)})`;
+
+            if (testItem.error) {
+              testItem.error === TypeError
+              ? should(testFunction, testDescription).throw(TypeError)
+              : should(testFunction, testDescription)
+                  .throw(DOMException, 'NotSupportedError');
+            } else {
+              should(testFunction, testDescription).notThrow();
+              should(node[entry.attribute], `node.${entry.attribute}`)
+                  .beEqualTo(options[entry.attribute]);
+            }
+          });
+        });
+
+        task.done();
+      });
+
+      audit.define('nullable buffer', (task, should) => {
+        let node;
+        let options = {buffer: null};
+
+        should(
+            () => {
+              node = new ConvolverNode(context, options);
+            },
+            'node1 = new ConvolverNode(c, ' + JSON.stringify(options))
+            .notThrow();
+
+        should(node.buffer, 'node1.buffer').beEqualTo(null);
+
+        task.done();
+      });
+      audit.define('illegal sample-rate', (task, should) => {
+        let node;
+        let options = {buffer: context.createBuffer(1, 1, context.sampleRate / 2)};
+
+        should(
+            () => {
+              node = new ConvolverNode(context, options);
+            },
+            'node1 = new ConvolverNode(c, ' + JSON.stringify(options))
+            .throw(DOMException, 'NotSupportedError');
+
+        task.done();
+      });
+
+      audit.define('construct with options', (task, should) => {
+        let buf = context.createBuffer(1, 1, context.sampleRate);
+        let options = {buffer: buf, disableNormalization: false};
+
+        let message =
+            'node = new ConvolverNode(c, ' + JSON.stringify(options) + ')';
+
+        let node;
+        should(() => {
+          node = new ConvolverNode(context, options);
+        }, message).notThrow();
+
+        should(node instanceof ConvolverNode, 'node1 instanceOf ConvolverNode')
+            .beEqualTo(true);
+        should(node.buffer === options.buffer, 'node1.buffer === <buf>')
+            .beEqualTo(true);
+        should(node.normalize, 'node1.normalize')
+            .beEqualTo(!options.disableNormalization);
+
+        options.buffer = null;
+        options.disableNormalization = true;
+
+        message =
+            'node2 = new ConvolverNode(, ' + JSON.stringify(options) + ')';
+
+        should(() => {
+          node = new ConvolverNode(context, options);
+        }, message).notThrow();
+        should(node.buffer, 'node2.buffer').beEqualTo(null);
+        should(node.normalize, 'node2.normalize')
+            .beEqualTo(!options.disableNormalization);
+
+        options.disableNormalization = false;
+        message = 'node3 = new ConvolverNode(context, ' +
+            JSON.stringify(options) + ')';
+
+        should(() => {
+          node = new ConvolverNode(context, options);
+        }, message).notThrow();
+        should(node.buffer, 'node3.buffer').beEqualTo(null);
+        should(node.normalize, 'node3.normalize')
+            .beEqualTo(!options.disableNormalization);
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/realtime-conv.html b/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/realtime-conv.html
new file mode 100644
index 0000000000..8668e9d5ac
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/realtime-conv.html
@@ -0,0 +1,149 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Convolver on Real-time Context
+    </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/convolution-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      const audit = Audit.createTaskRunner();
+      // Choose a length that is larger enough to cause multiple threads to be
+      // used in the convolver.  For browsers that don't support this, this
+      // value doesn't matter.
+      const pulseLength = 16384;
+
+      // The computed SNR should be at least this large.  This value depends on
+      // teh platform and browser.  Don't set this value to be to much lower
+      // than this. It probably indicates a fairly inaccurate convolver or
+      // constant source node automations that should be fixed instead.
+      const minRequiredSNR = 77.03;
+
+      // To test the real-time convolver, we convolve two square pulses together
+      // to produce a triangular pulse.  To verify the result is correct we
+      // compare it against a constant source node configured to generate the
+      // expected ramp.
+      audit.define(
+          {label: 'test', description: 'Test convolver with real-time context'},
+          (task, should) => {
+            // Use a power of two for the sample rate to eliminate round-off in
+            // computing times from frames.
+            const context = new AudioContext({sampleRate: 16384});
+
+            // Square pulse for the convolver impulse response.
+            const squarePulse = new AudioBuffer(
+                {length: pulseLength, sampleRate: context.sampleRate});
+            squarePulse.getChannelData(0).fill(1);
+
+            const convolver = new ConvolverNode(
+                context, {buffer: squarePulse, disableNormalization: true});
+
+            // Square pulse for testing
+            const srcSquare = new ConstantSourceNode(context, {offset: 0});
+            srcSquare.connect(convolver);
+
+            // Reference ramp.  Automations on this constant source node will
+            // generate the desired ramp.
+            const srcRamp = new ConstantSourceNode(context, {offset: 0});
+
+            // Use these gain nodes to compute the difference between the
+            // convolver output and the expected ramp to create the error
+            // signal.
+            const inverter = new GainNode(context, {gain: -1});
+            const sum = new GainNode(context, {gain: 1});
+            convolver.connect(sum);
+            srcRamp.connect(inverter).connect(sum);
+
+            // Square the error signal using this gain node.
+            const squarer = new GainNode(context, {gain: 0});
+            sum.connect(squarer);
+            sum.connect(squarer.gain);
+
+            // Merge the error signal and the square source so we can integrate
+            // the error signal to find an SNR.
+            const merger = new ChannelMergerNode(context, {numberOfInputs: 2});
+
+            squarer.connect(merger, 0, 0);
+            srcSquare.connect(merger, 0, 1);
+
+            // For simplicity, use a ScriptProcessor to integrate the error
+            // signal. The square pulse signal is used as a gate over which the
+            // integration is done.  When the pulse ends, the SNR is computed
+            // and the test ends.
+
+            // |doSum| is used to determine when to integrate and when it
+            // becomes false, it signals the end of integration.
+            let doSum = false;
+
+            // |signalSum| is the energy in the square pulse.  |errorSum| is the
+            // energy in the error signal.
+            let signalSum = 0;
+            let errorSum = 0;
+
+            let spn = context.createScriptProcessor(0, 2, 1);
+            spn.onaudioprocess = (event) => {
+              // Sum the values on the first channel when the second channel is
+              // not zero.  When the second channel goes from non-zero to 0,
+              // dump the value out and terminate the test.
+              let c0 = event.inputBuffer.getChannelData(0);
+              let c1 = event.inputBuffer.getChannelData(1);
+
+              for (let k = 0; k < c1.length; ++k) {
+                if (c1[k] == 0) {
+                  if (doSum) {
+                    doSum = false;
+                    // Square wave is now silent and we were integration, so we
+                    // can stop now and verify the SNR.
+                    should(10 * Math.log10(signalSum / errorSum), 'SNR')
+                        .beGreaterThanOrEqualTo(minRequiredSNR);
+                    spn.onaudioprocess = null;
+                    task.done();
+                  }
+                } else {
+                  // Signal is non-zero so sum up the values.
+                  doSum = true;
+                  errorSum += c0[k];
+                  signalSum += c1[k] * c1[k];
+                }
+              }
+            };
+
+            merger.connect(spn).connect(context.destination);
+
+            // Schedule everything to start a bit in the futurefrom now, and end
+            // pulseLength frames later.
+            let now = context.currentTime;
+
+            // |startFrame| is the number of frames to schedule ahead for
+            // testing.
+            const startFrame = 512;
+            const startTime = startFrame / context.sampleRate;
+            const pulseDuration = pulseLength / context.sampleRate;
+
+            // Create a square pulse in the constant source node.
+            srcSquare.offset.setValueAtTime(1, now + startTime);
+            srcSquare.offset.setValueAtTime(0, now + startTime + pulseDuration);
+
+            // Create the reference ramp.
+            srcRamp.offset.setValueAtTime(1, now + startTime);
+            srcRamp.offset.linearRampToValueAtTime(
+                pulseLength,
+                now + startTime + pulseDuration - 1 / context.sampleRate);
+            srcRamp.offset.linearRampToValueAtTime(
+                0,
+                now + startTime + 2 * pulseDuration - 1 / context.sampleRate);
+
+            // Start the ramps!
+            srcRamp.start();
+            srcSquare.start();
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/transferred-buffer-output.html b/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/transferred-buffer-output.html
new file mode 100644
index 0000000000..e37a98c386
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-convolvernode-interface/transferred-buffer-output.html
@@ -0,0 +1,107 @@
+<!doctype html>
+<html>
+  <head>
+    <title>
+      Test Convolver Output with Transferred Buffer
+    </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>
+      // Arbitrary sample rate.
+      const sampleRate = 16000;
+
+      // Number of frames to render.  Just need to have at least 2 render
+      // quanta.
+      const lengthInFrames = 10 * RENDER_QUANTUM_FRAMES;
+
+      let audit = Audit.createTaskRunner();
+
+      // Buffer to use for the impulse response of a ConvolverNode.
+      let impulseBuffer;
+
+      // This sets up a worker to receive one channel of an AudioBuffer.
+      function setUpWorkerForTest() {
+        impulseBuffer = new AudioBuffer({
+          numberOfChannels: 2,
+          length: 2 * RENDER_QUANTUM_FRAMES,
+          sampleRate: sampleRate
+        });
+
+        // Just fill the buffer with a constant value; the contents shouldn't
+        // matter for this test since we're transferring one of the channels.
+        impulseBuffer.getChannelData(0).fill(1);
+        impulseBuffer.getChannelData(1).fill(2);
+
+        // We're going to transfer channel 0 to the worker, making it
+        // unavailable for the convolver
+        let data = impulseBuffer.getChannelData(0).buffer;
+
+        let string = [
+          'onmessage = function(e) {', '    postMessage(\'done\');', '};'
+        ].join('\n');
+
+        let blobURL = URL.createObjectURL(new Blob([string]));
+        let worker = new Worker(blobURL);
+        worker.onmessage = workerReply;
+        worker.postMessage(data, [data]);
+      }
+
+      function workerReply() {
+        // Worker has received the message.  Run the test.
+        audit.run();
+      }
+
+      audit.define(
+          {
+            label: 'Test Convolver with transferred buffer',
+            description: 'Output should be all zeroes'
+          },
+          async (task, should) => {
+            // Two channels so we can capture the output of the convolver with a
+            // stereo convolver.
+            let context = new OfflineAudioContext({
+              numberOfChannels: 2,
+              length: lengthInFrames,
+              sampleRate: sampleRate
+            });
+
+            // Use a simple constant source so we easily check that the
+            // convolver output is correct.
+            let source = new ConstantSourceNode(context);
+
+            // Create the convolver with the desired impulse response and
+            // disable normalization so we can easily check the output.
+            let conv = new ConvolverNode(
+                context, {disableNormalization: true, buffer: impulseBuffer});
+
+            source.connect(conv).connect(context.destination);
+
+            source.start();
+
+            let renderedBuffer = await context.startRendering();
+
+            // Get the actual data
+            let c0 = renderedBuffer.getChannelData(0);
+            let c1 = renderedBuffer.getChannelData(1);
+
+            // Since one channel was transferred, we must behave as if all were
+            // transferred.  Hence, the output should be all zeroes for both
+            // channels.
+            should(c0, `Convolver channel 0 output[0:${c0.length - 1}]`)
+                .beConstantValueOf(0);
+
+            should(c1, `Convolver channel 1 output[0:${c1.length - 1}]`)
+                .beConstantValueOf(0);
+
+            task.done();
+          });
+
+      setUpWorkerForTest();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/ctor-delay.html b/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/ctor-delay.html
new file mode 100644
index 0000000000..e7ccefc655
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/ctor-delay.html
@@ -0,0 +1,76 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Constructor: Delay
+    </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, 'DelayNode', context);
+        task.done();
+      });
+
+      audit.define('default constructor', (task, should) => {
+        let prefix = 'node0';
+        let node = testDefaultConstructor(should, 'DelayNode', context, {
+          prefix: prefix,
+          numberOfInputs: 1,
+          numberOfOutputs: 1,
+          channelCount: 2,
+          channelCountMode: 'max',
+          channelInterpretation: 'speakers'
+        });
+
+        testDefaultAttributes(
+            should, node, prefix, [{name: 'delayTime', value: 0}]);
+
+        task.done();
+      });
+
+      audit.define('test AudioNodeOptions', (task, should) => {
+        testAudioNodeOptions(should, context, 'DelayNode');
+        task.done();
+      });
+
+      audit.define('constructor options', (task, should) => {
+        let node;
+        let options = {
+          delayTime: 0.5,
+          maxDelayTime: 1.5,
+        };
+
+        should(
+            () => {
+              node = new DelayNode(context, options);
+            },
+            'node1 = new DelayNode(c, ' + JSON.stringify(options) + ')')
+            .notThrow();
+
+        should(node.delayTime.value, 'node1.delayTime.value')
+            .beEqualTo(options.delayTime);
+        should(node.delayTime.maxValue, 'node1.delayTime.maxValue')
+            .beEqualTo(options.maxDelayTime);
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delay-test.html b/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delay-test.html
new file mode 100644
index 0000000000..6277c253ec
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delay-test.html
@@ -0,0 +1,61 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Test DelayNode Delay</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>
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {label: 'test0', description: 'Test delay of 3 frames'},
+          async (task, should) => {
+            // Only need a few outputs samples.  The sample rate is arbitrary.
+            const context =
+                new OfflineAudioContext(1, RENDER_QUANTUM_FRAMES, 8192);
+            let src;
+            let delay;
+
+            should(
+                () => {
+                  src = new ConstantSourceNode(context);
+                  delay = new DelayNode(context);
+                },
+                'Creating ConstantSourceNode(context) and DelayNode(context)')
+                .notThrow();
+
+            // The number of frames to delay for the DelayNode.  Should be a
+            // whole number, but is otherwise arbitrary.
+            const delayFrames = 3;
+
+            should(() => {
+              delay.delayTime.value = delayFrames / context.sampleRate;
+            }, `Setting delayTime to ${delayFrames} frames`).notThrow();
+
+            src.connect(delay).connect(context.destination);
+
+            src.start();
+
+            let buffer = await context.startRendering();
+            let output = buffer.getChannelData(0);
+
+            // Verify output was delayed the correct number of frames.
+            should(output.slice(0, delayFrames), `output[0:${delayFrames - 1}]`)
+                .beConstantValueOf(0);
+            should(
+                output.slice(delayFrames),
+                `output[${delayFrames}:${output.length - 1}]`)
+                .beConstantValueOf(1);
+
+            task.done();
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode-channel-count-1.html b/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode-channel-count-1.html
new file mode 100644
index 0000000000..dd964ef9e3
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode-channel-count-1.html
@@ -0,0 +1,104 @@
+<!DOCTYPE html>
+<title>Test that DelayNode output channelCount matches that of the delayed input</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+// See https://github.com/WebAudio/web-audio-api/issues/25
+
+// sampleRate is a power of two so that delay times are exact in base-2
+// floating point arithmetic.
+const SAMPLE_RATE = 32768;
+// Arbitrary delay time in frames (but this is assumed a multiple of block
+// size below):
+const DELAY_FRAMES = 3 * 128;
+// Implementations may apply interpolation to input samples, which can spread
+// the effect of input with larger channel counts over neighbouring blocks.
+// This test ignores enough neighbouring blocks to ignore the effects of
+// filter radius of up to this number of frames:
+const INTERPOLATION_GRACE = 128;
+// Number of frames of DelayNode output that are known to be stereo:
+const STEREO_FRAMES = 128;
+// The delay will be increased at this frame to switch DelayNode output back
+// to mono.
+const MONO_OUTPUT_START_FRAME =
+  DELAY_FRAMES + INTERPOLATION_GRACE + STEREO_FRAMES;
+// Number of frames of output that are known to be mono after the known stereo
+// and interpolation grace.
+const MONO_FRAMES = 128;
+// Total length allows for interpolation after effects of stereo input are
+// finished and one block to test return to mono output:
+const TOTAL_LENGTH =
+  MONO_OUTPUT_START_FRAME + INTERPOLATION_GRACE + MONO_FRAMES;
+// maxDelayTime, is a multiple of block size, because the Gecko implementation
+// once had a bug with delayTime = maxDelayTime in this situation:
+const MAX_DELAY_FRAMES = TOTAL_LENGTH + INTERPOLATION_GRACE;
+
+promise_test(() => {
+  let context = new OfflineAudioContext({numberOfChannels: 1,
+                                         length: TOTAL_LENGTH,
+                                         sampleRate: SAMPLE_RATE});
+
+  // Only channel 1 of the splitter is connected to the destination.
+  let splitter = new ChannelSplitterNode(context, {numberOfOutputs: 2});
+  splitter.connect(context.destination, 1);
+
+  // A gain node has channelCountMode "max" and channelInterpretation
+  // "speakers", and so will up-mix a mono input when there is stereo input.
+  let gain = new GainNode(context);
+  gain.connect(splitter);
+
+  // The delay node initially outputs a single channel of silence, when it
+  // does not have enough signal in its history to output what it has
+  // previously received.  After the delay period, it will then output the
+  // stereo signal it received.
+  let delay =
+      new DelayNode(context,
+                    {maxDelayTime: MAX_DELAY_FRAMES / context.sampleRate,
+                     delayTime: DELAY_FRAMES / context.sampleRate});
+  // Schedule an increase in the delay to return to mono silent output from
+  // the unfilled portion of the DelayNode's buffer.
+  delay.delayTime.setValueAtTime(MAX_DELAY_FRAMES / context.sampleRate,
+                                 MONO_OUTPUT_START_FRAME / context.sampleRate);
+  delay.connect(gain);
+
+  let stereoMerger = new ChannelMergerNode(context, {numberOfInputs: 2});
+  stereoMerger.connect(delay);
+
+  let leftOffset = 0.125;
+  let rightOffset = 0.5;
+  let leftSource = new ConstantSourceNode(context, {offset: leftOffset});
+  let rightSource = new ConstantSourceNode(context, {offset: rightOffset});
+  leftSource.start();
+  rightSource.start();
+  leftSource.connect(stereoMerger, 0, 0);
+  rightSource.connect(stereoMerger, 0, 1);
+  // Connect a mono source directly to the gain, so that even stereo silence
+  // will be detected in channel 1 of the gain output because it will cause
+  // the mono source to be up-mixed.
+  let monoOffset = 0.25
+  let monoSource = new ConstantSourceNode(context, {offset: monoOffset});
+  monoSource.start();
+  monoSource.connect(gain);
+
+  return context.startRendering().
+    then((buffer) => {
+      let output = buffer.getChannelData(0);
+
+      function assert_samples_equal(startIndex, length, expected, description)
+      {
+        for (let i = startIndex; i < startIndex + length; ++i) {
+          assert_equals(output[i], expected, description + ` at ${i}`);
+        }
+      }
+
+      assert_samples_equal(0, DELAY_FRAMES - INTERPOLATION_GRACE,
+                           0, "Initial mono");
+      assert_samples_equal(DELAY_FRAMES + INTERPOLATION_GRACE, STEREO_FRAMES,
+                           monoOffset + rightOffset, "Stereo");
+      assert_samples_equal(MONO_OUTPUT_START_FRAME + INTERPOLATION_GRACE,
+                           MONO_FRAMES,
+                           0, "Final mono");
+    });
+});
+
+</script>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode-max-default-delay.html b/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode-max-default-delay.html
new file mode 100644
index 0000000000..ef526c96ff
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode-max-default-delay.html
@@ -0,0 +1,49 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      delaynode-max-default-delay.html
+    </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/delay-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {
+            label: 'test',
+            description: 'DelayNode with delay set to default maximum delay'
+          },
+          function(task, should) {
+
+            // Create offline audio context.
+            let context = new OfflineAudioContext(
+                1, sampleRate * renderLengthSeconds, sampleRate);
+            let toneBuffer = createToneBuffer(
+                context, 20, 20 * toneLengthSeconds, sampleRate);  // 20Hz tone
+
+            let bufferSource = context.createBufferSource();
+            bufferSource.buffer = toneBuffer;
+
+            let delay = context.createDelay();
+            delayTimeSeconds = 1;
+            delay.delayTime.value = delayTimeSeconds;
+
+            bufferSource.connect(delay);
+            delay.connect(context.destination);
+            bufferSource.start(0);
+
+            context.startRendering()
+                .then(buffer => checkDelayedResult(buffer, toneBuffer, should))
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode-max-nondefault-delay.html b/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode-max-nondefault-delay.html
new file mode 100644
index 0000000000..3be07255e1
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode-max-nondefault-delay.html
@@ -0,0 +1,51 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      delaynode-max-nondefault-delay.html
+    </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/delay-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {
+            label: 'test',
+            description: 'DelayNode with delay set to non-default maximum delay'
+          },
+          function(task, should) {
+
+            // Create offline audio context.
+            let context = new OfflineAudioContext(
+                1, sampleRate * renderLengthSeconds, sampleRate);
+            let toneBuffer = createToneBuffer(
+                context, 20, 20 * toneLengthSeconds, sampleRate);  // 20Hz tone
+
+            let bufferSource = context.createBufferSource();
+            bufferSource.buffer = toneBuffer;
+
+            let maxDelay = 1.5;
+            let delay = context.createDelay(maxDelay);
+            delayTimeSeconds = maxDelay;
+            delay.delayTime.value = delayTimeSeconds;
+
+            bufferSource.connect(delay);
+            delay.connect(context.destination);
+            bufferSource.start(0);
+
+            context.startRendering()
+                .then(buffer => checkDelayedResult(buffer, toneBuffer, should))
+                .then(() => task.done());
+            ;
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode-maxdelay.html b/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode-maxdelay.html
new file mode 100644
index 0000000000..a43ceeb7be
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode-maxdelay.html
@@ -0,0 +1,54 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      delaynode-maxdelay.html
+    </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/delay-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {
+            label: 'test',
+            description:
+                'Basic functionality of DelayNode with a non-default max delay time'
+          },
+          function(task, should) {
+
+            // Create offline audio context.
+            let context = new OfflineAudioContext(
+                1, sampleRate * renderLengthSeconds, sampleRate);
+            let toneBuffer = createToneBuffer(
+                context, 20, 20 * toneLengthSeconds, sampleRate);  // 20Hz tone
+
+            let bufferSource = context.createBufferSource();
+            bufferSource.buffer = toneBuffer;
+
+            // Create a delay node with an explicit max delay time (greater than
+            // the default of 1 second).
+            let delay = context.createDelay(2);
+            // Set the delay time to a value greater than the default max delay
+            // so we can verify the delay is working for this case.
+            delayTimeSeconds = 1.5;
+            delay.delayTime.value = delayTimeSeconds;
+
+            bufferSource.connect(delay);
+            delay.connect(context.destination);
+            bufferSource.start(0);
+
+            context.startRendering()
+                .then(buffer => checkDelayedResult(buffer, toneBuffer, should))
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode-maxdelaylimit.html b/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode-maxdelaylimit.html
new file mode 100644
index 0000000000..caf2f85dfd
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode-maxdelaylimit.html
@@ -0,0 +1,68 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      delaynode-maxdelaylimit.html
+    </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/delay-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {
+            label: 'test',
+            description:
+                'Tests attribute and maximum allowed delay of DelayNode'
+          },
+          function(task, should) {
+
+            // Create offline audio context.
+            let context = new OfflineAudioContext(
+                1, sampleRate * renderLengthSeconds, sampleRate);
+            let toneBuffer = createToneBuffer(
+                context, 20, 20 * toneLengthSeconds, sampleRate);  // 20Hz tone
+
+            let bufferSource = context.createBufferSource();
+            bufferSource.buffer = toneBuffer;
+
+            window.context = context;
+            should(() => context.createDelay(180),
+                   'Setting Delay length to 180 seconds or more')
+                .throw(DOMException, 'NotSupportedError');
+            should(() => context.createDelay(0),
+                   'Setting Delay length to 0 seconds')
+                .throw(DOMException, 'NotSupportedError');
+            should(() => context.createDelay(-1),
+                   'Setting Delay length to negative')
+                .throw(DOMException, 'NotSupportedError');
+            should(() => context.createDelay(NaN),
+                   'Setting Delay length to NaN')
+                .throw(TypeError);
+
+            let delay = context.createDelay(179);
+            delay.delayTime.value = delayTimeSeconds;
+            window.delay = delay;
+            should(
+                delay.delayTime.value,
+                'delay.delayTime.value = ' + delayTimeSeconds)
+                .beEqualTo(delayTimeSeconds);
+
+            bufferSource.connect(delay);
+            delay.connect(context.destination);
+            bufferSource.start(0);
+
+            context.startRendering()
+                .then(buffer => checkDelayedResult(buffer, toneBuffer, should))
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode-scheduling.html b/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode-scheduling.html
new file mode 100644
index 0000000000..af6c54950a
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode-scheduling.html
@@ -0,0 +1,51 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      delaynode-scheduling.html
+    </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/delay-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {
+            label: 'test',
+            description:
+                'DelayNode delayTime parameter can be scheduled at a given time'
+          },
+          function(task, should) {
+
+            // Create offline audio context.
+            let context = new OfflineAudioContext(
+                1, sampleRate * renderLengthSeconds, sampleRate);
+            let toneBuffer = createToneBuffer(
+                context, 20, 20 * toneLengthSeconds, sampleRate);  // 20Hz tone
+
+            let bufferSource = context.createBufferSource();
+            bufferSource.buffer = toneBuffer;
+
+            let delay = context.createDelay();
+
+            // Schedule delay time at time zero.
+            delay.delayTime.setValueAtTime(delayTimeSeconds, 0);
+
+            bufferSource.connect(delay);
+            delay.connect(context.destination);
+            bufferSource.start(0);
+
+            context.startRendering()
+                .then(buffer => checkDelayedResult(buffer, toneBuffer, should))
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode.html b/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode.html
new file mode 100644
index 0000000000..da508e439f
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/delaynode.html
@@ -0,0 +1,61 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      delaynode.html
+    </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/delay-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {
+            label: 'test',
+            description: 'Tests attribute and basic functionality of DelayNode'
+          },
+          function(task, should) {
+
+            // Create offline audio context.
+            let context = new OfflineAudioContext(
+                1, sampleRate * renderLengthSeconds, sampleRate);
+            let toneBuffer = createToneBuffer(
+                context, 20, 20 * toneLengthSeconds, sampleRate);  // 20Hz tone
+
+            let bufferSource = context.createBufferSource();
+            bufferSource.buffer = toneBuffer;
+
+            let delay = context.createDelay();
+
+            window.delay = delay;
+            should(delay.numberOfInputs, 'delay.numberOfInputs').beEqualTo(1);
+            should(delay.numberOfOutputs, 'delay.numberOfOutputs').beEqualTo(1);
+            should(delay.delayTime.defaultValue, 'delay.delayTime.defaultValue')
+                .beEqualTo(0.0);
+            should(delay.delayTime.value, 'delay.delayTime.value')
+                .beEqualTo(0.0);
+
+            delay.delayTime.value = delayTimeSeconds;
+            should(
+                delay.delayTime.value,
+                'delay.delayTime.value = ' + delayTimeSeconds)
+                .beEqualTo(delayTimeSeconds);
+
+            bufferSource.connect(delay);
+            delay.connect(context.destination);
+            bufferSource.start(0);
+
+            context.startRendering()
+                .then(buffer => checkDelayedResult(buffer, toneBuffer, should))
+                .then(task.done.bind(task));
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/maxdelay-rounding.html b/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/maxdelay-rounding.html
new file mode 100644
index 0000000000..84d9f18138
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/maxdelay-rounding.html
@@ -0,0 +1,78 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test DelayNode when maxDelayTime requires rounding
+    </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 sampleRate = 44100;
+      let inputLengthSeconds = 1;
+      let renderLengthSeconds = 2;
+
+      // Delay for one second plus 0.4 of a sample frame, to test that
+      // DelayNode is properly rounding up when calculating its buffer
+      // size (crbug.com/1065110).
+      let delayTimeSeconds = 1 + 0.4 / sampleRate;
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {
+            label: 'maxdelay-rounding',
+            description: 'Test DelayNode when maxDelayTime requires rounding',
+          },
+          (task, should) => {
+            let context = new OfflineAudioContext({
+                numberOfChannels: 1,
+                length: sampleRate * renderLengthSeconds,
+                sampleRate: sampleRate,
+            });
+
+            // Create a constant source to use as input.
+            let src = new ConstantSourceNode(context);
+
+            // Create a DelayNode to delay for delayTimeSeconds.
+            let delay = new DelayNode(context, {
+                maxDelayTime: delayTimeSeconds,
+                delayTime: delayTimeSeconds,
+            });
+
+            src.connect(delay).connect(context.destination);
+
+            src.start();
+            context.startRendering()
+                .then(renderedBuffer => {
+                  let renderedData = renderedBuffer.getChannelData(0);
+
+                  // The first delayTimeSeconds of output should be silent.
+                  let expectedSilentFrames = Math.floor(
+                      delayTimeSeconds * sampleRate);
+
+                  should(
+                      renderedData.slice(0, expectedSilentFrames),
+                      `output[0:${expectedSilentFrames - 1}]`)
+                      .beConstantValueOf(0);
+
+                  // The rest should be non-silent: that is, there should
+                  // be at least one non-zero sample.  (Any reasonable
+                  // interpolation algorithm will make all these samples
+                  // non-zero, but I don't think that's guaranteed by the
+                  // spec, so we use a conservative test for now.)
+                  should(
+                      renderedData.slice(expectedSilentFrames),
+                      `output[${expectedSilentFrames}:]`)
+                      .notBeConstantValueOf(0);
+                })
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/no-dezippering.html b/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/no-dezippering.html
new file mode 100644
index 0000000000..ccca103a3b
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-delaynode-interface/no-dezippering.html
@@ -0,0 +1,184 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test DelayNode Has No Dezippering
+    </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">
+      // The sample rate must be a power of two to avoid any round-off errors in
+      // computing when to suspend a context on a rendering quantum boundary.
+      // Otherwise this is pretty arbitrary.
+      let sampleRate = 16384;
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {label: 'test0', description: 'Test DelayNode has no dezippering'},
+          (task, should) => {
+            let context = new OfflineAudioContext(1, sampleRate, sampleRate);
+
+            // Simple integer ramp for testing delay node
+            let buffer = new AudioBuffer(
+                {length: context.length, sampleRate: context.sampleRate});
+            let rampData = buffer.getChannelData(0);
+            for (let k = 0; k < rampData.length; ++k) {
+              rampData[k] = k + 1;
+            }
+
+            // |delay0Frame| is the initial delay in frames. |delay1Frame| is
+            // the new delay in frames.  These must be integers.
+            let delay0Frame = 64;
+            let delay1Frame = 16;
+
+            let src = new AudioBufferSourceNode(context, {buffer: buffer});
+            let delay = new DelayNode(
+                context, {delayTime: delay0Frame / context.sampleRate});
+
+            src.connect(delay).connect(context.destination);
+
+            // After a render quantum, change the delay to |delay1Frame|.
+            context.suspend(RENDER_QUANTUM_FRAMES / context.sampleRate)
+                .then(() => {
+                  delay.delayTime.value = delay1Frame / context.sampleRate;
+                })
+                .then(() => context.resume());
+
+            src.start();
+            context.startRendering()
+                .then(renderedBuffer => {
+                  let renderedData = renderedBuffer.getChannelData(0);
+
+                  // The first |delay0Frame| frames should be zero.
+                  should(
+                      renderedData.slice(0, delay0Frame),
+                      'output[0:' + (delay0Frame - 1) + ']')
+                      .beConstantValueOf(0);
+
+                  // Now we have the ramp should show up from the delay.
+                  let ramp0 =
+                      new Float32Array(RENDER_QUANTUM_FRAMES - delay0Frame);
+                  for (let k = 0; k < ramp0.length; ++k) {
+                    ramp0[k] = rampData[k];
+                  }
+
+                  should(
+                      renderedData.slice(delay0Frame, RENDER_QUANTUM_FRAMES),
+                      'output[' + delay0Frame + ':' +
+                          (RENDER_QUANTUM_FRAMES - 1) + ']')
+                      .beEqualToArray(ramp0);
+
+                  // After one rendering quantum, the delay is changed to
+                  // |delay1Frame|.
+                  let ramp1 =
+                      new Float32Array(context.length - RENDER_QUANTUM_FRAMES);
+                  for (let k = 0; k < ramp1.length; ++k) {
+                    // ramp1[k] = 1 + k + RENDER_QUANTUM_FRAMES - delay1Frame;
+                    ramp1[k] =
+                        rampData[k + RENDER_QUANTUM_FRAMES - delay1Frame];
+                  }
+                  should(
+                      renderedData.slice(RENDER_QUANTUM_FRAMES),
+                      'output[' + RENDER_QUANTUM_FRAMES + ':]')
+                      .beEqualToArray(ramp1);
+                })
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {label: 'test1', description: 'Test value setter and setValueAtTime'},
+          (task, should) => {
+            testWithAutomation(should, {prefix: '', threshold: 6.5819e-5})
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {label: 'test2', description: 'Test value setter and modulation'},
+          (task, should) => {
+            testWithAutomation(should, {
+              prefix: 'With modulation: ',
+              modulator: true
+            }).then(() => task.done());
+          });
+
+      // Compare .value setter with setValueAtTime, Optionally allow modulation
+      // of |delayTime|.
+      function testWithAutomation(should, options) {
+        let prefix = options.prefix;
+        // Channel 0 is the output of delay node using the setter and channel 1
+        // is the output using setValueAtTime.
+        let context = new OfflineAudioContext(2, sampleRate, sampleRate);
+
+        let merger = new ChannelMergerNode(
+            context, {numberOfInputs: context.destination.channelCount});
+        merger.connect(context.destination);
+
+        let src = new OscillatorNode(context);
+
+        // |delay0Frame| is the initial delay value in frames. |delay1Frame| is
+        // the new delay in frames. The values here are constrained only by the
+        // constraints for a DelayNode.  These are pretty arbitrary except we
+        // wanted them to be fractional so as not be on a frame boundary to
+        // test interpolation compared with |setValueAtTime()|..
+        let delay0Frame = 3.1;
+        let delay1Frame = 47.2;
+
+        let delayTest = new DelayNode(
+            context, {delayTime: delay0Frame / context.sampleRate});
+        let delayRef = new DelayNode(
+            context, {delayTime: delay0Frame / context.sampleRate});
+
+        src.connect(delayTest).connect(merger, 0, 0);
+        src.connect(delayRef).connect(merger, 0, 1);
+
+        if (options.modulator) {
+          // Fairly arbitrary modulation of the delay time, with a peak
+          // variation of 10 ms.
+          let mod = new OscillatorNode(context, {frequency: 1000});
+          let modGain = new GainNode(context, {gain: .01});
+          mod.connect(modGain);
+          modGain.connect(delayTest.delayTime);
+          modGain.connect(delayRef.delayTime);
+          mod.start();
+        }
+
+        // The time at which the delay time of |delayTest| node will be
+        // changed.  This MUST be on a render quantum boundary, but is
+        // otherwise arbitrary.
+        let changeTime = 3 * RENDER_QUANTUM_FRAMES / context.sampleRate;
+
+        // Schedule the delay change on |delayRef| and also apply the value
+        // setter for |delayTest| at |changeTime|.
+        delayRef.delayTime.setValueAtTime(
+            delay1Frame / context.sampleRate, changeTime);
+        context.suspend(changeTime)
+            .then(() => {
+              delayTest.delayTime.value = delay1Frame / context.sampleRate;
+            })
+            .then(() => context.resume());
+
+        src.start();
+
+        return context.startRendering().then(renderedBuffer => {
+          let actual = renderedBuffer.getChannelData(0);
+          let expected = renderedBuffer.getChannelData(1);
+
+          let match = should(actual, prefix + '.value setter output')
+                          .beCloseToArray(
+                              expected, {absoluteThreshold: options.threshold});
+          should(
+              match,
+              prefix + '.value setter output matches setValueAtTime output')
+              .beTrue();
+        });
+      }
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-destinationnode-interface/destination.html b/testing/web-platform/tests/webaudio/the-audio-api/the-destinationnode-interface/destination.html
new file mode 100644
index 0000000000..1af0e0f010
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-destinationnode-interface/destination.html
@@ -0,0 +1,51 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      AudioDestinationNode
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+  </head>
+  <body>
+    <script>
+      function assert_doesnt_throw(f, desc) {
+        try {
+          f();
+        } catch (e) {
+          assert_true(false, desc);
+          return;
+        }
+        assert_true(true, desc);
+      }
+
+      test(function() {
+          var ac = new AudioContext();
+
+          assert_equals(ac.destination.channelCount, 2,
+              "A DestinationNode should have two channels by default");
+
+          assert_greater_than_equal(ac.destination.maxChannelCount, 2,
+            "maxChannelCount should be >= 2");
+
+          assert_throws_dom("IndexSizeError", function() {
+              ac.destination.channelCount = ac.destination.maxChannelCount + 1
+              }, `Setting the channelCount to something greater than
+                  the maxChannelCount should throw IndexSizeError`);
+
+          assert_throws_dom("NotSupportedError", function() {
+              ac.destination.channelCount = 0;
+          }, "Setting the channelCount to 0 should throw NotSupportedError");
+
+          assert_doesnt_throw(function() {
+              ac.destination.channelCount = ac.destination.maxChannelCount;
+          }, "Setting the channelCount to maxChannelCount should not throw");
+
+          assert_doesnt_throw(function() {
+              ac.destination.channelCount = 1;
+          }, "Setting the channelCount to 1 should not throw");
+      });
+
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-dynamicscompressornode-interface/ctor-dynamicscompressor.html b/testing/web-platform/tests/webaudio/the-audio-api/the-dynamicscompressornode-interface/ctor-dynamicscompressor.html
new file mode 100644
index 0000000000..c2460dfa1d
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-dynamicscompressornode-interface/ctor-dynamicscompressor.html
@@ -0,0 +1,199 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Constructor: DynamicsCompressor
+    </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, 'DynamicsCompressorNode', context);
+        task.done();
+      });
+
+      audit.define('default constructor', (task, should) => {
+        let prefix = 'node0';
+        let node =
+            testDefaultConstructor(should, 'DynamicsCompressorNode', context, {
+              prefix: prefix,
+              numberOfInputs: 1,
+              numberOfOutputs: 1,
+              channelCount: 2,
+              channelCountMode: 'clamped-max',
+              channelInterpretation: 'speakers'
+            });
+
+        testDefaultAttributes(should, node, prefix, [
+          {name: 'threshold', value: -24}, {name: 'knee', value: 30},
+          {name: 'ratio', value: 12}, {name: 'reduction', value: 0},
+          {name: 'attack', value: Math.fround(0.003)},
+          {name: 'release', value: 0.25}
+        ]);
+
+        task.done();
+      });
+
+      audit.define('test AudioNodeOptions', (task, should) => {
+        // Can't use testAudioNodeOptions because the constraints for this node
+        // are not supported there.
+
+        // Array of test options to be run.  Each entry is a dictionary where
+        // |testAttribute| is the name of the attribute to be tested,
+        // |testValue| is the value to be used, and |expectedErrorType| is the
+        // error type if the test is expected to throw an error.
+        // |expectedErrorType| should be set only if the test does throw.
+        let testOptions = [
+          // Test channel count
+          {
+            testAttribute: 'channelCount',
+            testValue: 1,
+          },
+          {
+            testAttribute: 'channelCount',
+            testValue: 2,
+          },
+          {
+            testAttribute: 'channelCount',
+            testValue: 0,
+            expectedErrorType: 'NotSupportedError'
+          },
+          {
+            testAttribute: 'channelCount',
+            testValue: 3,
+            expectedErrorType: 'NotSupportedError'
+          },
+          {
+            testAttribute: 'channelCount',
+            testValue: 99,
+            expectedErrorType: 'NotSupportedError'
+          },
+          // Test channel count mode
+          {
+            testAttribute: 'channelCountMode',
+            testValue: 'clamped-max',
+          },
+          {
+            testAttribute: 'channelCountMode',
+            testValue: 'explicit',
+          },
+          {
+            testAttribute: 'channelCountMode',
+            testValue: 'max',
+            expectedErrorType: 'NotSupportedError'
+          },
+          {
+            testAttribute: 'channelCountMode',
+            testValue: 'foobar',
+            expectedErrorType: TypeError
+          },
+          // Test channel interpretation
+          {
+            testAttribute: 'channelInterpretation',
+            testValue: 'speakers',
+          },
+          {
+            testAttribute: 'channelInterpretation',
+            testValue: 'discrete',
+          },
+          {
+            testAttribute: 'channelInterpretation',
+            testValue: 'foobar',
+            expectedErrorType: TypeError
+          }
+        ];
+
+        testOptions.forEach((option) => {
+          let nodeOptions = {};
+          nodeOptions[option.testAttribute] = option.testValue;
+
+          testNode(should, context, {
+            nodeOptions: nodeOptions,
+            testAttribute: option.testAttribute,
+            expectedValue: option.testValue,
+            expectedErrorType: option.expectedErrorType
+          });
+        });
+
+        task.done();
+      });
+
+      audit.define('constructor with options', (task, should) => {
+        let node;
+        let options =
+            {threshold: -33, knee: 15, ratio: 7, attack: 0.625, release: 0.125};
+
+        should(
+            () => {
+              node = new DynamicsCompressorNode(context, options);
+            },
+            'node1 = new DynamicsCompressorNode(c, ' + JSON.stringify(options) +
+                ')')
+            .notThrow();
+        should(
+            node instanceof DynamicsCompressorNode,
+            'node1 instanceof DynamicsCompressorNode')
+            .beEqualTo(true);
+
+        should(node.threshold.value, 'node1.threshold.value')
+            .beEqualTo(options.threshold);
+        should(node.knee.value, 'node1.knee.value').beEqualTo(options.knee);
+        should(node.ratio.value, 'node1.ratio.value').beEqualTo(options.ratio);
+        should(node.attack.value, 'node1.attack.value')
+            .beEqualTo(options.attack);
+        should(node.release.value, 'node1.release.value')
+            .beEqualTo(options.release);
+
+        should(node.channelCount, 'node1.channelCount').beEqualTo(2);
+        should(node.channelCountMode, 'node1.channelCountMode')
+            .beEqualTo('clamped-max');
+        should(node.channelInterpretation, 'node1.channelInterpretation')
+            .beEqualTo('speakers');
+
+        task.done();
+      });
+
+      audit.run();
+
+      // Test possible options for DynamicsCompressor constructor.
+      function testNode(should, context, options) {
+        // Node to be tested
+        let node;
+
+        let createNodeFunction = () => {
+          return () => node =
+                     new DynamicsCompressorNode(context, options.nodeOptions);
+        };
+
+        let message = 'new DynamicsCompressorNode(c, ' +
+            JSON.stringify(options.nodeOptions) + ')';
+
+        if (options.expectedErrorType === TypeError) {
+          should(createNodeFunction(), message)
+              .throw(options.expectedErrorType);
+        } else if (options.expectedErrorType === 'NotSupportedError') {
+          should(createNodeFunction(), message)
+              .throw(DOMException, 'NotSupportedError');
+        } else {
+          should(createNodeFunction(), message).notThrow();
+          should(node[options.testAttribute], 'node.' + options.testAttribute)
+              .beEqualTo(options.expectedValue);
+        }
+      }
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-dynamicscompressornode-interface/dynamicscompressor-basic.html b/testing/web-platform/tests/webaudio/the-audio-api/the-dynamicscompressornode-interface/dynamicscompressor-basic.html
new file mode 100644
index 0000000000..6c602010d0
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-dynamicscompressornode-interface/dynamicscompressor-basic.html
@@ -0,0 +1,48 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      dynamicscompressor-basic.html
+    </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 audit = Audit.createTaskRunner();
+      let context;
+      let compressor;
+
+      audit.define(
+          {
+            label: 'test',
+            description: 'Basic tests for DynamicsCompressorNode API'
+          },
+          function(task, should) {
+
+            context = new AudioContext();
+            compressor = context.createDynamicsCompressor();
+
+            should(compressor.threshold.value, 'compressor.threshold.value')
+                .beEqualTo(-24);
+            should(compressor.knee.value, 'compressor.knee.value')
+                .beEqualTo(30);
+            should(compressor.ratio.value, 'compressor.ratio.value')
+                .beEqualTo(12);
+            should(compressor.attack.value, 'compressor.attack.value')
+                .beEqualTo(Math.fround(0.003));
+            should(compressor.release.value, 'compressor.release.value')
+                .beEqualTo(0.25);
+            should(typeof compressor.reduction, 'typeof compressor.reduction')
+                .beEqualTo('number');
+            should(compressor.reduction, 'compressor.reduction').beEqualTo(0);
+
+            task.done();
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-gainnode-interface/ctor-gain.html b/testing/web-platform/tests/webaudio/the-audio-api/the-gainnode-interface/ctor-gain.html
new file mode 100644
index 0000000000..dec273e969
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-gainnode-interface/ctor-gain.html
@@ -0,0 +1,79 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Constructor: Gain
+    </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, 'GainNode', context);
+        task.done();
+      });
+
+      audit.define('default constructor', (task, should) => {
+        let prefix = 'node0';
+        let node = testDefaultConstructor(should, 'GainNode', context, {
+          prefix: prefix,
+          numberOfInputs: 1,
+          numberOfOutputs: 1,
+          channelCount: 2,
+          channelCountMode: 'max',
+          channelInterpretation: 'speakers'
+        });
+
+        testDefaultAttributes(should, node, prefix, [{name: 'gain', value: 1}]);
+
+        task.done();
+      });
+
+      audit.define('test AudioNodeOptions', (task, should) => {
+        testAudioNodeOptions(should, context, 'GainNode');
+        task.done();
+      });
+
+      audit.define('constructor with options', (task, should) => {
+        let node;
+        let options = {
+          gain: -2,
+        };
+
+        should(
+            () => {
+              node = new GainNode(context, options);
+            },
+            'node1 = new GainNode(c, ' + JSON.stringify(options) + ')')
+            .notThrow();
+        should(node instanceof GainNode, 'node1 instanceof GainNode')
+            .beEqualTo(true);
+
+        should(node.gain.value, 'node1.gain.value').beEqualTo(options.gain);
+
+        should(node.channelCount, 'node1.channelCount').beEqualTo(2);
+        should(node.channelCountMode, 'node1.channelCountMode')
+            .beEqualTo('max');
+        should(node.channelInterpretation, 'node1.channelInterpretation')
+            .beEqualTo('speakers');
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-gainnode-interface/gain-basic.html b/testing/web-platform/tests/webaudio/the-audio-api/the-gainnode-interface/gain-basic.html
new file mode 100644
index 0000000000..de2ba11a7f
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-gainnode-interface/gain-basic.html
@@ -0,0 +1,37 @@
+<!DOCTYPE html>
+<!--
+Verifies GainNode attributes and their type.
+-->
+<html>
+  <head>
+    <title>
+      gain-basic.html
+    </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 audit = Audit.createTaskRunner();
+
+      audit.define('test', function(task, should) {
+        // Create audio context.
+        let context = new AudioContext();
+
+        // Create gain node.
+        let gainNode = context.createGain();
+
+        should(
+            gainNode.gain instanceof AudioParam,
+            'gainNode.gain instanceof AudioParam')
+            .beTrue();
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-gainnode-interface/gain.html b/testing/web-platform/tests/webaudio/the-audio-api/the-gainnode-interface/gain.html
new file mode 100644
index 0000000000..c41f4c9080
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-gainnode-interface/gain.html
@@ -0,0 +1,162 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Basic GainNode Functionality
+    </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">
+      // Tests that GainNode is properly scaling the gain.  We'll render 11
+      // notes, starting at a gain of 1.0, decreasing in gain by 0.1.  The 11th
+      // note will be of gain 0.0, so it should be silent (at the end in the
+      // rendered output).
+
+      let audit = Audit.createTaskRunner();
+
+      // Use a power of two to eliminate any round-off when converting frame to
+      // time.
+      let sampleRate = 32768;
+      // Make sure the buffer duration and spacing are all exact frame lengths
+      // so that the note spacing is also on frame boundaries to eliminate
+      // sub-sample accurate start of a ABSN.
+      let bufferDurationSeconds = Math.floor(0.125 * sampleRate) / sampleRate;
+      let numberOfNotes = 11;
+      // Leave about 20ms of silence, being sure this is an exact frame
+      // duration.
+      let noteSilence = Math.floor(0.020 * sampleRate) / sampleRate;
+      let noteSpacing = bufferDurationSeconds + noteSilence;
+
+      let lengthInSeconds = numberOfNotes * noteSpacing;
+
+      let context = 0;
+      let sinWaveBuffer = 0;
+
+      // Create a stereo AudioBuffer of duration |lengthInSeconds| consisting of
+      // a pure sine wave with the given |frequency|.  Both channels contain the
+      // same data.
+      function createSinWaveBuffer(lengthInSeconds, frequency) {
+        let audioBuffer =
+            context.createBuffer(2, lengthInSeconds * sampleRate, sampleRate);
+
+        let n = audioBuffer.length;
+        let channelL = audioBuffer.getChannelData(0);
+        let channelR = audioBuffer.getChannelData(1);
+
+        for (let i = 0; i < n; ++i) {
+          channelL[i] = Math.sin(frequency * 2.0 * Math.PI * i / sampleRate);
+          channelR[i] = channelL[i];
+        }
+
+        return audioBuffer;
+      }
+
+      function playNote(time, gain, merger) {
+        let source = context.createBufferSource();
+        source.buffer = sinWaveBuffer;
+
+        let gainNode = context.createGain();
+        gainNode.gain.value = gain;
+
+        let sourceSplitter = context.createChannelSplitter(2);
+        let gainSplitter = context.createChannelSplitter(2);
+
+        // Split the stereo channels from the source output and the gain output
+        // and merge them into the desired channels of the merger.
+        source.connect(gainNode).connect(gainSplitter);
+        source.connect(sourceSplitter);
+
+        gainSplitter.connect(merger, 0, 0);
+        gainSplitter.connect(merger, 1, 1);
+        sourceSplitter.connect(merger, 0, 2);
+        sourceSplitter.connect(merger, 1, 3);
+
+        source.start(time);
+      }
+
+      audit.define(
+          {label: 'create context', description: 'Create context for test'},
+          function(task, should) {
+            // Create offline audio context.
+            context = new OfflineAudioContext(
+                4, sampleRate * lengthInSeconds, sampleRate);
+            task.done();
+          });
+
+      audit.define(
+          {label: 'test', description: 'GainNode functionality'},
+          function(task, should) {
+            let merger = new ChannelMergerNode(
+                context, {numberOfInputs: context.destination.channelCount});
+            merger.connect(context.destination);
+
+            // Create a buffer for a short "note".
+            sinWaveBuffer = createSinWaveBuffer(bufferDurationSeconds, 880.0);
+
+            let startTimes = [];
+            let gainValues = [];
+
+            // Render 11 notes, starting at a gain of 1.0, decreasing in gain by
+            // 0.1. The last note will be of gain 0.0, so shouldn't be
+            // perceptible in the rendered output.
+            for (let i = 0; i < numberOfNotes; ++i) {
+              let time = i * noteSpacing;
+              let gain = 1.0 - i / (numberOfNotes - 1);
+              startTimes.push(time);
+              gainValues.push(gain);
+              playNote(time, gain, merger);
+            }
+
+            context.startRendering()
+                .then(buffer => {
+                  let actual0 = buffer.getChannelData(0);
+                  let actual1 = buffer.getChannelData(1);
+                  let reference0 = buffer.getChannelData(2);
+                  let reference1 = buffer.getChannelData(3);
+
+                  // It's ok to a frame too long since the sine pulses are
+                  // followed by silence.
+                  let bufferDurationFrames =
+                      Math.ceil(bufferDurationSeconds * context.sampleRate);
+
+                  // Apply the gains to the reference signal.
+                  for (let k = 0; k < startTimes.length; ++k) {
+                    // It's ok to be a frame early because the sine pulses are
+                    // preceded by silence.
+                    let startFrame =
+                        Math.floor(startTimes[k] * context.sampleRate);
+                    let gain = gainValues[k];
+                    for (let n = 0; n < bufferDurationFrames; ++n) {
+                      reference0[startFrame + n] *= gain;
+                      reference1[startFrame + n] *= gain;
+                    }
+                  }
+
+                  // Verify the channels are clsoe to the reference.
+                  should(actual0, 'Left output from gain node')
+                      .beCloseToArray(
+                          reference0, {relativeThreshold: 1.1877e-7});
+                  should(actual1, 'Right output from gain node')
+                      .beCloseToArray(
+                          reference1, {relativeThreshold: 1.1877e-7});
+
+                  // Test the SNR too for both channels.
+                  let snr0 = 10 * Math.log10(computeSNR(actual0, reference0));
+                  let snr1 = 10 * Math.log10(computeSNR(actual1, reference1));
+                  should(snr0, 'Left SNR (in dB)')
+                      .beGreaterThanOrEqualTo(148.71);
+                  should(snr1, 'Right SNR (in dB)')
+                      .beGreaterThanOrEqualTo(148.71);
+                })
+                .then(() => task.done());
+            ;
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-gainnode-interface/no-dezippering.html b/testing/web-platform/tests/webaudio/the-audio-api/the-gainnode-interface/no-dezippering.html
new file mode 100644
index 0000000000..6326d00dfb
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-gainnode-interface/no-dezippering.html
@@ -0,0 +1,121 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Gain Dezippering Test: Dezippering Removed
+    </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 audit = Audit.createTaskRunner();
+
+      audit.define(
+          {label: 'test0', description: 'Dezippering of GainNode removed'},
+          (task, should) => {
+            // Only need a few frames to verify that dezippering has been
+            // removed from the GainNode.  Sample rate is pretty arbitrary.
+            let context = new OfflineAudioContext(1, 1024, 16000);
+
+            // Send a unit source to the gain node so we can measure the effect
+            // of the gain node.
+            let src = new ConstantSourceNode(context, {offset: 1});
+            let g = new GainNode(context, {gain: 1});
+            src.connect(g).connect(context.destination);
+
+            context.suspend(RENDER_QUANTUM_FRAMES / context.sampleRate)
+                .then(() => {
+                  g.gain.value = .5;
+                })
+                .then(() => context.resume());
+
+            src.start();
+
+            context.startRendering()
+                .then(audio => {
+                  let c = audio.getChannelData(0);
+
+                  // If dezippering has been removed, the gain output should
+                  // instantly jump at frame 128 to 0.5.
+                  should(c.slice(0, 128), 'output[0:127]').beConstantValueOf(1);
+                  should(c.slice(128), 'output[128:]').beConstantValueOf(0.5);
+                })
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: 'test2',
+            description: 'Compare value setter and setValueAtTime'
+          },
+          (task, should) => {
+            testWithAutomation(should, {prefix: ''}).then(() => task.done());
+          });
+
+      audit.define(
+          {label: 'test3', description: 'Automation effects'},
+          (task, should) => {
+            testWithAutomation(should, {
+              prefix: 'With modulation: ',
+              modulator: true
+            }).then(() => task.done());
+          });
+
+      audit.run();
+
+      function testWithAutomation(should, options) {
+        // Sample rate must be a power of two to eliminate round-off in
+        // computing the time at render quantum boundaries.
+        let context = new OfflineAudioContext(2, 1024, 16384);
+        let merger = new ChannelMergerNode(context, {numberOfChannels: 2});
+        merger.connect(context.destination);
+
+        let src = new OscillatorNode(context);
+        let gainTest = new GainNode(context);
+        let gainRef = new GainNode(context);
+
+        src.connect(gainTest).connect(merger, 0, 0);
+        src.connect(gainRef).connect(merger, 0, 1);
+
+        if (options.modulator) {
+          let mod = new OscillatorNode(context, {frequency: 1000});
+          let modGain = new GainNode(context);
+          mod.connect(modGain);
+          modGain.connect(gainTest.gain);
+          modGain.connect(gainRef.gain);
+          mod.start();
+        }
+
+        // Change the gains. Must do the change on a render boundary!
+        let changeTime = 3 * RENDER_QUANTUM_FRAMES / context.sampleRate;
+        let newGain = .3;
+
+        gainRef.gain.setValueAtTime(newGain, changeTime);
+        context.suspend(changeTime)
+            .then(() => gainTest.gain.value = newGain)
+            .then(() => context.resume());
+
+        src.start();
+
+        return context.startRendering().then(audio => {
+          let actual = audio.getChannelData(0);
+          let expected = audio.getChannelData(1);
+
+          // The values using the .value setter must be identical to the
+          // values using setValueAtTime.
+          let match = should(actual, options.prefix + '.value setter output')
+                          .beEqualToArray(expected);
+
+          should(
+              match,
+              options.prefix +
+                  '.value setter output matches setValueAtTime output')
+              .beTrue();
+        });
+      }
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-iirfilternode-interface/ctor-iirfilter.html b/testing/web-platform/tests/webaudio/the-audio-api/the-iirfilternode-interface/ctor-iirfilter.html
new file mode 100644
index 0000000000..e884d487af
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-iirfilternode-interface/ctor-iirfilter.html
@@ -0,0 +1,126 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Constructor: IIRFilter
+    </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, 'IIRFilterNode', context);
+        task.done();
+      });
+
+      audit.define('default constructor', (task, should) => {
+        let prefix = 'node0';
+        let node = testDefaultConstructor(should, 'IIRFilterNode', context, {
+          prefix: prefix,
+          numberOfInputs: 1,
+          numberOfOutputs: 1,
+          channelCount: 2,
+          channelCountMode: 'max',
+          channelInterpretation: 'speakers',
+          constructorOptions: {feedforward: [1], feedback: [1, -.9]}
+        });
+
+        task.done();
+      });
+
+      audit.define('test AudioNodeOptions', (task, should) => {
+        testAudioNodeOptions(
+            should, context, 'IIRFilterNode',
+            {additionalOptions: {feedforward: [1, 1], feedback: [1, .5]}});
+        task.done();
+      });
+
+      audit.define('constructor options', (task, should) => {
+        let node;
+
+        let options = {feedback: [1, .5]};
+        should(
+            () => {
+              node = new IIRFilterNode(context, options);
+            },
+            'node = new IIRFilterNode(, ' + JSON.stringify(options) + ')')
+            .throw(TypeError);
+
+        options = {feedforward: [1, 0.5]};
+        should(
+            () => {
+              node = new IIRFilterNode(context, options);
+            },
+            'node = new IIRFilterNode(c, ' + JSON.stringify(options) + ')')
+            .throw(TypeError);
+
+        task.done();
+      });
+
+      // Test functionality of constructor.  This is needed because we have no
+      // way of determining if the filter coefficients were were actually set
+      // appropriately.
+
+      // TODO(rtoy): This functionality test should be moved out to a separate
+      // file.
+      audit.define('functionality', (task, should) => {
+        let options = {feedback: [1, .5], feedforward: [1, 1]};
+
+        // Create two-channel offline context; sample rate and length are fairly
+        // arbitrary.  Channel 0 contains the test output and channel 1 contains
+        // the expected output.
+        let sampleRate = 48000;
+        let renderLength = 0.125;
+        let testContext =
+            new OfflineAudioContext(2, renderLength * sampleRate, sampleRate);
+
+        // The test node uses the constructor.  The reference node creates the
+        // same filter but uses the old factory method.
+        let testNode = new IIRFilterNode(testContext, options);
+        let refNode = testContext.createIIRFilter(
+            Float32Array.from(options.feedforward),
+            Float32Array.from(options.feedback));
+
+        let source = testContext.createOscillator();
+        source.connect(testNode);
+        source.connect(refNode);
+
+        let merger = testContext.createChannelMerger(
+            testContext.destination.channelCount);
+
+        testNode.connect(merger, 0, 0);
+        refNode.connect(merger, 0, 1);
+
+        merger.connect(testContext.destination);
+
+        source.start();
+        testContext.startRendering()
+            .then(function(resultBuffer) {
+              let actual = resultBuffer.getChannelData(0);
+              let expected = resultBuffer.getChannelData(1);
+
+              // The output from the two channels should be exactly equal
+              // because exactly the same IIR filter should have been created.
+              should(actual, 'Output of filter using new IIRFilter(...)')
+                  .beEqualToArray(expected);
+            })
+            .then(() => task.done());
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-iirfilternode-interface/iirfilter-basic.html b/testing/web-platform/tests/webaudio/the-audio-api/the-iirfilternode-interface/iirfilter-basic.html
new file mode 100644
index 0000000000..7828f05226
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-iirfilternode-interface/iirfilter-basic.html
@@ -0,0 +1,204 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Basic IIRFilterNode Properties
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="../../resources/audit-util.js"></script>
+    <script src="../../resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let sampleRate = 48000;
+      let testFrames = 100;
+
+      // Global context that can be used by the individual tasks. It must be
+      // defined by the initialize task.
+      let context;
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define('initialize', (task, should) => {
+        should(() => {
+          context = new OfflineAudioContext(1, testFrames, sampleRate);
+        }, 'Initialize context for testing').notThrow();
+        task.done();
+      });
+
+      audit.define('existence', (task, should) => {
+        should(context.createIIRFilter, 'context.createIIRFilter').exist();
+        task.done();
+      });
+
+      audit.define('parameters', (task, should) => {
+        // Create a really simple IIR filter. Doesn't much matter what.
+        let coef = Float32Array.from([1]);
+
+        let f = context.createIIRFilter(coef, coef);
+
+        should(f.numberOfInputs, 'numberOfInputs').beEqualTo(1);
+        should(f.numberOfOutputs, 'numberOfOutputs').beEqualTo(1);
+        should(f.channelCountMode, 'channelCountMode').beEqualTo('max');
+        should(f.channelInterpretation, 'channelInterpretation')
+            .beEqualTo('speakers');
+
+        task.done();
+      });
+
+      audit.define('exceptions-createIIRFilter', (task, should) => {
+        should(function() {
+          // Two args are required.
+          context.createIIRFilter();
+        }, 'createIIRFilter()').throw(TypeError);
+
+        should(function() {
+          // Two args are required.
+          context.createIIRFilter(new Float32Array(1));
+        }, 'createIIRFilter(new Float32Array(1))').throw(TypeError);
+
+        should(function() {
+          // null is not valid
+          context.createIIRFilter(null, null);
+        }, 'createIIRFilter(null, null)').throw(TypeError);
+
+        should(function() {
+          // There has to be at least one coefficient.
+          context.createIIRFilter([], []);
+        }, 'createIIRFilter([], [])').throw(DOMException, 'NotSupportedError');
+
+        should(function() {
+          // There has to be at least one coefficient.
+          context.createIIRFilter([1], []);
+        }, 'createIIRFilter([1], [])').throw(DOMException, 'NotSupportedError');
+
+        should(function() {
+          // There has to be at least one coefficient.
+          context.createIIRFilter([], [1]);
+        }, 'createIIRFilter([], [1])').throw(DOMException, 'NotSupportedError');
+
+        should(
+            function() {
+              // Max allowed size for the coefficient arrays.
+              let fb = new Float32Array(20);
+              fb[0] = 1;
+              context.createIIRFilter(fb, fb);
+            },
+            'createIIRFilter(new Float32Array(20), new Float32Array(20))')
+            .notThrow();
+
+        should(
+            function() {
+              // Max allowed size for the feedforward coefficient array.
+              let coef = new Float32Array(21);
+              coef[0] = 1;
+              context.createIIRFilter(coef, [1]);
+            },
+            'createIIRFilter(new Float32Array(21), [1])')
+            .throw(DOMException, 'NotSupportedError');
+
+        should(
+            function() {
+              // Max allowed size for the feedback coefficient array.
+              let coef = new Float32Array(21);
+              coef[0] = 1;
+              context.createIIRFilter([1], coef);
+            },
+            'createIIRFilter([1], new Float32Array(21))')
+            .throw(DOMException, 'NotSupportedError');
+
+        should(
+            function() {
+              // First feedback coefficient can't be 0.
+              context.createIIRFilter([1], new Float32Array(2));
+            },
+            'createIIRFilter([1], new Float32Array(2))')
+            .throw(DOMException, 'InvalidStateError');
+
+        should(
+            function() {
+              // feedforward coefficients can't all be zero.
+              context.createIIRFilter(new Float32Array(10), [1]);
+            },
+            'createIIRFilter(new Float32Array(10), [1])')
+            .throw(DOMException, 'InvalidStateError');
+
+        should(function() {
+          // Feedback coefficients must be finite.
+          context.createIIRFilter([1], [1, Infinity, NaN]);
+        }, 'createIIRFilter([1], [1, NaN, Infinity])').throw(TypeError);
+
+        should(function() {
+          // Feedforward coefficients must be finite.
+          context.createIIRFilter([1, Infinity, NaN], [1]);
+        }, 'createIIRFilter([1, NaN, Infinity], [1])').throw(TypeError);
+
+        should(function() {
+          // Test that random junk in the array is converted to NaN.
+          context.createIIRFilter([1, 'abc', []], [1]);
+        }, 'createIIRFilter([1, \'abc\', []], [1])').throw(TypeError);
+
+        task.done();
+      });
+
+      audit.define('exceptions-getFrequencyData', (task, should) => {
+        // Create a really simple IIR filter. Doesn't much matter what.
+        let coef = Float32Array.from([1]);
+
+        let f = context.createIIRFilter(coef, coef);
+
+        should(
+            function() {
+              // frequencyHz can't be null.
+              f.getFrequencyResponse(
+                  null, new Float32Array(1), new Float32Array(1));
+            },
+            'getFrequencyResponse(null, new Float32Array(1), new Float32Array(1))')
+            .throw(TypeError);
+
+        should(
+            function() {
+              // magResponse can't be null.
+              f.getFrequencyResponse(
+                  new Float32Array(1), null, new Float32Array(1));
+            },
+            'getFrequencyResponse(new Float32Array(1), null, new Float32Array(1))')
+            .throw(TypeError);
+
+        should(
+            function() {
+              // phaseResponse can't be null.
+              f.getFrequencyResponse(
+                  new Float32Array(1), new Float32Array(1), null);
+            },
+            'getFrequencyResponse(new Float32Array(1), new Float32Array(1), null)')
+            .throw(TypeError);
+
+        should(
+            function() {
+              // magResponse array must the same length as frequencyHz
+              f.getFrequencyResponse(
+                  new Float32Array(10), new Float32Array(1),
+                  new Float32Array(20));
+            },
+            'getFrequencyResponse(new Float32Array(10), new Float32Array(1), new Float32Array(20))')
+            .throw(DOMException, 'InvalidAccessError');
+
+        should(
+            function() {
+              // phaseResponse array must be the same length as frequencyHz
+              f.getFrequencyResponse(
+                  new Float32Array(10), new Float32Array(20),
+                  new Float32Array(1));
+            },
+            'getFrequencyResponse(new Float32Array(10), new Float32Array(20), new Float32Array(1))')
+            .throw(DOMException, 'InvalidAccessError');
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-iirfilternode-interface/iirfilter-getFrequencyResponse.html b/testing/web-platform/tests/webaudio/the-audio-api/the-iirfilternode-interface/iirfilter-getFrequencyResponse.html
new file mode 100644
index 0000000000..c98555f161
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-iirfilternode-interface/iirfilter-getFrequencyResponse.html
@@ -0,0 +1,159 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test IIRFilter getFrequencyResponse() functionality
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="../../resources/audit-util.js"></script>
+    <script src="../../resources/audit.js"></script>
+    <script src="../../resources/biquad-filters.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let sampleRate = 48000;
+      // Some short duration; we're not actually looking at the rendered output.
+      let testDurationSec = 0.01;
+
+      // Number of frequency samples to take.
+      let numberOfFrequencies = 1000;
+
+      let audit = Audit.createTaskRunner();
+
+
+      // Compute a set of linearly spaced frequencies.
+      function createFrequencies(nFrequencies, sampleRate) {
+        let frequencies = new Float32Array(nFrequencies);
+        let nyquist = sampleRate / 2;
+        let freqDelta = nyquist / nFrequencies;
+
+        for (let k = 0; k < nFrequencies; ++k) {
+          frequencies[k] = k * freqDelta;
+        }
+
+        return frequencies;
+      }
+
+      audit.define('1-pole IIR', (task, should) => {
+        let context = new OfflineAudioContext(
+            1, testDurationSec * sampleRate, sampleRate);
+
+        let iir = context.createIIRFilter([1], [1, -0.9]);
+        let frequencies =
+            createFrequencies(numberOfFrequencies, context.sampleRate);
+
+        let iirMag = new Float32Array(numberOfFrequencies);
+        let iirPhase = new Float32Array(numberOfFrequencies);
+        let trueMag = new Float32Array(numberOfFrequencies);
+        let truePhase = new Float32Array(numberOfFrequencies);
+
+        // The IIR filter is
+        //   H(z) = 1/(1 - 0.9*z^(-1)).
+        //
+        // The frequency response is
+        //   H(exp(j*w)) = 1/(1 - 0.9*exp(-j*w)).
+        //
+        // Thus, the magnitude is
+        //   |H(exp(j*w))| = 1/sqrt(1.81-1.8*cos(w)).
+        //
+        // The phase is
+        //   arg(H(exp(j*w)) = atan(0.9*sin(w)/(.9*cos(w)-1))
+
+        let frequencyScale = Math.PI / (sampleRate / 2);
+
+        for (let k = 0; k < frequencies.length; ++k) {
+          let omega = frequencyScale * frequencies[k];
+          trueMag[k] = 1 / Math.sqrt(1.81 - 1.8 * Math.cos(omega));
+          truePhase[k] =
+              Math.atan(0.9 * Math.sin(omega) / (0.9 * Math.cos(omega) - 1));
+        }
+
+        iir.getFrequencyResponse(frequencies, iirMag, iirPhase);
+
+        // Thresholds were experimentally determined.
+        should(iirMag, '1-pole IIR Magnitude Response')
+            .beCloseToArray(trueMag, {absoluteThreshold: 2.8611e-6});
+        should(iirPhase, '1-pole IIR Phase Response')
+            .beCloseToArray(truePhase, {absoluteThreshold: 1.7882e-7});
+
+        task.done();
+      });
+
+      audit.define('compare IIR and biquad', (task, should) => {
+        // Create an IIR filter equivalent to the biquad filter. Compute the
+        // frequency response for both and verify that they are the same.
+        let context = new OfflineAudioContext(
+            1, testDurationSec * sampleRate, sampleRate);
+
+        let biquad = context.createBiquadFilter();
+        let coef = createFilter(
+            biquad.type, biquad.frequency.value / (context.sampleRate / 2),
+            biquad.Q.value, biquad.gain.value);
+
+        let iir = context.createIIRFilter(
+            [coef.b0, coef.b1, coef.b2], [1, coef.a1, coef.a2]);
+
+        let frequencies =
+            createFrequencies(numberOfFrequencies, context.sampleRate);
+        let biquadMag = new Float32Array(numberOfFrequencies);
+        let biquadPhase = new Float32Array(numberOfFrequencies);
+        let iirMag = new Float32Array(numberOfFrequencies);
+        let iirPhase = new Float32Array(numberOfFrequencies);
+
+        biquad.getFrequencyResponse(frequencies, biquadMag, biquadPhase);
+        iir.getFrequencyResponse(frequencies, iirMag, iirPhase);
+
+        // Thresholds were experimentally determined.
+        should(iirMag, 'IIR Magnitude Response').beCloseToArray(biquadMag, {
+          absoluteThreshold: 2.7419e-5
+        });
+        should(iirPhase, 'IIR Phase Response').beCloseToArray(biquadPhase, {
+          absoluteThreshold: 2.7657e-5
+        });
+
+        task.done();
+      });
+
+      audit.define(
+          {
+            label: 'getFrequencyResponse',
+            description: 'Test out-of-bounds frequency values'
+          },
+          (task, should) => {
+            let context = new OfflineAudioContext(1, 1, sampleRate);
+            let filter = new IIRFilterNode(
+                context, {feedforward: [1], feedback: [1, -.9]});
+
+            // Frequencies to test.  These are all outside the valid range of
+            // frequencies of 0 to Nyquist.
+            let freq = new Float32Array(2);
+            freq[0] = -1;
+            freq[1] = context.sampleRate / 2 + 1;
+
+            let mag = new Float32Array(freq.length);
+            let phase = new Float32Array(freq.length);
+
+            filter.getFrequencyResponse(freq, mag, phase);
+
+            // Verify that the returned magnitude and phase entries are alL NaN
+            // since the frequencies are outside the valid range
+            for (let k = 0; k < mag.length; ++k) {
+              should(mag[k],
+                  'Magnitude response at frequency ' + freq[k])
+                  .beNaN();
+            }
+
+            for (let k = 0; k < phase.length; ++k) {
+              should(phase[k],
+                  'Phase response at frequency ' + freq[k])
+                  .beNaN();
+            }
+
+            task.done();
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-iirfilternode-interface/iirfilter.html b/testing/web-platform/tests/webaudio/the-audio-api/the-iirfilternode-interface/iirfilter.html
new file mode 100644
index 0000000000..aa38a6bfca
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-iirfilternode-interface/iirfilter.html
@@ -0,0 +1,572 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Basic IIRFilterNode Operation
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="../../resources/audit-util.js"></script>
+    <script src="../../resources/audit.js"></script>
+    <script src="../../resources/biquad-filters.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let sampleRate = 24000;
+      let testDurationSec = 0.25;
+      let testFrames = testDurationSec * sampleRate;
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define('coefficient-normalization', (task, should) => {
+        // Test that the feedback coefficients are normalized.  Do this be
+        // creating two IIRFilterNodes.  One has normalized coefficients, and
+        // one doesn't.  Compute the difference and make sure they're the same.
+        let context = new OfflineAudioContext(2, testFrames, sampleRate);
+
+        // Use a simple impulse as the source.
+        let buffer = context.createBuffer(1, 1, sampleRate);
+        buffer.getChannelData(0)[0] = 1;
+        let source = context.createBufferSource();
+        source.buffer = buffer;
+
+        // Gain node for computing the difference between the filters.
+        let gain = context.createGain();
+        gain.gain.value = -1;
+
+        // The IIR filters.  Use a common feedforward array.
+        let ff = [1];
+
+        let fb1 = [1, .9];
+
+        let fb2 = new Float64Array(2);
+        // Scale the feedback coefficients by an arbitrary factor.
+        let coefScaleFactor = 2;
+        for (let k = 0; k < fb2.length; ++k) {
+          fb2[k] = coefScaleFactor * fb1[k];
+        }
+
+        let iir1;
+        let iir2;
+
+        should(function() {
+          iir1 = context.createIIRFilter(ff, fb1);
+        }, 'createIIRFilter with normalized coefficients').notThrow();
+
+        should(function() {
+          iir2 = context.createIIRFilter(ff, fb2);
+        }, 'createIIRFilter with unnormalized coefficients').notThrow();
+
+        // Create the graph.  The output of iir1 (normalized coefficients) is
+        // channel 0, and the output of iir2 (unnormalized coefficients), with
+        // appropriate scaling, is channel 1.
+        let merger = context.createChannelMerger(2);
+        source.connect(iir1);
+        source.connect(iir2);
+        iir1.connect(merger, 0, 0);
+        iir2.connect(gain);
+
+        // The gain for the gain node should be set to compensate for the
+        // scaling of the coefficients.  Since iir2 has scaled the coefficients
+        // by coefScaleFactor, the output is reduced by the same factor, so
+        // adjust the gain to scale the output of iir2 back up.
+        gain.gain.value = coefScaleFactor;
+        gain.connect(merger, 0, 1);
+
+        merger.connect(context.destination);
+
+        source.start();
+
+        // Rock and roll!
+
+        context.startRendering()
+            .then(function(result) {
+              // Find the max amplitude of the result, which should be near
+              // zero.
+              let iir1Data = result.getChannelData(0);
+              let iir2Data = result.getChannelData(1);
+
+              // Threshold isn't exactly zero because the arithmetic is done
+              // differently between the IIRFilterNode and the BiquadFilterNode.
+              should(
+                  iir2Data,
+                  'Output of IIR filter with unnormalized coefficients')
+                  .beCloseToArray(iir1Data, {absoluteThreshold: 2.1958e-38});
+            })
+            .then(() => task.done());
+      });
+
+      audit.define('one-zero', (task, should) => {
+        // Create a simple 1-zero filter and compare with the expected output.
+        let context = new OfflineAudioContext(1, testFrames, sampleRate);
+
+        // Use a simple impulse as the source
+        let buffer = context.createBuffer(1, 1, sampleRate);
+        buffer.getChannelData(0)[0] = 1;
+        let source = context.createBufferSource();
+        source.buffer = buffer;
+
+        // The filter is y(n) = 0.5*(x(n) + x(n-1)), a simple 2-point moving
+        // average.  This is rather arbitrary; keep it simple.
+
+        let iir = context.createIIRFilter([0.5, 0.5], [1]);
+
+        // Create the graph
+        source.connect(iir);
+        iir.connect(context.destination);
+
+        // Rock and roll!
+        source.start();
+
+        context.startRendering()
+            .then(function(result) {
+              let actual = result.getChannelData(0);
+              let expected = new Float64Array(testFrames);
+              // The filter is a simple 2-point moving average of an impulse, so
+              // the first two values are non-zero and the rest are zero.
+              expected[0] = 0.5;
+              expected[1] = 0.5;
+              should(actual, 'IIR 1-zero output').beCloseToArray(expected, {
+                absoluteThreshold: 0
+              });
+            })
+            .then(() => task.done());
+      });
+
+      audit.define('one-pole', (task, should) => {
+        // Create a simple 1-pole filter and compare with the expected output.
+
+        // The filter is y(n) + c*y(n-1)= x(n).  The analytical response is
+        // (-c)^n, so choose a suitable number of frames to run the test for
+        // where the output isn't flushed to zero.
+        let c = 0.9;
+        let eps = 1e-20;
+        let duration = Math.floor(Math.log(eps) / Math.log(Math.abs(c)));
+        let context = new OfflineAudioContext(1, duration, sampleRate);
+
+        // Use a simple impulse as the source
+        let buffer = context.createBuffer(1, 1, sampleRate);
+        buffer.getChannelData(0)[0] = 1;
+        let source = context.createBufferSource();
+        source.buffer = buffer;
+
+        let iir = context.createIIRFilter([1], [1, c]);
+
+        // Create the graph
+        source.connect(iir);
+        iir.connect(context.destination);
+
+        // Rock and roll!
+        source.start();
+
+        context.startRendering()
+            .then(function(result) {
+              let actual = result.getChannelData(0);
+              let expected = new Float64Array(actual.length);
+
+              // The filter is a simple 1-pole filter: y(n) = -c*y(n-k)+x(n),
+              // with an impulse as the input.
+              expected[0] = 1;
+              for (k = 1; k < testFrames; ++k) {
+                expected[k] = -c * expected[k - 1];
+              }
+
+              // Threshold isn't exactly zero due to round-off in the
+              // single-precision IIRFilterNode computations versus the
+              // double-precision Javascript computations.
+              should(actual, 'IIR 1-pole output').beCloseToArray(expected, {
+                absoluteThreshold: 2.7657e-8
+              });
+            })
+            .then(() => task.done());
+      });
+
+      // Return a function suitable for use as a defineTask function.  This
+      // function creates an IIRFilterNode equivalent to the specified
+      // BiquadFilterNode and compares the outputs.  The outputs from the two
+      // filters should be virtually identical.
+      function testWithBiquadFilter(filterType, errorThreshold, snrThreshold) {
+        return (task, should) => {
+          let context = new OfflineAudioContext(2, testFrames, sampleRate);
+
+          // Use a constant (step function) as the source
+          let buffer = createConstantBuffer(context, testFrames, 1);
+          let source = context.createBufferSource();
+          source.buffer = buffer;
+
+
+          // Create the biquad.  Choose some rather arbitrary values for Q and
+          // gain for the biquad so that the shelf filters aren't identical.
+          let biquad = context.createBiquadFilter();
+          biquad.type = filterType;
+          biquad.Q.value = 10;
+          biquad.gain.value = 10;
+
+          // Create the equivalent IIR Filter node by computing the coefficients
+          // of the given biquad filter type.
+          let nyquist = sampleRate / 2;
+          let coef = createFilter(
+              filterType, biquad.frequency.value / nyquist, biquad.Q.value,
+              biquad.gain.value);
+
+          let iir = context.createIIRFilter(
+              [coef.b0, coef.b1, coef.b2], [1, coef.a1, coef.a2]);
+
+          let merger = context.createChannelMerger(2);
+          // Create the graph
+          source.connect(biquad);
+          source.connect(iir);
+
+          biquad.connect(merger, 0, 0);
+          iir.connect(merger, 0, 1);
+
+          merger.connect(context.destination);
+
+          // Rock and roll!
+          source.start();
+
+          context.startRendering()
+              .then(function(result) {
+                // Find the max amplitude of the result, which should be near
+                // zero.
+                let expected = result.getChannelData(0);
+                let actual = result.getChannelData(1);
+
+                // On MacOSX, WebAudio uses an optimized Biquad implementation
+                // that is different from the implementation used for Linux and
+                // Windows.  This will cause the output to differ, even if the
+                // threshold passes.  Thus, only print out a very small number
+                // of elements of the array where we have tested that they are
+                // consistent.
+                should(actual, 'IIRFilter for Biquad ' + filterType)
+                    .beCloseToArray(expected, errorThreshold);
+
+                let snr = 10 * Math.log10(computeSNR(actual, expected));
+                should(snr, 'SNR for IIRFIlter for Biquad ' + filterType)
+                    .beGreaterThanOrEqualTo(snrThreshold);
+              })
+              .then(() => task.done());
+        };
+      }
+
+      // Thresholds here are experimentally determined.
+      let biquadTestConfigs = [
+        {
+          filterType: 'lowpass',
+          snrThreshold: 91.221,
+          errorThreshold: {relativeThreshold: 4.9834e-5}
+        },
+        {
+          filterType: 'highpass',
+          snrThreshold: 105.4590,
+          errorThreshold: {absoluteThreshold: 2.9e-6, relativeThreshold: 3e-5}
+        },
+        {
+          filterType: 'bandpass',
+          snrThreshold: 104.060,
+          errorThreshold: {absoluteThreshold: 2e-7, relativeThreshold: 8.7e-4}
+        },
+        {
+          filterType: 'notch',
+          snrThreshold: 91.312,
+          errorThreshold: {absoluteThreshold: 0, relativeThreshold: 4.22e-5}
+        },
+        {
+          filterType: 'allpass',
+          snrThreshold: 91.319,
+          errorThreshold: {absoluteThreshold: 0, relativeThreshold: 4.31e-5}
+        },
+        {
+          filterType: 'lowshelf',
+          snrThreshold: 90.609,
+          errorThreshold: {absoluteThreshold: 0, relativeThreshold: 2.98e-5}
+        },
+        {
+          filterType: 'highshelf',
+          snrThreshold: 103.159,
+          errorThreshold: {absoluteThreshold: 0, relativeThreshold: 1.24e-5}
+        },
+        {
+          filterType: 'peaking',
+          snrThreshold: 91.504,
+          errorThreshold: {absoluteThreshold: 0, relativeThreshold: 5.05e-5}
+        }
+      ];
+
+      // Create a set of tasks based on biquadTestConfigs.
+      for (k = 0; k < biquadTestConfigs.length; ++k) {
+        let config = biquadTestConfigs[k];
+        let name = k + ': ' + config.filterType;
+        audit.define(
+            name,
+            testWithBiquadFilter(
+                config.filterType, config.errorThreshold, config.snrThreshold));
+      }
+
+      audit.define('multi-channel', (task, should) => {
+        // Multi-channel test.  Create a biquad filter and the equivalent IIR
+        // filter.  Filter the same multichannel signal and compare the results.
+        let nChannels = 3;
+        let context =
+            new OfflineAudioContext(nChannels, testFrames, sampleRate);
+
+        // Create a set of oscillators as the multi-channel source.
+        let source = [];
+
+        for (k = 0; k < nChannels; ++k) {
+          source[k] = context.createOscillator();
+          source[k].type = 'sawtooth';
+          // The frequency of the oscillator is pretty arbitrary, but each
+          // oscillator should have a different frequency.
+          source[k].frequency.value = 100 + k * 100;
+        }
+
+        let merger = context.createChannelMerger(3);
+
+        let biquad = context.createBiquadFilter();
+
+        // Create the equivalent IIR Filter node.
+        let nyquist = sampleRate / 2;
+        let coef = createFilter(
+            biquad.type, biquad.frequency.value / nyquist, biquad.Q.value,
+            biquad.gain.value);
+        let fb = [1, coef.a1, coef.a2];
+        let ff = [coef.b0, coef.b1, coef.b2];
+
+        let iir = context.createIIRFilter(ff, fb);
+        // Gain node to compute the difference between the IIR and biquad
+        // filter.
+        let gain = context.createGain();
+        gain.gain.value = -1;
+
+        // Create the graph.
+        for (k = 0; k < nChannels; ++k)
+          source[k].connect(merger, 0, k);
+
+        merger.connect(biquad);
+        merger.connect(iir);
+        iir.connect(gain);
+        biquad.connect(context.destination);
+        gain.connect(context.destination);
+
+        for (k = 0; k < nChannels; ++k)
+          source[k].start();
+
+        context.startRendering()
+            .then(function(result) {
+              let errorThresholds = [3.7671e-5, 3.0071e-5, 2.6241e-5];
+
+              // Check the difference signal on each channel
+              for (channel = 0; channel < result.numberOfChannels; ++channel) {
+                // Find the max amplitude of the result, which should be near
+                // zero.
+                let data = result.getChannelData(channel);
+                let maxError =
+                    data.reduce(function(reducedValue, currentValue) {
+                      return Math.max(reducedValue, Math.abs(currentValue));
+                    });
+
+                should(
+                    maxError,
+                    'Max difference between IIR and Biquad on channel ' +
+                        channel)
+                    .beLessThanOrEqualTo(errorThresholds[channel]);
+              }
+
+            })
+            .then(() => task.done());
+      });
+
+      // Apply an IIRFilter to the given input signal.
+      //
+      // IIR filter in the time domain is
+      //
+      //   y[n] = sum(ff[k]*x[n-k], k, 0, M) - sum(fb[k]*y[n-k], k, 1, N)
+      //
+      function iirFilter(input, feedforward, feedback) {
+        // For simplicity, create an x buffer that contains the input, and a y
+        // buffer that contains the output.  Both of these buffers have an
+        // initial work space to implement the initial memory of the filter.
+        let workSize = Math.max(feedforward.length, feedback.length);
+        let x = new Float32Array(input.length + workSize);
+
+        // Float64 because we want to match the implementation that uses doubles
+        // to minimize roundoff.
+        let y = new Float64Array(input.length + workSize);
+
+        // Copy the input over.
+        for (let k = 0; k < input.length; ++k)
+          x[k + feedforward.length] = input[k];
+
+        // Run the filter
+        for (let n = 0; n < input.length; ++n) {
+          let index = n + workSize;
+          let yn = 0;
+          for (let k = 0; k < feedforward.length; ++k)
+            yn += feedforward[k] * x[index - k];
+          for (let k = 0; k < feedback.length; ++k)
+            yn -= feedback[k] * y[index - k];
+
+          y[index] = yn;
+        }
+
+        return y.slice(workSize).map(Math.fround);
+      }
+
+      // Cascade the two given biquad filters to create one IIR filter.
+      function cascadeBiquads(f1Coef, f2Coef) {
+        // The biquad filters are:
+        //
+        // f1 = (b10 + b11/z + b12/z^2)/(1 + a11/z + a12/z^2);
+        // f2 = (b20 + b21/z + b22/z^2)/(1 + a21/z + a22/z^2);
+        //
+        // To cascade them, multiply the two transforms together to get a fourth
+        // order IIR filter.
+
+        let numProduct = [
+          f1Coef.b0 * f2Coef.b0, f1Coef.b0 * f2Coef.b1 + f1Coef.b1 * f2Coef.b0,
+          f1Coef.b0 * f2Coef.b2 + f1Coef.b1 * f2Coef.b1 + f1Coef.b2 * f2Coef.b0,
+          f1Coef.b1 * f2Coef.b2 + f1Coef.b2 * f2Coef.b1, f1Coef.b2 * f2Coef.b2
+        ];
+
+        let denProduct = [
+          1, f2Coef.a1 + f1Coef.a1,
+          f2Coef.a2 + f1Coef.a1 * f2Coef.a1 + f1Coef.a2,
+          f1Coef.a1 * f2Coef.a2 + f1Coef.a2 * f2Coef.a1, f1Coef.a2 * f2Coef.a2
+        ];
+
+        return {
+          ff: numProduct, fb: denProduct
+        }
+      }
+
+      // Find the magnitude of the root of the quadratic that has the maximum
+      // magnitude.
+      //
+      // The quadratic is z^2 + a1 * z + a2 and we want the root z that has the
+      // largest magnitude.
+      function largestRootMagnitude(a1, a2) {
+        let discriminant = a1 * a1 - 4 * a2;
+        if (discriminant < 0) {
+          // Complex roots:  -a1/2 +/- i*sqrt(-d)/2.  Thus the magnitude of each
+          // root is the same and is sqrt(a1^2/4 + |d|/4)
+          let d = Math.sqrt(-discriminant);
+          return Math.hypot(a1 / 2, d / 2);
+        } else {
+          // Real roots
+          let d = Math.sqrt(discriminant);
+          return Math.max(Math.abs((-a1 + d) / 2), Math.abs((-a1 - d) / 2));
+        }
+      }
+
+      audit.define('4th-order-iir', (task, should) => {
+        // Cascade 2 lowpass biquad filters and compare that with the equivalent
+        // 4th order IIR filter.
+
+        let nyquist = sampleRate / 2;
+        // Compute the coefficients of a lowpass filter.
+
+        // First some preliminary stuff.  Compute the coefficients of the
+        // biquad.  This is used to figure out how frames to use in the test.
+        let biquadType = 'lowpass';
+        let biquadCutoff = 350;
+        let biquadQ = 5;
+        let biquadGain = 1;
+
+        let coef = createFilter(
+            biquadType, biquadCutoff / nyquist, biquadQ, biquadGain);
+
+        // Cascade the biquads together to create an equivalent IIR filter.
+        let cascade = cascadeBiquads(coef, coef);
+
+        // Since we're cascading two identical biquads, the root of denominator
+        // of the IIR filter is repeated, so the root of the denominator with
+        // the largest magnitude occurs twice.  The impulse response of the IIR
+        // filter will be roughly c*(r*r)^n at time n, where r is the root of
+        // largest magnitude.  This approximation gets better as n increases.
+        // We can use this to get a rough idea of when the response has died
+        // down to a small value.
+
+        // This is the value we will use to determine how many frames to render.
+        // Rendering too many is a waste of time and also makes it hard to
+        // compare the actual result to the expected because the magnitudes are
+        // so small that they could be mostly round-off noise.
+        //
+        // Find magnitude of the root with largest magnitude
+        let rootMagnitude = largestRootMagnitude(coef.a1, coef.a2);
+
+        // Find n such that |r|^(2*n) <= eps.  That is, n = log(eps)/(2*log(r)).
+        // Somewhat arbitrarily choose eps = 1e-20;
+        let eps = 1e-20;
+        let framesForTest =
+            Math.floor(Math.log(eps) / (2 * Math.log(rootMagnitude)));
+
+        // We're ready to create the graph for the test.  The offline context
+        // has two channels: channel 0 is the expected (cascaded biquad) result
+        // and channel 1 is the actual IIR filter result.
+        let context = new OfflineAudioContext(2, framesForTest, sampleRate);
+
+        // Use a simple impulse with a large (arbitrary) amplitude as the source
+        let amplitude = 1;
+        let buffer = context.createBuffer(1, testFrames, sampleRate);
+        buffer.getChannelData(0)[0] = amplitude;
+        let source = context.createBufferSource();
+        source.buffer = buffer;
+
+        // Create the two biquad filters.  Doesn't really matter what, but for
+        // simplicity we choose identical lowpass filters with the same
+        // parameters.
+        let biquad1 = context.createBiquadFilter();
+        biquad1.type = biquadType;
+        biquad1.frequency.value = biquadCutoff;
+        biquad1.Q.value = biquadQ;
+
+        let biquad2 = context.createBiquadFilter();
+        biquad2.type = biquadType;
+        biquad2.frequency.value = biquadCutoff;
+        biquad2.Q.value = biquadQ;
+
+        let iir = context.createIIRFilter(cascade.ff, cascade.fb);
+
+        // Create the merger to get the signals into multiple channels
+        let merger = context.createChannelMerger(2);
+
+        // Create the graph, filtering the source through two biquads.
+        source.connect(biquad1);
+        biquad1.connect(biquad2);
+        biquad2.connect(merger, 0, 0);
+
+        source.connect(iir);
+        iir.connect(merger, 0, 1);
+
+        merger.connect(context.destination);
+
+        // Now filter the source through the IIR filter.
+        let y = iirFilter(buffer.getChannelData(0), cascade.ff, cascade.fb);
+
+        // Rock and roll!
+        source.start();
+
+        context.startRendering()
+            .then(function(result) {
+              let expected = result.getChannelData(0);
+              let actual = result.getChannelData(1);
+
+              should(actual, '4-th order IIRFilter (biquad ref)')
+                  .beCloseToArray(expected, {
+                    // Thresholds experimentally determined.
+                    absoluteThreshold: 1.59e-7,
+                    relativeThreshold: 2.11e-5,
+                  });
+
+              let snr = 10 * Math.log10(computeSNR(actual, expected));
+              should(snr, 'SNR of 4-th order IIRFilter (biquad ref)')
+                  .beGreaterThanOrEqualTo(108.947);
+            })
+            .then(() => task.done());
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-iirfilternode-interface/test-iirfilternode.html b/testing/web-platform/tests/webaudio/the-audio-api/the-iirfilternode-interface/test-iirfilternode.html
new file mode 100644
index 0000000000..001a2a6172
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-iirfilternode-interface/test-iirfilternode.html
@@ -0,0 +1,59 @@
+<!doctype html>
+<meta charset=utf-8>
+<title>Test the IIRFilterNode Interface</title>
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script>
+test(function(t) {
+  var ac = new AudioContext();
+
+  function check_args(arg1, arg2, err, desc) {
+    test(function() {
+      assert_throws_dom(err, function() {
+        ac.createIIRFilter(arg1, arg2)
+      })
+    }, desc)
+  }
+
+  check_args([], [1.0], 'NotSupportedError',
+             'feedforward coefficients can not be empty');
+
+  check_args([1.0], [], 'NotSupportedError',
+             'feedback coefficients can not be empty');
+
+  var coeff = new Float32Array(21)
+  coeff[0] = 1.0;
+
+  check_args(coeff, [1.0], 'NotSupportedError',
+             'more than 20 feedforward coefficients can not be used');
+
+  check_args([1.0], coeff, 'NotSupportedError',
+             'more than 20 feedback coefficients can not be used');
+
+  check_args([0.0, 0.0], [1.0], 'InvalidStateError',
+             'at least one feedforward coefficient must be non-zero');
+
+  check_args([0.5, 0.5], [0.0], 'InvalidStateError',
+             'the first feedback coefficient must be non-zero');
+
+}, "IIRFilterNode coefficients are checked properly");
+
+test(function(t) {
+  var ac = new AudioContext();
+
+  var frequencies = new Float32Array([-1.0, ac.sampleRate*0.5 - 1.0, ac.sampleRate]);
+  var magResults = new Float32Array(3);
+  var phaseResults = new Float32Array(3);
+
+  var filter = ac.createIIRFilter([0.5, 0.5], [1.0]);
+  filter.getFrequencyResponse(frequencies, magResults, phaseResults);
+
+  assert_true(isNaN(magResults[0]), "Invalid input frequency should give NaN magnitude response");
+  assert_true(!isNaN(magResults[1]), "Valid input frequency should not give NaN magnitude response");
+  assert_true(isNaN(magResults[2]), "Invalid input frequency should give NaN magnitude response");
+  assert_true(isNaN(phaseResults[0]), "Invalid input frequency should give NaN phase response");
+  assert_true(!isNaN(phaseResults[1]), "Valid input frequency should not give NaN phase response");
+  assert_true(isNaN(phaseResults[2]), "Invalid input frequency should give NaN phase response");
+
+}, "IIRFilterNode getFrequencyResponse handles invalid frequencies properly");
+</script>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-mediaelementaudiosourcenode-interface/cors-check.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-mediaelementaudiosourcenode-interface/cors-check.https.html
new file mode 100644
index 0000000000..38bd94a037
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-mediaelementaudiosourcenode-interface/cors-check.https.html
@@ -0,0 +1,76 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test if MediaElementAudioSourceNode works for cross-origin redirects with
+      "cors" request mode.
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+    <script src="/common/get-host-info.sub.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      const audit = Audit.createTaskRunner();
+
+      setup(() => {
+        const context = new AudioContext();
+        context.suspend();
+
+        const host_info = get_host_info();
+        const audioElement = document.createElement('audio');
+        audioElement.loop = true;
+        audioElement.crossOrigin = 'anonymous';
+        const wav =
+            host_info.HTTPS_ORIGIN + '/webaudio/resources/4ch-440.wav?' +
+            'pipe=header(access-control-allow-origin,*)';
+        audioElement.src =
+            host_info.HTTPS_REMOTE_ORIGIN +
+            '/fetch/api/resources/redirect.py?location=' +
+            encodeURIComponent(wav);
+        let source;
+        let workletRecorder;
+
+        audit.define(
+            {label: 'setting-up-graph'},
+            (task, should) => {
+              source = new MediaElementAudioSourceNode(context, {
+                mediaElement: audioElement
+              });
+              workletRecorder = new AudioWorkletNode(
+                  context, 'recorder-processor', {channelCount: 4});
+              source.connect(workletRecorder).connect(context.destination);
+              task.done();
+            });
+
+        // The recorded data from MESN must be non-zero. The source file contains
+        // 4 channels of sine wave.
+        audit.define(
+            {label: 'start-playback-and-capture'},
+            (task, should) => {
+              workletRecorder.port.onmessage = (event) => {
+                if (event.data.type === 'recordfinished') {
+                  for (let i = 0; i < event.data.recordBuffer.length; ++i) {
+                    const channelData = event.data.recordBuffer[i];
+                    should(channelData, `Recorded channel #${i}`)
+                        .notBeConstantValueOf(0);
+                  }
+                }
+
+                task.done();
+              };
+
+              context.resume();
+              audioElement.play();
+            });
+
+        Promise.all([
+          context.audioWorklet.addModule('/webaudio/js/worklet-recorder.js')
+        ]).then(() => {
+          audit.run();
+        });
+      });
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-mediaelementaudiosourcenode-interface/mediaElementAudioSourceToScriptProcessorTest.html b/testing/web-platform/tests/webaudio/the-audio-api/the-mediaelementaudiosourcenode-interface/mediaElementAudioSourceToScriptProcessorTest.html
new file mode 100644
index 0000000000..56d0787b76
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-mediaelementaudiosourcenode-interface/mediaElementAudioSourceToScriptProcessorTest.html
@@ -0,0 +1,130 @@
+<!doctype html>
+
+<!--
+Tests that a create MediaElementSourceNode that is passed through
+a script processor passes the stream data.
+The the script processor saves the input buffers it gets to a temporary
+array, and after the playback has stopped, the contents are compared
+to those of a loaded AudioBuffer with the same source.
+
+Somewhat similiar to a test from Mozilla:
+https://searchfox.org/mozilla-central/source/dom/media/webaudio/test/test_mediaElementAudioSourceNode.html
+-->
+
+<html class="a">
+ <head>
+  <title>MediaElementAudioSource interface test (to scriptProcessor)</title>
+  <script src="/resources/testharness.js"></script>
+  <script src="/resources/testharnessreport.js"></script>
+  <script src="/webaudio/js/helpers.js"></script>
+  <script src="/webaudio/js/buffer-loader.js"></script>
+ </head>
+ <body class="a">
+  <div id="log"></div>
+  <script>
+ var elementSourceTest = async_test(function(elementSourceTest) {
+
+   var src = '/webaudio/resources/sin_440Hz_-6dBFS_1s.wav';
+   var BUFFER_SIZE = 2048;
+   var context = null;
+   var actualBufferArrayC0 = new Float32Array(0);
+   var actualBufferArrayC1 = new Float32Array(0);
+   var audio = null, source = null, processor = null
+
+   function loadExpectedBuffer(event) {
+     bufferLoader = new BufferLoader(
+       context,
+       [src],
+       elementSourceTest.step_func(bufferLoadCompleted)
+     );
+     bufferLoader.load();
+   };
+
+   function bufferLoadCompleted(buffer) {
+     runTests(buffer);
+   };
+
+   function concatTypedArray(arr1, arr2) {
+     var result = new Float32Array(arr1.length + arr2.length);
+     result.set(arr1);
+     result.set(arr2, arr1.length);
+     return result;
+   }
+
+   // Create Audio context.  The reference wav file is sampled at 44.1 kHz so
+   // use the same rate for the context to remove extra resampling that might
+   // be required.
+   context = new AudioContext({sampleRate: 44100});
+
+   // Create an audio element, and a media element source
+   audio = document.createElement('audio');
+   audio.src = src;
+   source = context.createMediaElementSource(audio);
+
+   function processListener (e) {
+     actualBufferArrayC0 = concatTypedArray(actualBufferArrayC0, e.inputBuffer.getChannelData(0));
+     actualBufferArrayC1 = concatTypedArray(actualBufferArrayC1, e.inputBuffer.getChannelData(1));
+   }
+
+   // Create a processor node to copy the input to the actual buffer
+   processor = context.createScriptProcessor(BUFFER_SIZE);
+   source.connect(processor);
+   processor.connect(context.destination);
+   let audioprocessListener = elementSourceTest.step_func(processListener);
+   processor.addEventListener('audioprocess', audioprocessListener);
+
+   context.addEventListener('statechange', elementSourceTest.step_func(() => {
+     assert_equals(context.state, "running", "context.state");
+     audio.play();
+   }), {once: true});
+
+   // When media playback ended, save the begin to compare with expected buffer
+   audio.addEventListener("ended", elementSourceTest.step_func(function(e) {
+     // Setting a timeout since we need audioProcess event to run for all samples
+     window.setTimeout(elementSourceTest.step_func(loadExpectedBuffer), 50);
+   }));
+
+   function runTests(expected) {
+     source.disconnect();
+     processor.disconnect();
+
+     // firefox seems to process events after disconnect
+     processor.removeEventListener('audioprocess', audioprocessListener)
+
+     // Note: the expected result is from a mono source file.
+     var expectedBuffer = expected[0];
+
+     // Trim the actual elements because we don't have a fine-grained
+     // control over the start and end time of recording the data.
+     var actualTrimmedC0 = trimEmptyElements(actualBufferArrayC0);
+     var actualTrimmedC1 = trimEmptyElements(actualBufferArrayC1);
+     var expectedLength = trimEmptyElements(expectedBuffer.getChannelData(0)).length;
+
+     // Test that there is some data.
+     test(function() {
+       assert_greater_than(actualTrimmedC0.length, 0,
+                           "processed data array (C0) length greater than 0");
+       assert_greater_than(actualTrimmedC1.length, 0,
+                           "processed data array (C1) length greater than 0");
+     }, "Channel 0 processed some data");
+
+     // Test the actual contents of the 1st and second channel.
+     test(function() {
+       assert_array_approx_equals(
+         actualTrimmedC0,
+         trimEmptyElements(expectedBuffer.getChannelData(0)),
+         1e-4,
+         "comparing expected and rendered buffers (channel 0)");
+       assert_array_approx_equals(
+         actualTrimmedC1,
+         trimEmptyElements(expectedBuffer.getChannelData(0)),
+         1e-4,
+         "comparing expected and rendered buffers (channel 1)");
+     }, "All data processed correctly");
+
+     elementSourceTest.done();
+   };
+ }, "Element Source tests completed");
+  </script>
+ </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-mediaelementaudiosourcenode-interface/no-cors.https.html b/testing/web-platform/tests/webaudio/the-audio-api/the-mediaelementaudiosourcenode-interface/no-cors.https.html
new file mode 100644
index 0000000000..de2f0b7dd3
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-mediaelementaudiosourcenode-interface/no-cors.https.html
@@ -0,0 +1,75 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test if MediaElementAudioSourceNode works for cross-origin redirects with
+      "no-cors" request mode.
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+    <script src="/common/get-host-info.sub.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      const audit = Audit.createTaskRunner();
+
+      setup(() => {
+        const context = new AudioContext();
+        context.suspend();
+
+        const host_info = get_host_info();
+        const audioElement = document.createElement('audio');
+        audioElement.loop = true;
+        const wav =
+            host_info.HTTPS_ORIGIN + '/webaudio/resources/4ch-440.wav?' +
+            'pipe=header(access-control-allow-origin,*)';
+        audioElement.src =
+            host_info.HTTPS_REMOTE_ORIGIN +
+            '/fetch/api/resources/redirect.py?location=' +
+            encodeURIComponent(wav);
+        let source;
+        let workletRecorder;
+
+        audit.define(
+            {label: 'setting-up-graph'},
+            (task, should) => {
+              source = new MediaElementAudioSourceNode(context, {
+                mediaElement: audioElement
+              });
+              workletRecorder = new AudioWorkletNode(
+                  context, 'recorder-processor', {channelCount: 4});
+              source.connect(workletRecorder).connect(context.destination);
+              task.done();
+            });
+
+        // The recorded data from MESN must be non-zero. The source file contains
+        // 4 channels of sine wave.
+        audit.define(
+            {label: 'start-playback-and-capture'},
+            (task, should) => {
+              workletRecorder.port.onmessage = (event) => {
+                if (event.data.type === 'recordfinished') {
+                  for (let i = 0; i < event.data.recordBuffer.length; ++i) {
+                    const channelData = event.data.recordBuffer[i];
+                    should(channelData, `Recorded channel #${i}`)
+                        .beConstantValueOf(0);
+                  }
+                }
+
+                task.done();
+              };
+
+              context.resume();
+              audioElement.play();
+            });
+
+        Promise.all([
+          context.audioWorklet.addModule('/webaudio/js/worklet-recorder.js')
+        ]).then(() => {
+          audit.run();
+        });
+      });
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-mediastreamaudiodestinationnode-interface/ctor-mediastreamaudiodestination.html b/testing/web-platform/tests/webaudio/the-audio-api/the-mediastreamaudiodestinationnode-interface/ctor-mediastreamaudiodestination.html
new file mode 100644
index 0000000000..5d3fd0c26f
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-mediastreamaudiodestinationnode-interface/ctor-mediastreamaudiodestination.html
@@ -0,0 +1,64 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Constructor: MediaStreamAudioDestinationNode
+    </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 = new AudioContext();
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define('initialize', (task, should) => {
+        // Need AudioContext, not OfflineAudioContext, for these tests.
+        should(() => {
+          context = new AudioContext();
+        }, 'context = new AudioContext()').notThrow();
+        task.done();
+      });
+
+      audit.define('invalid constructor', (task, should) => {
+        testInvalidConstructor(
+            should, 'MediaStreamAudioDestinationNode', context);
+        task.done();
+      });
+
+      audit.define('default constructor', (task, should) => {
+        let prefix = 'node0';
+        let node = testDefaultConstructor(
+            should, 'MediaStreamAudioDestinationNode', context, {
+              prefix: prefix,
+              numberOfInputs: 1,
+              numberOfOutputs: 0,
+              channelCount: 2,
+              channelCountMode: 'explicit',
+              channelInterpretation: 'speakers'
+            });
+
+        testDefaultAttributes(should, node, prefix, []);
+
+        task.done();
+      });
+
+      audit.define('test AudioNodeOptions', (task, should) => {
+        testAudioNodeOptions(
+            should, context, 'MediaStreamAudioDestinationNode', {
+              channelCount: {
+                // An arbitrary but valid, non-default count for this node.
+                value: 7
+              }
+            });
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-mediastreamaudiosourcenode-interface/mediastreamaudiosourcenode-ctor.html b/testing/web-platform/tests/webaudio/the-audio-api/the-mediastreamaudiosourcenode-interface/mediastreamaudiosourcenode-ctor.html
new file mode 100644
index 0000000000..a711419656
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-mediastreamaudiosourcenode-interface/mediastreamaudiosourcenode-ctor.html
@@ -0,0 +1,73 @@
+<!DOCTYPE html>
+
+<html class="a">
+  <head>
+    <title>MediaStreamAudioSourceNode</title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+  </head>
+  <body class="a">
+    <div id="log"></div>
+    <script>
+      setup({explicit_done: true});
+      // Wait until the DOM is ready to be able to get a reference to the canvas
+      // element.
+      window.addEventListener("load", function() {
+        const ac = new AudioContext();
+        const emptyStream = new MediaStream();
+
+        test(function() {
+          assert_throws_dom(
+            "InvalidStateError",
+            function() {
+              ac.createMediaStreamSource(emptyStream);
+            },
+            `A MediaStreamAudioSourceNode can only be constructed via the factory
+    method with a MediaStream that has at least one track of kind "audio"`
+          );
+        }, "MediaStreamAudioSourceNode created with factory method and MediaStream with no tracks");
+
+        test(function() {
+          assert_throws_dom(
+            "InvalidStateError",
+            function() {
+              new MediaStreamAudioSourceNode(ac, { mediaStream: emptyStream });
+            },
+            `A MediaStreamAudioSourceNode can only be constructed via the constructor
+          with a MediaStream that has at least one track of kind "audio"`
+          );
+        }, "MediaStreamAudioSourceNode created with constructor and MediaStream with no tracks");
+
+        const canvas = document.querySelector("canvas");
+        const ctx = canvas.getContext("2d");
+        const videoOnlyStream = canvas.captureStream();
+
+        test(function() {
+          assert_throws_dom(
+            "InvalidStateError",
+            function() {
+              ac.createMediaStreamSource(videoOnlyStream);
+            },
+            `A MediaStreamAudioSourceNode can only be constructed via the factory with a
+          MediaStream that has at least one track of kind "audio"`
+          );
+        }, `MediaStreamAudioSourceNode created with the factory method and MediaStream with only a video track`);
+
+        test(function() {
+          assert_throws_dom(
+            "InvalidStateError",
+            function() {
+              new MediaStreamAudioSourceNode(ac, {
+                mediaStream: videoOnlyStream,
+              });
+            },
+            `A MediaStreamAudioSourceNode can only be constructed via the factory with a
+          MediaStream that has at least one track of kind "audio"`
+          );
+        }, `MediaStreamAudioSourceNode created with constructor and MediaStream with only a video track`);
+        done();
+      });
+    </script>
+  </body>
+  <canvas></canvas>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-mediastreamaudiosourcenode-interface/mediastreamaudiosourcenode-routing.html b/testing/web-platform/tests/webaudio/the-audio-api/the-mediastreamaudiosourcenode-interface/mediastreamaudiosourcenode-routing.html
new file mode 100644
index 0000000000..816eba0b29
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-mediastreamaudiosourcenode-interface/mediastreamaudiosourcenode-routing.html
@@ -0,0 +1,127 @@
+<!DOCTYPE html>
+
+<html class="a">
+  <head>
+    <title>MediaStreamAudioSourceNode</title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+  </head>
+  <body class="a">
+    <div id="log"></div>
+    <script>
+      function binIndexForFrequency(frequency, analyser) {
+        return (
+          1 +
+          Math.round(
+            (frequency * analyser.fftSize) / analyser.context.sampleRate
+          )
+        );
+      }
+
+      const t = async_test(
+        "MediaStreamAudioSourceNode captures the right track."
+      );
+      t.step(function() {
+          const ac = new AudioContext();
+          // Test that the right track is captured. Set up a MediaStream that has two
+          // tracks, one with a tone at 100Hz and one with a tone at 1000Hz.
+          const dest0 = ac.createMediaStreamDestination();
+          const dest1 = ac.createMediaStreamDestination();
+          const osc0 = ac.createOscillator();
+          const osc1 = ac.createOscillator();
+          osc0.frequency.value = 100;
+          osc1.frequency.value = 1000;
+          osc0.connect(dest0);
+          osc1.connect(dest1);
+          osc0.start(0);
+          osc1.start(0);
+          const track0 = dest0.stream.getAudioTracks()[0];
+          const track0id = track0.id;
+          const track1 = dest1.stream.getAudioTracks()[0];
+          const track1id = track1.id;
+
+          let ids = [track0id, track1id];
+          ids.sort();
+          let targetFrequency;
+          let otherFrequency;
+          if (ids[0] == track0id) {
+              targetFrequency = 100;
+              otherFrequency = 1000;
+          } else {
+              targetFrequency = 1000;
+              otherFrequency = 100;
+          }
+
+          let twoTrackMediaStream = new MediaStream();
+          twoTrackMediaStream.addTrack(track0);
+          twoTrackMediaStream.addTrack(track1);
+
+          const twoTrackSource = ac.createMediaStreamSource(twoTrackMediaStream);
+          const analyser = ac.createAnalyser();
+          // Don't do smoothing so that the frequency data changes quickly
+          analyser.smoothingTimeConstant = 0;
+
+          twoTrackSource.connect(analyser);
+
+          const indexToCheckForHighEnergy = binIndexForFrequency(
+              targetFrequency,
+              analyser
+          );
+          const indexToCheckForLowEnergy = binIndexForFrequency(
+              otherFrequency,
+              analyser
+          );
+          let frequencyData = new Float32Array(1024);
+          let checkCount = 0;
+          let numberOfRemovals = 0;
+          let stopped = false;
+          function analyse() {
+              analyser.getFloatFrequencyData(frequencyData);
+              // there should be high energy in the right bin, higher than 40dbfs because
+              // it's supposed to be a sine wave at 0dbfs
+              if (frequencyData[indexToCheckForHighEnergy] > -40 && !stopped) {
+                  assert_true(true, "Correct track routed to the AudioContext.");
+                  checkCount++;
+              }
+              if (stopped && frequencyData[indexToCheckForHighEnergy] < -40) {
+                  assert_true(
+                      true,
+                      `After stopping the track, low energy is found in the
+              same bin`
+                  );
+                  checkCount++;
+              }
+              if (checkCount > 5 && checkCount < 20) {
+                  twoTrackMediaStream.getAudioTracks().forEach(track => {
+                      if (track.id == ids[0]) {
+                          numberOfRemovals++;
+                          window.removedTrack = track;
+                          twoTrackMediaStream.removeTrack(track);
+                      }
+                  });
+                  assert_true(
+                      numberOfRemovals == 1,
+                      `The mediastreamtrack can only be
+        removed once from the mediastream`
+                  );
+              } else if (checkCount >= 20 && checkCount < 30) {
+                  window.removedTrack.stop();
+                  stopped = true;
+              } else if (checkCount >= 30) {
+                  assert_true(
+                      numberOfRemovals == 1,
+                      `After removing the track from the
+        mediastream, it's still routed to the graph.`
+                  );
+                  // After some time, consider that it worked.
+                  t.done();
+                  return;
+              }
+
+              t.step_timeout(analyse, 100);
+          }
+          t.step_timeout(analyse, 100);
+      });
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-offlineaudiocontext-interface/ctor-offlineaudiocontext.html b/testing/web-platform/tests/webaudio/the-audio-api/the-offlineaudiocontext-interface/ctor-offlineaudiocontext.html
new file mode 100644
index 0000000000..4b68631036
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-offlineaudiocontext-interface/ctor-offlineaudiocontext.html
@@ -0,0 +1,203 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Test Constructor: OfflineAudioContext</title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+    <script src="/webaudio/resources/audit-util.js"></script>
+    <script src="/webaudio/resources/audionodeoptions.js"></script>
+  </head>
+
+  <body>
+    <script>
+      let audit = Audit.createTaskRunner();
+
+      // Just a simple test of the 3-arg constructor; This should be
+      // well-covered by other layout tests that use the 3-arg constructor.
+      audit.define(
+          {label: 'basic', description: 'Old-style constructor'},
+          (task, should) => {
+            let context;
+
+            // First and only arg should be a dictionary.
+            should(() => {
+              new OfflineAudioContext(3);
+            }, 'new OfflineAudioContext(3)').throw(TypeError);
+
+            // Constructor needs 1 or 3 args, so 2 should throw.
+            should(() => {
+              new OfflineAudioContext(3, 42);
+            }, 'new OfflineAudioContext(3, 42)').throw(TypeError);
+
+            // Valid constructor
+            should(() => {
+              context = new OfflineAudioContext(3, 42, 12345);
+            }, 'context = new OfflineAudioContext(3, 42, 12345)').notThrow();
+
+            // Verify that the context was constructed correctly.
+            should(context.length, 'context.length').beEqualTo(42);
+            should(context.sampleRate, 'context.sampleRate').beEqualTo(12345);
+            should(
+                context.destination.channelCount,
+                'context.destination.channelCount')
+                .beEqualTo(3);
+            should(
+                context.destination.channelCountMode,
+                'context.destination.channelCountMode')
+                .beEqualTo('explicit');
+            should(
+                context.destination.channelInterpretation,
+                'context.destination.channelInterpretation')
+                .beEqualTo('speakers');
+            task.done();
+          });
+
+      // Test constructor throws an error if the required members of the
+      // dictionary are not given.
+      audit.define(
+          {label: 'options-1', description: 'Required options'},
+          (task, should) => {
+            let context2;
+
+            // No args should throw
+            should(() => {
+              new OfflineAudioContext();
+            }, 'new OfflineAudioContext()').throw(TypeError);
+
+            // Empty OfflineAudioContextOptions should throw
+            should(() => {
+              new OfflineAudioContext({});
+            }, 'new OfflineAudioContext({})').throw(TypeError);
+
+            let options = {length: 42};
+            // sampleRate is required.
+            should(
+                () => {
+                  new OfflineAudioContext(options);
+                },
+                'new OfflineAudioContext(' + JSON.stringify(options) + ')')
+                .throw(TypeError);
+
+            options = {sampleRate: 12345};
+            // length is required.
+            should(
+                () => {
+                  new OfflineAudioContext(options);
+                },
+                'new OfflineAudioContext(' + JSON.stringify(options) + ')')
+                .throw(TypeError);
+
+            // Valid constructor.  Verify that the resulting context has the
+            // correct values.
+            options = {length: 42, sampleRate: 12345};
+            should(
+                () => {
+                  context2 = new OfflineAudioContext(options);
+                },
+                'c2 = new OfflineAudioContext(' + JSON.stringify(options) + ')')
+                .notThrow();
+            should(
+                context2.destination.channelCount,
+                'c2.destination.channelCount')
+                .beEqualTo(1);
+            should(context2.length, 'c2.length').beEqualTo(options.length);
+            should(context2.sampleRate, 'c2.sampleRate')
+                .beEqualTo(options.sampleRate);
+            should(
+                context2.destination.channelCountMode,
+                'c2.destination.channelCountMode')
+                .beEqualTo('explicit');
+            should(
+                context2.destination.channelInterpretation,
+                'c2.destination.channelInterpretation')
+                .beEqualTo('speakers');
+
+            task.done();
+          });
+
+      // Constructor should throw errors for invalid values specified by
+      // OfflineAudioContextOptions.
+      audit.define(
+          {label: 'options-2', description: 'Invalid options'},
+          (task, should) => {
+            let options = {length: 42, sampleRate: 8000, numberOfChannels: 33};
+
+            // channelCount too large.
+            should(
+                () => {
+                  new OfflineAudioContext(options);
+                },
+                'new OfflineAudioContext(' + JSON.stringify(options) + ')')
+                .throw(DOMException, 'NotSupportedError');
+
+            // length cannot be 0
+            options = {length: 0, sampleRate: 8000};
+            should(
+                () => {
+                  new OfflineAudioContext(options);
+                },
+                'new OfflineAudioContext(' + JSON.stringify(options) + ')')
+                .throw(DOMException, 'NotSupportedError');
+
+            // sampleRate outside valid range
+            options = {length: 1, sampleRate: 1};
+            should(
+                () => {
+                  new OfflineAudioContext(options);
+                },
+                'new OfflineAudioContext(' + JSON.stringify(options) + ')')
+                .throw(DOMException, 'NotSupportedError');
+
+            task.done();
+          });
+
+      audit.define(
+          {label: 'options-3', description: 'Valid options'},
+          (task, should) => {
+            let context;
+            let options = {
+              length: 1,
+              sampleRate: 8000,
+            };
+
+            // Verify context with valid constructor has the correct values.
+            should(
+                () => {
+                  context = new OfflineAudioContext(options);
+                },
+                'c = new OfflineAudioContext' + JSON.stringify(options) + ')')
+                .notThrow();
+            should(context.length, 'c.length').beEqualTo(options.length);
+            should(context.sampleRate, 'c.sampleRate')
+                .beEqualTo(options.sampleRate);
+            should(
+                context.destination.channelCount, 'c.destination.channelCount')
+                .beEqualTo(1);
+            should(
+                context.destination.channelCountMode,
+                'c.destination.channelCountMode')
+                .beEqualTo('explicit');
+            should(
+                context.destination.channelInterpretation,
+                'c.destination.channelCountMode')
+                .beEqualTo('speakers');
+
+            options.numberOfChannels = 7;
+            should(
+                () => {
+                  context = new OfflineAudioContext(options);
+                },
+                'c = new OfflineAudioContext' + JSON.stringify(options) + ')')
+                .notThrow();
+            should(
+                context.destination.channelCount, 'c.destination.channelCount')
+                .beEqualTo(options.numberOfChannels);
+
+            task.done();
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-offlineaudiocontext-interface/current-time-block-size.html b/testing/web-platform/tests/webaudio/the-audio-api/the-offlineaudiocontext-interface/current-time-block-size.html
new file mode 100644
index 0000000000..ee976f7f72
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-offlineaudiocontext-interface/current-time-block-size.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<title>Test currentTime at completion of OfflineAudioContext rendering</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+promise_test(function() {
+  // sampleRate is a power of two so that time can be represented exactly
+  // in double currentTime.
+  var context = new OfflineAudioContext(1, 1, 65536);
+  return context.startRendering().
+    then(function(buffer) {
+      assert_equals(buffer.length, 1, "buffer length");
+      assert_equals(context.currentTime, 128 / context.sampleRate,
+                    "currentTime at completion");
+    });
+});
+</script>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-offlineaudiocontext-interface/offlineaudiocontext-detached-execution-context.html b/testing/web-platform/tests/webaudio/the-audio-api/the-offlineaudiocontext-interface/offlineaudiocontext-detached-execution-context.html
new file mode 100644
index 0000000000..6eafd15fd2
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-offlineaudiocontext-interface/offlineaudiocontext-detached-execution-context.html
@@ -0,0 +1,34 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Testing behavior OfflineAudioContext after execution context is detached
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      const audit = Audit.createTaskRunner();
+
+      audit.define('decoding-on-detached-iframe', (task, should) => {
+        const iframe =
+            document.createElementNS("http://www.w3.org/1999/xhtml", "iframe");
+        document.body.appendChild(iframe);
+
+        // Use the lowest value possible for the faster test.
+        let context =
+            new iframe.contentWindow.OfflineAudioContext(1, 1, 8000);
+
+        document.body.removeChild(iframe);
+
+        return should(context.decodeAudioData(new ArrayBuffer(1)),
+               'decodeAudioData() upon a detached iframe')
+            .beRejectedWith('InvalidStateError');
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-offlineaudiocontext-interface/startrendering-after-discard.html b/testing/web-platform/tests/webaudio/the-audio-api/the-offlineaudiocontext-interface/startrendering-after-discard.html
new file mode 100644
index 0000000000..dd610ec335
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-offlineaudiocontext-interface/startrendering-after-discard.html
@@ -0,0 +1,24 @@
+<!doctype html>
+<title>Test for rejected promise from startRendering() on an
+  OfflineAudioContext in a discarded browsing context</title>
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<body></body>
+<script>
+let context;
+let childDOMException;
+setup(() => {
+  const frame = document.createElement('iframe');
+  document.body.appendChild(frame);
+  context = new frame.contentWindow.OfflineAudioContext(
+    {length: 1, sampleRate: 48000});
+  childDOMException = frame.contentWindow.DOMException;
+  frame.remove();
+});
+
+promise_test((t) => promise_rejects_dom(
+  t, 'InvalidStateError', childDOMException, context.startRendering()),
+             'startRendering()');
+// decodeAudioData() is tested in
+// offlineaudiocontext-detached-execution-context.html
+</script>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-oscillatornode-interface/ctor-oscillator.html b/testing/web-platform/tests/webaudio/the-audio-api/the-oscillatornode-interface/ctor-oscillator.html
new file mode 100644
index 0000000000..bf50195a5b
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-oscillatornode-interface/ctor-oscillator.html
@@ -0,0 +1,112 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Constructor: Oscillator
+    </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, 'OscillatorNode', context);
+        task.done();
+      });
+
+      audit.define('default constructor', (task, should) => {
+        let prefix = 'node0';
+        let node = testDefaultConstructor(should, 'OscillatorNode', context, {
+          prefix: prefix,
+          numberOfInputs: 0,
+          numberOfOutputs: 1,
+          channelCount: 2,
+          channelCountMode: 'max',
+          channelInterpretation: 'speakers'
+        });
+
+        testDefaultAttributes(
+            should, node, prefix,
+            [{name: 'type', value: 'sine'}, {name: 'frequency', value: 440}]);
+
+        task.done();
+      });
+
+      audit.define('test AudioNodeOptions', (task, should) => {
+        testAudioNodeOptions(should, context, 'OscillatorNode');
+        task.done();
+      });
+
+      audit.define('constructor options', (task, should) => {
+        let node;
+        let options = {type: 'sawtooth', detune: 7, frequency: 918};
+
+        should(
+            () => {
+              node = new OscillatorNode(context, options);
+            },
+            'node1 = new OscillatorNode(c, ' + JSON.stringify(options) + ')')
+            .notThrow();
+
+        should(node.type, 'node1.type').beEqualTo(options.type);
+        should(node.detune.value, 'node1.detune.value')
+            .beEqualTo(options.detune);
+        should(node.frequency.value, 'node1.frequency.value')
+            .beEqualTo(options.frequency);
+
+        should(node.channelCount, 'node1.channelCount').beEqualTo(2);
+        should(node.channelCountMode, 'node1.channelCountMode')
+            .beEqualTo('max');
+        should(node.channelInterpretation, 'node1.channelInterpretation')
+            .beEqualTo('speakers');
+
+        // Test that type and periodicWave options work as described.
+        options = {
+          type: 'sine',
+          periodicWave: new PeriodicWave(context, {real: [1, 1]})
+        };
+        should(() => {
+          node = new OscillatorNode(context, options);
+        }, 'new OscillatorNode(c, ' + JSON.stringify(options) + ')').notThrow();
+
+        options = {type: 'custom'};
+        should(
+            () => {
+              node = new OscillatorNode(context, options);
+            },
+            'new OscillatorNode(c, ' + JSON.stringify(options) + ')')
+            .throw(DOMException, 'InvalidStateError');
+
+        options = {
+          type: 'custom',
+          periodicWave: new PeriodicWave(context, {real: [1, 1]})
+        };
+        should(() => {
+          node = new OscillatorNode(context, options);
+        }, 'new OscillatorNode(c, ' + JSON.stringify(options) + ')').notThrow();
+
+        should(
+            () => {
+              node = new OscillatorNode(context, {periodicWave: null});
+            },
+            'new OscillatorNode(c, {periodicWave: null}')
+            .throw(DOMException, 'TypeError');
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-oscillatornode-interface/detune-limiting.html b/testing/web-platform/tests/webaudio/the-audio-api/the-oscillatornode-interface/detune-limiting.html
new file mode 100644
index 0000000000..81a1293d03
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-oscillatornode-interface/detune-limiting.html
@@ -0,0 +1,154 @@
+<!doctype html>
+<html>
+  <head>
+    <title>
+      Oscillator Detune Limits
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+  </head>
+
+  <body>
+    <script>
+      const sampleRate = 44100;
+      const renderLengthSeconds = 0.125;
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {
+            label: 'detune limits',
+            description:
+                'Oscillator with detune and frequency at Nyquist or above'
+          },
+          (task, should) => {
+            let context = new OfflineAudioContext(
+                2, renderLengthSeconds * sampleRate, sampleRate);
+
+            let merger = new ChannelMergerNode(
+                context, {numberOfInputs: context.destination.channelCount});
+            merger.connect(context.destination);
+
+            // For test oscillator, set the oscillator frequency to -Nyquist and
+            // set detune to be a large number that would cause the detuned
+            // frequency to be way above Nyquist.
+            const oscFrequency = 1;
+            const detunedFrequency = sampleRate;
+            const detuneValue = Math.fround(1200 * Math.log2(detunedFrequency));
+
+            let testOsc = new OscillatorNode(
+                context, {frequency: oscFrequency, detune: detuneValue});
+            testOsc.connect(merger, 0, 1);
+
+            // For the reference oscillator, determine the computed oscillator
+            // frequency using the values above and set that as the oscillator
+            // frequency.
+            let computedFreq = oscFrequency * Math.pow(2, detuneValue / 1200);
+
+            let refOsc = new OscillatorNode(context, {frequency: computedFreq});
+            refOsc.connect(merger, 0, 0);
+
+            // Start 'em up and render
+            testOsc.start();
+            refOsc.start();
+
+            context.startRendering()
+                .then(renderedBuffer => {
+                  let expected = renderedBuffer.getChannelData(0);
+                  let actual = renderedBuffer.getChannelData(1);
+
+                  // Let user know about the smaple rate so following messages
+                  // make more sense.
+                  should(context.sampleRate, 'Context sample rate')
+                    .beEqualTo(context.sampleRate);
+
+                  // Since the frequency is at Nyquist, the reference oscillator
+                  // output should be zero.
+                  should(
+                      refOsc.frequency.value, 'Reference oscillator frequency')
+                      .beGreaterThanOrEqualTo(context.sampleRate / 2);
+                  should(
+                      expected, `Osc(freq: ${refOsc.frequency.value}) output`)
+                      .beConstantValueOf(0);
+                  // The output from each oscillator should be the same.
+                  should(
+                      actual,
+                      'Osc(freq: ' + oscFrequency + ', detune: ' + detuneValue +
+                          ') output')
+                      .beCloseToArray(expected, {absoluteThreshold: 0});
+
+                })
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: 'detune automation',
+            description:
+                'Oscillator output with detune automation should be zero ' +
+                'above Nyquist'
+          },
+          (task, should) => {
+            let context = new OfflineAudioContext(
+                1, renderLengthSeconds * sampleRate, sampleRate);
+
+            const baseFrequency = 1;
+            const rampEnd = renderLengthSeconds / 2;
+            const detuneEnd = 1e7;
+
+            let src = new OscillatorNode(context, {frequency: baseFrequency});
+            src.detune.linearRampToValueAtTime(detuneEnd, rampEnd);
+
+            src.connect(context.destination);
+
+            src.start();
+
+            context.startRendering()
+                .then(renderedBuffer => {
+                  let audio = renderedBuffer.getChannelData(0);
+
+                  // At some point, the computed oscillator frequency will go
+                  // above Nyquist.  Determine at what time this occurrs.  The
+                  // computed frequency is f * 2^(d/1200) where |f| is the
+                  // oscillator frequency and |d| is the detune value.  Thus,
+                  // find |d| such that Nyquist = f*2^(d/1200). That is, d =
+                  // 1200*log2(Nyquist/f)
+                  let criticalDetune =
+                      1200 * Math.log2(context.sampleRate / 2 / baseFrequency);
+
+                  // Now figure out at what point on the linear ramp does the
+                  // detune value reach this critical value.  For a linear ramp:
+                  //
+                  //   v(t) = V0+(V1-V0)*(t-T0)/(T1-T0)
+                  //
+                  // Thus,
+                  //
+                  //   t = ((T1-T0)*v(t) + T0*V1 - T1*V0)/(V1-V0)
+                  //
+                  // In this test, T0 = 0, V0 = 0, T1 = rampEnd, V1 =
+                  // detuneEnd, and v(t) = criticalDetune
+                  let criticalTime = (rampEnd * criticalDetune) / detuneEnd;
+                  let criticalFrame =
+                      Math.ceil(criticalTime * context.sampleRate);
+
+                  should(
+                      criticalFrame,
+                      `Frame where detuned oscillator reaches Nyquist`)
+                      .beEqualTo(criticalFrame);
+
+                  should(
+                      audio.slice(0, criticalFrame),
+                      `osc[0:${criticalFrame - 1}]`)
+                      .notBeConstantValueOf(0);
+
+                  should(audio.slice(criticalFrame), `osc[${criticalFrame}:]`)
+                      .beConstantValueOf(0);
+                })
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-oscillatornode-interface/detune-overflow.html b/testing/web-platform/tests/webaudio/the-audio-api/the-oscillatornode-interface/detune-overflow.html
new file mode 100644
index 0000000000..28c28bc1db
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-oscillatornode-interface/detune-overflow.html
@@ -0,0 +1,41 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Test Osc.detune Overflow</title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/webaudio/resources/audit.js"></script>
+    <script src="/webaudio/resources/audit-util.js"></script>
+  </head>
+
+  <body>
+    <script>
+      const sampleRate = 44100;
+      const renderLengthFrames = RENDER_QUANTUM_FRAMES;
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define('detune overflow', async (task, should) => {
+        let context =
+            new OfflineAudioContext(1, renderLengthFrames, sampleRate);
+
+        // This value of frequency and detune results in a computed frequency of
+        // 440*2^(153600/1200) = 1.497e41.  The frequency needs to be clamped to
+        // Nyquist.  But a sine wave at Nyquist frequency is all zeroes.  Verify
+        // the output is 0.
+        let osc = new OscillatorNode(context, {frequency: 440, detune: 153600});
+
+        osc.connect(context.destination);
+
+        let buffer = await context.startRendering();
+        let output = buffer.getChannelData(0);
+        should(output, 'Osc freq and detune outside nominal range')
+            .beConstantValueOf(0);
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-oscillatornode-interface/osc-basic-waveform.html b/testing/web-platform/tests/webaudio/the-audio-api/the-oscillatornode-interface/osc-basic-waveform.html
new file mode 100644
index 0000000000..b34c96855f
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-oscillatornode-interface/osc-basic-waveform.html
@@ -0,0 +1,229 @@
+<!doctype html>
+<html>
+  <head>
+    <title>
+      Test Basic Oscillator Sine Wave Test
+    </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>
+      // Don't change the sample rate.  The tests below depend on this sample
+      // rate to cover all the cases in Chrome's implementation.  But the tests
+      // are general and apply to any browser.
+      const sampleRate = 44100;
+
+      // Only need a few samples for testing, so just use two renders.
+      const durationFrames = 2 * RENDER_QUANTUM_FRAMES;
+
+      let audit = Audit.createTaskRunner();
+
+      // The following tests verify that the oscillator produces the same
+      // results as the mathematical oscillators.  We choose sine wave and a
+      // custom wave because we know they're bandlimited and won't change with
+      // the frequency.
+      //
+      // The tests for 1 and 2 Hz are intended to test Chrome's interpolation
+      // algorithm, but are still generally applicable to any browser.
+
+      audit.define(
+          {label: 'Test 0', description: 'Sine wave: 100 Hz'},
+          async (task, should) => {
+            let context = new OfflineAudioContext(
+                {length: durationFrames, sampleRate: sampleRate});
+
+            const freqHz = 100;
+
+            let src =
+                new OscillatorNode(context, {type: 'sine', frequency: freqHz});
+            src.connect(context.destination);
+
+            src.start();
+
+            let renderedBuffer = await context.startRendering();
+            checkResult(should, renderedBuffer, context, {
+              freqHz: freqHz,
+              a1: 0,
+              b1: 1,
+              prefix: 'Sine',
+              threshold: 1.8045e-6,
+              snrThreshold: 118.91
+            });
+            task.done();
+          });
+
+      audit.define(
+          {label: 'Test 1', description: 'Sine wave: -100 Hz'},
+          async (task, should) => {
+            let context = new OfflineAudioContext(
+                {length: durationFrames, sampleRate: sampleRate});
+
+            const freqHz = -100;
+
+            let src =
+                new OscillatorNode(context, {type: 'sine', frequency: freqHz});
+            src.connect(context.destination);
+
+            src.start();
+
+            let renderedBuffer = await context.startRendering();
+            checkResult(should, renderedBuffer, context, {
+              freqHz: freqHz,
+              a1: 0,
+              b1: 1,
+              prefix: 'Sine',
+              threshold: 4.7684e-7,
+              snrThreshold: 130.95
+            });
+            task.done();
+          });
+
+      audit.define(
+          {label: 'Test 2', description: 'Sine wave: 2 Hz'},
+          async (task, should) => {
+            let context = new OfflineAudioContext(
+                {length: durationFrames, sampleRate: sampleRate});
+
+            const freqHz = 2;
+
+            let src =
+                new OscillatorNode(context, {type: 'sine', frequency: freqHz});
+            src.connect(context.destination);
+
+            src.start();
+
+            let renderedBuffer = await context.startRendering();
+            checkResult(should, renderedBuffer, context, {
+              freqHz: freqHz,
+              a1: 0,
+              b1: 1,
+              prefix: 'Sine',
+              threshold: 1.4516e-7,
+              snrThreshold: 119.93
+            });
+            task.done();
+          });
+
+      audit.define(
+          {label: 'Test 3', description: 'Sine wave: 1 Hz'},
+          async (task, should) => {
+            let context = new OfflineAudioContext(
+                {length: durationFrames, sampleRate: sampleRate});
+
+            const freqHz = 1;
+
+            let src =
+                new OscillatorNode(context, {type: 'sine', frequency: freqHz});
+            src.connect(context.destination);
+
+            src.start();
+
+            let renderedBuffer = await context.startRendering();
+            checkResult(should, renderedBuffer, context, {
+              freqHz: freqHz,
+              a1: 0,
+              b1: 1,
+              prefix: 'Sine',
+              threshold: 1.4157e-7,
+              snrThreshold: 112.22
+            });
+            task.done();
+          });
+
+      audit.define(
+          {label: 'Test 4', description: 'Custom wave: 100 Hz'},
+          async (task, should) => {
+            let context = new OfflineAudioContext(
+                {length: durationFrames, sampleRate: sampleRate});
+
+            const freqHz = 100;
+
+            let wave = new PeriodicWave(
+                context,
+                {real: [0, 1], imag: [0, 1], disableNormalization: true});
+            let src = new OscillatorNode(
+                context,
+                {type: 'custom', frequency: freqHz, periodicWave: wave});
+            src.connect(context.destination);
+
+            src.start();
+
+            let renderedBuffer = await context.startRendering();
+            checkResult(should, renderedBuffer, context, {
+              freqHz: freqHz,
+              a1: 1,
+              b1: 1,
+              prefix: 'Custom',
+              threshold: 1.8478e-6,
+              snrThreshold: 122.43
+            });
+            task.done();
+          });
+
+      audit.define(
+          {label: 'Test 5', description: 'Custom wave: 1 Hz'},
+          async (task, should) => {
+            let context = new OfflineAudioContext(
+                {length: durationFrames, sampleRate: sampleRate});
+
+            const freqHz = 1;
+
+            let wave = new PeriodicWave(
+                context,
+                {real: [0, 1], imag: [0, 1], disableNormalization: true});
+            let src = new OscillatorNode(
+                context,
+                {type: 'custom', frequency: freqHz, periodicWave: wave});
+            src.connect(context.destination);
+
+            src.start();
+
+            let renderedBuffer = await context.startRendering();
+            checkResult(should, renderedBuffer, context, {
+              freqHz: freqHz,
+              a1: 1,
+              b1: 1,
+              prefix: 'Custom',
+              threshold: 4.7684e-7,
+              snrThreshold: 138.76
+            });
+            task.done();
+          });
+
+      audit.run();
+
+      function waveForm(context, freqHz, a1, b1, nsamples) {
+        let buffer =
+            new AudioBuffer({length: nsamples, sampleRate: context.sampleRate});
+        let signal = buffer.getChannelData(0);
+        const omega = 2 * Math.PI * freqHz / context.sampleRate;
+        for (let k = 0; k < nsamples; ++k) {
+          signal[k] = a1 * Math.cos(omega * k) + b1 * Math.sin(omega * k);
+        }
+
+        return buffer;
+      }
+
+      function checkResult(should, renderedBuffer, context, options) {
+        let {freqHz, a1, b1, prefix, threshold, snrThreshold} = options;
+
+        let actual = renderedBuffer.getChannelData(0);
+
+        let expected =
+            waveForm(context, freqHz, a1, b1, actual.length).getChannelData(0);
+
+        should(actual, `${prefix}: ${freqHz} Hz`).beCloseToArray(expected, {
+          absoluteThreshold: threshold
+        });
+
+        let snr = 10 * Math.log10(computeSNR(actual, expected));
+
+        should(snr, `${prefix}: SNR (db)`).beGreaterThanOrEqualTo(snrThreshold);
+      }
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/automation-changes.html b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/automation-changes.html
new file mode 100644
index 0000000000..8aa73552aa
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/automation-changes.html
@@ -0,0 +1,140 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Panner Node Automation</title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="../../resources/audit-util.js"></script>
+    <script src="../../resources/audit.js"></script>
+  </head>
+
+  <body>
+    <script>
+      // Use a power-of-two to eliminate some round-off; otherwise, this isn't
+      // really important.
+      const sampleRate = 16384;
+
+      // Render enough for the test; we don't need a lot.
+      const renderFrames = 2048;
+
+      // Initial panner positionX and final positionX for listener.
+      const positionX = 2000;
+
+      const audit = Audit.createTaskRunner();
+
+      // Test that listener.positionX.value setter does the right thing.
+      audit.define('Set Listener.positionX.value', (task, should) => {
+        const context = new OfflineAudioContext(2, renderFrames, sampleRate);
+
+        createGraph(context);
+
+        // Frame at which the listener instantaneously moves to a new location.
+        const moveFrame = 512;
+
+        context.suspend(moveFrame / context.sampleRate)
+            .then(() => {
+              context.listener.positionX.value = positionX;
+            })
+            .then(() => context.resume());
+
+        verifyOutput(context, moveFrame, should, 'listenr.positionX.value')
+            .then(() => task.done());
+      });
+
+      // Test that listener.positionX.setValueAtTime() does the right thing.
+      audit.define('Listener.positionX.setValue', (task, should) => {
+        const context = new OfflineAudioContext(2, renderFrames, sampleRate);
+
+        createGraph(context);
+
+        // Frame at which the listener instantaneously moves to a new location.
+        const moveFrame = 512;
+
+        context.listener.positionX.setValueAtTime(
+            positionX, moveFrame / context.sampleRate);
+
+        verifyOutput(
+            context, moveFrame, should, 'listener.positionX.setValueATTime')
+            .then(() => task.done());
+      });
+
+      // Test that listener.setPosition() does the right thing.
+      audit.define('Listener.setPosition', (task, should) => {
+        const context = new OfflineAudioContext(2, renderFrames, sampleRate);
+
+        createGraph(context);
+
+        // Frame at which the listener instantaneously moves to a new location.
+        const moveFrame = 512;
+
+        context.suspend(moveFrame / context.sampleRate)
+            .then(() => {
+              context.listener.setPosition(positionX, 0, 0);
+            })
+            .then(() => context.resume());
+
+        verifyOutput(context, moveFrame, should, 'listener.setPostion')
+            .then(() => task.done());
+      });
+
+      audit.run();
+
+
+      // Create the basic graph for testing which consists of an oscillator node
+      // connected to a panner node.
+      function createGraph(context) {
+        const listener = context.listener;
+
+        listener.positionX.value = 0;
+        listener.positionY.value = 0;
+        listener.positionZ.value = 0;
+
+        const src = new OscillatorNode(context);
+
+        const panner = new PannerNode(context, {
+          distanceModel: 'linear',
+          refDistance: 1,
+          maxDistance: 3000,
+          positionX: positionX,
+          positionY: 0,
+          positionZ: 0
+        });
+        src.connect(panner).connect(context.destination);
+
+        src.start();
+      }
+
+
+      // Verify the output from the panner is correct.
+      function verifyOutput(context, moveFrame, should, prefix) {
+        return context.startRendering().then(resultBuffer => {
+          // Get the outputs (left and right)
+          const c0 = resultBuffer.getChannelData(0);
+          const c1 = resultBuffer.getChannelData(1);
+
+          // The src/listener set up is such that audio should only come
+          // from the right for until |moveFrame|.  Hence the left channel
+          // should be 0 (or very nearly 0).
+          const zero = new Float32Array(moveFrame);
+
+          should(
+              c0.slice(0, moveFrame), `${prefix}: output0[0:${moveFrame - 1}]`)
+              .beCloseToArray(zero, {absoluteThreshold: 1e-16});
+          should(
+              c1.slice(0, moveFrame), `${prefix}: output1[0:${moveFrame - 1}]`)
+              .notBeConstantValueOf(0);
+
+          // At |moveFrame| and beyond, the listener and source are at the
+          // same position, so the outputs from the left and right should be
+          // identical, and the left channel should not be 0 anymore.
+
+          should(c0.slice(moveFrame), `${prefix}: output0[${moveFrame}:]`)
+              .notBeConstantValueOf(0);
+          should(c1.slice(moveFrame), `${prefix}: output1[${moveFrame}:]`)
+              .beCloseToArray(c0.slice(moveFrame));
+        });
+      }
+    </script>
+  </body>
+</html>
+
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/ctor-panner.html b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/ctor-panner.html
new file mode 100644
index 0000000000..c434aa8c6a
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/ctor-panner.html
@@ -0,0 +1,468 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Constructor: Panner
+    </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, 'PannerNode', context);
+        task.done();
+      });
+
+      audit.define('default constructor', (task, should) => {
+        let prefix = 'node0';
+        let node = testDefaultConstructor(should, 'PannerNode', context, {
+          prefix: prefix,
+          numberOfInputs: 1,
+          numberOfOutputs: 1,
+          channelCount: 2,
+          channelCountMode: 'clamped-max',
+          channelInterpretation: 'speakers'
+        });
+
+        testDefaultAttributes(should, node, prefix, [
+          {name: 'panningModel', value: 'equalpower'},
+          {name: 'positionX', value: 0}, {name: 'positionY', value: 0},
+          {name: 'positionZ', value: 0}, {name: 'orientationX', value: 1},
+          {name: 'orientationY', value: 0}, {name: 'orientationZ', value: 0},
+          {name: 'distanceModel', value: 'inverse'},
+          {name: 'refDistance', value: 1}, {name: 'maxDistance', value: 10000},
+          {name: 'rolloffFactor', value: 1},
+          {name: 'coneInnerAngle', value: 360},
+          {name: 'coneOuterAngle', value: 360},
+          {name: 'coneOuterGain', value: 0}
+        ]);
+
+        // Test the listener too, while we're at it.
+        let listenerAttributes = [
+          {name: 'positionX', value: 0},
+          {name: 'positionY', value: 0},
+          {name: 'positionZ', value: 0},
+          {name: 'forwardX', value: 0},
+          {name: 'forwardY', value: 0},
+          {name: 'forwardZ', value: -1},
+          {name: 'upX', value: 0},
+          {name: 'upY', value: 1},
+          {name: 'upZ', value: 0},
+        ];
+
+        listenerAttributes.forEach((item) => {
+          should(
+              context.listener[item.name].value,
+              'context.listener.' + item.name + '.value')
+              .beEqualTo(item.value);
+        });
+
+        task.done();
+      });
+
+      audit.define('test AudioNodeOptions', (task, should) => {
+        // Can't use testAudioNodeOptions because the constraints for this node
+        // are not supported there.
+        let node;
+        let success = true;
+
+        // Test that we can set the channel count to 1 or 2.
+        let options = {channelCount: 1};
+        should(
+            () => {
+              node = new PannerNode(context, options);
+            },
+            'node1 = new PannerNode(c, ' + JSON.stringify(options) + ')')
+            .notThrow();
+        should(node.channelCount, 'node1.channelCount')
+            .beEqualTo(options.channelCount);
+
+        options = {channelCount: 2};
+        should(
+            () => {
+              node = new PannerNode(context, options);
+            },
+            'node2 = new PannerNode(c, ' + JSON.stringify(options) + ')')
+            .notThrow();
+        should(node.channelCount, 'node2.channelCount')
+            .beEqualTo(options.channelCount);
+
+        // Test that other channel counts throw an error
+        options = {channelCount: 0};
+        should(
+            () => {
+              node = new PannerNode(context, options);
+            },
+            'new PannerNode(c, ' + JSON.stringify(options) + ')')
+            .throw(DOMException, 'NotSupportedError');
+        should(
+            () => {
+              node = new PannerNode(context);
+              node.channelCount = options.channelCount;
+            },
+            `node.channelCount = ${options.channelCount}`)
+            .throw(DOMException, "NotSupportedError");
+        should(node.channelCount,
+               `node.channelCount after setting to ${options.channelCount}`)
+            .beEqualTo(2);
+
+        options = {channelCount: 3};
+        should(
+            () => {
+              node = new PannerNode(context, options);
+            },
+            'new PannerNode(c, ' + JSON.stringify(options) + ')')
+            .throw(DOMException, 'NotSupportedError');
+        should(
+            () => {
+              node = new PannerNode(context);
+              node.channelCount = options.channelCount;
+            },
+            `node.channelCount = ${options.channelCount}`)
+            .throw(DOMException, "NotSupportedError");
+        should(node.channelCount,
+               `node.channelCount after setting to ${options.channelCount}`)
+            .beEqualTo(2);
+
+        options = {channelCount: 99};
+        should(
+            () => {
+              node = new PannerNode(context, options);
+            },
+            'new PannerNode(c, ' + JSON.stringify(options) + ')')
+            .throw(DOMException, 'NotSupportedError');
+        should(
+            () => {
+              node = new PannerNode(context);
+              node.channelCount = options.channelCount;
+            },
+            `node.channelCount = ${options.channelCount}`)
+            .throw(DOMException, "NotSupportedError");
+        should(node.channelCount,
+               `node.channelCount after setting to ${options.channelCount}`)
+            .beEqualTo(2);
+
+        // Test channelCountMode.  A mode of "max" is illegal, but others are
+        // ok.
+        options = {channelCountMode: 'clamped-max'};
+        should(
+            () => {
+              node = new PannerNode(context, options);
+            },
+            'node3 = new PannerNode(c, ' + JSON.stringify(options) + ')')
+            .notThrow();
+        should(node.channelCountMode, 'node3.channelCountMode')
+            .beEqualTo(options.channelCountMode);
+
+        options = {channelCountMode: 'explicit'};
+        should(
+            () => {
+              node = new PannerNode(context, options);
+            },
+            'node4 = new PannerNode(c, ' + JSON.stringify(options) + ')')
+            .notThrow();
+        should(node.channelCountMode, 'node4.channelCountMode')
+            .beEqualTo(options.channelCountMode);
+
+        options = {channelCountMode: 'max'};
+        should(
+            () => {
+              node = new PannerNode(context, options);
+            },
+            'new PannerNode(c, ' + JSON.stringify(options) + ')')
+            .throw(DOMException, 'NotSupportedError');
+        should(
+            () => {
+              node = new PannerNode(context);
+              node.channelCountMode = options.channelCountMode;
+            },
+            `node.channelCountMode = ${options.channelCountMode}`)
+            .throw(DOMException, "NotSupportedError");
+        should(node.channelCountMode,
+               `node.channelCountMode after setting to ${options.channelCountMode}`)
+            .beEqualTo("clamped-max");
+
+        options = {channelCountMode: 'foobar'};
+        should(
+            () => {
+              node = new PannerNode(context, options);
+            },
+            'new PannerNode(c, " + JSON.stringify(options) + ")')
+            .throw(TypeError);
+        should(
+            () => {
+              node = new PannerNode(context);
+              node.channelCountMode = options.channelCountMode;
+            },
+            `node.channelCountMode = ${options.channelCountMode}`)
+            .notThrow(); // Invalid assignment to enum-valued attrs does not throw.
+        should(node.channelCountMode,
+               `node.channelCountMode after setting to ${options.channelCountMode}`)
+            .beEqualTo("clamped-max");
+
+        // Test channelInterpretation.
+        options = {channelInterpretation: 'speakers'};
+        should(
+            () => {
+              node = new PannerNode(context, options);
+            },
+            'node5 = new PannerNode(c, ' + JSON.stringify(options) + ')')
+            .notThrow();
+        should(node.channelInterpretation, 'node5.channelInterpretation')
+            .beEqualTo(options.channelInterpretation);
+
+        options = {channelInterpretation: 'discrete'};
+        should(
+            () => {
+              node = new PannerNode(context, options);
+            },
+            'node6 = new PannerNode(c, ' + JSON.stringify(options) + ')')
+            .notThrow();
+        should(node.channelInterpretation, 'node6.channelInterpretation')
+            .beEqualTo(options.channelInterpretation);
+
+        options = {channelInterpretation: 'foobar'};
+        should(
+            () => {
+              node = new PannerNode(context, options);
+            },
+            'new PannerNode(c, ' + JSON.stringify(options) + ')')
+            .throw(TypeError);
+
+        // Test maxDistance
+        options = {maxDistance: -1};
+        should(
+            () => {
+              node = new PannerNode(context, options);
+            },
+            'new PannerNode(c, ' + JSON.stringify(options) + ')')
+            .throw(RangeError);
+        should(
+            () => {
+              node = new PannerNode(context);
+              node.maxDistance = options.maxDistance;
+            },
+            `node.maxDistance = ${options.maxDistance}`)
+            .throw(RangeError);
+        should(node.maxDistance,
+               `node.maxDistance after setting to ${options.maxDistance}`)
+            .beEqualTo(10000);
+
+        options = {maxDistance: 100};
+        should(
+            () => {
+              node = new PannerNode(context, options);
+            },
+            'node7 = new PannerNode(c, ' + JSON.stringify(options) + ')')
+            .notThrow();
+        should(node.maxDistance, 'node7.maxDistance')
+            .beEqualTo(options.maxDistance);
+
+        // Test rolloffFactor
+        options = {rolloffFactor: -1};
+        should(
+            () => {
+              node = new PannerNode(context, options);
+            },
+            'new PannerNode(c, ' + JSON.stringify(options) + ')')
+            .throw(RangeError);
+        should(
+            () => {
+              node = new PannerNode(context);
+              node.rolloffFactor = options.rolloffFactor;
+            },
+            `node.rolloffFactor = ${options.rolloffFactor}`)
+            .throw(RangeError);
+        should(node.rolloffFactor,
+               `node.rolloffFactor after setting to ${options.rolloffFactor}`)
+            .beEqualTo(1);
+
+        options = {rolloffFactor: 0};
+        should(
+            () => {
+              node = new PannerNode(context, options);
+            },
+            'node8 = new PannerNode(c, ' + JSON.stringify(options) + ')')
+            .notThrow();
+        should(node.rolloffFactor, 'node8.rolloffFactor')
+            .beEqualTo(options.rolloffFactor);
+
+        options = {rolloffFactor: 0.5};
+        should(
+            () => {
+              node = new PannerNode(context, options);
+            },
+            'node8 = new PannerNode(c, ' + JSON.stringify(options) + ')')
+            .notThrow();
+        should(node.rolloffFactor, 'node8.rolloffFactor')
+            .beEqualTo(options.rolloffFactor);
+
+        options = {rolloffFactor: 100};
+        should(
+            () => {
+              node = new PannerNode(context, options);
+            },
+            'node8 = new PannerNode(c, ' + JSON.stringify(options) + ')')
+            .notThrow();
+        should(node.rolloffFactor, 'node8.rolloffFactor')
+            .beEqualTo(options.rolloffFactor);
+
+        // Test coneOuterGain
+        options = {coneOuterGain: -1};
+        should(
+            () => {
+              node = new PannerNode(context, options);
+            },
+            'new PannerNode(c, ' + JSON.stringify(options) + ')')
+            .throw(DOMException, 'InvalidStateError');
+        should(
+            () => {
+              node = new PannerNode(context);
+              node.coneOuterGain = options.coneOuterGain;
+            },
+            `node.coneOuterGain = ${options.coneOuterGain}`)
+            .throw(DOMException, 'InvalidStateError');
+        should(node.coneOuterGain,
+               `node.coneOuterGain after setting to ${options.coneOuterGain}`)
+            .beEqualTo(0);
+
+        options = {coneOuterGain: 1.1};
+        should(
+            () => {
+              node = new PannerNode(context, options);
+            },
+            'new PannerNode(c, ' + JSON.stringify(options) + ')')
+            .throw(DOMException, 'InvalidStateError');
+        should(
+            () => {
+              node = new PannerNode(context);
+              node.coneOuterGain = options.coneOuterGain;
+            },
+            `node.coneOuterGain = ${options.coneOuterGain}`)
+            .throw(DOMException, 'InvalidStateError');
+        should(node.coneOuterGain,
+               `node.coneOuterGain after setting to ${options.coneOuterGain}`)
+            .beEqualTo(0);
+
+        options = {coneOuterGain: 0.0};
+        should(
+            () => {
+              node = new PannerNode(context, options);
+            },
+            'node9 = new PannerNode(c, ' + JSON.stringify(options) + ')')
+            .notThrow();
+        should(node.coneOuterGain, 'node9.coneOuterGain')
+            .beEqualTo(options.coneOuterGain);
+        options = {coneOuterGain: 0.5};
+        should(
+            () => {
+              node = new PannerNode(context, options);
+            },
+            'node9 = new PannerNode(c, ' + JSON.stringify(options) + ')')
+            .notThrow();
+        should(node.coneOuterGain, 'node9.coneOuterGain')
+            .beEqualTo(options.coneOuterGain);
+
+        options = {coneOuterGain: 1.0};
+        should(
+            () => {
+              node = new PannerNode(context, options);
+            },
+            'node9 = new PannerNode(c, ' + JSON.stringify(options) + ')')
+            .notThrow();
+        should(node.coneOuterGain, 'node9.coneOuterGain')
+            .beEqualTo(options.coneOuterGain);
+
+        task.done();
+      });
+
+      audit.define('constructor with options', (task, should) => {
+        let node;
+        let success = true;
+        let options = {
+          panningModel: 'HRTF',
+          // We use full double float values here to verify also that the actual
+          // AudioParam value is properly rounded to a float.  The actual value
+          // is immaterial as long as x != Math.fround(x).
+          positionX: Math.SQRT2,
+          positionY: 2 * Math.SQRT2,
+          positionZ: 3 * Math.SQRT2,
+          orientationX: -Math.SQRT2,
+          orientationY: -2 * Math.SQRT2,
+          orientationZ: -3 * Math.SQRT2,
+          distanceModel: 'linear',
+          // We use full double float values here to verify also that the actual
+          // attribute is a double float.  The actual value is immaterial as
+          // long as x != Math.fround(x).
+          refDistance: Math.PI,
+          maxDistance: 2 * Math.PI,
+          rolloffFactor: 3 * Math.PI,
+          coneInnerAngle: 4 * Math.PI,
+          coneOuterAngle: 5 * Math.PI,
+          coneOuterGain: 0.1 * Math.PI
+        };
+
+        should(
+            () => {
+              node = new PannerNode(context, options);
+            },
+            'node = new PannerNode(c, ' + JSON.stringify(options) + ')')
+            .notThrow();
+        should(node instanceof PannerNode, 'node instanceof PannerNode')
+            .beEqualTo(true);
+
+        should(node.panningModel, 'node.panningModel')
+            .beEqualTo(options.panningModel);
+        should(node.positionX.value, 'node.positionX.value')
+            .beEqualTo(Math.fround(options.positionX));
+        should(node.positionY.value, 'node.positionY.value')
+            .beEqualTo(Math.fround(options.positionY));
+        should(node.positionZ.value, 'node.positionZ.value')
+            .beEqualTo(Math.fround(options.positionZ));
+        should(node.orientationX.value, 'node.orientationX.value')
+            .beEqualTo(Math.fround(options.orientationX));
+        should(node.orientationY.value, 'node.orientationY.value')
+            .beEqualTo(Math.fround(options.orientationY));
+        should(node.orientationZ.value, 'node.orientationZ.value')
+            .beEqualTo(Math.fround(options.orientationZ));
+        should(node.distanceModel, 'node.distanceModel')
+            .beEqualTo(options.distanceModel);
+        should(node.refDistance, 'node.refDistance')
+            .beEqualTo(options.refDistance);
+        should(node.maxDistance, 'node.maxDistance')
+            .beEqualTo(options.maxDistance);
+        should(node.rolloffFactor, 'node.rolloffFactor')
+            .beEqualTo(options.rolloffFactor);
+        should(node.coneInnerAngle, 'node.coneInnerAngle')
+            .beEqualTo(options.coneInnerAngle);
+        should(node.coneOuterAngle, 'node.coneOuterAngle')
+            .beEqualTo(options.coneOuterAngle);
+        should(node.coneOuterGain, 'node.coneOuterGain')
+            .beEqualTo(options.coneOuterGain);
+
+        should(node.channelCount, 'node.channelCount').beEqualTo(2);
+        should(node.channelCountMode, 'node.channelCountMode')
+            .beEqualTo('clamped-max');
+        should(node.channelInterpretation, 'node.channelInterpretation')
+            .beEqualTo('speakers');
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/distance-exponential.html b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/distance-exponential.html
new file mode 100644
index 0000000000..383e2c67b6
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/distance-exponential.html
@@ -0,0 +1,34 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      distance-exponential.html
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="../../resources/audit-util.js"></script>
+    <script src="../../resources/audit.js"></script>
+    <script src="../../resources/distance-model-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {
+            label: 'test',
+            description: 'Exponential distance model for PannerNode'
+          },
+          (task, should) => {
+            // Create offline audio context.
+            context = new OfflineAudioContext(
+                2, sampleRate * renderLengthSeconds, sampleRate);
+
+            createTestAndRun(context, 'exponential', should)
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/distance-inverse.html b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/distance-inverse.html
new file mode 100644
index 0000000000..a4ff984e09
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/distance-inverse.html
@@ -0,0 +1,28 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      distance-inverse.html
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="../../resources/audit-util.js"></script>
+    <script src="../../resources/audit.js"></script>
+    <script src="../../resources/distance-model-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      audit.define('test', (task, should) => {
+        // Create offline audio context.
+        context = new OfflineAudioContext(
+            2, sampleRate * renderLengthSeconds, sampleRate);
+
+        createTestAndRun(context, 'inverse', should).then(() => task.done());
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/distance-linear.html b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/distance-linear.html
new file mode 100644
index 0000000000..812fea3eba
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/distance-linear.html
@@ -0,0 +1,30 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      distance-linear.html
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="../../resources/audit-util.js"></script>
+    <script src="../../resources/audit.js"></script>
+    <script src="../../resources/distance-model-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {label: 'test', description: 'Linear distance model PannerNode'},
+          (task, should) => {
+            // Create offline audio context.
+            context = new OfflineAudioContext(
+                2, sampleRate * renderLengthSeconds, sampleRate);
+
+            createTestAndRun(context, 'linear', should).then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-automation-basic.html b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-automation-basic.html
new file mode 100644
index 0000000000..5c3df0e6fd
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-automation-basic.html
@@ -0,0 +1,298 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Basic PannerNode with Automation Position Properties
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="../../resources/audit-util.js"></script>
+    <script src="../../resources/audit.js"></script>
+    <script src="../../resources/panner-formulas.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let sampleRate = 48000;
+
+      // These tests are quite slow, so don't run for many frames.  256 frames
+      // should be enough to demonstrate that automations are working.
+      let renderFrames = 256;
+      let renderDuration = renderFrames / sampleRate;
+
+      let audit = Audit.createTaskRunner();
+
+      // Array of tests for setting the panner positions.  These tests basically
+      // verify that the position setters for the panner and listener are
+      // working correctly.
+      let testConfig = [
+        {
+          setter: 'positionX',
+        },
+        {
+          setter: 'positionY',
+        },
+        {
+          setter: 'positionZ',
+        }
+      ];
+
+      // Create tests for the panner position setters.  Both mono and steroe
+      // sources are tested.
+      for (let k = 0; k < testConfig.length; ++k) {
+        let config = testConfig[k];
+        // Function to create the test to define the test.
+        let tester = function(config, channelCount) {
+          return (task, should) => {
+            let nodes = createGraph(channelCount);
+            let {context, source, panner} = nodes;
+
+            let message = channelCount == 1 ? 'Mono' : 'Stereo';
+            message += ' panner.' + config.setter;
+
+            testPositionSetter(should, {
+              nodes: nodes,
+              pannerSetter: panner[config.setter],
+              message: message
+            }).then(() => task.done());
+          }
+        };
+
+        audit.define('Stereo panner.' + config.setter, tester(config, 2));
+        audit.define('Mono panner.' + config.setter, tester(config, 1));
+      }
+
+      // Create tests for the listener position setters.  Both mono and steroe
+      // sources are tested.
+      for (let k = 0; k < testConfig.length; ++k) {
+        let config = testConfig[k];
+        // Function to create the test to define the test.
+        let tester = function(config, channelCount) {
+          return (task, should) => {
+            let nodes = createGraph(channelCount);
+            let {context, source, panner} = nodes;
+
+            let message = channelCount == 1 ? 'Mono' : 'Stereo';
+            message += ' listener.' + config.setter;
+
+            // Some relatively arbitrary (non-default) position for the source
+            // location.
+            panner.setPosition(1, 0, 1);
+
+            testPositionSetter(should, {
+              nodes: nodes,
+              pannerSetter: context.listener[config.setter],
+              message: message
+            }).then(() => task.done());
+          }
+        };
+
+        audit.define('Stereo listener.' + config.setter, tester(config, 2));
+        audit.define('Mono listener.' + config.setter, tester(config, 1));
+      }
+
+      // Test setPosition method.
+      audit.define('setPosition', (task, should) => {
+        let {context, panner, source} = createGraph(2);
+
+        // Initialize source position (values don't really matter).
+        panner.setPosition(1, 1, 1);
+
+        // After some (unimportant) time, move the panner to a (any) new
+        // location.
+        let suspendFrame = 128;
+        context.suspend(suspendFrame / sampleRate)
+            .then(function() {
+              panner.setPosition(-100, 2000, 8000);
+            })
+            .then(context.resume.bind(context));
+
+        context.startRendering()
+            .then(function(resultBuffer) {
+              verifyPannerOutputChanged(
+                  should, resultBuffer,
+                  {message: 'setPosition', suspendFrame: suspendFrame});
+            })
+            .then(() => task.done());
+      });
+
+      audit.define('orientation setter', (task, should) => {
+        let {context, panner, source} = createGraph(2);
+
+        // For orientation to matter, we need to make the source directional,
+        // and also move away from the listener (because the default location is
+        // 0,0,0).
+        panner.setPosition(0, 0, 1);
+        panner.coneInnerAngle = 0;
+        panner.coneOuterAngle = 360;
+        panner.coneOuterGain = .001;
+
+        // After some (unimportant) time, change the panner orientation to a new
+        // orientation.  The only constraint is that the orientation changes
+        // from before.
+        let suspendFrame = 128;
+        context.suspend(suspendFrame / sampleRate)
+            .then(function() {
+              panner.orientationX.value = -100;
+              panner.orientationY.value = 2000;
+              panner.orientationZ.value = 8000;
+            })
+            .then(context.resume.bind(context));
+
+        context.startRendering()
+            .then(function(resultBuffer) {
+              verifyPannerOutputChanged(should, resultBuffer, {
+                message: 'panner.orientation{XYZ}',
+                suspendFrame: suspendFrame
+              });
+            })
+            .then(() => task.done());
+      });
+
+      audit.define('forward setter', (task, should) => {
+        let {context, panner, source} = createGraph(2);
+
+        // For orientation to matter, we need to make the source directional,
+        // and also move away from the listener (because the default location is
+        // 0,0,0).
+        panner.setPosition(0, 0, 1);
+        panner.coneInnerAngle = 0;
+        panner.coneOuterAngle = 360;
+        panner.coneOuterGain = .001;
+
+        // After some (unimportant) time, change the panner orientation to a new
+        // orientation.  The only constraint is that the orientation changes
+        // from before.
+        let suspendFrame = 128;
+        context.suspend(suspendFrame / sampleRate)
+            .then(function() {
+              context.listener.forwardX.value = -100;
+              context.listener.forwardY.value = 2000;
+              context.listener.forwardZ.value = 8000;
+            })
+            .then(context.resume.bind(context));
+
+        context.startRendering()
+            .then(function(resultBuffer) {
+              verifyPannerOutputChanged(should, resultBuffer, {
+                message: 'listener.forward{XYZ}',
+                suspendFrame: suspendFrame
+              });
+            })
+            .then(() => task.done());
+      });
+
+      audit.define('up setter', (task, should) => {
+        let {context, panner, source} = createGraph(2);
+
+        // For orientation to matter, we need to make the source directional,
+        // and also move away from the listener (because the default location is
+        // 0,0,0).
+        panner.setPosition(0, 0, 1);
+        panner.coneInnerAngle = 0;
+        panner.coneOuterAngle = 360;
+        panner.coneOuterGain = .001;
+        panner.setPosition(1, 0, 1);
+
+        // After some (unimportant) time, change the panner orientation to a new
+        // orientation.  The only constraint is that the orientation changes
+        // from before.
+        let suspendFrame = 128;
+        context.suspend(suspendFrame / sampleRate)
+            .then(function() {
+              context.listener.upX.value = 100;
+              context.listener.upY.value = 100;
+              context.listener.upZ.value = 100;
+              ;
+            })
+            .then(context.resume.bind(context));
+
+        context.startRendering()
+            .then(function(resultBuffer) {
+              verifyPannerOutputChanged(
+                  should, resultBuffer,
+                  {message: 'listener.up{XYZ}', suspendFrame: suspendFrame});
+            })
+            .then(() => task.done());
+      });
+
+      audit.run();
+
+      function createGraph(channelCount) {
+        let context = new OfflineAudioContext(2, renderFrames, sampleRate);
+        let panner = context.createPanner();
+        let source = context.createBufferSource();
+        source.buffer =
+            createConstantBuffer(context, 1, channelCount == 1 ? 1 : [1, 2]);
+        source.loop = true;
+
+        source.connect(panner);
+        panner.connect(context.destination);
+
+        source.start();
+        return {context: context, source: source, panner: panner};
+      }
+
+      function testPositionSetter(should, options) {
+        let {nodes, pannerSetter, message} = options;
+
+        let {context, source, panner} = nodes;
+
+        // Set panner x position. (Value doesn't matter);
+        pannerSetter.value = 1;
+
+        // Wait a bit and set a new position.  (Actual time and position doesn't
+        // matter).
+        let suspendFrame = 128;
+        context.suspend(suspendFrame / sampleRate)
+            .then(function() {
+              pannerSetter.value = 10000;
+            })
+            .then(context.resume.bind(context));
+
+        return context.startRendering().then(function(resultBuffer) {
+          verifyPannerOutputChanged(
+              should, resultBuffer,
+              {message: message, suspendFrame: suspendFrame});
+        });
+      }
+
+      function verifyPannerOutputChanged(should, resultBuffer, options) {
+        let {message, suspendFrame} = options;
+        // Verify that the first part of output is constant. (Doesn't matter
+        // what.)
+        let data0 = resultBuffer.getChannelData(0);
+        let data1 = resultBuffer.getChannelData(1);
+
+        let middle = '[0, ' + suspendFrame + ') ';
+        should(
+            data0.slice(0, suspendFrame),
+            message + '.value frame ' + middle + 'channel 0')
+            .beConstantValueOf(data0[0]);
+        should(
+            data1.slice(0, suspendFrame),
+            message + '.value frame ' + middle + 'channel 1')
+            .beConstantValueOf(data1[0]);
+
+        // The rest after suspendTime should be constant and different from the
+        // first part.
+        middle = '[' + suspendFrame + ', ' + renderFrames + ') ';
+        should(
+            data0.slice(suspendFrame),
+            message + '.value frame ' + middle + 'channel 0')
+            .beConstantValueOf(data0[suspendFrame]);
+        should(
+            data1.slice(suspendFrame),
+            message + '.value frame ' + middle + 'channel 1')
+            .beConstantValueOf(data1[suspendFrame]);
+        should(
+            data0[suspendFrame],
+            message + ': Output at frame ' + suspendFrame + ' channel 0')
+            .notBeEqualTo(data0[0]);
+        should(
+            data1[suspendFrame],
+            message + ': Output at frame ' + suspendFrame + ' channel 1')
+            .notBeEqualTo(data1[0]);
+      }
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-automation-equalpower-stereo.html b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-automation-equalpower-stereo.html
new file mode 100644
index 0000000000..7afc9c2a39
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-automation-equalpower-stereo.html
@@ -0,0 +1,47 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      panner-automation-equalpower-stereo.html
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="../../resources/audit-util.js"></script>
+    <script src="../../resources/audit.js"></script>
+    <script src="../../resources/panner-model-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      // To test the panner, we create a number of panner nodes
+      // equally spaced on a semicircle at unit distance.  The
+      // semicircle covers the azimuth range from -90 to 90 deg,
+      // covering full left to full right.  Each source is an impulse
+      // turning at a different time and we check that the rendered
+      // impulse has the expected gain.
+      audit.define(
+          {
+            label: 'test',
+            description:
+                'Equal-power panner model of AudioPannerNode with stereo source',
+          },
+          (task, should) => {
+            // Create offline audio context.
+            context = new OfflineAudioContext(
+                2, sampleRate * renderLengthSeconds, sampleRate);
+
+            createTestAndRun(
+                context, should, nodesToCreate, 2,
+                function(panner, x, y, z) {
+                  panner.positionX.value = x;
+                  panner.positionY.value = y;
+                  panner.positionZ.value = z;
+                })
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-automation-position.html b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-automation-position.html
new file mode 100644
index 0000000000..8e09e869ac
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-automation-position.html
@@ -0,0 +1,265 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Automation of PannerNode Positions
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="../../resources/audit-util.js"></script>
+    <script src="../../resources/audit.js"></script>
+    <script src="../../resources/panner-formulas.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let sampleRate = 48000;
+      // These tests are quite slow, so don't run for many frames.  256 frames
+      // should be enough to demonstrate that automations are working.
+      let renderFrames = 256;
+      let renderDuration = renderFrames / sampleRate;
+
+      let context;
+      let panner;
+
+      let audit = Audit.createTaskRunner();
+
+      // Set of tests for the panner node with automations applied to the
+      // position of the source.
+      let testConfigs = [
+        {
+          // Distance model parameters for the panner
+          distanceModel: {model: 'inverse', rolloff: 1},
+          // Initial location of the source
+          startPosition: [0, 0, 1],
+          // Final position of the source.  For this test, we only want to move
+          // on the z axis which
+          // doesn't change the azimuth angle.
+          endPosition: [0, 0, 10000],
+        },
+        {
+          distanceModel: {model: 'inverse', rolloff: 1},
+          startPosition: [0, 0, 1],
+          // An essentially random end position, but it should be such that
+          // azimuth angle changes as
+          // we move from the start to the end.
+          endPosition: [20000, 30000, 10000],
+          errorThreshold: [
+            {
+              // Error threshold for 1-channel case
+              relativeThreshold: 4.8124e-7
+            },
+            {
+              // Error threshold for 2-channel case
+              relativeThreshold: 4.3267e-7
+            }
+          ],
+        },
+        {
+          distanceModel: {model: 'exponential', rolloff: 1.5},
+          startPosition: [0, 0, 1],
+          endPosition: [20000, 30000, 10000],
+          errorThreshold:
+              [{relativeThreshold: 5.0783e-7}, {relativeThreshold: 5.2180e-7}]
+        },
+        {
+          distanceModel: {model: 'linear', rolloff: 1},
+          startPosition: [0, 0, 1],
+          endPosition: [20000, 30000, 10000],
+          errorThreshold: [
+            {relativeThreshold: 6.5324e-6}, {relativeThreshold: 6.5756e-6}
+          ]
+        }
+      ];
+
+      for (let k = 0; k < testConfigs.length; ++k) {
+        let config = testConfigs[k];
+        let tester = function(c, channelCount) {
+          return (task, should) => {
+            runTest(should, c, channelCount).then(() => task.done());
+          }
+        };
+
+        let baseTestName = config.distanceModel.model +
+            ' rolloff: ' + config.distanceModel.rolloff;
+
+        // Define tasks for both 1-channel and 2-channel
+        audit.define(k + ': 1-channel ' + baseTestName, tester(config, 1));
+        audit.define(k + ': 2-channel ' + baseTestName, tester(config, 2));
+      }
+
+      audit.run();
+
+      function runTest(should, options, channelCount) {
+        // Output has 5 channels: channels 0 and 1 are for the stereo output of
+        // the panner node. Channels 2-5 are the for automation of the x,y,z
+        // coordinate so that we have actual coordinates used for the panner
+        // automation.
+        context = new OfflineAudioContext(5, renderFrames, sampleRate);
+
+        // Stereo source for the panner.
+        let source = context.createBufferSource();
+        source.buffer = createConstantBuffer(
+            context, renderFrames, channelCount == 1 ? 1 : [1, 2]);
+
+        panner = context.createPanner();
+        panner.distanceModel = options.distanceModel.model;
+        panner.rolloffFactor = options.distanceModel.rolloff;
+        panner.panningModel = 'equalpower';
+
+        // Source and gain node for the z-coordinate calculation.
+        let dist = context.createBufferSource();
+        dist.buffer = createConstantBuffer(context, 1, 1);
+        dist.loop = true;
+        let gainX = context.createGain();
+        let gainY = context.createGain();
+        let gainZ = context.createGain();
+        dist.connect(gainX);
+        dist.connect(gainY);
+        dist.connect(gainZ);
+
+        // Set the gain automation to match the z-coordinate automation of the
+        // panner.
+
+        // End the automation some time before the end of the rendering so we
+        // can verify that automation has the correct end time and value.
+        let endAutomationTime = 0.75 * renderDuration;
+
+        gainX.gain.setValueAtTime(options.startPosition[0], 0);
+        gainX.gain.linearRampToValueAtTime(
+            options.endPosition[0], endAutomationTime);
+        gainY.gain.setValueAtTime(options.startPosition[1], 0);
+        gainY.gain.linearRampToValueAtTime(
+            options.endPosition[1], endAutomationTime);
+        gainZ.gain.setValueAtTime(options.startPosition[2], 0);
+        gainZ.gain.linearRampToValueAtTime(
+            options.endPosition[2], endAutomationTime);
+
+        dist.start();
+
+        // Splitter and merger to map the panner output and the z-coordinate
+        // automation to the correct channels in the destination.
+        let splitter = context.createChannelSplitter(2);
+        let merger = context.createChannelMerger(5);
+
+        source.connect(panner);
+        // Split the output of the panner to separate channels
+        panner.connect(splitter);
+
+        // Merge the panner outputs and the z-coordinate output to the correct
+        // destination channels.
+        splitter.connect(merger, 0, 0);
+        splitter.connect(merger, 1, 1);
+        gainX.connect(merger, 0, 2);
+        gainY.connect(merger, 0, 3);
+        gainZ.connect(merger, 0, 4);
+
+        merger.connect(context.destination);
+
+        // Initialize starting point of the panner.
+        panner.positionX.setValueAtTime(options.startPosition[0], 0);
+        panner.positionY.setValueAtTime(options.startPosition[1], 0);
+        panner.positionZ.setValueAtTime(options.startPosition[2], 0);
+
+        // Automate z coordinate to move away from the listener
+        panner.positionX.linearRampToValueAtTime(
+            options.endPosition[0], 0.75 * renderDuration);
+        panner.positionY.linearRampToValueAtTime(
+            options.endPosition[1], 0.75 * renderDuration);
+        panner.positionZ.linearRampToValueAtTime(
+            options.endPosition[2], 0.75 * renderDuration);
+
+        source.start();
+
+        // Go!
+        return context.startRendering().then(function(renderedBuffer) {
+          // Get the panner outputs
+          let data0 = renderedBuffer.getChannelData(0);
+          let data1 = renderedBuffer.getChannelData(1);
+          let xcoord = renderedBuffer.getChannelData(2);
+          let ycoord = renderedBuffer.getChannelData(3);
+          let zcoord = renderedBuffer.getChannelData(4);
+
+          // We're doing a linear ramp on the Z axis with the equalpower panner,
+          // so the equalpower panning gain remains constant.  We only need to
+          // model the distance effect.
+
+          // Compute the distance gain
+          let distanceGain = new Float32Array(xcoord.length);
+          ;
+
+          if (panner.distanceModel === 'inverse') {
+            for (let k = 0; k < distanceGain.length; ++k) {
+              distanceGain[k] =
+                  inverseDistance(panner, xcoord[k], ycoord[k], zcoord[k])
+            }
+          } else if (panner.distanceModel === 'linear') {
+            for (let k = 0; k < distanceGain.length; ++k) {
+              distanceGain[k] =
+                  linearDistance(panner, xcoord[k], ycoord[k], zcoord[k])
+            }
+          } else if (panner.distanceModel === 'exponential') {
+            for (let k = 0; k < distanceGain.length; ++k) {
+              distanceGain[k] =
+                  exponentialDistance(panner, xcoord[k], ycoord[k], zcoord[k])
+            }
+          }
+
+          // Compute the expected result.  Since we're on the z-axis, the left
+          // and right channels pass through the equalpower panner unchanged.
+          // Only need to apply the distance gain.
+          let buffer0 = source.buffer.getChannelData(0);
+          let buffer1 =
+              channelCount == 2 ? source.buffer.getChannelData(1) : buffer0;
+
+          let azimuth = new Float32Array(buffer0.length);
+
+          for (let k = 0; k < data0.length; ++k) {
+            azimuth[k] = calculateAzimuth(
+                [xcoord[k], ycoord[k], zcoord[k]],
+                [
+                  context.listener.positionX.value,
+                  context.listener.positionY.value,
+                  context.listener.positionZ.value
+                ],
+                [
+                  context.listener.forwardX.value,
+                  context.listener.forwardY.value,
+                  context.listener.forwardZ.value
+                ],
+                [
+                  context.listener.upX.value, context.listener.upY.value,
+                  context.listener.upZ.value
+                ]);
+          }
+
+          let expected = applyPanner(azimuth, buffer0, buffer1, channelCount);
+          let expected0 = expected.left;
+          let expected1 = expected.right;
+
+          for (let k = 0; k < expected0.length; ++k) {
+            expected0[k] *= distanceGain[k];
+            expected1[k] *= distanceGain[k];
+          }
+
+          let info = options.distanceModel.model +
+              ', rolloff: ' + options.distanceModel.rolloff;
+          let prefix = channelCount + '-channel ' +
+              '[' + options.startPosition[0] + ', ' + options.startPosition[1] +
+              ', ' + options.startPosition[2] + '] -> [' +
+              options.endPosition[0] + ', ' + options.endPosition[1] + ', ' +
+              options.endPosition[2] + ']: ';
+
+          let errorThreshold = 0;
+
+          if (options.errorThreshold)
+            errorThreshold = options.errorThreshold[channelCount - 1]
+
+            should(data0, prefix + 'distanceModel: ' + info + ', left channel')
+                .beCloseToArray(expected0, {absoluteThreshold: errorThreshold});
+          should(data1, prefix + 'distanceModel: ' + info + ', right channel')
+              .beCloseToArray(expected1, {absoluteThreshold: errorThreshold});
+        });
+      }
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-azimuth.html b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-azimuth.html
new file mode 100644
index 0000000000..d09f2ec352
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-azimuth.html
@@ -0,0 +1,51 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Test Panner Azimuth Calculation</title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="../../resources/audit.js"></script>
+  </head>
+
+  <body>
+    <script>
+      const audit = Audit.createTaskRunner();
+
+      // Fairly arbitrary sample rate
+      const sampleRate = 16000;
+
+      audit.define('Azimuth calculation', (task, should) => {
+        // Two channels for the context so we can see each channel of the
+        // panner node.
+        let context = new OfflineAudioContext(2, sampleRate, sampleRate);
+
+        let src = new ConstantSourceNode(context);
+        let panner = new PannerNode(context);
+
+        src.connect(panner).connect(context.destination);
+
+        // The source is still pointed directly at the listener, but is now
+        // directly above.  The audio should be the same in both the left and
+        // right channels.
+        panner.positionY.value = 1;
+
+        src.start();
+
+        context.startRendering()
+            .then(audioBuffer => {
+              // The left and right channels should contain the same signal.
+              let c0 = audioBuffer.getChannelData(0);
+              let c1 = audioBuffer.getChannelData(1);
+
+              let expected = Math.fround(Math.SQRT1_2);
+
+              should(c0, 'Left channel').beConstantValueOf(expected);
+              should(c1, 'Righteft channel').beConstantValueOf(expected);
+            })
+            .then(() => task.done());
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-distance-clamping.html b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-distance-clamping.html
new file mode 100644
index 0000000000..78c1ec6dc2
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-distance-clamping.html
@@ -0,0 +1,227 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Clamping of Distance for PannerNode
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="../../resources/audit-util.js"></script>
+    <script src="../../resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      // Arbitrary sample rate and render length.
+      let sampleRate = 48000;
+      let renderFrames = 128;
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define('ref-distance-error', (task, should) => {
+        testDistanceLimits(should, {name: 'refDistance', isZeroAllowed: true});
+        task.done();
+      });
+
+      audit.define('max-distance-error', (task, should) => {
+        testDistanceLimits(should, {name: 'maxDistance', isZeroAllowed: false});
+        task.done();
+      });
+
+      function testDistanceLimits(should, options) {
+        // Verify that exceptions are thrown for invalid values of refDistance.
+        let context = new OfflineAudioContext(1, renderFrames, sampleRate);
+
+        let attrName = options.name;
+        let prefix = 'new PannerNode(c, {' + attrName + ': ';
+
+        should(function() {
+          let nodeOptions = {};
+          nodeOptions[attrName] = -1;
+          new PannerNode(context, nodeOptions);
+        }, prefix + '-1})').throw(RangeError);
+
+        if (options.isZeroAllowed) {
+          should(function() {
+            let nodeOptions = {};
+            nodeOptions[attrName] = 0;
+            new PannerNode(context, nodeOptions);
+          }, prefix + '0})').notThrow();
+        } else {
+          should(function() {
+            let nodeOptions = {};
+            nodeOptions[attrName] = 0;
+            new PannerNode(context, nodeOptions);
+          }, prefix + '0})').throw(RangeError);
+        }
+
+        // The smallest representable positive single float.
+        let leastPositiveDoubleFloat = 4.9406564584124654e-324;
+
+        should(function() {
+          let nodeOptions = {};
+          nodeOptions[attrName] = leastPositiveDoubleFloat;
+          new PannerNode(context, nodeOptions);
+        }, prefix + leastPositiveDoubleFloat + '})').notThrow();
+
+        prefix = 'panner.' + attrName + ' = ';
+        panner = new PannerNode(context);
+        should(function() {
+          panner[attrName] = -1;
+        }, prefix + '-1').throw(RangeError);
+
+        if (options.isZeroAllowed) {
+          should(function() {
+            panner[attrName] = 0;
+          }, prefix + '0').notThrow();
+        } else {
+          should(function() {
+            panner[attrName] = 0;
+          }, prefix + '0').throw(RangeError);
+        }
+
+        should(function() {
+          panner[attrName] = leastPositiveDoubleFloat;
+        }, prefix + leastPositiveDoubleFloat).notThrow();
+      }
+
+      audit.define('min-distance', async (task, should) => {
+        // Test clamping of panner distance to refDistance for all of the
+        // distance models.  The actual distance is arbitrary as long as it's
+        // less than refDistance.  We test default and non-default values for
+        // the panner's refDistance and maxDistance.
+        // correctly.
+        await runTest(should, {
+          distance: 0.01,
+          distanceModel: 'linear',
+        });
+        await runTest(should, {
+          distance: 0.01,
+          distanceModel: 'exponential',
+        });
+        await runTest(should, {
+          distance: 0.01,
+          distanceModel: 'inverse',
+        });
+        await runTest(should, {
+          distance: 2,
+          distanceModel: 'linear',
+          maxDistance: 1000,
+          refDistance: 10,
+        });
+        await runTest(should, {
+          distance: 2,
+          distanceModel: 'exponential',
+          maxDistance: 1000,
+          refDistance: 10,
+        });
+        await runTest(should, {
+          distance: 2,
+          distanceModel: 'inverse',
+          maxDistance: 1000,
+          refDistance: 10,
+        });
+        task.done();
+      });
+
+      audit.define('max-distance', async (task, should) => {
+        // Like the "min-distance" task, but for clamping to the max
+        // distance. The actual distance is again arbitrary as long as it is
+        // greater than maxDistance.
+        await runTest(should, {
+          distance: 20000,
+          distanceModel: 'linear',
+        });
+        await runTest(should, {
+          distance: 21000,
+          distanceModel: 'exponential',
+        });
+        await runTest(should, {
+          distance: 23000,
+          distanceModel: 'inverse',
+        });
+        await runTest(should, {
+          distance: 5000,
+          distanceModel: 'linear',
+          maxDistance: 1000,
+          refDistance: 10,
+        });
+        await runTest(should, {
+          distance: 5000,
+          distanceModel: 'exponential',
+          maxDistance: 1000,
+          refDistance: 10,
+        });
+        await runTest(should, {
+          distance: 5000,
+          distanceModel: 'inverse',
+          maxDistance: 1000,
+          refDistance: 10,
+        });
+        task.done();
+      });
+
+      function runTest(should, options) {
+        let context = new OfflineAudioContext(2, renderFrames, sampleRate);
+        let src = new OscillatorNode(context, {
+          type: 'sawtooth',
+          frequency: 20 * 440,
+        });
+
+        // Set panner options.  Use a non-default rolloffFactor so that the
+        // various distance models look distinctly different.
+        let pannerOptions = {};
+        Object.assign(pannerOptions, options, {rolloffFactor: 0.5});
+
+        let pannerRef = new PannerNode(context, pannerOptions);
+        let pannerTest = new PannerNode(context, pannerOptions);
+
+        // Split the panner output so we can grab just one of the output
+        // channels.
+        let splitRef = new ChannelSplitterNode(context, {numberOfOutputs: 2});
+        let splitTest = new ChannelSplitterNode(context, {numberOfOutputs: 2});
+
+        // Merge the panner outputs back into one stereo stream for the
+        // destination.
+        let merger = new ChannelMergerNode(context, {numberOfInputs: 2});
+
+        src.connect(pannerTest).connect(splitTest).connect(merger, 0, 0);
+        src.connect(pannerRef).connect(splitRef).connect(merger, 0, 1);
+
+        merger.connect(context.destination);
+
+        // Move the panner some distance away. Arbitrarily select the x
+        // direction.  For the reference panner, manually clamp the distance.
+        // All models clamp the distance to a minimum of refDistance.  Only the
+        // linear model also clamps to a maximum of maxDistance.
+        let xRef = Math.max(options.distance, pannerRef.refDistance);
+
+        if (pannerRef.distanceModel === 'linear') {
+          xRef = Math.min(xRef, pannerRef.maxDistance);
+        }
+
+        let xTest = options.distance;
+
+        pannerRef.positionZ.setValueAtTime(xRef, 0);
+        pannerTest.positionZ.setValueAtTime(xTest, 0);
+
+        src.start();
+
+        return context.startRendering().then(function(resultBuffer) {
+          let actual = resultBuffer.getChannelData(0);
+          let expected = resultBuffer.getChannelData(1);
+
+          should(
+              xTest < pannerRef.refDistance || xTest > pannerRef.maxDistance,
+              'Model: ' + options.distanceModel + ': Distance (' + xTest +
+                  ') is outside the range [' + pannerRef.refDistance + ', ' +
+                  pannerRef.maxDistance + ']')
+              .beEqualTo(true);
+          should(actual, 'Test panner output ' + JSON.stringify(options))
+              .beEqualToArray(expected);
+        });
+      }
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-equalpower-stereo.html b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-equalpower-stereo.html
new file mode 100644
index 0000000000..2a0225b3f6
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-equalpower-stereo.html
@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      panner-equalpower-stereo.html
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="../../resources/audit-util.js"></script>
+    <script src="../../resources/audit.js"></script>
+    <script src="../../resources/panner-model-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      // To test the panner, we create a number of panner nodes
+      // equally spaced on a semicircle at unit distance.  The
+      // semicircle covers the azimuth range from -90 to 90 deg,
+      // covering full left to full right.  Each source is an impulse
+      // turning at a different time and we check that the rendered
+      // impulse has the expected gain.
+      audit.define(
+          {
+            label: 'test',
+            description:
+                'Equal-power panner model of AudioPannerNode with stereo source'
+          },
+          (task, should) => {
+            context = new OfflineAudioContext(
+                2, sampleRate * renderLengthSeconds, sampleRate);
+
+            createTestAndRun(
+                context, should, nodesToCreate, 2,
+                function(panner, x, y, z) {
+                  panner.setPosition(x, y, z);
+                })
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-equalpower.html b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-equalpower.html
new file mode 100644
index 0000000000..3ff21b651f
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-equalpower.html
@@ -0,0 +1,139 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      panner-equalpower.html
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="../../resources/audit-util.js"></script>
+    <script src="../../resources/audit.js"></script>
+    <script src="../../resources/panner-model-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      // To test the panner, we create a number of panner nodes
+      // equally spaced on a semicircle at unit distance.  The
+      // semicircle covers the azimuth range from -90 to 90 deg,
+      // covering full left to full right.  Each source is an impulse
+      // turning at a different time and we check that the rendered
+      // impulse has the expected gain.
+      audit.define(
+          {
+            label: 'test',
+            description: 'Equal-power panner model of AudioPannerNode',
+          },
+          (task, should) => {
+            // Create offline audio context.
+            context = new OfflineAudioContext(
+                2, sampleRate * renderLengthSeconds, sampleRate);
+
+            createTestAndRun(
+                context, should, nodesToCreate, 1,
+                function(panner, x, y, z) {
+                  panner.setPosition(x, y, z);
+                })
+                .then(() => task.done());
+            ;
+          });
+
+      // Test that a mono source plays out on both the left and right channels
+      // when the source and listener positions are the same.
+      audit.define(
+          {
+            label: 'mono source=listener',
+            description: 'Source and listener at the same position'
+          },
+          (task, should) => {
+            // Must be stereo to verify output and only need a short duration
+            let context =
+                new OfflineAudioContext(2, 0.25 * sampleRate, sampleRate);
+
+            // Arbitrary position for source and listener.  Just so we don't use
+            // defaults positions.
+            let x = 1;
+            let y = 2;
+            let z = 3;
+
+            context.listener.setPosition(x, y, z);
+
+            let src = new OscillatorNode(context);
+            let panner = new PannerNode(context, {
+              panningModel: 'equalpower',
+              positionX: x,
+              positionY: y,
+              positionZ: z
+            });
+
+            src.connect(panner).connect(context.destination);
+
+            src.start();
+
+            context.startRendering()
+                .then(renderedBuffer => {
+                  // Verify that both channels have the same data because they
+                  // should when the source and listener are at the same
+                  // position
+                  let c0 = renderedBuffer.getChannelData(0);
+                  let c1 = renderedBuffer.getChannelData(1);
+                  should(c0, 'Mono: Left and right channels').beEqualToArray(c1);
+                })
+                .then(() => task.done());
+          });
+
+      // Test that a stereo source plays out on both the left and right channels
+      // when the source and listener positions are the same.
+      audit.define(
+          {
+            label: 'stereo source=listener',
+            description: 'Source and listener at the same position'
+          },
+          (task, should) => {
+            // Must be stereo to verify output and only need a short duration.
+            let context =
+                new OfflineAudioContext(2, 0.25 * sampleRate, sampleRate);
+
+            // Arbitrary position for source and listener.  Just so we don't use
+            // defaults positions.
+            let x = 1;
+            let y = 2;
+            let z = 3;
+
+            context.listener.setPosition(x, y, z);
+
+            let src = new OscillatorNode(context);
+            let merger = new ChannelMergerNode(context, {numberOfInputs: 2});
+            let panner = new PannerNode(context, {
+              panningModel: 'equalpower',
+              positionX: x,
+              positionY: y,
+              positionZ: z
+            });
+
+            // Make the oscillator a stereo signal (with identical signals on
+            // each channel).
+            src.connect(merger, 0, 0);
+            src.connect(merger, 0, 1);
+
+            merger.connect(panner).connect(context.destination);
+
+            src.start();
+
+            context.startRendering()
+                .then(renderedBuffer => {
+                  // Verify that both channels have the same data because they
+                  // should when the source and listener are at the same
+                  // position.
+                  let c0 = renderedBuffer.getChannelData(0);
+                  let c1 = renderedBuffer.getChannelData(1);
+                  should(c0, 'Stereo: Left and right channels').beEqualToArray(c1);
+                })
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-rolloff-clamping.html b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-rolloff-clamping.html
new file mode 100644
index 0000000000..387f873010
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/panner-rolloff-clamping.html
@@ -0,0 +1,98 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Clamping of PannerNode rolloffFactor
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="../../resources/audit-util.js"></script>
+    <script src="../../resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      // Fairly arbitrary sample rate and render frames.
+      let sampleRate = 16000;
+      let renderFrames = 2048;
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {
+            label: 'linear-clamp-high',
+            description: 'rolloffFactor clamping for linear distance model'
+          },
+          (task, should) => {
+            runTest(should, {
+              distanceModel: 'linear',
+              // Fairly arbitrary value outside the nominal range
+              rolloffFactor: 2,
+              clampedRolloff: 1
+            }).then(() => task.done());
+          });
+
+      // Test clamping of the rolloffFactor.  The test is done by comparing the
+      // output of a panner with the rolloffFactor set outside the nominal range
+      // against the output of a panner with the rolloffFactor clamped to the
+      // nominal range.  The outputs should be the same.
+      //
+      // The |options| dictionary should contain the members
+      //   distanceModel  - The distance model to use for the panners
+      //   rolloffFactor  - The desired rolloffFactor.  Should be outside the
+      //                    nominal range of the distance model.
+      //   clampedRolloff - The rolloffFactor (above) clamped to the nominal
+      //                    range for the given distance model.
+      function runTest(should, options) {
+        // Offline context with two channels.  The first channel is the panner
+        // node under test.  The second channel is the reference panner node.
+        let context = new OfflineAudioContext(2, renderFrames, sampleRate);
+
+        // The source for the panner nodes.  This is fairly arbitrary.
+        let src = new OscillatorNode(context, {type: 'sawtooth'});
+
+        // Create the test panner with the specified rolloff factor.  The
+        // position is fairly arbitrary, but something that is not the default
+        // is good to show the distance model had some effect.
+        let pannerTest = new PannerNode(context, {
+          rolloffFactor: options.rolloffFactor,
+          distanceModel: options.distanceModel,
+          positionX: 5000
+        });
+
+        // Create the reference panner with the rolloff factor clamped to the
+        // appropriate limit.
+        let pannerRef = new PannerNode(context, {
+          rolloffFactor: options.clampedRolloff,
+          distanceModel: options.distanceModel,
+          positionX: 5000
+        });
+
+
+        // Connect the source to the panners to the destination appropriately.
+        let merger = new ChannelMergerNode(context, {numberOfInputs: 2});
+
+
+        src.connect(pannerTest).connect(merger, 0, 0);
+        src.connect(pannerRef).connect(merger, 0, 1);
+
+        merger.connect(context.destination);
+
+        src.start();
+
+        return context.startRendering().then(function(resultBuffer) {
+          // The two channels should be the same due to the clamping.  Verify
+          // that they are the same.
+          let actual = resultBuffer.getChannelData(0);
+          let expected = resultBuffer.getChannelData(1);
+
+          let message = 'Panner distanceModel: "' + options.distanceModel +
+              '", rolloffFactor: ' + options.rolloffFactor;
+
+          should(actual, message).beEqualToArray(expected);
+        });
+      }
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/pannernode-basic.window.js b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/pannernode-basic.window.js
new file mode 100644
index 0000000000..298fce0f20
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/pannernode-basic.window.js
@@ -0,0 +1,71 @@
+test((t) => {
+  const context = new AudioContext();
+  const source = new ConstantSourceNode(context);
+  const panner = new PannerNode(context);
+  source.connect(panner).connect(context.destination);
+
+  // Basic parameters
+  assert_equals(panner.numberOfInputs,1);
+  assert_equals(panner.numberOfOutputs,1);
+  assert_equals(panner.refDistance, 1);
+  panner.refDistance = 270.5;
+  assert_equals(panner.refDistance, 270.5);
+  assert_equals(panner.maxDistance, 10000);
+  panner.maxDistance = 100.5;
+  assert_equals(panner.maxDistance, 100.5);
+  assert_equals(panner.rolloffFactor, 1);
+  panner.rolloffFactor = 0.75;
+  assert_equals(panner.rolloffFactor, 0.75);
+  assert_equals(panner.coneInnerAngle, 360);
+  panner.coneInnerAngle = 240.5;
+  assert_equals(panner.coneInnerAngle, 240.5);
+  assert_equals(panner.coneOuterAngle, 360);
+  panner.coneOuterAngle = 166.5;
+  assert_equals(panner.coneOuterAngle, 166.5);
+  assert_equals(panner.coneOuterGain, 0);
+  panner.coneOuterGain = 0.25;
+  assert_equals(panner.coneOuterGain, 0.25);
+  assert_equals(panner.panningModel, 'equalpower');
+  assert_equals(panner.distanceModel, 'inverse');
+
+  // Position/orientation AudioParams
+  assert_equals(panner.positionX.value, 0);
+  assert_equals(panner.positionY.value, 0);
+  assert_equals(panner.positionZ.value, 0);
+  assert_equals(panner.orientationX.value, 1);
+  assert_equals(panner.orientationY.value, 0);
+  assert_equals(panner.orientationZ.value, 0);
+
+  // AudioListener
+  assert_equals(context.listener.positionX.value, 0);
+  assert_equals(context.listener.positionY.value, 0);
+  assert_equals(context.listener.positionZ.value, 0);
+  assert_equals(context.listener.forwardX.value, 0);
+  assert_equals(context.listener.forwardY.value, 0);
+  assert_equals(context.listener.forwardZ.value, -1);
+  assert_equals(context.listener.upX.value, 0);
+  assert_equals(context.listener.upY.value, 1);
+  assert_equals(context.listener.upZ.value, 0);
+
+  panner.panningModel = 'equalpower';
+  assert_equals(panner.panningModel, 'equalpower');
+  panner.panningModel = 'HRTF';
+  assert_equals(panner.panningModel, 'HRTF');
+  panner.panningModel = 'invalid';
+  assert_equals(panner.panningModel, 'HRTF');
+
+  // Check that numerical values are no longer supported.  We shouldn't
+  // throw and the value shouldn't be changed.
+  panner.panningModel = 1;
+  assert_equals(panner.panningModel, 'HRTF');
+
+  panner.distanceModel = 'linear';
+  assert_equals(panner.distanceModel, 'linear');
+  panner.distanceModel = 'inverse';
+  assert_equals(panner.distanceModel, 'inverse');
+  panner.distanceModel = 'exponential';
+  assert_equals(panner.distanceModel, 'exponential');
+
+  panner.distanceModel = 'invalid';
+  assert_equals(panner.distanceModel, 'exponential');
+}, 'Test the PannerNode interface');
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/pannernode-setposition-throws.html b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/pannernode-setposition-throws.html
new file mode 100644
index 0000000000..2053411943
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/pannernode-setposition-throws.html
@@ -0,0 +1,37 @@
+<!doctype html>
+<meta charset=utf-8>
+<title>Test PannerNode.setPosition() throws with parameter out of range of float</title>
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script>
+// https://webaudio.github.io/web-audio-api/#dom-pannernode-setposition
+// setPosition(x, y, z) "is equivalent to setting positionX.value,
+// positionY.value, and positionZ.value directly with the given x, y, and z
+// values, respectively."  setPosition() parameters are double, but the
+// AudioParam value setter has a float parameter, so out of range values
+// throw.
+const FLT_MAX = 3.40282e+38;
+let panner;
+setup(() => {
+  const ctx = new OfflineAudioContext({length: 1, sampleRate: 24000});
+  panner = ctx.createPanner();
+});
+test(() => {
+  assert_throws_js(TypeError, () => panner.setPosition(2 * FLT_MAX, 0, 0));
+}, "setPosition x");
+test(() => {
+  assert_throws_js(TypeError, () => panner.setPosition(0, -2 * FLT_MAX, 0));
+}, "setPosition y");
+test(() => {
+  assert_throws_js(TypeError, () => panner.setPosition(0, 0, 2 * FLT_MAX));
+}, "setPosition z");
+test(() => {
+  assert_throws_js(TypeError, () => panner.setOrientation(-2 * FLT_MAX, 0, 0));
+}, "setOrientation x");
+test(() => {
+  assert_throws_js(TypeError, () => panner.setOrientation(0, 2 * FLT_MAX, 0));
+}, "setOrientation y");
+test(() => {
+  assert_throws_js(TypeError, () => panner.setOrientation(0, 0, -2 * FLT_MAX));
+}, "setOrientation z");
+</script>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/test-pannernode-automation.html b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/test-pannernode-automation.html
new file mode 100644
index 0000000000..ce474b10b5
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-pannernode-interface/test-pannernode-automation.html
@@ -0,0 +1,36 @@
+<!doctype html>
+<meta charset=utf-8>
+<title></title>
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script>
+
+// This value is purposefuly not aligned on a 128-block boundary so that we test
+// that the PannerNode position audioparam is a-rate.
+const POSITION_CHANGE_FRAME = 1111;
+
+promise_test(function(t) {
+  var ac = new OfflineAudioContext(2, 2048, 44100);
+  var panner = ac.createPanner();
+  panner.positionX.value = -1;
+  panner.positionY.value = -1;
+  panner.positionZ.value = 1;
+  panner.positionX.setValueAtTime(1, POSITION_CHANGE_FRAME/ac.sampleRate);
+  var osc = ac.createOscillator();
+  osc.connect(panner);
+  panner.connect(ac.destination);
+  osc.start()
+  return ac.startRendering().then(function(buffer) {
+    var left = buffer.getChannelData(0);
+    var right = buffer.getChannelData(1);
+    for (var i = 0; i < 2048; ++i) {
+      if (i < POSITION_CHANGE_FRAME) {
+        assert_true(Math.abs(left[i]) >= Math.abs(right[i]), "index " + i + " should be on the left");
+      } else {
+        assert_true(Math.abs(left[i]) < Math.abs(right[i]), "index " + i + " should be on the right");
+      }
+    }
+  });
+}, "PannerNode AudioParam automation works properly");
+
+</script>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-periodicwave-interface/createPeriodicWaveInfiniteValuesThrows.html b/testing/web-platform/tests/webaudio/the-audio-api/the-periodicwave-interface/createPeriodicWaveInfiniteValuesThrows.html
new file mode 100644
index 0000000000..928f45bd8f
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-periodicwave-interface/createPeriodicWaveInfiniteValuesThrows.html
@@ -0,0 +1,22 @@
+<!doctype html>
+<meta charset=utf-8>
+<title>Test AudioContext.createPeriodicWave when inputs contain Infinite values</title>
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script>
+let ctx;
+setup(() => {
+  ctx = new OfflineAudioContext({length: 1, sampleRate: 24000});
+});
+test(() => {
+  const real = new Float32Array([0, Infinity]);
+  const imag = new Float32Array([0, 1]);
+  assert_throws_js(TypeError, () => ctx.createPeriodicWave(real, imag));
+}, "createPeriodicWave with Infinity real values should throw");
+
+test(() => {
+  const real = new Float32Array([0, 1]);
+  const imag = new Float32Array([1, Infinity]);
+  assert_throws_js(TypeError, () => ctx.createPeriodicWave(real, imag));
+}, "createPeriodicWave with Infinity imag values should throw");
+</script>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-periodicwave-interface/periodicWave.html b/testing/web-platform/tests/webaudio/the-audio-api/the-periodicwave-interface/periodicWave.html
new file mode 100644
index 0000000000..fe42f8ad50
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-periodicwave-interface/periodicWave.html
@@ -0,0 +1,130 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Constructor: PeriodicWave
+    </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">
+      // real and imag are used in separate PeriodicWaves to make their peak values
+      // easy to determine.
+      const realMax = 99;
+      var real = new Float32Array(realMax + 1);
+      real[1] = 2.0; // fundamental
+      real[realMax] = 3.0;
+      const realPeak = real[1] + real[realMax];
+      const realFundamental = 19.0;
+      var imag = new Float32Array(4);
+      imag[0] = 6.0; // should be ignored.
+      imag[3] = 0.5;
+      const imagPeak = imag[3];
+      const imagFundamental = 551.0;
+
+      const testLength = 8192;
+      let context = new AudioContext();
+
+      let audit = Audit.createTaskRunner();
+
+      // Create with the factory method
+
+      audit.define('create with factory method', (task, should) => {
+        should(() => {
+          context.createPeriodicWave(new Float32Array(testLength), new Float32Array(testLength));
+        }, 'context.createPeriodicWave(new Float32Array(' + testLength + '), ' +
+        'new Float32Array(' + testLength + '))').notThrow();
+        task.done();
+      });
+
+      audit.define('different length with factory method', (task, should) => {
+        should(() => {
+          context.createPeriodicWave(new Float32Array(512), new Float32Array(4));
+        }, 'context.createPeriodicWave(new Float32Array(512), ' +
+        'new Float32Array(4))').throw(DOMException, "IndexSizeError");
+        task.done();
+      });
+
+      audit.define('too small with factory method', (task, should) => {
+        should(() => {
+          context.createPeriodicWave(new Float32Array(1), new Float32Array(1));
+        }, 'context.createPeriodicWave(new Float32Array(1), ' +
+        'new Float32Array(1))').throw(DOMException, "IndexSizeError");
+        task.done();
+      });
+
+      // Create with the constructor
+
+      audit.define('create with constructor', (task, should) => {
+        should(() => {
+          new PeriodicWave(context, { real: new Float32Array(testLength), imag: new Float32Array(testLength) });
+        }, 'new PeriodicWave(context, { real : new Float32Array(' + testLength + '), ' +
+        'imag : new Float32Array(' + testLength + ') })').notThrow();
+        task.done();
+      });
+
+      audit.define('different length with constructor', (task, should) => {
+        should(() => {
+          new PeriodicWave(context, { real: new Float32Array(testLength), imag: new Float32Array(4) });
+        }, 'new PeriodicWave(context, { real : new Float32Array(' + testLength + '), ' +
+        'imag : new Float32Array(4) })').throw(DOMException, "IndexSizeError");
+        task.done();
+      });
+
+      audit.define('too small with constructor', (task, should) => {
+        should(() => {
+          new PeriodicWave(context, { real: new Float32Array(1), imag: new Float32Array(1) });
+        }, 'new PeriodicWave(context, { real : new Float32Array(1), ' +
+        'imag : new Float32Array(1) })').throw(DOMException, "IndexSizeError");
+        task.done();
+      });
+
+      audit.define('output test', (task, should) => {
+        let context = new OfflineAudioContext(2, testLength, 44100);
+        // Create the expected output buffer
+        let expectations = context.createBuffer(2, testLength, context.sampleRate);
+        for (var i = 0; i < expectations.length; ++i) {
+
+          expectations.getChannelData(0)[i] = 1.0 / realPeak *
+            (real[1] * Math.cos(2 * Math.PI * realFundamental * i /
+                                context.sampleRate) +
+             real[realMax] * Math.cos(2 * Math.PI * realMax * realFundamental * i /
+                                context.sampleRate));
+
+          expectations.getChannelData(1)[i] = 1.0 / imagPeak *
+             imag[3] * Math.sin(2 * Math.PI * 3 * imagFundamental * i /
+                                context.sampleRate);
+        }
+
+        // Create the real output buffer
+        let merger = context.createChannelMerger();
+
+        let osc1 = context.createOscillator();
+        let osc2 = context.createOscillator();
+
+        osc1.setPeriodicWave(context.createPeriodicWave(
+                                real, new Float32Array(real.length)));
+        osc2.setPeriodicWave(context.createPeriodicWave(
+                                new Float32Array(imag.length), imag));
+        osc1.frequency.value = realFundamental;
+        osc2.frequency.value = imagFundamental;
+
+        osc1.start();
+        osc2.start();
+
+        osc1.connect(merger, 0, 0);
+        osc2.connect(merger, 0, 1);
+
+        context.startRendering().then(reality => {
+          should(reality, 'rendering PeriodicWave').beEqualToArray(expectations);
+          task.done();
+        });
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-scriptprocessornode-interface/simple-input-output.html b/testing/web-platform/tests/webaudio/the-audio-api/the-scriptprocessornode-interface/simple-input-output.html
new file mode 100644
index 0000000000..7fd20e67a7
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-scriptprocessornode-interface/simple-input-output.html
@@ -0,0 +1,98 @@
+<!doctype html>
+<html>
+  <head>
+    <title>Test ScriptProcessorNode</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>
+      // Arbitrary sample rate
+      const sampleRate = 48000;
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {
+            label: 'test',
+            description: 'ScriptProcessor with stopped input source'
+          },
+          (task, should) => {
+            // Two channels for testing.  Channel 0 is the output of the
+            // scriptProcessor.  Channel 1 is the oscillator so we can compare
+            // the outputs.
+            let context = new OfflineAudioContext({
+              numberOfChannels: 2,
+              length: sampleRate,
+              sampleRate: sampleRate
+            });
+
+            let merger = new ChannelMergerNode(
+                context, {numberOfChannels: context.destination.channelCount});
+            merger.connect(context.destination);
+
+            let src = new OscillatorNode(context);
+
+            // Arbitrary buffer size for the ScriptProcessorNode.  Don't use 0;
+            // we need to know the actual size to know the latency of the node
+            // (easily).
+            const spnSize = 512;
+            let spn = context.createScriptProcessor(spnSize, 1, 1);
+
+            // Arrange for the ScriptProcessor to add |offset| to the input.
+            const offset = 1;
+            spn.onaudioprocess = (event) => {
+              let input = event.inputBuffer.getChannelData(0);
+              let output = event.outputBuffer.getChannelData(0);
+              for (let k = 0; k < output.length; ++k) {
+                output[k] = input[k] + offset;
+              }
+            };
+
+            src.connect(spn).connect(merger, 0, 0);
+            src.connect(merger, 0, 1);
+
+            // Start and stop the source.  The stop time is fairly arbitrary,
+            // but use a render quantum boundary for simplicity.
+            const stopFrame = RENDER_QUANTUM_FRAMES;
+            src.start(0);
+            src.stop(stopFrame / context.sampleRate);
+
+            context.startRendering()
+                .then(buffer => {
+                  let ch0 = buffer.getChannelData(0);
+                  let ch1 = buffer.getChannelData(1);
+
+                  let shifted = ch1.slice(0, stopFrame).map(x => x + offset);
+
+                  // SPN has a basic latency of 2*|spnSize| fraems, so the
+                  // beginning is silent.
+                  should(
+                      ch0.slice(0, 2 * spnSize - 1),
+                      `ScriptProcessor output[0:${2 * spnSize - 1}]`)
+                      .beConstantValueOf(0);
+
+                  // For the middle section (after adding latency), the output
+                  // should be the source shifted by |offset|.
+                  should(
+                      ch0.slice(2 * spnSize, 2 * spnSize + stopFrame),
+                      `ScriptProcessor output[${2 * spnSize}:${
+                          2 * spnSize + stopFrame - 1}]`)
+                      .beCloseToArray(shifted, {absoluteThreshold: 0});
+
+                  // Output should be constant after the source has stopped.
+                  // Include the latency introduced by the node.
+                  should(
+                      ch0.slice(2 * spnSize + stopFrame),
+                      `ScriptProcessor output[${2 * spnSize + stopFrame}:]`)
+                      .beConstantValueOf(offset);
+                })
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-stereopanner-interface/ctor-stereopanner.html b/testing/web-platform/tests/webaudio/the-audio-api/the-stereopanner-interface/ctor-stereopanner.html
new file mode 100644
index 0000000000..9409f1ffce
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-stereopanner-interface/ctor-stereopanner.html
@@ -0,0 +1,131 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Constructor: StereoPanner
+    </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, 'StereoPannerNode', context);
+        task.done();
+      });
+
+      audit.define('default constructor', (task, should) => {
+        let prefix = 'node0';
+        let node = testDefaultConstructor(should, 'StereoPannerNode', context, {
+          prefix: prefix,
+          numberOfInputs: 1,
+          numberOfOutputs: 1,
+          channelCount: 2,
+          channelCountMode: 'clamped-max',
+          channelInterpretation: 'speakers'
+        });
+
+        testDefaultAttributes(should, node, prefix, [{name: 'pan', value: 0}]);
+
+        task.done();
+      });
+
+      audit.define('test AudioNodeOptions', (task, should) => {
+        // Can't use testAudioNodeOptions because the constraints for this node
+        // are not supported there.
+        let node;
+
+        // An array of tests.
+        [{
+          // Test that we can set the channel count to 1 or 2 and that other
+          // channel counts throw an error.
+          attribute: 'channelCount',
+          tests: [
+            {value: 1}, {value: 2}, {value: 0, error: 'NotSupportedError'},
+            {value: 3, error: 'NotSupportedError'},
+            {value: 99, error: 'NotSupportedError'}
+          ]
+        },
+         {
+           // Test channelCountMode.  A mode of "max" is illegal, but others are
+           // ok.  But also throw an error of unknown values.
+           attribute: 'channelCountMode',
+           tests: [
+             {value: 'clamped-max'}, {value: 'explicit'},
+             {value: 'max', error: 'NotSupportedError'},
+             {value: 'foobar', error: TypeError}
+           ]
+         },
+         {
+           // Test channelInterpretation can be set for valid values and an
+           // error is thrown for others.
+           attribute: 'channelInterpretation',
+           tests: [
+             {value: 'speakers'}, {value: 'discrete'},
+             {value: 'foobar', error: TypeError}
+           ]
+         }].forEach(entry => {
+          entry.tests.forEach(testItem => {
+            let options = {};
+            options[entry.attribute] = testItem.value;
+
+            const testFunction = () => {
+              node = new StereoPannerNode(context, options);
+            };
+            const testDescription =
+                `new StereoPannerNode(c, ${JSON.stringify(options)})`;
+
+            if (testItem.error) {
+              testItem.error === TypeError
+              ? should(testFunction, testDescription).throw(TypeError)
+              : should(testFunction, testDescription)
+                  .throw(DOMException, 'NotSupportedError');
+            } else {
+              should(testFunction, testDescription).notThrow();
+              should(node[entry.attribute], `node.${entry.attribute}`)
+                  .beEqualTo(options[entry.attribute]);
+            }
+          });
+        });
+
+        task.done();
+      });
+
+      audit.define('constructor with options', (task, should) => {
+        let node;
+        let options = {
+          pan: 0.75,
+        };
+
+        should(
+            () => {
+              node = new StereoPannerNode(context, options);
+            },
+            'node1 = new StereoPannerNode(, ' + JSON.stringify(options) + ')')
+            .notThrow();
+        should(
+            node instanceof StereoPannerNode,
+            'node1 instanceof StereoPannerNode')
+            .beEqualTo(true);
+
+        should(node.pan.value, 'node1.pan.value').beEqualTo(options.pan);
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-stereopanner-interface/no-dezippering.html b/testing/web-platform/tests/webaudio/the-audio-api/the-stereopanner-interface/no-dezippering.html
new file mode 100644
index 0000000000..355db8b9dc
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-stereopanner-interface/no-dezippering.html
@@ -0,0 +1,261 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test StereoPannerNode Has No Dezippering
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="../../resources/audit-util.js"></script>
+    <script src="../../resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      // Arbitrary sample rate except that it should be a power of two to
+      // eliminate any round-off in computing frame boundaries.
+      let sampleRate = 16384;
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {
+            label: 'test mono input',
+            description: 'Test StereoPanner with mono input has no dezippering'
+          },
+          (task, should) => {
+            let context = new OfflineAudioContext(2, sampleRate, sampleRate);
+            let src = new ConstantSourceNode(context, {offset: 1});
+            let p = new StereoPannerNode(context, {pan: -1});
+
+            src.connect(p).connect(context.destination);
+            src.start();
+
+            // Frame at which to change pan value.
+            let panFrame = 256;
+            context.suspend(panFrame / context.sampleRate)
+                .then(() => p.pan.value = 1)
+                .then(() => context.resume());
+
+            context.startRendering()
+                .then(renderedBuffer => {
+                  let c0 = renderedBuffer.getChannelData(0);
+                  let c1 = renderedBuffer.getChannelData(1);
+
+                  // The first part should be full left.
+                  should(
+                      c0.slice(0, panFrame), 'Mono: Left channel, pan = -1: ')
+                      .beConstantValueOf(1);
+                  should(
+                      c1.slice(0, panFrame), 'Mono: Right channel, pan = -1:')
+                      .beConstantValueOf(0);
+
+                  // The second part should be full right, but due to roundoff,
+                  // the left channel won't be exactly zero.  Compare the left
+                  // channel against zero with a threshold instead.
+                  let tail = c0.slice(panFrame);
+                  let zero = new Float32Array(tail.length);
+
+                  should(c0.slice(panFrame), 'Mono: Left channel, pan = 1: ')
+                      .beCloseToArray(zero, {absoluteThreshold: 6.1233e-17});
+                  should(c1.slice(panFrame), 'Mono: Right channel, pan = 1:')
+                      .beConstantValueOf(1);
+                })
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: 'test stereo input',
+            description:
+                'Test StereoPanner with stereo input has no dezippering'
+          },
+          (task, should) => {
+            let context = new OfflineAudioContext(2, sampleRate, sampleRate);
+
+            // Create stereo source from two constant source nodes.
+            let s0 = new ConstantSourceNode(context, {offset: 1});
+            let s1 = new ConstantSourceNode(context, {offset: 2});
+            let merger = new ChannelMergerNode(context, {numberOfInputs: 2});
+
+            s0.connect(merger, 0, 0);
+            s1.connect(merger, 0, 1);
+
+            let p = new StereoPannerNode(context, {pan: -1});
+
+            merger.connect(p).connect(context.destination);
+            s0.start();
+            s1.start();
+
+            // Frame at which to change pan value.
+            let panFrame = 256;
+            context.suspend(panFrame / context.sampleRate)
+                .then(() => p.pan.value = 1)
+                .then(() => context.resume());
+
+            context.startRendering()
+                .then(renderedBuffer => {
+                  let c0 = renderedBuffer.getChannelData(0);
+                  let c1 = renderedBuffer.getChannelData(1);
+
+                  // The first part should be full left.
+                  should(
+                      c0.slice(0, panFrame), 'Stereo: Left channel, pan = -1: ')
+                      .beConstantValueOf(3);
+                  should(
+                      c1.slice(0, panFrame), 'Stereo: Right channel, pan = -1:')
+                      .beConstantValueOf(0);
+
+                  // The second part should be full right, but due to roundoff,
+                  // the left channel won't be exactly zero.  Compare the left
+                  // channel against zero with a threshold instead.
+                  let tail = c0.slice(panFrame);
+                  let zero = new Float32Array(tail.length);
+
+                  should(c0.slice(panFrame), 'Stereo: Left channel, pan = 1: ')
+                      .beCloseToArray(zero, {absoluteThreshold: 6.1233e-17});
+                  should(c1.slice(panFrame), 'Stereo: Right channel, pan = 1:')
+                      .beConstantValueOf(3);
+                })
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: 'test mono input setValue',
+            description: 'Test StereoPanner with mono input value setter ' +
+                'vs setValueAtTime'
+          },
+          (task, should) => {
+            let context = new OfflineAudioContext(4, sampleRate, sampleRate);
+
+            let src = new OscillatorNode(context);
+
+            src.start();
+            testWithSetValue(context, src, should, {
+              prefix: 'Mono'
+            }).then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: 'test stereo input setValue',
+            description: 'Test StereoPanner with mono input value setter ' +
+                ' vs setValueAtTime'
+          },
+          (task, should) => {
+            let context = new OfflineAudioContext(4, sampleRate, sampleRate);
+
+            let src0 = new OscillatorNode(context, {frequency: 800});
+            let src1 = new OscillatorNode(context, {frequency: 250});
+            let merger = new ChannelMergerNode(context, {numberOfChannels: 2});
+
+            src0.connect(merger, 0, 0);
+            src1.connect(merger, 0, 1);
+
+            src0.start();
+            src1.start();
+
+            testWithSetValue(context, merger, should, {
+              prefix: 'Stereo'
+            }).then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: 'test mono input automation',
+            description: 'Test StereoPanner with mono input and automation'
+          },
+          (task, should) => {
+            let context = new OfflineAudioContext(4, sampleRate, sampleRate);
+
+            let src0 = new OscillatorNode(context, {frequency: 800});
+            let src1 = new OscillatorNode(context, {frequency: 250});
+            let merger = new ChannelMergerNode(context, {numberOfChannels: 2});
+
+            src0.connect(merger, 0, 0);
+            src1.connect(merger, 0, 1);
+
+            src0.start();
+            src1.start();
+
+            let mod = new OscillatorNode(context, {frequency: 100});
+            mod.start();
+
+            testWithSetValue(context, merger, should, {
+              prefix: 'Modulated Stereo',
+              modulator: (testNode, refNode) => {
+                mod.connect(testNode.pan);
+                mod.connect(refNode.pan);
+              }
+            }).then(() => task.done());
+          });
+
+
+      function testWithSetValue(context, src, should, options) {
+        let merger = new ChannelMergerNode(
+            context, {numberOfInputs: context.destination.channelCount});
+        merger.connect(context.destination);
+
+        let pannerRef = new StereoPannerNode(context, {pan: -0.3});
+        let pannerTest =
+            new StereoPannerNode(context, {pan: pannerRef.pan.value});
+
+        let refSplitter =
+            new ChannelSplitterNode(context, {numberOfOutputs: 2});
+        let testSplitter =
+            new ChannelSplitterNode(context, {numberOfOutputs: 2});
+
+        pannerRef.connect(refSplitter);
+        pannerTest.connect(testSplitter);
+
+        testSplitter.connect(merger, 0, 0);
+        testSplitter.connect(merger, 1, 1);
+        refSplitter.connect(merger, 0, 2);
+        refSplitter.connect(merger, 1, 3);
+
+        src.connect(pannerRef);
+        src.connect(pannerTest);
+
+        let changeTime = 3 * RENDER_QUANTUM_FRAMES / context.sampleRate;
+        // An arbitrary position, different from the default pan value.
+        let newPanPosition = .71;
+
+        pannerRef.pan.setValueAtTime(newPanPosition, changeTime);
+        context.suspend(changeTime)
+            .then(() => pannerTest.pan.value = newPanPosition)
+            .then(() => context.resume());
+
+        if (options.modulator) {
+          options.modulator(pannerTest, pannerRef);
+        }
+        return context.startRendering().then(renderedBuffer => {
+          let actual = new Array(2);
+          let expected = new Array(2);
+
+          actual[0] = renderedBuffer.getChannelData(0);
+          actual[1] = renderedBuffer.getChannelData(1);
+          expected[0] = renderedBuffer.getChannelData(2);
+          expected[1] = renderedBuffer.getChannelData(3);
+
+          let label = ['Left', 'Right'];
+
+          for (let k = 0; k < 2; ++k) {
+            let match =
+                should(
+                    actual[k],
+                    options.prefix + ' ' + label[k] + ' .value setter output')
+                    .beCloseToArray(expected[k], {absoluteThreshold: 1.192094e-7});
+            should(
+                match,
+                options.prefix + ' ' + label[k] +
+                    ' .value setter output matches setValueAtTime output')
+                .beTrue();
+          }
+
+        });
+      }
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-stereopanner-interface/stereopannernode-basic.html b/testing/web-platform/tests/webaudio/the-audio-api/the-stereopanner-interface/stereopannernode-basic.html
new file mode 100644
index 0000000000..48bacb08c6
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-stereopanner-interface/stereopannernode-basic.html
@@ -0,0 +1,54 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      stereopannernode-basic.html
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="../../resources/audit-util.js"></script>
+    <script src="../../resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {
+            label: 'test',
+            description:
+                'Attributes and basic functionality of StereoPannerNode'
+          },
+          (task, should) => {
+
+            let context = new AudioContext();
+            let panner = context.createStereoPanner();
+
+            should(panner.numberOfInputs, 'panner.numberOfInputs').beEqualTo(1);
+            should(panner.numberOfOutputs, 'panner.numberOfOutputs')
+                .beEqualTo(1);
+            should(panner.pan.defaultValue, 'panner.pan.defaultValue')
+                .beEqualTo(0.0);
+            should(() => panner.pan.value = 1.0, 'panner.pan.value = 1.0')
+                .notThrow();
+            should(panner.pan.value, 'panner.pan.value').beEqualTo(1.0);
+
+            should(() => panner.channelCount = 1, 'panner.channelCount = 1')
+                .notThrow();
+            should(() => panner.channelCount = 3, 'panner.channelCount = 3')
+                .throw();
+            should(
+                () => panner.channelCountMode = 'explicit',
+                'panner.channelCountMode = "explicit"')
+                .notThrow();
+            should(
+                () => panner.channelCountMode = 'max',
+                'panner.channelCountMode = "max"')
+                .throw();
+
+            task.done();
+          });
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-stereopanner-interface/stereopannernode-panning.html b/testing/web-platform/tests/webaudio/the-audio-api/the-stereopanner-interface/stereopannernode-panning.html
new file mode 100644
index 0000000000..f683fd78bf
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-stereopanner-interface/stereopannernode-panning.html
@@ -0,0 +1,34 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      stereopannernode-panning.html
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="../../resources/audit-util.js"></script>
+    <script src="../../resources/audit.js"></script>
+    <script src="../../resources/stereopanner-testing.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      audit.define('mono-test', (task, should) => {
+        StereoPannerTest
+            .create(should, {numberOfInputChannels: 1, prefix: 'Mono: '})
+            .run()
+            .then(() => task.done());
+      });
+
+      audit.define('stereo-test', (task, should) => {
+        StereoPannerTest
+            .create(should, {numberOfInputChannels: 2, prefix: 'Stereo: '})
+            .run()
+            .then(() => task.done());
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/ctor-waveshaper.html b/testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/ctor-waveshaper.html
new file mode 100644
index 0000000000..7aa33ca5aa
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/ctor-waveshaper.html
@@ -0,0 +1,72 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test Constructor: WaveShaper
+    </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('incorrect construction', (task, should) => {
+        testInvalidConstructor(should, 'WaveShaperNode', context);
+        task.done();
+      });
+
+      audit.define('valid default construction', (task, should) => {
+        let prefix = 'node0';
+        let node = testDefaultConstructor(should, 'WaveShaperNode', context, {
+          prefix: prefix,
+          numberOfInputs: 1,
+          numberOfOutputs: 1,
+          channelCount: 2,
+          channelCountMode: 'max',
+          channelInterpretation: 'speakers'
+        });
+
+        testDefaultAttributes(should, node, prefix, [
+          {name: 'curve', value: null}, {name: 'oversample', value: 'none'}
+        ]);
+
+        task.done();
+      });
+
+      audit.define('test AudioNodeOptions', (task, should) => {
+        testAudioNodeOptions(should, context, 'WaveShaperNode');
+        task.done();
+      });
+
+      audit.define('valid non-default', (task, should) => {
+        // Construct an WaveShaperNode with options
+        let options = {curve: Float32Array.from([1, 2, 3]), oversample: '4x'};
+        let node;
+
+        let message =
+            'node1 = new WaveShaperNode(, ' + JSON.stringify(options) + ')';
+        should(() => {
+          node = new WaveShaperNode(context, options);
+        }, message).notThrow();
+        should(node.curve, 'node1.curve').beEqualToArray(options.curve);
+        should(node.oversample, 'node1.oversample')
+            .beEqualTo(options.oversample);
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/curve-tests.html b/testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/curve-tests.html
new file mode 100644
index 0000000000..d09cf78fd8
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/curve-tests.html
@@ -0,0 +1,184 @@
+<!doctype html>
+<html>
+<head>
+    <title>WaveShaperNode interface - Curve tests | WebAudio</title>
+
+    <script type="text/javascript" src="/resources/testharness.js"></script>
+    <script type="text/javascript" src="/resources/testharnessreport.js"></script>
+</head>
+<body>
+    <div id="log">
+    </div>
+
+    <script type="text/javascript">
+        var sampleRate=44100.0;
+        var tolerance=0.01;
+
+        /*
+        Testing that -1, 0 and +1 map correctly to curve (with 1:1 correlation)
+        =======================================================================
+        From the specification:
+            The input signal is nominally within the range -1 -> +1.
+            Each input sample within this range will index into the shaping curve with a signal level of zero corresponding
+                to the center value of the curve array.
+        */
+        (function() {
+            var threeElementCurve=[2.0, -3.0, 4.0];
+            var inputData=[-1.0, 0, 1.0];
+            var expectedData=[2.0, -3.0, 4.0];
+            executeTest(threeElementCurve, inputData, expectedData, "Testing that -1, 0 and +1 map correctly to curve (with 1:1 correlation)");
+        })();
+
+        /*
+        Testing interpolation (where inputs don't correlate directly to curve elements)
+        ===============================================================================
+        From the specification:
+            The implementation must perform linear interpolation between adjacent points in the curve.
+        */
+        (function() {
+            var threeElementCurve=[2.0, -3.0, 4.0];
+            var inputData=[-0.5, +0.5, +0.75];
+            var expectedData=[-0.5, +0.5, +2.25];
+            executeTest(threeElementCurve, inputData, expectedData, "Testing interpolation (where inputs don't correlate directly to curve elements)");
+        })();
+
+        /*
+        Testing out-of-range inputs (should be mapped to the first/last elements of the curve)
+        ======================================================================================
+        From the specification:
+            Any sample value less than -1 will correspond to the first value in the curve array.
+            Any sample value greater than +1 will correspond to the last value in the curve array.
+        */
+        (function() {
+            var threeElementCurve=[2.0, -3.0, 4.0];
+            var inputData=[-1.5, +1.5];
+            var expectedData=[2.0, 4.0];
+            executeTest(threeElementCurve, inputData, expectedData, "Testing out-of-range inputs (should be mapped to the first/last elements of the curve)");
+        })();
+
+        /*
+        Testing a 2-element curve (does not have a middle element)
+        ==========================================================
+        From the specification:
+            Each input sample within this range will index into the shaping curve with a signal level of zero corresponding
+                to the center value of the curve array.
+            The implementation must perform linear interpolation between adjacent points in the curve.
+        */
+        (function() {
+            var twoElementCurve=[2.0, -2.0];
+            var inputData=[-1.0, 0, 1.0];
+            var expectedData=[2.0, 0.0, -2.0];
+            executeTest(twoElementCurve, inputData, expectedData, "Testing a 2-element curve (does not have a middle element)");
+        })();
+
+        /*
+        Testing a 4-element curve (does not have a middle element)
+        ==========================================================
+        From the specification:
+            Each input sample within this range will index into the shaping curve with a signal level of zero corresponding
+                to the center value of the curve array.
+            The implementation must perform linear interpolation between adjacent points in the curve.
+        */
+        (function() {
+            var fourElementCurve=[1.0, 2.0, 4.0, 7.0];
+            var inputData=[-1.0, 0, 1.0];
+            var expectedData=[1.0, 3.0, 7.0];
+            executeTest(fourElementCurve, inputData, expectedData, "Testing a 4-element curve (does not have a middle element)");
+        })();
+
+        /*
+        Testing a huge curve
+        ====================
+        From the specification:
+            Each input sample within this range will index into the shaping curve with a signal level of zero corresponding
+                to the center value of the curve array.
+        */
+        (function() {
+            var bigCurve=[];
+            for(var i=0;i<=60000;i++) { bigCurve.push(i/3.5435); }
+            var inputData=[-1.0, 0, 1.0];
+            var expectedData=[bigCurve[0], bigCurve[30000], bigCurve[60000]];
+            executeTest(bigCurve, inputData, expectedData, "Testing a huge curve");
+        })();
+
+        /*
+        Testing single-element curve (boundary condition)
+        =================================================
+        From the specification:
+            Each input sample within this range will index into the shaping curve with a signal level of zero corresponding
+                to the center value of the curve array.
+            Any sample value less than -1 will correspond to the first value in the curve array.
+            Any sample value greater than +1 will correspond to the last value in the curve array.
+            The implementation must perform linear interpolation between adjacent points in the curve.
+        */
+
+        /*
+        Testing null curve (should return input values)
+        ===============================================
+        From the specification:
+            Initially the curve attribute is null, which means that the WaveShaperNode will pass its input to its output
+                without modification.
+        */
+        (function() {
+            var inputData=[-1.0, 0, 1.0, 2.0];
+            var expectedData=[-1.0, 0.0, 1.0, 2.0];
+            executeTest(null, inputData, expectedData, "Testing null curve (should return input values)");
+        })();
+
+        /**
+        * Function that does the actual testing (using an asynchronous test).
+        * @param {?Array.<number>} curveData - Array containing values for the WaveShaper curve.
+        * @param {!Array.<number>} inputData - Array containing values for the input stream.
+        * @param {!Array.<number>} expectedData - Array containing expected results for each of the corresponding inputs.
+        * @param {!string} testName - Name of the test case.
+        */
+        function executeTest(curveData, inputData, expectedData, testName) {
+            var stTest=async_test("WaveShaperNode - "+testName);
+            stTest.step(function() {
+
+                // Create offline audio context.
+                var ac=new OfflineAudioContext(1, inputData.length, sampleRate);
+
+                // Create the WaveShaper and its curve.
+                var waveShaper=ac.createWaveShaper();
+                if(curveData!=null) {
+                    var curve=new Float32Array(curveData.length);
+                    for(var i=0;i<curveData.length;i++) { curve[i]=curveData[i]; }
+                    waveShaper.curve=curve;
+                }
+                waveShaper.connect(ac.destination);
+
+                // Create buffer containing the input values.
+                var inputBuffer=ac.createBuffer(1, Math.max(inputData.length, 2), sampleRate);
+                var d=inputBuffer.getChannelData(0);
+                for(var i=0;i<inputData.length;i++) { d[i]=inputData[i]; }
+
+                // Play the input buffer through the WaveShaper.
+                var src=ac.createBufferSource();
+                src.buffer=inputBuffer;
+                src.connect(waveShaper);
+                src.start();
+
+                // Test the outputs match the expected values.
+                ac.oncomplete=stTest.step_func_done(function(ev) {
+                    var d=ev.renderedBuffer.getChannelData(0);
+
+                    for(var i=0;i<expectedData.length;i++) {
+                        var curveText="null";
+                        if(curve!=null) {
+                            if(curveData.length<20) {
+                                curveText=curveData.join(",");
+                            } else {
+                                curveText="TooBigToDisplay ("+(curveData.length-1)+" elements)";
+                            }
+                        }
+                        var comment="Input="+inputData[i]+", Curve=["+curveText+"] >>> ";
+                        assert_approx_equals(d[i], expectedData[i], tolerance, comment);
+                    }
+                });
+                ac.startRendering();
+            });
+        }
+    </script>
+</body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/silent-inputs.html b/testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/silent-inputs.html
new file mode 100644
index 0000000000..45d2c9ad4b
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/silent-inputs.html
@@ -0,0 +1,103 @@
+<!doctype html>
+<html>
+  <head>
+    <title>
+      Test Silent Inputs to WaveShaperNode
+    </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 audit = Audit.createTaskRunner();
+      let sampleRate = 16000;
+
+      // Identity curve for the wave shaper: the input value is mapped directly
+      // to the output value.
+      let identityCurve = [-1, 0, 1];
+      let nonZeroCurve = [0.5, 0.5, 0.5];
+
+      audit.define(
+          {
+            label: 'test-0',
+            description: 'curve output is non-zero for silent inputs'
+          },
+          (task, should) => {
+            let {context, source, shaper} =
+                setupGraph(nonZeroCurve, sampleRate, sampleRate);
+
+            source.offset.setValueAtTime(0, 0);
+
+            context.startRendering()
+                .then(audioBuffer => {
+                  should(
+                      audioBuffer.getChannelData(0),
+                      'WaveShaper with silent inputs and curve ' +
+                          JSON.stringify(shaper.curve))
+                      .beConstantValueOf(0.5);
+                })
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: 'test-1',
+            description: '2x curve output is non-zero for silent inputs'
+          },
+          (task, should) => {
+            let {context, source, shaper} =
+                setupGraph(nonZeroCurve, sampleRate, sampleRate);
+
+            source.offset.setValueAtTime(0, 0);
+            shaper.overSample = '2x';
+
+            context.startRendering()
+                .then(audioBuffer => {
+                  should(
+                      audioBuffer.getChannelData(0),
+                      'WaveShaper with ' + shaper.overSample +
+                          ' oversample, silent inputs, and curve ' +
+                          JSON.stringify(shaper.curve))
+                      .beConstantValueOf(0.5);
+                })
+                .then(() => task.done());
+          });
+
+      audit.define(
+          {
+            label: 'test-2',
+            description: 'curve output is non-zero for no inputs'
+          },
+          (task, should) => {
+            let {context, source, shaper} =
+                setupGraph(nonZeroCurve, sampleRate, sampleRate);
+
+            source.disconnect();
+
+            context.startRendering()
+                .then(audioBuffer => {
+                  should(
+                      audioBuffer.getChannelData(0),
+                      'WaveShaper with no inputs and curve ' +
+                          JSON.stringify(shaper.curve))
+                      .beConstantValueOf(0.5);
+                })
+                .then(() => task.done());
+          });
+
+      function setupGraph(curve, testFrames, sampleRate) {
+        let context = new OfflineAudioContext(1, testFrames, sampleRate);
+        let source = new ConstantSourceNode(context);
+        let shaper = new WaveShaperNode(context, {curve: curve});
+
+        source.connect(shaper).connect(context.destination);
+
+        return {context: context, source: source, shaper: shaper};
+      }
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/waveshaper-copy-curve.html b/testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/waveshaper-copy-curve.html
new file mode 100644
index 0000000000..e897ac08a1
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/waveshaper-copy-curve.html
@@ -0,0 +1,100 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Test WaveShaper Copies Curve Data
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="../../resources/audit-util.js"></script>
+    <script src="../../resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      // Sample rate and number of frames are fairly arbitrary.  We need to
+      // render, however, at least 384 frames.  1024 is a nice small value.
+      let sampleRate = 16000;
+      let renderFrames = 1024;
+
+      let audit = Audit.createTaskRunner();
+
+      audit.define(
+          {
+            label: 'test copying',
+            description: 'Modifying curve should not modify WaveShaper'
+          },
+          (task, should) => {
+            // Two-channel context; channel 0 contains the test data and channel
+            // 1 contains the expected result.  Channel 1 has the normal
+            // WaveShaper output and channel 0 has the WaveShaper output with a
+            // modified curve.
+            let context = new OfflineAudioContext(2, renderFrames, sampleRate);
+
+            // Just use a default oscillator as the source.  Doesn't really
+            // matter what we use.
+            let src = context.createOscillator();
+            src.type = 'sawtooth';
+
+            // Create the wave shapers: ws0 is the test shaper, and ws1 is the
+            // reference wave shaper.
+            let ws0 = context.createWaveShaper();
+            let ws1 = context.createWaveShaper();
+
+            // Wave shaper curves.  Doesn't really matter what we use as long as
+            // it modifies the input in some way.  Thus, keep it simple and just
+            // invert the input.
+            let desiredCurve = [1, 0, -1];
+            let curve0 = Float32Array.from(desiredCurve);
+            let curve1 = Float32Array.from(desiredCurve);
+
+            ws0.curve = curve0;
+            ws1.curve = curve1;
+
+            let merger = context.createChannelMerger(2);
+
+            // Connect the graph
+            src.connect(ws0);
+            src.connect(ws1);
+
+            ws0.connect(merger, 0, 0);
+            ws1.connect(merger, 0, 1);
+
+            merger.connect(context.destination);
+
+            // Let the context run for a bit and then modify the curve for ws0.
+            // Doesn't really matter what we modify the curve to as long as it's
+            // different.
+            context.suspend(256 / context.sampleRate)
+                .then(() => {
+                  should(
+                      () => {
+                        curve0[0] = -0.5;
+                        curve0[1] = 0.125;
+                        curve0[2] = 0.75;
+                      },
+                      `Modifying curve array at time ${context.currentTime}`)
+                      .notThrow();
+                })
+                .then(context.resume.bind(context));
+
+            src.start();
+
+            context.startRendering()
+                .then(function(renderedBuffer) {
+                  let actual = renderedBuffer.getChannelData(0);
+                  let expected = renderedBuffer.getChannelData(1);
+
+                  // Modifying the wave shaper curve should not modify the
+                  // output so the outputs from the two wave shaper nodes should
+                  // be exactly identical.
+                  should(actual, 'Output of WaveShaper with modified curve')
+                      .beEqualToArray(expected);
+
+                })
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/waveshaper-limits.html b/testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/waveshaper-limits.html
new file mode 100644
index 0000000000..13e88be567
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/waveshaper-limits.html
@@ -0,0 +1,110 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      waveshaper-limits.html
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="../../resources/audit-util.js"></script>
+    <script src="../../resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      let context;
+      let bufferData;
+      let outputData;
+      let reference;
+
+      let sampleRate = 48000;
+      // Must be odd so we have an exact middle point.
+      let testFrames = 23;
+      let scale = 1 / ((testFrames - 1) / 2 - 1);
+      // Number of decimal digits to print
+      let decimals = 6;
+      // Required accuracy
+      let diffThreshold = Math.pow(10, -decimals);
+
+      // Generate reference data
+      function generateReference() {
+        // The curve data is 0, 1, 0, and the input data is a ramp from -1+eps
+        // to 1+eps.  Then the output is a ramp from 0 to 1 back to 0.
+        let ref = new Float32Array(testFrames);
+        let midPoint = (testFrames - 1) / 2;
+        // First sample is below -1 at -1-scale.
+        ref[0] = 0;
+        // Generate ramp up to the mid-point
+        for (let k = 0; k < midPoint; ++k) {
+          ref[k + 1] = k * scale;
+        }
+        // The value at the mid-point must be 1, from the curve
+        ref[midPoint] = 1;
+        // Generate a ramp from 1 down to 0
+        for (let k = midPoint; k < testFrames - 1; ++k) {
+          ref[k + 1] = 2 - k * scale;
+        }
+        // The last sample is out of range at 1+scale
+        ref[testFrames - 1] = 0;
+        return ref;
+      }
+
+      function checkResult(renderedBuffer, should) {
+        outputData = renderedBuffer.getChannelData(0);
+        reference = generateReference();
+        let success = true;
+        // Verify that every output value matches our expected reference value.
+        for (let k = 0; k < outputData.length; ++k) {
+          let diff = outputData[k] - reference[k];
+          should(
+              Math.abs(diff),
+              'Max error mapping ' + bufferData[k].toFixed(decimals) + ' to ' +
+                  outputData[k].toFixed(decimals))
+              .beLessThanOrEqualTo(diffThreshold);
+        }
+      }
+
+      audit.define(
+          {
+            label: 'test',
+            description:
+                'WaveShaperNode including values outside the range of [-1,1]'
+          },
+          function(task, should) {
+            context = new OfflineAudioContext(1, testFrames, sampleRate);
+            // Create input values between -1.1 and 1.1
+            let buffer =
+                context.createBuffer(1, testFrames, context.sampleRate);
+            bufferData = new Float32Array(testFrames);
+            let start = -1 - scale;
+            for (let k = 0; k < testFrames; ++k) {
+              bufferData[k] = k * scale + start;
+            }
+            buffer.copyToChannel(bufferData, 0);
+
+            let source = context.createBufferSource();
+            source.buffer = buffer;
+
+            // Create simple waveshaper. It should map -1 to 0, 0 to 1, and +1
+            // to 0 and interpolate all points in between using a simple linear
+            // interpolator.
+            let shaper = context.createWaveShaper();
+            let curve = new Float32Array(3);
+            curve[0] = 0;
+            curve[1] = 1;
+            curve[2] = 0;
+            shaper.curve = curve;
+            source.connect(shaper);
+            shaper.connect(context.destination);
+
+            source.start();
+            context.startRendering()
+                .then(buffer => checkResult(buffer, should))
+                .then(() => task.done());
+          });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/waveshaper-simple.html b/testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/waveshaper-simple.html
new file mode 100644
index 0000000000..affd0c58af
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/waveshaper-simple.html
@@ -0,0 +1,61 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      Simple Tests of WaveShaperNode
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="../../resources/audit-util.js"></script>
+    <script src="../../resources/audit.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      audit.define('simple', (task, should) => {
+        let context = new OfflineAudioContext(1, 1, 48000);
+        let shaper = context.createWaveShaper();
+
+        // Verify default values are correct.
+        should(shaper.curve, 'Initial WaveShaper.curve').beEqualTo(null);
+        should(shaper.oversample, 'Initial WaveShaper.oversample')
+            .beEqualTo('none');
+
+        // Set oversample and verify that it is set correctly.
+        should(() => shaper.oversample = '2x', 'Setting oversample to "2x"')
+            .notThrow();
+        should(shaper.oversample, 'Waveshaper.oversample = "2x"')
+            .beEqualTo('2x');
+
+        should(() => shaper.oversample = '4x', 'Setting oversample to "4x"')
+            .notThrow();
+        should(shaper.oversample, 'Waveshaper.oversample = "4x"')
+            .beEqualTo('4x');
+
+        should(
+            () => shaper.oversample = 'invalid',
+            'Setting oversample to "invalid"')
+            .notThrow();
+        should(shaper.oversample, 'Waveshaper.oversample = "invalid"')
+            .beEqualTo('4x');
+
+        // Set the curve and verify that the returned curve is the same as what
+        // it was set to.
+        let curve = Float32Array.from([-1, 0.25, .75]);
+        should(() => shaper.curve = curve, 'Setting curve to [' + curve + ']')
+            .notThrow();
+        should(shaper.curve, 'WaveShaper.curve').beEqualToArray(curve);
+
+        // Verify setting the curve to null works.
+        should(() => shaper.curve = null, 'Setting curve back to null')
+            .notThrow();
+        should(shaper.curve, 'Waveshaper.curve = null').beEqualTo(null);
+
+        task.done();
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
diff --git a/testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/waveshaper.html b/testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/waveshaper.html
new file mode 100644
index 0000000000..8bfa009b18
--- /dev/null
+++ b/testing/web-platform/tests/webaudio/the-audio-api/the-waveshapernode-interface/waveshaper.html
@@ -0,0 +1,127 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>
+      waveshaper.html
+    </title>
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="../../resources/audit-util.js"></script>
+    <script src="../../resources/audit.js"></script>
+    <script src="../../resources/buffer-loader.js"></script>
+  </head>
+  <body>
+    <script id="layout-test-code">
+      let audit = Audit.createTaskRunner();
+
+      let sampleRate = 44100;
+      let lengthInSeconds = 4;
+      let numberOfRenderFrames = sampleRate * lengthInSeconds;
+      let numberOfCurveFrames = 65536;
+      let inputBuffer;
+      let waveShapingCurve;
+
+      let context;
+
+      function generateInputBuffer() {
+        // Create mono input buffer.
+        let buffer =
+            context.createBuffer(1, numberOfRenderFrames, context.sampleRate);
+        let data = buffer.getChannelData(0);
+
+        // Generate an input vector with values from -1 -> +1 over a duration of
+        // lengthInSeconds. This exercises the full nominal input range and will
+        // touch every point of the shaping curve.
+        for (let i = 0; i < numberOfRenderFrames; ++i) {
+          let x = i / numberOfRenderFrames;  // 0 -> 1
+          x = 2 * x - 1;                     // -1 -> +1
+          data[i] = x;
+        }
+
+        return buffer;
+      }
+
+      // Generates a symmetric curve: Math.atan(5 * x) / (0.5 * Math.PI)
+      // (with x == 0 corresponding to the center of the array)
+      // This curve is arbitrary, but would be useful in the real-world.
+      // To some extent, the actual curve we choose is not important in this
+      // test, since the input vector walks through all possible curve values.
+      function generateWaveShapingCurve() {
+        let curve = new Float32Array(numberOfCurveFrames);
+
+        let n = numberOfCurveFrames;
+        let n2 = n / 2;
+
+        for (let i = 0; i < n; ++i) {
+          let x = (i - n2) / n2;
+          let y = Math.atan(5 * x) / (0.5 * Math.PI);
+        }
+
+        return curve;
+      }
+
+      function checkShapedCurve(buffer, should) {
+        let inputData = inputBuffer.getChannelData(0);
+        let outputData = buffer.getChannelData(0);
+
+        let success = true;
+
+        // Go through every sample and make sure it has been shaped exactly
+        // according to the shaping curve we gave it.
+        for (let i = 0; i < buffer.length; ++i) {
+          let input = inputData[i];
+
+          // Calculate an index based on input -1 -> +1 with 0 being at the
+          // center of the curve data.
+          let index = Math.floor(numberOfCurveFrames * 0.5 * (input + 1));
+
+          // Clip index to the input range of the curve.
+          // This takes care of input outside of nominal range -1 -> +1
+          index = index < 0 ? 0 : index;
+          index =
+              index > numberOfCurveFrames - 1 ? numberOfCurveFrames - 1 : index;
+
+          let expectedOutput = waveShapingCurve[index];
+
+          let output = outputData[i];
+
+          if (output != expectedOutput) {
+            success = false;
+            break;
+          }
+        }
+
+        should(
+            success, 'WaveShaperNode applied non-linear distortion correctly')
+            .beTrue();
+      }
+
+      audit.define('test', function(task, should) {
+        // Create offline audio context.
+        context = new OfflineAudioContext(1, numberOfRenderFrames, sampleRate);
+
+        // source -> waveshaper -> destination
+        let source = context.createBufferSource();
+        let waveshaper = context.createWaveShaper();
+        source.connect(waveshaper);
+        waveshaper.connect(context.destination);
+
+        // Create an input test vector.
+        inputBuffer = generateInputBuffer();
+        source.buffer = inputBuffer;
+
+        // We'll apply non-linear distortion according to this shaping curve.
+        waveShapingCurve = generateWaveShapingCurve();
+        waveshaper.curve = waveShapingCurve;
+
+        source.start(0);
+
+        context.startRendering()
+            .then(buffer => checkShapedCurve(buffer, should))
+            .then(task.done.bind(task));
+      });
+
+      audit.run();
+    </script>
+  </body>
+</html>
-- 
cgit v1.2.3