Implement should().notBeConstantValueOf(x)

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
@@ skipping 523 matching lines @@
               + ' more errors.';
             break;
           }
         }
       }
 
       return this._assert(passed, passDetail, failDetail);
     }
 
     /**
+     * Check if |actual| array is not filled with a constant |expected| value.
+     *
+     * @example
+     *   should([1, 0, 1]).notBeConstantValueOf(1);
+     *   should([0, 0, 0]).notBeConstantValueOf(0);
+     *
+     * @result
+     *   "PASS   [1,0,1] contains values that differ from the constant 1."

[Raymond Toy, 2017/01/06 18:50:12]

This doesn't seem to match what the code is producing.  Make it match.

[hongchan, 2017/01/06 19:14:42]

Done.

+     *   "FAIL   [0,0,0] contains only the constant 0."
+     */
+    notBeConstantValueOf () {
+      this._processArguments(arguments);
+      this._printActualForFailure = false;
+
+      let passed = true;
+      let passDetail, failDetail;

[Raymond Toy, 2017/01/06 18:50:12]

Should this be two separate lets?  Couldn't find anything in the Javascript
style guide, but the C++ style says separate declarations.

[hongchan, 2017/01/06 19:14:42]

You are correct. Should I fix this instance only?

+      let differences = {};

[Raymond Toy, 2017/01/06 18:50:12]

Would it be better if differences were an (empty) array and you just pushed the
index onto it (in line 564 below)?

[hongchan, 2017/01/06 19:14:42]

Not sure. I thought you might want to print out the index and the value that
differ from the expected value. With an array, we will lose the record of actual
values. I am open, but not sure if the change gives us any benefit.

+
+      for (let index in this._actual) {
+        if (this._actual[index] !== this._expected)
+          differences[index] = this._actual[index];
+      }
+
+      let numberOfDifferences = Object.keys(differences).length;
+      passed = numberOfDifferences > 0;
+
+      if (passed) {
+        let valueString = {
+          noun: numberOfDifferences > 1 ? 'values' : 'value',
+          verb: numberOfDifferences > 1 ? 'differ' : 'differs'
+        };
+        passDetail = '${actual} contains ' + numberOfDifferences + ' ' +
+            valueString.noun + ' that ' + valueString.verb + ' from the ' +
+            'constant ${expected}.';
+      } else {
+        failDetail = '${actual} contains only the constant ${expected}.';

[Raymond Toy, 2017/01/06 18:50:12]

It might be better, maybe, to say "${actual} should have contain at least one
value different from ${expected}".  When reading the output, we know it fails,
but it's not so easy to determine why from this sentence.  I think the
rephrasing makes it clear that the actual result should not be a constant. 
(Feel free to phrase my suggestion differently to make it clearer.)

[hongchan, 2017/01/06 19:14:42]

Thanks, your phrasing is much better. Done.

+      }
+
+      return this._assert(passed, passDetail, failDetail);
+    }
+
+    /**
      * Check if |actual| array is identical to |expected| array element-wise.
      *
      * @example
      *   should([1, 2, 3]).beEqualToArray([1, 2, 3]);
      *
      * @result
      *   "[1,2,3] is identical to the array [1,2,3]."
      */
     beEqualToArray () {
       this._processArguments(arguments);
@@ skipping 476 matching lines @@
         _logError('this test requires the explicit comparison with the '
             + 'expected result when it runs with run-webkit-tests.');
       }
 
       return new TaskRunner();
     }
 
   };
 
 })();