Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(102)

Unified Diff: pkg/analyzer/test/generated/utilities_test.dart

Issue 975453004: Reformat (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart
Patch Set: Created 5 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: pkg/analyzer/test/generated/utilities_test.dart
diff --git a/pkg/analyzer/test/generated/utilities_test.dart b/pkg/analyzer/test/generated/utilities_test.dart
index d7cd1dfd24b12d84894e1a3e07330cec9fcac9fa..fec07430fbe06411cf67d7cb08645330fbe8be2a 100644
--- a/pkg/analyzer/test/generated/utilities_test.dart
+++ b/pkg/analyzer/test/generated/utilities_test.dart
@@ -64,8 +64,8 @@ class AstCloneComparator extends AstComparator {
@reflectiveTest
class AstClonerTest extends EngineTestCase {
void test_visitAdjacentStrings() {
- _assertClone(
- AstFactory.adjacentStrings([AstFactory.string2("a"), AstFactory.string2("b")]));
+ _assertClone(AstFactory
+ .adjacentStrings([AstFactory.string2("a"), AstFactory.string2("b")]));
}
void test_visitAnnotation_constant() {
@@ -73,24 +73,18 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitAnnotation_constructor() {
- _assertClone(
- AstFactory.annotation2(
- AstFactory.identifier3("A"),
- AstFactory.identifier3("c"),
- AstFactory.argumentList()));
+ _assertClone(AstFactory.annotation2(AstFactory.identifier3("A"),
+ AstFactory.identifier3("c"), AstFactory.argumentList()));
}
void test_visitArgumentList() {
- _assertClone(
- AstFactory.argumentList(
- [AstFactory.identifier3("a"), AstFactory.identifier3("b")]));
+ _assertClone(AstFactory.argumentList(
+ [AstFactory.identifier3("a"), AstFactory.identifier3("b")]));
}
void test_visitAsExpression() {
- _assertClone(
- AstFactory.asExpression(
- AstFactory.identifier3("e"),
- AstFactory.typeName4("T")));
+ _assertClone(AstFactory.asExpression(
+ AstFactory.identifier3("e"), AstFactory.typeName4("T")));
}
void test_visitAssertStatement() {
@@ -98,11 +92,8 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitAssignmentExpression() {
- _assertClone(
- AstFactory.assignmentExpression(
- AstFactory.identifier3("a"),
- TokenType.EQ,
- AstFactory.identifier3("b")));
+ _assertClone(AstFactory.assignmentExpression(AstFactory.identifier3("a"),
+ TokenType.EQ, AstFactory.identifier3("b")));
}
void test_visitAwaitExpression() {
@@ -110,11 +101,8 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitBinaryExpression() {
- _assertClone(
- AstFactory.binaryExpression(
- AstFactory.identifier3("a"),
- TokenType.PLUS,
- AstFactory.identifier3("b")));
+ _assertClone(AstFactory.binaryExpression(AstFactory.identifier3("a"),
+ TokenType.PLUS, AstFactory.identifier3("b")));
}
void test_visitBlock_empty() {
@@ -122,8 +110,8 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitBlock_nonEmpty() {
- _assertClone(
- AstFactory.block([AstFactory.breakStatement(), AstFactory.breakStatement()]));
+ _assertClone(AstFactory
+ .block([AstFactory.breakStatement(), AstFactory.breakStatement()]));
}
void test_visitBlockFunctionBody() {
@@ -147,30 +135,24 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitCascadeExpression_field() {
- _assertClone(
- AstFactory.cascadeExpression(
- AstFactory.identifier3("a"),
- [
- AstFactory.cascadedPropertyAccess("b"),
- AstFactory.cascadedPropertyAccess("c")]));
+ _assertClone(AstFactory.cascadeExpression(AstFactory.identifier3("a"), [
+ AstFactory.cascadedPropertyAccess("b"),
+ AstFactory.cascadedPropertyAccess("c")
+ ]));
}
void test_visitCascadeExpression_index() {
- _assertClone(
- AstFactory.cascadeExpression(
- AstFactory.identifier3("a"),
- [
- AstFactory.cascadedIndexExpression(AstFactory.integer(0)),
- AstFactory.cascadedIndexExpression(AstFactory.integer(1))]));
+ _assertClone(AstFactory.cascadeExpression(AstFactory.identifier3("a"), [
+ AstFactory.cascadedIndexExpression(AstFactory.integer(0)),
+ AstFactory.cascadedIndexExpression(AstFactory.integer(1))
+ ]));
}
void test_visitCascadeExpression_method() {
- _assertClone(
- AstFactory.cascadeExpression(
- AstFactory.identifier3("a"),
- [
- AstFactory.cascadedMethodInvocation("b"),
- AstFactory.cascadedMethodInvocation("c")]));
+ _assertClone(AstFactory.cascadeExpression(AstFactory.identifier3("a"), [
+ AstFactory.cascadedMethodInvocation("b"),
+ AstFactory.cascadedMethodInvocation("c")
+ ]));
}
void test_visitCatchClause_catch_noStack() {
@@ -190,8 +172,8 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitClassDeclaration_abstract() {
- _assertClone(
- AstFactory.classDeclaration(Keyword.ABSTRACT, "C", null, null, null, null));
+ _assertClone(AstFactory.classDeclaration(
+ Keyword.ABSTRACT, "C", null, null, null, null));
}
void test_visitClassDeclaration_empty() {
@@ -200,274 +182,167 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitClassDeclaration_extends() {
- _assertClone(
- AstFactory.classDeclaration(
- null,
- "C",
- null,
- AstFactory.extendsClause(AstFactory.typeName4("A")),
- null,
- null));
+ _assertClone(AstFactory.classDeclaration(null, "C", null,
+ AstFactory.extendsClause(AstFactory.typeName4("A")), null, null));
}
void test_visitClassDeclaration_extends_implements() {
- _assertClone(
- AstFactory.classDeclaration(
- null,
- "C",
- null,
- AstFactory.extendsClause(AstFactory.typeName4("A")),
- null,
- AstFactory.implementsClause([AstFactory.typeName4("B")])));
+ _assertClone(AstFactory.classDeclaration(null, "C", null,
+ AstFactory.extendsClause(AstFactory.typeName4("A")), null,
+ AstFactory.implementsClause([AstFactory.typeName4("B")])));
}
void test_visitClassDeclaration_extends_with() {
- _assertClone(
- AstFactory.classDeclaration(
- null,
- "C",
- null,
- AstFactory.extendsClause(AstFactory.typeName4("A")),
- AstFactory.withClause([AstFactory.typeName4("M")]),
- null));
+ _assertClone(AstFactory.classDeclaration(null, "C", null,
+ AstFactory.extendsClause(AstFactory.typeName4("A")),
+ AstFactory.withClause([AstFactory.typeName4("M")]), null));
}
void test_visitClassDeclaration_extends_with_implements() {
- _assertClone(
- AstFactory.classDeclaration(
- null,
- "C",
- null,
- AstFactory.extendsClause(AstFactory.typeName4("A")),
- AstFactory.withClause([AstFactory.typeName4("M")]),
- AstFactory.implementsClause([AstFactory.typeName4("B")])));
+ _assertClone(AstFactory.classDeclaration(null, "C", null,
+ AstFactory.extendsClause(AstFactory.typeName4("A")),
+ AstFactory.withClause([AstFactory.typeName4("M")]),
+ AstFactory.implementsClause([AstFactory.typeName4("B")])));
}
void test_visitClassDeclaration_implements() {
- _assertClone(
- AstFactory.classDeclaration(
- null,
- "C",
- null,
- null,
- null,
- AstFactory.implementsClause([AstFactory.typeName4("B")])));
+ _assertClone(AstFactory.classDeclaration(null, "C", null, null, null,
+ AstFactory.implementsClause([AstFactory.typeName4("B")])));
}
void test_visitClassDeclaration_multipleMember() {
- _assertClone(
- AstFactory.classDeclaration(
- null,
- "C",
- null,
- null,
- null,
- null,
- [
- AstFactory.fieldDeclaration2(
- false,
- Keyword.VAR,
- [AstFactory.variableDeclaration("a")]),
- AstFactory.fieldDeclaration2(
- false,
- Keyword.VAR,
- [AstFactory.variableDeclaration("b")])]));
+ _assertClone(AstFactory.classDeclaration(null, "C", null, null, null, null,
+ [
+ AstFactory.fieldDeclaration2(
+ false, Keyword.VAR, [AstFactory.variableDeclaration("a")]),
+ AstFactory.fieldDeclaration2(
+ false, Keyword.VAR, [AstFactory.variableDeclaration("b")])
+ ]));
}
void test_visitClassDeclaration_parameters() {
- _assertClone(
- AstFactory.classDeclaration(
- null,
- "C",
- AstFactory.typeParameterList(["E"]),
- null,
- null,
- null));
+ _assertClone(AstFactory.classDeclaration(
+ null, "C", AstFactory.typeParameterList(["E"]), null, null, null));
}
void test_visitClassDeclaration_parameters_extends() {
- _assertClone(
- AstFactory.classDeclaration(
- null,
- "C",
- AstFactory.typeParameterList(["E"]),
- AstFactory.extendsClause(AstFactory.typeName4("A")),
- null,
- null));
+ _assertClone(AstFactory.classDeclaration(null, "C",
+ AstFactory.typeParameterList(["E"]),
+ AstFactory.extendsClause(AstFactory.typeName4("A")), null, null));
}
void test_visitClassDeclaration_parameters_extends_implements() {
- _assertClone(
- AstFactory.classDeclaration(
- null,
- "C",
- AstFactory.typeParameterList(["E"]),
- AstFactory.extendsClause(AstFactory.typeName4("A")),
- null,
- AstFactory.implementsClause([AstFactory.typeName4("B")])));
+ _assertClone(AstFactory.classDeclaration(null, "C",
+ AstFactory.typeParameterList(["E"]),
+ AstFactory.extendsClause(AstFactory.typeName4("A")), null,
+ AstFactory.implementsClause([AstFactory.typeName4("B")])));
}
void test_visitClassDeclaration_parameters_extends_with() {
- _assertClone(
- AstFactory.classDeclaration(
- null,
- "C",
- AstFactory.typeParameterList(["E"]),
- AstFactory.extendsClause(AstFactory.typeName4("A")),
- AstFactory.withClause([AstFactory.typeName4("M")]),
- null));
+ _assertClone(AstFactory.classDeclaration(null, "C",
+ AstFactory.typeParameterList(["E"]),
+ AstFactory.extendsClause(AstFactory.typeName4("A")),
+ AstFactory.withClause([AstFactory.typeName4("M")]), null));
}
void test_visitClassDeclaration_parameters_extends_with_implements() {
- _assertClone(
- AstFactory.classDeclaration(
- null,
- "C",
- AstFactory.typeParameterList(["E"]),
- AstFactory.extendsClause(AstFactory.typeName4("A")),
- AstFactory.withClause([AstFactory.typeName4("M")]),
- AstFactory.implementsClause([AstFactory.typeName4("B")])));
+ _assertClone(AstFactory.classDeclaration(null, "C",
+ AstFactory.typeParameterList(["E"]),
+ AstFactory.extendsClause(AstFactory.typeName4("A")),
+ AstFactory.withClause([AstFactory.typeName4("M")]),
+ AstFactory.implementsClause([AstFactory.typeName4("B")])));
}
void test_visitClassDeclaration_parameters_implements() {
- _assertClone(
- AstFactory.classDeclaration(
- null,
- "C",
- AstFactory.typeParameterList(["E"]),
- null,
- null,
- AstFactory.implementsClause([AstFactory.typeName4("B")])));
+ _assertClone(AstFactory.classDeclaration(null, "C",
+ AstFactory.typeParameterList(["E"]), null, null,
+ AstFactory.implementsClause([AstFactory.typeName4("B")])));
}
void test_visitClassDeclaration_singleMember() {
- _assertClone(
- AstFactory.classDeclaration(
- null,
- "C",
- null,
- null,
- null,
- null,
- [
- AstFactory.fieldDeclaration2(
- false,
- Keyword.VAR,
- [AstFactory.variableDeclaration("a")])]));
+ _assertClone(AstFactory.classDeclaration(null, "C", null, null, null, null,
+ [
+ AstFactory.fieldDeclaration2(
+ false, Keyword.VAR, [AstFactory.variableDeclaration("a")])
+ ]));
}
void test_visitClassDeclaration_withMetadata() {
ClassDeclaration declaration =
AstFactory.classDeclaration(null, "C", null, null, null, null);
- declaration.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
+ declaration.metadata
+ .add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
_assertClone(declaration);
}
void test_visitClassTypeAlias_abstract() {
- _assertClone(
- AstFactory.classTypeAlias(
- "C",
- null,
- Keyword.ABSTRACT,
- AstFactory.typeName4("S"),
- AstFactory.withClause([AstFactory.typeName4("M1")]),
- null));
+ _assertClone(AstFactory.classTypeAlias("C", null, Keyword.ABSTRACT,
+ AstFactory.typeName4("S"),
+ AstFactory.withClause([AstFactory.typeName4("M1")]), null));
}
void test_visitClassTypeAlias_abstract_implements() {
- _assertClone(
- AstFactory.classTypeAlias(
- "C",
- null,
- Keyword.ABSTRACT,
- AstFactory.typeName4("S"),
- AstFactory.withClause([AstFactory.typeName4("M1")]),
- AstFactory.implementsClause([AstFactory.typeName4("I")])));
+ _assertClone(AstFactory.classTypeAlias("C", null, Keyword.ABSTRACT,
+ AstFactory.typeName4("S"),
+ AstFactory.withClause([AstFactory.typeName4("M1")]),
+ AstFactory.implementsClause([AstFactory.typeName4("I")])));
}
void test_visitClassTypeAlias_generic() {
- _assertClone(
- AstFactory.classTypeAlias(
- "C",
- AstFactory.typeParameterList(["E"]),
- null,
- AstFactory.typeName4("S", [AstFactory.typeName4("E")]),
- AstFactory.withClause(
- [AstFactory.typeName4("M1", [AstFactory.typeName4("E")])]),
- null));
+ _assertClone(AstFactory.classTypeAlias("C",
+ AstFactory.typeParameterList(["E"]), null,
+ AstFactory.typeName4("S", [AstFactory.typeName4("E")]),
+ AstFactory.withClause(
+ [AstFactory.typeName4("M1", [AstFactory.typeName4("E")])]), null));
}
void test_visitClassTypeAlias_implements() {
- _assertClone(
- AstFactory.classTypeAlias(
- "C",
- null,
- null,
- AstFactory.typeName4("S"),
- AstFactory.withClause([AstFactory.typeName4("M1")]),
- AstFactory.implementsClause([AstFactory.typeName4("I")])));
+ _assertClone(AstFactory.classTypeAlias("C", null, null,
+ AstFactory.typeName4("S"),
+ AstFactory.withClause([AstFactory.typeName4("M1")]),
+ AstFactory.implementsClause([AstFactory.typeName4("I")])));
}
void test_visitClassTypeAlias_minimal() {
- _assertClone(
- AstFactory.classTypeAlias(
- "C",
- null,
- null,
- AstFactory.typeName4("S"),
- AstFactory.withClause([AstFactory.typeName4("M1")]),
- null));
+ _assertClone(AstFactory.classTypeAlias("C", null, null,
+ AstFactory.typeName4("S"),
+ AstFactory.withClause([AstFactory.typeName4("M1")]), null));
}
void test_visitClassTypeAlias_parameters_abstract() {
- _assertClone(
- AstFactory.classTypeAlias(
- "C",
- AstFactory.typeParameterList(["E"]),
- Keyword.ABSTRACT,
- AstFactory.typeName4("S"),
- AstFactory.withClause([AstFactory.typeName4("M1")]),
- null));
+ _assertClone(AstFactory.classTypeAlias("C",
+ AstFactory.typeParameterList(["E"]), Keyword.ABSTRACT,
+ AstFactory.typeName4("S"),
+ AstFactory.withClause([AstFactory.typeName4("M1")]), null));
}
void test_visitClassTypeAlias_parameters_abstract_implements() {
- _assertClone(
- AstFactory.classTypeAlias(
- "C",
- AstFactory.typeParameterList(["E"]),
- Keyword.ABSTRACT,
- AstFactory.typeName4("S"),
- AstFactory.withClause([AstFactory.typeName4("M1")]),
- AstFactory.implementsClause([AstFactory.typeName4("I")])));
+ _assertClone(AstFactory.classTypeAlias("C",
+ AstFactory.typeParameterList(["E"]), Keyword.ABSTRACT,
+ AstFactory.typeName4("S"),
+ AstFactory.withClause([AstFactory.typeName4("M1")]),
+ AstFactory.implementsClause([AstFactory.typeName4("I")])));
}
void test_visitClassTypeAlias_parameters_implements() {
- _assertClone(
- AstFactory.classTypeAlias(
- "C",
- AstFactory.typeParameterList(["E"]),
- null,
- AstFactory.typeName4("S"),
- AstFactory.withClause([AstFactory.typeName4("M1")]),
- AstFactory.implementsClause([AstFactory.typeName4("I")])));
+ _assertClone(AstFactory.classTypeAlias("C",
+ AstFactory.typeParameterList(["E"]), null, AstFactory.typeName4("S"),
+ AstFactory.withClause([AstFactory.typeName4("M1")]),
+ AstFactory.implementsClause([AstFactory.typeName4("I")])));
}
void test_visitClassTypeAlias_withMetadata() {
- ClassTypeAlias declaration = AstFactory.classTypeAlias(
- "C",
- null,
- null,
+ ClassTypeAlias declaration = AstFactory.classTypeAlias("C", null, null,
AstFactory.typeName4("S"),
- AstFactory.withClause([AstFactory.typeName4("M1")]),
- null);
- declaration.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
+ AstFactory.withClause([AstFactory.typeName4("M1")]), null);
+ declaration.metadata
+ .add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
_assertClone(declaration);
}
void test_visitComment() {
- _assertClone(
- Comment.createBlockComment(
- <Token>[TokenFactory.tokenFromString("/* comment */")]));
+ _assertClone(Comment.createBlockComment(
+ <Token>[TokenFactory.tokenFromString("/* comment */")]));
}
void test_visitCommentReference() {
@@ -475,12 +350,10 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitCompilationUnit_declaration() {
- _assertClone(
- AstFactory.compilationUnit2(
- [
- AstFactory.topLevelVariableDeclaration2(
- Keyword.VAR,
- [AstFactory.variableDeclaration("a")])]));
+ _assertClone(AstFactory.compilationUnit2([
+ AstFactory.topLevelVariableDeclaration2(
+ Keyword.VAR, [AstFactory.variableDeclaration("a")])
+ ]));
}
void test_visitCompilationUnit_directive() {
@@ -489,13 +362,12 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitCompilationUnit_directive_declaration() {
- _assertClone(
- AstFactory.compilationUnit4(
- [AstFactory.libraryDirective2("l")],
- [
- AstFactory.topLevelVariableDeclaration2(
- Keyword.VAR,
- [AstFactory.variableDeclaration("a")])]));
+ _assertClone(AstFactory.compilationUnit4([
+ AstFactory.libraryDirective2("l")
+ ], [
+ AstFactory.topLevelVariableDeclaration2(
+ Keyword.VAR, [AstFactory.variableDeclaration("a")])
+ ]));
}
void test_visitCompilationUnit_empty() {
@@ -507,158 +379,98 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitCompilationUnit_script_declaration() {
- _assertClone(
- AstFactory.compilationUnit6(
- "!#/bin/dartvm",
- [
- AstFactory.topLevelVariableDeclaration2(
- Keyword.VAR,
- [AstFactory.variableDeclaration("a")])]));
+ _assertClone(AstFactory.compilationUnit6("!#/bin/dartvm", [
+ AstFactory.topLevelVariableDeclaration2(
+ Keyword.VAR, [AstFactory.variableDeclaration("a")])
+ ]));
}
void test_visitCompilationUnit_script_directive() {
- _assertClone(
- AstFactory.compilationUnit7(
- "!#/bin/dartvm",
- [AstFactory.libraryDirective2("l")]));
+ _assertClone(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")])]));
+ _assertClone(AstFactory.compilationUnit8("!#/bin/dartvm", [
+ AstFactory.libraryDirective2("l")
+ ], [
+ AstFactory.topLevelVariableDeclaration2(
+ Keyword.VAR, [AstFactory.variableDeclaration("a")])
+ ]));
}
void test_visitConditionalExpression() {
- _assertClone(
- AstFactory.conditionalExpression(
- AstFactory.identifier3("a"),
- AstFactory.identifier3("b"),
- AstFactory.identifier3("c")));
+ _assertClone(AstFactory.conditionalExpression(AstFactory.identifier3("a"),
+ AstFactory.identifier3("b"), AstFactory.identifier3("c")));
}
void test_visitConstructorDeclaration_const() {
- _assertClone(
- AstFactory.constructorDeclaration2(
- Keyword.CONST,
- null,
- AstFactory.identifier3("C"),
- null,
- AstFactory.formalParameterList(),
- null,
- AstFactory.blockFunctionBody2()));
+ _assertClone(AstFactory.constructorDeclaration2(Keyword.CONST, null,
+ AstFactory.identifier3("C"), null, AstFactory.formalParameterList(),
+ null, AstFactory.blockFunctionBody2()));
}
void test_visitConstructorDeclaration_external() {
- _assertClone(
- AstFactory.constructorDeclaration(
- AstFactory.identifier3("C"),
- null,
- AstFactory.formalParameterList(),
- null));
+ _assertClone(AstFactory.constructorDeclaration(AstFactory.identifier3("C"),
+ null, AstFactory.formalParameterList(), null));
}
void test_visitConstructorDeclaration_minimal() {
- _assertClone(
- AstFactory.constructorDeclaration2(
- null,
- null,
- AstFactory.identifier3("C"),
- null,
- AstFactory.formalParameterList(),
- null,
- AstFactory.blockFunctionBody2()));
+ _assertClone(AstFactory.constructorDeclaration2(null, null,
+ AstFactory.identifier3("C"), null, AstFactory.formalParameterList(),
+ null, AstFactory.blockFunctionBody2()));
}
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.blockFunctionBody2()));
+ _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.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")]),
- null,
- AstFactory.blockFunctionBody2()));
+ _assertClone(AstFactory.constructorDeclaration2(null, null,
+ AstFactory.identifier3("C"), null, 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()));
+ _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.blockFunctionBody2()));
+ _assertClone(AstFactory.constructorDeclaration2(null, null,
+ AstFactory.identifier3("C"), null, AstFactory.formalParameterList(), [
+ 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,
+ null, null, AstFactory.identifier3("C"), null,
+ AstFactory.formalParameterList(), null,
AstFactory.blockFunctionBody2());
- declaration.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
+ declaration.metadata
+ .add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
_assertClone(declaration);
}
void test_visitConstructorFieldInitializer_withoutThis() {
- _assertClone(
- AstFactory.constructorFieldInitializer(
- false,
- "a",
- AstFactory.identifier3("b")));
+ _assertClone(AstFactory.constructorFieldInitializer(
+ false, "a", AstFactory.identifier3("b")));
}
void test_visitConstructorFieldInitializer_withThis() {
- _assertClone(
- AstFactory.constructorFieldInitializer(true, "a", AstFactory.identifier3("b")));
+ _assertClone(AstFactory.constructorFieldInitializer(
+ true, "a", AstFactory.identifier3("b")));
}
void test_visitConstructorName_named_prefix() {
@@ -671,10 +483,8 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitConstructorName_unnamed_prefix() {
- _assertClone(
- AstFactory.constructorName(
- AstFactory.typeName3(AstFactory.identifier5("p", "C")),
- null));
+ _assertClone(AstFactory.constructorName(
+ AstFactory.typeName3(AstFactory.identifier5("p", "C")), null));
}
void test_visitContinueStatement_label() {
@@ -686,34 +496,28 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitDefaultFormalParameter_named_noValue() {
- _assertClone(
- AstFactory.namedFormalParameter(AstFactory.simpleFormalParameter3("p"), null));
+ _assertClone(AstFactory.namedFormalParameter(
+ AstFactory.simpleFormalParameter3("p"), null));
}
void test_visitDefaultFormalParameter_named_value() {
- _assertClone(
- AstFactory.namedFormalParameter(
- AstFactory.simpleFormalParameter3("p"),
- AstFactory.integer(0)));
+ _assertClone(AstFactory.namedFormalParameter(
+ AstFactory.simpleFormalParameter3("p"), AstFactory.integer(0)));
}
void test_visitDefaultFormalParameter_positional_noValue() {
- _assertClone(
- AstFactory.positionalFormalParameter(
- AstFactory.simpleFormalParameter3("p"),
- null));
+ _assertClone(AstFactory.positionalFormalParameter(
+ AstFactory.simpleFormalParameter3("p"), null));
}
void test_visitDefaultFormalParameter_positional_value() {
- _assertClone(
- AstFactory.positionalFormalParameter(
- AstFactory.simpleFormalParameter3("p"),
- AstFactory.integer(0)));
+ _assertClone(AstFactory.positionalFormalParameter(
+ AstFactory.simpleFormalParameter3("p"), AstFactory.integer(0)));
}
void test_visitDoStatement() {
- _assertClone(
- AstFactory.doStatement(AstFactory.block(), AstFactory.identifier3("c")));
+ _assertClone(AstFactory.doStatement(
+ AstFactory.block(), AstFactory.identifier3("c")));
}
void test_visitDoubleLiteral() {
@@ -729,19 +533,15 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitExportDirective_combinator() {
- _assertClone(
- AstFactory.exportDirective2(
- "a.dart",
- [AstFactory.showCombinator([AstFactory.identifier3("A")])]));
+ _assertClone(AstFactory.exportDirective2(
+ "a.dart", [AstFactory.showCombinator([AstFactory.identifier3("A")])]));
}
void test_visitExportDirective_combinators() {
- _assertClone(
- AstFactory.exportDirective2(
- "a.dart",
- [
- AstFactory.showCombinator([AstFactory.identifier3("A")]),
- AstFactory.hideCombinator([AstFactory.identifier3("B")])]));
+ _assertClone(AstFactory.exportDirective2("a.dart", [
+ AstFactory.showCombinator([AstFactory.identifier3("A")]),
+ AstFactory.hideCombinator([AstFactory.identifier3("B")])
+ ]));
}
void test_visitExportDirective_minimal() {
@@ -750,7 +550,8 @@ class AstClonerTest extends EngineTestCase {
void test_visitExportDirective_withMetadata() {
ExportDirective directive = AstFactory.exportDirective2("a.dart");
- directive.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
+ directive.metadata
+ .add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
_assertClone(directive);
}
@@ -768,37 +569,27 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitFieldDeclaration_instance() {
- _assertClone(
- AstFactory.fieldDeclaration2(
- false,
- Keyword.VAR,
- [AstFactory.variableDeclaration("a")]));
+ _assertClone(AstFactory.fieldDeclaration2(
+ false, Keyword.VAR, [AstFactory.variableDeclaration("a")]));
}
void test_visitFieldDeclaration_static() {
- _assertClone(
- AstFactory.fieldDeclaration2(
- true,
- Keyword.VAR,
- [AstFactory.variableDeclaration("a")]));
+ _assertClone(AstFactory.fieldDeclaration2(
+ true, Keyword.VAR, [AstFactory.variableDeclaration("a")]));
}
void test_visitFieldDeclaration_withMetadata() {
FieldDeclaration declaration = AstFactory.fieldDeclaration2(
- false,
- Keyword.VAR,
- [AstFactory.variableDeclaration("a")]);
- declaration.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
+ false, Keyword.VAR, [AstFactory.variableDeclaration("a")]);
+ declaration.metadata
+ .add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
_assertClone(declaration);
}
void test_visitFieldFormalParameter_functionTyped() {
- _assertClone(
- AstFactory.fieldFormalParameter(
- null,
- AstFactory.typeName4("A"),
- "a",
- AstFactory.formalParameterList([AstFactory.simpleFormalParameter3("b")])));
+ _assertClone(AstFactory.fieldFormalParameter(null,
+ AstFactory.typeName4("A"), "a", AstFactory
+ .formalParameterList([AstFactory.simpleFormalParameter3("b")])));
}
void test_visitFieldFormalParameter_keyword() {
@@ -806,8 +597,8 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitFieldFormalParameter_keywordAndType() {
- _assertClone(
- AstFactory.fieldFormalParameter(Keyword.FINAL, AstFactory.typeName4("A"), "a"));
+ _assertClone(AstFactory.fieldFormalParameter(
+ Keyword.FINAL, AstFactory.typeName4("A"), "a"));
}
void test_visitFieldFormalParameter_type() {
@@ -816,37 +607,28 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitForEachStatement_declared() {
- _assertClone(
- AstFactory.forEachStatement(
- AstFactory.declaredIdentifier3("a"),
- AstFactory.identifier3("b"),
- AstFactory.block()));
+ _assertClone(AstFactory.forEachStatement(
+ AstFactory.declaredIdentifier3("a"), AstFactory.identifier3("b"),
+ AstFactory.block()));
}
void test_visitForEachStatement_variable() {
- _assertClone(
- new ForEachStatement.con2(
- null,
- 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()));
+ _assertClone(new ForEachStatement.con2(null,
+ 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_visitForEachStatement_variable_await() {
- _assertClone(
- new ForEachStatement.con2(
- 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()));
+ _assertClone(new ForEachStatement.con2(
+ 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_visitFormalParameterList_empty() {
@@ -854,307 +636,217 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitFormalParameterList_n() {
- _assertClone(
- AstFactory.formalParameterList(
- [
- AstFactory.namedFormalParameter(
- AstFactory.simpleFormalParameter3("a"),
- AstFactory.integer(0))]));
+ _assertClone(AstFactory.formalParameterList([
+ AstFactory.namedFormalParameter(
+ AstFactory.simpleFormalParameter3("a"), AstFactory.integer(0))
+ ]));
}
void test_visitFormalParameterList_nn() {
- _assertClone(
- AstFactory.formalParameterList(
- [
- AstFactory.namedFormalParameter(
- AstFactory.simpleFormalParameter3("a"),
- AstFactory.integer(0)),
- AstFactory.namedFormalParameter(
- AstFactory.simpleFormalParameter3("b"),
- AstFactory.integer(1))]));
+ _assertClone(AstFactory.formalParameterList([
+ AstFactory.namedFormalParameter(
+ AstFactory.simpleFormalParameter3("a"), AstFactory.integer(0)),
+ AstFactory.namedFormalParameter(
+ AstFactory.simpleFormalParameter3("b"), AstFactory.integer(1))
+ ]));
}
void test_visitFormalParameterList_p() {
- _assertClone(
- AstFactory.formalParameterList(
- [
- AstFactory.positionalFormalParameter(
- AstFactory.simpleFormalParameter3("a"),
- AstFactory.integer(0))]));
+ _assertClone(AstFactory.formalParameterList([
+ AstFactory.positionalFormalParameter(
+ AstFactory.simpleFormalParameter3("a"), AstFactory.integer(0))
+ ]));
}
void test_visitFormalParameterList_pp() {
- _assertClone(
- AstFactory.formalParameterList(
- [
- AstFactory.positionalFormalParameter(
- AstFactory.simpleFormalParameter3("a"),
- AstFactory.integer(0)),
- AstFactory.positionalFormalParameter(
- AstFactory.simpleFormalParameter3("b"),
- AstFactory.integer(1))]));
+ _assertClone(AstFactory.formalParameterList([
+ AstFactory.positionalFormalParameter(
+ AstFactory.simpleFormalParameter3("a"), AstFactory.integer(0)),
+ AstFactory.positionalFormalParameter(
+ AstFactory.simpleFormalParameter3("b"), AstFactory.integer(1))
+ ]));
}
void test_visitFormalParameterList_r() {
- _assertClone(
- AstFactory.formalParameterList([AstFactory.simpleFormalParameter3("a")]));
+ _assertClone(AstFactory
+ .formalParameterList([AstFactory.simpleFormalParameter3("a")]));
}
void test_visitFormalParameterList_rn() {
- _assertClone(
- AstFactory.formalParameterList(
- [
- AstFactory.simpleFormalParameter3("a"),
- AstFactory.namedFormalParameter(
- AstFactory.simpleFormalParameter3("b"),
- AstFactory.integer(1))]));
+ _assertClone(AstFactory.formalParameterList([
+ AstFactory.simpleFormalParameter3("a"),
+ AstFactory.namedFormalParameter(
+ AstFactory.simpleFormalParameter3("b"), AstFactory.integer(1))
+ ]));
}
void test_visitFormalParameterList_rnn() {
- _assertClone(
- AstFactory.formalParameterList(
- [
- AstFactory.simpleFormalParameter3("a"),
- AstFactory.namedFormalParameter(
- AstFactory.simpleFormalParameter3("b"),
- AstFactory.integer(1)),
- AstFactory.namedFormalParameter(
- AstFactory.simpleFormalParameter3("c"),
- AstFactory.integer(2))]));
+ _assertClone(AstFactory.formalParameterList([
+ AstFactory.simpleFormalParameter3("a"),
+ AstFactory.namedFormalParameter(
+ AstFactory.simpleFormalParameter3("b"), AstFactory.integer(1)),
+ AstFactory.namedFormalParameter(
+ AstFactory.simpleFormalParameter3("c"), AstFactory.integer(2))
+ ]));
}
void test_visitFormalParameterList_rp() {
- _assertClone(
- AstFactory.formalParameterList(
- [
- AstFactory.simpleFormalParameter3("a"),
- AstFactory.positionalFormalParameter(
- AstFactory.simpleFormalParameter3("b"),
- AstFactory.integer(1))]));
+ _assertClone(AstFactory.formalParameterList([
+ AstFactory.simpleFormalParameter3("a"),
+ AstFactory.positionalFormalParameter(
+ AstFactory.simpleFormalParameter3("b"), AstFactory.integer(1))
+ ]));
}
void test_visitFormalParameterList_rpp() {
- _assertClone(
- AstFactory.formalParameterList(
- [
- AstFactory.simpleFormalParameter3("a"),
- AstFactory.positionalFormalParameter(
- AstFactory.simpleFormalParameter3("b"),
- AstFactory.integer(1)),
- AstFactory.positionalFormalParameter(
- AstFactory.simpleFormalParameter3("c"),
- AstFactory.integer(2))]));
+ _assertClone(AstFactory.formalParameterList([
+ AstFactory.simpleFormalParameter3("a"),
+ AstFactory.positionalFormalParameter(
+ AstFactory.simpleFormalParameter3("b"), AstFactory.integer(1)),
+ AstFactory.positionalFormalParameter(
+ AstFactory.simpleFormalParameter3("c"), AstFactory.integer(2))
+ ]));
}
void test_visitFormalParameterList_rr() {
- _assertClone(
- AstFactory.formalParameterList(
- [
- AstFactory.simpleFormalParameter3("a"),
- AstFactory.simpleFormalParameter3("b")]));
+ _assertClone(AstFactory.formalParameterList([
+ AstFactory.simpleFormalParameter3("a"),
+ AstFactory.simpleFormalParameter3("b")
+ ]));
}
void test_visitFormalParameterList_rrn() {
- _assertClone(
- AstFactory.formalParameterList(
- [
- AstFactory.simpleFormalParameter3("a"),
- AstFactory.simpleFormalParameter3("b"),
- AstFactory.namedFormalParameter(
- AstFactory.simpleFormalParameter3("c"),
- AstFactory.integer(3))]));
+ _assertClone(AstFactory.formalParameterList([
+ AstFactory.simpleFormalParameter3("a"),
+ AstFactory.simpleFormalParameter3("b"),
+ AstFactory.namedFormalParameter(
+ AstFactory.simpleFormalParameter3("c"), AstFactory.integer(3))
+ ]));
}
void test_visitFormalParameterList_rrnn() {
- _assertClone(
- AstFactory.formalParameterList(
- [
- AstFactory.simpleFormalParameter3("a"),
- AstFactory.simpleFormalParameter3("b"),
- AstFactory.namedFormalParameter(
- AstFactory.simpleFormalParameter3("c"),
- AstFactory.integer(3)),
- AstFactory.namedFormalParameter(
- AstFactory.simpleFormalParameter3("d"),
- AstFactory.integer(4))]));
+ _assertClone(AstFactory.formalParameterList([
+ AstFactory.simpleFormalParameter3("a"),
+ AstFactory.simpleFormalParameter3("b"),
+ AstFactory.namedFormalParameter(
+ AstFactory.simpleFormalParameter3("c"), AstFactory.integer(3)),
+ AstFactory.namedFormalParameter(
+ AstFactory.simpleFormalParameter3("d"), AstFactory.integer(4))
+ ]));
}
void test_visitFormalParameterList_rrp() {
- _assertClone(
- AstFactory.formalParameterList(
- [
- AstFactory.simpleFormalParameter3("a"),
- AstFactory.simpleFormalParameter3("b"),
- AstFactory.positionalFormalParameter(
- AstFactory.simpleFormalParameter3("c"),
- AstFactory.integer(3))]));
+ _assertClone(AstFactory.formalParameterList([
+ AstFactory.simpleFormalParameter3("a"),
+ AstFactory.simpleFormalParameter3("b"),
+ AstFactory.positionalFormalParameter(
+ AstFactory.simpleFormalParameter3("c"), AstFactory.integer(3))
+ ]));
}
void test_visitFormalParameterList_rrpp() {
- _assertClone(
- AstFactory.formalParameterList(
- [
- AstFactory.simpleFormalParameter3("a"),
- AstFactory.simpleFormalParameter3("b"),
- AstFactory.positionalFormalParameter(
- AstFactory.simpleFormalParameter3("c"),
- AstFactory.integer(3)),
- AstFactory.positionalFormalParameter(
- AstFactory.simpleFormalParameter3("d"),
- AstFactory.integer(4))]));
+ _assertClone(AstFactory.formalParameterList([
+ AstFactory.simpleFormalParameter3("a"),
+ AstFactory.simpleFormalParameter3("b"),
+ AstFactory.positionalFormalParameter(
+ AstFactory.simpleFormalParameter3("c"), AstFactory.integer(3)),
+ AstFactory.positionalFormalParameter(
+ AstFactory.simpleFormalParameter3("d"), AstFactory.integer(4))
+ ]));
}
void test_visitForStatement_c() {
- _assertClone(
- AstFactory.forStatement(
- null,
- AstFactory.identifier3("c"),
- null,
- AstFactory.block()));
+ _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()));
+ _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()));
+ _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()));
+ _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()));
+ _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()));
+ _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()));
+ _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()));
+ _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()));
+ _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()));
+ _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()));
+ _assertClone(AstFactory.forStatement(
+ null, null, [AstFactory.identifier3("u")], AstFactory.block()));
}
void test_visitFunctionDeclaration_getter() {
- _assertClone(
- AstFactory.functionDeclaration(
- null,
- Keyword.GET,
- "f",
- AstFactory.functionExpression()));
+ _assertClone(AstFactory.functionDeclaration(
+ null, Keyword.GET, "f", AstFactory.functionExpression()));
}
void test_visitFunctionDeclaration_normal() {
- _assertClone(
- AstFactory.functionDeclaration(
- null,
- null,
- "f",
- AstFactory.functionExpression()));
+ _assertClone(AstFactory.functionDeclaration(
+ null, null, "f", AstFactory.functionExpression()));
}
void test_visitFunctionDeclaration_setter() {
- _assertClone(
- AstFactory.functionDeclaration(
- null,
- Keyword.SET,
- "f",
- AstFactory.functionExpression()));
+ _assertClone(AstFactory.functionDeclaration(
+ null, Keyword.SET, "f", AstFactory.functionExpression()));
}
void test_visitFunctionDeclaration_withMetadata() {
FunctionDeclaration declaration = AstFactory.functionDeclaration(
- null,
- null,
- "f",
- AstFactory.functionExpression());
- declaration.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
+ null, null, "f", AstFactory.functionExpression());
+ declaration.metadata
+ .add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
_assertClone(declaration);
}
void test_visitFunctionDeclarationStatement() {
- _assertClone(
- AstFactory.functionDeclarationStatement(
- null,
- null,
- "f",
- AstFactory.functionExpression()));
+ _assertClone(AstFactory.functionDeclarationStatement(
+ null, null, "f", AstFactory.functionExpression()));
}
void test_visitFunctionExpression() {
@@ -1167,30 +859,20 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitFunctionTypeAlias_generic() {
- _assertClone(
- AstFactory.typeAlias(
- AstFactory.typeName4("A"),
- "F",
- AstFactory.typeParameterList(["B"]),
- AstFactory.formalParameterList()));
+ _assertClone(AstFactory.typeAlias(AstFactory.typeName4("A"), "F",
+ AstFactory.typeParameterList(["B"]), AstFactory.formalParameterList()));
}
void test_visitFunctionTypeAlias_nonGeneric() {
- _assertClone(
- AstFactory.typeAlias(
- AstFactory.typeName4("A"),
- "F",
- null,
- AstFactory.formalParameterList()));
+ _assertClone(AstFactory.typeAlias(AstFactory.typeName4("A"), "F", null,
+ AstFactory.formalParameterList()));
}
void test_visitFunctionTypeAlias_withMetadata() {
FunctionTypeAlias declaration = AstFactory.typeAlias(
- AstFactory.typeName4("A"),
- "F",
- null,
- AstFactory.formalParameterList());
- declaration.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
+ AstFactory.typeName4("A"), "F", null, AstFactory.formalParameterList());
+ declaration.metadata
+ .add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
_assertClone(declaration);
}
@@ -1199,27 +881,23 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitFunctionTypedFormalParameter_type() {
- _assertClone(
- AstFactory.functionTypedFormalParameter(AstFactory.typeName4("T"), "f"));
+ _assertClone(AstFactory.functionTypedFormalParameter(
+ AstFactory.typeName4("T"), "f"));
}
void test_visitIfStatement_withElse() {
- _assertClone(
- AstFactory.ifStatement2(
- AstFactory.identifier3("c"),
- AstFactory.block(),
- AstFactory.block()));
+ _assertClone(AstFactory.ifStatement2(
+ AstFactory.identifier3("c"), AstFactory.block(), AstFactory.block()));
}
void test_visitIfStatement_withoutElse() {
- _assertClone(
- AstFactory.ifStatement(AstFactory.identifier3("c"), AstFactory.block()));
+ _assertClone(AstFactory.ifStatement(
+ AstFactory.identifier3("c"), AstFactory.block()));
}
void test_visitImplementsClause_multiple() {
- _assertClone(
- AstFactory.implementsClause(
- [AstFactory.typeName4("A"), AstFactory.typeName4("B")]));
+ _assertClone(AstFactory.implementsClause(
+ [AstFactory.typeName4("A"), AstFactory.typeName4("B")]));
}
void test_visitImplementsClause_single() {
@@ -1227,21 +905,16 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitImportDirective_combinator() {
- _assertClone(
- AstFactory.importDirective3(
- "a.dart",
- null,
- [AstFactory.showCombinator([AstFactory.identifier3("A")])]));
+ _assertClone(AstFactory.importDirective3("a.dart", null, [
+ AstFactory.showCombinator([AstFactory.identifier3("A")])
+ ]));
}
void test_visitImportDirective_combinators() {
- _assertClone(
- AstFactory.importDirective3(
- "a.dart",
- null,
- [
- AstFactory.showCombinator([AstFactory.identifier3("A")]),
- AstFactory.hideCombinator([AstFactory.identifier3("B")])]));
+ _assertClone(AstFactory.importDirective3("a.dart", null, [
+ AstFactory.showCombinator([AstFactory.identifier3("A")]),
+ AstFactory.hideCombinator([AstFactory.identifier3("B")])
+ ]));
}
void test_visitImportDirective_minimal() {
@@ -1253,33 +926,28 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitImportDirective_prefix_combinator() {
- _assertClone(
- AstFactory.importDirective3(
- "a.dart",
- "p",
- [AstFactory.showCombinator([AstFactory.identifier3("A")])]));
+ _assertClone(AstFactory.importDirective3("a.dart", "p", [
+ AstFactory.showCombinator([AstFactory.identifier3("A")])
+ ]));
}
void test_visitImportDirective_prefix_combinators() {
- _assertClone(
- AstFactory.importDirective3(
- "a.dart",
- "p",
- [
- AstFactory.showCombinator([AstFactory.identifier3("A")]),
- AstFactory.hideCombinator([AstFactory.identifier3("B")])]));
+ _assertClone(AstFactory.importDirective3("a.dart", "p", [
+ AstFactory.showCombinator([AstFactory.identifier3("A")]),
+ AstFactory.hideCombinator([AstFactory.identifier3("B")])
+ ]));
}
void test_visitImportDirective_withMetadata() {
ImportDirective directive = AstFactory.importDirective3("a.dart", null);
- directive.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
+ directive.metadata
+ .add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
_assertClone(directive);
}
void test_visitImportHideCombinator_multiple() {
- _assertClone(
- AstFactory.hideCombinator(
- [AstFactory.identifier3("a"), AstFactory.identifier3("b")]));
+ _assertClone(AstFactory.hideCombinator(
+ [AstFactory.identifier3("a"), AstFactory.identifier3("b")]));
}
void test_visitImportHideCombinator_single() {
@@ -1287,9 +955,8 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitImportShowCombinator_multiple() {
- _assertClone(
- AstFactory.showCombinator(
- [AstFactory.identifier3("a"), AstFactory.identifier3("b")]));
+ _assertClone(AstFactory.showCombinator(
+ [AstFactory.identifier3("a"), AstFactory.identifier3("b")]));
}
void test_visitImportShowCombinator_single() {
@@ -1297,30 +964,23 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitIndexExpression() {
- _assertClone(
- AstFactory.indexExpression(
- AstFactory.identifier3("a"),
- AstFactory.identifier3("i")));
+ _assertClone(AstFactory.indexExpression(
+ AstFactory.identifier3("a"), AstFactory.identifier3("i")));
}
void test_visitInstanceCreationExpression_const() {
- _assertClone(
- AstFactory.instanceCreationExpression2(
- Keyword.CONST,
- AstFactory.typeName4("C")));
+ _assertClone(AstFactory.instanceCreationExpression2(
+ Keyword.CONST, AstFactory.typeName4("C")));
}
void test_visitInstanceCreationExpression_named() {
- _assertClone(
- AstFactory.instanceCreationExpression3(
- Keyword.NEW,
- AstFactory.typeName4("C"),
- "c"));
+ _assertClone(AstFactory.instanceCreationExpression3(
+ Keyword.NEW, AstFactory.typeName4("C"), "c"));
}
void test_visitInstanceCreationExpression_unnamed() {
- _assertClone(
- AstFactory.instanceCreationExpression2(Keyword.NEW, AstFactory.typeName4("C")));
+ _assertClone(AstFactory.instanceCreationExpression2(
+ Keyword.NEW, AstFactory.typeName4("C")));
}
void test_visitIntegerLiteral() {
@@ -1341,19 +1001,13 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitIsExpression_negated() {
- _assertClone(
- AstFactory.isExpression(
- AstFactory.identifier3("a"),
- true,
- AstFactory.typeName4("C")));
+ _assertClone(AstFactory.isExpression(
+ AstFactory.identifier3("a"), true, AstFactory.typeName4("C")));
}
void test_visitIsExpression_normal() {
- _assertClone(
- AstFactory.isExpression(
- AstFactory.identifier3("a"),
- false,
- AstFactory.typeName4("C")));
+ _assertClone(AstFactory.isExpression(
+ AstFactory.identifier3("a"), false, AstFactory.typeName4("C")));
}
void test_visitLabel() {
@@ -1361,17 +1015,15 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitLabeledStatement_multiple() {
- _assertClone(
- AstFactory.labeledStatement(
- [AstFactory.label2("a"), AstFactory.label2("b")],
- AstFactory.returnStatement()));
+ _assertClone(AstFactory.labeledStatement([
+ AstFactory.label2("a"),
+ AstFactory.label2("b")
+ ], AstFactory.returnStatement()));
}
void test_visitLabeledStatement_single() {
- _assertClone(
- AstFactory.labeledStatement(
- [AstFactory.label2("a")],
- AstFactory.returnStatement()));
+ _assertClone(AstFactory.labeledStatement(
+ [AstFactory.label2("a")], AstFactory.returnStatement()));
}
void test_visitLibraryDirective() {
@@ -1380,17 +1032,17 @@ class AstClonerTest extends EngineTestCase {
void test_visitLibraryDirective_withMetadata() {
LibraryDirective directive = AstFactory.libraryDirective2("l");
- directive.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
+ directive.metadata
+ .add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
_assertClone(directive);
}
void test_visitLibraryIdentifier_multiple() {
- _assertClone(
- AstFactory.libraryIdentifier(
- [
- AstFactory.identifier3("a"),
- AstFactory.identifier3("b"),
- AstFactory.identifier3("c")]));
+ _assertClone(AstFactory.libraryIdentifier([
+ AstFactory.identifier3("a"),
+ AstFactory.identifier3("b"),
+ AstFactory.identifier3("c")
+ ]));
}
void test_visitLibraryIdentifier_single() {
@@ -1406,12 +1058,11 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitListLiteral_nonEmpty() {
- _assertClone(
- AstFactory.listLiteral(
- [
- AstFactory.identifier3("a"),
- AstFactory.identifier3("b"),
- AstFactory.identifier3("c")]));
+ _assertClone(AstFactory.listLiteral([
+ AstFactory.identifier3("a"),
+ AstFactory.identifier3("b"),
+ AstFactory.identifier3("c")
+ ]));
}
void test_visitMapLiteral_const() {
@@ -1423,12 +1074,11 @@ class AstClonerTest extends EngineTestCase {
}
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"))]));
+ _assertClone(AstFactory.mapLiteral2([
+ AstFactory.mapLiteralEntry("a", AstFactory.identifier3("a")),
+ AstFactory.mapLiteralEntry("b", AstFactory.identifier3("b")),
+ AstFactory.mapLiteralEntry("c", AstFactory.identifier3("c"))
+ ]));
}
void test_visitMapLiteralEntry() {
@@ -1436,174 +1086,92 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitMethodDeclaration_external() {
- _assertClone(
- AstFactory.methodDeclaration(
- null,
- null,
- null,
- null,
- AstFactory.identifier3("m"),
- AstFactory.formalParameterList()));
+ _assertClone(AstFactory.methodDeclaration(null, null, null, null,
+ AstFactory.identifier3("m"), AstFactory.formalParameterList()));
}
void test_visitMethodDeclaration_external_returnType() {
- _assertClone(
- AstFactory.methodDeclaration(
- null,
- AstFactory.typeName4("T"),
- null,
- null,
- AstFactory.identifier3("m"),
- AstFactory.formalParameterList()));
+ _assertClone(AstFactory.methodDeclaration(null, AstFactory.typeName4("T"),
+ null, null, AstFactory.identifier3("m"),
+ AstFactory.formalParameterList()));
}
void test_visitMethodDeclaration_getter() {
- _assertClone(
- AstFactory.methodDeclaration2(
- null,
- null,
- Keyword.GET,
- null,
- AstFactory.identifier3("m"),
- null,
- AstFactory.blockFunctionBody2()));
+ _assertClone(AstFactory.methodDeclaration2(null, null, Keyword.GET, null,
+ AstFactory.identifier3("m"), null, AstFactory.blockFunctionBody2()));
}
void test_visitMethodDeclaration_getter_returnType() {
- _assertClone(
- AstFactory.methodDeclaration2(
- null,
- AstFactory.typeName4("T"),
- Keyword.GET,
- null,
- AstFactory.identifier3("m"),
- null,
- AstFactory.blockFunctionBody2()));
+ _assertClone(AstFactory.methodDeclaration2(null, AstFactory.typeName4("T"),
+ Keyword.GET, null, AstFactory.identifier3("m"), null,
+ AstFactory.blockFunctionBody2()));
}
void test_visitMethodDeclaration_getter_seturnType() {
- _assertClone(
- AstFactory.methodDeclaration2(
- null,
- AstFactory.typeName4("T"),
- Keyword.SET,
- null,
- AstFactory.identifier3("m"),
- AstFactory.formalParameterList(
+ _assertClone(AstFactory.methodDeclaration2(null, AstFactory.typeName4("T"),
+ Keyword.SET, null, AstFactory.identifier3("m"), AstFactory
+ .formalParameterList(
[AstFactory.simpleFormalParameter(Keyword.VAR, "v")]),
- AstFactory.blockFunctionBody2()));
+ AstFactory.blockFunctionBody2()));
}
void test_visitMethodDeclaration_minimal() {
- _assertClone(
- AstFactory.methodDeclaration2(
- null,
- null,
- null,
- null,
- AstFactory.identifier3("m"),
- AstFactory.formalParameterList(),
- AstFactory.blockFunctionBody2()));
+ _assertClone(AstFactory.methodDeclaration2(null, null, null, null,
+ AstFactory.identifier3("m"), AstFactory.formalParameterList(),
+ AstFactory.blockFunctionBody2()));
}
void test_visitMethodDeclaration_multipleParameters() {
- _assertClone(
- AstFactory.methodDeclaration2(
- null,
- null,
- null,
- null,
- AstFactory.identifier3("m"),
- AstFactory.formalParameterList(
- [
- AstFactory.simpleFormalParameter(Keyword.VAR, "a"),
- AstFactory.simpleFormalParameter(Keyword.VAR, "b")]),
- AstFactory.blockFunctionBody2()));
+ _assertClone(AstFactory.methodDeclaration2(null, null, null, null,
+ AstFactory.identifier3("m"), AstFactory.formalParameterList([
+ AstFactory.simpleFormalParameter(Keyword.VAR, "a"),
+ AstFactory.simpleFormalParameter(Keyword.VAR, "b")
+ ]), AstFactory.blockFunctionBody2()));
}
void test_visitMethodDeclaration_operator() {
- _assertClone(
- AstFactory.methodDeclaration2(
- null,
- null,
- null,
- Keyword.OPERATOR,
- AstFactory.identifier3("+"),
- AstFactory.formalParameterList(),
- AstFactory.blockFunctionBody2()));
+ _assertClone(AstFactory.methodDeclaration2(null, null, null,
+ Keyword.OPERATOR, AstFactory.identifier3("+"),
+ AstFactory.formalParameterList(), AstFactory.blockFunctionBody2()));
}
void test_visitMethodDeclaration_operator_returnType() {
- _assertClone(
- AstFactory.methodDeclaration2(
- null,
- AstFactory.typeName4("T"),
- null,
- Keyword.OPERATOR,
- AstFactory.identifier3("+"),
- AstFactory.formalParameterList(),
- AstFactory.blockFunctionBody2()));
+ _assertClone(AstFactory.methodDeclaration2(null, AstFactory.typeName4("T"),
+ null, Keyword.OPERATOR, AstFactory.identifier3("+"),
+ AstFactory.formalParameterList(), AstFactory.blockFunctionBody2()));
}
void test_visitMethodDeclaration_returnType() {
- _assertClone(
- AstFactory.methodDeclaration2(
- null,
- AstFactory.typeName4("T"),
- null,
- null,
- AstFactory.identifier3("m"),
- AstFactory.formalParameterList(),
- AstFactory.blockFunctionBody2()));
+ _assertClone(AstFactory.methodDeclaration2(null, AstFactory.typeName4("T"),
+ null, null, AstFactory.identifier3("m"),
+ AstFactory.formalParameterList(), AstFactory.blockFunctionBody2()));
}
void test_visitMethodDeclaration_setter() {
- _assertClone(
- AstFactory.methodDeclaration2(
- null,
- null,
- Keyword.SET,
- null,
- AstFactory.identifier3("m"),
- AstFactory.formalParameterList(
- [AstFactory.simpleFormalParameter(Keyword.VAR, "v")]),
- AstFactory.blockFunctionBody2()));
+ _assertClone(AstFactory.methodDeclaration2(null, null, Keyword.SET, null,
+ AstFactory.identifier3("m"), AstFactory.formalParameterList(
+ [AstFactory.simpleFormalParameter(Keyword.VAR, "v")]),
+ AstFactory.blockFunctionBody2()));
}
void test_visitMethodDeclaration_static() {
- _assertClone(
- AstFactory.methodDeclaration2(
- Keyword.STATIC,
- null,
- null,
- null,
- AstFactory.identifier3("m"),
- AstFactory.formalParameterList(),
- AstFactory.blockFunctionBody2()));
+ _assertClone(AstFactory.methodDeclaration2(Keyword.STATIC, null, null, null,
+ AstFactory.identifier3("m"), AstFactory.formalParameterList(),
+ AstFactory.blockFunctionBody2()));
}
void test_visitMethodDeclaration_static_returnType() {
- _assertClone(
- AstFactory.methodDeclaration2(
- Keyword.STATIC,
- AstFactory.typeName4("T"),
- null,
- null,
- AstFactory.identifier3("m"),
- AstFactory.formalParameterList(),
- AstFactory.blockFunctionBody2()));
+ _assertClone(AstFactory.methodDeclaration2(Keyword.STATIC,
+ AstFactory.typeName4("T"), null, null, AstFactory.identifier3("m"),
+ AstFactory.formalParameterList(), AstFactory.blockFunctionBody2()));
}
void test_visitMethodDeclaration_withMetadata() {
- MethodDeclaration declaration = AstFactory.methodDeclaration2(
- null,
- null,
- null,
- null,
- AstFactory.identifier3("m"),
- AstFactory.formalParameterList(),
- AstFactory.blockFunctionBody2());
- declaration.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
+ MethodDeclaration declaration = AstFactory.methodDeclaration2(null, null,
+ null, null, AstFactory.identifier3("m"),
+ AstFactory.formalParameterList(), AstFactory.blockFunctionBody2());
+ declaration.metadata
+ .add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
_assertClone(declaration);
}
@@ -1620,10 +1188,9 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitNamedFormalParameter() {
- _assertClone(
- AstFactory.namedFormalParameter(
- AstFactory.simpleFormalParameter(Keyword.VAR, "a"),
- AstFactory.integer(0)));
+ _assertClone(AstFactory.namedFormalParameter(
+ AstFactory.simpleFormalParameter(Keyword.VAR, "a"),
+ AstFactory.integer(0)));
}
void test_visitNativeClause() {
@@ -1649,7 +1216,8 @@ class AstClonerTest extends EngineTestCase {
void test_visitPartDirective_withMetadata() {
PartDirective directive = AstFactory.partDirective2("a.dart");
- directive.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
+ directive.metadata
+ .add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
_assertClone(directive);
}
@@ -1661,20 +1229,20 @@ class AstClonerTest extends EngineTestCase {
void test_visitPartOfDirective_withMetadata() {
PartOfDirective directive =
AstFactory.partOfDirective(AstFactory.libraryIdentifier2(["l"]));
- directive.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
+ directive.metadata
+ .add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
_assertClone(directive);
}
void test_visitPositionalFormalParameter() {
- _assertClone(
- AstFactory.positionalFormalParameter(
- AstFactory.simpleFormalParameter(Keyword.VAR, "a"),
- AstFactory.integer(0)));
+ _assertClone(AstFactory.positionalFormalParameter(
+ AstFactory.simpleFormalParameter(Keyword.VAR, "a"),
+ AstFactory.integer(0)));
}
void test_visitPostfixExpression() {
- _assertClone(
- AstFactory.postfixExpression(AstFactory.identifier3("a"), TokenType.PLUS_PLUS));
+ _assertClone(AstFactory.postfixExpression(
+ AstFactory.identifier3("a"), TokenType.PLUS_PLUS));
}
void test_visitPrefixedIdentifier() {
@@ -1682,8 +1250,8 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitPrefixExpression() {
- _assertClone(
- AstFactory.prefixExpression(TokenType.MINUS, AstFactory.identifier3("a")));
+ _assertClone(AstFactory.prefixExpression(
+ TokenType.MINUS, AstFactory.identifier3("a")));
}
void test_visitPropertyAccess() {
@@ -1720,11 +1288,8 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitSimpleFormalParameter_keyword_type() {
- _assertClone(
- AstFactory.simpleFormalParameter2(
- Keyword.FINAL,
- AstFactory.typeName4("A"),
- "a"));
+ _assertClone(AstFactory.simpleFormalParameter2(
+ Keyword.FINAL, AstFactory.typeName4("A"), "a"));
}
void test_visitSimpleFormalParameter_type() {
@@ -1741,12 +1306,11 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitStringInterpolation() {
- _assertClone(
- AstFactory.string(
- [
- AstFactory.interpolationString("'a", "a"),
- AstFactory.interpolationExpression(AstFactory.identifier3("e")),
- AstFactory.interpolationString("b'", "b")]));
+ _assertClone(AstFactory.string([
+ AstFactory.interpolationString("'a", "a"),
+ AstFactory.interpolationExpression(AstFactory.identifier3("e")),
+ AstFactory.interpolationString("b'", "b")
+ ]));
}
void test_visitSuperConstructorInvocation() {
@@ -1762,38 +1326,33 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitSwitchCase_multipleLabels() {
- _assertClone(
- AstFactory.switchCase2(
- [AstFactory.label2("l1"), AstFactory.label2("l2")],
- AstFactory.identifier3("a"),
- [AstFactory.block()]));
+ _assertClone(AstFactory.switchCase2([
+ AstFactory.label2("l1"),
+ AstFactory.label2("l2")
+ ], AstFactory.identifier3("a"), [AstFactory.block()]));
}
void test_visitSwitchCase_multipleStatements() {
- _assertClone(
- AstFactory.switchCase(
- AstFactory.identifier3("a"),
- [AstFactory.block(), AstFactory.block()]));
+ _assertClone(AstFactory.switchCase(
+ AstFactory.identifier3("a"), [AstFactory.block(), AstFactory.block()]));
}
void test_visitSwitchCase_noLabels() {
- _assertClone(
- AstFactory.switchCase(AstFactory.identifier3("a"), [AstFactory.block()]));
+ _assertClone(AstFactory.switchCase(
+ AstFactory.identifier3("a"), [AstFactory.block()]));
}
void test_visitSwitchCase_singleLabel() {
- _assertClone(
- AstFactory.switchCase2(
- [AstFactory.label2("l1")],
- AstFactory.identifier3("a"),
- [AstFactory.block()]));
+ _assertClone(AstFactory.switchCase2([
+ AstFactory.label2("l1")
+ ], AstFactory.identifier3("a"), [AstFactory.block()]));
}
void test_visitSwitchDefault_multipleLabels() {
- _assertClone(
- AstFactory.switchDefault(
- [AstFactory.label2("l1"), AstFactory.label2("l2")],
- [AstFactory.block()]));
+ _assertClone(AstFactory.switchDefault([
+ AstFactory.label2("l1"),
+ AstFactory.label2("l2")
+ ], [AstFactory.block()]));
}
void test_visitSwitchDefault_multipleStatements() {
@@ -1806,17 +1365,15 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitSwitchDefault_singleLabel() {
- _assertClone(
- AstFactory.switchDefault([AstFactory.label2("l1")], [AstFactory.block()]));
+ _assertClone(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()])]));
+ _assertClone(AstFactory.switchStatement(AstFactory.identifier3("a"), [
+ AstFactory.switchCase(AstFactory.string2("b"), [AstFactory.block()]),
+ AstFactory.switchDefault2([AstFactory.block()])
+ ]));
}
void test_visitSymbolLiteral_multiple() {
@@ -1836,41 +1393,34 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitTopLevelVariableDeclaration_multiple() {
- _assertClone(
- AstFactory.topLevelVariableDeclaration2(
- Keyword.VAR,
- [AstFactory.variableDeclaration("a")]));
+ _assertClone(AstFactory.topLevelVariableDeclaration2(
+ Keyword.VAR, [AstFactory.variableDeclaration("a")]));
}
void test_visitTopLevelVariableDeclaration_single() {
- _assertClone(
- AstFactory.topLevelVariableDeclaration2(
- Keyword.VAR,
- [AstFactory.variableDeclaration("a"), AstFactory.variableDeclaration("b")]));
+ _assertClone(AstFactory.topLevelVariableDeclaration2(Keyword.VAR, [
+ AstFactory.variableDeclaration("a"),
+ AstFactory.variableDeclaration("b")
+ ]));
}
void test_visitTryStatement_catch() {
- _assertClone(
- AstFactory.tryStatement2(
- AstFactory.block(),
- [AstFactory.catchClause3(AstFactory.typeName4("E"))]));
+ _assertClone(AstFactory.tryStatement2(AstFactory.block(), [
+ AstFactory.catchClause3(AstFactory.typeName4("E"))
+ ]));
}
void test_visitTryStatement_catches() {
- _assertClone(
- AstFactory.tryStatement2(
- AstFactory.block(),
- [
- AstFactory.catchClause3(AstFactory.typeName4("E")),
- AstFactory.catchClause3(AstFactory.typeName4("F"))]));
+ _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()));
+ _assertClone(AstFactory.tryStatement3(AstFactory.block(), [
+ AstFactory.catchClause3(AstFactory.typeName4("E"))
+ ], AstFactory.block()));
}
void test_visitTryStatement_finally() {
@@ -1879,9 +1429,8 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitTypeArgumentList_multiple() {
- _assertClone(
- AstFactory.typeArgumentList(
- [AstFactory.typeName4("E"), AstFactory.typeName4("F")]));
+ _assertClone(AstFactory.typeArgumentList(
+ [AstFactory.typeName4("E"), AstFactory.typeName4("F")]));
}
void test_visitTypeArgumentList_single() {
@@ -1889,17 +1438,13 @@ class AstClonerTest extends EngineTestCase {
}
void test_visitTypeName_multipleArgs() {
- _assertClone(
- AstFactory.typeName4(
- "C",
- [AstFactory.typeName4("D"), AstFactory.typeName4("E")]));
+ _assertClone(AstFactory.typeName4(
+ "C", [AstFactory.typeName4("D"), AstFactory.typeName4("E")]));
}
void test_visitTypeName_nestedArg() {
- _assertClone(
- AstFactory.typeName4(
- "C",
- [AstFactory.typeName4("D", [AstFactory.typeName4("E")])]));
+ _assertClone(AstFactory.typeName4(
+ "C", [AstFactory.typeName4("D", [AstFactory.typeName4("E")])]));
}
void test_visitTypeName_noArgs() {
@@ -1916,7 +1461,8 @@ class AstClonerTest extends EngineTestCase {
void test_visitTypeParameter_withMetadata() {
TypeParameter parameter = AstFactory.typeParameter("E");
- parameter.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
+ parameter.metadata
+ .add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
_assertClone(parameter);
}
@@ -1943,69 +1489,68 @@ class AstClonerTest extends EngineTestCase {
void test_visitVariableDeclaration_withMetadata() {
VariableDeclaration declaration = AstFactory.variableDeclaration("a");
- declaration.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
+ declaration.metadata
+ .add(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")]));
+ _assertClone(AstFactory.variableDeclarationList(Keyword.CONST,
+ AstFactory.typeName4("C"), [
+ AstFactory.variableDeclaration("a"),
+ AstFactory.variableDeclaration("b")
+ ]));
}
void test_visitVariableDeclarationList_final_noType() {
- _assertClone(
- AstFactory.variableDeclarationList2(
- Keyword.FINAL,
- [AstFactory.variableDeclaration("a"), AstFactory.variableDeclaration("b")]));
+ _assertClone(AstFactory.variableDeclarationList2(Keyword.FINAL, [
+ AstFactory.variableDeclaration("a"),
+ AstFactory.variableDeclaration("b")
+ ]));
}
void test_visitVariableDeclarationList_final_withMetadata() {
- VariableDeclarationList declarationList =
- AstFactory.variableDeclarationList2(
- Keyword.FINAL,
- [AstFactory.variableDeclaration("a"), AstFactory.variableDeclaration("b")]);
- declarationList.metadata.add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
+ VariableDeclarationList declarationList = AstFactory
+ .variableDeclarationList2(Keyword.FINAL, [
+ AstFactory.variableDeclaration("a"),
+ AstFactory.variableDeclaration("b")
+ ]);
+ declarationList.metadata
+ .add(AstFactory.annotation(AstFactory.identifier3("deprecated")));
_assertClone(declarationList);
}
void test_visitVariableDeclarationList_type() {
- _assertClone(
- AstFactory.variableDeclarationList(
- null,
- AstFactory.typeName4("C"),
- [AstFactory.variableDeclaration("a"), AstFactory.variableDeclaration("b")]));
+ _assertClone(AstFactory.variableDeclarationList(null,
+ AstFactory.typeName4("C"), [
+ AstFactory.variableDeclaration("a"),
+ AstFactory.variableDeclaration("b")
+ ]));
}
void test_visitVariableDeclarationList_var() {
- _assertClone(
- AstFactory.variableDeclarationList2(
- Keyword.VAR,
- [AstFactory.variableDeclaration("a"), AstFactory.variableDeclaration("b")]));
+ _assertClone(AstFactory.variableDeclarationList2(Keyword.VAR, [
+ AstFactory.variableDeclaration("a"),
+ AstFactory.variableDeclaration("b")
+ ]));
}
void test_visitVariableDeclarationStatement() {
- _assertClone(
- AstFactory.variableDeclarationStatement(
- null,
- AstFactory.typeName4("C"),
- [AstFactory.variableDeclaration("c")]));
+ _assertClone(AstFactory.variableDeclarationStatement(null,
+ AstFactory.typeName4("C"), [AstFactory.variableDeclaration("c")]));
}
void test_visitWhileStatement() {
- _assertClone(
- AstFactory.whileStatement(AstFactory.identifier3("c"), AstFactory.block()));
+ _assertClone(AstFactory.whileStatement(
+ AstFactory.identifier3("c"), AstFactory.block()));
}
void test_visitWithClause_multiple() {
- _assertClone(
- AstFactory.withClause(
- [
- AstFactory.typeName4("A"),
- AstFactory.typeName4("B"),
- AstFactory.typeName4("C")]));
+ _assertClone(AstFactory.withClause([
+ AstFactory.typeName4("A"),
+ AstFactory.typeName4("B"),
+ AstFactory.typeName4("C")
+ ]));
}
void test_visitWithClause_single() {
@@ -2366,366 +1911,365 @@ class DirectedGraphTest extends EngineTestCase {
/**
* Instances of the class `Node` represent simple nodes used for testing purposes.
*/
-class DirectedGraphTest_Node {
-}
+class DirectedGraphTest_Node {}
-class Getter_NodeReplacerTest_test_annotation implements NodeReplacerTest_Getter
- {
+class Getter_NodeReplacerTest_test_annotation
+ implements NodeReplacerTest_Getter {
@override
ArgumentList get(Annotation node) => node.arguments;
}
-class Getter_NodeReplacerTest_test_annotation_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_annotation_2
+ implements NodeReplacerTest_Getter {
@override
Identifier get(Annotation node) => node.name;
}
-class Getter_NodeReplacerTest_test_annotation_3 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_annotation_3
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(Annotation node) => node.constructorName;
}
-class Getter_NodeReplacerTest_test_asExpression implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_asExpression
+ implements NodeReplacerTest_Getter {
@override
TypeName get(AsExpression node) => node.type;
}
-class Getter_NodeReplacerTest_test_asExpression_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_asExpression_2
+ implements NodeReplacerTest_Getter {
@override
Expression get(AsExpression node) => node.expression;
}
-class Getter_NodeReplacerTest_test_assertStatement implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_assertStatement
+ implements NodeReplacerTest_Getter {
@override
Expression get(AssertStatement node) => node.condition;
}
-class Getter_NodeReplacerTest_test_assignmentExpression implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_assignmentExpression
+ implements NodeReplacerTest_Getter {
@override
Expression get(AssignmentExpression node) => node.rightHandSide;
}
-class Getter_NodeReplacerTest_test_assignmentExpression_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_assignmentExpression_2
+ implements NodeReplacerTest_Getter {
@override
Expression get(AssignmentExpression node) => node.leftHandSide;
}
-class Getter_NodeReplacerTest_test_binaryExpression implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_binaryExpression
+ implements NodeReplacerTest_Getter {
@override
Expression get(BinaryExpression node) => node.leftOperand;
}
-class Getter_NodeReplacerTest_test_binaryExpression_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_binaryExpression_2
+ implements NodeReplacerTest_Getter {
@override
Expression get(BinaryExpression node) => node.rightOperand;
}
-class Getter_NodeReplacerTest_test_blockFunctionBody implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_blockFunctionBody
+ implements NodeReplacerTest_Getter {
@override
Block get(BlockFunctionBody node) => node.block;
}
-class Getter_NodeReplacerTest_test_breakStatement implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_breakStatement
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(BreakStatement node) => node.label;
}
-class Getter_NodeReplacerTest_test_cascadeExpression implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_cascadeExpression
+ implements NodeReplacerTest_Getter {
@override
Expression get(CascadeExpression node) => node.target;
}
-class Getter_NodeReplacerTest_test_catchClause implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_catchClause
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(CatchClause node) => node.stackTraceParameter;
}
-class Getter_NodeReplacerTest_test_catchClause_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_catchClause_2
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(CatchClause node) => node.exceptionParameter;
}
-class Getter_NodeReplacerTest_test_catchClause_3 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_catchClause_3
+ implements NodeReplacerTest_Getter {
@override
TypeName get(CatchClause node) => node.exceptionType;
}
-class Getter_NodeReplacerTest_test_classDeclaration implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_classDeclaration
+ implements NodeReplacerTest_Getter {
@override
ImplementsClause get(ClassDeclaration node) => node.implementsClause;
}
-class Getter_NodeReplacerTest_test_classDeclaration_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_classDeclaration_2
+ implements NodeReplacerTest_Getter {
@override
WithClause get(ClassDeclaration node) => node.withClause;
}
-class Getter_NodeReplacerTest_test_classDeclaration_3 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_classDeclaration_3
+ implements NodeReplacerTest_Getter {
@override
NativeClause get(ClassDeclaration node) => node.nativeClause;
}
-class Getter_NodeReplacerTest_test_classDeclaration_4 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_classDeclaration_4
+ implements NodeReplacerTest_Getter {
@override
ExtendsClause get(ClassDeclaration node) => node.extendsClause;
}
-class Getter_NodeReplacerTest_test_classDeclaration_5 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_classDeclaration_5
+ implements NodeReplacerTest_Getter {
@override
TypeParameterList get(ClassDeclaration node) => node.typeParameters;
}
-class Getter_NodeReplacerTest_test_classDeclaration_6 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_classDeclaration_6
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(ClassDeclaration node) => node.name;
}
-class Getter_NodeReplacerTest_test_classTypeAlias implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_classTypeAlias
+ implements NodeReplacerTest_Getter {
@override
TypeName get(ClassTypeAlias node) => node.superclass;
}
-class Getter_NodeReplacerTest_test_classTypeAlias_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_classTypeAlias_2
+ implements NodeReplacerTest_Getter {
@override
ImplementsClause get(ClassTypeAlias node) => node.implementsClause;
}
-class Getter_NodeReplacerTest_test_classTypeAlias_3 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_classTypeAlias_3
+ implements NodeReplacerTest_Getter {
@override
WithClause get(ClassTypeAlias node) => node.withClause;
}
-class Getter_NodeReplacerTest_test_classTypeAlias_4 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_classTypeAlias_4
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(ClassTypeAlias node) => node.name;
}
-class Getter_NodeReplacerTest_test_classTypeAlias_5 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_classTypeAlias_5
+ implements NodeReplacerTest_Getter {
@override
TypeParameterList get(ClassTypeAlias node) => node.typeParameters;
}
-class Getter_NodeReplacerTest_test_commentReference implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_commentReference
+ implements NodeReplacerTest_Getter {
@override
Identifier get(CommentReference node) => node.identifier;
}
-class Getter_NodeReplacerTest_test_compilationUnit implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_compilationUnit
+ implements NodeReplacerTest_Getter {
@override
ScriptTag get(CompilationUnit node) => node.scriptTag;
}
-class Getter_NodeReplacerTest_test_conditionalExpression implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_conditionalExpression
+ implements NodeReplacerTest_Getter {
@override
Expression get(ConditionalExpression node) => node.elseExpression;
}
-class Getter_NodeReplacerTest_test_conditionalExpression_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_conditionalExpression_2
+ implements NodeReplacerTest_Getter {
@override
Expression get(ConditionalExpression node) => node.thenExpression;
}
-class Getter_NodeReplacerTest_test_conditionalExpression_3 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_conditionalExpression_3
+ implements NodeReplacerTest_Getter {
@override
Expression get(ConditionalExpression node) => node.condition;
}
-class Getter_NodeReplacerTest_test_constructorDeclaration implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_constructorDeclaration
+ implements NodeReplacerTest_Getter {
@override
ConstructorName get(ConstructorDeclaration node) =>
node.redirectedConstructor;
}
-class Getter_NodeReplacerTest_test_constructorDeclaration_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_constructorDeclaration_2
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(ConstructorDeclaration node) => node.name;
}
-class Getter_NodeReplacerTest_test_constructorDeclaration_3 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_constructorDeclaration_3
+ implements NodeReplacerTest_Getter {
@override
Identifier get(ConstructorDeclaration node) => node.returnType;
}
-class Getter_NodeReplacerTest_test_constructorDeclaration_4 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_constructorDeclaration_4
+ implements NodeReplacerTest_Getter {
@override
FormalParameterList get(ConstructorDeclaration node) => node.parameters;
}
-class Getter_NodeReplacerTest_test_constructorDeclaration_5 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_constructorDeclaration_5
+ implements NodeReplacerTest_Getter {
@override
FunctionBody get(ConstructorDeclaration node) => node.body;
}
-class Getter_NodeReplacerTest_test_constructorFieldInitializer implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_constructorFieldInitializer
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(ConstructorFieldInitializer node) => node.fieldName;
}
-class Getter_NodeReplacerTest_test_constructorFieldInitializer_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_constructorFieldInitializer_2
+ implements NodeReplacerTest_Getter {
@override
Expression get(ConstructorFieldInitializer node) => node.expression;
}
-class Getter_NodeReplacerTest_test_constructorName implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_constructorName
+ implements NodeReplacerTest_Getter {
@override
TypeName get(ConstructorName node) => node.type;
}
-class Getter_NodeReplacerTest_test_constructorName_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_constructorName_2
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(ConstructorName node) => node.name;
}
-class Getter_NodeReplacerTest_test_continueStatement implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_continueStatement
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(ContinueStatement node) => node.label;
}
-class Getter_NodeReplacerTest_test_declaredIdentifier implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_declaredIdentifier
+ implements NodeReplacerTest_Getter {
@override
TypeName get(DeclaredIdentifier node) => node.type;
}
-class Getter_NodeReplacerTest_test_declaredIdentifier_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_declaredIdentifier_2
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(DeclaredIdentifier node) => node.identifier;
}
-class Getter_NodeReplacerTest_test_defaultFormalParameter implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_defaultFormalParameter
+ implements NodeReplacerTest_Getter {
@override
NormalFormalParameter get(DefaultFormalParameter node) => node.parameter;
}
-class Getter_NodeReplacerTest_test_defaultFormalParameter_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_defaultFormalParameter_2
+ implements NodeReplacerTest_Getter {
@override
Expression get(DefaultFormalParameter node) => node.defaultValue;
}
-class Getter_NodeReplacerTest_test_doStatement implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_doStatement
+ implements NodeReplacerTest_Getter {
@override
Expression get(DoStatement node) => node.condition;
}
-class Getter_NodeReplacerTest_test_doStatement_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_doStatement_2
+ implements NodeReplacerTest_Getter {
@override
Statement get(DoStatement node) => node.body;
}
-class Getter_NodeReplacerTest_test_enumConstantDeclaration implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_enumConstantDeclaration
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(EnumConstantDeclaration node) => node.name;
}
-class Getter_NodeReplacerTest_test_enumDeclaration implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_enumDeclaration
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(EnumDeclaration node) => node.name;
}
-class Getter_NodeReplacerTest_test_expressionFunctionBody implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_expressionFunctionBody
+ implements NodeReplacerTest_Getter {
@override
Expression get(ExpressionFunctionBody node) => node.expression;
}
-class Getter_NodeReplacerTest_test_expressionStatement implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_expressionStatement
+ implements NodeReplacerTest_Getter {
@override
Expression get(ExpressionStatement node) => node.expression;
}
-class Getter_NodeReplacerTest_test_extendsClause implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_extendsClause
+ implements NodeReplacerTest_Getter {
@override
TypeName get(ExtendsClause node) => node.superclass;
}
-class Getter_NodeReplacerTest_test_fieldDeclaration implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_fieldDeclaration
+ implements NodeReplacerTest_Getter {
@override
VariableDeclarationList get(FieldDeclaration node) => node.fields;
}
-class Getter_NodeReplacerTest_test_fieldFormalParameter implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_fieldFormalParameter
+ implements NodeReplacerTest_Getter {
@override
FormalParameterList get(FieldFormalParameter node) => node.parameters;
}
-class Getter_NodeReplacerTest_test_fieldFormalParameter_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_fieldFormalParameter_2
+ implements NodeReplacerTest_Getter {
@override
TypeName get(FieldFormalParameter node) => node.type;
}
-class Getter_NodeReplacerTest_test_forEachStatement_withIdentifier implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_forEachStatement_withIdentifier
+ implements NodeReplacerTest_Getter {
@override
Statement get(ForEachStatement node) => node.body;
}
-class Getter_NodeReplacerTest_test_forEachStatement_withIdentifier_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_forEachStatement_withIdentifier_2
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(ForEachStatement node) => node.identifier;
}
-class Getter_NodeReplacerTest_test_forEachStatement_withIdentifier_3 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_forEachStatement_withIdentifier_3
+ implements NodeReplacerTest_Getter {
@override
Expression get(ForEachStatement node) => node.iterable;
}
-class Getter_NodeReplacerTest_test_forEachStatement_withLoopVariable implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_forEachStatement_withLoopVariable
+ implements NodeReplacerTest_Getter {
@override
Expression get(ForEachStatement node) => node.iterable;
}
@@ -2742,189 +2286,189 @@ class Getter_NodeReplacerTest_test_forEachStatement_withLoopVariable_3
Statement get(ForEachStatement node) => node.body;
}
-class Getter_NodeReplacerTest_test_forStatement_withInitialization implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_forStatement_withInitialization
+ implements NodeReplacerTest_Getter {
@override
Statement get(ForStatement node) => node.body;
}
-class Getter_NodeReplacerTest_test_forStatement_withInitialization_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_forStatement_withInitialization_2
+ implements NodeReplacerTest_Getter {
@override
Expression get(ForStatement node) => node.condition;
}
-class Getter_NodeReplacerTest_test_forStatement_withInitialization_3 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_forStatement_withInitialization_3
+ implements NodeReplacerTest_Getter {
@override
Expression get(ForStatement node) => node.initialization;
}
-class Getter_NodeReplacerTest_test_forStatement_withVariables implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_forStatement_withVariables
+ implements NodeReplacerTest_Getter {
@override
Statement get(ForStatement node) => node.body;
}
-class Getter_NodeReplacerTest_test_forStatement_withVariables_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_forStatement_withVariables_2
+ implements NodeReplacerTest_Getter {
@override
VariableDeclarationList get(ForStatement node) => node.variables;
}
-class Getter_NodeReplacerTest_test_forStatement_withVariables_3 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_forStatement_withVariables_3
+ implements NodeReplacerTest_Getter {
@override
Expression get(ForStatement node) => node.condition;
}
-class Getter_NodeReplacerTest_test_functionDeclaration implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_functionDeclaration
+ implements NodeReplacerTest_Getter {
@override
TypeName get(FunctionDeclaration node) => node.returnType;
}
-class Getter_NodeReplacerTest_test_functionDeclaration_2 implements
- NodeReplacerTest_Getter {
+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 {
+class Getter_NodeReplacerTest_test_functionDeclaration_3
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(FunctionDeclaration node) => node.name;
}
-class Getter_NodeReplacerTest_test_functionDeclarationStatement implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_functionDeclarationStatement
+ implements NodeReplacerTest_Getter {
@override
FunctionDeclaration get(FunctionDeclarationStatement node) =>
node.functionDeclaration;
}
-class Getter_NodeReplacerTest_test_functionExpression implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_functionExpression
+ implements NodeReplacerTest_Getter {
@override
FormalParameterList get(FunctionExpression node) => node.parameters;
}
-class Getter_NodeReplacerTest_test_functionExpression_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_functionExpression_2
+ implements NodeReplacerTest_Getter {
@override
FunctionBody get(FunctionExpression node) => node.body;
}
-class Getter_NodeReplacerTest_test_functionExpressionInvocation implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_functionExpressionInvocation
+ implements NodeReplacerTest_Getter {
@override
Expression get(FunctionExpressionInvocation node) => node.function;
}
-class Getter_NodeReplacerTest_test_functionExpressionInvocation_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_functionExpressionInvocation_2
+ implements NodeReplacerTest_Getter {
@override
ArgumentList get(FunctionExpressionInvocation node) => node.argumentList;
}
-class Getter_NodeReplacerTest_test_functionTypeAlias implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_functionTypeAlias
+ implements NodeReplacerTest_Getter {
@override
TypeParameterList get(FunctionTypeAlias node) => node.typeParameters;
}
-class Getter_NodeReplacerTest_test_functionTypeAlias_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_functionTypeAlias_2
+ implements NodeReplacerTest_Getter {
@override
FormalParameterList get(FunctionTypeAlias node) => node.parameters;
}
-class Getter_NodeReplacerTest_test_functionTypeAlias_3 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_functionTypeAlias_3
+ implements NodeReplacerTest_Getter {
@override
TypeName get(FunctionTypeAlias node) => node.returnType;
}
-class Getter_NodeReplacerTest_test_functionTypeAlias_4 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_functionTypeAlias_4
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(FunctionTypeAlias node) => node.name;
}
-class Getter_NodeReplacerTest_test_functionTypedFormalParameter implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_functionTypedFormalParameter
+ implements NodeReplacerTest_Getter {
@override
TypeName get(FunctionTypedFormalParameter node) => node.returnType;
}
-class Getter_NodeReplacerTest_test_functionTypedFormalParameter_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_functionTypedFormalParameter_2
+ implements NodeReplacerTest_Getter {
@override
FormalParameterList get(FunctionTypedFormalParameter node) => node.parameters;
}
-class Getter_NodeReplacerTest_test_ifStatement implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_ifStatement
+ implements NodeReplacerTest_Getter {
@override
Expression get(IfStatement node) => node.condition;
}
-class Getter_NodeReplacerTest_test_ifStatement_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_ifStatement_2
+ implements NodeReplacerTest_Getter {
@override
Statement get(IfStatement node) => node.elseStatement;
}
-class Getter_NodeReplacerTest_test_ifStatement_3 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_ifStatement_3
+ implements NodeReplacerTest_Getter {
@override
Statement get(IfStatement node) => node.thenStatement;
}
-class Getter_NodeReplacerTest_test_importDirective implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_importDirective
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(ImportDirective node) => node.prefix;
}
-class Getter_NodeReplacerTest_test_indexExpression implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_indexExpression
+ implements NodeReplacerTest_Getter {
@override
Expression get(IndexExpression node) => node.target;
}
-class Getter_NodeReplacerTest_test_indexExpression_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_indexExpression_2
+ implements NodeReplacerTest_Getter {
@override
Expression get(IndexExpression node) => node.index;
}
-class Getter_NodeReplacerTest_test_instanceCreationExpression implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_instanceCreationExpression
+ implements NodeReplacerTest_Getter {
@override
ArgumentList get(InstanceCreationExpression node) => node.argumentList;
}
-class Getter_NodeReplacerTest_test_instanceCreationExpression_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_instanceCreationExpression_2
+ implements NodeReplacerTest_Getter {
@override
ConstructorName get(InstanceCreationExpression node) => node.constructorName;
}
-class Getter_NodeReplacerTest_test_interpolationExpression implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_interpolationExpression
+ implements NodeReplacerTest_Getter {
@override
Expression get(InterpolationExpression node) => node.expression;
}
-class Getter_NodeReplacerTest_test_isExpression implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_isExpression
+ implements NodeReplacerTest_Getter {
@override
Expression get(IsExpression node) => node.expression;
}
-class Getter_NodeReplacerTest_test_isExpression_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_isExpression_2
+ implements NodeReplacerTest_Getter {
@override
TypeName get(IsExpression node) => node.type;
}
@@ -2934,214 +2478,214 @@ class Getter_NodeReplacerTest_test_label implements NodeReplacerTest_Getter {
SimpleIdentifier get(Label node) => node.label;
}
-class Getter_NodeReplacerTest_test_labeledStatement implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_labeledStatement
+ implements NodeReplacerTest_Getter {
@override
Statement get(LabeledStatement node) => node.statement;
}
-class Getter_NodeReplacerTest_test_libraryDirective implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_libraryDirective
+ implements NodeReplacerTest_Getter {
@override
LibraryIdentifier get(LibraryDirective node) => node.name;
}
-class Getter_NodeReplacerTest_test_mapLiteralEntry implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_mapLiteralEntry
+ implements NodeReplacerTest_Getter {
@override
Expression get(MapLiteralEntry node) => node.value;
}
-class Getter_NodeReplacerTest_test_mapLiteralEntry_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_mapLiteralEntry_2
+ implements NodeReplacerTest_Getter {
@override
Expression get(MapLiteralEntry node) => node.key;
}
-class Getter_NodeReplacerTest_test_methodDeclaration implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_methodDeclaration
+ implements NodeReplacerTest_Getter {
@override
TypeName get(MethodDeclaration node) => node.returnType;
}
-class Getter_NodeReplacerTest_test_methodDeclaration_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_methodDeclaration_2
+ implements NodeReplacerTest_Getter {
@override
FunctionBody get(MethodDeclaration node) => node.body;
}
-class Getter_NodeReplacerTest_test_methodDeclaration_3 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_methodDeclaration_3
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(MethodDeclaration node) => node.name;
}
-class Getter_NodeReplacerTest_test_methodDeclaration_4 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_methodDeclaration_4
+ implements NodeReplacerTest_Getter {
@override
FormalParameterList get(MethodDeclaration node) => node.parameters;
}
-class Getter_NodeReplacerTest_test_methodInvocation implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_methodInvocation
+ implements NodeReplacerTest_Getter {
@override
ArgumentList get(MethodInvocation node) => node.argumentList;
}
-class Getter_NodeReplacerTest_test_methodInvocation_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_methodInvocation_2
+ implements NodeReplacerTest_Getter {
@override
Expression get(MethodInvocation node) => node.target;
}
-class Getter_NodeReplacerTest_test_methodInvocation_3 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_methodInvocation_3
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(MethodInvocation node) => node.methodName;
}
-class Getter_NodeReplacerTest_test_namedExpression implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_namedExpression
+ implements NodeReplacerTest_Getter {
@override
Label get(NamedExpression node) => node.name;
}
-class Getter_NodeReplacerTest_test_namedExpression_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_namedExpression_2
+ implements NodeReplacerTest_Getter {
@override
Expression get(NamedExpression node) => node.expression;
}
-class Getter_NodeReplacerTest_test_nativeClause implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_nativeClause
+ implements NodeReplacerTest_Getter {
@override
StringLiteral get(NativeClause node) => node.name;
}
-class Getter_NodeReplacerTest_test_nativeFunctionBody implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_nativeFunctionBody
+ implements NodeReplacerTest_Getter {
@override
StringLiteral get(NativeFunctionBody node) => node.stringLiteral;
}
-class Getter_NodeReplacerTest_test_parenthesizedExpression implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_parenthesizedExpression
+ implements NodeReplacerTest_Getter {
@override
Expression get(ParenthesizedExpression node) => node.expression;
}
-class Getter_NodeReplacerTest_test_partOfDirective implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_partOfDirective
+ implements NodeReplacerTest_Getter {
@override
LibraryIdentifier get(PartOfDirective node) => node.libraryName;
}
-class Getter_NodeReplacerTest_test_postfixExpression implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_postfixExpression
+ implements NodeReplacerTest_Getter {
@override
Expression get(PostfixExpression node) => node.operand;
}
-class Getter_NodeReplacerTest_test_prefixedIdentifier implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_prefixedIdentifier
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(PrefixedIdentifier node) => node.identifier;
}
-class Getter_NodeReplacerTest_test_prefixedIdentifier_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_prefixedIdentifier_2
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(PrefixedIdentifier node) => node.prefix;
}
-class Getter_NodeReplacerTest_test_prefixExpression implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_prefixExpression
+ implements NodeReplacerTest_Getter {
@override
Expression get(PrefixExpression node) => node.operand;
}
-class Getter_NodeReplacerTest_test_propertyAccess implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_propertyAccess
+ implements NodeReplacerTest_Getter {
@override
Expression get(PropertyAccess node) => node.target;
}
-class Getter_NodeReplacerTest_test_propertyAccess_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_propertyAccess_2
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(PropertyAccess node) => node.propertyName;
}
-class Getter_NodeReplacerTest_test_redirectingConstructorInvocation implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_redirectingConstructorInvocation
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(RedirectingConstructorInvocation node) =>
node.constructorName;
}
-class Getter_NodeReplacerTest_test_redirectingConstructorInvocation_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_redirectingConstructorInvocation_2
+ implements NodeReplacerTest_Getter {
@override
ArgumentList get(RedirectingConstructorInvocation node) => node.argumentList;
}
-class Getter_NodeReplacerTest_test_returnStatement implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_returnStatement
+ implements NodeReplacerTest_Getter {
@override
Expression get(ReturnStatement node) => node.expression;
}
-class Getter_NodeReplacerTest_test_simpleFormalParameter implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_simpleFormalParameter
+ implements NodeReplacerTest_Getter {
@override
TypeName get(SimpleFormalParameter node) => node.type;
}
-class Getter_NodeReplacerTest_test_superConstructorInvocation implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_superConstructorInvocation
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(SuperConstructorInvocation node) => node.constructorName;
}
-class Getter_NodeReplacerTest_test_superConstructorInvocation_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_superConstructorInvocation_2
+ implements NodeReplacerTest_Getter {
@override
ArgumentList get(SuperConstructorInvocation node) => node.argumentList;
}
-class Getter_NodeReplacerTest_test_switchCase implements NodeReplacerTest_Getter
- {
+class Getter_NodeReplacerTest_test_switchCase
+ implements NodeReplacerTest_Getter {
@override
Expression get(SwitchCase node) => node.expression;
}
-class Getter_NodeReplacerTest_test_switchStatement implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_switchStatement
+ implements NodeReplacerTest_Getter {
@override
Expression get(SwitchStatement node) => node.expression;
}
-class Getter_NodeReplacerTest_test_throwExpression implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_throwExpression
+ implements NodeReplacerTest_Getter {
@override
Expression get(ThrowExpression node) => node.expression;
}
-class Getter_NodeReplacerTest_test_topLevelVariableDeclaration implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_topLevelVariableDeclaration
+ implements NodeReplacerTest_Getter {
@override
VariableDeclarationList get(TopLevelVariableDeclaration node) =>
node.variables;
}
-class Getter_NodeReplacerTest_test_tryStatement implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_tryStatement
+ implements NodeReplacerTest_Getter {
@override
Block get(TryStatement node) => node.finallyBlock;
}
-class Getter_NodeReplacerTest_test_tryStatement_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_tryStatement_2
+ implements NodeReplacerTest_Getter {
@override
Block get(TryStatement node) => node.body;
}
@@ -3151,87 +2695,87 @@ class Getter_NodeReplacerTest_test_typeName implements NodeReplacerTest_Getter {
TypeArgumentList get(TypeName node) => node.typeArguments;
}
-class Getter_NodeReplacerTest_test_typeName_2 implements NodeReplacerTest_Getter
- {
+class Getter_NodeReplacerTest_test_typeName_2
+ implements NodeReplacerTest_Getter {
@override
Identifier get(TypeName node) => node.name;
}
-class Getter_NodeReplacerTest_test_typeParameter implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_typeParameter
+ implements NodeReplacerTest_Getter {
@override
TypeName get(TypeParameter node) => node.bound;
}
-class Getter_NodeReplacerTest_test_typeParameter_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_typeParameter_2
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(TypeParameter node) => node.name;
}
-class Getter_NodeReplacerTest_test_variableDeclaration implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_variableDeclaration
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(VariableDeclaration node) => node.name;
}
-class Getter_NodeReplacerTest_test_variableDeclaration_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_variableDeclaration_2
+ implements NodeReplacerTest_Getter {
@override
Expression get(VariableDeclaration node) => node.initializer;
}
-class Getter_NodeReplacerTest_test_variableDeclarationList implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_variableDeclarationList
+ implements NodeReplacerTest_Getter {
@override
TypeName get(VariableDeclarationList node) => node.type;
}
-class Getter_NodeReplacerTest_test_variableDeclarationStatement implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_variableDeclarationStatement
+ implements NodeReplacerTest_Getter {
@override
VariableDeclarationList get(VariableDeclarationStatement node) =>
node.variables;
}
-class Getter_NodeReplacerTest_test_whileStatement implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_whileStatement
+ implements NodeReplacerTest_Getter {
@override
Expression get(WhileStatement node) => node.condition;
}
-class Getter_NodeReplacerTest_test_whileStatement_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_test_whileStatement_2
+ implements NodeReplacerTest_Getter {
@override
Statement get(WhileStatement node) => node.body;
}
-class Getter_NodeReplacerTest_testAnnotatedNode implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_testAnnotatedNode
+ implements NodeReplacerTest_Getter {
@override
Comment get(AnnotatedNode node) => node.documentationComment;
}
-class Getter_NodeReplacerTest_testNormalFormalParameter implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_testNormalFormalParameter
+ implements NodeReplacerTest_Getter {
@override
SimpleIdentifier get(NormalFormalParameter node) => node.identifier;
}
-class Getter_NodeReplacerTest_testNormalFormalParameter_2 implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_testNormalFormalParameter_2
+ implements NodeReplacerTest_Getter {
@override
Comment get(NormalFormalParameter node) => node.documentationComment;
}
-class Getter_NodeReplacerTest_testTypedLiteral implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_testTypedLiteral
+ implements NodeReplacerTest_Getter {
@override
TypeArgumentList get(TypedLiteral node) => node.typeArguments;
}
-class Getter_NodeReplacerTest_testUriBasedDirective implements
- NodeReplacerTest_Getter {
+class Getter_NodeReplacerTest_testUriBasedDirective
+ implements NodeReplacerTest_Getter {
@override
StringLiteral get(UriBasedDirective node) => node.uri;
}
@@ -3282,72 +2826,72 @@ class LineInfoTest {
}
}
-class ListGetter_NodeReplacerTest_test_adjacentStrings extends
- NodeReplacerTest_ListGetter<AdjacentStrings, StringLiteral> {
+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> {
+class ListGetter_NodeReplacerTest_test_adjacentStrings_2
+ extends NodeReplacerTest_ListGetter<AdjacentStrings, StringLiteral> {
ListGetter_NodeReplacerTest_test_adjacentStrings_2(int arg0) : super(arg0);
@override
NodeList<StringLiteral> getList(AdjacentStrings node) => node.strings;
}
-class ListGetter_NodeReplacerTest_test_argumentList extends
- NodeReplacerTest_ListGetter<ArgumentList, Expression> {
+class ListGetter_NodeReplacerTest_test_argumentList
+ extends NodeReplacerTest_ListGetter<ArgumentList, Expression> {
ListGetter_NodeReplacerTest_test_argumentList(int arg0) : super(arg0);
@override
NodeList<Expression> getList(ArgumentList node) => node.arguments;
}
-class ListGetter_NodeReplacerTest_test_block extends
- NodeReplacerTest_ListGetter<Block, Statement> {
+class ListGetter_NodeReplacerTest_test_block
+ extends NodeReplacerTest_ListGetter<Block, Statement> {
ListGetter_NodeReplacerTest_test_block(int arg0) : super(arg0);
@override
NodeList<Statement> getList(Block node) => node.statements;
}
-class ListGetter_NodeReplacerTest_test_cascadeExpression extends
- NodeReplacerTest_ListGetter<CascadeExpression, Expression> {
+class ListGetter_NodeReplacerTest_test_cascadeExpression
+ extends NodeReplacerTest_ListGetter<CascadeExpression, Expression> {
ListGetter_NodeReplacerTest_test_cascadeExpression(int arg0) : super(arg0);
@override
NodeList<Expression> getList(CascadeExpression node) => node.cascadeSections;
}
-class ListGetter_NodeReplacerTest_test_classDeclaration extends
- NodeReplacerTest_ListGetter<ClassDeclaration, ClassMember> {
+class ListGetter_NodeReplacerTest_test_classDeclaration
+ extends NodeReplacerTest_ListGetter<ClassDeclaration, ClassMember> {
ListGetter_NodeReplacerTest_test_classDeclaration(int arg0) : super(arg0);
@override
NodeList<ClassMember> getList(ClassDeclaration node) => node.members;
}
-class ListGetter_NodeReplacerTest_test_comment extends
- NodeReplacerTest_ListGetter<Comment, CommentReference> {
+class ListGetter_NodeReplacerTest_test_comment
+ extends NodeReplacerTest_ListGetter<Comment, CommentReference> {
ListGetter_NodeReplacerTest_test_comment(int arg0) : super(arg0);
@override
NodeList<CommentReference> getList(Comment node) => node.references;
}
-class ListGetter_NodeReplacerTest_test_compilationUnit extends
- NodeReplacerTest_ListGetter<CompilationUnit, Directive> {
+class ListGetter_NodeReplacerTest_test_compilationUnit
+ extends NodeReplacerTest_ListGetter<CompilationUnit, Directive> {
ListGetter_NodeReplacerTest_test_compilationUnit(int arg0) : super(arg0);
@override
NodeList<Directive> getList(CompilationUnit node) => node.directives;
}
-class ListGetter_NodeReplacerTest_test_compilationUnit_2 extends
- NodeReplacerTest_ListGetter<CompilationUnit, CompilationUnitMember> {
+class ListGetter_NodeReplacerTest_test_compilationUnit_2
+ extends NodeReplacerTest_ListGetter<CompilationUnit, CompilationUnitMember> {
ListGetter_NodeReplacerTest_test_compilationUnit_2(int arg0) : super(arg0);
@override
@@ -3355,8 +2899,8 @@ class ListGetter_NodeReplacerTest_test_compilationUnit_2 extends
node.declarations;
}
-class ListGetter_NodeReplacerTest_test_constructorDeclaration extends
- NodeReplacerTest_ListGetter<ConstructorDeclaration, ConstructorInitializer> {
+class ListGetter_NodeReplacerTest_test_constructorDeclaration
+ extends NodeReplacerTest_ListGetter<ConstructorDeclaration, ConstructorInitializer> {
ListGetter_NodeReplacerTest_test_constructorDeclaration(int arg0)
: super(arg0);
@@ -3365,8 +2909,8 @@ class ListGetter_NodeReplacerTest_test_constructorDeclaration extends
node.initializers;
}
-class ListGetter_NodeReplacerTest_test_formalParameterList extends
- NodeReplacerTest_ListGetter<FormalParameterList, FormalParameter> {
+class ListGetter_NodeReplacerTest_test_formalParameterList
+ extends NodeReplacerTest_ListGetter<FormalParameterList, FormalParameter> {
ListGetter_NodeReplacerTest_test_formalParameterList(int arg0) : super(arg0);
@override
@@ -3374,8 +2918,8 @@ class ListGetter_NodeReplacerTest_test_formalParameterList extends
node.parameters;
}
-class ListGetter_NodeReplacerTest_test_forStatement_withInitialization extends
- NodeReplacerTest_ListGetter<ForStatement, Expression> {
+class ListGetter_NodeReplacerTest_test_forStatement_withInitialization
+ extends NodeReplacerTest_ListGetter<ForStatement, Expression> {
ListGetter_NodeReplacerTest_test_forStatement_withInitialization(int arg0)
: super(arg0);
@@ -3383,8 +2927,8 @@ class ListGetter_NodeReplacerTest_test_forStatement_withInitialization extends
NodeList<Expression> getList(ForStatement node) => node.updaters;
}
-class ListGetter_NodeReplacerTest_test_forStatement_withVariables extends
- NodeReplacerTest_ListGetter<ForStatement, Expression> {
+class ListGetter_NodeReplacerTest_test_forStatement_withVariables
+ extends NodeReplacerTest_ListGetter<ForStatement, Expression> {
ListGetter_NodeReplacerTest_test_forStatement_withVariables(int arg0)
: super(arg0);
@@ -3392,64 +2936,64 @@ class ListGetter_NodeReplacerTest_test_forStatement_withVariables extends
NodeList<Expression> getList(ForStatement node) => node.updaters;
}
-class ListGetter_NodeReplacerTest_test_hideCombinator extends
- NodeReplacerTest_ListGetter<HideCombinator, SimpleIdentifier> {
+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> {
+class ListGetter_NodeReplacerTest_test_implementsClause
+ extends NodeReplacerTest_ListGetter<ImplementsClause, TypeName> {
ListGetter_NodeReplacerTest_test_implementsClause(int arg0) : super(arg0);
@override
NodeList<TypeName> getList(ImplementsClause node) => node.interfaces;
}
-class ListGetter_NodeReplacerTest_test_labeledStatement extends
- NodeReplacerTest_ListGetter<LabeledStatement, Label> {
+class ListGetter_NodeReplacerTest_test_labeledStatement
+ extends NodeReplacerTest_ListGetter<LabeledStatement, Label> {
ListGetter_NodeReplacerTest_test_labeledStatement(int arg0) : super(arg0);
@override
NodeList<Label> getList(LabeledStatement node) => node.labels;
}
-class ListGetter_NodeReplacerTest_test_libraryIdentifier extends
- NodeReplacerTest_ListGetter<LibraryIdentifier, SimpleIdentifier> {
+class ListGetter_NodeReplacerTest_test_libraryIdentifier
+ extends NodeReplacerTest_ListGetter<LibraryIdentifier, SimpleIdentifier> {
ListGetter_NodeReplacerTest_test_libraryIdentifier(int arg0) : super(arg0);
@override
NodeList<SimpleIdentifier> getList(LibraryIdentifier node) => node.components;
}
-class ListGetter_NodeReplacerTest_test_listLiteral extends
- NodeReplacerTest_ListGetter<ListLiteral, Expression> {
+class ListGetter_NodeReplacerTest_test_listLiteral
+ extends NodeReplacerTest_ListGetter<ListLiteral, Expression> {
ListGetter_NodeReplacerTest_test_listLiteral(int arg0) : super(arg0);
@override
NodeList<Expression> getList(ListLiteral node) => node.elements;
}
-class ListGetter_NodeReplacerTest_test_mapLiteral extends
- NodeReplacerTest_ListGetter<MapLiteral, MapLiteralEntry> {
+class ListGetter_NodeReplacerTest_test_mapLiteral
+ extends NodeReplacerTest_ListGetter<MapLiteral, MapLiteralEntry> {
ListGetter_NodeReplacerTest_test_mapLiteral(int arg0) : super(arg0);
@override
NodeList<MapLiteralEntry> getList(MapLiteral node) => node.entries;
}
-class ListGetter_NodeReplacerTest_test_showCombinator extends
- NodeReplacerTest_ListGetter<ShowCombinator, SimpleIdentifier> {
+class ListGetter_NodeReplacerTest_test_showCombinator
+ extends NodeReplacerTest_ListGetter<ShowCombinator, SimpleIdentifier> {
ListGetter_NodeReplacerTest_test_showCombinator(int arg0) : super(arg0);
@override
NodeList<SimpleIdentifier> getList(ShowCombinator node) => node.shownNames;
}
-class ListGetter_NodeReplacerTest_test_stringInterpolation extends
- NodeReplacerTest_ListGetter<StringInterpolation, InterpolationElement> {
+class ListGetter_NodeReplacerTest_test_stringInterpolation
+ extends NodeReplacerTest_ListGetter<StringInterpolation, InterpolationElement> {
ListGetter_NodeReplacerTest_test_stringInterpolation(int arg0) : super(arg0);
@override
@@ -3457,32 +3001,32 @@ class ListGetter_NodeReplacerTest_test_stringInterpolation extends
node.elements;
}
-class ListGetter_NodeReplacerTest_test_switchStatement extends
- NodeReplacerTest_ListGetter<SwitchStatement, SwitchMember> {
+class ListGetter_NodeReplacerTest_test_switchStatement
+ extends NodeReplacerTest_ListGetter<SwitchStatement, SwitchMember> {
ListGetter_NodeReplacerTest_test_switchStatement(int arg0) : super(arg0);
@override
NodeList<SwitchMember> getList(SwitchStatement node) => node.members;
}
-class ListGetter_NodeReplacerTest_test_tryStatement extends
- NodeReplacerTest_ListGetter<TryStatement, CatchClause> {
+class ListGetter_NodeReplacerTest_test_tryStatement
+ extends NodeReplacerTest_ListGetter<TryStatement, CatchClause> {
ListGetter_NodeReplacerTest_test_tryStatement(int arg0) : super(arg0);
@override
NodeList<CatchClause> getList(TryStatement node) => node.catchClauses;
}
-class ListGetter_NodeReplacerTest_test_typeArgumentList extends
- NodeReplacerTest_ListGetter<TypeArgumentList, TypeName> {
+class ListGetter_NodeReplacerTest_test_typeArgumentList
+ extends NodeReplacerTest_ListGetter<TypeArgumentList, TypeName> {
ListGetter_NodeReplacerTest_test_typeArgumentList(int arg0) : super(arg0);
@override
NodeList<TypeName> getList(TypeArgumentList node) => node.arguments;
}
-class ListGetter_NodeReplacerTest_test_typeParameterList extends
- NodeReplacerTest_ListGetter<TypeParameterList, TypeParameter> {
+class ListGetter_NodeReplacerTest_test_typeParameterList
+ extends NodeReplacerTest_ListGetter<TypeParameterList, TypeParameter> {
ListGetter_NodeReplacerTest_test_typeParameterList(int arg0) : super(arg0);
@override
@@ -3490,8 +3034,8 @@ class ListGetter_NodeReplacerTest_test_typeParameterList extends
node.typeParameters;
}
-class ListGetter_NodeReplacerTest_test_variableDeclarationList extends
- NodeReplacerTest_ListGetter<VariableDeclarationList, VariableDeclaration> {
+class ListGetter_NodeReplacerTest_test_variableDeclarationList
+ extends NodeReplacerTest_ListGetter<VariableDeclarationList, VariableDeclaration> {
ListGetter_NodeReplacerTest_test_variableDeclarationList(int arg0)
: super(arg0);
@@ -3500,48 +3044,48 @@ class ListGetter_NodeReplacerTest_test_variableDeclarationList extends
node.variables;
}
-class ListGetter_NodeReplacerTest_test_withClause extends
- NodeReplacerTest_ListGetter<WithClause, TypeName> {
+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> {
+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> {
+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> {
+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> {
+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> {
+class ListGetter_NodeReplacerTest_testSwitchMember_2
+ extends NodeReplacerTest_ListGetter<SwitchMember, Statement> {
ListGetter_NodeReplacerTest_testSwitchMember_2(int arg0) : super(arg0);
@override
@@ -3707,19 +3251,16 @@ class NodeReplacerTest extends EngineTestCase {
static const List<Token> EMPTY_TOKEN_LIST = const <Token>[];
void test_adjacentStrings() {
- AdjacentStrings node =
- AstFactory.adjacentStrings([AstFactory.string2("a"), AstFactory.string2("b")]);
+ AdjacentStrings node = AstFactory
+ .adjacentStrings([AstFactory.string2("a"), AstFactory.string2("b")]);
_assertReplace(
- node,
- new ListGetter_NodeReplacerTest_test_adjacentStrings_2(0));
+ node, new ListGetter_NodeReplacerTest_test_adjacentStrings_2(0));
_assertReplace(
- node,
- new ListGetter_NodeReplacerTest_test_adjacentStrings(1));
+ node, new ListGetter_NodeReplacerTest_test_adjacentStrings(1));
}
void test_annotation() {
- Annotation node = AstFactory.annotation2(
- AstFactory.identifier3("C"),
+ Annotation node = AstFactory.annotation2(AstFactory.identifier3("C"),
AstFactory.identifier3("c"),
AstFactory.argumentList([AstFactory.integer(0)]));
_assertReplace(node, new Getter_NodeReplacerTest_test_annotation());
@@ -3733,9 +3274,9 @@ class NodeReplacerTest extends EngineTestCase {
}
void test_asExpression() {
- AsExpression node = AstFactory.asExpression(
- AstFactory.integer(0),
- AstFactory.typeName3(AstFactory.identifier3("a"), [AstFactory.typeName4("C")]));
+ AsExpression node = AstFactory.asExpression(AstFactory.integer(0),
+ AstFactory.typeName3(
+ AstFactory.identifier3("a"), [AstFactory.typeName4("C")]));
_assertReplace(node, new Getter_NodeReplacerTest_test_asExpression_2());
_assertReplace(node, new Getter_NodeReplacerTest_test_asExpression());
}
@@ -3748,21 +3289,16 @@ class NodeReplacerTest extends EngineTestCase {
void test_assignmentExpression() {
AssignmentExpression node = AstFactory.assignmentExpression(
- AstFactory.identifier3("l"),
- TokenType.EQ,
- AstFactory.identifier3("r"));
+ AstFactory.identifier3("l"), TokenType.EQ, AstFactory.identifier3("r"));
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_assignmentExpression_2());
+ node, new Getter_NodeReplacerTest_test_assignmentExpression_2());
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_assignmentExpression());
+ node, new Getter_NodeReplacerTest_test_assignmentExpression());
}
void test_binaryExpression() {
BinaryExpression node = AstFactory.binaryExpression(
- AstFactory.identifier3("l"),
- TokenType.PLUS,
+ AstFactory.identifier3("l"), TokenType.PLUS,
AstFactory.identifier3("r"));
_assertReplace(node, new Getter_NodeReplacerTest_test_binaryExpression());
_assertReplace(node, new Getter_NodeReplacerTest_test_binaryExpression_2());
@@ -3784,39 +3320,30 @@ class NodeReplacerTest extends EngineTestCase {
}
void test_cascadeExpression() {
- CascadeExpression node = AstFactory.cascadeExpression(
- AstFactory.integer(0),
+ CascadeExpression node = AstFactory.cascadeExpression(AstFactory.integer(0),
[AstFactory.propertyAccess(null, AstFactory.identifier3("b"))]);
_assertReplace(node, new Getter_NodeReplacerTest_test_cascadeExpression());
_assertReplace(
- node,
- new ListGetter_NodeReplacerTest_test_cascadeExpression(0));
+ node, new ListGetter_NodeReplacerTest_test_cascadeExpression(0));
}
void test_catchClause() {
CatchClause node = AstFactory.catchClause5(
- AstFactory.typeName4("E"),
- "e",
- "s",
- [AstFactory.emptyStatement()]);
+ AstFactory.typeName4("E"), "e", "s", [AstFactory.emptyStatement()]);
_assertReplace(node, new Getter_NodeReplacerTest_test_catchClause_3());
_assertReplace(node, new Getter_NodeReplacerTest_test_catchClause_2());
_assertReplace(node, new Getter_NodeReplacerTest_test_catchClause());
}
void test_classDeclaration() {
- ClassDeclaration node = AstFactory.classDeclaration(
- null,
- "A",
+ ClassDeclaration node = AstFactory.classDeclaration(null, "A",
AstFactory.typeParameterList(["E"]),
AstFactory.extendsClause(AstFactory.typeName4("B")),
AstFactory.withClause([AstFactory.typeName4("C")]),
- AstFactory.implementsClause([AstFactory.typeName4("D")]),
- [
- AstFactory.fieldDeclaration2(
- false,
- null,
- [AstFactory.variableDeclaration("f")])]);
+ AstFactory.implementsClause([AstFactory.typeName4("D")]), [
+ AstFactory.fieldDeclaration2(
+ false, null, [AstFactory.variableDeclaration("f")])
+ ]);
node.documentationComment =
Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
@@ -3828,17 +3355,13 @@ class NodeReplacerTest extends EngineTestCase {
_assertReplace(node, new Getter_NodeReplacerTest_test_classDeclaration());
_assertReplace(node, new Getter_NodeReplacerTest_test_classDeclaration_3());
_assertReplace(
- node,
- new ListGetter_NodeReplacerTest_test_classDeclaration(0));
+ node, new ListGetter_NodeReplacerTest_test_classDeclaration(0));
_testAnnotatedNode(node);
}
void test_classTypeAlias() {
- ClassTypeAlias node = AstFactory.classTypeAlias(
- "A",
- AstFactory.typeParameterList(["E"]),
- null,
- AstFactory.typeName4("B"),
+ ClassTypeAlias node = AstFactory.classTypeAlias("A",
+ AstFactory.typeParameterList(["E"]), null, AstFactory.typeName4("B"),
AstFactory.withClause([AstFactory.typeName4("C")]),
AstFactory.implementsClause([AstFactory.typeName4("D")]));
node.documentationComment =
@@ -3854,8 +3377,8 @@ class NodeReplacerTest extends EngineTestCase {
void test_comment() {
Comment node = Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
- node.references.add(
- new CommentReference(null, AstFactory.identifier3("x")));
+ node.references
+ .add(new CommentReference(null, AstFactory.identifier3("x")));
_assertReplace(node, new ListGetter_NodeReplacerTest_test_comment(0));
}
@@ -3866,82 +3389,63 @@ class NodeReplacerTest extends EngineTestCase {
}
void test_compilationUnit() {
- CompilationUnit node = AstFactory.compilationUnit8(
- "",
- [AstFactory.libraryDirective2("lib")],
- [
- AstFactory.topLevelVariableDeclaration2(
- null,
- [AstFactory.variableDeclaration("X")])]);
+ CompilationUnit node = AstFactory.compilationUnit8("", [
+ AstFactory.libraryDirective2("lib")
+ ], [
+ AstFactory.topLevelVariableDeclaration2(
+ null, [AstFactory.variableDeclaration("X")])
+ ]);
_assertReplace(node, new Getter_NodeReplacerTest_test_compilationUnit());
_assertReplace(
- node,
- new ListGetter_NodeReplacerTest_test_compilationUnit(0));
+ node, new ListGetter_NodeReplacerTest_test_compilationUnit(0));
_assertReplace(
- node,
- new ListGetter_NodeReplacerTest_test_compilationUnit_2(0));
+ node, new ListGetter_NodeReplacerTest_test_compilationUnit_2(0));
}
void test_conditionalExpression() {
ConditionalExpression node = AstFactory.conditionalExpression(
- AstFactory.booleanLiteral(true),
- AstFactory.integer(0),
+ AstFactory.booleanLiteral(true), AstFactory.integer(0),
AstFactory.integer(1));
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_conditionalExpression_3());
+ node, new Getter_NodeReplacerTest_test_conditionalExpression_3());
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_conditionalExpression_2());
+ node, new Getter_NodeReplacerTest_test_conditionalExpression_2());
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_conditionalExpression());
+ node, new Getter_NodeReplacerTest_test_conditionalExpression());
}
void test_constructorDeclaration() {
- ConstructorDeclaration node = AstFactory.constructorDeclaration2(
- null,
- null,
- AstFactory.identifier3("C"),
- "d",
- AstFactory.formalParameterList(),
- [AstFactory.constructorFieldInitializer(false, "x", AstFactory.integer(0))],
- AstFactory.emptyFunctionBody());
+ 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.add(AstFactory.annotation(AstFactory.identifier3("a")));
node.redirectedConstructor =
AstFactory.constructorName(AstFactory.typeName4("B"), "a");
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_constructorDeclaration_3());
+ node, new Getter_NodeReplacerTest_test_constructorDeclaration_3());
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_constructorDeclaration_2());
+ node, new Getter_NodeReplacerTest_test_constructorDeclaration_2());
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_constructorDeclaration_4());
+ node, new Getter_NodeReplacerTest_test_constructorDeclaration_4());
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_constructorDeclaration());
+ node, new Getter_NodeReplacerTest_test_constructorDeclaration());
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_constructorDeclaration_5());
+ node, new Getter_NodeReplacerTest_test_constructorDeclaration_5());
_assertReplace(
- node,
- new ListGetter_NodeReplacerTest_test_constructorDeclaration(0));
+ node, new ListGetter_NodeReplacerTest_test_constructorDeclaration(0));
_testAnnotatedNode(node);
}
void test_constructorFieldInitializer() {
- ConstructorFieldInitializer node =
- AstFactory.constructorFieldInitializer(false, "f", AstFactory.integer(0));
+ ConstructorFieldInitializer node = AstFactory.constructorFieldInitializer(
+ false, "f", AstFactory.integer(0));
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_constructorFieldInitializer());
+ node, new Getter_NodeReplacerTest_test_constructorFieldInitializer());
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_constructorFieldInitializer_2());
+ node, new Getter_NodeReplacerTest_test_constructorFieldInitializer_2());
}
void test_constructorName() {
@@ -3964,38 +3468,33 @@ class NodeReplacerTest extends EngineTestCase {
node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
_assertReplace(node, new Getter_NodeReplacerTest_test_declaredIdentifier());
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_declaredIdentifier_2());
+ node, new Getter_NodeReplacerTest_test_declaredIdentifier_2());
_testAnnotatedNode(node);
}
void test_defaultFormalParameter() {
DefaultFormalParameter node = AstFactory.positionalFormalParameter(
- AstFactory.simpleFormalParameter3("p"),
- AstFactory.integer(0));
+ AstFactory.simpleFormalParameter3("p"), AstFactory.integer(0));
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_defaultFormalParameter());
+ node, new Getter_NodeReplacerTest_test_defaultFormalParameter());
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_defaultFormalParameter_2());
+ node, new Getter_NodeReplacerTest_test_defaultFormalParameter_2());
}
void test_doStatement() {
- DoStatement node =
- AstFactory.doStatement(AstFactory.block(), AstFactory.booleanLiteral(true));
+ DoStatement node = AstFactory.doStatement(
+ AstFactory.block(), AstFactory.booleanLiteral(true));
_assertReplace(node, new Getter_NodeReplacerTest_test_doStatement_2());
_assertReplace(node, new Getter_NodeReplacerTest_test_doStatement());
}
void test_enumConstantDeclaration() {
EnumConstantDeclaration node = new EnumConstantDeclaration(
- Comment.createEndOfLineComment(EMPTY_TOKEN_LIST),
- [AstFactory.annotation(AstFactory.identifier3("a"))],
- AstFactory.identifier3("C"));
+ Comment.createEndOfLineComment(EMPTY_TOKEN_LIST), [
+ AstFactory.annotation(AstFactory.identifier3("a"))
+ ], AstFactory.identifier3("C"));
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_enumConstantDeclaration());
+ node, new Getter_NodeReplacerTest_test_enumConstantDeclaration());
_testAnnotatedNode(node);
}
@@ -4021,16 +3520,14 @@ class NodeReplacerTest extends EngineTestCase {
ExpressionFunctionBody node =
AstFactory.expressionFunctionBody(AstFactory.integer(0));
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_expressionFunctionBody());
+ node, new Getter_NodeReplacerTest_test_expressionFunctionBody());
}
void test_expressionStatement() {
ExpressionStatement node =
AstFactory.expressionStatement(AstFactory.integer(0));
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_expressionStatement());
+ node, new Getter_NodeReplacerTest_test_expressionStatement());
}
void test_extendsClause() {
@@ -4039,11 +3536,8 @@ class NodeReplacerTest extends EngineTestCase {
}
void test_fieldDeclaration() {
- FieldDeclaration node = AstFactory.fieldDeclaration(
- false,
- null,
- AstFactory.typeName4("C"),
- [AstFactory.variableDeclaration("c")]);
+ FieldDeclaration node = AstFactory.fieldDeclaration(false, null,
+ AstFactory.typeName4("C"), [AstFactory.variableDeclaration("c")]);
node.documentationComment =
Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
@@ -4053,138 +3547,105 @@ class NodeReplacerTest extends EngineTestCase {
void test_fieldFormalParameter() {
FieldFormalParameter node = AstFactory.fieldFormalParameter(
- null,
- AstFactory.typeName4("C"),
- "f",
- AstFactory.formalParameterList());
+ null, AstFactory.typeName4("C"), "f", AstFactory.formalParameterList());
node.documentationComment =
Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_fieldFormalParameter_2());
+ node, new Getter_NodeReplacerTest_test_fieldFormalParameter_2());
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_fieldFormalParameter());
+ node, new Getter_NodeReplacerTest_test_fieldFormalParameter());
_testNormalFormalParameter(node);
}
void test_forEachStatement_withIdentifier() {
ForEachStatement node = AstFactory.forEachStatement2(
- AstFactory.identifier3("i"),
- AstFactory.identifier3("l"),
+ AstFactory.identifier3("i"), AstFactory.identifier3("l"),
AstFactory.block());
- _assertReplace(
- node,
+ _assertReplace(node,
new Getter_NodeReplacerTest_test_forEachStatement_withIdentifier_2());
- _assertReplace(
- node,
+ _assertReplace(node,
new Getter_NodeReplacerTest_test_forEachStatement_withIdentifier_3());
- _assertReplace(
- node,
+ _assertReplace(node,
new Getter_NodeReplacerTest_test_forEachStatement_withIdentifier());
}
void test_forEachStatement_withLoopVariable() {
ForEachStatement node = AstFactory.forEachStatement(
- AstFactory.declaredIdentifier3("e"),
- AstFactory.identifier3("l"),
+ AstFactory.declaredIdentifier3("e"), AstFactory.identifier3("l"),
AstFactory.block());
- _assertReplace(
- node,
+ _assertReplace(node,
new Getter_NodeReplacerTest_test_forEachStatement_withLoopVariable_2());
- _assertReplace(
- node,
+ _assertReplace(node,
new Getter_NodeReplacerTest_test_forEachStatement_withLoopVariable());
- _assertReplace(
- node,
+ _assertReplace(node,
new Getter_NodeReplacerTest_test_forEachStatement_withLoopVariable_3());
}
void test_formalParameterList() {
- FormalParameterList node =
- AstFactory.formalParameterList([AstFactory.simpleFormalParameter3("p")]);
+ FormalParameterList node = AstFactory
+ .formalParameterList([AstFactory.simpleFormalParameter3("p")]);
_assertReplace(
- node,
- new ListGetter_NodeReplacerTest_test_formalParameterList(0));
+ 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,
+ 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(
- node,
+ _assertReplace(node,
new Getter_NodeReplacerTest_test_forStatement_withInitialization_2());
- _assertReplace(
- node,
+ _assertReplace(node,
new Getter_NodeReplacerTest_test_forStatement_withInitialization());
- _assertReplace(
- node,
- new ListGetter_NodeReplacerTest_test_forStatement_withInitialization(0));
+ _assertReplace(node,
+ new ListGetter_NodeReplacerTest_test_forStatement_withInitialization(
+ 0));
}
void test_forStatement_withVariables() {
- ForStatement node = AstFactory.forStatement2(
- AstFactory.variableDeclarationList2(
- null,
- [AstFactory.variableDeclaration("i")]),
- AstFactory.booleanLiteral(true),
- [AstFactory.integer(0)],
- AstFactory.block());
+ ForStatement node = AstFactory.forStatement2(AstFactory
+ .variableDeclarationList2(null, [
+ AstFactory.variableDeclaration("i")
+ ]), AstFactory.booleanLiteral(true), [
+ AstFactory.integer(0)
+ ], AstFactory.block());
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_forStatement_withVariables_2());
+ node, new Getter_NodeReplacerTest_test_forStatement_withVariables_2());
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_forStatement_withVariables_3());
+ node, new Getter_NodeReplacerTest_test_forStatement_withVariables_3());
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_forStatement_withVariables());
- _assertReplace(
- node,
+ node, new Getter_NodeReplacerTest_test_forStatement_withVariables());
+ _assertReplace(node,
new ListGetter_NodeReplacerTest_test_forStatement_withVariables(0));
}
void test_functionDeclaration() {
FunctionDeclaration node = AstFactory.functionDeclaration(
- AstFactory.typeName4("R"),
- null,
- "f",
- AstFactory.functionExpression2(
+ AstFactory.typeName4("R"), null, "f", AstFactory.functionExpression2(
AstFactory.formalParameterList(),
AstFactory.blockFunctionBody(AstFactory.block())));
node.documentationComment =
Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_functionDeclaration());
+ node, new Getter_NodeReplacerTest_test_functionDeclaration());
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_functionDeclaration_3());
+ node, new Getter_NodeReplacerTest_test_functionDeclaration_3());
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_functionDeclaration_2());
+ node, new Getter_NodeReplacerTest_test_functionDeclaration_2());
_testAnnotatedNode(node);
}
void test_functionDeclarationStatement() {
FunctionDeclarationStatement node = AstFactory.functionDeclarationStatement(
- AstFactory.typeName4("R"),
- null,
- "f",
- AstFactory.functionExpression2(
+ AstFactory.typeName4("R"), null, "f", AstFactory.functionExpression2(
AstFactory.formalParameterList(),
AstFactory.blockFunctionBody(AstFactory.block())));
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_functionDeclarationStatement());
+ node, new Getter_NodeReplacerTest_test_functionDeclarationStatement());
}
void test_functionExpression() {
@@ -4193,57 +3654,46 @@ class NodeReplacerTest extends EngineTestCase {
AstFactory.blockFunctionBody(AstFactory.block()));
_assertReplace(node, new Getter_NodeReplacerTest_test_functionExpression());
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_functionExpression_2());
+ node, new Getter_NodeReplacerTest_test_functionExpression_2());
}
void test_functionExpressionInvocation() {
FunctionExpressionInvocation node = AstFactory.functionExpressionInvocation(
- AstFactory.identifier3("f"),
- [AstFactory.integer(0)]);
- _assertReplace(
- node,
- new Getter_NodeReplacerTest_test_functionExpressionInvocation());
+ AstFactory.identifier3("f"), [AstFactory.integer(0)]);
_assertReplace(
- node,
+ node, new Getter_NodeReplacerTest_test_functionExpressionInvocation());
+ _assertReplace(node,
new Getter_NodeReplacerTest_test_functionExpressionInvocation_2());
}
void test_functionTypeAlias() {
- FunctionTypeAlias node = AstFactory.typeAlias(
- AstFactory.typeName4("R"),
- "F",
- AstFactory.typeParameterList(["E"]),
+ FunctionTypeAlias node = AstFactory.typeAlias(AstFactory.typeName4("R"),
+ "F", AstFactory.typeParameterList(["E"]),
AstFactory.formalParameterList());
node.documentationComment =
Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_functionTypeAlias_3());
+ node, new Getter_NodeReplacerTest_test_functionTypeAlias_3());
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_functionTypeAlias_4());
+ node, new Getter_NodeReplacerTest_test_functionTypeAlias_4());
_assertReplace(node, new Getter_NodeReplacerTest_test_functionTypeAlias());
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_functionTypeAlias_2());
+ node, new Getter_NodeReplacerTest_test_functionTypeAlias_2());
_testAnnotatedNode(node);
}
void test_functionTypedFormalParameter() {
FunctionTypedFormalParameter node = AstFactory.functionTypedFormalParameter(
- AstFactory.typeName4("R"),
- "f",
- [AstFactory.simpleFormalParameter3("p")]);
+ AstFactory.typeName4("R"), "f", [
+ AstFactory.simpleFormalParameter3("p")
+ ]);
node.documentationComment =
Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_functionTypedFormalParameter());
- _assertReplace(
- node,
+ node, new Getter_NodeReplacerTest_test_functionTypedFormalParameter());
+ _assertReplace(node,
new Getter_NodeReplacerTest_test_functionTypedFormalParameter_2());
_testNormalFormalParameter(node);
}
@@ -4251,15 +3701,12 @@ class NodeReplacerTest extends EngineTestCase {
void test_hideCombinator() {
HideCombinator node = AstFactory.hideCombinator2(["A", "B"]);
_assertReplace(
- node,
- new ListGetter_NodeReplacerTest_test_hideCombinator(0));
+ node, new ListGetter_NodeReplacerTest_test_hideCombinator(0));
}
void test_ifStatement() {
- IfStatement node = AstFactory.ifStatement2(
- AstFactory.booleanLiteral(true),
- AstFactory.block(),
- AstFactory.block());
+ IfStatement node = AstFactory.ifStatement2(AstFactory.booleanLiteral(true),
+ AstFactory.block(), AstFactory.block());
_assertReplace(node, new Getter_NodeReplacerTest_test_ifStatement());
_assertReplace(node, new Getter_NodeReplacerTest_test_ifStatement_3());
_assertReplace(node, new Getter_NodeReplacerTest_test_ifStatement_2());
@@ -4269,15 +3716,14 @@ class NodeReplacerTest extends EngineTestCase {
ImplementsClause node = AstFactory.implementsClause(
[AstFactory.typeName4("I"), AstFactory.typeName4("J")]);
_assertReplace(
- node,
- new ListGetter_NodeReplacerTest_test_implementsClause(0));
+ node, new ListGetter_NodeReplacerTest_test_implementsClause(0));
}
void test_importDirective() {
- ImportDirective node = AstFactory.importDirective3(
- "",
- "p",
- [AstFactory.showCombinator2(["A"]), AstFactory.hideCombinator2(["B"])]);
+ ImportDirective node = AstFactory.importDirective3("", "p", [
+ AstFactory.showCombinator2(["A"]),
+ AstFactory.hideCombinator2(["B"])
+ ]);
node.documentationComment =
Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
@@ -4287,38 +3733,29 @@ class NodeReplacerTest extends EngineTestCase {
void test_indexExpression() {
IndexExpression node = AstFactory.indexExpression(
- AstFactory.identifier3("a"),
- AstFactory.identifier3("i"));
+ AstFactory.identifier3("a"), AstFactory.identifier3("i"));
_assertReplace(node, new Getter_NodeReplacerTest_test_indexExpression());
_assertReplace(node, new Getter_NodeReplacerTest_test_indexExpression_2());
}
void test_instanceCreationExpression() {
InstanceCreationExpression node = AstFactory.instanceCreationExpression3(
- null,
- AstFactory.typeName4("C"),
- "c",
- [AstFactory.integer(2)]);
+ null, AstFactory.typeName4("C"), "c", [AstFactory.integer(2)]);
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_instanceCreationExpression_2());
+ node, new Getter_NodeReplacerTest_test_instanceCreationExpression_2());
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_instanceCreationExpression());
+ node, new Getter_NodeReplacerTest_test_instanceCreationExpression());
}
void test_interpolationExpression() {
InterpolationExpression node = AstFactory.interpolationExpression2("x");
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_interpolationExpression());
+ node, new Getter_NodeReplacerTest_test_interpolationExpression());
}
void test_isExpression() {
IsExpression node = AstFactory.isExpression(
- AstFactory.identifier3("v"),
- false,
- AstFactory.typeName4("T"));
+ AstFactory.identifier3("v"), false, AstFactory.typeName4("T"));
_assertReplace(node, new Getter_NodeReplacerTest_test_isExpression());
_assertReplace(node, new Getter_NodeReplacerTest_test_isExpression_2());
}
@@ -4329,11 +3766,10 @@ class NodeReplacerTest extends EngineTestCase {
}
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));
+ node, new ListGetter_NodeReplacerTest_test_labeledStatement(0));
_assertReplace(node, new Getter_NodeReplacerTest_test_labeledStatement());
}
@@ -4349,24 +3785,23 @@ class NodeReplacerTest extends EngineTestCase {
void test_libraryIdentifier() {
LibraryIdentifier node = AstFactory.libraryIdentifier2(["lib"]);
_assertReplace(
- node,
- new ListGetter_NodeReplacerTest_test_libraryIdentifier(0));
+ node, new ListGetter_NodeReplacerTest_test_libraryIdentifier(0));
}
void test_listLiteral() {
- ListLiteral node = AstFactory.listLiteral2(
- null,
- AstFactory.typeArgumentList([AstFactory.typeName4("E")]),
- [AstFactory.identifier3("e")]);
+ ListLiteral node = AstFactory.listLiteral2(null,
+ AstFactory.typeArgumentList([AstFactory.typeName4("E")]), [
+ AstFactory.identifier3("e")
+ ]);
_assertReplace(node, new ListGetter_NodeReplacerTest_test_listLiteral(0));
_testTypedLiteral(node);
}
void test_mapLiteral() {
- MapLiteral node = AstFactory.mapLiteral(
- null,
- AstFactory.typeArgumentList([AstFactory.typeName4("E")]),
- [AstFactory.mapLiteralEntry("k", AstFactory.identifier3("v"))]);
+ MapLiteral node = AstFactory.mapLiteral(null,
+ AstFactory.typeArgumentList([AstFactory.typeName4("E")]), [
+ AstFactory.mapLiteralEntry("k", AstFactory.identifier3("v"))
+ ]);
_assertReplace(node, new ListGetter_NodeReplacerTest_test_mapLiteral(0));
_testTypedLiteral(node);
}
@@ -4379,12 +3814,8 @@ class NodeReplacerTest extends EngineTestCase {
}
void test_methodDeclaration() {
- MethodDeclaration node = AstFactory.methodDeclaration2(
- null,
- AstFactory.typeName4("A"),
- null,
- null,
- AstFactory.identifier3("m"),
+ MethodDeclaration node = AstFactory.methodDeclaration2(null,
+ AstFactory.typeName4("A"), null, null, AstFactory.identifier3("m"),
AstFactory.formalParameterList(),
AstFactory.blockFunctionBody(AstFactory.block()));
node.documentationComment =
@@ -4392,22 +3823,17 @@ class NodeReplacerTest extends EngineTestCase {
node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
_assertReplace(node, new Getter_NodeReplacerTest_test_methodDeclaration());
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_methodDeclaration_3());
+ node, new Getter_NodeReplacerTest_test_methodDeclaration_3());
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_methodDeclaration_4());
+ node, new Getter_NodeReplacerTest_test_methodDeclaration_4());
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_methodDeclaration_2());
+ node, new Getter_NodeReplacerTest_test_methodDeclaration_2());
_testAnnotatedNode(node);
}
void test_methodInvocation() {
MethodInvocation node = AstFactory.methodInvocation(
- AstFactory.identifier3("t"),
- "m",
- [AstFactory.integer(0)]);
+ AstFactory.identifier3("t"), "m", [AstFactory.integer(0)]);
_assertReplace(node, new Getter_NodeReplacerTest_test_methodInvocation_2());
_assertReplace(node, new Getter_NodeReplacerTest_test_methodInvocation_3());
_assertReplace(node, new Getter_NodeReplacerTest_test_methodInvocation());
@@ -4434,8 +3860,7 @@ class NodeReplacerTest extends EngineTestCase {
ParenthesizedExpression node =
AstFactory.parenthesizedExpression(AstFactory.integer(0));
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_parenthesizedExpression());
+ node, new Getter_NodeReplacerTest_test_parenthesizedExpression());
}
void test_partDirective() {
@@ -4458,22 +3883,20 @@ class NodeReplacerTest extends EngineTestCase {
void test_postfixExpression() {
PostfixExpression node = AstFactory.postfixExpression(
- AstFactory.identifier3("x"),
- TokenType.MINUS_MINUS);
+ AstFactory.identifier3("x"), TokenType.MINUS_MINUS);
_assertReplace(node, new Getter_NodeReplacerTest_test_postfixExpression());
}
void test_prefixedIdentifier() {
PrefixedIdentifier node = AstFactory.identifier5("a", "b");
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_prefixedIdentifier_2());
+ 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"));
+ PrefixExpression node = AstFactory.prefixExpression(
+ TokenType.PLUS_PLUS, AstFactory.identifier3("y"));
_assertReplace(node, new Getter_NodeReplacerTest_test_prefixExpression());
}
@@ -4485,13 +3908,11 @@ class NodeReplacerTest extends EngineTestCase {
}
void test_redirectingConstructorInvocation() {
- RedirectingConstructorInvocation node =
- AstFactory.redirectingConstructorInvocation2("c", [AstFactory.integer(0)]);
- _assertReplace(
- node,
+ RedirectingConstructorInvocation node = AstFactory
+ .redirectingConstructorInvocation2("c", [AstFactory.integer(0)]);
+ _assertReplace(node,
new Getter_NodeReplacerTest_test_redirectingConstructorInvocation());
- _assertReplace(
- node,
+ _assertReplace(node,
new Getter_NodeReplacerTest_test_redirectingConstructorInvocation_2());
}
@@ -4503,8 +3924,7 @@ class NodeReplacerTest extends EngineTestCase {
void test_showCombinator() {
ShowCombinator node = AstFactory.showCombinator2(["X", "Y"]);
_assertReplace(
- node,
- new ListGetter_NodeReplacerTest_test_showCombinator(0));
+ node, new ListGetter_NodeReplacerTest_test_showCombinator(0));
}
void test_simpleFormalParameter() {
@@ -4514,8 +3934,7 @@ class NodeReplacerTest extends EngineTestCase {
Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))];
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_simpleFormalParameter());
+ node, new Getter_NodeReplacerTest_test_simpleFormalParameter());
_testNormalFormalParameter(node);
}
@@ -4523,49 +3942,42 @@ class NodeReplacerTest extends EngineTestCase {
StringInterpolation node =
AstFactory.string([AstFactory.interpolationExpression2("a")]);
_assertReplace(
- node,
- new ListGetter_NodeReplacerTest_test_stringInterpolation(0));
+ node, new ListGetter_NodeReplacerTest_test_stringInterpolation(0));
}
void test_superConstructorInvocation() {
SuperConstructorInvocation node =
AstFactory.superConstructorInvocation2("s", [AstFactory.integer(1)]);
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_superConstructorInvocation());
+ node, new Getter_NodeReplacerTest_test_superConstructorInvocation());
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_superConstructorInvocation_2());
+ node, new Getter_NodeReplacerTest_test_superConstructorInvocation_2());
}
void test_switchCase() {
SwitchCase node = AstFactory.switchCase2(
- [AstFactory.label2("l")],
- AstFactory.integer(0),
- [AstFactory.block()]);
+ [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.identifier3("x"), [
+ AstFactory.switchCase2([AstFactory.label2("l")], AstFactory.integer(0), [
+ AstFactory.block()
+ ]),
+ AstFactory.switchDefault([AstFactory.label2("l")], [AstFactory.block()])
+ ]);
_assertReplace(node, new Getter_NodeReplacerTest_test_switchStatement());
_assertReplace(
- node,
- new ListGetter_NodeReplacerTest_test_switchStatement(0));
+ node, new ListGetter_NodeReplacerTest_test_switchStatement(0));
}
void test_throwExpression() {
@@ -4576,23 +3988,19 @@ class NodeReplacerTest extends EngineTestCase {
void test_topLevelVariableDeclaration() {
TopLevelVariableDeclaration node = AstFactory.topLevelVariableDeclaration(
- null,
- AstFactory.typeName4("T"),
- [AstFactory.variableDeclaration("t")]);
+ null, AstFactory.typeName4("T"), [AstFactory.variableDeclaration("t")]);
node.documentationComment =
Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_topLevelVariableDeclaration());
+ node, new Getter_NodeReplacerTest_test_topLevelVariableDeclaration());
_testAnnotatedNode(node);
}
void test_tryStatement() {
- TryStatement node = AstFactory.tryStatement3(
- AstFactory.block(),
- [AstFactory.catchClause("e", [AstFactory.block()])],
- AstFactory.block());
+ TryStatement node = AstFactory.tryStatement3(AstFactory.block(), [
+ AstFactory.catchClause("e", [AstFactory.block()])
+ ], AstFactory.block());
_assertReplace(node, new Getter_NodeReplacerTest_test_tryStatement_2());
_assertReplace(node, new Getter_NodeReplacerTest_test_tryStatement());
_assertReplace(node, new ListGetter_NodeReplacerTest_test_tryStatement(0));
@@ -4602,14 +4010,12 @@ class NodeReplacerTest extends EngineTestCase {
TypeArgumentList node =
AstFactory.typeArgumentList([AstFactory.typeName4("A")]);
_assertReplace(
- node,
- new ListGetter_NodeReplacerTest_test_typeArgumentList(0));
+ node, new ListGetter_NodeReplacerTest_test_typeArgumentList(0));
}
void test_typeName() {
TypeName node = AstFactory.typeName4(
- "T",
- [AstFactory.typeName4("E"), AstFactory.typeName4("F")]);
+ "T", [AstFactory.typeName4("E"), AstFactory.typeName4("F")]);
_assertReplace(node, new Getter_NodeReplacerTest_test_typeName_2());
_assertReplace(node, new Getter_NodeReplacerTest_test_typeName());
}
@@ -4624,8 +4030,7 @@ class NodeReplacerTest extends EngineTestCase {
void test_typeParameterList() {
TypeParameterList node = AstFactory.typeParameterList(["A", "B"]);
_assertReplace(
- node,
- new ListGetter_NodeReplacerTest_test_typeParameterList(0));
+ node, new ListGetter_NodeReplacerTest_test_typeParameterList(0));
}
void test_variableDeclaration() {
@@ -4635,40 +4040,31 @@ class NodeReplacerTest extends EngineTestCase {
Comment.createEndOfLineComment(EMPTY_TOKEN_LIST);
node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a")));
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_variableDeclaration());
+ node, new Getter_NodeReplacerTest_test_variableDeclaration());
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_variableDeclaration_2());
+ node, new Getter_NodeReplacerTest_test_variableDeclaration_2());
_testAnnotatedNode(node);
}
void test_variableDeclarationList() {
VariableDeclarationList node = AstFactory.variableDeclarationList(
- null,
- AstFactory.typeName4("T"),
- [AstFactory.variableDeclaration("a")]);
+ null, AstFactory.typeName4("T"), [AstFactory.variableDeclaration("a")]);
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_variableDeclarationList());
+ node, new Getter_NodeReplacerTest_test_variableDeclarationList());
_assertReplace(
- node,
- new ListGetter_NodeReplacerTest_test_variableDeclarationList(0));
+ node, new ListGetter_NodeReplacerTest_test_variableDeclarationList(0));
}
void test_variableDeclarationStatement() {
VariableDeclarationStatement node = AstFactory.variableDeclarationStatement(
- null,
- AstFactory.typeName4("T"),
- [AstFactory.variableDeclaration("a")]);
+ null, AstFactory.typeName4("T"), [AstFactory.variableDeclaration("a")]);
_assertReplace(
- node,
- new Getter_NodeReplacerTest_test_variableDeclarationStatement());
+ 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());
}
@@ -4695,21 +4091,17 @@ class NodeReplacerTest extends EngineTestCase {
void _testNamespaceDirective(NamespaceDirective node) {
_assertReplace(
- node,
- new ListGetter_NodeReplacerTest_testNamespaceDirective(0));
+ node, new ListGetter_NodeReplacerTest_testNamespaceDirective(0));
_testUriBasedDirective(node);
}
void _testNormalFormalParameter(NormalFormalParameter node) {
_assertReplace(
- node,
- new Getter_NodeReplacerTest_testNormalFormalParameter_2());
+ node, new Getter_NodeReplacerTest_testNormalFormalParameter_2());
_assertReplace(
- node,
- new Getter_NodeReplacerTest_testNormalFormalParameter());
+ node, new Getter_NodeReplacerTest_testNormalFormalParameter());
_assertReplace(
- node,
- new ListGetter_NodeReplacerTest_testNormalFormalParameter(0));
+ node, new ListGetter_NodeReplacerTest_testNormalFormalParameter(0));
}
void _testSwitchMember(SwitchMember node) {
@@ -4907,18 +4299,14 @@ class SourceRangeTest {
}
void test_getUnion() {
- expect(
- new SourceRange(10, 10).getUnion(new SourceRange(15, 10)),
+ expect(new SourceRange(10, 10).getUnion(new SourceRange(15, 10)),
new SourceRange(10, 15));
- expect(
- new SourceRange(15, 10).getUnion(new SourceRange(10, 10)),
+ 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)),
+ expect(new SourceRange(10, 10).getUnion(new SourceRange(15, 2)),
new SourceRange(10, 10));
- expect(
- new SourceRange(15, 2).getUnion(new SourceRange(10, 10)),
+ expect(new SourceRange(15, 2).getUnion(new SourceRange(10, 10)),
new SourceRange(10, 10));
}
@@ -5007,18 +4395,15 @@ class StringUtilitiesTest {
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);
+ StringUtilities.indexOf4("abcdefghi", 0, 0x64, 0x65, 0x61, 0x64), -1);
expect(
- StringUtilities.indexOf4("abcdefghi", 1, 0x61, 0x62, 0x63, 0x64),
- -1);
+ 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);
+ StringUtilities.indexOf5("abcde", 0, 0x61, 0x62, 0x63, 0x64, 0x65), 0);
expect(
StringUtilities.indexOf5("abcdefghi", 0, 0x61, 0x62, 0x63, 0x64, 0x65),
0);
@@ -5067,8 +4452,8 @@ class StringUtilitiesTest {
}
void test_printListOfQuotedNames_five() {
- expect(
- StringUtilities.printListOfQuotedNames(<String>["a", "b", "c", "d", "e"]),
+ expect(StringUtilities
+ .printListOfQuotedNames(<String>["a", "b", "c", "d", "e"]),
"'a', 'b', 'c', 'd' and 'e'");
}
@@ -5091,14 +4476,12 @@ class StringUtilitiesTest {
}
void test_printListOfQuotedNames_three() {
- expect(
- StringUtilities.printListOfQuotedNames(<String>["a", "b", "c"]),
+ expect(StringUtilities.printListOfQuotedNames(<String>["a", "b", "c"]),
"'a', 'b' and 'c'");
}
void test_printListOfQuotedNames_two() {
- expect(
- StringUtilities.printListOfQuotedNames(<String>["a", "b"]),
+ expect(StringUtilities.printListOfQuotedNames(<String>["a", "b"]),
"'a' and 'b'");
}
@@ -5114,35 +4497,26 @@ class StringUtilitiesTest {
void test_startsWith3() {
expect(StringUtilities.startsWith3("abc", 0, 0x61, 0x62, 0x63), isTrue);
expect(
- StringUtilities.startsWith3("abcdefghi", 0, 0x61, 0x62, 0x63),
- isTrue);
+ StringUtilities.startsWith3("abcdefghi", 0, 0x61, 0x62, 0x63), isTrue);
expect(
- StringUtilities.startsWith3("abcdefghi", 2, 0x63, 0x64, 0x65),
- isTrue);
+ StringUtilities.startsWith3("abcdefghi", 2, 0x63, 0x64, 0x65), isTrue);
expect(
- StringUtilities.startsWith3("abcdefghi", 6, 0x67, 0x68, 0x69),
- isTrue);
+ StringUtilities.startsWith3("abcdefghi", 6, 0x67, 0x68, 0x69), isTrue);
expect(
- StringUtilities.startsWith3("abcdefghi", 0, 0x64, 0x65, 0x61),
- isFalse);
+ StringUtilities.startsWith3("abcdefghi", 0, 0x64, 0x65, 0x61), isFalse);
// missing
}
void test_startsWith4() {
expect(
- StringUtilities.startsWith4("abcd", 0, 0x61, 0x62, 0x63, 0x64),
+ StringUtilities.startsWith4("abcd", 0, 0x61, 0x62, 0x63, 0x64), isTrue);
+ expect(StringUtilities.startsWith4("abcdefghi", 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),
+ expect(StringUtilities.startsWith4("abcdefghi", 2, 0x63, 0x64, 0x65, 0x66),
isTrue);
- expect(
- StringUtilities.startsWith4("abcdefghi", 5, 0x66, 0x67, 0x68, 0x69),
+ expect(StringUtilities.startsWith4("abcdefghi", 5, 0x66, 0x67, 0x68, 0x69),
isTrue);
- expect(
- StringUtilities.startsWith4("abcdefghi", 0, 0x64, 0x65, 0x61, 0x64),
+ expect(StringUtilities.startsWith4("abcdefghi", 0, 0x64, 0x65, 0x61, 0x64),
isFalse);
// missing
}
@@ -5151,37 +4525,28 @@ class StringUtilitiesTest {
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(
+ "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
}
@@ -5213,7 +4578,6 @@ class StringUtilitiesTest {
}
}
-
@reflectiveTest
class TokenMapTest {
void test_creation() {
« no previous file with comments | « pkg/analyzer/test/generated/test_support.dart ('k') | pkg/analyzer/test/instrumentation/instrumentation_test.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698