Index: third_party/WebKit/LayoutTests/webaudio/constructor/new-audionodeoptions.js |
diff --git a/third_party/WebKit/LayoutTests/webaudio/constructor/new-audionodeoptions.js b/third_party/WebKit/LayoutTests/webaudio/constructor/new-audionodeoptions.js |
new file mode 100644 |
index 0000000000000000000000000000000000000000..d5c509780772bea95f104a5a8199f751bfc3af67 |
--- /dev/null |
+++ b/third_party/WebKit/LayoutTests/webaudio/constructor/new-audionodeoptions.js |
@@ -0,0 +1,213 @@ |
+// Test that constructor for the node with name |nodeName| handles the |
+// various possible values for channelCount, channelCountMode, and |
+// channelInterpretation. |
hongchan
2017/04/20 19:04:19
Please mention that this method requires |Audit| a
Raymond Toy
2017/04/20 19:19:38
Here and everywhere, I assume.
|
+function testAudioNodeOptions(should, context, nodeName, nodeOptions) { |
hongchan
2017/04/20 19:04:19
Can we name this |expectedNodeOptions| and remove
Raymond Toy
2017/04/20 21:00:00
Done.
|
+ if (nodeOptions === undefined) |
+ nodeOptions = {}; |
+ var node; |
hongchan
2017/04/20 19:04:19
I see the mixed usage of |var| and |let|. Let's be
Raymond Toy
2017/04/20 21:00:00
Done.
|
+ |
+ // Test that we can set channelCount and that errors are thrown for |
+ // invalid values |
+ var testCount = 17; |
hongchan
2017/04/20 19:04:19
testChannelCount
Raymond Toy
2017/04/20 21:00:00
Done.
|
+ if (nodeOptions.expectedChannelCount) { |
+ testCount = nodeOptions.expectedChannelCount.value; |
hongchan
2017/04/20 19:04:19
So |expectedChannelCount| is an object, not a valu
Raymond Toy
2017/04/20 19:19:38
Yes. Analyser doesn't show this usage, but, say, C
|
+ } |
+ should(() => { |
+ node = new window[nodeName]( |
+ context, |
+ Object.assign( |
+ {}, nodeOptions.additionalOptions, {channelCount: testCount})); |
+ }, 'new ' + nodeName + '(c, {channelCount: ' + testCount + '}}').notThrow(); |
+ should(node.channelCount, 'node.channelCount').beEqualTo(testCount); |
+ |
+ if (nodeOptions.expectedChannelCount && |
+ nodeOptions.expectedChannelCount.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. |
+ testCount = nodeOptions.expectedChannelCount.value + 1; |
+ should( |
+ () => { |
+ node = new window[nodeName]( |
+ context, Object.assign({}, nodeOptions.additionalOptions, { |
+ channelCount: testCount |
+ })); |
+ }, |
+ 'new ' + nodeName + '(c, {channelCount: ' + testCount + '}}') |
+ .throw(nodeOptions.expectedChannelCount.errorType || 'TypeError'); |
+ } else { |
+ // The channel count is not fixed. Try to set the count to invalid |
+ // values and make sure an error is thrown. |
+ var errorType = 'NotSupportedError'; |
+ |
+ should(() => { |
+ node = new window[nodeName]( |
+ context, |
+ Object.assign({}, nodeOptions.additionalOptions, {channelCount: 0})); |
+ }, 'new ' + nodeName + '(c, {channelCount: 0}}', ).throw(errorType); |
+ |
+ should(() => { |
+ node = new window[nodeName]( |
+ context, |
+ Object.assign({}, nodeOptions.additionalOptions, {channelCount: 99})); |
+ }, 'new ' + nodeName + '(c, {channelCount: 99}}').throw(errorType); |
+ } |
+ |
+ // Test channelCountMode |
+ var testMode = 'max'; |
+ if (nodeOptions && nodeOptions.expectedChannelCountMode) { |
hongchan
2017/04/20 19:04:19
|nodeOptions| cannot be invalid at this point.
Raymond Toy
2017/04/20 21:00:00
Done.
|
+ testMode = nodeOptions.expectedChannelCountMode.value; |
+ } |
+ should( |
+ () => { |
+ node = new window[nodeName]( |
+ context, Object.assign({}, nodeOptions.additionalOptions, { |
+ channelCountMode: testMode |
+ })); |
+ }, |
+ 'new ' + nodeName + '(c, {channelCountMode: "' + testMode + '"}') |
+ .notThrow(); |
+ should(node.channelCountMode, 'node.channelCountMode').beEqualTo(testMode); |
+ |
+ if (nodeOptions.expectedChannelCountMode && |
+ nodeOptions.expectedChannelCountMode.isFixed) { |
+ // Channel count mode is fixed. Test setting to something else throws. |
+ var testModeMap = { |
+ 'max': 'clamped-max', |
+ 'clamped-max': 'explicit', |
+ 'explicit': 'max' |
+ }; |
+ testMode = testModeMap[nodeOptions.expectedChannelCountMode.value]; |
+ should( |
+ () => { |
+ node = new window[nodeName]( |
+ context, Object.assign({}, nodeOptions.additionalOptions, { |
+ channelCountMode: testMode |
+ })); |
+ }, |
+ 'new ' + nodeName + '(c, {channelCountMode: "' + testMode + '"}') |
+ .throw(nodeOptions.expectedChannelCountMode.errorType); |
+ } else { |
+ // Mode is not fixed. Verify that we can set the mode to all valid |
+ // values, and that we throw for invalid values. |
+ |
+ should(() => { |
+ node = new window[nodeName]( |
+ context, Object.assign({}, nodeOptions.additionalOptions, { |
+ channelCountMode: 'clamped-max' |
+ })); |
+ }, 'new ' + nodeName + '(c, {channelCountMode: "clamped-max"}').notThrow(); |
+ should(node.channelCountMode, 'node.channelCountMode after invalid setter') |
+ .beEqualTo('clamped-max'); |
+ |
+ should(() => { |
+ node = new window[nodeName]( |
+ context, Object.assign({}, nodeOptions.additionalOptions, { |
+ channelCountMode: 'explicit' |
+ })); |
+ }, 'new ' + nodeName + '(c, {channelCountMode: "explicit"}').notThrow(); |
+ should(node.channelCountMode, 'node.channelCountMode') |
+ .beEqualTo('explicit'); |
+ |
+ should( |
+ () => { |
+ node = new window[nodeName]( |
+ context, Object.assign({}, nodeOptions.additionalOptions, { |
+ channelCountMode: 'foobar' |
+ })); |
+ }, |
+ 'new ' + nodeName + '(c, {channelCountMode: "foobar"}') |
+ .throw('TypeError'); |
+ should(node.channelCountMode, 'node.channelCountMode after invalid setter') |
+ .beEqualTo('explicit'); |
+ } |
+ |
+ // Test channelInterpretation |
+ should(() => { |
+ node = new window[nodeName]( |
+ context, Object.assign({}, nodeOptions.additionalOptions, { |
+ channelInterpretation: 'speakers' |
+ })); |
+ }, 'new ' + nodeName + '(c, {channelInterpretation: "speakers"})').notThrow(); |
+ should(node.channelInterpretation, 'node.channelInterpretation') |
+ .beEqualTo('speakers'); |
+ |
+ should(() => { |
+ node = new window[nodeName]( |
+ context, Object.assign({}, nodeOptions.additionalOptions, { |
+ channelInterpretation: 'discrete' |
+ })); |
+ }, 'new ' + nodeName + '(c, {channelInterpretation: "discrete"})').notThrow(); |
+ should(node.channelInterpretation, 'node.channelInterpretation') |
+ .beEqualTo('discrete'); |
+ |
+ should( |
+ () => { |
+ node = new window[nodeName]( |
+ context, Object.assign({}, nodeOptions.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; |
+ |
+ should(() => { |
+ node = new window[name](context); |
+ }, options.prefix + ' = new ' + name + '(context)').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); |
+ } |
+ }); |
+} |