Replace accessibility-developer-tools submodule with accessibility-audit directory containing just …

chrome/test/data/webui/accessibility_audit_browsertest.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 Tests to ensure that the accessibility audit and mechanisms
  * to enable/disable it work as expected.
  * @author aboxhall@google.com (Alice Boxhall)
  * @see test_api.js
  */
@@ skipping 22 matching lines @@
 
   /**
    * Number of expected accessibility warnings, if it should be checked,
    * otherwise null.
    * @type {?number}
    */
   expectedErrors: null,
 
   isAsync: false,
 
+  accessibilityAuditConfig: function() {
+      if (!this.accessibilityAuditConfig_) {
+          testing.Test.prototype.accessibilityAuditConfig.call(this);
+      }
+      this.accessibilityAuditConfig_.auditRulesToRun = ['lowContrastElements',
+                                                        'badAriaRole',
+                                                        'controlsWithoutLabel'];
+      return this.accessibilityAuditConfig_;
+  },
+
   tearDown: function() {
     var accessibilityResults = this.getAccessibilityResults();
     var numAccessibilityErrors = 0;
     var numAccessibilityWarnings = 0;
     for (var i = 0; i < accessibilityResults.length; i++) {
       var result = accessibilityResults[i];
       if (result.rule.severity == axs.constants.Severity.Warning)
         numAccessibilityWarnings++;
       else
         numAccessibilityErrors++;
@@ skipping 81 matching lines @@
   axs.Audit = audit.proxy();
 }
 
 /**
  * Creates an expectation that the global axs.Audit object will have its run()
  * method called |times| times.
  * This creates an interstitial mock axs.Audit object with the expectation, and
  * delegates to the real axs.Audit object to run the actual audit.
  * @param {number} times The number of times the audit is expected to run.
  */
-function expectAuditWillRun(times) {
+function expectAuditWillRun(times, auditConfig) {
   var audit = createMockAudit();
   var realAudit = axs.Audit;
   var expectedInvocation = audit.expects(exactly(times)).run(ANYTHING);
   var willArgs = [];
   for (var i = 0; i < times; i++)
-    willArgs.push(callFunction(realAudit.run));
+    willArgs.push(callFunction(realAudit.run, auditConfig));
   expectedInvocation.will.apply(expectedInvocation, willArgs);
   axs.Audit = audit.proxy();
   axs.Audit.createReport = realAudit.createReport;
   axs.Audit.auditResults = realAudit.auditResults;
   axs.Audit.accessibilityErrorMessage = realAudit.accessibilityErrorMessage;
 }
 
 // Test that an audit failure causes a test failure, if both
 // |runAccessibilityChecks| and |accessibilityIssuesAreErrors| are true.
 TEST_F('WebUIAccessibilityAuditBrowserTest_ShouldFail', 'testWithAuditFailures',
        function() {
-  expectAuditWillRun(1);
+  expectAuditWillRun(1, this.accessibilityAuditConfig());
   addAuditFailures();
 });
 
 // Test that the accessibility audit does not run if |runAccessibilityChecks|
 // is false.
 TEST_F('WebUIAccessibilityAuditBrowserTest',
        'testWithAuditFailures_a11yChecksDisabled',
        function() {
   expectAuditWillNotRun();
   this.disableAccessibilityChecks();
   addAuditFailures();
 });
 
 // Tests that the accessibility audit will run but not cause a test failure when
 // accessibilityIssuesAreErrors(false) is called in the test function
 TEST_F('WebUIAccessibilityAuditBrowserTest',
        'testWithAuditFailures_a11yIssuesAreWarnings',
         function() {
   this.accessibilityIssuesAreErrors = false;
-  expectAuditWillRun(1);
+  expectAuditWillRun(1, this.accessibilityAuditConfig());
   expectReportConsoleWarning();
 
   this.expectedWarnings = 1;
   this.expectedErrors = 2;
   this.enableAccessibilityChecks();
   addAuditFailures();
 });
 
 /**
  * Test fixture with |runAccessibilityChecks| set to false.
@@ skipping 35 matching lines @@
        function() {
   expectAuditWillNotRun();
   addAuditFailures();
 });
 
 // Test that the accessibility audit does run if the enableAccessibilityChecks()
 // method is called in the test function.
 TEST_F('WebUIAccessibilityAuditBrowserTest_TestsDisabledInFixture_ShouldFail',
        'testWithAuditFailures',
        function() {
-  expectAuditWillRun(1);
+  expectAuditWillRun(1, this.accessibilityAuditConfig());
   this.enableAccessibilityChecks();
   addAuditFailures();
 });
 
 // Test that the accessibility audit runs when the expectAccessibilityOk()
 // method is called.
 TEST_F('WebUIAccessibilityAuditBrowserTest_TestsDisabledInFixture',
        'testRunningAuditManually_noErrors',
        function() {
-  expectAuditWillRun(1);
+  expectAuditWillRun(1, this.accessibilityAuditConfig());
   expectAccessibilityOk();
 });
 
 // Test that calling expectAccessibilityOk() when there are accessibility issues
 // on the page causes the test to fail.
 TEST_F('WebUIAccessibilityAuditBrowserTest_TestsDisabledInFixture_ShouldFail',
        'testRunningAuditManually_withErrors',
        function() {
-  expectAuditWillRun(1);
+  expectAuditWillRun(1, this.accessibilityAuditConfig());
   addAuditFailures();
   expectAccessibilityOk();
 });
 
 // Test that calling expectAccessibilityOk() multiple times will cause the
 // accessibility audit to run multiple times.
 TEST_F('WebUIAccessibilityAuditBrowserTest_TestsDisabledInFixture',
        'testRunningAuditManuallySeveralTimes', function() {
-  expectAuditWillRun(2);
+  expectAuditWillRun(2, this.accessibilityAuditConfig());
   expectAccessibilityOk();
   expectAccessibilityOk();
 });
 
 /**
  * Test fixture with |accessibilityIssuesAreErrors| set to false.
  * @constructor
  * @extends {WebUIAccessibilityAuditBrowserTest}
  */
 function WebUIAccessibilityAuditBrowserTest_IssuesAreWarnings() {}
@@ skipping 17 matching lines @@
 
   testShouldFail: true
 };
 
 
 // Tests that the accessibility audit will run but not cause a test failure when
 // |accessibilityIssuesAreErrors| is false in the test fixture.
 TEST_F('WebUIAccessibilityAuditBrowserTest_IssuesAreWarnings',
        'testWithAuditFailures',
         function() {
-  expectAuditWillRun(1);
+  expectAuditWillRun(1, this.accessibilityAuditConfig());
   expectReportConsoleWarning();
   this.expectedWarnings = 1;
   this.expectedErrors = 2;
 
   this.enableAccessibilityChecks();
   addAuditFailures();
 });
 
 // Tests that the accessibility audit will run and call a test failure when
 // accessibilityIssuesAreErrors(true) is called in the test function.
 TEST_F('WebUIAccessibilityAuditBrowserTest_IssuesAreWarnings_ShouldFail',
        'testWithAuditFailuresAndIssuesAreErrors',
         function() {
-  expectAuditWillRun(1);
+  expectAuditWillRun(1, this.accessibilityAuditConfig());
   this.expectedWarnings = 1;
   this.expectedErrors = 2;
 
   this.accessibilityIssuesAreErrors = true;
   this.enableAccessibilityChecks();
 
   addAuditFailures();
 });
 
 // Tests that the accessibility audit will run twice if expectAccessibilityOk()
 // is called during the test function and |runAccessibilityChecks| is true in
 // the test fixture.
 TEST_F('WebUIAccessibilityAuditBrowserTest_IssuesAreWarnings',
        'testWithAuditFailuresAndExpectA11yOk',
         function() {
-  expectAuditWillRun(2);
+  expectAuditWillRun(2, this.accessibilityAuditConfig());
 
   expectAccessibilityOk();
 
   this.expectedWarnings = 1;
   this.expectedErrors = 2;
   expectReportConsoleWarning();
 
   this.enableAccessibilityChecks();
 
   addAuditFailures();
 });
 
 // Tests that parts of the page can be ignored on a per-audit rule basis.
 TEST_F('WebUIAccessibilityAuditBrowserTest_IssuesAreWarnings',
        'testCanIgnoreSelectors',
         function() {
   this.disableAccessibilityChecks();
-
   addAuditFailures();
   var accessibilityResults = [];
   try {
     assertAccessibilityOk(accessibilityResults);
   } catch (e) {
     // Expected error from assertion
   }
   expectEquals(3, accessibilityResults.length);
 
   accessibilityResults.length = 0;
 
   this.accessibilityAuditConfig().ignoreSelectors('lowContrastElements', 'P');
   try {
     assertAccessibilityOk(accessibilityResults);
   } catch (e) {
     // Expected error from assertion
   }
   expectEquals(2, accessibilityResults.length);
   for (var i = 0; i < accessibilityResults.length; i++) {
     expectFalse(accessibilityResults[i].rule.name == 'lowContrastElements');
   }
 });