Convert constructor/analyser test to new Audit

third_party/WebKit/LayoutTests/webaudio/constructor/new-audionodeoptions.js

+// 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| and |should|.

[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 all 'expected' prefix from
other variables?

[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 consistent.

[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 value? That seems awkward.

[Raymond Toy, 2017/04/20 19:19:38]

Yes. Analyser doesn't show this usage, but, say, Convolver does.

This is needed because, currently, sometimes the channel count is fixed, so we
should throw an error on that, and the error type that is thrown varies.

+  }
+  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);
+    }
+  });
+}