Add a mechanism to ignore certain elements for accessibility audit on a per-test basis.

chrome/test/data/webui/test_api.js

 // Copyright (c) 2012 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 Library providing basic test framework functionality.
  */
 
 /**
  * Namespace for |Test|.
@@ skipping 24 matching lines @@
    */
   var currentTestArguments = [];
 
  /**
    * This class will be exported as testing.Test, and is provided to hold the
    * fixture's configuration and callback methods for the various phases of
    * invoking a test. It is called "Test" rather than TestFixture to roughly
    * mimic the gtest's class names.
    * @constructor
    */
-  function Test() {}
+  function Test() {};
 
   Test.prototype = {
     /**
      * The name of the test.
      */
     name: null,
 
     /**
      * When set to a string value representing a url, generate BrowsePreload
      * call, which will browse to the url and call fixture.preLoad of the
@@ skipping 62 matching lines @@
     /**
      * Extra libraries to add before loading this test file.
      * @type {Array.<string>}
      */
     extraLibraries: [],
 
     /**
      * Whether to run the accessibility checks.
      * @type {boolean}
      */
-    runAccessibilityChecks : true,
+    runAccessibilityChecks: true,
+
+    /**
+     * Configuration for the accessibility audit.
+     * @type {axs.AuditConfiguration}
+     */
+    accessibilityAuditConfig: new axs.AuditConfiguration(),
 
     /**
      * Whether to treat accessibility issues (errors or warnings) as test
      * failures. If true, any accessibility issues will cause the test to fail.
      * If false, accessibility issues will cause a console.warn.
      * Off by default to begin with; as we add the ability to suppress false
      * positives, we will transition this to true.
      * @type {boolean}
      */
     accessibilityIssuesAreErrors: false,
@@ skipping 99 matching lines @@
     },
 
     /**
      * Called to run the accessibility audit from the perspective of this
      * fixture.
      */
     runAccessibilityAudit: function() {
       if (!this.runAccessibilityChecks || typeof document === 'undefined')
         return;
 
-      if (!runAccessibilityAudit(this.a11yErrors_, this.a11yWarnings_)) {
+      if (!runAccessibilityAudit(this.a11yErrors_, this.a11yWarnings_,
+                                 this.accessibilityAuditConfig)) {
         var report = accessibilityAuditReport(this.a11yErrors_,
                                               this.a11yWarnings_);
         if (this.accessibilityIssuesAreErrors)
           throw new Error(report);
         else
           console.warn(report);
       }
     },
 
     /**
@@ skipping 617 matching lines @@
    * @throws {Error} always.
    */
   function assertNotReached(message) {
     helper.registerCall();
     throw new Error(helper.getCallMessage(message));
   }
 
   /**
    * Run an accessibility audit on the current page state.
    * @type {Function}
+   * @param {Array} a11yErrors
+   * @param {Array} a11yWarnings
+   * @param {axs.AuditConfigutarion=} opt_config
    * @return {boolean} Whether there were any errors or warnings
    * @private
    */
-  function runAccessibilityAudit(a11yErrors, a11yWarnings) {
-    var auditResults = axs.Audit.run();
+  function runAccessibilityAudit(a11yErrors, a11yWarnings, opt_config) {
+    var auditResults = axs.Audit.run(opt_config);
     for (var i = 0; i < auditResults.length; i++) {
       var auditResult = auditResults[i];
       if (auditResult.result == axs.constants.AuditResult.FAIL) {
         var auditRule = auditResult.rule;
         // TODO(aboxhall): more useful error messages (sadly non-trivial)
         if (auditRule.severity == axs.constants.Severity.Severe)
           a11yErrors.push(accessibilityErrorMessage(auditRule, auditResult));
         else
           a11yWarnings.push(accessibilityErrorMessage(auditRule, auditResult));
       }
@@ skipping 67 matching lines @@
     }
 
     var maxElements = Math.min(result.elements.length, 5);
     for (var i = 0; i < maxElements; i++)
       message += '\n' + axs.utils.getQuerySelectorText(result.elements[i]);
     return message;
   }
 
   /**
    * Asserts that the current page state passes the accessibility audit.
+   * @param {Array=} opt_errors Array to fill with errors, if desired.
+   * @param {Array=} opt_warnings Array to fill with warnings, if desired.
    */
-  function assertAccessibilityOk() {
+  function assertAccessibilityOk(opt_errors, opt_warnings) {
     helper.registerCall();
-    var a11yErrors = [];
-    var a11yWarnings = [];
-    if (!runAccessibilityAudit(a11yErrors, a11yWarnings))
+    var a11yErrors = opt_errors || [];
+    var a11yWarnings = opt_warnings || [];
+    var auditConfig = currentTestCase.fixture.accessibilityAuditConfig;
+    if (!runAccessibilityAudit(a11yErrors, a11yWarnings, auditConfig))
       throw new Error(accessibilityAuditReport(a11yErrors, a11yWarnings));
   }
 
   /**
    * Creates a function based upon a function that thows an exception on
    * failure. The new function stuffs any errors into the |errors| array for
    * checking by runTest. This allows tests to continue running other checks,
    * while failing the overall test if any errors occurrred.
    * @param {Function} assertFunc The function which may throw an Error.
    * @return {function(...*):bool} A function that applies its arguments to
@@ skipping 604 matching lines @@
   exports.TEST = TEST;
   exports.TEST_F = TEST_F;
   exports.RUNTIME_TEST_F = TEST_F;
   exports.GEN = GEN;
   exports.GEN_INCLUDE = GEN_INCLUDE;
   exports.WhenTestDone = WhenTestDone;
 
   // Import the Mock4JS helpers.
   Mock4JS.addMockSupport(exports);
 })(this);