Added unit tests for tree_walker and automation_predicate.

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

 // Copyright 2017 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.
 
 /**
  * Test fixture for tree_walker.js.
  * @constructor
  * @extends {testing.Test}
  */
 function AutomationTreeWalkerUnitTest () {
   testing.Test.call(this);
 };
 
 AutomationTreeWalkerUnitTest.prototype = {
   __proto__: testing.Test.prototype,
 
   /** @override */
   extraLibraries: [
     'tree_walker.js',
   ],
 
   /** @override */
   browsePreload: DUMMY_URL,
 
   getSampleTree: function() {
     let loc = {left: 0, top: 0, width: 0, height: 0};
     // root
-    //   middle1
-    //     leaf1
-    //     leaf2
-    //     leaf3
-    //   middle2
-    //     leaf4
-    //     leaf5
+    //   upper1

[David Tseng, 2017/05/09 16:49:21]

Suggestion: write a general method to create the fake tree from a json object
e.g.
{
  role: 'webView',
  children: [
    {
      role: 'staticText'
    }, ...
  ], ...

then you don't need to duplicate the structure in a comment and do hand rolled
connections of tree properties.

[elichtenberg, 2017/05/09 23:35:30]

I tried this, but it wasn't very readable, and it would've taken additional code
to get access to each of the nodes in the tree like we have now. Also, I usually
set some of the properties of the nodes in the tests themselves rather than just
in getSampleTree, so setting the properties through JSON isn't as helpful for
that.

Instead, I created a test support file with a "setChildren" function that is
used to connect all of the nodes in the tree pretty concisely. The comment
showing the structure of the tree was a lot more readable than just building the
tree in JSON, so I figured I would keep that. The "setChildren" function ends up
removing a lot of the code inside getSampleTree though, so I think this function
is in a good place. What do you think?

+    //     middle1
+    //       lower1
+    //         leaf1
+    //         leaf2
+    //         leaf3
+    //       lower2
+    //         leaf4
+    //         leaf5
+    //     middle2
+    //       lower3
+    //         leaf6
+    //         leaf7
+    //   upper2
+    //     leaf8
     let root = {location: loc, state: {}};
+    let upper1 = {location: loc, state: {}};
+    let upper2 = {location: loc, state: {}};
     let middle1 = {location: loc, state: {}};
     let middle2 = {location: loc, state: {}};
+    let lower1 = {location: loc, state: {}};
+    let lower2 = {location: loc, state: {}};
+    let lower3 = {location: loc, state: {}};
     let leaf1 = {location: loc, state: {}};
     let leaf2 = {location: loc, state: {}};
     let leaf3 = {location: loc, state: {}};
     let leaf4 = {location: loc, state: {}};
     let leaf5 = {location: loc, state: {}};
+    let leaf6 = {location: loc, state: {}};
+    let leaf7 = {location: loc, state: {}};
+    let leaf8 = {location: loc, state: {}};
 
-    root.firstChild = middle1;
-    root.lastChild = middle2;
+    root.firstChild = upper1;
+    root.lastChild = upper2;
 
-    middle1.parent = root;
-    middle2.parent = root;
+    upper1.parent = root;
+    upper2.parent = root;
+    upper1.nextSibling = upper2;
+    upper2.previousSibling = upper1;
+    upper1.firstChild = middle1;
+    upper1.lastChild = middle2;
+    upper2.firstChild = leaf8;
+    upper2.lastChild = leaf8;
+
+    middle1.parent = upper1;
+    middle2.parent = upper1;
     middle1.nextSibling = middle2;
     middle2.previousSibling = middle1;
-    middle1.firstChild = leaf1;
-    middle1.lastChild = leaf3;
-    middle2.firstChild = leaf4;
-    middle2.lastChild = leaf5;
+    middle1.firstChild = lower1;
+    middle1.lastChild = lower2;
+    middle2.firstChild = lower3;
+    middle2.lastChild = lower3;
 
-    leaf1.parent = middle1;
-    leaf2.parent = middle1;
-    leaf3.parent = middle1;
+    lower1.parent = middle1;
+    lower2.parent = middle1;
+    lower1.nextSibling = lower2;
+    lower2.previousSibling = lower1;
+    lower1.firstChild = leaf1;
+    lower1.lastChild = leaf3;
+    lower2.firstChild = leaf4;
+    lower2.lastChild = leaf5;
+
+    lower3.parent = middle2;
+    lower3.firstChild = leaf6;
+    lower3.lastChild = leaf7;
+
+    leaf1.parent = lower1;
+    leaf2.parent = lower1;
+    leaf3.parent = lower1;
     leaf1.nextSibling = leaf2;
     leaf2.previousSibling = leaf1;
     leaf2.nextSibling = leaf3;
     leaf3.previousSibling = leaf2;
 
-    leaf4.parent = middle2;
-    leaf5.parent = middle2;
+    leaf4.parent = lower2;
+    leaf5.parent = lower2;
     leaf4.nextSibling = leaf5;
     leaf5.previousSibling = leaf4;
 
+    leaf6.parent = lower3;
+    leaf7.parent = lower3;
+    leaf6.nextSibling = leaf7;
+    leaf7.previousSibling = leaf6;
+
+    leaf8.parent = upper2;
+
     return {
       root: root,
+      upper1: upper1,
+      upper2: upper2,
       middle1: middle1,
       middle2: middle2,
+      lower1: lower1,
+      lower2: lower2,
+      lower3: lower3,
       leaf1: leaf1,
       leaf2: leaf2,
       leaf3: leaf3,
       leaf4: leaf4,
-      leaf5: leaf5
+      leaf5: leaf5,
+      leaf6: leaf6,
+      leaf7: leaf7,
+      leaf8: leaf8
     };
   },
 
   getDefaultRestrictions: function() {
     return {
       leaf: function(node) {
         return false;
       },
       visit: function(node) {
         return node.state.focusable === true;
       },
     }
+  },
+
+  getSubtreeRestrictions: function() {
+    return {
+      leaf: function(node) {
+        return node.state.leaf === true;
+      },
+      visit: function(node) {
+        return node.state.focusable === true;
+      },
+    }
   }
 };
 
-TEST_F('AutomationTreeWalkerUnitTest', 'MoveToNode', function() {
-  chrome.automation = {
-    RoleType: {DESKTOP: 'desktop', TAB: 'tab', TAB_LIST: 'tabList'},
-    StateType: {FOCUSABLE: 'focusable', OFFSCREEN: 'offscreen'}
-  };
+TEST_F('AutomationTreeWalkerUnitTest', 'MoveToNodeWholeTree', function() {
+  let t = this.getSampleTree();
+  let treeWalker = new AutomationTreeWalker(
+      t.root, t.root, this.getDefaultRestrictions());
 
-  let t = this.getSampleTree();
-  let treeWalker =
-      new AutomationTreeWalker(t.root, t.root, this.getDefaultRestrictions());
-
-  let interesting = {focusable: true};
-  t.leaf1.state = interesting;
-  t.leaf2.state = interesting;
-  t.middle2.state = interesting;
-  t.leaf5.state = interesting;
+  t.root.state['focusable'] = true;
+  t.middle1.state['focusable'] = true;
+  t.leaf1.state['focusable'] = true;
+  t.leaf2.state['focusable'] = true;
+  t.leaf5.state['focusable'] = true;
+  t.lower3.state['focusable'] = true;
+  t.leaf6.state['focusable'] = true;
+  t.upper2.state['focusable'] = true;
+  t.leaf8.state['focusable'] = true;
 
   // Move to next node.
+  assertEquals(t.middle1, treeWalker.moveToNode(true));
   assertEquals(t.leaf1, treeWalker.moveToNode(true));
   assertEquals(t.leaf2, treeWalker.moveToNode(true));
-  assertEquals(t.middle2, treeWalker.moveToNode(true));
   assertEquals(t.leaf5, treeWalker.moveToNode(true));
-  assertEquals(t.leaf1, treeWalker.moveToNode(true));
+  assertEquals(t.lower3, treeWalker.moveToNode(true));
+  assertEquals(t.leaf6, treeWalker.moveToNode(true));
+  assertEquals(t.upper2, treeWalker.moveToNode(true));
+  assertEquals(t.leaf8, treeWalker.moveToNode(true));
+  assertEquals(t.root, treeWalker.moveToNode(true));
+  assertEquals(t.middle1, treeWalker.moveToNode(true));
 
   // Move to previous node.
+  assertEquals(t.root, treeWalker.moveToNode(false));
+  assertEquals(t.leaf8, treeWalker.moveToNode(false));
+  assertEquals(t.upper2, treeWalker.moveToNode(false));
+  assertEquals(t.leaf6, treeWalker.moveToNode(false));
+  assertEquals(t.lower3, treeWalker.moveToNode(false));
   assertEquals(t.leaf5, treeWalker.moveToNode(false));
-  assertEquals(t.middle2, treeWalker.moveToNode(false));
   assertEquals(t.leaf2, treeWalker.moveToNode(false));
   assertEquals(t.leaf1, treeWalker.moveToNode(false));
-  assertEquals(t.leaf5, treeWalker.moveToNode(false));
+  assertEquals(t.middle1, treeWalker.moveToNode(false));
+});
+
+TEST_F('AutomationTreeWalkerUnitTest', 'MoveToNodeInSubtree', function() {
+  let t = this.getSampleTree();
+  let treeWalker = new AutomationTreeWalker(
+      t.upper1, t.upper1, this.getSubtreeRestrictions());
+
+  t.lower2.state['leaf'] = true;
+  t.lower3.state['leaf'] = true;
+
+  t.root.state['focusable'] = true;
+  t.middle1.state['focusable'] = true;
+  t.leaf1.state['focusable'] = true;
+  t.leaf2.state['focusable'] = true;
+  t.leaf5.state['focusable'] = true;
+  t.lower3.state['focusable'] = true;
+  t.leaf6.state['focusable'] = true;
+  t.upper2.state['focusable'] = true;
+  t.leaf8.state['focusable'] = true;
+
+  // Move to next node.
+  assertEquals(t.middle1, treeWalker.moveToNode(true));
+  assertEquals(t.leaf1, treeWalker.moveToNode(true));
+  assertEquals(t.leaf2, treeWalker.moveToNode(true));
+  assertEquals(t.lower3, treeWalker.moveToNode(true));
+  assertEquals(t.middle1, treeWalker.moveToNode(true));
+
+  // Move to previous node.
+  assertEquals(t.lower3, treeWalker.moveToNode(false));
+  assertEquals(t.leaf2, treeWalker.moveToNode(false));
+  assertEquals(t.leaf1, treeWalker.moveToNode(false));
+  assertEquals(t.middle1, treeWalker.moveToNode(false));
+  assertEquals(t.lower3, treeWalker.moveToNode(false));
 });
 
 TEST_F('AutomationTreeWalkerUnitTest', 'GetNextNode', function() {
   let t = this.getSampleTree();
   let treeWalker =
-      new AutomationTreeWalker(t.root, t.root, this.getDefaultRestrictions());
+      new AutomationTreeWalker(t.middle1, t.middle1, this.getDefaultRestrictions());
 
   let order =
-      [t.root, t.middle1, t.leaf1, t.leaf2, t.leaf3,
-      t.middle2, t.leaf4, t.leaf5];
-  let node = t.root;
+      [t.middle1, t.lower1, t.leaf1, t.leaf2, t.leaf3,
+      t.lower2, t.leaf4, t.leaf5];
+  let node = t.middle1;
   for (let i = 0; i < order.length; i++) {
     assertEquals(order[i], node);
     node = treeWalker.getNextNode_(node);
   }
   assertEquals(undefined, node);
 });
 
 TEST_F('AutomationTreeWalkerUnitTest', 'GetPreviousNode', function() {
   let t = this.getSampleTree();
   let treeWalker =
-      new AutomationTreeWalker(t.root, t.root, this.getDefaultRestrictions());
+      new AutomationTreeWalker(t.leaf5, t.middle1, this.getDefaultRestrictions());
 
   let order =
-      [t.leaf5, t.leaf4, t.middle2, t.leaf3, t.leaf2,
-      t.leaf1, t.middle1, t.root];
+      [t.leaf5, t.leaf4, t.lower2, t.leaf3, t.leaf2,
+      t.leaf1, t.lower1, t.middle1];
   let node = t.leaf5;
   for (let i = 0; i < order.length; i++) {
     assertEquals(order[i], node);
     node = treeWalker.getPreviousNode_(node);
   }
   assertEquals(undefined, node);
 });
 
 TEST_F('AutomationTreeWalkerUnitTest', 'GetYoungestDescendant', function() {
   let t = this.getSampleTree();
   let treeWalker =
       new AutomationTreeWalker(t.root, t.root, this.getDefaultRestrictions());
 
-  assertEquals(t.leaf5, treeWalker.getYoungestDescendant_(t.root));
-  assertEquals(t.leaf3, treeWalker.getYoungestDescendant_(t.middle1));
-  assertEquals(t.leaf5, treeWalker.getYoungestDescendant_(t.middle2));
+  assertEquals(t.leaf8, treeWalker.getYoungestDescendant_(t.root));
+  assertEquals(t.leaf7, treeWalker.getYoungestDescendant_(t.upper1));
+  assertEquals(t.leaf8, treeWalker.getYoungestDescendant_(t.upper2));
+  assertEquals(t.leaf5, treeWalker.getYoungestDescendant_(t.middle1));
+  assertEquals(t.leaf7, treeWalker.getYoungestDescendant_(t.middle2));
+  assertEquals(t.leaf3, treeWalker.getYoungestDescendant_(t.lower1));
+  assertEquals(t.leaf5, treeWalker.getYoungestDescendant_(t.lower2));
+  assertEquals(t.leaf7, treeWalker.getYoungestDescendant_(t.lower3));
   assertEquals(undefined, treeWalker.getYoungestDescendant_(t.leaf1));
   assertEquals(undefined, treeWalker.getYoungestDescendant_(t.leaf2));
   assertEquals(undefined, treeWalker.getYoungestDescendant_(t.leaf3));
   assertEquals(undefined, treeWalker.getYoungestDescendant_(t.leaf4));
   assertEquals(undefined, treeWalker.getYoungestDescendant_(t.leaf5));
+  assertEquals(undefined, treeWalker.getYoungestDescendant_(t.leaf6));
+  assertEquals(undefined, treeWalker.getYoungestDescendant_(t.leaf7));
+  assertEquals(undefined, treeWalker.getYoungestDescendant_(t.leaf8));
 });