Revert "Optimize subclass/subtype queries"

tests/compiler/dart2js/class_set_test.dart

Index: tests/compiler/dart2js/class_set_test.dart
diff --git a/tests/compiler/dart2js/class_set_test.dart b/tests/compiler/dart2js/class_set_test.dart
index 7c6626aa79cb6cd7f000b055a61e1412f8f66978..d88745d2c781e34da05b4ef450be9ab90010525b 100644
--- a/tests/compiler/dart2js/class_set_test.dart
+++ b/tests/compiler/dart2js/class_set_test.dart
@@ -17,14 +17,7 @@ import 'package:compiler/src/util/util.dart';
 import 'package:compiler/src/world.dart';
 
 void main() {
-  asyncTest(() async {
-    await testIterators();
-    await testForEach();
-  });
-}
-
-testIterators() async {
-  var env = await TypeEnvironment.create(r"""
+  asyncTest(() => TypeEnvironment.create(r"""
       ///        A
       ///       / \
       ///      B   C
@@ -49,502 +42,305 @@ testIterators() async {
         new G();
       }
       """,
-      useMockCompiler: false);
-  World world = env.compiler.world;
-
-  ClassElement A = env.getElement("A");
-  ClassElement B = env.getElement("B");
-  ClassElement C = env.getElement("C");
-  ClassElement D = env.getElement("D");
-  ClassElement E = env.getElement("E");
-  ClassElement F = env.getElement("F");
-  ClassElement G = env.getElement("G");
-
-  void checkClass(ClassElement cls,
-                  {bool directlyInstantiated: false,
-                   bool indirectlyInstantiated: false}) {
-    ClassHierarchyNode node = world.getClassHierarchyNode(cls);
-    Expect.isNotNull(node, "Expected ClassHierarchyNode for $cls.");
-    Expect.equals(
-        directlyInstantiated || indirectlyInstantiated,
-        node.isInstantiated,
-        "Unexpected `isInstantiated` on ClassHierarchyNode for $cls.");
-    Expect.equals(
-        directlyInstantiated,
-        node.isDirectlyInstantiated,
-        "Unexpected `isDirectlyInstantiated` on ClassHierarchyNode for "
-        "$cls.");
-    Expect.equals(
-        indirectlyInstantiated,
-        node.isIndirectlyInstantiated,
-        "Unexpected `isIndirectlyInstantiated` on ClassHierarchyNode for "
-        "$cls.");
-  }
-
-
-  checkClass(A, directlyInstantiated: true, indirectlyInstantiated: true);
-  checkClass(B, indirectlyInstantiated: true);
-  checkClass(C, directlyInstantiated: true, indirectlyInstantiated: true);
-  checkClass(D, directlyInstantiated: true);
-  checkClass(E, directlyInstantiated: true);
-  checkClass(F, directlyInstantiated: true);
-  checkClass(G, directlyInstantiated: true);
-
-  ClassHierarchyNodeIterator iterator;
-
-  void checkState(
-      ClassElement root,
-      {ClassElement currentNode,
-       List<List<ClassElement>> stack}) {
-
-    ClassElement classOf(ClassHierarchyNode node) {
-      return node != null ? node.cls : null;
+      useMockCompiler: false).then((env) {
+    World world = env.compiler.world;
+
+    ClassElement A = env.getElement("A");
+    ClassElement B = env.getElement("B");
+    ClassElement C = env.getElement("C");
+    ClassElement D = env.getElement("D");
+    ClassElement E = env.getElement("E");
+    ClassElement F = env.getElement("F");
+    ClassElement G = env.getElement("G");
+
+    void checkClass(ClassElement cls,
+                    {bool directlyInstantiated: false,
+                     bool indirectlyInstantiated: false}) {
+      ClassHierarchyNode node = world.getClassHierarchyNode(cls);
+      Expect.isNotNull(node, "Expected ClassHierarchyNode for $cls.");
+      Expect.equals(
+          directlyInstantiated || indirectlyInstantiated,
+          node.isInstantiated,
+          "Unexpected `isInstantiated` on ClassHierarchyNode for $cls.");
+      Expect.equals(
+          directlyInstantiated,
+          node.isDirectlyInstantiated,
+          "Unexpected `isDirectlyInstantiated` on ClassHierarchyNode for "
+          "$cls.");
+      Expect.equals(
+          indirectlyInstantiated,
+          node.isIndirectlyInstantiated,
+          "Unexpected `isIndirectlyInstantiated` on ClassHierarchyNode for "
+          "$cls.");
     }
 
-    List<ClassElement> classesOf(Link<ClassHierarchyNode> link) {
-      if (link == null) return null;
-      return link.map(classOf).toList();
-    }
-
-    ClassElement foundRoot = iterator.root.cls;
-    ClassElement foundCurrentNode = classOf(iterator.currentNode);
-    List<ClassElement> foundStack = classesOf(iterator.stack);
-
-    StringBuffer sb = new StringBuffer();
-    sb.write('{\n root: $foundRoot');
-    sb.write('\n currentNode: $foundCurrentNode');
-    sb.write('\n stack: $foundStack\n}');
-
-    Expect.equals(root, foundRoot,
-        "Expected root $root in $sb.");
-    if (currentNode == null) {
-      Expect.isNull(iterator.currentNode,
-          "Unexpected non-null currentNode in $sb.");
-    } else {
-      Expect.isNotNull(foundCurrentNode,
-          "Expected non-null currentNode ${currentNode} in $sb.");
-      Expect.equals(currentNode, foundCurrentNode,
-          "Expected currentNode $currentNode in $sb.");
-    }
-    if (stack == null) {
-      Expect.isNull(foundStack,
-          "Unexpected non-null stack in $sb.");
-    } else {
-      Expect.isNotNull(foundStack,
-          "Expected non-null stack ${stack} in $sb.");
-      Expect.listEquals(stack, foundStack,
-          "Expected stack ${stack}, "
-          "found ${foundStack} in $sb.");
-    }
-  }
-
-  iterator = new ClassHierarchyNodeIterable(
-      world.getClassHierarchyNode(G),
-      ClassHierarchyNode.ALL).iterator;
-  checkState(G, currentNode: null, stack: null);
-  Expect.isNull(iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(G, currentNode: G, stack: []);
-  Expect.equals(G, iterator.current);
-  Expect.isFalse(iterator.moveNext());
-  checkState(G, currentNode: null, stack: []);
-  Expect.isNull(iterator.current);
-
-  iterator = new ClassHierarchyNodeIterable(
-      world.getClassHierarchyNode(G),
-      ClassHierarchyNode.ALL,
-      includeRoot: false).iterator;
-  checkState(G, currentNode: null, stack: null);
-  Expect.isNull(iterator.current);
-  Expect.isFalse(iterator.moveNext());
-  checkState(G, currentNode: null, stack: []);
-  Expect.isNull(iterator.current);
-
-  iterator = new ClassHierarchyNodeIterable(
-      world.getClassHierarchyNode(C),
-      ClassHierarchyNode.ALL).iterator;
-  checkState(C, currentNode: null, stack: null);
-  Expect.isNull(iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(C, currentNode: C, stack: [E, F, G]);
-  Expect.equals(C, iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(C, currentNode: E, stack: [F, G]);
-  Expect.equals(E, iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(C, currentNode: F, stack: [G]);
-  Expect.equals(F, iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(C, currentNode: G, stack: []);
-  Expect.equals(G, iterator.current);
-  Expect.isFalse(iterator.moveNext());
-  checkState(C, currentNode: null, stack: []);
-  Expect.isNull(iterator.current);
 
-  iterator = new ClassHierarchyNodeIterable(
-      world.getClassHierarchyNode(D),
-      ClassHierarchyNode.ALL).iterator;
-  checkState(D, currentNode: null, stack: null);
-  Expect.isNull(iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(D, currentNode: D, stack: []);
-  Expect.equals(D, iterator.current);
-  Expect.isFalse(iterator.moveNext());
-  checkState(D, currentNode: null, stack: []);
-  Expect.isNull(iterator.current);
+    checkClass(A, directlyInstantiated: true, indirectlyInstantiated: true);
+    checkClass(B, indirectlyInstantiated: true);
+    checkClass(C, directlyInstantiated: true, indirectlyInstantiated: true);
+    checkClass(D, directlyInstantiated: true);
+    checkClass(E, directlyInstantiated: true);
+    checkClass(F, directlyInstantiated: true);
+    checkClass(G, directlyInstantiated: true);
 
-  iterator = new ClassHierarchyNodeIterable(
-      world.getClassHierarchyNode(B),
-      ClassHierarchyNode.ALL).iterator;
-  checkState(B, currentNode: null, stack: null);
-  Expect.isNull(iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(B, currentNode: B, stack: [D]);
-  Expect.equals(B, iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(B, currentNode: D, stack: []);
-  Expect.equals(D, iterator.current);
-  Expect.isFalse(iterator.moveNext());
-  checkState(B, currentNode: null, stack: []);
-  Expect.isNull(iterator.current);
+    ClassHierarchyNodeIterator iterator;
 
-  iterator = new ClassHierarchyNodeIterable(
-      world.getClassHierarchyNode(B),
-      ClassHierarchyNode.ALL,
-      includeRoot: false).iterator;
-  checkState(B, currentNode: null, stack: null);
-  Expect.isNull(iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(B, currentNode: D, stack: []);
-  Expect.equals(D, iterator.current);
-  Expect.isFalse(iterator.moveNext());
-  checkState(B, currentNode: null, stack: []);
-  Expect.isNull(iterator.current);
+    void checkState(
+        ClassElement root,
+        {ClassElement currentNode,
+         List<List<ClassElement>> stack}) {
 
-  iterator = new ClassHierarchyNodeIterable(
-      world.getClassHierarchyNode(B),
-      new EnumSet<Instantiation>.fromValues(<Instantiation>[
-          Instantiation.DIRECTLY_INSTANTIATED,
-          Instantiation.UNINSTANTIATED])).iterator;
-  checkState(B, currentNode: null, stack: null);
-  Expect.isNull(iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(B, currentNode: D, stack: []);
-  Expect.equals(D, iterator.current);
-  Expect.isFalse(iterator.moveNext());
-  checkState(B, currentNode: null, stack: []);
-  Expect.isNull(iterator.current);
-
-  iterator = new ClassHierarchyNodeIterable(
-      world.getClassHierarchyNode(A),
-      ClassHierarchyNode.ALL).iterator;
-  checkState(A, currentNode: null, stack: null);
-  Expect.isNull(iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(A, currentNode: A, stack: [C, B]);
-  Expect.equals(A, iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(A, currentNode: C, stack: [E, F, G, B]);
-  Expect.equals(C, iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(A, currentNode: E, stack: [F, G, B]);
-  Expect.equals(E, iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(A, currentNode: F, stack: [G, B]);
-  Expect.equals(F, iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(A, currentNode: G, stack: [B]);
-  Expect.equals(G, iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(A, currentNode: B, stack: [D]);
-  Expect.equals(B, iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(A, currentNode: D, stack: []);
-  Expect.equals(D, iterator.current);
-  Expect.isFalse(iterator.moveNext());
-  checkState(A, currentNode: null, stack: []);
-  Expect.isNull(iterator.current);
-
-  iterator = new ClassHierarchyNodeIterable(
-      world.getClassHierarchyNode(A),
-      ClassHierarchyNode.ALL,
-      includeRoot: false).iterator;
-  checkState(A, currentNode: null, stack: null);
-  Expect.isNull(iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(A, currentNode: C, stack: [E, F, G, B]);
-  Expect.equals(C, iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(A, currentNode: E, stack: [F, G, B]);
-  Expect.equals(E, iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(A, currentNode: F, stack: [G, B]);
-  Expect.equals(F, iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(A, currentNode: G, stack: [B]);
-  Expect.equals(G, iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(A, currentNode: B, stack: [D]);
-  Expect.equals(B, iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(A, currentNode: D, stack: []);
-  Expect.equals(D, iterator.current);
-  Expect.isFalse(iterator.moveNext());
-  checkState(A, currentNode: null, stack: []);
-  Expect.isNull(iterator.current);
-
-  iterator = new ClassHierarchyNodeIterable(
-      world.getClassHierarchyNode(A),
-      new EnumSet<Instantiation>.fromValues(<Instantiation>[
-          Instantiation.DIRECTLY_INSTANTIATED,
-          Instantiation.UNINSTANTIATED])).iterator;
-  checkState(A, currentNode: null, stack: null);
-  Expect.isNull(iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(A, currentNode: A, stack: [C, B]);
-  Expect.equals(A, iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(A, currentNode: C, stack: [E, F, G, B]);
-  Expect.equals(C, iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(A, currentNode: E, stack: [F, G, B]);
-  Expect.equals(E, iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(A, currentNode: F, stack: [G, B]);
-  Expect.equals(F, iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(A, currentNode: G, stack: [B]);
-  Expect.equals(G, iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(A, currentNode: D, stack: []);
-  Expect.equals(D, iterator.current);
-  Expect.isFalse(iterator.moveNext());
-  checkState(A, currentNode: null, stack: []);
-  Expect.isNull(iterator.current);
-
-  iterator = new ClassHierarchyNodeIterable(
-      world.getClassHierarchyNode(A),
-      new EnumSet<Instantiation>.fromValues(<Instantiation>[
-          Instantiation.DIRECTLY_INSTANTIATED,
-          Instantiation.UNINSTANTIATED]),
-      includeRoot: false).iterator;
-  checkState(A, currentNode: null, stack: null);
-  Expect.isNull(iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(A, currentNode: C, stack: [E, F, G, B]);
-  Expect.equals(C, iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(A, currentNode: E, stack: [F, G, B]);
-  Expect.equals(E, iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(A, currentNode: F, stack: [G, B]);
-  Expect.equals(F, iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(A, currentNode: G, stack: [B]);
-  Expect.equals(G, iterator.current);
-  Expect.isTrue(iterator.moveNext());
-  checkState(A, currentNode: D, stack: []);
-  Expect.equals(D, iterator.current);
-  Expect.isFalse(iterator.moveNext());
-  checkState(A, currentNode: null, stack: []);
-  Expect.isNull(iterator.current);
-}
-
-testForEach() async {
-  var env = await TypeEnvironment.create(r"""
-      ///        A
-      ///       / \
-      ///      B   C
-      ///     /   /|\
-      ///    D   E F G
-      ///         / \
-      ///         H I
-      ///
-      class A {}
-      class B extends A {}
-      class C extends A {}
-      class D extends B {}
-      class E extends C {}
-      class F extends C implements B {}
-      class G extends C implements D {}
-      class H extends F {}
-      class I extends F {}
-      """,
-        mainSource: r"""
-      main() {
-        new A();
-        new C();
-        new D();
-        new E();
-        new F();
-        new G();
-        new H();
-        new I();
+      ClassElement classOf(ClassHierarchyNode node) {
+        return node != null ? node.cls : null;
       }
-      """,
-      useMockCompiler: false);
-  World world = env.compiler.world;
-
-  ClassElement A = env.getElement("A");
-  ClassElement B = env.getElement("B");
-  ClassElement C = env.getElement("C");
-  ClassElement D = env.getElement("D");
-  ClassElement E = env.getElement("E");
-  ClassElement F = env.getElement("F");
-  ClassElement G = env.getElement("G");
-  ClassElement H = env.getElement("H");
-  ClassElement I = env.getElement("I");
-
-  void checkForEachSubclass(ClassElement cls, List<ClassElement> expected) {
-    ClassSet classSet = world.getClassSet(cls);
-    List<ClassElement> visited = <ClassElement>[];
-    classSet.forEachSubclass((ClassElement cls) {
-      visited.add(cls);
-    }, ClassHierarchyNode.ALL);
-
-    Expect.listEquals(expected, visited,
-        "Unexpected classes on $cls.forEachSubclass:\n"
-        "Actual: $visited, expected: $expected\n$classSet");
-
-    visited = <ClassElement>[];
-    classSet.forEachSubclass((ClassElement cls) {
-      visited.add(cls);
-      return ForEach.CONTINUE;
-    }, ClassHierarchyNode.ALL);
-
-    Expect.listEquals(expected, visited,
-        "Unexpected classes on $cls.forEachSubclass:\n"
-        "Actual: $visited, expected: $expected\n$classSet");
-  }
-
-  checkForEachSubclass(A, [A, B, D, C, G, F, I, H, E]);
-  checkForEachSubclass(B, [B, D]);
-  checkForEachSubclass(C, [C, G, F, I, H, E]);
-  checkForEachSubclass(D, [D]);
-  checkForEachSubclass(E, [E]);
-  checkForEachSubclass(F, [F, I, H]);
-  checkForEachSubclass(G, [G]);
-  checkForEachSubclass(H, [H]);
-  checkForEachSubclass(I, [I]);
-
-  void checkForEachSubtype(ClassElement cls, List<ClassElement> expected) {
-    ClassSet classSet = world.getClassSet(cls);
-    List<ClassElement> visited = <ClassElement>[];
-    classSet.forEachSubtype((ClassElement cls) {
-      visited.add(cls);
-    }, ClassHierarchyNode.ALL);
-
-    Expect.listEquals(expected, visited,
-        "Unexpected classes on $cls.forEachSubtype:\n"
-        "Actual: $visited, expected: $expected\n$classSet");
-
-    visited = <ClassElement>[];
-    classSet.forEachSubtype((ClassElement cls) {
-      visited.add(cls);
-      return ForEach.CONTINUE;
-    }, ClassHierarchyNode.ALL);
 
-    Expect.listEquals(expected, visited,
-        "Unexpected classes on $cls.forEachSubtype:\n"
-        "Actual: $visited, expected: $expected\n$classSet");
-  }
-
-  checkForEachSubtype(A, [A, B, D, C, G, F, I, H, E]);
-  checkForEachSubtype(B, [B, D, F, I, H, G]);
-  checkForEachSubtype(C, [C, G, F, I, H, E]);
-  checkForEachSubtype(D, [D, G]);
-  checkForEachSubtype(E, [E]);
-  checkForEachSubtype(F, [F, I, H]);
-  checkForEachSubtype(G, [G]);
-  checkForEachSubtype(H, [H]);
-  checkForEachSubtype(I, [I]);
-
-  void checkForEach(
-      ClassElement cls,
-      List<ClassElement> expected,
-      {ClassElement stop,
-       List<ClassElement> skipChildren: const <ClassElement>[],
-       bool forEachSubtype: false}) {
-    ClassSet classSet = world.getClassSet(cls);
-    List<ClassElement> visited = <ClassElement>[];
-
-    ForEach visit(ClassElement cls) {
-      visited.add(cls);
-      if (cls == stop) {
-        return ForEach.STOP;
-      } else if (skipChildren.contains(cls)) {
-        return ForEach.SKIP_CHILDREN;
+      List<ClassElement> classesOf(Link<ClassHierarchyNode> link) {
+        if (link == null) return null;
+        return link.map(classOf).toList();
       }
-      return ForEach.CONTINUE;
-    }
-
-    if (forEachSubtype) {
-      classSet.forEachSubtype(visit, ClassHierarchyNode.ALL);
-    } else {
-      classSet.forEachSubclass(visit, ClassHierarchyNode.ALL);
-    }
-
-    Expect.listEquals(expected, visited,
-        "Unexpected classes on $cls."
-        "forEach${forEachSubtype ? 'Subtype' : 'Subclass'} "
-        "(stop:$stop, skipChildren:$skipChildren):\n"
-        "Actual: $visited, expected: $expected\n$classSet");
-  }
-
-  checkForEach(A, [A, B, D, C, G, F, I, H, E]);
-  checkForEach(A, [A], stop: A);
-  checkForEach(A, [A, B, C, G, F, I, H, E], skipChildren: [B]);
-  checkForEach(A, [A, B, C], skipChildren: [B, C]);
-  checkForEach(A, [A, B, C, G], stop: G, skipChildren: [B]);
-
-  checkForEach(B, [B, D, F, I, H, G], forEachSubtype: true);
-  checkForEach(B, [B, D], stop: D, forEachSubtype: true);
-  checkForEach(B, [B, D, F, G], skipChildren: [F], forEachSubtype: true);
-  checkForEach(B, [B], skipChildren: [B], forEachSubtype: true);
-  checkForEach(B, [B, D, F, I, H, G], skipChildren: [D], forEachSubtype: true);
 
-  void checkAny(
-      ClassElement cls,
-      List<ClassElement> expected,
-      {ClassElement find,
-       bool expectedResult,
-       bool anySubtype: false}) {
-    ClassSet classSet = world.getClassSet(cls);
-    List<ClassElement> visited = <ClassElement>[];
-
-    bool visit(ClassElement cls) {
-      visited.add(cls);
-      return cls == find;
-    }
-
-    bool result;
-    if (anySubtype) {
-      result = classSet.anySubtype(visit, ClassHierarchyNode.ALL);
-    } else {
-      result = classSet.anySubclass(visit, ClassHierarchyNode.ALL);
+      ClassElement foundRoot = iterator.root.cls;
+      ClassElement foundCurrentNode = classOf(iterator.currentNode);
+      List<ClassElement> foundStack = classesOf(iterator.stack);
+
+      StringBuffer sb = new StringBuffer();
+      sb.write('{\n root: $foundRoot');
+      sb.write('\n currentNode: $foundCurrentNode');
+      sb.write('\n stack: $foundStack\n}');
+
+      Expect.equals(root, foundRoot,
+          "Expected root $root in $sb.");
+      if (currentNode == null) {
+        Expect.isNull(iterator.currentNode,
+            "Unexpected non-null currentNode in $sb.");
+      } else {
+        Expect.isNotNull(foundCurrentNode,
+            "Expected non-null currentNode ${currentNode} in $sb.");
+        Expect.equals(currentNode, foundCurrentNode,
+            "Expected currentNode $currentNode in $sb.");
+      }
+      if (stack == null) {
+        Expect.isNull(foundStack,
+            "Unexpected non-null stack in $sb.");
+      } else {
+        Expect.isNotNull(foundStack,
+            "Expected non-null stack ${stack} in $sb.");
+        Expect.listEquals(stack, foundStack,
+            "Expected stack ${stack}, "
+            "found ${foundStack} in $sb.");
+      }
     }
 
-    Expect.equals(expectedResult, result,
-        "Unexpected result on $cls."
-        "any${anySubtype ? 'Subtype' : 'Subclass'} "
-        "(find:$find).");
-
-    Expect.listEquals(expected, visited,
-        "Unexpected classes on $cls."
-        "any${anySubtype ? 'Subtype' : 'Subclass'} "
-        "(find:$find):\n"
-        "Actual: $visited, expected: $expected\n$classSet");
-  }
-
-  checkAny(A, [A, B, D, C, G, F, I, H, E], expectedResult: false);
-  checkAny(A, [A], find: A, expectedResult: true);
-  checkAny(A, [A, B, D, C, G, F, I], find: I, expectedResult: true);
-
-  checkAny(B, [B, D, F, I, H, G], anySubtype: true, expectedResult: false);
-  checkAny(B, [B, D, F, I, H, G],
-      find: A, anySubtype: true, expectedResult: false);
-  checkAny(B, [B, D],
-      find: D, anySubtype: true, expectedResult: true);
-  checkAny(B, [B, D, F, I],
-      find: I, anySubtype: true, expectedResult: true);
+    iterator = new ClassHierarchyNodeIterable(
+        world.getClassHierarchyNode(G),
+        ClassHierarchyNode.ALL).iterator;
+    checkState(G, currentNode: null, stack: null);
+    Expect.isNull(iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(G, currentNode: G, stack: []);
+    Expect.equals(G, iterator.current);
+    Expect.isFalse(iterator.moveNext());
+    checkState(G, currentNode: null, stack: []);
+    Expect.isNull(iterator.current);
+
+    iterator = new ClassHierarchyNodeIterable(
+        world.getClassHierarchyNode(G),
+        ClassHierarchyNode.ALL,
+        includeRoot: false).iterator;
+    checkState(G, currentNode: null, stack: null);
+    Expect.isNull(iterator.current);
+    Expect.isFalse(iterator.moveNext());
+    checkState(G, currentNode: null, stack: []);
+    Expect.isNull(iterator.current);
+
+    iterator = new ClassHierarchyNodeIterable(
+        world.getClassHierarchyNode(C),
+        ClassHierarchyNode.ALL).iterator;
+    checkState(C, currentNode: null, stack: null);
+    Expect.isNull(iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(C, currentNode: C, stack: [E, F, G]);
+    Expect.equals(C, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(C, currentNode: E, stack: [F, G]);
+    Expect.equals(E, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(C, currentNode: F, stack: [G]);
+    Expect.equals(F, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(C, currentNode: G, stack: []);
+    Expect.equals(G, iterator.current);
+    Expect.isFalse(iterator.moveNext());
+    checkState(C, currentNode: null, stack: []);
+    Expect.isNull(iterator.current);
+
+    iterator = new ClassHierarchyNodeIterable(
+        world.getClassHierarchyNode(D),
+        ClassHierarchyNode.ALL).iterator;
+    checkState(D, currentNode: null, stack: null);
+    Expect.isNull(iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(D, currentNode: D, stack: []);
+    Expect.equals(D, iterator.current);
+    Expect.isFalse(iterator.moveNext());
+    checkState(D, currentNode: null, stack: []);
+    Expect.isNull(iterator.current);
+
+    iterator = new ClassHierarchyNodeIterable(
+        world.getClassHierarchyNode(B),
+        ClassHierarchyNode.ALL).iterator;
+    checkState(B, currentNode: null, stack: null);
+    Expect.isNull(iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(B, currentNode: B, stack: [D]);
+    Expect.equals(B, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(B, currentNode: D, stack: []);
+    Expect.equals(D, iterator.current);
+    Expect.isFalse(iterator.moveNext());
+    checkState(B, currentNode: null, stack: []);
+    Expect.isNull(iterator.current);
+
+    iterator = new ClassHierarchyNodeIterable(
+        world.getClassHierarchyNode(B),
+        ClassHierarchyNode.ALL,
+        includeRoot: false).iterator;
+    checkState(B, currentNode: null, stack: null);
+    Expect.isNull(iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(B, currentNode: D, stack: []);
+    Expect.equals(D, iterator.current);
+    Expect.isFalse(iterator.moveNext());
+    checkState(B, currentNode: null, stack: []);
+    Expect.isNull(iterator.current);
+
+    iterator = new ClassHierarchyNodeIterable(
+        world.getClassHierarchyNode(B),
+        new EnumSet<Instantiation>.fromValues(<Instantiation>[
+            Instantiation.DIRECTLY_INSTANTIATED,
+            Instantiation.UNINSTANTIATED])).iterator;
+    checkState(B, currentNode: null, stack: null);
+    Expect.isNull(iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(B, currentNode: D, stack: []);
+    Expect.equals(D, iterator.current);
+    Expect.isFalse(iterator.moveNext());
+    checkState(B, currentNode: null, stack: []);
+    Expect.isNull(iterator.current);
+
+    iterator = new ClassHierarchyNodeIterable(
+        world.getClassHierarchyNode(A),
+        ClassHierarchyNode.ALL).iterator;
+    checkState(A, currentNode: null, stack: null);
+    Expect.isNull(iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: A, stack: [C, B]);
+    Expect.equals(A, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: C, stack: [E, F, G, B]);
+    Expect.equals(C, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: E, stack: [F, G, B]);
+    Expect.equals(E, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: F, stack: [G, B]);
+    Expect.equals(F, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: G, stack: [B]);
+    Expect.equals(G, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: B, stack: [D]);
+    Expect.equals(B, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: D, stack: []);
+    Expect.equals(D, iterator.current);
+    Expect.isFalse(iterator.moveNext());
+    checkState(A, currentNode: null, stack: []);
+    Expect.isNull(iterator.current);
+
+    iterator = new ClassHierarchyNodeIterable(
+        world.getClassHierarchyNode(A),
+        ClassHierarchyNode.ALL,
+        includeRoot: false).iterator;
+    checkState(A, currentNode: null, stack: null);
+    Expect.isNull(iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: C, stack: [E, F, G, B]);
+    Expect.equals(C, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: E, stack: [F, G, B]);
+    Expect.equals(E, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: F, stack: [G, B]);
+    Expect.equals(F, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: G, stack: [B]);
+    Expect.equals(G, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: B, stack: [D]);
+    Expect.equals(B, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: D, stack: []);
+    Expect.equals(D, iterator.current);
+    Expect.isFalse(iterator.moveNext());
+    checkState(A, currentNode: null, stack: []);
+    Expect.isNull(iterator.current);
+
+    iterator = new ClassHierarchyNodeIterable(
+        world.getClassHierarchyNode(A),
+        new EnumSet<Instantiation>.fromValues(<Instantiation>[
+            Instantiation.DIRECTLY_INSTANTIATED,
+            Instantiation.UNINSTANTIATED])).iterator;
+    checkState(A, currentNode: null, stack: null);
+    Expect.isNull(iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: A, stack: [C, B]);
+    Expect.equals(A, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: C, stack: [E, F, G, B]);
+    Expect.equals(C, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: E, stack: [F, G, B]);
+    Expect.equals(E, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: F, stack: [G, B]);
+    Expect.equals(F, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: G, stack: [B]);
+    Expect.equals(G, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: D, stack: []);
+    Expect.equals(D, iterator.current);
+    Expect.isFalse(iterator.moveNext());
+    checkState(A, currentNode: null, stack: []);
+    Expect.isNull(iterator.current);
+
+    iterator = new ClassHierarchyNodeIterable(
+        world.getClassHierarchyNode(A),
+        new EnumSet<Instantiation>.fromValues(<Instantiation>[
+            Instantiation.DIRECTLY_INSTANTIATED,
+            Instantiation.UNINSTANTIATED]),
+        includeRoot: false).iterator;
+    checkState(A, currentNode: null, stack: null);
+    Expect.isNull(iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: C, stack: [E, F, G, B]);
+    Expect.equals(C, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: E, stack: [F, G, B]);
+    Expect.equals(E, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: F, stack: [G, B]);
+    Expect.equals(F, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: G, stack: [B]);
+    Expect.equals(G, iterator.current);
+    Expect.isTrue(iterator.moveNext());
+    checkState(A, currentNode: D, stack: []);
+    Expect.equals(D, iterator.current);
+    Expect.isFalse(iterator.moveNext());
+    checkState(A, currentNode: null, stack: []);
+    Expect.isNull(iterator.current);
+  }));
 }
+