Additional unit test for audit.js: failure cases and logging examples.

third_party/WebKit/LayoutTests/webaudio/resources/audit.js

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 
 /**
  * @fileOverview  WebAudio layout test utility library. Built around W3C's
  *                testharness.js. Includes asynchronous test task manager,
  *                assertion utilities.
  * @dependency    testharness.js
- * @seealso       webaudio/unit-tests/audit.html for actual examples.
  */
 
 
 (function () {
 
   'use strict';
 
   // Selected properties from testharness.js
   let testharnessProperties = [
     'test', 'async_test', 'promise_test', 'promise_rejects',
     '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])) {
+    if (!self.hasOwnProperty(testharnessProperties[name]))
       throw new Error('Cannot proceed. testharness.js is not loaded.');
-      break;
-    }
   }
 })();
 
 
-/**
- * @class Audit
- * @description A WebAudio layout test task manager.
- * @example
- *   let audit = Audit.createTaskRunner();
- *   audit.define('first-task', function (task, should) {
- *     task.describe('the first task');
- *     should(someValue).beEqualTo(someValue);
- *     task.done();
- *   });
- *   audit.run();
- */
 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);
@@ skipping 171 matching lines @@
      *
      * @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.');
+          '${actual} does not exist.');
     }
 
     /**
      * Check if |actual| operation wrapped in a function throws an exception
      * with a expected error type correctly. |expected| is optional.
      *
      * @example
      *   should(() => { let a = b; }, 'A bad code').throw();
      *   should(() => { let c = d; }, 'Assigning d to c.')
      *       .throw('ReferenceError');
      *
      * @result
      *   "PASS   A bad code threw an exception of ReferenceError."
      *   "PASS   Assigning d to c threw ReferenceError."
      */
     throw () {
       this._processArguments(arguments);
 
       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.';
+        failDetail = '${actual} did not throw an exception.';
       } catch (error) {
         if (this._expected === undefined) {
           didThrowCorrectly = true;
           passDetail = '${actual} threw an exception of ' + error.name + '.';
         } else if (error.name === this._expected) {
           didThrowCorrectly = true;
           passDetail = '${actual} threw ${expected} : "' + error.message + '".';
         } else {
           didThrowCorrectly = false;
           failDetail = '${actual} threw "' + error.name
@@ skipping 16 matching lines @@
      */
     notThrow () {
       let didThrowCorrectly = false;
       let passDetail, failDetail;
 
       try {
         this._actual();
         passDetail = '${actual} did not throw an exception.';
       } catch (error) {
         didThrowCorrectly = true;
-        failDetail = '${actual} threw ' + error.name + ': '
-            + error.message + '.';
+        failDetail = '${actual} incorrectly threw ' + error.name + ': "'
+            + error.message + '".';
       }
 
       return this._assert(!didThrowCorrectly, passDetail, failDetail);
     }
 
     /**
      * Check if |actual| promise is resolved correctly.
      *
      * @example
      *   should('My promise', promise).beResolve().then(nextStuff);
      *
      * @result
      *   "PASS   My promise resolved correctly."
      *   "FAIL X My promise rejected *INCORRECTLY* with _ERROR_."
      */
     beResolved () {
       return this._actual.then(function () {
           this._assert(true, '${actual} resolved correctly.', null);
         }.bind(this), function (error) {
           this._assert(false, null,
-              '${actual} rejected *INCORRECTLY* with ' + error + '.');
+              '${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*.');
+          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| 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.');
+          '${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.');
+          '${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}.');
+          '${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."
+     *   "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}.');
+          '${actual} should not be equal to ${expected}.');
     }
 
     /**
      * 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}.'
+           '${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}.'
+           '${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}.'
+           '${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}.'
+           '${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
@@ skipping 11 matching lines @@
           errors[index] = this._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} contains ' + numberOfErrors
-          + ' values that are *NOT* equal to ${expected}: ';
+        failDetail = '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;
           }
         }
@@ skipping 13 matching lines @@
      */
     beEqualToArray () {
       this._processArguments(arguments);
 
       let passed = true;
       let passDetail, failDetail;
       let errorIndices = [];
 
       if (this._actual.length !== this._expected.length) {
         passed = false;
-        failDetail = 'The array length does *NOT* match.';
+        failDetail = 'The array length does not match.';
         return this._assert(passed, passDetail, failDetail);
       }
 
       for (let index in this._actual) {
         if (this._actual[index] !== this._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} contains ' + errorIndices.length
-          + ' values that are *NOT* equal to ${expected}: ';
-        failDetail += '\n\tIndex\tActual\t\t\tExpected';
+        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 ' + (numberOfErrors - counter)
               + ' more errors.';
             break;
           }
         }
@@ skipping 10 matching lines @@
      *   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);
 
       let passed = true;
-      let indexActual = 0, indexExpected = 0;
+      let indexedActual = [];
+      let firstErrorIndex = null;
 
-      while (indexActual < this._actual.length
-          && indexExpected < this._expected.length) {
-        if (this._actual[indexActual] === this._expected[indexExpected]) {
-          indexActual++;
-        } else {
-          indexExpected++;
+      // 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];
         }
       }
 
-      passed = !(indexActual < this._actual.length - 1
-          || indexExpected < this._expected.length - 1);
+      // Compare against the expected sequence.
+      for (let j = 0; j < this._expected.length; j++) {
+        if (this._expected[j] !== indexedActual[j].value) {
+          firstErrorIndex = indexedActual[j].index;
+          passed = false;
+          break;
+        }
+      }
 
       return this._assert(
           passed,
           '${actual} contains all the expected values in the correct order: '
             + '${expected}.',
-          '${actual} contains an unexpected value of '
-            + this._actual[indexActual] + ' at index ' + indexActual + '.');
+          '${actual} expected to have the value sequence of ${expected} but '
+            + 'got ' + this._actual[firstErrorIndex] + ' at index '
+            + firstErrorIndex + '.');
     }
 
     /**
      * 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
@@ skipping 36 matching lines @@
      */
     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 ${expected} within an error of ${threshold}: ' +
-          '${actual} with error of ${threshold}.');
+          error <= this._options.threshold,
+          '${actual} is ${expected} within an error of ${threshold}.',
+          '${actual} is not close to ${expected} within an error of ' +
+            '${threshold}');
     }
 
     /**
      * 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
@@ skipping 281 matching lines @@
       }
 
       // Start the first task.
       this._currentTaskIndex = 0;
       this._runNextTask();
     }
 
   }
 
 
+  /**
+   * @class Audit
+   * @description A WebAudio layout test task manager.
+   * @example
+   *   let audit = Audit.createTaskRunner();
+   *   audit.define('first-task', function (task, should) {
+   *     task.describe('the first task');
+   *     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 () {
+    createTaskRunner: function (options) {
+      if (options && options.requireResultFile == true) {
+        _logError('this test requires the explicit comparison with the '
+            + 'expected result when it runs with run-webkit-tests.');
+      }
+
       return new TaskRunner();
     }
 
   };
 
 })();