[Switch Access] Update existing Javascript tests

This change adds error messages to all of the asserts in each existing
JavaScript test and updating the testing infrastructure in small ways.

Bug: 897365
Change-Id: Id83c9975d734d785524beb1370c5415ab4d0c900
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1865479
Commit-Queue: Anastasia Helfinstein <anastasi@google.com>
Reviewed-by: Akihiro Ota <akihiroota@chromium.org>
Cr-Commit-Position: refs/heads/master@{#709172}

chrome/browser/resources/chromeos/switch_access/auto_scan_manager_test.extjs

@@ -54,109 +54,120 @@ SwitchAccessAutoScanManagerTest.prototype = {
 };
 
 TEST_F('SwitchAccessAutoScanManagerTest', 'SetEnabled', function() {
-  this.runWithLoadedTree('data:text/html;charset=utf-8,',
-      function(desktop) {
-        assertFalse(this.autoScanManager.isRunning());
-        assertEquals(0, switchAccess.moveForwardCount);
-        assertEquals(0, intervalCount);
-
-        switchAccess.onMoveForwardForTesting_ =
-          this.newCallback(function() {
-            assertTrue(this.autoScanManager.isRunning());
-            assertGT(switchAccess.moveForwardCount, 0);
-            assertEquals(1, intervalCount);
-          });
-
-        this.autoScanManager.setEnabled(true);
-        assertTrue(this.autoScanManager.isRunning());
-        assertEquals(1, intervalCount);
-      }
-  );
+  this.runWithLoadedTree('', (desktop) => {
+    assertFalse(this.autoScanManager.isRunning(),
+        'Auto scan manager is running prematurely');
+    assertEquals(0, switchAccess.moveForwardCount,
+        'Incorrect initialization of moveForwardCount');
+    assertEquals(0, intervalCount, 'Incorrect initialization of intervalCount');
+
+    switchAccess.onMoveForwardForTesting_ =
+      this.newCallback(() => {
+        assertTrue(this.autoScanManager.isRunning(),
+            'Auto scan manager has stopped running');
+        assertGT(switchAccess.moveForwardCount, 0,
+            'Switch Access has not moved forward');
+        assertEquals(1, intervalCount,
+            'The number of intervals is no longer exactly 1');
+      });
+
+    this.autoScanManager.setEnabled(true);
+    assertTrue(this.autoScanManager.isRunning(),
+        'Auto scan manager is not running');
+    assertEquals(1, intervalCount, 'There is not exactly 1 interval');
+  });
 });
 
 TEST_F('SwitchAccessAutoScanManagerTest', 'SetEnabledMultiple', function() {
-  this.runWithLoadedTree('data:text/html;charset=utf-8,',
-      function(desktop) {
-        assertFalse(this.autoScanManager.isRunning());
-        assertEquals(0, intervalCount);
-
-        this.autoScanManager.setEnabled(true);
-        this.autoScanManager.setEnabled(true);
-        this.autoScanManager.setEnabled(true);
-
-        assertTrue(this.autoScanManager.isRunning());
-        assertEquals(1, intervalCount);
-      }
-  );
+  this.runWithLoadedTree('', (desktop) => {
+    assertFalse(this.autoScanManager.isRunning(),
+        'Auto scan manager is running prematurely');
+    assertEquals(0, intervalCount, 'Incorrect initialization of intervalCount');
+
+    this.autoScanManager.setEnabled(true);
+    this.autoScanManager.setEnabled(true);
+    this.autoScanManager.setEnabled(true);
+
+    assertTrue(this.autoScanManager.isRunning(),
+        'Auto scan manager is not running');
+    assertEquals(1, intervalCount, 'There is not exactly 1 interval');
+  });
 });
 
 TEST_F('SwitchAccessAutoScanManagerTest', 'EnableAndDisable', function() {
-  this.runWithLoadedTree('data:text/html;charset=utf-8,',
-      function(desktop) {
-        assertFalse(this.autoScanManager.isRunning());
-        assertEquals(0, intervalCount);
-
-        this.autoScanManager.setEnabled(true);
-        assertTrue(this.autoScanManager.isRunning());
-        assertEquals(1, intervalCount);
-
-
-        this.autoScanManager.setEnabled(false);
-        assertFalse(this.autoScanManager.isRunning());
-        assertEquals(0, intervalCount);
-      }
-  );
+  this.runWithLoadedTree('', (desktop) => {
+    assertFalse(this.autoScanManager.isRunning(),
+        'Auto scan manager is running prematurely');
+    assertEquals(0, intervalCount, 'Incorrect initialization of intervalCount');
+
+    this.autoScanManager.setEnabled(true);
+    assertTrue(this.autoScanManager.isRunning(),
+        'Auto scan manager is not running');
+    assertEquals(1, intervalCount, 'There is not exactly 1 interval');
+
+    this.autoScanManager.setEnabled(false);
+    assertFalse(this.autoScanManager.isRunning(),
+        'Auto scan manager did not stop running');
+    assertEquals(0, intervalCount, 'Interval was not removed');
+  });
 });
 
 TEST_F('SwitchAccessAutoScanManagerTest', 'RestartIfRunningMultiple', function() {
-  this.runWithLoadedTree('data:text/html;charset=utf-8,',
-      function(desktop) {
-        assertFalse(this.autoScanManager.isRunning());
-        assertEquals(0, switchAccess.moveForwardCount);
-        assertEquals(0, intervalCount);
-
-        this.autoScanManager.setEnabled(true);
-        this.autoScanManager.restartIfRunning();
-        this.autoScanManager.restartIfRunning();
-        this.autoScanManager.restartIfRunning();
-
-        assertTrue(this.autoScanManager.isRunning());
-        assertEquals(1, intervalCount);
-      }
-  );
+  this.runWithLoadedTree('', (desktop) => {
+    assertFalse(this.autoScanManager.isRunning(),
+        'Auto scan manager is running prematurely');
+    assertEquals(0, switchAccess.moveForwardCount,
+        'Incorrect initialization of moveForwardCount');
+    assertEquals(0, intervalCount, 'Incorrect initialization of intervalCount');
+
+    this.autoScanManager.setEnabled(true);
+    this.autoScanManager.restartIfRunning();
+    this.autoScanManager.restartIfRunning();
+    this.autoScanManager.restartIfRunning();
+
+    assertTrue(this.autoScanManager.isRunning(),
+        'Auto scan manager is not running');
+    assertEquals(1, intervalCount, 'There is not exactly 1 interval');
+  });
 });
 
-TEST_F('SwitchAccessAutoScanManagerTest', 'RestartIfRunningWhenOff', function() {
-  this.runWithLoadedTree('data:text/html;charset=utf-8,',
-      function(desktop) {
-        assertFalse(this.autoScanManager.isRunning());
-        this.autoScanManager.restartIfRunning();
-        assertFalse(this.autoScanManager.isRunning());
-      }
-  );
+TEST_F('SwitchAccessAutoScanManagerTest', 'RestartIfRunningWhenOff', function()
+{
+  this.runWithLoadedTree('', (desktop) => {
+    assertFalse(this.autoScanManager.isRunning(),
+        'Auto scan manager is running at start.');
+    this.autoScanManager.restartIfRunning();
+    assertFalse(this.autoScanManager.isRunning(),
+        'Auto scan manager enabled by restartIfRunning');
+  });
 });
 
 TEST_F('SwitchAccessAutoScanManagerTest', 'SetDefaultScanTime', function() {
-  this.runWithLoadedTree('data:text/html;charset=utf-8,',
-      function(desktop) {
-        assertFalse(this.autoScanManager.isRunning());
-        assertEquals(UNDEFINED_INTERVAL_DELAY, intervalDelay);
-
-        this.autoScanManager.setDefaultScanTime(2);
-        assertFalse(this.autoScanManager.isRunning());
-        assertEquals(2, this.autoScanManager.defaultScanTime_);
-        assertEquals(UNDEFINED_INTERVAL_DELAY, intervalDelay);
-
-        this.autoScanManager.setEnabled(true);
-        assertTrue(this.autoScanManager.isRunning());
-        assertEquals(2, this.autoScanManager.defaultScanTime_);
-        assertEquals(2, intervalDelay);
-
-        this.autoScanManager.setDefaultScanTime(5);
-        assertTrue(this.autoScanManager.isRunning());
-        assertEquals(5, this.autoScanManager.defaultScanTime_);
-        assertEquals(5, intervalDelay);
-      }
-  );
+  this.runWithLoadedTree('', (desktop) => {
+    assertFalse(this.autoScanManager.isRunning(),
+        'Auto scan manager is running prematurely');
+    assertEquals(UNDEFINED_INTERVAL_DELAY, intervalDelay,
+        'Interval delay improperly initialized');
+
+    this.autoScanManager.setDefaultScanTime(2);
+    assertFalse(this.autoScanManager.isRunning(),
+        'Setting default scan time started auto-scanning');
+    assertEquals(2, this.autoScanManager.defaultScanTime_,
+        'Default scan time set improperly');
+    assertEquals(UNDEFINED_INTERVAL_DELAY, intervalDelay,
+        'Interval delay set prematurely');
+
+    this.autoScanManager.setEnabled(true);
+    assertTrue(this.autoScanManager.isRunning(), 'Auto scan did not start');
+    assertEquals(2, this.autoScanManager.defaultScanTime_,
+        'Default scan time has changed');
+    assertEquals(2, intervalDelay, 'Interval delay not set');
+
+    this.autoScanManager.setDefaultScanTime(5);
+    assertTrue(this.autoScanManager.isRunning(), 'Auto scan stopped');
+    assertEquals(5, this.autoScanManager.defaultScanTime_,
+        'Default scan time did not change when set a second time');
+    assertEquals(5, intervalDelay, 'Interval delay did not update');
+  });
 });
 

chrome/browser/resources/chromeos/switch_access/navigation_manager_test.extjs

@@ -38,12 +38,10 @@ function currentNode() {
 
 TEST_F('SwitchAccessNavigationManagerTest', 'SelectButton', function() {
   const website =
-      `data:text/html;charset=utf-8,
-      <button id="test" aria-pressed="false">First Button</button>
-      <button>Second Button</button>
+      `<button id="test" aria-pressed=false>First Button</button>
       <script>
-        var state = false;
-        var button = document.getElementById("test");
+        let state = false;
+        let button = document.getElementById("test");
         button.onclick = () => {
           state = !state;
           button.setAttribute("aria-pressed", state);
@@ -54,13 +52,18 @@ TEST_F('SwitchAccessNavigationManagerTest', 'SelectButton', function() {
     moveToPageContents();
 
     let node = currentNode().automationNode;
-    assertTrue(!!node);
-    assertEquals(node.name, "First Button");
+    assertTrue(!!node, 'Node is invalid');
+    assertEquals(node.name, 'First Button', 'Did not find the right node');
 
     node.addEventListener(
       chrome.automation.EventType.CHECKED_STATE_CHANGED,
-      this.newCallback((event) => assertEquals(node.name, event.target.name)));
+      this.newCallback((event) => {
+        assertEquals(node.name, event.target.name,
+            'Checked state changed on unexpected node');
+      }));
 
-    switchAccess.selectCurrentNode();
+    // The event listener is not set instantaneously. Set a timeout of 0 to
+    // yield to pending processes.
+    setTimeout(this.newCallback(switchAccess.selectCurrentNode), 0);
   });
 });

chrome/browser/resources/chromeos/switch_access/rect_helper_unittest.gtestjs

@@ -28,17 +28,27 @@ TEST_F('SwitchAccessRectHelperUnitTest', 'Equals', function() {
   const rect5 = {left: 0, top: 0, width: 11, height: 10};
   const rect6 = {left: 0, top: 0, width: 10, height: 11};
 
-  assertTrue(RectHelper.areEqual(rect1, rect1));
-  assertTrue(RectHelper.areEqual(rect1, rect2));
-  assertTrue(RectHelper.areEqual(rect2, rect1));
-  assertFalse(RectHelper.areEqual(rect1, rect3));
-  assertFalse(RectHelper.areEqual(rect3, rect1));
-  assertFalse(RectHelper.areEqual(rect1, rect4));
-  assertFalse(RectHelper.areEqual(rect4, rect1));
-  assertFalse(RectHelper.areEqual(rect1, rect5));
-  assertFalse(RectHelper.areEqual(rect5, rect1));
-  assertFalse(RectHelper.areEqual(rect1, rect6));
-  assertFalse(RectHelper.areEqual(rect6, rect1));
+  assertTrue(RectHelper.areEqual(rect1, rect1), 'areEqual should be reflexive');
+  assertTrue(RectHelper.areEqual(rect1, rect2),
+      'Rect1 and Rect2 should be equal');
+  assertTrue(RectHelper.areEqual(rect2, rect1),
+      'areEqual should be symmetric (1)');
+  assertFalse(RectHelper.areEqual(rect1, rect3),
+      'rect1 and rect3 should not be equal');
+  assertFalse(RectHelper.areEqual(rect3, rect1),
+      'areEqual should be symmetric (2)');
+  assertFalse(RectHelper.areEqual(rect1, rect4),
+      'rect1 and rect4 should not be equal');
+  assertFalse(RectHelper.areEqual(rect4, rect1),
+      'areEqual should be symmetric (3)');
+  assertFalse(RectHelper.areEqual(rect1, rect5),
+      'rect1 and rect5 should not be equal');
+  assertFalse(RectHelper.areEqual(rect5, rect1),
+      'areEqual should be symmetric (4)');
+  assertFalse(RectHelper.areEqual(rect1, rect6),
+      'rect1 and rect6 should not be equal');
+  assertFalse(RectHelper.areEqual(rect6, rect1),
+      'areEqual should be symmetric (5)');
 });
 
 TEST_F('SwitchAccessRectHelperUnitTest', 'Center', function() {
@@ -46,12 +56,12 @@ TEST_F('SwitchAccessRectHelperUnitTest', 'Center', function() {
   const rect2 = {left: 10, top: 20, width: 10, height: 40};
 
   const center1 = RectHelper.center(rect1);
-  assertEquals(5, center1.x);
-  assertEquals(5, center1.y);
+  assertEquals(5, center1.x, 'Center1 x should be 5');
+  assertEquals(5, center1.y, 'Center1 y should be 5');
 
   const center2 = RectHelper.center(rect2);
-  assertEquals(15, center2.x);
-  assertEquals(40, center2.y);
+  assertEquals(15, center2.x, 'Center2 x should be 15');
+  assertEquals(40, center2.y, 'Center2 y should be 40');
 });
 
 TEST_F('SwitchAccessRectHelperUnitTest', 'Union', function() {
@@ -63,19 +73,23 @@ TEST_F('SwitchAccessRectHelperUnitTest', 'Union', function() {
 
   // When one rect entirely contains the other, that rect is returned.
   const union_1_2 = RectHelper.union(rect1, rect2);
-  assertTrue(RectHelper.areEqual(rect1, union_1_2));
+  assertTrue(RectHelper.areEqual(rect1, union_1_2),
+      'Union of rect1 and rect2 should be rect1');
 
   const union_1_3 = RectHelper.union(rect1, rect3);
   let expected = {left: 0, top: 0, width: 20, height: 60};
-  assertTrue(RectHelper.areEqual(expected, union_1_3));
+  assertTrue(RectHelper.areEqual(expected, union_1_3),
+      'Union of rect1 and rect3 does not match expected value');
 
   const union_1_4 = RectHelper.union(rect1, rect4);
   expected = {left: 0, top: 0, width: 10, height: 20};
-  assertTrue(RectHelper.areEqual(expected, union_1_4));
+  assertTrue(RectHelper.areEqual(expected, union_1_4),
+      'Union of rect1 and rect4 does not match expected value');
 
   const union_1_5 = RectHelper.union(rect1, rect5);
   expected = {left: 0, top: 0, width: 15, height: 15};
-  assertTrue(RectHelper.areEqual(expected, union_1_5));
+  assertTrue(RectHelper.areEqual(expected, union_1_5),
+      'Union of rect1 and rect5 does not match expected value');
 });
 
 TEST_F('SwitchAccessRectHelperUnitTest', 'UnionAll', function() {
@@ -87,64 +101,52 @@ TEST_F('SwitchAccessRectHelperUnitTest', 'UnionAll', function() {
 
   const union1 = RectHelper.unionAll([rect1, rect2, rect3, rect4]);
   let expected = {left: 0, top: 0, width: 20, height: 20};
-  assertTrue(RectHelper.areEqual(expected, union1));
+  assertTrue(RectHelper.areEqual(expected, union1),
+      'Union of rects 1-4 does not match expected value');
 
   const union2 = RectHelper.unionAll([rect1, rect2, rect3, rect4, rect5]);
   expected = {left: 0, top: 0, width: 100, height: 20};
-  assertTrue(RectHelper.areEqual(expected, union2));
+  assertTrue(RectHelper.areEqual(expected, union2),
+      'Union of rects 1-5 does not match expected value');
 });
 
-TEST_F('SwitchAccessRectHelperUnitTest',
-       'ExpandToFitWithPadding_OuterContainedInInner', function() {
+TEST_F('SwitchAccessRectHelperUnitTest', 'ExpandToFitWithPadding', function() {
   const padding = 5;
-  const inner = {left: 100, top: 100, width: 100, height: 100};
-
-  const outer = {left: 120, top: 120, width: 20, height: 20};
+  let inner = {left: 100, top: 100, width: 100, height: 100};
+  let outer = {left: 120, top: 120, width: 20, height: 20};
   let expected = {left: 95, top: 95, width: 110, height: 110};
-
   assertTrue(RectHelper.areEqual(expected,
-      RectHelper.expandToFitWithPadding(padding, outer, inner)));
-});
-
-TEST_F('SwitchAccessRectHelperUnitTest',
-       'ExpandToFitWithPadding_OuterContainsInner', function() {
-  const padding = 5;
-  const inner = {left: 100, top: 100, width: 100, height: 100};
-  const outer = {left: 50, top: 50, width: 200, height: 200};
+      RectHelper.expandToFitWithPadding(padding, outer, inner)),
+      'When outer is contained in inner, expandToFitWithPadding does not ' +
+      'match expected value');
 
+  inner = {left: 100, top: 100, width: 100, height: 100};
+  outer = {left: 50, top: 50, width: 200, height: 200};
   assertTrue(RectHelper.areEqual(outer,
-      RectHelper.expandToFitWithPadding(padding, outer, inner)));
-});
+      RectHelper.expandToFitWithPadding(padding, outer, inner)),
+      'When outer contains inner, expandToFitWithPadding should equal outer');
 
-TEST_F('SwitchAccessRectHelperUnitTest', 'ExpandToFitWithPadding_NoOverlap',
-       function() {
-  const padding = 5;
-  const inner = {left: 100, top: 100, width: 100, height: 100};
-  const outer = {left: 10, top: 10, width: 10, height: 10};
+  inner = {left: 100, top: 100, width: 100, height: 100};
+  outer = {left: 10, top: 10, width: 10, height: 10};
   expected = {left: 10, top: 10, width: 195, height: 195};
-
   assertTrue(RectHelper.areEqual(expected,
-      RectHelper.expandToFitWithPadding(padding, outer, inner)));
-});
+      RectHelper.expandToFitWithPadding(padding, outer, inner)),
+      'When there is no overlap, expandToFitWithPadding does not match ' +
+      'expected value');
 
-TEST_F('SwitchAccessRectHelperUnitTest', 'ExpandToFitWithPadding_Overlap',
-       function() {
-  const padding = 5;
-  const inner = {left: 100, top: 100, width: 100, height: 100};
-  const outer = {left: 120, top: 50, width: 200, height: 200};
+  inner = {left: 100, top: 100, width: 100, height: 100};
+  outer = {left: 120, top: 50, width: 200, height: 200};
   expected = {left: 95, top: 50, width: 225, height: 200};
-
   assertTrue(RectHelper.areEqual(expected,
-      RectHelper.expandToFitWithPadding(padding, outer, inner)));
-});
+      RectHelper.expandToFitWithPadding(padding, outer, inner)),
+      'When there is some overlap, expandToFitWithPadding does not match ' +
+      'expected value');
 
-TEST_F('SwitchAccessRectHelperUnitTest', 'ExpandToFitWithPadding_WithinPadding',
-       function() {
-  const padding = 5;
-  const inner = {left: 100, top: 100, width: 100, height: 100};
-  const outer = {left: 97, top: 95, width: 108, height: 110};
+  inner = {left: 100, top: 100, width: 100, height: 100};
+  outer = {left: 97, top: 95, width: 108, height: 110};
   expected = {left: 95, top: 95, width: 110, height: 110};
-
   assertTrue(RectHelper.areEqual(expected,
-      RectHelper.expandToFitWithPadding(padding, outer, inner)));
+      RectHelper.expandToFitWithPadding(padding, outer, inner)),
+      'When outer contains inner but without sufficient padding, ' +
+      'expandToFitWithPadding does not match expected value');
 });

chrome/browser/resources/chromeos/switch_access/switch_access_e2e_test_base.js

@@ -83,6 +83,11 @@ SwitchAccessE2ETest.prototype = {
    *     the desktop node once the document is ready.
    */
   runWithLoadedTree: function(url, callback) {
+    const prefix = url.substring(0, 4);
+    if (prefix !== 'http' && prefix !== 'data') {
+      url = 'data:text/html;charset=utf-8,' + url;
+    }
+
     callback = this.newCallback(callback);
     chrome.automation.getDesktop(function(desktopRootNode) {
       var createParams = {active: true, url: url};