Improve AXTree unit tests.

ui/accessibility/ax_generated_tree_unittest.cc

 // Copyright 2014 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.
 
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/accessibility/ax_node.h"
 #include "ui/accessibility/ax_serializable_tree.h"
 #include "ui/accessibility/ax_tree.h"
@@ skipping 30 matching lines @@
 
 std::string TreeToString(const AXTree& tree) {
   std::string result;
   TreeToStringHelper(tree.root(), &result);
   return "(" + result + ")";
 }
 
 }  // anonymous namespace
 
 // Test the TreeGenerator class by building all possible trees with
-// 3 nodes and the ids [1...3].
-TEST(AXGeneratedTreeTest, TestTreeGenerator) {
+// 3 nodes and the ids [1...3], with no permutations of ids.
+TEST(AXGeneratedTreeTest, TestTreeGeneratorNoPermutations) {
   int tree_size = 3;
-  TreeGenerator generator(tree_size);
+  TreeGenerator generator(tree_size, false);
   const char* EXPECTED_TREES[] = {
+    "(1)",
+    "(1 (2))",
+    "(1 (2 3))",
+    "(1 (2 (3)))",
+  };
+
+  int n = generator.UniqueTreeCount();
+  ASSERT_EQ(static_cast<int>(arraysize(EXPECTED_TREES)), n);
+
+  for (int i = 0; i < n; ++i) {
+    AXTree tree;
+    generator.BuildUniqueTree(i, &tree);
+    std::string str = TreeToString(tree);
+    EXPECT_EQ(EXPECTED_TREES[i], str);
+  }
+}
+
+// Test the TreeGenerator class by building all possible trees with
+// 3 nodes and the ids [1...3] permuted in any order.
+TEST(AXGeneratedTreeTest, TestTreeGeneratorWithPermutations) {
+  int tree_size = 3;
+  TreeGenerator generator(tree_size, true);
+  const char* EXPECTED_TREES[] = {
+    "(1)",
+    "(1 (2))",
+    "(2 (1))",
     "(1 (2 3))",
     "(2 (1 3))",
     "(3 (1 2))",
     "(1 (3 2))",
     "(2 (3 1))",
     "(3 (2 1))",
     "(1 (2 (3)))",
     "(2 (1 (3)))",
     "(3 (1 (2)))",
     "(1 (3 (2)))",
@@ skipping 19 matching lines @@
 //
 // For every possible scenario, we check that the AXTreeUpdate is valid,
 // that the destination tree can unserialize it and create a valid tree,
 // and that after updating all nodes the resulting tree now matches the
 // intended tree.
 TEST(AXGeneratedTreeTest, SerializeGeneratedTrees) {
   // Do a more exhaustive test in release mode. If you're modifying
   // the algorithm you may want to try even larger tree sizes if you
   // can afford the time.
 #ifdef NDEBUG
-  int tree_size = 4;
+  int max_tree_size = 4;
 #else
   LOG(WARNING) << "Debug build, only testing trees with 3 nodes and not 4.";
-  int tree_size = 3;
+  int max_tree_size = 3;
 #endif
 
-  TreeGenerator generator(tree_size);
-  int n = generator.UniqueTreeCount();
+  TreeGenerator generator0(max_tree_size, false);
+  int n0 = generator0.UniqueTreeCount();
 
-  for (int i = 0; i < n; i++) {
+  TreeGenerator generator1(max_tree_size, true);
+  int n1 = generator1.UniqueTreeCount();
+
+  for (int i = 0; i < n0; i++) {
     // Build the first tree, tree0.
     AXSerializableTree tree0;
-    generator.BuildUniqueTree(i, &tree0);
+    generator0.BuildUniqueTree(i, &tree0);
     SCOPED_TRACE("tree0 is " + TreeToString(tree0));
 
-    for (int j = 0; j < n; j++) {
+    for (int j = 0; j < n1; j++) {
       // Build the second tree, tree1.
       AXSerializableTree tree1;
-      generator.BuildUniqueTree(j, &tree1);
-      SCOPED_TRACE("tree1 is " + TreeToString(tree0));
+      generator1.BuildUniqueTree(j, &tree1);
+      SCOPED_TRACE("tree1 is " + TreeToString(tree1));
+
+      int tree_size = tree1.size();
 
       // Now iterate over which node to update first, |k|.
       for (int k = 0; k < tree_size; k++) {
         SCOPED_TRACE("i=" + base::IntToString(i) +
                      " j=" + base::IntToString(j) +
                      " k=" + base::IntToString(k));
 
         // Start by serializing tree0 and unserializing it into a new
         // empty tree |dst_tree|.
         scoped_ptr<AXTreeSource<const AXNode*> > tree0_source(
@@ skipping 23 matching lines @@
 
         // After the sequence of updates, |dst_tree| should now be
         // identical to |tree1|.
         EXPECT_EQ(TreeToString(tree1), TreeToString(dst_tree));
       }
     }
   }
 }
 
 }  // namespace ui