Add constructors for WebAudio nodes

third_party/WebKit/LayoutTests/webaudio/resources/audio-testing.js

 /* global self */
 
 // testharness.js has the higher priority.
 var TESTHARNESS = true;
 var JSTEST = false;
 
 (function () {
     // Selected properies from testharness.js
     var testharnessProperties = [
         'test', 'async_test', 'promise_test', 'promise_rejects',
@@ skipping 473 matching lines @@
 
         // If true, verbose output for the failure case is printed, for methods where this makes
         // sense.
         this.verbose = !opts.brief;
 
         // If set, this is the precision with which numbers will be printed.
         this.PRINT_PRECISION = opts.precision;
     }
 
     // Internal methods starting with a underscore.
-    ShouldModel.prototype._testPassed = function (msg) {
+    ShouldModel.prototype._testPassed = function (msg, addNewline) {
         this._success = true;
+        var newLine = addNewline ? '\n' : '';
         if (TESTHARNESS) {
             // Using testharness.js
             test(function () {
                 assert_true(true);
-                }, this.desc + ' ' + msg + '.');
+                }, this.desc + ' ' + msg + '.' + newLine);
         } else {
             // Using js-test.js
-            testPassed(this.desc + ' ' + msg + '.');
+            testPassed(this.desc + ' ' + msg + '.' + newLine);
         }
     };
 
-    ShouldModel.prototype._testFailed = function (msg) {
+    ShouldModel.prototype._testFailed = function (msg, addNewline) {
         this._success = false;
         var that = this;
+        var newLine = addNewline ? '\n' : '';
         if (TESTHARNESS) {
             test(function () {
-                assert_true(false, that.desc + ' ' + msg + '.');
+                assert_true(false, that.desc + ' ' + msg + '.' + newLine);
                 }, this.desc);
         } else {
-            testFailed(this.desc + ' ' + msg + '.');
+            testFailed(this.desc + ' ' + msg + '.' + newLine);
         }
     };
 
     ShouldModel.prototype._isArray = function (arg) {
       return arg instanceof Array || arg instanceof Float32Array || arg instanceof Uint8Array ||
         arg instanceof Uint16Array || arg instanceof Uint32Array || arg instanceof Int8Array ||
         arg instanceof Int16Array || arg instanceof Int32Array || arg instanceof Uint8ClampedArray ||
         arg instanceof Float64Array;
     };
 
@@ skipping 118 matching lines @@
     };
 
     // Check if |target| is not equal to |value|.
     //
     // Example:
     // Should('One', one).notBeEqualTo(0);
     // Result:
     // "PASS One is not equal to 0."
     ShouldModel.prototype.notBeEqualTo = function (value) {
         var type = typeof value;
-        this._assert(type === 'number' || type === 'string',
-            'value should be number or string for', value);
+        this._assert(type === 'number' || type === 'string' || type === "boolean",
+            'value should be number, string, or boolean for', value);
 
         this._checkNaN(value, 'EXPECTED');
 
         if (this.target === value)
             this._testFailed('should not be equal to ' + value);
         else
             this._testPassed('is not equal to ' + value);
         return this._success;
     };
 
@@ skipping 493 matching lines @@
     // A summary message
     //
     // Example:
     // Should("Summary1", true).summarize("passed1", "failed1");
     // Should("Summary2", false).summarize("passed2", "failed2");
     // Result:
     // "PASS Summary1: passed1."
     // "FAIL Summary2: failed2."
     ShouldModel.prototype.summarize = function (pass, fail) {
         if (this.target)
-            this._testPassed(pass);
+            this._testPassed(pass, true);
         else
-            this._testFailed(fail);
+            this._testFailed(fail, true);
         return this._success;
     }
 
     // Should() method.
     //
     // |desc| is the description of the task or check and |target| is a value
     // needs to be checked or a task to be performed. |opt| contains options for
     // printing out log messages: options are |opt.numberOfErrorLog| and
     // |opts.numberOfArrayLog|.
     return function (desc, target, opts) {
@@ skipping 11 matching lines @@
             if (opts.hasOwnProperty('brief'))
                 _opts.brief = opts.brief;
             if (opts.hasOwnProperty('precision'))
                 _opts.precision = opts.precision;
         }
 
         return new ShouldModel(desc, target, _opts);
     };
 
 })();