Modifying audio-testing.js to support testharness.js.

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',
+        'generate_tests', 'setup', 'done', 'assert_true', 'assert_false'
+    ];
+
+    // Selected properties from js-test.js
+    var jsTestProperties = [
+        'isJsTest', 'testPassed', 'testFailed', 'gc', 'finishJSTest'
+    ];
+
+    // Check if testharness.js is properly loaded and set up a flag for it.
+    for (var name in testharnessProperties) {
+        if (!self.hasOwnProperty(testharnessProperties[name])) {
+            TESTHARNESS = false;
+            break;
+        }
+    }
+
+    // Immediately return here because testharness.js is ready.
+    if (TESTHARNESS)
+        return;
+
+    // Because testharness.js is not loaded, let us assume that js-test.js might
+    // be in use. Check if js-test.js is properly loaded and set up a flag for
+    // it.
+    JSTEST = true;
+    for (var name in jsTestProperties) {
+        if (!self.hasOwnProperty(jsTestProperties[name])) {
+            JSTEST = false;
+            break;
+        }
+    }
+
+    // If both are not loaded at all, throw here.
+    if (!JSTEST)
+        throw new Error('Cannot proceed. No test infrastructure is loaded.');
+})();
+
+
+
 function writeString(s, a, offset) {
     for (var i = 0; i < s.length; ++i) {
         a[offset + i] = s.charCodeAt(i);
     }
 }
 
 function writeInt16(n, a, offset) {
     n = Math.floor(n);
 
     var b1 = n & 255;
@@ skipping 283 matching lines @@
  var Audit = (function () {
 
     'use strict';
 
     function Tasks() {
         this.tasks = {};
         this.queue = [];
         this.currentTask = 0;
     }
 
+    // This is to prime the task runner for the testharness.js async operation.
+    Tasks.prototype._initialize = function () {
+        if (TESTHARNESS) {
+            setup(new Function(), {
+                explicit_done: true
+            });
+        }
+    };
+
+    // Finalize the task runner by notifying testharness and testRunner that
+    // all the task is completed.
+    Tasks.prototype._finalize = function () {
+        if (TESTHARNESS) {
+            // From testharness.js
+            done();
+        }
+    };
+
     Tasks.prototype.defineTask = function (taskName, taskFunc) {
         // Check if there is a task defined with the same name.  If found, do
         // not add the task to the roster.
         if (this.tasks.hasOwnProperty(taskName)) {
             debug('>> Audit.defineTask:: Duplicate task definition. ("' + taskName + '")');
             return;
         }
 
         this.tasks[taskName] = taskFunc;
 
         // Push the task name in the order of definition.
         this.queue.push(taskName);
     };
 
     // If arguments are given, only run the requested tasks.  Check for any
     // undefined or duplicate task in the requested task arguments.  If there
     // is no argument, run all the defined tasks.
     Tasks.prototype.runTasks = function () {
 
+        this._initialize();
+
         if (arguments.length > 0) {
 
             // Reset task queue and refill it with the with the given arguments,
             // in argument order.
             this.queue = [];
 
             for (var i = 0; i < arguments.length; i++) {
                 if (!this.tasks.hasOwnProperty(arguments[i]))
                     debug('>> Audit.runTasks:: Ignoring undefined task. ("' + arguments[i] + '")');
                 else if (this.queue.indexOf(arguments[i]) > -1)
                     debug('>> Audit.runTasks:: Ignoring duplicate task request. ("' + arguments[i] + '")');
                 else
                     this.queue.push(arguments[i]);
             }
         }
 
         if (this.queue.length === 0) {
             debug('>> Audit.runTasks:: No task to run.');
             return;
         }
 
-        // done() callback from each task.  Increase the task index and call the
-        // next task.  Note that explicit signaling by done() in each task
-        // is needed because some of tests run asynchronously.
-        var done = function () {
+        // taskDone() callback from each task.  Increase the task index and call
+        // the next task.  Note that explicit signaling by taskDone() in each
+        // task is needed because some of tests run asynchronously.
+        var taskDone = function () {
             if (this.currentTask !== this.queue.length - 1) {
                 ++this.currentTask;
                 // debug('>> Audit.runTasks: ' + this.queue[this.currentTask]);
-                this.tasks[this.queue[this.currentTask]](done);
+                this.tasks[this.queue[this.currentTask]](taskDone);
+            } else {
+                this._finalize();
             }
             return;
         }.bind(this);
 
         // Start the first task.
         // debug('>> Audit.runTasks: ' + this.queue[this.currentTask]);
-        this.tasks[this.queue[this.currentTask]](done);
+        this.tasks[this.queue[this.currentTask]](taskDone);
     };
 
     return {
         createTaskRunner: function () {
             return new Tasks();
         }
     };
 
 })();
 
@@ skipping 23 matching lines @@
     'use strict';
 
     // ShouldModel internal class. For the exposed (factory) method, it is the
     // return value of this closure.
     function ShouldModel(desc, target, opts) {
         this.desc = desc;
         this.target = target;
 
         // Check if the target contains any NaN value.
         this._checkNaN(this.target, 'ACTUAL');
-        // if (resultNaNCheck.length > 0) {
-        //     var failureMessage = 'NaN found while testing the target (' + label + ')';
-        //     testFailed(failureMessage + ': "' + this.desc + '" \n' +
-        //         resultNaNCheck);
-        //     throw failureMessage;
-        // }
 
         // |_testPassed| and |_testFailed| set this appropriately.
         this._success = false;
 
         // If the number of errors is greater than this, the rest of error
         // messages are suppressed. the value is fairly arbitrary, but shouldn't
         // be too small or too large.
         this.NUM_ERRORS_LOG = opts.numberOfErrorLog;
 
         // If the number of array elements is greater than this, the rest of
         // elements will be omitted.
         this.NUM_ARRAY_LOG = opts.numberOfArrayLog;
 
         // 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) {
-        testPassed(this.desc + ' ' + msg + '.');
         this._success = true;
+        if (TESTHARNESS) {
+            // Using testharness.js
+            test(function () {
+                assert_true(true);
+                }, this.desc + ' ' + msg + '.');
+        } else {
+            // Using js-test.js
+            testPassed(this.desc + ' ' + msg + '.');
+        }
     };
 
     ShouldModel.prototype._testFailed = function (msg) {
-        testFailed(this.desc + ' ' + msg + '.');
         this._success = false;
+        var that = this;
+        if (TESTHARNESS) {
+            test(function () {
+                assert_true(false, that.desc + ' ' + msg + '.');
+                }, this.desc);
+        } else {
+            testFailed(this.desc + ' ' + msg + '.');
+        }
     };
 
     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;
     };
 
     ShouldModel.prototype._assert = function (expression, reason, value) {
         if (expression)
             return;
 
         var failureMessage = 'Assertion failed: ' + reason + ' ' + this.desc +'.';
         if (arguments.length >= 3)
             failureMessage += ": " + value;
-        testFailed(failureMessage);
+
+        if (TESTHARNESS) {
+            test(function () {
+                assert_true(false, reason + ' (' + value + ')');
+            }, this.desc)
+        } else {
+            testFailed(failureMessage);
+        }
+
         throw failureMessage;
     };
 
     // Check the expected value if it is a NaN (Number) or has NaN(s) in
     // its content (Array or Float32Array). Returns a string depends on the
     // result of check.
     ShouldModel.prototype._checkNaN = function (value, label) {
         var failureMessage = 'NaN found in ' + label + ' while testing "' +
             this.desc + '"';
 
         // Checking a single variable first.
         if (Number.isNaN(value)) {
-            testFailed(failureMessage);
+            if (TESTHARNESS) {
+                test(function () {
+                    assert_true(false, failureMessage);
+                }, this.desc)
+            } else {
+                testFailed(failureMessage);
+            }
+
             throw failureMessage;
         }
 
         // If the value is not a NaN nor array, we can assume it is safe.
         if (!this._isArray(value))
             return;
 
         // Otherwise, check the array array.
         var indices = [];
         for (var i = 0; i < value.length; i++) {
             if (Number.isNaN(value[i]))
                 indices.push(i);
         }
 
         if (indices.length === 0)
             return;
 
         var failureDetail = ' (' + indices.length + ' instances total)\n';
         for (var n = 0; n < indices.length; n++) {
             failureDetail += '   >> [' + indices[n] + '] = NaN\n';
             if (n >= this.NUM_ERRORS_LOG) {
                 failureDetail += ' and ' + (indices.length - n) +
                 ' more NaNs...';
                 break;
             }
         }
 
-        testFailed(failureMessage + failureDetail);
+        if (TESTHARNESS) {
+            test(function () {
+                assert_true(false, failureMessage + failureDetail);
+            }, this.desc)
+        } else {
+            testFailed(failureMessage + failureDetail);
+        }
+
         throw failureMessage;
     };
 
     // Check if |target| is equal to |value|.
     //
     // Example:
     // Should('Zero', 0).beEqualTo(0);
     // Result:
     // "PASS Zero is equal to 0."
     ShouldModel.prototype.beEqualTo = function (value) {
@@ skipping 552 matching lines @@
             if (opts.hasOwnProperty('brief'))
                 _opts.brief = opts.brief;
             if (opts.hasOwnProperty('precision'))
                 _opts.precision = opts.precision;
         }
 
         return new ShouldModel(desc, target, _opts);
     };
 
 })();