Format and sort analyzer and analysis_server packages.

pkg/analyzer/test/generated/utilities_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.utilities_test;
 
 import 'dart:collection';
@@ skipping 19 matching lines @@
   runReflectiveTests(SourceRangeTest);
   runReflectiveTests(BooleanArrayTest);
   runReflectiveTests(DirectedGraphTest);
   runReflectiveTests(ListUtilitiesTest);
   runReflectiveTests(MultipleMapIteratorTest);
   runReflectiveTests(SingleMapIteratorTest);
   runReflectiveTests(TokenMapTest);
   runReflectiveTests(StringUtilitiesTest);
 }
 
+class AstCloneComparator extends AstComparator {
+  final bool expectTokensCopied;
+
+  AstCloneComparator(this.expectTokensCopied);
+
+  @override
+  bool isEqualNodes(AstNode first, AstNode second) {
+    if (first != null && identical(first, second)) {
+      fail('Failed to copy node: $first (${first.offset})');
+      return false;
+    }
+    return super.isEqualNodes(first, second);
+  }
+
+  @override
+  bool isEqualTokens(Token first, Token second) {
+    if (expectTokensCopied && first != null && identical(first, second)) {
+      fail('Failed to copy token: ${first.lexeme} (${first.offset})');
+      return false;
+    }
+    return super.isEqualTokens(first, second);
+  }
+}
+
 class AstClonerTest extends EngineTestCase {
   void test_visitAdjacentStrings() {
     _assertClone(
         AstFactory.adjacentStrings([AstFactory.string2("a"), AstFactory.string2("b")]));
   }
 
   void test_visitAnnotation_constant() {
     _assertClone(AstFactory.annotation(AstFactory.identifier3("A")));
   }
 
@@ skipping 35 matching lines @@
   }
 
   void test_visitBinaryExpression() {
     _assertClone(
         AstFactory.binaryExpression(
             AstFactory.identifier3("a"),
             TokenType.PLUS,
             AstFactory.identifier3("b")));
   }
 
-  void test_visitBlockFunctionBody() {
-    _assertClone(AstFactory.blockFunctionBody2());
-  }
-
   void test_visitBlock_empty() {
     _assertClone(AstFactory.block());
   }
 
   void test_visitBlock_nonEmpty() {
     _assertClone(
         AstFactory.block([AstFactory.breakStatement(), AstFactory.breakStatement()]));
   }
 
+  void test_visitBlockFunctionBody() {
+    _assertClone(AstFactory.blockFunctionBody2());
+  }
+
   void test_visitBooleanLiteral_false() {
     _assertClone(AstFactory.booleanLiteral(false));
   }
 
   void test_visitBooleanLiteral_true() {
     _assertClone(AstFactory.booleanLiteral(true));
   }
 
   void test_visitBreakStatement_label() {
     _assertClone(AstFactory.breakStatement2("l"));
@@ skipping 36 matching lines @@
 
   void test_visitCatchClause_catch_stack() {
     _assertClone(AstFactory.catchClause2("e", "s"));
   }
 
   void test_visitCatchClause_on() {
     _assertClone(AstFactory.catchClause3(AstFactory.typeName4("E")));
   }
 
   void test_visitCatchClause_on_catch() {
-    _assertClone(
-        AstFactory.catchClause4(AstFactory.typeName4("E"), "e"));
+    _assertClone(AstFactory.catchClause4(AstFactory.typeName4("E"), "e"));
   }
 
   void test_visitClassDeclaration_abstract() {
     _assertClone(
         AstFactory.classDeclaration(Keyword.ABSTRACT, "C", null, null, null, null));
   }
 
   void test_visitClassDeclaration_empty() {
     _assertClone(
         AstFactory.classDeclaration(null, "C", null, null, null, null));
@@ skipping 287 matching lines @@
 
   void test_visitCompilationUnit_directive() {
     _assertClone(
         AstFactory.compilationUnit3([AstFactory.libraryDirective2("l")]));
   }
 
   void test_visitCompilationUnit_directive_declaration() {
     _assertClone(
         AstFactory.compilationUnit4(
             [AstFactory.libraryDirective2("l")],
-            [AstFactory.topLevelVariableDeclaration2(
-                Keyword.VAR,
-                [AstFactory.variableDeclaration("a")])]));
+            [
+                AstFactory.topLevelVariableDeclaration2(
+                    Keyword.VAR,
+                    [AstFactory.variableDeclaration("a")])]));
   }
 
   void test_visitCompilationUnit_empty() {
     _assertClone(AstFactory.compilationUnit());
   }
 
   void test_visitCompilationUnit_script() {
     _assertClone(AstFactory.compilationUnit5("!#/bin/dartvm"));
   }
 
@@ skipping 12 matching lines @@
         AstFactory.compilationUnit7(
             "!#/bin/dartvm",
             [AstFactory.libraryDirective2("l")]));
   }
 
   void test_visitCompilationUnit_script_directives_declarations() {
     _assertClone(
         AstFactory.compilationUnit8(
             "!#/bin/dartvm",
             [AstFactory.libraryDirective2("l")],
-            [AstFactory.topLevelVariableDeclaration2(
-                Keyword.VAR,
-                [AstFactory.variableDeclaration("a")])]));
+            [
+                AstFactory.topLevelVariableDeclaration2(
+                    Keyword.VAR,
+                    [AstFactory.variableDeclaration("a")])]));
   }
 
   void test_visitConditionalExpression() {
     _assertClone(
         AstFactory.conditionalExpression(
             AstFactory.identifier3("a"),
             AstFactory.identifier3("b"),
             AstFactory.identifier3("c")));
   }
 
@@ skipping 31 matching lines @@
   }
 
   void test_visitConstructorDeclaration_multipleInitializers() {
     _assertClone(
         AstFactory.constructorDeclaration2(
             null,
             null,
             AstFactory.identifier3("C"),
             null,
             AstFactory.formalParameterList(),
-            [AstFactory.constructorFieldInitializer(false, "a", AstFactory.identifier3("b")),
-            AstFactory.constructorFieldInitializer(
-                false,
-                "c",
-                AstFactory.identifier3("d"))],
+            [
+                AstFactory.constructorFieldInitializer(false, "a", AstFactory.identifier3("b")),
+                AstFactory.constructorFieldInitializer(
+                    false,
+                    "c",
+                    AstFactory.identifier3("d"))],
             AstFactory.blockFunctionBody2()));
   }
 
   void test_visitConstructorDeclaration_multipleParameters() {
     _assertClone(
         AstFactory.constructorDeclaration2(
             null,
             null,
             AstFactory.identifier3("C"),
             null,
-            AstFactory.formalParameterList([
-                AstFactory.simpleFormalParameter(Keyword.VAR, "a"),
-                AstFactory.simpleFormalParameter(Keyword.VAR, "b")]),
+            AstFactory.formalParameterList(
+                [
+                    AstFactory.simpleFormalParameter(Keyword.VAR, "a"),
+                    AstFactory.simpleFormalParameter(Keyword.VAR, "b")]),
             null,
             AstFactory.blockFunctionBody2()));
   }
 
   void test_visitConstructorDeclaration_named() {
     _assertClone(
         AstFactory.constructorDeclaration2(
             null,
             null,
             AstFactory.identifier3("C"),
             "m",
             AstFactory.formalParameterList(),
             null,
             AstFactory.blockFunctionBody2()));
   }
 
   void test_visitConstructorDeclaration_singleInitializer() {
     _assertClone(
         AstFactory.constructorDeclaration2(
             null,
             null,
             AstFactory.identifier3("C"),
             null,
             AstFactory.formalParameterList(),
-            [AstFactory.constructorFieldInitializer(
-                false,
-                "a",
-                AstFactory.identifier3("b"))],
+            [
+                AstFactory.constructorFieldInitializer(
+                    false,
+                    "a",
+                    AstFactory.identifier3("b"))],
             AstFactory.blockFunctionBody2()));
   }
 
   void test_visitConstructorDeclaration_withMetadata() {
     ConstructorDeclaration declaration = AstFactory.constructorDeclaration2(
         null,
         null,
         AstFactory.identifier3("C"),
         null,
         AstFactory.formalParameterList(),
         null,
         AstFactory.blockFunctionBody2());
     declaration.metadata =
         [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertClone(declaration);
   }
 
-  void test_visitConstructorFieldInitializer_withThis() {
-    _assertClone(
-        AstFactory.constructorFieldInitializer(true, "a", AstFactory.identifier3("b")));
-  }
-
   void test_visitConstructorFieldInitializer_withoutThis() {
     _assertClone(
         AstFactory.constructorFieldInitializer(
             false,
             "a",
             AstFactory.identifier3("b")));
   }
 
+  void test_visitConstructorFieldInitializer_withThis() {
+    _assertClone(
+        AstFactory.constructorFieldInitializer(true, "a", AstFactory.identifier3("b")));
+  }
+
   void test_visitConstructorName_named_prefix() {
     _assertClone(
         AstFactory.constructorName(AstFactory.typeName4("p.C.n"), null));
   }
 
   void test_visitConstructorName_unnamed_noPrefix() {
-    _assertClone(
-        AstFactory.constructorName(AstFactory.typeName4("C"), null));
+    _assertClone(AstFactory.constructorName(AstFactory.typeName4("C"), null));
   }
 
   void test_visitConstructorName_unnamed_prefix() {
     _assertClone(
         AstFactory.constructorName(
             AstFactory.typeName3(AstFactory.identifier5("p", "C")),
             null));
   }
 
   void test_visitContinueStatement_label() {
@@ skipping 121 matching lines @@
             "a",
             AstFactory.formalParameterList([AstFactory.simpleFormalParameter3("b")])));
   }
 
   void test_visitFieldFormalParameter_keyword() {
     _assertClone(AstFactory.fieldFormalParameter(Keyword.VAR, null, "a"));
   }
 
   void test_visitFieldFormalParameter_keywordAndType() {
     _assertClone(
-        AstFactory.fieldFormalParameter(
-            Keyword.FINAL,
-            AstFactory.typeName4("A"),
-            "a"));
+        AstFactory.fieldFormalParameter(Keyword.FINAL, AstFactory.typeName4("A"), "a"));
   }
 
   void test_visitFieldFormalParameter_type() {
     _assertClone(
         AstFactory.fieldFormalParameter(null, AstFactory.typeName4("A"), "a"));
   }
 
   void test_visitForEachStatement_declared() {
     _assertClone(
         AstFactory.forEachStatement(
@@ skipping 21 matching lines @@
             TokenFactory.tokenFromString("await"),
             TokenFactory.tokenFromKeyword(Keyword.FOR),
             TokenFactory.tokenFromType(TokenType.OPEN_PAREN),
             AstFactory.identifier3("a"),
             TokenFactory.tokenFromKeyword(Keyword.IN),
             AstFactory.identifier3("b"),
             TokenFactory.tokenFromType(TokenType.CLOSE_PAREN),
             AstFactory.block()));
   }
 
-  void test_visitForStatement_c() {
-    _assertClone(
-        AstFactory.forStatement(
-            null,
-            AstFactory.identifier3("c"),
-            null,
-            AstFactory.block()));
-  }
-
-  void test_visitForStatement_cu() {
-    _assertClone(
-        AstFactory.forStatement(
-            null,
-            AstFactory.identifier3("c"),
-            [AstFactory.identifier3("u")],
-            AstFactory.block()));
-  }
-
-  void test_visitForStatement_e() {
-    _assertClone(
-        AstFactory.forStatement(
-            AstFactory.identifier3("e"),
-            null,
-            null,
-            AstFactory.block()));
-  }
-
-  void test_visitForStatement_ec() {
-    _assertClone(
-        AstFactory.forStatement(
-            AstFactory.identifier3("e"),
-            AstFactory.identifier3("c"),
-            null,
-            AstFactory.block()));
-  }
-
-  void test_visitForStatement_ecu() {
-    _assertClone(
-        AstFactory.forStatement(
-            AstFactory.identifier3("e"),
-            AstFactory.identifier3("c"),
-            [AstFactory.identifier3("u")],
-            AstFactory.block()));
-  }
-
-  void test_visitForStatement_eu() {
-    _assertClone(
-        AstFactory.forStatement(
-            AstFactory.identifier3("e"),
-            null,
-            [AstFactory.identifier3("u")],
-            AstFactory.block()));
-  }
-
-  void test_visitForStatement_i() {
-    _assertClone(
-        AstFactory.forStatement2(
-            AstFactory.variableDeclarationList2(
-                Keyword.VAR,
-                [AstFactory.variableDeclaration("i")]),
-            null,
-            null,
-            AstFactory.block()));
-  }
-
-  void test_visitForStatement_ic() {
-    _assertClone(
-        AstFactory.forStatement2(
-            AstFactory.variableDeclarationList2(
-                Keyword.VAR,
-                [AstFactory.variableDeclaration("i")]),
-            AstFactory.identifier3("c"),
-            null,
-            AstFactory.block()));
-  }
-
-  void test_visitForStatement_icu() {
-    _assertClone(
-        AstFactory.forStatement2(
-            AstFactory.variableDeclarationList2(
-                Keyword.VAR,
-                [AstFactory.variableDeclaration("i")]),
-            AstFactory.identifier3("c"),
-            [AstFactory.identifier3("u")],
-            AstFactory.block()));
-  }
-
-  void test_visitForStatement_iu() {
-    _assertClone(
-        AstFactory.forStatement2(
-            AstFactory.variableDeclarationList2(
-                Keyword.VAR,
-                [AstFactory.variableDeclaration("i")]),
-            null,
-            [AstFactory.identifier3("u")],
-            AstFactory.block()));
-  }
-
-  void test_visitForStatement_u() {
-    _assertClone(
-        AstFactory.forStatement(
-            null,
-            null,
-            [AstFactory.identifier3("u")],
-            AstFactory.block()));
-  }
-
   void test_visitFormalParameterList_empty() {
     _assertClone(AstFactory.formalParameterList());
   }
 
   void test_visitFormalParameterList_n() {
     _assertClone(
         AstFactory.formalParameterList(
             [
                 AstFactory.namedFormalParameter(
                     AstFactory.simpleFormalParameter3("a"),
@@ skipping 135 matching lines @@
                 AstFactory.simpleFormalParameter3("a"),
                 AstFactory.simpleFormalParameter3("b"),
                 AstFactory.positionalFormalParameter(
                     AstFactory.simpleFormalParameter3("c"),
                     AstFactory.integer(3)),
                 AstFactory.positionalFormalParameter(
                     AstFactory.simpleFormalParameter3("d"),
                     AstFactory.integer(4))]));
   }
 
-  void test_visitFunctionDeclarationStatement() {
+  void test_visitForStatement_c() {
     _assertClone(
-        AstFactory.functionDeclarationStatement(
+        AstFactory.forStatement(
+            null,
+            AstFactory.identifier3("c"),
+            null,
+            AstFactory.block()));
+  }
+
+  void test_visitForStatement_cu() {
+    _assertClone(
+        AstFactory.forStatement(
+            null,
+            AstFactory.identifier3("c"),
+            [AstFactory.identifier3("u")],
+            AstFactory.block()));
+  }
+
+  void test_visitForStatement_e() {
+    _assertClone(
+        AstFactory.forStatement(
+            AstFactory.identifier3("e"),
             null,
             null,
-            "f",
-            AstFactory.functionExpression()));
+            AstFactory.block()));
+  }
+
+  void test_visitForStatement_ec() {
+    _assertClone(
+        AstFactory.forStatement(
+            AstFactory.identifier3("e"),
+            AstFactory.identifier3("c"),
+            null,
+            AstFactory.block()));
+  }
+
+  void test_visitForStatement_ecu() {
+    _assertClone(
+        AstFactory.forStatement(
+            AstFactory.identifier3("e"),
+            AstFactory.identifier3("c"),
+            [AstFactory.identifier3("u")],
+            AstFactory.block()));
+  }
+
+  void test_visitForStatement_eu() {
+    _assertClone(
+        AstFactory.forStatement(
+            AstFactory.identifier3("e"),
+            null,
+            [AstFactory.identifier3("u")],
+            AstFactory.block()));
+  }
+
+  void test_visitForStatement_i() {
+    _assertClone(
+        AstFactory.forStatement2(
+            AstFactory.variableDeclarationList2(
+                Keyword.VAR,
+                [AstFactory.variableDeclaration("i")]),
+            null,
+            null,
+            AstFactory.block()));
+  }
+
+  void test_visitForStatement_ic() {
+    _assertClone(
+        AstFactory.forStatement2(
+            AstFactory.variableDeclarationList2(
+                Keyword.VAR,
+                [AstFactory.variableDeclaration("i")]),
+            AstFactory.identifier3("c"),
+            null,
+            AstFactory.block()));
+  }
+
+  void test_visitForStatement_icu() {
+    _assertClone(
+        AstFactory.forStatement2(
+            AstFactory.variableDeclarationList2(
+                Keyword.VAR,
+                [AstFactory.variableDeclaration("i")]),
+            AstFactory.identifier3("c"),
+            [AstFactory.identifier3("u")],
+            AstFactory.block()));
+  }
+
+  void test_visitForStatement_iu() {
+    _assertClone(
+        AstFactory.forStatement2(
+            AstFactory.variableDeclarationList2(
+                Keyword.VAR,
+                [AstFactory.variableDeclaration("i")]),
+            null,
+            [AstFactory.identifier3("u")],
+            AstFactory.block()));
+  }
+
+  void test_visitForStatement_u() {
+    _assertClone(
+        AstFactory.forStatement(
+            null,
+            null,
+            [AstFactory.identifier3("u")],
+            AstFactory.block()));
   }
 
   void test_visitFunctionDeclaration_getter() {
     _assertClone(
         AstFactory.functionDeclaration(
             null,
             Keyword.GET,
             "f",
             AstFactory.functionExpression()));
   }
@@ skipping 20 matching lines @@
     FunctionDeclaration declaration = AstFactory.functionDeclaration(
         null,
         null,
         "f",
         AstFactory.functionExpression());
     declaration.metadata =
         [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertClone(declaration);
   }
 
+  void test_visitFunctionDeclarationStatement() {
+    _assertClone(
+        AstFactory.functionDeclarationStatement(
+            null,
+            null,
+            "f",
+            AstFactory.functionExpression()));
+  }
+
   void test_visitFunctionExpression() {
     _assertClone(AstFactory.functionExpression());
   }
 
   void test_visitFunctionExpressionInvocation() {
     _assertClone(
         AstFactory.functionExpressionInvocation(AstFactory.identifier3("f")));
   }
 
   void test_visitFunctionTypeAlias_generic() {
@@ skipping 24 matching lines @@
         [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertClone(declaration);
   }
 
   void test_visitFunctionTypedFormalParameter_noType() {
     _assertClone(AstFactory.functionTypedFormalParameter(null, "f"));
   }
 
   void test_visitFunctionTypedFormalParameter_type() {
     _assertClone(
-        AstFactory.functionTypedFormalParameter(
-            AstFactory.typeName4("T"),
-            "f"));
+        AstFactory.functionTypedFormalParameter(AstFactory.typeName4("T"), "f"));
   }
 
   void test_visitIfStatement_withElse() {
     _assertClone(
         AstFactory.ifStatement2(
             AstFactory.identifier3("c"),
             AstFactory.block(),
             AstFactory.block()));
   }
 
@@ skipping 100 matching lines @@
   void test_visitInstanceCreationExpression_named() {
     _assertClone(
         AstFactory.instanceCreationExpression3(
             Keyword.NEW,
             AstFactory.typeName4("C"),
             "c"));
   }
 
   void test_visitInstanceCreationExpression_unnamed() {
     _assertClone(
-        AstFactory.instanceCreationExpression2(
-            Keyword.NEW,
-            AstFactory.typeName4("C")));
+        AstFactory.instanceCreationExpression2(Keyword.NEW, AstFactory.typeName4("C")));
   }
 
   void test_visitIntegerLiteral() {
     _assertClone(AstFactory.integer(42));
   }
 
   void test_visitInterpolationExpression_expression() {
     _assertClone(
         AstFactory.interpolationExpression(AstFactory.identifier3("a")));
   }
@@ skipping 74 matching lines @@
 
   void test_visitListLiteral_nonEmpty() {
     _assertClone(
         AstFactory.listLiteral(
             [
                 AstFactory.identifier3("a"),
                 AstFactory.identifier3("b"),
                 AstFactory.identifier3("c")]));
   }
 
-  void test_visitMapLiteralEntry() {
-    _assertClone(AstFactory.mapLiteralEntry("a", AstFactory.identifier3("b")));
-  }
-
   void test_visitMapLiteral_const() {
     _assertClone(AstFactory.mapLiteral(Keyword.CONST, null));
   }
 
   void test_visitMapLiteral_empty() {
     _assertClone(AstFactory.mapLiteral2());
   }
 
   void test_visitMapLiteral_nonEmpty() {
     _assertClone(
         AstFactory.mapLiteral2(
             [
                 AstFactory.mapLiteralEntry("a", AstFactory.identifier3("a")),
                 AstFactory.mapLiteralEntry("b", AstFactory.identifier3("b")),
                 AstFactory.mapLiteralEntry("c", AstFactory.identifier3("c"))]));
   }
 
+  void test_visitMapLiteralEntry() {
+    _assertClone(AstFactory.mapLiteralEntry("a", AstFactory.identifier3("b")));
+  }
+
   void test_visitMethodDeclaration_external() {
     _assertClone(
         AstFactory.methodDeclaration(
             null,
             null,
             null,
             null,
             AstFactory.identifier3("m"),
             AstFactory.formalParameterList()));
   }
@@ skipping 158 matching lines @@
     declaration.metadata =
         [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertClone(declaration);
   }
 
   void test_visitMethodInvocation_noTarget() {
     _assertClone(AstFactory.methodInvocation2("m"));
   }
 
   void test_visitMethodInvocation_target() {
-    _assertClone(
-        AstFactory.methodInvocation(AstFactory.identifier3("t"), "m"));
+    _assertClone(AstFactory.methodInvocation(AstFactory.identifier3("t"), "m"));
   }
 
   void test_visitNamedExpression() {
     _assertClone(AstFactory.namedExpression2("a", AstFactory.identifier3("b")));
   }
 
   void test_visitNamedFormalParameter() {
     _assertClone(
         AstFactory.namedFormalParameter(
             AstFactory.simpleFormalParameter(Keyword.VAR, "a"),
@@ skipping 46 matching lines @@
         AstFactory.positionalFormalParameter(
             AstFactory.simpleFormalParameter(Keyword.VAR, "a"),
             AstFactory.integer(0)));
   }
 
   void test_visitPostfixExpression() {
     _assertClone(
         AstFactory.postfixExpression(AstFactory.identifier3("a"), TokenType.PLUS_PLUS));
   }
 
+  void test_visitPrefixedIdentifier() {
+    _assertClone(AstFactory.identifier5("a", "b"));
+  }
+
   void test_visitPrefixExpression() {
     _assertClone(
         AstFactory.prefixExpression(TokenType.MINUS, AstFactory.identifier3("a")));
   }
 
-  void test_visitPrefixedIdentifier() {
-    _assertClone(AstFactory.identifier5("a", "b"));
-  }
-
   void test_visitPropertyAccess() {
     _assertClone(AstFactory.propertyAccess2(AstFactory.identifier3("a"), "b"));
   }
 
   void test_visitRedirectingConstructorInvocation_named() {
     _assertClone(AstFactory.redirectingConstructorInvocation2("c"));
   }
 
   void test_visitRedirectingConstructorInvocation_unnamed() {
     _assertClone(AstFactory.redirectingConstructorInvocation());
@@ skipping 101 matching lines @@
     _assertClone(
         AstFactory.switchDefault2([AstFactory.block(), AstFactory.block()]));
   }
 
   void test_visitSwitchDefault_noLabels() {
     _assertClone(AstFactory.switchDefault2([AstFactory.block()]));
   }
 
   void test_visitSwitchDefault_singleLabel() {
     _assertClone(
-        AstFactory.switchDefault(
-            [AstFactory.label2("l1")],
-            [AstFactory.block()]));
+        AstFactory.switchDefault([AstFactory.label2("l1")], [AstFactory.block()]));
   }
 
   void test_visitSwitchStatement() {
     _assertClone(
         AstFactory.switchStatement(
             AstFactory.identifier3("a"),
             [
                 AstFactory.switchCase(AstFactory.string2("b"), [AstFactory.block()]),
                 AstFactory.switchDefault2([AstFactory.block()])]));
   }
@@ skipping 28 matching lines @@
             [AstFactory.variableDeclaration("a"), AstFactory.variableDeclaration("b")]));
   }
 
   void test_visitTryStatement_catch() {
     _assertClone(
         AstFactory.tryStatement2(
             AstFactory.block(),
             [AstFactory.catchClause3(AstFactory.typeName4("E"))]));
   }
 
-  void test_visitTryStatement_catchFinally() {
-    _assertClone(
-        AstFactory.tryStatement3(
-            AstFactory.block(),
-            [AstFactory.catchClause3(AstFactory.typeName4("E"))],
-            AstFactory.block()));
-  }
-
   void test_visitTryStatement_catches() {
     _assertClone(
         AstFactory.tryStatement2(
             AstFactory.block(),
             [
                 AstFactory.catchClause3(AstFactory.typeName4("E")),
                 AstFactory.catchClause3(AstFactory.typeName4("F"))]));
   }
 
+  void test_visitTryStatement_catchFinally() {
+    _assertClone(
+        AstFactory.tryStatement3(
+            AstFactory.block(),
+            [AstFactory.catchClause3(AstFactory.typeName4("E"))],
+            AstFactory.block()));
+  }
+
   void test_visitTryStatement_finally() {
     _assertClone(
         AstFactory.tryStatement(AstFactory.block(), AstFactory.block()));
   }
 
   void test_visitTypeArgumentList_multiple() {
     _assertClone(
         AstFactory.typeArgumentList(
             [AstFactory.typeName4("E"), AstFactory.typeName4("F")]));
   }
@@ skipping 17 matching lines @@
   }
 
   void test_visitTypeName_noArgs() {
     _assertClone(AstFactory.typeName4("C"));
   }
 
   void test_visitTypeName_singleArg() {
     _assertClone(AstFactory.typeName4("C", [AstFactory.typeName4("D")]));
   }
 
-  void test_visitTypeParameterList_multiple() {
-    _assertClone(AstFactory.typeParameterList(["E", "F"]));
-  }
-
-  void test_visitTypeParameterList_single() {
-    _assertClone(AstFactory.typeParameterList(["E"]));
-  }
-
   void test_visitTypeParameter_withExtends() {
     _assertClone(AstFactory.typeParameter2("E", AstFactory.typeName4("C")));
   }
 
   void test_visitTypeParameter_withMetadata() {
     TypeParameter parameter = AstFactory.typeParameter("E");
     parameter.metadata =
         [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
     _assertClone(parameter);
   }
 
   void test_visitTypeParameter_withoutExtends() {
     _assertClone(AstFactory.typeParameter("E"));
   }
 
+  void test_visitTypeParameterList_multiple() {
+    _assertClone(AstFactory.typeParameterList(["E", "F"]));
+  }
+
+  void test_visitTypeParameterList_single() {
+    _assertClone(AstFactory.typeParameterList(["E"]));
+  }
+
+  void test_visitVariableDeclaration_initialized() {
+    _assertClone(
+        AstFactory.variableDeclaration2("a", AstFactory.identifier3("b")));
+  }
+
+  void test_visitVariableDeclaration_uninitialized() {
+    _assertClone(AstFactory.variableDeclaration("a"));
+  }
+
+  void test_visitVariableDeclaration_withMetadata() {
+    VariableDeclaration declaration = AstFactory.variableDeclaration("a");
+    declaration.metadata =
+        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
+    _assertClone(declaration);
+  }
+
   void test_visitVariableDeclarationList_const_type() {
     _assertClone(
         AstFactory.variableDeclarationList(
             Keyword.CONST,
             AstFactory.typeName4("C"),
             [AstFactory.variableDeclaration("a"), AstFactory.variableDeclaration("b")]));
   }
 
   void test_visitVariableDeclarationList_final_noType() {
     _assertClone(
@@ skipping 28 matching lines @@
   }
 
   void test_visitVariableDeclarationStatement() {
     _assertClone(
         AstFactory.variableDeclarationStatement(
             null,
             AstFactory.typeName4("C"),
             [AstFactory.variableDeclaration("c")]));
   }
 
-  void test_visitVariableDeclaration_initialized() {
-    _assertClone(
-        AstFactory.variableDeclaration2("a", AstFactory.identifier3("b")));
-  }
-
-  void test_visitVariableDeclaration_uninitialized() {
-    _assertClone(AstFactory.variableDeclaration("a"));
-  }
-
-  void test_visitVariableDeclaration_withMetadata() {
-    VariableDeclaration declaration = AstFactory.variableDeclaration("a");
-    declaration.metadata =
-        [AstFactory.annotation(AstFactory.identifier3("deprecated"))];
-    _assertClone(declaration);
-  }
-
   void test_visitWhileStatement() {
     _assertClone(
         AstFactory.whileStatement(AstFactory.identifier3("c"), AstFactory.block()));
   }
 
   void test_visitWithClause_multiple() {
     _assertClone(
         AstFactory.withClause(
             [
                 AstFactory.typeName4("A"),
@@ skipping 24 matching lines @@
     }
 
     clone = node.accept(new AstCloner(true));
     comparitor = new AstCloneComparator(true);
     if (!comparitor.isEqualNodes(node, clone)) {
       fail("Failed to clone ${node.runtimeType.toString()}");
     }
   }
 }
 
-class AstCloneComparator extends AstComparator {
-  final bool expectTokensCopied;
-
-  AstCloneComparator(this.expectTokensCopied);
-
-  @override
-  bool isEqualNodes(AstNode first, AstNode second) {
-    if (first != null && identical(first, second)) {
-      fail('Failed to copy node: $first (${first.offset})');
-      return false;
-    }
-    return super.isEqualNodes(first, second);
-  }
-
-  @override
-  bool isEqualTokens(Token first, Token second) {
-    if (expectTokensCopied && first != null && identical(first, second)) {
-      fail('Failed to copy token: ${first.lexeme} (${first.offset})');
-      return false;
-    }
-    return super.isEqualTokens(first, second);
-  }
-}
-
 class BooleanArrayTest {
   void test_get_negative() {
     try {
       BooleanArray.get(0, -1);
       fail("Expected ");
     } on RangeError catch (exception) {
       // Expected
     }
   }
 
@@ skipping 309 matching lines @@
     expect(topologicalSort[1], unorderedEquals([node1, node2]));
   }
 }
 
 /**
  * Instances of the class `Node` represent simple nodes used for testing purposes.
  */
 class DirectedGraphTest_Node {
 }
 
-class Getter_NodeReplacerTest_testAnnotatedNode implements
-    NodeReplacerTest_Getter {
-  @override
-  Comment get(AnnotatedNode node) => node.documentationComment;
-}
-
-class Getter_NodeReplacerTest_testNormalFormalParameter implements
-    NodeReplacerTest_Getter {
-  @override
-  SimpleIdentifier get(NormalFormalParameter node) => node.identifier;
-}
-
-class Getter_NodeReplacerTest_testNormalFormalParameter_2 implements
-    NodeReplacerTest_Getter {
-  @override
-  Comment get(NormalFormalParameter node) => node.documentationComment;
-}
-
-class Getter_NodeReplacerTest_testTypedLiteral implements
-    NodeReplacerTest_Getter {
-  @override
-  TypeArgumentList get(TypedLiteral node) => node.typeArguments;
-}
-
-class Getter_NodeReplacerTest_testUriBasedDirective implements
-    NodeReplacerTest_Getter {
-  @override
-  StringLiteral get(UriBasedDirective node) => node.uri;
-}
-
 class Getter_NodeReplacerTest_test_annotation implements NodeReplacerTest_Getter
     {
   @override
   ArgumentList get(Annotation node) => node.arguments;
 }
 
 class Getter_NodeReplacerTest_test_annotation_2 implements
     NodeReplacerTest_Getter {
   @override
   Identifier get(Annotation node) => node.name;
@@ skipping 395 matching lines @@
   @override
   Expression get(ForStatement node) => node.condition;
 }
 
 class Getter_NodeReplacerTest_test_functionDeclaration implements
     NodeReplacerTest_Getter {
   @override
   TypeName get(FunctionDeclaration node) => node.returnType;
 }
 
-class Getter_NodeReplacerTest_test_functionDeclarationStatement implements
-    NodeReplacerTest_Getter {
-  @override
-  FunctionDeclaration get(FunctionDeclarationStatement node) =>
-      node.functionDeclaration;
-}
-
 class Getter_NodeReplacerTest_test_functionDeclaration_2 implements
     NodeReplacerTest_Getter {
   @override
   FunctionExpression get(FunctionDeclaration node) => node.functionExpression;
 }
 
 class Getter_NodeReplacerTest_test_functionDeclaration_3 implements
     NodeReplacerTest_Getter {
   @override
   SimpleIdentifier get(FunctionDeclaration node) => node.name;
 }
 
+class Getter_NodeReplacerTest_test_functionDeclarationStatement implements
+    NodeReplacerTest_Getter {
+  @override
+  FunctionDeclaration get(FunctionDeclarationStatement node) =>
+      node.functionDeclaration;
+}
+
 class Getter_NodeReplacerTest_test_functionExpression implements
     NodeReplacerTest_Getter {
   @override
   FormalParameterList get(FunctionExpression node) => node.parameters;
 }
 
+class Getter_NodeReplacerTest_test_functionExpression_2 implements
+    NodeReplacerTest_Getter {
+  @override
+  FunctionBody get(FunctionExpression node) => node.body;
+}
+
 class Getter_NodeReplacerTest_test_functionExpressionInvocation implements
     NodeReplacerTest_Getter {
   @override
   Expression get(FunctionExpressionInvocation node) => node.function;
 }
 
 class Getter_NodeReplacerTest_test_functionExpressionInvocation_2 implements
     NodeReplacerTest_Getter {
   @override
   ArgumentList get(FunctionExpressionInvocation node) => node.argumentList;
 }
 
-class Getter_NodeReplacerTest_test_functionExpression_2 implements
-    NodeReplacerTest_Getter {
-  @override
-  FunctionBody get(FunctionExpression node) => node.body;
-}
-
 class Getter_NodeReplacerTest_test_functionTypeAlias implements
     NodeReplacerTest_Getter {
   @override
   TypeParameterList get(FunctionTypeAlias node) => node.typeParameters;
 }
 
 class Getter_NodeReplacerTest_test_functionTypeAlias_2 implements
     NodeReplacerTest_Getter {
   @override
   FormalParameterList get(FunctionTypeAlias node) => node.parameters;
@@ skipping 195 matching lines @@
   @override
   LibraryIdentifier get(PartOfDirective node) => node.libraryName;
 }
 
 class Getter_NodeReplacerTest_test_postfixExpression implements
     NodeReplacerTest_Getter {
   @override
   Expression get(PostfixExpression node) => node.operand;
 }
 
-class Getter_NodeReplacerTest_test_prefixExpression implements
-    NodeReplacerTest_Getter {
-  @override
-  Expression get(PrefixExpression node) => node.operand;
-}
-
 class Getter_NodeReplacerTest_test_prefixedIdentifier implements
     NodeReplacerTest_Getter {
   @override
   SimpleIdentifier get(PrefixedIdentifier node) => node.identifier;
 }
 
 class Getter_NodeReplacerTest_test_prefixedIdentifier_2 implements
     NodeReplacerTest_Getter {
   @override
   SimpleIdentifier get(PrefixedIdentifier node) => node.prefix;
 }
 
+class Getter_NodeReplacerTest_test_prefixExpression implements
+    NodeReplacerTest_Getter {
+  @override
+  Expression get(PrefixExpression node) => node.operand;
+}
+
 class Getter_NodeReplacerTest_test_propertyAccess implements
     NodeReplacerTest_Getter {
   @override
   Expression get(PropertyAccess node) => node.target;
 }
 
 class Getter_NodeReplacerTest_test_propertyAccess_2 implements
     NodeReplacerTest_Getter {
   @override
   SimpleIdentifier get(PropertyAccess node) => node.propertyName;
@@ skipping 95 matching lines @@
   @override
   SimpleIdentifier get(TypeParameter node) => node.name;
 }
 
 class Getter_NodeReplacerTest_test_variableDeclaration implements
     NodeReplacerTest_Getter {
   @override
   SimpleIdentifier get(VariableDeclaration node) => node.name;
 }
 
+class Getter_NodeReplacerTest_test_variableDeclaration_2 implements
+    NodeReplacerTest_Getter {
+  @override
+  Expression get(VariableDeclaration node) => node.initializer;
+}
+
 class Getter_NodeReplacerTest_test_variableDeclarationList implements
     NodeReplacerTest_Getter {
   @override
   TypeName get(VariableDeclarationList node) => node.type;
 }
 
 class Getter_NodeReplacerTest_test_variableDeclarationStatement implements
     NodeReplacerTest_Getter {
   @override
   VariableDeclarationList get(VariableDeclarationStatement node) =>
       node.variables;
 }
 
-class Getter_NodeReplacerTest_test_variableDeclaration_2 implements
-    NodeReplacerTest_Getter {
-  @override
-  Expression get(VariableDeclaration node) => node.initializer;
-}
-
 class Getter_NodeReplacerTest_test_whileStatement implements
     NodeReplacerTest_Getter {
   @override
   Expression get(WhileStatement node) => node.condition;
 }
 
 class Getter_NodeReplacerTest_test_whileStatement_2 implements
     NodeReplacerTest_Getter {
   @override
   Statement get(WhileStatement node) => node.body;
 }
 
+class Getter_NodeReplacerTest_testAnnotatedNode implements
+    NodeReplacerTest_Getter {
+  @override
+  Comment get(AnnotatedNode node) => node.documentationComment;
+}
+
+class Getter_NodeReplacerTest_testNormalFormalParameter implements
+    NodeReplacerTest_Getter {
+  @override
+  SimpleIdentifier get(NormalFormalParameter node) => node.identifier;
+}
+
+class Getter_NodeReplacerTest_testNormalFormalParameter_2 implements
+    NodeReplacerTest_Getter {
+  @override
+  Comment get(NormalFormalParameter node) => node.documentationComment;
+}
+
+class Getter_NodeReplacerTest_testTypedLiteral implements
+    NodeReplacerTest_Getter {
+  @override
+  TypeArgumentList get(TypedLiteral node) => node.typeArguments;
+}
+
+class Getter_NodeReplacerTest_testUriBasedDirective implements
+    NodeReplacerTest_Getter {
+  @override
+  StringLiteral get(UriBasedDirective node) => node.uri;
+}
+
 class LineInfoTest {
   void test_creation() {
     expect(new LineInfo(<int>[0]), isNotNull);
   }
 
   void test_creation_empty() {
     try {
       new LineInfo(<int>[]);
       fail("Expected IllegalArgumentException");
     } on IllegalArgumentException catch (exception) {
@@ skipping 25 matching lines @@
   }
 
   void test_middleLine() {
     LineInfo info = new LineInfo(<int>[0, 12, 34]);
     LineInfo_Location location = info.getLocation(12);
     expect(location.lineNumber, 2);
     expect(location.columnNumber, 1);
   }
 }
 
-class ListGetter_NodeReplacerTest_testAnnotatedNode extends
-    NodeReplacerTest_ListGetter<AnnotatedNode, Annotation> {
-  ListGetter_NodeReplacerTest_testAnnotatedNode(int arg0) : super(arg0);
-
-  @override
-  NodeList<Annotation> getList(AnnotatedNode node) => node.metadata;
-}
-
-class ListGetter_NodeReplacerTest_testNamespaceDirective extends
-    NodeReplacerTest_ListGetter<NamespaceDirective, Combinator> {
-  ListGetter_NodeReplacerTest_testNamespaceDirective(int arg0) : super(arg0);
-
-  @override
-  NodeList<Combinator> getList(NamespaceDirective node) => node.combinators;
-}
-
-class ListGetter_NodeReplacerTest_testNormalFormalParameter extends
-    NodeReplacerTest_ListGetter<NormalFormalParameter, Annotation> {
-  ListGetter_NodeReplacerTest_testNormalFormalParameter(int arg0) : super(arg0);
-
-  @override
-  NodeList<Annotation> getList(NormalFormalParameter node) => node.metadata;
-}
-
-class ListGetter_NodeReplacerTest_testSwitchMember extends
-    NodeReplacerTest_ListGetter<SwitchMember, Label> {
-  ListGetter_NodeReplacerTest_testSwitchMember(int arg0) : super(arg0);
-
-  @override
-  NodeList<Label> getList(SwitchMember node) => node.labels;
-}
-
-class ListGetter_NodeReplacerTest_testSwitchMember_2 extends
-    NodeReplacerTest_ListGetter<SwitchMember, Statement> {
-  ListGetter_NodeReplacerTest_testSwitchMember_2(int arg0) : super(arg0);
-
-  @override
-  NodeList<Statement> getList(SwitchMember node) => node.statements;
-}
-
 class ListGetter_NodeReplacerTest_test_adjacentStrings extends
     NodeReplacerTest_ListGetter<AdjacentStrings, StringLiteral> {
   ListGetter_NodeReplacerTest_test_adjacentStrings(int arg0) : super(arg0);
 
   @override
   NodeList<StringLiteral> getList(AdjacentStrings node) => node.strings;
 }
 
 class ListGetter_NodeReplacerTest_test_adjacentStrings_2 extends
     NodeReplacerTest_ListGetter<AdjacentStrings, StringLiteral> {
@@ skipping 63 matching lines @@
 class ListGetter_NodeReplacerTest_test_constructorDeclaration extends
     NodeReplacerTest_ListGetter<ConstructorDeclaration, ConstructorInitializer> {
   ListGetter_NodeReplacerTest_test_constructorDeclaration(int arg0)
       : super(arg0);
 
   @override
   NodeList<ConstructorInitializer> getList(ConstructorDeclaration node) =>
       node.initializers;
 }
 
+class ListGetter_NodeReplacerTest_test_formalParameterList extends
+    NodeReplacerTest_ListGetter<FormalParameterList, FormalParameter> {
+  ListGetter_NodeReplacerTest_test_formalParameterList(int arg0) : super(arg0);
+
+  @override
+  NodeList<FormalParameter> getList(FormalParameterList node) =>
+      node.parameters;
+}
+
 class ListGetter_NodeReplacerTest_test_forStatement_withInitialization extends
     NodeReplacerTest_ListGetter<ForStatement, Expression> {
   ListGetter_NodeReplacerTest_test_forStatement_withInitialization(int arg0)
       : super(arg0);
 
   @override
   NodeList<Expression> getList(ForStatement node) => node.updaters;
 }
 
 class ListGetter_NodeReplacerTest_test_forStatement_withVariables extends
     NodeReplacerTest_ListGetter<ForStatement, Expression> {
   ListGetter_NodeReplacerTest_test_forStatement_withVariables(int arg0)
       : super(arg0);
 
   @override
   NodeList<Expression> getList(ForStatement node) => node.updaters;
 }
 
-class ListGetter_NodeReplacerTest_test_formalParameterList extends
-    NodeReplacerTest_ListGetter<FormalParameterList, FormalParameter> {
-  ListGetter_NodeReplacerTest_test_formalParameterList(int arg0) : super(arg0);
-
-  @override
-  NodeList<FormalParameter> getList(FormalParameterList node) =>
-      node.parameters;
-}
-
 class ListGetter_NodeReplacerTest_test_hideCombinator extends
     NodeReplacerTest_ListGetter<HideCombinator, SimpleIdentifier> {
   ListGetter_NodeReplacerTest_test_hideCombinator(int arg0) : super(arg0);
 
   @override
   NodeList<SimpleIdentifier> getList(HideCombinator node) => node.hiddenNames;
 }
 
 class ListGetter_NodeReplacerTest_test_implementsClause extends
     NodeReplacerTest_ListGetter<ImplementsClause, TypeName> {
@@ skipping 96 matching lines @@
 }
 
 class ListGetter_NodeReplacerTest_test_withClause extends
     NodeReplacerTest_ListGetter<WithClause, TypeName> {
   ListGetter_NodeReplacerTest_test_withClause(int arg0) : super(arg0);
 
   @override
   NodeList<TypeName> getList(WithClause node) => node.mixinTypes;
 }
 
+class ListGetter_NodeReplacerTest_testAnnotatedNode extends
+    NodeReplacerTest_ListGetter<AnnotatedNode, Annotation> {
+  ListGetter_NodeReplacerTest_testAnnotatedNode(int arg0) : super(arg0);
+
+  @override
+  NodeList<Annotation> getList(AnnotatedNode node) => node.metadata;
+}
+
+class ListGetter_NodeReplacerTest_testNamespaceDirective extends
+    NodeReplacerTest_ListGetter<NamespaceDirective, Combinator> {
+  ListGetter_NodeReplacerTest_testNamespaceDirective(int arg0) : super(arg0);
+
+  @override
+  NodeList<Combinator> getList(NamespaceDirective node) => node.combinators;
+}
+
+class ListGetter_NodeReplacerTest_testNormalFormalParameter extends
+    NodeReplacerTest_ListGetter<NormalFormalParameter, Annotation> {
+  ListGetter_NodeReplacerTest_testNormalFormalParameter(int arg0) : super(arg0);
+
+  @override
+  NodeList<Annotation> getList(NormalFormalParameter node) => node.metadata;
+}
+
+class ListGetter_NodeReplacerTest_testSwitchMember extends
+    NodeReplacerTest_ListGetter<SwitchMember, Label> {
+  ListGetter_NodeReplacerTest_testSwitchMember(int arg0) : super(arg0);
+
+  @override
+  NodeList<Label> getList(SwitchMember node) => node.labels;
+}
+
+class ListGetter_NodeReplacerTest_testSwitchMember_2 extends
+    NodeReplacerTest_ListGetter<SwitchMember, Statement> {
+  ListGetter_NodeReplacerTest_testSwitchMember_2(int arg0) : super(arg0);
+
+  @override
+  NodeList<Statement> getList(SwitchMember node) => node.statements;
+}
+
 class ListUtilitiesTest {
   void test_addAll_emptyToEmpty() {
     List<String> list = new List<String>();
     List<String> elements = <String>[];
     ListUtilities.addAll(list, elements);
     expect(list.length, 0);
   }
 
   void test_addAll_emptyToNonEmpty() {
     List<String> list = new List<String>();
@@ skipping 164 matching lines @@
   }
 
   void test_argumentList() {
     ArgumentList node = AstFactory.argumentList([AstFactory.integer(0)]);
     _assertReplace(node, new ListGetter_NodeReplacerTest_test_argumentList(0));
   }
 
   void test_asExpression() {
     AsExpression node = AstFactory.asExpression(
         AstFactory.integer(0),
-        AstFactory.typeName3(
-            AstFactory.identifier3("a"),
-            [AstFactory.typeName4("C")]));
+        AstFactory.typeName3(AstFactory.identifier3("a"), [AstFactory.typeName4("C")]));
     _assertReplace(node, new Getter_NodeReplacerTest_test_asExpression_2());
     _assertReplace(node, new Getter_NodeReplacerTest_test_asExpression());
   }
 
   void test_assertStatement() {
     AssertStatement node =
         AstFactory.assertStatement(AstFactory.booleanLiteral(true));
     _assertReplace(node, new Getter_NodeReplacerTest_test_assertStatement());
   }
 
@@ skipping 113 matching lines @@
   void test_commentReference() {
     CommentReference node =
         new CommentReference(null, AstFactory.identifier3("x"));
     _assertReplace(node, new Getter_NodeReplacerTest_test_commentReference());
   }
 
   void test_compilationUnit() {
     CompilationUnit node = AstFactory.compilationUnit8(
         "",
         [AstFactory.libraryDirective2("lib")],
-        [AstFactory.topLevelVariableDeclaration2(
-            null,
-            [AstFactory.variableDeclaration("X")])]);
+        [
+            AstFactory.topLevelVariableDeclaration2(
+                null,
+                [AstFactory.variableDeclaration("X")])]);
     _assertReplace(node, new Getter_NodeReplacerTest_test_compilationUnit());
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_compilationUnit(0));
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_compilationUnit_2(0));
   }
 
   void test_conditionalExpression() {
@@ skipping 16 matching lines @@
     ConstructorDeclaration node = AstFactory.constructorDeclaration2(
         null,
         null,
         AstFactory.identifier3("C"),
         "d",
         AstFactory.formalParameterList(),
         [AstFactory.constructorFieldInitializer(false, "x", AstFactory.integer(0))],
         AstFactory.emptyFunctionBody());
     node.documentationComment =
         Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
-    node.metadata =
-        [AstFactory.annotation(AstFactory.identifier3("a"))];
+    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
     node.redirectedConstructor =
         AstFactory.constructorName(AstFactory.typeName4("B"), "a");
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_constructorDeclaration_3());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_constructorDeclaration_2());
     _assertReplace(
         node,
@@ skipping 31 matching lines @@
   void test_continueStatement() {
     ContinueStatement node = AstFactory.continueStatement("l");
     _assertReplace(node, new Getter_NodeReplacerTest_test_continueStatement());
   }
 
   void test_declaredIdentifier() {
     DeclaredIdentifier node =
         AstFactory.declaredIdentifier4(AstFactory.typeName4("C"), "i");
     node.documentationComment =
         Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
-    node.metadata =
-        [AstFactory.annotation(AstFactory.identifier3("a"))];
+    node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
     _assertReplace(node, new Getter_NodeReplacerTest_test_declaredIdentifier());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_declaredIdentifier_2());
     _testAnnotatedNode(node);
   }
 
   void test_defaultFormalParameter() {
     DefaultFormalParameter node = AstFactory.positionalFormalParameter(
         AstFactory.simpleFormalParameter3("p"),
@@ skipping 19 matching lines @@
         [AstFactory.annotation(AstFactory.identifier3("a"))],
         AstFactory.identifier3("C"));
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_enumConstantDeclaration());
     _testAnnotatedNode(node);
   }
 
   void test_enumDeclaration() {
     EnumDeclaration node = AstFactory.enumDeclaration2("E", ["ONE", "TWO"]);
-    node.documentationComment
-        = Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
+    node.documentationComment =
+        Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
     node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
     _assertReplace(node, new Getter_NodeReplacerTest_test_enumDeclaration());
     _testAnnotatedNode(node);
   }
 
   void test_exportDirective() {
     ExportDirective node =
         AstFactory.exportDirective2("", [AstFactory.hideCombinator2(["C"])]);
     node.documentationComment =
         Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
@@ skipping 11 matching lines @@
 
   void test_expressionStatement() {
     ExpressionStatement node =
         AstFactory.expressionStatement(AstFactory.integer(0));
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_expressionStatement());
   }
 
   void test_extendsClause() {
-    ExtendsClause node =
-        AstFactory.extendsClause(AstFactory.typeName4("S"));
+    ExtendsClause node = AstFactory.extendsClause(AstFactory.typeName4("S"));
     _assertReplace(node, new Getter_NodeReplacerTest_test_extendsClause());
   }
 
   void test_fieldDeclaration() {
     FieldDeclaration node = AstFactory.fieldDeclaration(
         false,
         null,
         AstFactory.typeName4("C"),
         [AstFactory.variableDeclaration("c")]);
     node.documentationComment =
@@ skipping 46 matching lines @@
         node,
         new Getter_NodeReplacerTest_test_forEachStatement_withLoopVariable_2());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_forEachStatement_withLoopVariable());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_forEachStatement_withLoopVariable_3());
   }
 
+  void test_formalParameterList() {
+    FormalParameterList node =
+        AstFactory.formalParameterList([AstFactory.simpleFormalParameter3("p")]);
+    _assertReplace(
+        node,
+        new ListGetter_NodeReplacerTest_test_formalParameterList(0));
+  }
+
   void test_forStatement_withInitialization() {
     ForStatement node = AstFactory.forStatement(
         AstFactory.identifier3("a"),
         AstFactory.booleanLiteral(true),
         [AstFactory.integer(0)],
         AstFactory.block());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_forStatement_withInitialization_3());
     _assertReplace(
@@ skipping 22 matching lines @@
         node,
         new Getter_NodeReplacerTest_test_forStatement_withVariables_3());
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_forStatement_withVariables());
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_forStatement_withVariables(0));
   }
 
-  void test_formalParameterList() {
-    FormalParameterList node =
-        AstFactory.formalParameterList([AstFactory.simpleFormalParameter3("p")]);
-    _assertReplace(
-        node,
-        new ListGetter_NodeReplacerTest_test_formalParameterList(0));
-  }
-
   void test_functionDeclaration() {
     FunctionDeclaration node = AstFactory.functionDeclaration(
         AstFactory.typeName4("R"),
         null,
         "f",
         AstFactory.functionExpression2(
             AstFactory.formalParameterList(),
             AstFactory.blockFunctionBody(AstFactory.block())));
     node.documentationComment =
         Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
@@ skipping 158 matching lines @@
     _assertReplace(node, new Getter_NodeReplacerTest_test_isExpression());
     _assertReplace(node, new Getter_NodeReplacerTest_test_isExpression_2());
   }
 
   void test_label() {
     Label node = AstFactory.label2("l");
     _assertReplace(node, new Getter_NodeReplacerTest_test_label());
   }
 
   void test_labeledStatement() {
-    LabeledStatement node = AstFactory.labeledStatement(
-        [AstFactory.label2("l")],
-        AstFactory.block());
+    LabeledStatement node =
+        AstFactory.labeledStatement([AstFactory.label2("l")], AstFactory.block());
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_labeledStatement(0));
     _assertReplace(node, new Getter_NodeReplacerTest_test_labeledStatement());
   }
 
   void test_libraryDirective() {
     LibraryDirective node = AstFactory.libraryDirective2("lib");
     node.documentationComment =
         Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
@@ skipping 112 matching lines @@
     _testAnnotatedNode(node);
   }
 
   void test_postfixExpression() {
     PostfixExpression node = AstFactory.postfixExpression(
         AstFactory.identifier3("x"),
         TokenType.MINUS_MINUS);
     _assertReplace(node, new Getter_NodeReplacerTest_test_postfixExpression());
   }
 
-  void test_prefixExpression() {
-    PrefixExpression node =
-        AstFactory.prefixExpression(TokenType.PLUS_PLUS, AstFactory.identifier3("y"));
-    _assertReplace(node, new Getter_NodeReplacerTest_test_prefixExpression());
-  }
-
   void test_prefixedIdentifier() {
     PrefixedIdentifier node = AstFactory.identifier5("a", "b");
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_prefixedIdentifier_2());
     _assertReplace(node, new Getter_NodeReplacerTest_test_prefixedIdentifier());
   }
 
+  void test_prefixExpression() {
+    PrefixExpression node =
+        AstFactory.prefixExpression(TokenType.PLUS_PLUS, AstFactory.identifier3("y"));
+    _assertReplace(node, new Getter_NodeReplacerTest_test_prefixExpression());
+  }
+
   void test_propertyAccess() {
     PropertyAccess node =
         AstFactory.propertyAccess2(AstFactory.identifier3("x"), "y");
     _assertReplace(node, new Getter_NodeReplacerTest_test_propertyAccess());
     _assertReplace(node, new Getter_NodeReplacerTest_test_propertyAccess_2());
   }
 
   void test_redirectingConstructorInvocation() {
     RedirectingConstructorInvocation node =
         AstFactory.redirectingConstructorInvocation2("c", [AstFactory.integer(0)]);
@@ skipping 51 matching lines @@
   void test_switchCase() {
     SwitchCase node = AstFactory.switchCase2(
         [AstFactory.label2("l")],
         AstFactory.integer(0),
         [AstFactory.block()]);
     _assertReplace(node, new Getter_NodeReplacerTest_test_switchCase());
     _testSwitchMember(node);
   }
 
   void test_switchDefault() {
-    SwitchDefault node = AstFactory.switchDefault(
-        [AstFactory.label2("l")],
-        [AstFactory.block()]);
+    SwitchDefault node =
+        AstFactory.switchDefault([AstFactory.label2("l")], [AstFactory.block()]);
     _testSwitchMember(node);
   }
 
   void test_switchStatement() {
     SwitchStatement node = AstFactory.switchStatement(
         AstFactory.identifier3("x"),
         [
             AstFactory.switchCase2(
                 [AstFactory.label2("l")],
                 AstFactory.integer(0),
                 [AstFactory.block()]),
-            AstFactory.switchDefault(
-                [AstFactory.label2("l")],
-                [AstFactory.block()])]);
+            AstFactory.switchDefault([AstFactory.label2("l")], [AstFactory.block()])]);
     _assertReplace(node, new Getter_NodeReplacerTest_test_switchStatement());
     _assertReplace(
         node,
         new ListGetter_NodeReplacerTest_test_switchStatement(0));
   }
 
   void test_throwExpression() {
     ThrowExpression node =
         AstFactory.throwExpression2(AstFactory.identifier3("e"));
     _assertReplace(node, new Getter_NodeReplacerTest_test_throwExpression());
@@ skipping 85 matching lines @@
     VariableDeclarationStatement node = AstFactory.variableDeclarationStatement(
         null,
         AstFactory.typeName4("T"),
         [AstFactory.variableDeclaration("a")]);
     _assertReplace(
         node,
         new Getter_NodeReplacerTest_test_variableDeclarationStatement());
   }
 
   void test_whileStatement() {
-    WhileStatement node = AstFactory.whileStatement(
-        AstFactory.booleanLiteral(true),
-        AstFactory.block());
+    WhileStatement node =
+        AstFactory.whileStatement(AstFactory.booleanLiteral(true), AstFactory.block());
     _assertReplace(node, new Getter_NodeReplacerTest_test_whileStatement());
     _assertReplace(node, new Getter_NodeReplacerTest_test_whileStatement_2());
   }
 
   void test_withClause() {
     WithClause node = AstFactory.withClause([AstFactory.typeName4("M")]);
     _assertReplace(node, new ListGetter_NodeReplacerTest_test_withClause(0));
   }
 
   void _assertReplace(AstNode parent, NodeReplacerTest_Getter getter) {
@@ skipping 216 matching lines @@
   }
 
   void test_getTranslated() {
     SourceRange r = new SourceRange(5, 3);
     expect(r.getTranslated(0), r);
     expect(r.getTranslated(2), new SourceRange(7, 3));
     expect(r.getTranslated(-1), new SourceRange(4, 3));
   }
 
   void test_getUnion() {
-    expect(new SourceRange(10, 10).getUnion(new SourceRange(15, 10)), new SourceRange(10, 15));
-    expect(new SourceRange(15, 10).getUnion(new SourceRange(10, 10)), new SourceRange(10, 15));
+    expect(
+        new SourceRange(10, 10).getUnion(new SourceRange(15, 10)),
+        new SourceRange(10, 15));
+    expect(
+        new SourceRange(15, 10).getUnion(new SourceRange(10, 10)),
+        new SourceRange(10, 15));
     // "other" is covered/covers
-    expect(new SourceRange(10, 10).getUnion(new SourceRange(15, 2)), new SourceRange(10, 10));
-    expect(new SourceRange(15, 2).getUnion(new SourceRange(10, 10)), new SourceRange(10, 10));
+    expect(
+        new SourceRange(10, 10).getUnion(new SourceRange(15, 2)),
+        new SourceRange(10, 10));
+    expect(
+        new SourceRange(15, 2).getUnion(new SourceRange(10, 10)),
+        new SourceRange(10, 10));
   }
 
   void test_intersects() {
     SourceRange r = new SourceRange(5, 3);
     // null
     expect(r.intersects(null), isFalse);
     // ends before
     expect(r.intersects(new SourceRange(0, 5)), isFalse);
     // begins after
     expect(r.intersects(new SourceRange(8, 5)), isFalse);
@@ skipping 65 matching lines @@
     expect(StringUtilities.indexOf2("abcdef", 0, 0x64, 0x61), -1);
     expect(StringUtilities.indexOf2("abcdef", 1, 0x61, 0x62), -1);
     // before start
   }
 
   void test_indexOf4() {
     expect(StringUtilities.indexOf4("abcd", 0, 0x61, 0x62, 0x63, 0x64), 0);
     expect(StringUtilities.indexOf4("abcdefghi", 0, 0x61, 0x62, 0x63, 0x64), 0);
     expect(StringUtilities.indexOf4("abcdefghi", 0, 0x63, 0x64, 0x65, 0x66), 2);
     expect(StringUtilities.indexOf4("abcdefghi", 0, 0x66, 0x67, 0x68, 0x69), 5);
-    expect(StringUtilities.indexOf4("abcdefghi", 0, 0x64, 0x65, 0x61, 0x64), -1);
-    expect(StringUtilities.indexOf4("abcdefghi", 1, 0x61, 0x62, 0x63, 0x64), -1);
+    expect(
+        StringUtilities.indexOf4("abcdefghi", 0, 0x64, 0x65, 0x61, 0x64),
+        -1);
+    expect(
+        StringUtilities.indexOf4("abcdefghi", 1, 0x61, 0x62, 0x63, 0x64),
+        -1);
     // before start
   }
 
   void test_indexOf5() {
-    expect(StringUtilities.indexOf5("abcde", 0, 0x61, 0x62, 0x63, 0x64, 0x65), 0);
-    expect(StringUtilities.indexOf5("abcdefghi", 0, 0x61, 0x62, 0x63, 0x64, 0x65), 0);
-    expect(StringUtilities.indexOf5("abcdefghi", 0, 0x63, 0x64, 0x65, 0x66, 0x67), 2);
-    expect(StringUtilities.indexOf5("abcdefghi", 0, 0x65, 0x66, 0x67, 0x68, 0x69), 4);
-    expect(StringUtilities.indexOf5("abcdefghi", 0, 0x64, 0x65, 0x66, 0x69, 0x6E), -1);
-    expect(StringUtilities.indexOf5("abcdefghi", 1, 0x61, 0x62, 0x63, 0x64, 0x65), -1);
+    expect(
+        StringUtilities.indexOf5("abcde", 0, 0x61, 0x62, 0x63, 0x64, 0x65),
+        0);
+    expect(
+        StringUtilities.indexOf5("abcdefghi", 0, 0x61, 0x62, 0x63, 0x64, 0x65),
+        0);
+    expect(
+        StringUtilities.indexOf5("abcdefghi", 0, 0x63, 0x64, 0x65, 0x66, 0x67),
+        2);
+    expect(
+        StringUtilities.indexOf5("abcdefghi", 0, 0x65, 0x66, 0x67, 0x68, 0x69),
+        4);
+    expect(
+        StringUtilities.indexOf5("abcdefghi", 0, 0x64, 0x65, 0x66, 0x69, 0x6E),
+        -1);
+    expect(
+        StringUtilities.indexOf5("abcdefghi", 1, 0x61, 0x62, 0x63, 0x64, 0x65),
+        -1);
     // before start
   }
 
   void test_isEmpty() {
     expect(StringUtilities.isEmpty(""), isTrue);
     expect(StringUtilities.isEmpty(" "), isFalse);
     expect(StringUtilities.isEmpty("a"), isFalse);
     expect(StringUtilities.isEmpty(StringUtilities.EMPTY), isTrue);
   }
 
@@ skipping 13 matching lines @@
   void test_printListOfQuotedNames_empty() {
     try {
       StringUtilities.printListOfQuotedNames(new List<String>(0));
       fail("Expected IllegalArgumentException");
     } on IllegalArgumentException catch (exception) {
       // Expected
     }
   }
 
   void test_printListOfQuotedNames_five() {
-    expect(StringUtilities.printListOfQuotedNames(<String>["a", "b", "c", "d", "e"]), "'a', 'b', 'c', 'd' and 'e'");
+    expect(
+        StringUtilities.printListOfQuotedNames(<String>["a", "b", "c", "d", "e"]),
+        "'a', 'b', 'c', 'd' and 'e'");
   }
 
   void test_printListOfQuotedNames_null() {
     try {
       StringUtilities.printListOfQuotedNames(null);
       fail("Expected IllegalArgumentException");
     } on IllegalArgumentException catch (exception) {
       // Expected
     }
   }
 
   void test_printListOfQuotedNames_one() {
     try {
       StringUtilities.printListOfQuotedNames(<String>["a"]);
       fail("Expected IllegalArgumentException");
     } on IllegalArgumentException catch (exception) {
       // Expected
     }
   }
 
   void test_printListOfQuotedNames_three() {
-    expect(StringUtilities.printListOfQuotedNames(<String>["a", "b", "c"]), "'a', 'b' and 'c'");
+    expect(
+        StringUtilities.printListOfQuotedNames(<String>["a", "b", "c"]),
+        "'a', 'b' and 'c'");
   }
 
   void test_printListOfQuotedNames_two() {
-    expect(StringUtilities.printListOfQuotedNames(<String>["a", "b"]), "'a' and 'b'");
+    expect(
+        StringUtilities.printListOfQuotedNames(<String>["a", "b"]),
+        "'a' and 'b'");
   }
 
   void test_startsWith2() {
     expect(StringUtilities.startsWith2("ab", 0, 0x61, 0x62), isTrue);
     expect(StringUtilities.startsWith2("abcdefghi", 0, 0x61, 0x62), isTrue);
     expect(StringUtilities.startsWith2("abcdefghi", 2, 0x63, 0x64), isTrue);
     expect(StringUtilities.startsWith2("abcdefghi", 5, 0x66, 0x67), isTrue);
     expect(StringUtilities.startsWith2("abcdefghi", 0, 0x64, 0x64), isFalse);
     // missing
   }
 
   void test_startsWith3() {
     expect(StringUtilities.startsWith3("abc", 0, 0x61, 0x62, 0x63), isTrue);
-    expect(StringUtilities.startsWith3("abcdefghi", 0, 0x61, 0x62, 0x63), isTrue);
-    expect(StringUtilities.startsWith3("abcdefghi", 2, 0x63, 0x64, 0x65), isTrue);
-    expect(StringUtilities.startsWith3("abcdefghi", 6, 0x67, 0x68, 0x69), isTrue);
-    expect(StringUtilities.startsWith3("abcdefghi", 0, 0x64, 0x65, 0x61), isFalse);
+    expect(
+        StringUtilities.startsWith3("abcdefghi", 0, 0x61, 0x62, 0x63),
+        isTrue);
+    expect(
+        StringUtilities.startsWith3("abcdefghi", 2, 0x63, 0x64, 0x65),
+        isTrue);
+    expect(
+        StringUtilities.startsWith3("abcdefghi", 6, 0x67, 0x68, 0x69),
+        isTrue);
+    expect(
+        StringUtilities.startsWith3("abcdefghi", 0, 0x64, 0x65, 0x61),
+        isFalse);
     // missing
   }
 
   void test_startsWith4() {
-    expect(StringUtilities.startsWith4("abcd", 0, 0x61, 0x62, 0x63, 0x64), isTrue);
-    expect(StringUtilities.startsWith4("abcdefghi", 0, 0x61, 0x62, 0x63, 0x64), isTrue);
-    expect(StringUtilities.startsWith4("abcdefghi", 2, 0x63, 0x64, 0x65, 0x66), isTrue);
-    expect(StringUtilities.startsWith4("abcdefghi", 5, 0x66, 0x67, 0x68, 0x69), isTrue);
-    expect(StringUtilities.startsWith4("abcdefghi", 0, 0x64, 0x65, 0x61, 0x64), isFalse);
+    expect(
+        StringUtilities.startsWith4("abcd", 0, 0x61, 0x62, 0x63, 0x64),
+        isTrue);
+    expect(
+        StringUtilities.startsWith4("abcdefghi", 0, 0x61, 0x62, 0x63, 0x64),
+        isTrue);
+    expect(
+        StringUtilities.startsWith4("abcdefghi", 2, 0x63, 0x64, 0x65, 0x66),
+        isTrue);
+    expect(
+        StringUtilities.startsWith4("abcdefghi", 5, 0x66, 0x67, 0x68, 0x69),
+        isTrue);
+    expect(
+        StringUtilities.startsWith4("abcdefghi", 0, 0x64, 0x65, 0x61, 0x64),
+        isFalse);
     // missing
   }
 
   void test_startsWith5() {
-    expect(StringUtilities.startsWith5("abcde", 0, 0x61, 0x62, 0x63, 0x64, 0x65), isTrue);
-    expect(StringUtilities.startsWith5("abcdefghi", 0, 0x61, 0x62, 0x63, 0x64, 0x65), isTrue);
-    expect(StringUtilities.startsWith5("abcdefghi", 2, 0x63, 0x64, 0x65, 0x66, 0x67), isTrue);
-    expect(StringUtilities.startsWith5("abcdefghi", 4, 0x65, 0x66, 0x67, 0x68, 0x69), isTrue);
-    expect(StringUtilities.startsWith5("abcdefghi", 0, 0x61, 0x62, 0x63, 0x62, 0x61), isFalse);
+    expect(
+        StringUtilities.startsWith5("abcde", 0, 0x61, 0x62, 0x63, 0x64, 0x65),
+        isTrue);
+    expect(
+        StringUtilities.startsWith5("abcdefghi", 0, 0x61, 0x62, 0x63, 0x64, 0x65),
+        isTrue);
+    expect(
+        StringUtilities.startsWith5("abcdefghi", 2, 0x63, 0x64, 0x65, 0x66, 0x67),
+        isTrue);
+    expect(
+        StringUtilities.startsWith5("abcdefghi", 4, 0x65, 0x66, 0x67, 0x68, 0x69),
+        isTrue);
+    expect(
+        StringUtilities.startsWith5("abcdefghi", 0, 0x61, 0x62, 0x63, 0x62, 0x61),
+        isFalse);
     // missing
   }
 
   void test_startsWith6() {
-    expect(StringUtilities.startsWith6("abcdef", 0, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66), isTrue);
-    expect(StringUtilities.startsWith6(
-            "abcdefghi",
-            0,
-            0x61,
-            0x62,
-            0x63,
-            0x64,
-            0x65,
-            0x66), isTrue);
-    expect(StringUtilities.startsWith6(
-            "abcdefghi",
-            2,
-            0x63,
-            0x64,
-            0x65,
-            0x66,
-            0x67,
-            0x68), isTrue);
-    expect(StringUtilities.startsWith6(
-            "abcdefghi",
-            3,
-            0x64,
-            0x65,
-            0x66,
-            0x67,
-            0x68,
-            0x69), isTrue);
-    expect(StringUtilities.startsWith6(
-            "abcdefghi",
-            0,
-            0x61,
-            0x62,
-            0x63,
-            0x64,
-            0x65,
-            0x67), isFalse);
+    expect(
+        StringUtilities.startsWith6("abcdef", 0, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66),
+        isTrue);
+    expect(
+        StringUtilities.startsWith6("abcdefghi", 0, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66),
+        isTrue);
+    expect(
+        StringUtilities.startsWith6("abcdefghi", 2, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68),
+        isTrue);
+    expect(
+        StringUtilities.startsWith6("abcdefghi", 3, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69),
+        isTrue);
+    expect(
+        StringUtilities.startsWith6("abcdefghi", 0, 0x61, 0x62, 0x63, 0x64, 0x65, 0x67),
+        isFalse);
     // missing
   }
 
   void test_startsWithChar() {
     expect(StringUtilities.startsWithChar("a", 0x61), isTrue);
     expect(StringUtilities.startsWithChar("b", 0x61), isFalse);
     expect(StringUtilities.startsWithChar("", 0x61), isFalse);
   }
 
   void test_substringBefore() {
@@ skipping 30 matching lines @@
   }
 
   void test_get_added() {
     TokenMap tokenMap = new TokenMap();
     Token key = TokenFactory.tokenFromType(TokenType.AT);
     Token value = TokenFactory.tokenFromType(TokenType.AT);
     tokenMap.put(key, value);
     expect(tokenMap.get(key), same(value));
   }
 }