| OLD | NEW |
|---|
| (Empty) | |
| 1 // Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file |
| 2 // for details. All rights reserved. Use of this source code is governed by a |
| 3 // BSD-style license that can be found in the LICENSE file. |
| 4 |
| 5 library engine.utilities_test; |
| 6 |
| 7 import 'dart:collection'; |
| 8 |
| 9 import 'package:analyzer/src/generated/ast.dart'; |
| 10 import 'package:analyzer/src/generated/java_core.dart'; |
| 11 import 'package:analyzer/src/generated/java_engine.dart'; |
| 12 import 'package:analyzer/src/generated/scanner.dart'; |
| 13 import 'package:analyzer/src/generated/source.dart'; |
| 14 import 'package:analyzer/src/generated/testing/ast_factory.dart'; |
| 15 import 'package:analyzer/src/generated/testing/token_factory.dart'; |
| 16 import 'package:analyzer/src/generated/utilities_collection.dart'; |
| 17 import 'package:unittest/unittest.dart'; |
| 18 |
| 19 import '../reflective_tests.dart'; |
| 20 import '../utils.dart'; |
| 21 import 'test_support.dart'; |
| 22 |
| 23 main() { |
| 24 initializeTestEnvironment(); |
| 25 runReflectiveTests(AstClonerTest); |
| 26 runReflectiveTests(NodeReplacerTest); |
| 27 runReflectiveTests(LineInfoTest); |
| 28 runReflectiveTests(SourceRangeTest); |
| 29 runReflectiveTests(BooleanArrayTest); |
| 30 runReflectiveTests(DirectedGraphTest); |
| 31 runReflectiveTests(ListUtilitiesTest); |
| 32 runReflectiveTests(MultipleMapIteratorTest); |
| 33 runReflectiveTests(SingleMapIteratorTest); |
| 34 runReflectiveTests(TokenMapTest); |
| 35 runReflectiveTests(StringUtilitiesTest); |
| 36 } |
| 37 |
| 38 class AstCloneComparator extends AstComparator { |
| 39 final bool expectTokensCopied; |
| 40 |
| 41 AstCloneComparator(this.expectTokensCopied); |
| 42 |
| 43 @override |
| 44 bool isEqualNodes(AstNode first, AstNode second) { |
| 45 if (first != null && identical(first, second)) { |
| 46 fail('Failed to copy node: $first (${first.offset})'); |
| 47 return false; |
| 48 } |
| 49 return super.isEqualNodes(first, second); |
| 50 } |
| 51 |
| 52 @override |
| 53 bool isEqualTokens(Token first, Token second) { |
| 54 if (expectTokensCopied && first != null && identical(first, second)) { |
| 55 fail('Failed to copy token: ${first.lexeme} (${first.offset})'); |
| 56 return false; |
| 57 } |
| 58 return super.isEqualTokens(first, second); |
| 59 } |
| 60 } |
| 61 |
| 62 @reflectiveTest |
| 63 class AstClonerTest extends EngineTestCase { |
| 64 void test_visitAdjacentStrings() { |
| 65 _assertClone(AstFactory |
| 66 .adjacentStrings([AstFactory.string2("a"), AstFactory.string2("b")])); |
| 67 } |
| 68 |
| 69 void test_visitAnnotation_constant() { |
| 70 _assertClone(AstFactory.annotation(AstFactory.identifier3("A"))); |
| 71 } |
| 72 |
| 73 void test_visitAnnotation_constructor() { |
| 74 _assertClone(AstFactory.annotation2(AstFactory.identifier3("A"), |
| 75 AstFactory.identifier3("c"), AstFactory.argumentList())); |
| 76 } |
| 77 |
| 78 void test_visitArgumentList() { |
| 79 _assertClone(AstFactory.argumentList( |
| 80 [AstFactory.identifier3("a"), AstFactory.identifier3("b")])); |
| 81 } |
| 82 |
| 83 void test_visitAsExpression() { |
| 84 _assertClone(AstFactory.asExpression( |
| 85 AstFactory.identifier3("e"), AstFactory.typeName4("T"))); |
| 86 } |
| 87 |
| 88 void test_visitAssertStatement() { |
| 89 _assertClone(AstFactory.assertStatement(AstFactory.identifier3("a"))); |
| 90 } |
| 91 |
| 92 void test_visitAssignmentExpression() { |
| 93 _assertClone(AstFactory.assignmentExpression(AstFactory.identifier3("a"), |
| 94 TokenType.EQ, AstFactory.identifier3("b"))); |
| 95 } |
| 96 |
| 97 void test_visitAwaitExpression() { |
| 98 _assertClone(AstFactory.awaitExpression(AstFactory.identifier3("a"))); |
| 99 } |
| 100 |
| 101 void test_visitBinaryExpression() { |
| 102 _assertClone(AstFactory.binaryExpression(AstFactory.identifier3("a"), |
| 103 TokenType.PLUS, AstFactory.identifier3("b"))); |
| 104 } |
| 105 |
| 106 void test_visitBlock_empty() { |
| 107 _assertClone(AstFactory.block()); |
| 108 } |
| 109 |
| 110 void test_visitBlock_nonEmpty() { |
| 111 _assertClone(AstFactory |
| 112 .block([AstFactory.breakStatement(), AstFactory.breakStatement()])); |
| 113 } |
| 114 |
| 115 void test_visitBlockFunctionBody() { |
| 116 _assertClone(AstFactory.blockFunctionBody2()); |
| 117 } |
| 118 |
| 119 void test_visitBooleanLiteral_false() { |
| 120 _assertClone(AstFactory.booleanLiteral(false)); |
| 121 } |
| 122 |
| 123 void test_visitBooleanLiteral_true() { |
| 124 _assertClone(AstFactory.booleanLiteral(true)); |
| 125 } |
| 126 |
| 127 void test_visitBreakStatement_label() { |
| 128 _assertClone(AstFactory.breakStatement2("l")); |
| 129 } |
| 130 |
| 131 void test_visitBreakStatement_noLabel() { |
| 132 _assertClone(AstFactory.breakStatement()); |
| 133 } |
| 134 |
| 135 void test_visitCascadeExpression_field() { |
| 136 _assertClone(AstFactory.cascadeExpression(AstFactory.identifier3("a"), [ |
| 137 AstFactory.cascadedPropertyAccess("b"), |
| 138 AstFactory.cascadedPropertyAccess("c") |
| 139 ])); |
| 140 } |
| 141 |
| 142 void test_visitCascadeExpression_index() { |
| 143 _assertClone(AstFactory.cascadeExpression(AstFactory.identifier3("a"), [ |
| 144 AstFactory.cascadedIndexExpression(AstFactory.integer(0)), |
| 145 AstFactory.cascadedIndexExpression(AstFactory.integer(1)) |
| 146 ])); |
| 147 } |
| 148 |
| 149 void test_visitCascadeExpression_method() { |
| 150 _assertClone(AstFactory.cascadeExpression(AstFactory.identifier3("a"), [ |
| 151 AstFactory.cascadedMethodInvocation("b"), |
| 152 AstFactory.cascadedMethodInvocation("c") |
| 153 ])); |
| 154 } |
| 155 |
| 156 void test_visitCatchClause_catch_noStack() { |
| 157 _assertClone(AstFactory.catchClause("e")); |
| 158 } |
| 159 |
| 160 void test_visitCatchClause_catch_stack() { |
| 161 _assertClone(AstFactory.catchClause2("e", "s")); |
| 162 } |
| 163 |
| 164 void test_visitCatchClause_on() { |
| 165 _assertClone(AstFactory.catchClause3(AstFactory.typeName4("E"))); |
| 166 } |
| 167 |
| 168 void test_visitCatchClause_on_catch() { |
| 169 _assertClone(AstFactory.catchClause4(AstFactory.typeName4("E"), "e")); |
| 170 } |
| 171 |
| 172 void test_visitClassDeclaration_abstract() { |
| 173 _assertClone(AstFactory.classDeclaration( |
| 174 Keyword.ABSTRACT, "C", null, null, null, null)); |
| 175 } |
| 176 |
| 177 void test_visitClassDeclaration_empty() { |
| 178 _assertClone( |
| 179 AstFactory.classDeclaration(null, "C", null, null, null, null)); |
| 180 } |
| 181 |
| 182 void test_visitClassDeclaration_extends() { |
| 183 _assertClone(AstFactory.classDeclaration(null, "C", null, |
| 184 AstFactory.extendsClause(AstFactory.typeName4("A")), null, null)); |
| 185 } |
| 186 |
| 187 void test_visitClassDeclaration_extends_implements() { |
| 188 _assertClone(AstFactory.classDeclaration( |
| 189 null, |
| 190 "C", |
| 191 null, |
| 192 AstFactory.extendsClause(AstFactory.typeName4("A")), |
| 193 null, |
| 194 AstFactory.implementsClause([AstFactory.typeName4("B")]))); |
| 195 } |
| 196 |
| 197 void test_visitClassDeclaration_extends_with() { |
| 198 _assertClone(AstFactory.classDeclaration( |
| 199 null, |
| 200 "C", |
| 201 null, |
| 202 AstFactory.extendsClause(AstFactory.typeName4("A")), |
| 203 AstFactory.withClause([AstFactory.typeName4("M")]), |
| 204 null)); |
| 205 } |
| 206 |
| 207 void test_visitClassDeclaration_extends_with_implements() { |
| 208 _assertClone(AstFactory.classDeclaration( |
| 209 null, |
| 210 "C", |
| 211 null, |
| 212 AstFactory.extendsClause(AstFactory.typeName4("A")), |
| 213 AstFactory.withClause([AstFactory.typeName4("M")]), |
| 214 AstFactory.implementsClause([AstFactory.typeName4("B")]))); |
| 215 } |
| 216 |
| 217 void test_visitClassDeclaration_implements() { |
| 218 _assertClone(AstFactory.classDeclaration(null, "C", null, null, null, |
| 219 AstFactory.implementsClause([AstFactory.typeName4("B")]))); |
| 220 } |
| 221 |
| 222 void test_visitClassDeclaration_multipleMember() { |
| 223 _assertClone( |
| 224 AstFactory.classDeclaration(null, "C", null, null, null, null, [ |
| 225 AstFactory.fieldDeclaration2( |
| 226 false, Keyword.VAR, [AstFactory.variableDeclaration("a")]), |
| 227 AstFactory.fieldDeclaration2( |
| 228 false, Keyword.VAR, [AstFactory.variableDeclaration("b")]) |
| 229 ])); |
| 230 } |
| 231 |
| 232 void test_visitClassDeclaration_parameters() { |
| 233 _assertClone(AstFactory.classDeclaration( |
| 234 null, "C", AstFactory.typeParameterList(["E"]), null, null, null)); |
| 235 } |
| 236 |
| 237 void test_visitClassDeclaration_parameters_extends() { |
| 238 _assertClone(AstFactory.classDeclaration( |
| 239 null, |
| 240 "C", |
| 241 AstFactory.typeParameterList(["E"]), |
| 242 AstFactory.extendsClause(AstFactory.typeName4("A")), |
| 243 null, |
| 244 null)); |
| 245 } |
| 246 |
| 247 void test_visitClassDeclaration_parameters_extends_implements() { |
| 248 _assertClone(AstFactory.classDeclaration( |
| 249 null, |
| 250 "C", |
| 251 AstFactory.typeParameterList(["E"]), |
| 252 AstFactory.extendsClause(AstFactory.typeName4("A")), |
| 253 null, |
| 254 AstFactory.implementsClause([AstFactory.typeName4("B")]))); |
| 255 } |
| 256 |
| 257 void test_visitClassDeclaration_parameters_extends_with() { |
| 258 _assertClone(AstFactory.classDeclaration( |
| 259 null, |
| 260 "C", |
| 261 AstFactory.typeParameterList(["E"]), |
| 262 AstFactory.extendsClause(AstFactory.typeName4("A")), |
| 263 AstFactory.withClause([AstFactory.typeName4("M")]), |
| 264 null)); |
| 265 } |
| 266 |
| 267 void test_visitClassDeclaration_parameters_extends_with_implements() { |
| 268 _assertClone(AstFactory.classDeclaration( |
| 269 null, |
| 270 "C", |
| 271 AstFactory.typeParameterList(["E"]), |
| 272 AstFactory.extendsClause(AstFactory.typeName4("A")), |
| 273 AstFactory.withClause([AstFactory.typeName4("M")]), |
| 274 AstFactory.implementsClause([AstFactory.typeName4("B")]))); |
| 275 } |
| 276 |
| 277 void test_visitClassDeclaration_parameters_implements() { |
| 278 _assertClone(AstFactory.classDeclaration( |
| 279 null, |
| 280 "C", |
| 281 AstFactory.typeParameterList(["E"]), |
| 282 null, |
| 283 null, |
| 284 AstFactory.implementsClause([AstFactory.typeName4("B")]))); |
| 285 } |
| 286 |
| 287 void test_visitClassDeclaration_singleMember() { |
| 288 _assertClone( |
| 289 AstFactory.classDeclaration(null, "C", null, null, null, null, [ |
| 290 AstFactory.fieldDeclaration2( |
| 291 false, Keyword.VAR, [AstFactory.variableDeclaration("a")]) |
| 292 ])); |
| 293 } |
| 294 |
| 295 void test_visitClassDeclaration_withMetadata() { |
| 296 ClassDeclaration declaration = |
| 297 AstFactory.classDeclaration(null, "C", null, null, null, null); |
| 298 declaration.metadata |
| 299 .add(AstFactory.annotation(AstFactory.identifier3("deprecated"))); |
| 300 _assertClone(declaration); |
| 301 } |
| 302 |
| 303 void test_visitClassTypeAlias_abstract() { |
| 304 _assertClone(AstFactory.classTypeAlias( |
| 305 "C", |
| 306 null, |
| 307 Keyword.ABSTRACT, |
| 308 AstFactory.typeName4("S"), |
| 309 AstFactory.withClause([AstFactory.typeName4("M1")]), |
| 310 null)); |
| 311 } |
| 312 |
| 313 void test_visitClassTypeAlias_abstract_implements() { |
| 314 _assertClone(AstFactory.classTypeAlias( |
| 315 "C", |
| 316 null, |
| 317 Keyword.ABSTRACT, |
| 318 AstFactory.typeName4("S"), |
| 319 AstFactory.withClause([AstFactory.typeName4("M1")]), |
| 320 AstFactory.implementsClause([AstFactory.typeName4("I")]))); |
| 321 } |
| 322 |
| 323 void test_visitClassTypeAlias_generic() { |
| 324 _assertClone(AstFactory.classTypeAlias( |
| 325 "C", |
| 326 AstFactory.typeParameterList(["E"]), |
| 327 null, |
| 328 AstFactory.typeName4("S", [AstFactory.typeName4("E")]), |
| 329 AstFactory.withClause([ |
| 330 AstFactory.typeName4("M1", [AstFactory.typeName4("E")]) |
| 331 ]), |
| 332 null)); |
| 333 } |
| 334 |
| 335 void test_visitClassTypeAlias_implements() { |
| 336 _assertClone(AstFactory.classTypeAlias( |
| 337 "C", |
| 338 null, |
| 339 null, |
| 340 AstFactory.typeName4("S"), |
| 341 AstFactory.withClause([AstFactory.typeName4("M1")]), |
| 342 AstFactory.implementsClause([AstFactory.typeName4("I")]))); |
| 343 } |
| 344 |
| 345 void test_visitClassTypeAlias_minimal() { |
| 346 _assertClone(AstFactory.classTypeAlias( |
| 347 "C", |
| 348 null, |
| 349 null, |
| 350 AstFactory.typeName4("S"), |
| 351 AstFactory.withClause([AstFactory.typeName4("M1")]), |
| 352 null)); |
| 353 } |
| 354 |
| 355 void test_visitClassTypeAlias_parameters_abstract() { |
| 356 _assertClone(AstFactory.classTypeAlias( |
| 357 "C", |
| 358 AstFactory.typeParameterList(["E"]), |
| 359 Keyword.ABSTRACT, |
| 360 AstFactory.typeName4("S"), |
| 361 AstFactory.withClause([AstFactory.typeName4("M1")]), |
| 362 null)); |
| 363 } |
| 364 |
| 365 void test_visitClassTypeAlias_parameters_abstract_implements() { |
| 366 _assertClone(AstFactory.classTypeAlias( |
| 367 "C", |
| 368 AstFactory.typeParameterList(["E"]), |
| 369 Keyword.ABSTRACT, |
| 370 AstFactory.typeName4("S"), |
| 371 AstFactory.withClause([AstFactory.typeName4("M1")]), |
| 372 AstFactory.implementsClause([AstFactory.typeName4("I")]))); |
| 373 } |
| 374 |
| 375 void test_visitClassTypeAlias_parameters_implements() { |
| 376 _assertClone(AstFactory.classTypeAlias( |
| 377 "C", |
| 378 AstFactory.typeParameterList(["E"]), |
| 379 null, |
| 380 AstFactory.typeName4("S"), |
| 381 AstFactory.withClause([AstFactory.typeName4("M1")]), |
| 382 AstFactory.implementsClause([AstFactory.typeName4("I")]))); |
| 383 } |
| 384 |
| 385 void test_visitClassTypeAlias_withMetadata() { |
| 386 ClassTypeAlias declaration = AstFactory.classTypeAlias( |
| 387 "C", |
| 388 null, |
| 389 null, |
| 390 AstFactory.typeName4("S"), |
| 391 AstFactory.withClause([AstFactory.typeName4("M1")]), |
| 392 null); |
| 393 declaration.metadata |
| 394 .add(AstFactory.annotation(AstFactory.identifier3("deprecated"))); |
| 395 _assertClone(declaration); |
| 396 } |
| 397 |
| 398 void test_visitComment() { |
| 399 _assertClone(Comment.createBlockComment( |
| 400 <Token>[TokenFactory.tokenFromString("/* comment */")])); |
| 401 } |
| 402 |
| 403 void test_visitCommentReference() { |
| 404 _assertClone(new CommentReference(null, AstFactory.identifier3("a"))); |
| 405 } |
| 406 |
| 407 void test_visitCompilationUnit_declaration() { |
| 408 _assertClone(AstFactory.compilationUnit2([ |
| 409 AstFactory.topLevelVariableDeclaration2( |
| 410 Keyword.VAR, [AstFactory.variableDeclaration("a")]) |
| 411 ])); |
| 412 } |
| 413 |
| 414 void test_visitCompilationUnit_directive() { |
| 415 _assertClone( |
| 416 AstFactory.compilationUnit3([AstFactory.libraryDirective2("l")])); |
| 417 } |
| 418 |
| 419 void test_visitCompilationUnit_directive_declaration() { |
| 420 _assertClone(AstFactory.compilationUnit4([ |
| 421 AstFactory.libraryDirective2("l") |
| 422 ], [ |
| 423 AstFactory.topLevelVariableDeclaration2( |
| 424 Keyword.VAR, [AstFactory.variableDeclaration("a")]) |
| 425 ])); |
| 426 } |
| 427 |
| 428 void test_visitCompilationUnit_empty() { |
| 429 _assertClone(AstFactory.compilationUnit()); |
| 430 } |
| 431 |
| 432 void test_visitCompilationUnit_script() { |
| 433 _assertClone(AstFactory.compilationUnit5("!#/bin/dartvm")); |
| 434 } |
| 435 |
| 436 void test_visitCompilationUnit_script_declaration() { |
| 437 _assertClone(AstFactory.compilationUnit6("!#/bin/dartvm", [ |
| 438 AstFactory.topLevelVariableDeclaration2( |
| 439 Keyword.VAR, [AstFactory.variableDeclaration("a")]) |
| 440 ])); |
| 441 } |
| 442 |
| 443 void test_visitCompilationUnit_script_directive() { |
| 444 _assertClone(AstFactory.compilationUnit7( |
| 445 "!#/bin/dartvm", [AstFactory.libraryDirective2("l")])); |
| 446 } |
| 447 |
| 448 void test_visitCompilationUnit_script_directives_declarations() { |
| 449 _assertClone(AstFactory.compilationUnit8("!#/bin/dartvm", [ |
| 450 AstFactory.libraryDirective2("l") |
| 451 ], [ |
| 452 AstFactory.topLevelVariableDeclaration2( |
| 453 Keyword.VAR, [AstFactory.variableDeclaration("a")]) |
| 454 ])); |
| 455 } |
| 456 |
| 457 void test_visitConditionalExpression() { |
| 458 _assertClone(AstFactory.conditionalExpression(AstFactory.identifier3("a"), |
| 459 AstFactory.identifier3("b"), AstFactory.identifier3("c"))); |
| 460 } |
| 461 |
| 462 void test_visitConstructorDeclaration_const() { |
| 463 _assertClone(AstFactory.constructorDeclaration2( |
| 464 Keyword.CONST, |
| 465 null, |
| 466 AstFactory.identifier3("C"), |
| 467 null, |
| 468 AstFactory.formalParameterList(), |
| 469 null, |
| 470 AstFactory.blockFunctionBody2())); |
| 471 } |
| 472 |
| 473 void test_visitConstructorDeclaration_external() { |
| 474 _assertClone(AstFactory.constructorDeclaration(AstFactory.identifier3("C"), |
| 475 null, AstFactory.formalParameterList(), null)); |
| 476 } |
| 477 |
| 478 void test_visitConstructorDeclaration_minimal() { |
| 479 _assertClone(AstFactory.constructorDeclaration2( |
| 480 null, |
| 481 null, |
| 482 AstFactory.identifier3("C"), |
| 483 null, |
| 484 AstFactory.formalParameterList(), |
| 485 null, |
| 486 AstFactory.blockFunctionBody2())); |
| 487 } |
| 488 |
| 489 void test_visitConstructorDeclaration_multipleInitializers() { |
| 490 _assertClone(AstFactory.constructorDeclaration2( |
| 491 null, |
| 492 null, |
| 493 AstFactory.identifier3("C"), |
| 494 null, |
| 495 AstFactory.formalParameterList(), |
| 496 [ |
| 497 AstFactory.constructorFieldInitializer( |
| 498 false, "a", AstFactory.identifier3("b")), |
| 499 AstFactory.constructorFieldInitializer( |
| 500 false, "c", AstFactory.identifier3("d")) |
| 501 ], |
| 502 AstFactory.blockFunctionBody2())); |
| 503 } |
| 504 |
| 505 void test_visitConstructorDeclaration_multipleParameters() { |
| 506 _assertClone(AstFactory.constructorDeclaration2( |
| 507 null, |
| 508 null, |
| 509 AstFactory.identifier3("C"), |
| 510 null, |
| 511 AstFactory.formalParameterList([ |
| 512 AstFactory.simpleFormalParameter(Keyword.VAR, "a"), |
| 513 AstFactory.simpleFormalParameter(Keyword.VAR, "b") |
| 514 ]), |
| 515 null, |
| 516 AstFactory.blockFunctionBody2())); |
| 517 } |
| 518 |
| 519 void test_visitConstructorDeclaration_named() { |
| 520 _assertClone(AstFactory.constructorDeclaration2( |
| 521 null, |
| 522 null, |
| 523 AstFactory.identifier3("C"), |
| 524 "m", |
| 525 AstFactory.formalParameterList(), |
| 526 null, |
| 527 AstFactory.blockFunctionBody2())); |
| 528 } |
| 529 |
| 530 void test_visitConstructorDeclaration_singleInitializer() { |
| 531 _assertClone(AstFactory.constructorDeclaration2( |
| 532 null, |
| 533 null, |
| 534 AstFactory.identifier3("C"), |
| 535 null, |
| 536 AstFactory.formalParameterList(), |
| 537 [ |
| 538 AstFactory.constructorFieldInitializer( |
| 539 false, "a", AstFactory.identifier3("b")) |
| 540 ], |
| 541 AstFactory.blockFunctionBody2())); |
| 542 } |
| 543 |
| 544 void test_visitConstructorDeclaration_withMetadata() { |
| 545 ConstructorDeclaration declaration = AstFactory.constructorDeclaration2( |
| 546 null, |
| 547 null, |
| 548 AstFactory.identifier3("C"), |
| 549 null, |
| 550 AstFactory.formalParameterList(), |
| 551 null, |
| 552 AstFactory.blockFunctionBody2()); |
| 553 declaration.metadata |
| 554 .add(AstFactory.annotation(AstFactory.identifier3("deprecated"))); |
| 555 _assertClone(declaration); |
| 556 } |
| 557 |
| 558 void test_visitConstructorFieldInitializer_withoutThis() { |
| 559 _assertClone(AstFactory.constructorFieldInitializer( |
| 560 false, "a", AstFactory.identifier3("b"))); |
| 561 } |
| 562 |
| 563 void test_visitConstructorFieldInitializer_withThis() { |
| 564 _assertClone(AstFactory.constructorFieldInitializer( |
| 565 true, "a", AstFactory.identifier3("b"))); |
| 566 } |
| 567 |
| 568 void test_visitConstructorName_named_prefix() { |
| 569 _assertClone( |
| 570 AstFactory.constructorName(AstFactory.typeName4("p.C.n"), null)); |
| 571 } |
| 572 |
| 573 void test_visitConstructorName_unnamed_noPrefix() { |
| 574 _assertClone(AstFactory.constructorName(AstFactory.typeName4("C"), null)); |
| 575 } |
| 576 |
| 577 void test_visitConstructorName_unnamed_prefix() { |
| 578 _assertClone(AstFactory.constructorName( |
| 579 AstFactory.typeName3(AstFactory.identifier5("p", "C")), null)); |
| 580 } |
| 581 |
| 582 void test_visitContinueStatement_label() { |
| 583 _assertClone(AstFactory.continueStatement("l")); |
| 584 } |
| 585 |
| 586 void test_visitContinueStatement_noLabel() { |
| 587 _assertClone(AstFactory.continueStatement()); |
| 588 } |
| 589 |
| 590 void test_visitDefaultFormalParameter_named_noValue() { |
| 591 _assertClone(AstFactory.namedFormalParameter( |
| 592 AstFactory.simpleFormalParameter3("p"), null)); |
| 593 } |
| 594 |
| 595 void test_visitDefaultFormalParameter_named_value() { |
| 596 _assertClone(AstFactory.namedFormalParameter( |
| 597 AstFactory.simpleFormalParameter3("p"), AstFactory.integer(0))); |
| 598 } |
| 599 |
| 600 void test_visitDefaultFormalParameter_positional_noValue() { |
| 601 _assertClone(AstFactory.positionalFormalParameter( |
| 602 AstFactory.simpleFormalParameter3("p"), null)); |
| 603 } |
| 604 |
| 605 void test_visitDefaultFormalParameter_positional_value() { |
| 606 _assertClone(AstFactory.positionalFormalParameter( |
| 607 AstFactory.simpleFormalParameter3("p"), AstFactory.integer(0))); |
| 608 } |
| 609 |
| 610 void test_visitDoStatement() { |
| 611 _assertClone(AstFactory.doStatement( |
| 612 AstFactory.block(), AstFactory.identifier3("c"))); |
| 613 } |
| 614 |
| 615 void test_visitDoubleLiteral() { |
| 616 _assertClone(AstFactory.doubleLiteral(4.2)); |
| 617 } |
| 618 |
| 619 void test_visitEmptyFunctionBody() { |
| 620 _assertClone(AstFactory.emptyFunctionBody()); |
| 621 } |
| 622 |
| 623 void test_visitEmptyStatement() { |
| 624 _assertClone(AstFactory.emptyStatement()); |
| 625 } |
| 626 |
| 627 void test_visitExportDirective_combinator() { |
| 628 _assertClone(AstFactory.exportDirective2("a.dart", [ |
| 629 AstFactory.showCombinator([AstFactory.identifier3("A")]) |
| 630 ])); |
| 631 } |
| 632 |
| 633 void test_visitExportDirective_combinators() { |
| 634 _assertClone(AstFactory.exportDirective2("a.dart", [ |
| 635 AstFactory.showCombinator([AstFactory.identifier3("A")]), |
| 636 AstFactory.hideCombinator([AstFactory.identifier3("B")]) |
| 637 ])); |
| 638 } |
| 639 |
| 640 void test_visitExportDirective_minimal() { |
| 641 _assertClone(AstFactory.exportDirective2("a.dart")); |
| 642 } |
| 643 |
| 644 void test_visitExportDirective_withMetadata() { |
| 645 ExportDirective directive = AstFactory.exportDirective2("a.dart"); |
| 646 directive.metadata |
| 647 .add(AstFactory.annotation(AstFactory.identifier3("deprecated"))); |
| 648 _assertClone(directive); |
| 649 } |
| 650 |
| 651 void test_visitExpressionFunctionBody() { |
| 652 _assertClone( |
| 653 AstFactory.expressionFunctionBody(AstFactory.identifier3("a"))); |
| 654 } |
| 655 |
| 656 void test_visitExpressionStatement() { |
| 657 _assertClone(AstFactory.expressionStatement(AstFactory.identifier3("a"))); |
| 658 } |
| 659 |
| 660 void test_visitExtendsClause() { |
| 661 _assertClone(AstFactory.extendsClause(AstFactory.typeName4("C"))); |
| 662 } |
| 663 |
| 664 void test_visitFieldDeclaration_instance() { |
| 665 _assertClone(AstFactory.fieldDeclaration2( |
| 666 false, Keyword.VAR, [AstFactory.variableDeclaration("a")])); |
| 667 } |
| 668 |
| 669 void test_visitFieldDeclaration_static() { |
| 670 _assertClone(AstFactory.fieldDeclaration2( |
| 671 true, Keyword.VAR, [AstFactory.variableDeclaration("a")])); |
| 672 } |
| 673 |
| 674 void test_visitFieldDeclaration_withMetadata() { |
| 675 FieldDeclaration declaration = AstFactory.fieldDeclaration2( |
| 676 false, Keyword.VAR, [AstFactory.variableDeclaration("a")]); |
| 677 declaration.metadata |
| 678 .add(AstFactory.annotation(AstFactory.identifier3("deprecated"))); |
| 679 _assertClone(declaration); |
| 680 } |
| 681 |
| 682 void test_visitFieldFormalParameter_functionTyped() { |
| 683 _assertClone(AstFactory.fieldFormalParameter( |
| 684 null, |
| 685 AstFactory.typeName4("A"), |
| 686 "a", |
| 687 AstFactory |
| 688 .formalParameterList([AstFactory.simpleFormalParameter3("b")]))); |
| 689 } |
| 690 |
| 691 void test_visitFieldFormalParameter_keyword() { |
| 692 _assertClone(AstFactory.fieldFormalParameter(Keyword.VAR, null, "a")); |
| 693 } |
| 694 |
| 695 void test_visitFieldFormalParameter_keywordAndType() { |
| 696 _assertClone(AstFactory.fieldFormalParameter( |
| 697 Keyword.FINAL, AstFactory.typeName4("A"), "a")); |
| 698 } |
| 699 |
| 700 void test_visitFieldFormalParameter_type() { |
| 701 _assertClone( |
| 702 AstFactory.fieldFormalParameter(null, AstFactory.typeName4("A"), "a")); |
| 703 } |
| 704 |
| 705 void test_visitForEachStatement_declared() { |
| 706 _assertClone(AstFactory.forEachStatement( |
| 707 AstFactory.declaredIdentifier3("a"), |
| 708 AstFactory.identifier3("b"), |
| 709 AstFactory.block())); |
| 710 } |
| 711 |
| 712 void test_visitForEachStatement_variable() { |
| 713 _assertClone(new ForEachStatement.withReference( |
| 714 null, |
| 715 TokenFactory.tokenFromKeyword(Keyword.FOR), |
| 716 TokenFactory.tokenFromType(TokenType.OPEN_PAREN), |
| 717 AstFactory.identifier3("a"), |
| 718 TokenFactory.tokenFromKeyword(Keyword.IN), |
| 719 AstFactory.identifier3("b"), |
| 720 TokenFactory.tokenFromType(TokenType.CLOSE_PAREN), |
| 721 AstFactory.block())); |
| 722 } |
| 723 |
| 724 void test_visitForEachStatement_variable_await() { |
| 725 _assertClone(new ForEachStatement.withReference( |
| 726 TokenFactory.tokenFromString("await"), |
| 727 TokenFactory.tokenFromKeyword(Keyword.FOR), |
| 728 TokenFactory.tokenFromType(TokenType.OPEN_PAREN), |
| 729 AstFactory.identifier3("a"), |
| 730 TokenFactory.tokenFromKeyword(Keyword.IN), |
| 731 AstFactory.identifier3("b"), |
| 732 TokenFactory.tokenFromType(TokenType.CLOSE_PAREN), |
| 733 AstFactory.block())); |
| 734 } |
| 735 |
| 736 void test_visitFormalParameterList_empty() { |
| 737 _assertClone(AstFactory.formalParameterList()); |
| 738 } |
| 739 |
| 740 void test_visitFormalParameterList_n() { |
| 741 _assertClone(AstFactory.formalParameterList([ |
| 742 AstFactory.namedFormalParameter( |
| 743 AstFactory.simpleFormalParameter3("a"), AstFactory.integer(0)) |
| 744 ])); |
| 745 } |
| 746 |
| 747 void test_visitFormalParameterList_nn() { |
| 748 _assertClone(AstFactory.formalParameterList([ |
| 749 AstFactory.namedFormalParameter( |
| 750 AstFactory.simpleFormalParameter3("a"), AstFactory.integer(0)), |
| 751 AstFactory.namedFormalParameter( |
| 752 AstFactory.simpleFormalParameter3("b"), AstFactory.integer(1)) |
| 753 ])); |
| 754 } |
| 755 |
| 756 void test_visitFormalParameterList_p() { |
| 757 _assertClone(AstFactory.formalParameterList([ |
| 758 AstFactory.positionalFormalParameter( |
| 759 AstFactory.simpleFormalParameter3("a"), AstFactory.integer(0)) |
| 760 ])); |
| 761 } |
| 762 |
| 763 void test_visitFormalParameterList_pp() { |
| 764 _assertClone(AstFactory.formalParameterList([ |
| 765 AstFactory.positionalFormalParameter( |
| 766 AstFactory.simpleFormalParameter3("a"), AstFactory.integer(0)), |
| 767 AstFactory.positionalFormalParameter( |
| 768 AstFactory.simpleFormalParameter3("b"), AstFactory.integer(1)) |
| 769 ])); |
| 770 } |
| 771 |
| 772 void test_visitFormalParameterList_r() { |
| 773 _assertClone(AstFactory |
| 774 .formalParameterList([AstFactory.simpleFormalParameter3("a")])); |
| 775 } |
| 776 |
| 777 void test_visitFormalParameterList_rn() { |
| 778 _assertClone(AstFactory.formalParameterList([ |
| 779 AstFactory.simpleFormalParameter3("a"), |
| 780 AstFactory.namedFormalParameter( |
| 781 AstFactory.simpleFormalParameter3("b"), AstFactory.integer(1)) |
| 782 ])); |
| 783 } |
| 784 |
| 785 void test_visitFormalParameterList_rnn() { |
| 786 _assertClone(AstFactory.formalParameterList([ |
| 787 AstFactory.simpleFormalParameter3("a"), |
| 788 AstFactory.namedFormalParameter( |
| 789 AstFactory.simpleFormalParameter3("b"), AstFactory.integer(1)), |
| 790 AstFactory.namedFormalParameter( |
| 791 AstFactory.simpleFormalParameter3("c"), AstFactory.integer(2)) |
| 792 ])); |
| 793 } |
| 794 |
| 795 void test_visitFormalParameterList_rp() { |
| 796 _assertClone(AstFactory.formalParameterList([ |
| 797 AstFactory.simpleFormalParameter3("a"), |
| 798 AstFactory.positionalFormalParameter( |
| 799 AstFactory.simpleFormalParameter3("b"), AstFactory.integer(1)) |
| 800 ])); |
| 801 } |
| 802 |
| 803 void test_visitFormalParameterList_rpp() { |
| 804 _assertClone(AstFactory.formalParameterList([ |
| 805 AstFactory.simpleFormalParameter3("a"), |
| 806 AstFactory.positionalFormalParameter( |
| 807 AstFactory.simpleFormalParameter3("b"), AstFactory.integer(1)), |
| 808 AstFactory.positionalFormalParameter( |
| 809 AstFactory.simpleFormalParameter3("c"), AstFactory.integer(2)) |
| 810 ])); |
| 811 } |
| 812 |
| 813 void test_visitFormalParameterList_rr() { |
| 814 _assertClone(AstFactory.formalParameterList([ |
| 815 AstFactory.simpleFormalParameter3("a"), |
| 816 AstFactory.simpleFormalParameter3("b") |
| 817 ])); |
| 818 } |
| 819 |
| 820 void test_visitFormalParameterList_rrn() { |
| 821 _assertClone(AstFactory.formalParameterList([ |
| 822 AstFactory.simpleFormalParameter3("a"), |
| 823 AstFactory.simpleFormalParameter3("b"), |
| 824 AstFactory.namedFormalParameter( |
| 825 AstFactory.simpleFormalParameter3("c"), AstFactory.integer(3)) |
| 826 ])); |
| 827 } |
| 828 |
| 829 void test_visitFormalParameterList_rrnn() { |
| 830 _assertClone(AstFactory.formalParameterList([ |
| 831 AstFactory.simpleFormalParameter3("a"), |
| 832 AstFactory.simpleFormalParameter3("b"), |
| 833 AstFactory.namedFormalParameter( |
| 834 AstFactory.simpleFormalParameter3("c"), AstFactory.integer(3)), |
| 835 AstFactory.namedFormalParameter( |
| 836 AstFactory.simpleFormalParameter3("d"), AstFactory.integer(4)) |
| 837 ])); |
| 838 } |
| 839 |
| 840 void test_visitFormalParameterList_rrp() { |
| 841 _assertClone(AstFactory.formalParameterList([ |
| 842 AstFactory.simpleFormalParameter3("a"), |
| 843 AstFactory.simpleFormalParameter3("b"), |
| 844 AstFactory.positionalFormalParameter( |
| 845 AstFactory.simpleFormalParameter3("c"), AstFactory.integer(3)) |
| 846 ])); |
| 847 } |
| 848 |
| 849 void test_visitFormalParameterList_rrpp() { |
| 850 _assertClone(AstFactory.formalParameterList([ |
| 851 AstFactory.simpleFormalParameter3("a"), |
| 852 AstFactory.simpleFormalParameter3("b"), |
| 853 AstFactory.positionalFormalParameter( |
| 854 AstFactory.simpleFormalParameter3("c"), AstFactory.integer(3)), |
| 855 AstFactory.positionalFormalParameter( |
| 856 AstFactory.simpleFormalParameter3("d"), AstFactory.integer(4)) |
| 857 ])); |
| 858 } |
| 859 |
| 860 void test_visitForStatement_c() { |
| 861 _assertClone(AstFactory.forStatement( |
| 862 null, AstFactory.identifier3("c"), null, AstFactory.block())); |
| 863 } |
| 864 |
| 865 void test_visitForStatement_cu() { |
| 866 _assertClone(AstFactory.forStatement(null, AstFactory.identifier3("c"), |
| 867 [AstFactory.identifier3("u")], AstFactory.block())); |
| 868 } |
| 869 |
| 870 void test_visitForStatement_e() { |
| 871 _assertClone(AstFactory.forStatement( |
| 872 AstFactory.identifier3("e"), null, null, AstFactory.block())); |
| 873 } |
| 874 |
| 875 void test_visitForStatement_ec() { |
| 876 _assertClone(AstFactory.forStatement(AstFactory.identifier3("e"), |
| 877 AstFactory.identifier3("c"), null, AstFactory.block())); |
| 878 } |
| 879 |
| 880 void test_visitForStatement_ecu() { |
| 881 _assertClone(AstFactory.forStatement( |
| 882 AstFactory.identifier3("e"), |
| 883 AstFactory.identifier3("c"), |
| 884 [AstFactory.identifier3("u")], |
| 885 AstFactory.block())); |
| 886 } |
| 887 |
| 888 void test_visitForStatement_eu() { |
| 889 _assertClone(AstFactory.forStatement(AstFactory.identifier3("e"), null, |
| 890 [AstFactory.identifier3("u")], AstFactory.block())); |
| 891 } |
| 892 |
| 893 void test_visitForStatement_i() { |
| 894 _assertClone(AstFactory.forStatement2( |
| 895 AstFactory.variableDeclarationList2( |
| 896 Keyword.VAR, [AstFactory.variableDeclaration("i")]), |
| 897 null, |
| 898 null, |
| 899 AstFactory.block())); |
| 900 } |
| 901 |
| 902 void test_visitForStatement_ic() { |
| 903 _assertClone(AstFactory.forStatement2( |
| 904 AstFactory.variableDeclarationList2( |
| 905 Keyword.VAR, [AstFactory.variableDeclaration("i")]), |
| 906 AstFactory.identifier3("c"), |
| 907 null, |
| 908 AstFactory.block())); |
| 909 } |
| 910 |
| 911 void test_visitForStatement_icu() { |
| 912 _assertClone(AstFactory.forStatement2( |
| 913 AstFactory.variableDeclarationList2( |
| 914 Keyword.VAR, [AstFactory.variableDeclaration("i")]), |
| 915 AstFactory.identifier3("c"), |
| 916 [AstFactory.identifier3("u")], |
| 917 AstFactory.block())); |
| 918 } |
| 919 |
| 920 void test_visitForStatement_iu() { |
| 921 _assertClone(AstFactory.forStatement2( |
| 922 AstFactory.variableDeclarationList2( |
| 923 Keyword.VAR, [AstFactory.variableDeclaration("i")]), |
| 924 null, |
| 925 [AstFactory.identifier3("u")], |
| 926 AstFactory.block())); |
| 927 } |
| 928 |
| 929 void test_visitForStatement_u() { |
| 930 _assertClone(AstFactory.forStatement( |
| 931 null, null, [AstFactory.identifier3("u")], AstFactory.block())); |
| 932 } |
| 933 |
| 934 void test_visitFunctionDeclaration_getter() { |
| 935 _assertClone(AstFactory.functionDeclaration( |
| 936 null, Keyword.GET, "f", AstFactory.functionExpression())); |
| 937 } |
| 938 |
| 939 void test_visitFunctionDeclaration_normal() { |
| 940 _assertClone(AstFactory.functionDeclaration( |
| 941 null, null, "f", AstFactory.functionExpression())); |
| 942 } |
| 943 |
| 944 void test_visitFunctionDeclaration_setter() { |
| 945 _assertClone(AstFactory.functionDeclaration( |
| 946 null, Keyword.SET, "f", AstFactory.functionExpression())); |
| 947 } |
| 948 |
| 949 void test_visitFunctionDeclaration_withMetadata() { |
| 950 FunctionDeclaration declaration = AstFactory.functionDeclaration( |
| 951 null, null, "f", AstFactory.functionExpression()); |
| 952 declaration.metadata |
| 953 .add(AstFactory.annotation(AstFactory.identifier3("deprecated"))); |
| 954 _assertClone(declaration); |
| 955 } |
| 956 |
| 957 void test_visitFunctionDeclarationStatement() { |
| 958 _assertClone(AstFactory.functionDeclarationStatement( |
| 959 null, null, "f", AstFactory.functionExpression())); |
| 960 } |
| 961 |
| 962 void test_visitFunctionExpression() { |
| 963 _assertClone(AstFactory.functionExpression()); |
| 964 } |
| 965 |
| 966 void test_visitFunctionExpressionInvocation() { |
| 967 _assertClone( |
| 968 AstFactory.functionExpressionInvocation(AstFactory.identifier3("f"))); |
| 969 } |
| 970 |
| 971 void test_visitFunctionTypeAlias_generic() { |
| 972 _assertClone(AstFactory.typeAlias(AstFactory.typeName4("A"), "F", |
| 973 AstFactory.typeParameterList(["B"]), AstFactory.formalParameterList())); |
| 974 } |
| 975 |
| 976 void test_visitFunctionTypeAlias_nonGeneric() { |
| 977 _assertClone(AstFactory.typeAlias(AstFactory.typeName4("A"), "F", null, |
| 978 AstFactory.formalParameterList())); |
| 979 } |
| 980 |
| 981 void test_visitFunctionTypeAlias_withMetadata() { |
| 982 FunctionTypeAlias declaration = AstFactory.typeAlias( |
| 983 AstFactory.typeName4("A"), "F", null, AstFactory.formalParameterList()); |
| 984 declaration.metadata |
| 985 .add(AstFactory.annotation(AstFactory.identifier3("deprecated"))); |
| 986 _assertClone(declaration); |
| 987 } |
| 988 |
| 989 void test_visitFunctionTypedFormalParameter_noType() { |
| 990 _assertClone(AstFactory.functionTypedFormalParameter(null, "f")); |
| 991 } |
| 992 |
| 993 void test_visitFunctionTypedFormalParameter_type() { |
| 994 _assertClone(AstFactory.functionTypedFormalParameter( |
| 995 AstFactory.typeName4("T"), "f")); |
| 996 } |
| 997 |
| 998 void test_visitIfStatement_withElse() { |
| 999 _assertClone(AstFactory.ifStatement2( |
| 1000 AstFactory.identifier3("c"), AstFactory.block(), AstFactory.block())); |
| 1001 } |
| 1002 |
| 1003 void test_visitIfStatement_withoutElse() { |
| 1004 _assertClone(AstFactory.ifStatement( |
| 1005 AstFactory.identifier3("c"), AstFactory.block())); |
| 1006 } |
| 1007 |
| 1008 void test_visitImplementsClause_multiple() { |
| 1009 _assertClone(AstFactory.implementsClause( |
| 1010 [AstFactory.typeName4("A"), AstFactory.typeName4("B")])); |
| 1011 } |
| 1012 |
| 1013 void test_visitImplementsClause_single() { |
| 1014 _assertClone(AstFactory.implementsClause([AstFactory.typeName4("A")])); |
| 1015 } |
| 1016 |
| 1017 void test_visitImportDirective_combinator() { |
| 1018 _assertClone(AstFactory.importDirective3("a.dart", null, [ |
| 1019 AstFactory.showCombinator([AstFactory.identifier3("A")]) |
| 1020 ])); |
| 1021 } |
| 1022 |
| 1023 void test_visitImportDirective_combinators() { |
| 1024 _assertClone(AstFactory.importDirective3("a.dart", null, [ |
| 1025 AstFactory.showCombinator([AstFactory.identifier3("A")]), |
| 1026 AstFactory.hideCombinator([AstFactory.identifier3("B")]) |
| 1027 ])); |
| 1028 } |
| 1029 |
| 1030 void test_visitImportDirective_minimal() { |
| 1031 _assertClone(AstFactory.importDirective3("a.dart", null)); |
| 1032 } |
| 1033 |
| 1034 void test_visitImportDirective_prefix() { |
| 1035 _assertClone(AstFactory.importDirective3("a.dart", "p")); |
| 1036 } |
| 1037 |
| 1038 void test_visitImportDirective_prefix_combinator() { |
| 1039 _assertClone(AstFactory.importDirective3("a.dart", "p", [ |
| 1040 AstFactory.showCombinator([AstFactory.identifier3("A")]) |
| 1041 ])); |
| 1042 } |
| 1043 |
| 1044 void test_visitImportDirective_prefix_combinators() { |
| 1045 _assertClone(AstFactory.importDirective3("a.dart", "p", [ |
| 1046 AstFactory.showCombinator([AstFactory.identifier3("A")]), |
| 1047 AstFactory.hideCombinator([AstFactory.identifier3("B")]) |
| 1048 ])); |
| 1049 } |
| 1050 |
| 1051 void test_visitImportDirective_withMetadata() { |
| 1052 ImportDirective directive = AstFactory.importDirective3("a.dart", null); |
| 1053 directive.metadata |
| 1054 .add(AstFactory.annotation(AstFactory.identifier3("deprecated"))); |
| 1055 _assertClone(directive); |
| 1056 } |
| 1057 |
| 1058 void test_visitImportHideCombinator_multiple() { |
| 1059 _assertClone(AstFactory.hideCombinator( |
| 1060 [AstFactory.identifier3("a"), AstFactory.identifier3("b")])); |
| 1061 } |
| 1062 |
| 1063 void test_visitImportHideCombinator_single() { |
| 1064 _assertClone(AstFactory.hideCombinator([AstFactory.identifier3("a")])); |
| 1065 } |
| 1066 |
| 1067 void test_visitImportShowCombinator_multiple() { |
| 1068 _assertClone(AstFactory.showCombinator( |
| 1069 [AstFactory.identifier3("a"), AstFactory.identifier3("b")])); |
| 1070 } |
| 1071 |
| 1072 void test_visitImportShowCombinator_single() { |
| 1073 _assertClone(AstFactory.showCombinator([AstFactory.identifier3("a")])); |
| 1074 } |
| 1075 |
| 1076 void test_visitIndexExpression() { |
| 1077 _assertClone(AstFactory.indexExpression( |
| 1078 AstFactory.identifier3("a"), AstFactory.identifier3("i"))); |
| 1079 } |
| 1080 |
| 1081 void test_visitInstanceCreationExpression_const() { |
| 1082 _assertClone(AstFactory.instanceCreationExpression2( |
| 1083 Keyword.CONST, AstFactory.typeName4("C"))); |
| 1084 } |
| 1085 |
| 1086 void test_visitInstanceCreationExpression_named() { |
| 1087 _assertClone(AstFactory.instanceCreationExpression3( |
| 1088 Keyword.NEW, AstFactory.typeName4("C"), "c")); |
| 1089 } |
| 1090 |
| 1091 void test_visitInstanceCreationExpression_unnamed() { |
| 1092 _assertClone(AstFactory.instanceCreationExpression2( |
| 1093 Keyword.NEW, AstFactory.typeName4("C"))); |
| 1094 } |
| 1095 |
| 1096 void test_visitIntegerLiteral() { |
| 1097 _assertClone(AstFactory.integer(42)); |
| 1098 } |
| 1099 |
| 1100 void test_visitInterpolationExpression_expression() { |
| 1101 _assertClone( |
| 1102 AstFactory.interpolationExpression(AstFactory.identifier3("a"))); |
| 1103 } |
| 1104 |
| 1105 void test_visitInterpolationExpression_identifier() { |
| 1106 _assertClone(AstFactory.interpolationExpression2("a")); |
| 1107 } |
| 1108 |
| 1109 void test_visitInterpolationString() { |
| 1110 _assertClone(AstFactory.interpolationString("'x", "x")); |
| 1111 } |
| 1112 |
| 1113 void test_visitIsExpression_negated() { |
| 1114 _assertClone(AstFactory.isExpression( |
| 1115 AstFactory.identifier3("a"), true, AstFactory.typeName4("C"))); |
| 1116 } |
| 1117 |
| 1118 void test_visitIsExpression_normal() { |
| 1119 _assertClone(AstFactory.isExpression( |
| 1120 AstFactory.identifier3("a"), false, AstFactory.typeName4("C"))); |
| 1121 } |
| 1122 |
| 1123 void test_visitLabel() { |
| 1124 _assertClone(AstFactory.label2("a")); |
| 1125 } |
| 1126 |
| 1127 void test_visitLabeledStatement_multiple() { |
| 1128 _assertClone(AstFactory.labeledStatement( |
| 1129 [AstFactory.label2("a"), AstFactory.label2("b")], |
| 1130 AstFactory.returnStatement())); |
| 1131 } |
| 1132 |
| 1133 void test_visitLabeledStatement_single() { |
| 1134 _assertClone(AstFactory.labeledStatement( |
| 1135 [AstFactory.label2("a")], AstFactory.returnStatement())); |
| 1136 } |
| 1137 |
| 1138 void test_visitLibraryDirective() { |
| 1139 _assertClone(AstFactory.libraryDirective2("l")); |
| 1140 } |
| 1141 |
| 1142 void test_visitLibraryDirective_withMetadata() { |
| 1143 LibraryDirective directive = AstFactory.libraryDirective2("l"); |
| 1144 directive.metadata |
| 1145 .add(AstFactory.annotation(AstFactory.identifier3("deprecated"))); |
| 1146 _assertClone(directive); |
| 1147 } |
| 1148 |
| 1149 void test_visitLibraryIdentifier_multiple() { |
| 1150 _assertClone(AstFactory.libraryIdentifier([ |
| 1151 AstFactory.identifier3("a"), |
| 1152 AstFactory.identifier3("b"), |
| 1153 AstFactory.identifier3("c") |
| 1154 ])); |
| 1155 } |
| 1156 |
| 1157 void test_visitLibraryIdentifier_single() { |
| 1158 _assertClone(AstFactory.libraryIdentifier([AstFactory.identifier3("a")])); |
| 1159 } |
| 1160 |
| 1161 void test_visitListLiteral_const() { |
| 1162 _assertClone(AstFactory.listLiteral2(Keyword.CONST, null)); |
| 1163 } |
| 1164 |
| 1165 void test_visitListLiteral_empty() { |
| 1166 _assertClone(AstFactory.listLiteral()); |
| 1167 } |
| 1168 |
| 1169 void test_visitListLiteral_nonEmpty() { |
| 1170 _assertClone(AstFactory.listLiteral([ |
| 1171 AstFactory.identifier3("a"), |
| 1172 AstFactory.identifier3("b"), |
| 1173 AstFactory.identifier3("c") |
| 1174 ])); |
| 1175 } |
| 1176 |
| 1177 void test_visitMapLiteral_const() { |
| 1178 _assertClone(AstFactory.mapLiteral(Keyword.CONST, null)); |
| 1179 } |
| 1180 |
| 1181 void test_visitMapLiteral_empty() { |
| 1182 _assertClone(AstFactory.mapLiteral2()); |
| 1183 } |
| 1184 |
| 1185 void test_visitMapLiteral_nonEmpty() { |
| 1186 _assertClone(AstFactory.mapLiteral2([ |
| 1187 AstFactory.mapLiteralEntry("a", AstFactory.identifier3("a")), |
| 1188 AstFactory.mapLiteralEntry("b", AstFactory.identifier3("b")), |
| 1189 AstFactory.mapLiteralEntry("c", AstFactory.identifier3("c")) |
| 1190 ])); |
| 1191 } |
| 1192 |
| 1193 void test_visitMapLiteralEntry() { |
| 1194 _assertClone(AstFactory.mapLiteralEntry("a", AstFactory.identifier3("b"))); |
| 1195 } |
| 1196 |
| 1197 void test_visitMethodDeclaration_external() { |
| 1198 _assertClone(AstFactory.methodDeclaration(null, null, null, null, |
| 1199 AstFactory.identifier3("m"), AstFactory.formalParameterList())); |
| 1200 } |
| 1201 |
| 1202 void test_visitMethodDeclaration_external_returnType() { |
| 1203 _assertClone(AstFactory.methodDeclaration( |
| 1204 null, |
| 1205 AstFactory.typeName4("T"), |
| 1206 null, |
| 1207 null, |
| 1208 AstFactory.identifier3("m"), |
| 1209 AstFactory.formalParameterList())); |
| 1210 } |
| 1211 |
| 1212 void test_visitMethodDeclaration_getter() { |
| 1213 _assertClone(AstFactory.methodDeclaration2(null, null, Keyword.GET, null, |
| 1214 AstFactory.identifier3("m"), null, AstFactory.blockFunctionBody2())); |
| 1215 } |
| 1216 |
| 1217 void test_visitMethodDeclaration_getter_returnType() { |
| 1218 _assertClone(AstFactory.methodDeclaration2( |
| 1219 null, |
| 1220 AstFactory.typeName4("T"), |
| 1221 Keyword.GET, |
| 1222 null, |
| 1223 AstFactory.identifier3("m"), |
| 1224 null, |
| 1225 AstFactory.blockFunctionBody2())); |
| 1226 } |
| 1227 |
| 1228 void test_visitMethodDeclaration_getter_seturnType() { |
| 1229 _assertClone(AstFactory.methodDeclaration2( |
| 1230 null, |
| 1231 AstFactory.typeName4("T"), |
| 1232 Keyword.SET, |
| 1233 null, |
| 1234 AstFactory.identifier3("m"), |
| 1235 AstFactory.formalParameterList( |
| 1236 [AstFactory.simpleFormalParameter(Keyword.VAR, "v")]), |
| 1237 AstFactory.blockFunctionBody2())); |
| 1238 } |
| 1239 |
| 1240 void test_visitMethodDeclaration_minimal() { |
| 1241 _assertClone(AstFactory.methodDeclaration2( |
| 1242 null, |
| 1243 null, |
| 1244 null, |
| 1245 null, |
| 1246 AstFactory.identifier3("m"), |
| 1247 AstFactory.formalParameterList(), |
| 1248 AstFactory.blockFunctionBody2())); |
| 1249 } |
| 1250 |
| 1251 void test_visitMethodDeclaration_multipleParameters() { |
| 1252 _assertClone(AstFactory.methodDeclaration2( |
| 1253 null, |
| 1254 null, |
| 1255 null, |
| 1256 null, |
| 1257 AstFactory.identifier3("m"), |
| 1258 AstFactory.formalParameterList([ |
| 1259 AstFactory.simpleFormalParameter(Keyword.VAR, "a"), |
| 1260 AstFactory.simpleFormalParameter(Keyword.VAR, "b") |
| 1261 ]), |
| 1262 AstFactory.blockFunctionBody2())); |
| 1263 } |
| 1264 |
| 1265 void test_visitMethodDeclaration_operator() { |
| 1266 _assertClone(AstFactory.methodDeclaration2( |
| 1267 null, |
| 1268 null, |
| 1269 null, |
| 1270 Keyword.OPERATOR, |
| 1271 AstFactory.identifier3("+"), |
| 1272 AstFactory.formalParameterList(), |
| 1273 AstFactory.blockFunctionBody2())); |
| 1274 } |
| 1275 |
| 1276 void test_visitMethodDeclaration_operator_returnType() { |
| 1277 _assertClone(AstFactory.methodDeclaration2( |
| 1278 null, |
| 1279 AstFactory.typeName4("T"), |
| 1280 null, |
| 1281 Keyword.OPERATOR, |
| 1282 AstFactory.identifier3("+"), |
| 1283 AstFactory.formalParameterList(), |
| 1284 AstFactory.blockFunctionBody2())); |
| 1285 } |
| 1286 |
| 1287 void test_visitMethodDeclaration_returnType() { |
| 1288 _assertClone(AstFactory.methodDeclaration2( |
| 1289 null, |
| 1290 AstFactory.typeName4("T"), |
| 1291 null, |
| 1292 null, |
| 1293 AstFactory.identifier3("m"), |
| 1294 AstFactory.formalParameterList(), |
| 1295 AstFactory.blockFunctionBody2())); |
| 1296 } |
| 1297 |
| 1298 void test_visitMethodDeclaration_setter() { |
| 1299 _assertClone(AstFactory.methodDeclaration2( |
| 1300 null, |
| 1301 null, |
| 1302 Keyword.SET, |
| 1303 null, |
| 1304 AstFactory.identifier3("m"), |
| 1305 AstFactory.formalParameterList( |
| 1306 [AstFactory.simpleFormalParameter(Keyword.VAR, "v")]), |
| 1307 AstFactory.blockFunctionBody2())); |
| 1308 } |
| 1309 |
| 1310 void test_visitMethodDeclaration_static() { |
| 1311 _assertClone(AstFactory.methodDeclaration2( |
| 1312 Keyword.STATIC, |
| 1313 null, |
| 1314 null, |
| 1315 null, |
| 1316 AstFactory.identifier3("m"), |
| 1317 AstFactory.formalParameterList(), |
| 1318 AstFactory.blockFunctionBody2())); |
| 1319 } |
| 1320 |
| 1321 void test_visitMethodDeclaration_static_returnType() { |
| 1322 _assertClone(AstFactory.methodDeclaration2( |
| 1323 Keyword.STATIC, |
| 1324 AstFactory.typeName4("T"), |
| 1325 null, |
| 1326 null, |
| 1327 AstFactory.identifier3("m"), |
| 1328 AstFactory.formalParameterList(), |
| 1329 AstFactory.blockFunctionBody2())); |
| 1330 } |
| 1331 |
| 1332 void test_visitMethodDeclaration_withMetadata() { |
| 1333 MethodDeclaration declaration = AstFactory.methodDeclaration2( |
| 1334 null, |
| 1335 null, |
| 1336 null, |
| 1337 null, |
| 1338 AstFactory.identifier3("m"), |
| 1339 AstFactory.formalParameterList(), |
| 1340 AstFactory.blockFunctionBody2()); |
| 1341 declaration.metadata |
| 1342 .add(AstFactory.annotation(AstFactory.identifier3("deprecated"))); |
| 1343 _assertClone(declaration); |
| 1344 } |
| 1345 |
| 1346 void test_visitMethodInvocation_noTarget() { |
| 1347 _assertClone(AstFactory.methodInvocation2("m")); |
| 1348 } |
| 1349 |
| 1350 void test_visitMethodInvocation_target() { |
| 1351 _assertClone(AstFactory.methodInvocation(AstFactory.identifier3("t"), "m")); |
| 1352 } |
| 1353 |
| 1354 void test_visitNamedExpression() { |
| 1355 _assertClone(AstFactory.namedExpression2("a", AstFactory.identifier3("b"))); |
| 1356 } |
| 1357 |
| 1358 void test_visitNamedFormalParameter() { |
| 1359 _assertClone(AstFactory.namedFormalParameter( |
| 1360 AstFactory.simpleFormalParameter(Keyword.VAR, "a"), |
| 1361 AstFactory.integer(0))); |
| 1362 } |
| 1363 |
| 1364 void test_visitNativeClause() { |
| 1365 _assertClone(AstFactory.nativeClause("code")); |
| 1366 } |
| 1367 |
| 1368 void test_visitNativeFunctionBody() { |
| 1369 _assertClone(AstFactory.nativeFunctionBody("str")); |
| 1370 } |
| 1371 |
| 1372 void test_visitNullLiteral() { |
| 1373 _assertClone(AstFactory.nullLiteral()); |
| 1374 } |
| 1375 |
| 1376 void test_visitParenthesizedExpression() { |
| 1377 _assertClone( |
| 1378 AstFactory.parenthesizedExpression(AstFactory.identifier3("a"))); |
| 1379 } |
| 1380 |
| 1381 void test_visitPartDirective() { |
| 1382 _assertClone(AstFactory.partDirective2("a.dart")); |
| 1383 } |
| 1384 |
| 1385 void test_visitPartDirective_withMetadata() { |
| 1386 PartDirective directive = AstFactory.partDirective2("a.dart"); |
| 1387 directive.metadata |
| 1388 .add(AstFactory.annotation(AstFactory.identifier3("deprecated"))); |
| 1389 _assertClone(directive); |
| 1390 } |
| 1391 |
| 1392 void test_visitPartOfDirective() { |
| 1393 _assertClone( |
| 1394 AstFactory.partOfDirective(AstFactory.libraryIdentifier2(["l"]))); |
| 1395 } |
| 1396 |
| 1397 void test_visitPartOfDirective_withMetadata() { |
| 1398 PartOfDirective directive = |
| 1399 AstFactory.partOfDirective(AstFactory.libraryIdentifier2(["l"])); |
| 1400 directive.metadata |
| 1401 .add(AstFactory.annotation(AstFactory.identifier3("deprecated"))); |
| 1402 _assertClone(directive); |
| 1403 } |
| 1404 |
| 1405 void test_visitPositionalFormalParameter() { |
| 1406 _assertClone(AstFactory.positionalFormalParameter( |
| 1407 AstFactory.simpleFormalParameter(Keyword.VAR, "a"), |
| 1408 AstFactory.integer(0))); |
| 1409 } |
| 1410 |
| 1411 void test_visitPostfixExpression() { |
| 1412 _assertClone(AstFactory.postfixExpression( |
| 1413 AstFactory.identifier3("a"), TokenType.PLUS_PLUS)); |
| 1414 } |
| 1415 |
| 1416 void test_visitPrefixedIdentifier() { |
| 1417 _assertClone(AstFactory.identifier5("a", "b")); |
| 1418 } |
| 1419 |
| 1420 void test_visitPrefixExpression() { |
| 1421 _assertClone(AstFactory.prefixExpression( |
| 1422 TokenType.MINUS, AstFactory.identifier3("a"))); |
| 1423 } |
| 1424 |
| 1425 void test_visitPropertyAccess() { |
| 1426 _assertClone(AstFactory.propertyAccess2(AstFactory.identifier3("a"), "b")); |
| 1427 } |
| 1428 |
| 1429 void test_visitRedirectingConstructorInvocation_named() { |
| 1430 _assertClone(AstFactory.redirectingConstructorInvocation2("c")); |
| 1431 } |
| 1432 |
| 1433 void test_visitRedirectingConstructorInvocation_unnamed() { |
| 1434 _assertClone(AstFactory.redirectingConstructorInvocation()); |
| 1435 } |
| 1436 |
| 1437 void test_visitRethrowExpression() { |
| 1438 _assertClone(AstFactory.rethrowExpression()); |
| 1439 } |
| 1440 |
| 1441 void test_visitReturnStatement_expression() { |
| 1442 _assertClone(AstFactory.returnStatement2(AstFactory.identifier3("a"))); |
| 1443 } |
| 1444 |
| 1445 void test_visitReturnStatement_noExpression() { |
| 1446 _assertClone(AstFactory.returnStatement()); |
| 1447 } |
| 1448 |
| 1449 void test_visitScriptTag() { |
| 1450 String scriptTag = "!#/bin/dart.exe"; |
| 1451 _assertClone(AstFactory.scriptTag(scriptTag)); |
| 1452 } |
| 1453 |
| 1454 void test_visitSimpleFormalParameter_keyword() { |
| 1455 _assertClone(AstFactory.simpleFormalParameter(Keyword.VAR, "a")); |
| 1456 } |
| 1457 |
| 1458 void test_visitSimpleFormalParameter_keyword_type() { |
| 1459 _assertClone(AstFactory.simpleFormalParameter2( |
| 1460 Keyword.FINAL, AstFactory.typeName4("A"), "a")); |
| 1461 } |
| 1462 |
| 1463 void test_visitSimpleFormalParameter_type() { |
| 1464 _assertClone( |
| 1465 AstFactory.simpleFormalParameter4(AstFactory.typeName4("A"), "a")); |
| 1466 } |
| 1467 |
| 1468 void test_visitSimpleIdentifier() { |
| 1469 _assertClone(AstFactory.identifier3("a")); |
| 1470 } |
| 1471 |
| 1472 void test_visitSimpleStringLiteral() { |
| 1473 _assertClone(AstFactory.string2("a")); |
| 1474 } |
| 1475 |
| 1476 void test_visitStringInterpolation() { |
| 1477 _assertClone(AstFactory.string([ |
| 1478 AstFactory.interpolationString("'a", "a"), |
| 1479 AstFactory.interpolationExpression(AstFactory.identifier3("e")), |
| 1480 AstFactory.interpolationString("b'", "b") |
| 1481 ])); |
| 1482 } |
| 1483 |
| 1484 void test_visitSuperConstructorInvocation() { |
| 1485 _assertClone(AstFactory.superConstructorInvocation()); |
| 1486 } |
| 1487 |
| 1488 void test_visitSuperConstructorInvocation_named() { |
| 1489 _assertClone(AstFactory.superConstructorInvocation2("c")); |
| 1490 } |
| 1491 |
| 1492 void test_visitSuperExpression() { |
| 1493 _assertClone(AstFactory.superExpression()); |
| 1494 } |
| 1495 |
| 1496 void test_visitSwitchCase_multipleLabels() { |
| 1497 _assertClone(AstFactory.switchCase2( |
| 1498 [AstFactory.label2("l1"), AstFactory.label2("l2")], |
| 1499 AstFactory.identifier3("a"), |
| 1500 [AstFactory.block()])); |
| 1501 } |
| 1502 |
| 1503 void test_visitSwitchCase_multipleStatements() { |
| 1504 _assertClone(AstFactory.switchCase( |
| 1505 AstFactory.identifier3("a"), [AstFactory.block(), AstFactory.block()])); |
| 1506 } |
| 1507 |
| 1508 void test_visitSwitchCase_noLabels() { |
| 1509 _assertClone(AstFactory.switchCase( |
| 1510 AstFactory.identifier3("a"), [AstFactory.block()])); |
| 1511 } |
| 1512 |
| 1513 void test_visitSwitchCase_singleLabel() { |
| 1514 _assertClone(AstFactory.switchCase2([AstFactory.label2("l1")], |
| 1515 AstFactory.identifier3("a"), [AstFactory.block()])); |
| 1516 } |
| 1517 |
| 1518 void test_visitSwitchDefault_multipleLabels() { |
| 1519 _assertClone(AstFactory.switchDefault( |
| 1520 [AstFactory.label2("l1"), AstFactory.label2("l2")], |
| 1521 [AstFactory.block()])); |
| 1522 } |
| 1523 |
| 1524 void test_visitSwitchDefault_multipleStatements() { |
| 1525 _assertClone( |
| 1526 AstFactory.switchDefault2([AstFactory.block(), AstFactory.block()])); |
| 1527 } |
| 1528 |
| 1529 void test_visitSwitchDefault_noLabels() { |
| 1530 _assertClone(AstFactory.switchDefault2([AstFactory.block()])); |
| 1531 } |
| 1532 |
| 1533 void test_visitSwitchDefault_singleLabel() { |
| 1534 _assertClone(AstFactory.switchDefault( |
| 1535 [AstFactory.label2("l1")], [AstFactory.block()])); |
| 1536 } |
| 1537 |
| 1538 void test_visitSwitchStatement() { |
| 1539 _assertClone(AstFactory.switchStatement(AstFactory.identifier3("a"), [ |
| 1540 AstFactory.switchCase(AstFactory.string2("b"), [AstFactory.block()]), |
| 1541 AstFactory.switchDefault2([AstFactory.block()]) |
| 1542 ])); |
| 1543 } |
| 1544 |
| 1545 void test_visitSymbolLiteral_multiple() { |
| 1546 _assertClone(AstFactory.symbolLiteral(["a", "b", "c"])); |
| 1547 } |
| 1548 |
| 1549 void test_visitSymbolLiteral_single() { |
| 1550 _assertClone(AstFactory.symbolLiteral(["a"])); |
| 1551 } |
| 1552 |
| 1553 void test_visitThisExpression() { |
| 1554 _assertClone(AstFactory.thisExpression()); |
| 1555 } |
| 1556 |
| 1557 void test_visitThrowStatement() { |
| 1558 _assertClone(AstFactory.throwExpression2(AstFactory.identifier3("e"))); |
| 1559 } |
| 1560 |
| 1561 void test_visitTopLevelVariableDeclaration_multiple() { |
| 1562 _assertClone(AstFactory.topLevelVariableDeclaration2( |
| 1563 Keyword.VAR, [AstFactory.variableDeclaration("a")])); |
| 1564 } |
| 1565 |
| 1566 void test_visitTopLevelVariableDeclaration_single() { |
| 1567 _assertClone(AstFactory.topLevelVariableDeclaration2(Keyword.VAR, [ |
| 1568 AstFactory.variableDeclaration("a"), |
| 1569 AstFactory.variableDeclaration("b") |
| 1570 ])); |
| 1571 } |
| 1572 |
| 1573 void test_visitTryStatement_catch() { |
| 1574 _assertClone(AstFactory.tryStatement2(AstFactory.block(), |
| 1575 [AstFactory.catchClause3(AstFactory.typeName4("E"))])); |
| 1576 } |
| 1577 |
| 1578 void test_visitTryStatement_catches() { |
| 1579 _assertClone(AstFactory.tryStatement2(AstFactory.block(), [ |
| 1580 AstFactory.catchClause3(AstFactory.typeName4("E")), |
| 1581 AstFactory.catchClause3(AstFactory.typeName4("F")) |
| 1582 ])); |
| 1583 } |
| 1584 |
| 1585 void test_visitTryStatement_catchFinally() { |
| 1586 _assertClone(AstFactory.tryStatement3( |
| 1587 AstFactory.block(), |
| 1588 [AstFactory.catchClause3(AstFactory.typeName4("E"))], |
| 1589 AstFactory.block())); |
| 1590 } |
| 1591 |
| 1592 void test_visitTryStatement_finally() { |
| 1593 _assertClone( |
| 1594 AstFactory.tryStatement(AstFactory.block(), AstFactory.block())); |
| 1595 } |
| 1596 |
| 1597 void test_visitTypeArgumentList_multiple() { |
| 1598 _assertClone(AstFactory.typeArgumentList( |
| 1599 [AstFactory.typeName4("E"), AstFactory.typeName4("F")])); |
| 1600 } |
| 1601 |
| 1602 void test_visitTypeArgumentList_single() { |
| 1603 _assertClone(AstFactory.typeArgumentList([AstFactory.typeName4("E")])); |
| 1604 } |
| 1605 |
| 1606 void test_visitTypeName_multipleArgs() { |
| 1607 _assertClone(AstFactory.typeName4( |
| 1608 "C", [AstFactory.typeName4("D"), AstFactory.typeName4("E")])); |
| 1609 } |
| 1610 |
| 1611 void test_visitTypeName_nestedArg() { |
| 1612 _assertClone(AstFactory.typeName4("C", [ |
| 1613 AstFactory.typeName4("D", [AstFactory.typeName4("E")]) |
| 1614 ])); |
| 1615 } |
| 1616 |
| 1617 void test_visitTypeName_noArgs() { |
| 1618 _assertClone(AstFactory.typeName4("C")); |
| 1619 } |
| 1620 |
| 1621 void test_visitTypeName_singleArg() { |
| 1622 _assertClone(AstFactory.typeName4("C", [AstFactory.typeName4("D")])); |
| 1623 } |
| 1624 |
| 1625 void test_visitTypeParameter_withExtends() { |
| 1626 _assertClone(AstFactory.typeParameter2("E", AstFactory.typeName4("C"))); |
| 1627 } |
| 1628 |
| 1629 void test_visitTypeParameter_withMetadata() { |
| 1630 TypeParameter parameter = AstFactory.typeParameter("E"); |
| 1631 parameter.metadata |
| 1632 .add(AstFactory.annotation(AstFactory.identifier3("deprecated"))); |
| 1633 _assertClone(parameter); |
| 1634 } |
| 1635 |
| 1636 void test_visitTypeParameter_withoutExtends() { |
| 1637 _assertClone(AstFactory.typeParameter("E")); |
| 1638 } |
| 1639 |
| 1640 void test_visitTypeParameterList_multiple() { |
| 1641 _assertClone(AstFactory.typeParameterList(["E", "F"])); |
| 1642 } |
| 1643 |
| 1644 void test_visitTypeParameterList_single() { |
| 1645 _assertClone(AstFactory.typeParameterList(["E"])); |
| 1646 } |
| 1647 |
| 1648 void test_visitVariableDeclaration_initialized() { |
| 1649 _assertClone( |
| 1650 AstFactory.variableDeclaration2("a", AstFactory.identifier3("b"))); |
| 1651 } |
| 1652 |
| 1653 void test_visitVariableDeclaration_uninitialized() { |
| 1654 _assertClone(AstFactory.variableDeclaration("a")); |
| 1655 } |
| 1656 |
| 1657 void test_visitVariableDeclarationList_const_type() { |
| 1658 _assertClone(AstFactory.variableDeclarationList( |
| 1659 Keyword.CONST, AstFactory.typeName4("C"), [ |
| 1660 AstFactory.variableDeclaration("a"), |
| 1661 AstFactory.variableDeclaration("b") |
| 1662 ])); |
| 1663 } |
| 1664 |
| 1665 void test_visitVariableDeclarationList_final_noType() { |
| 1666 _assertClone(AstFactory.variableDeclarationList2(Keyword.FINAL, [ |
| 1667 AstFactory.variableDeclaration("a"), |
| 1668 AstFactory.variableDeclaration("b") |
| 1669 ])); |
| 1670 } |
| 1671 |
| 1672 void test_visitVariableDeclarationList_final_withMetadata() { |
| 1673 VariableDeclarationList declarationList = AstFactory |
| 1674 .variableDeclarationList2(Keyword.FINAL, [ |
| 1675 AstFactory.variableDeclaration("a"), |
| 1676 AstFactory.variableDeclaration("b") |
| 1677 ]); |
| 1678 declarationList.metadata |
| 1679 .add(AstFactory.annotation(AstFactory.identifier3("deprecated"))); |
| 1680 _assertClone(declarationList); |
| 1681 } |
| 1682 |
| 1683 void test_visitVariableDeclarationList_type() { |
| 1684 _assertClone(AstFactory.variableDeclarationList( |
| 1685 null, AstFactory.typeName4("C"), [ |
| 1686 AstFactory.variableDeclaration("a"), |
| 1687 AstFactory.variableDeclaration("b") |
| 1688 ])); |
| 1689 } |
| 1690 |
| 1691 void test_visitVariableDeclarationList_var() { |
| 1692 _assertClone(AstFactory.variableDeclarationList2(Keyword.VAR, [ |
| 1693 AstFactory.variableDeclaration("a"), |
| 1694 AstFactory.variableDeclaration("b") |
| 1695 ])); |
| 1696 } |
| 1697 |
| 1698 void test_visitVariableDeclarationStatement() { |
| 1699 _assertClone(AstFactory.variableDeclarationStatement(null, |
| 1700 AstFactory.typeName4("C"), [AstFactory.variableDeclaration("c")])); |
| 1701 } |
| 1702 |
| 1703 void test_visitWhileStatement() { |
| 1704 _assertClone(AstFactory.whileStatement( |
| 1705 AstFactory.identifier3("c"), AstFactory.block())); |
| 1706 } |
| 1707 |
| 1708 void test_visitWithClause_multiple() { |
| 1709 _assertClone(AstFactory.withClause([ |
| 1710 AstFactory.typeName4("A"), |
| 1711 AstFactory.typeName4("B"), |
| 1712 AstFactory.typeName4("C") |
| 1713 ])); |
| 1714 } |
| 1715 |
| 1716 void test_visitWithClause_single() { |
| 1717 _assertClone(AstFactory.withClause([AstFactory.typeName4("A")])); |
| 1718 } |
| 1719 |
| 1720 void test_visitYieldStatement() { |
| 1721 _assertClone(AstFactory.yieldStatement(AstFactory.identifier3("A"))); |
| 1722 } |
| 1723 |
| 1724 /** |
| 1725 * Assert that an `AstCloner` will produce the expected AST structure when |
| 1726 * visiting the given [node]. |
| 1727 * |
| 1728 * @param node the AST node being visited to produce the cloned structure |
| 1729 * @throws AFE if the visitor does not produce the expected source for the giv
en node |
| 1730 */ |
| 1731 void _assertClone(AstNode node) { |
| 1732 AstNode clone = node.accept(new AstCloner()); |
| 1733 AstCloneComparator comparitor = new AstCloneComparator(false); |
| 1734 if (!comparitor.isEqualNodes(node, clone)) { |
| 1735 fail("Failed to clone ${node.runtimeType.toString()}"); |
| 1736 } |
| 1737 |
| 1738 clone = node.accept(new AstCloner(true)); |
| 1739 comparitor = new AstCloneComparator(true); |
| 1740 if (!comparitor.isEqualNodes(node, clone)) { |
| 1741 fail("Failed to clone ${node.runtimeType.toString()}"); |
| 1742 } |
| 1743 } |
| 1744 } |
| 1745 |
| 1746 @reflectiveTest |
| 1747 class BooleanArrayTest { |
| 1748 void test_get_negative() { |
| 1749 try { |
| 1750 BooleanArray.get(0, -1); |
| 1751 fail("Expected "); |
| 1752 } on RangeError { |
| 1753 // Expected |
| 1754 } |
| 1755 } |
| 1756 |
| 1757 void test_get_tooBig() { |
| 1758 try { |
| 1759 BooleanArray.get(0, 31); |
| 1760 fail("Expected "); |
| 1761 } on RangeError { |
| 1762 // Expected |
| 1763 } |
| 1764 } |
| 1765 |
| 1766 void test_get_valid() { |
| 1767 expect(BooleanArray.get(0, 0), false); |
| 1768 expect(BooleanArray.get(1, 0), true); |
| 1769 expect(BooleanArray.get(0, 30), false); |
| 1770 expect(BooleanArray.get(1 << 30, 30), true); |
| 1771 } |
| 1772 |
| 1773 void test_set_negative() { |
| 1774 try { |
| 1775 BooleanArray.set(0, -1, true); |
| 1776 fail("Expected "); |
| 1777 } on RangeError { |
| 1778 // Expected |
| 1779 } |
| 1780 } |
| 1781 |
| 1782 void test_set_tooBig() { |
| 1783 try { |
| 1784 BooleanArray.set(0, 32, true); |
| 1785 fail("Expected "); |
| 1786 } on RangeError { |
| 1787 // Expected |
| 1788 } |
| 1789 } |
| 1790 |
| 1791 void test_set_valueChanging() { |
| 1792 expect(BooleanArray.set(0, 0, true), 1); |
| 1793 expect(BooleanArray.set(1, 0, false), 0); |
| 1794 expect(BooleanArray.set(0, 30, true), 1 << 30); |
| 1795 expect(BooleanArray.set(1 << 30, 30, false), 0); |
| 1796 } |
| 1797 |
| 1798 void test_set_valuePreserving() { |
| 1799 expect(BooleanArray.set(0, 0, false), 0); |
| 1800 expect(BooleanArray.set(1, 0, true), 1); |
| 1801 expect(BooleanArray.set(0, 30, false), 0); |
| 1802 expect(BooleanArray.set(1 << 30, 30, true), 1 << 30); |
| 1803 } |
| 1804 } |
| 1805 |
| 1806 @reflectiveTest |
| 1807 class DirectedGraphTest extends EngineTestCase { |
| 1808 void test_addEdge() { |
| 1809 DirectedGraph<DirectedGraphTest_Node> graph = |
| 1810 new DirectedGraph<DirectedGraphTest_Node>(); |
| 1811 expect(graph.isEmpty, isTrue); |
| 1812 graph.addEdge(new DirectedGraphTest_Node(), new DirectedGraphTest_Node()); |
| 1813 expect(graph.isEmpty, isFalse); |
| 1814 } |
| 1815 |
| 1816 void test_addNode() { |
| 1817 DirectedGraph<DirectedGraphTest_Node> graph = |
| 1818 new DirectedGraph<DirectedGraphTest_Node>(); |
| 1819 expect(graph.isEmpty, isTrue); |
| 1820 graph.addNode(new DirectedGraphTest_Node()); |
| 1821 expect(graph.isEmpty, isFalse); |
| 1822 } |
| 1823 |
| 1824 void test_containsPath_noCycles() { |
| 1825 DirectedGraphTest_Node node1 = new DirectedGraphTest_Node(); |
| 1826 DirectedGraphTest_Node node2 = new DirectedGraphTest_Node(); |
| 1827 DirectedGraphTest_Node node3 = new DirectedGraphTest_Node(); |
| 1828 DirectedGraph<DirectedGraphTest_Node> graph = |
| 1829 new DirectedGraph<DirectedGraphTest_Node>(); |
| 1830 graph.addEdge(node1, node2); |
| 1831 graph.addEdge(node2, node3); |
| 1832 expect(graph.containsPath(node1, node1), isTrue); |
| 1833 expect(graph.containsPath(node1, node2), isTrue); |
| 1834 expect(graph.containsPath(node1, node3), isTrue); |
| 1835 expect(graph.containsPath(node2, node1), isFalse); |
| 1836 expect(graph.containsPath(node2, node2), isTrue); |
| 1837 expect(graph.containsPath(node2, node3), isTrue); |
| 1838 expect(graph.containsPath(node3, node1), isFalse); |
| 1839 expect(graph.containsPath(node3, node2), isFalse); |
| 1840 expect(graph.containsPath(node3, node3), isTrue); |
| 1841 } |
| 1842 |
| 1843 void test_containsPath_withCycles() { |
| 1844 DirectedGraphTest_Node node1 = new DirectedGraphTest_Node(); |
| 1845 DirectedGraphTest_Node node2 = new DirectedGraphTest_Node(); |
| 1846 DirectedGraphTest_Node node3 = new DirectedGraphTest_Node(); |
| 1847 DirectedGraphTest_Node node4 = new DirectedGraphTest_Node(); |
| 1848 DirectedGraph<DirectedGraphTest_Node> graph = |
| 1849 new DirectedGraph<DirectedGraphTest_Node>(); |
| 1850 graph.addEdge(node1, node2); |
| 1851 graph.addEdge(node2, node1); |
| 1852 graph.addEdge(node1, node3); |
| 1853 graph.addEdge(node3, node4); |
| 1854 graph.addEdge(node4, node3); |
| 1855 expect(graph.containsPath(node1, node1), isTrue); |
| 1856 expect(graph.containsPath(node1, node2), isTrue); |
| 1857 expect(graph.containsPath(node1, node3), isTrue); |
| 1858 expect(graph.containsPath(node1, node4), isTrue); |
| 1859 expect(graph.containsPath(node2, node1), isTrue); |
| 1860 expect(graph.containsPath(node2, node2), isTrue); |
| 1861 expect(graph.containsPath(node2, node3), isTrue); |
| 1862 expect(graph.containsPath(node2, node4), isTrue); |
| 1863 expect(graph.containsPath(node3, node1), isFalse); |
| 1864 expect(graph.containsPath(node3, node2), isFalse); |
| 1865 expect(graph.containsPath(node3, node3), isTrue); |
| 1866 expect(graph.containsPath(node3, node4), isTrue); |
| 1867 expect(graph.containsPath(node4, node1), isFalse); |
| 1868 expect(graph.containsPath(node4, node2), isFalse); |
| 1869 expect(graph.containsPath(node4, node3), isTrue); |
| 1870 expect(graph.containsPath(node4, node4), isTrue); |
| 1871 } |
| 1872 |
| 1873 void test_creation() { |
| 1874 expect(new DirectedGraph<DirectedGraphTest_Node>(), isNotNull); |
| 1875 } |
| 1876 |
| 1877 void test_findCycleContaining_complexCycle() { |
| 1878 // Two overlapping loops: (1, 2, 3) and (3, 4, 5) |
| 1879 DirectedGraphTest_Node node1 = new DirectedGraphTest_Node(); |
| 1880 DirectedGraphTest_Node node2 = new DirectedGraphTest_Node(); |
| 1881 DirectedGraphTest_Node node3 = new DirectedGraphTest_Node(); |
| 1882 DirectedGraphTest_Node node4 = new DirectedGraphTest_Node(); |
| 1883 DirectedGraphTest_Node node5 = new DirectedGraphTest_Node(); |
| 1884 DirectedGraph<DirectedGraphTest_Node> graph = |
| 1885 new DirectedGraph<DirectedGraphTest_Node>(); |
| 1886 graph.addEdge(node1, node2); |
| 1887 graph.addEdge(node2, node3); |
| 1888 graph.addEdge(node3, node1); |
| 1889 graph.addEdge(node3, node4); |
| 1890 graph.addEdge(node4, node5); |
| 1891 graph.addEdge(node5, node3); |
| 1892 List<DirectedGraphTest_Node> cycle = graph.findCycleContaining(node1); |
| 1893 expect(cycle, hasLength(5)); |
| 1894 expect(cycle.contains(node1), isTrue); |
| 1895 expect(cycle.contains(node2), isTrue); |
| 1896 expect(cycle.contains(node3), isTrue); |
| 1897 expect(cycle.contains(node4), isTrue); |
| 1898 expect(cycle.contains(node5), isTrue); |
| 1899 } |
| 1900 |
| 1901 void test_findCycleContaining_cycle() { |
| 1902 DirectedGraphTest_Node node1 = new DirectedGraphTest_Node(); |
| 1903 DirectedGraphTest_Node node2 = new DirectedGraphTest_Node(); |
| 1904 DirectedGraphTest_Node node3 = new DirectedGraphTest_Node(); |
| 1905 DirectedGraph<DirectedGraphTest_Node> graph = |
| 1906 new DirectedGraph<DirectedGraphTest_Node>(); |
| 1907 graph.addEdge(node1, node2); |
| 1908 graph.addEdge(node2, node3); |
| 1909 graph.addEdge(node2, new DirectedGraphTest_Node()); |
| 1910 graph.addEdge(node3, node1); |
| 1911 graph.addEdge(node3, new DirectedGraphTest_Node()); |
| 1912 List<DirectedGraphTest_Node> cycle = graph.findCycleContaining(node1); |
| 1913 expect(cycle, hasLength(3)); |
| 1914 expect(cycle.contains(node1), isTrue); |
| 1915 expect(cycle.contains(node2), isTrue); |
| 1916 expect(cycle.contains(node3), isTrue); |
| 1917 } |
| 1918 |
| 1919 void test_findCycleContaining_notInGraph() { |
| 1920 DirectedGraphTest_Node node = new DirectedGraphTest_Node(); |
| 1921 DirectedGraph<DirectedGraphTest_Node> graph = |
| 1922 new DirectedGraph<DirectedGraphTest_Node>(); |
| 1923 List<DirectedGraphTest_Node> cycle = graph.findCycleContaining(node); |
| 1924 expect(cycle, hasLength(1)); |
| 1925 expect(cycle[0], node); |
| 1926 } |
| 1927 |
| 1928 void test_findCycleContaining_null() { |
| 1929 DirectedGraph<DirectedGraphTest_Node> graph = |
| 1930 new DirectedGraph<DirectedGraphTest_Node>(); |
| 1931 try { |
| 1932 graph.findCycleContaining(null); |
| 1933 fail("Expected IllegalArgumentException"); |
| 1934 } on IllegalArgumentException { |
| 1935 // Expected |
| 1936 } |
| 1937 } |
| 1938 |
| 1939 void test_findCycleContaining_singleton() { |
| 1940 DirectedGraphTest_Node node1 = new DirectedGraphTest_Node(); |
| 1941 DirectedGraphTest_Node node2 = new DirectedGraphTest_Node(); |
| 1942 DirectedGraphTest_Node node3 = new DirectedGraphTest_Node(); |
| 1943 DirectedGraph<DirectedGraphTest_Node> graph = |
| 1944 new DirectedGraph<DirectedGraphTest_Node>(); |
| 1945 graph.addEdge(node1, node2); |
| 1946 graph.addEdge(node2, node3); |
| 1947 List<DirectedGraphTest_Node> cycle = graph.findCycleContaining(node1); |
| 1948 expect(cycle, hasLength(1)); |
| 1949 expect(cycle[0], node1); |
| 1950 } |
| 1951 |
| 1952 void test_getNodeCount() { |
| 1953 DirectedGraphTest_Node node1 = new DirectedGraphTest_Node(); |
| 1954 DirectedGraphTest_Node node2 = new DirectedGraphTest_Node(); |
| 1955 DirectedGraph<DirectedGraphTest_Node> graph = |
| 1956 new DirectedGraph<DirectedGraphTest_Node>(); |
| 1957 expect(graph.nodeCount, 0); |
| 1958 graph.addNode(node1); |
| 1959 expect(graph.nodeCount, 1); |
| 1960 graph.addNode(node2); |
| 1961 expect(graph.nodeCount, 2); |
| 1962 graph.removeNode(node1); |
| 1963 expect(graph.nodeCount, 1); |
| 1964 } |
| 1965 |
| 1966 void test_getTails() { |
| 1967 DirectedGraphTest_Node node1 = new DirectedGraphTest_Node(); |
| 1968 DirectedGraphTest_Node node2 = new DirectedGraphTest_Node(); |
| 1969 DirectedGraphTest_Node node3 = new DirectedGraphTest_Node(); |
| 1970 DirectedGraph<DirectedGraphTest_Node> graph = |
| 1971 new DirectedGraph<DirectedGraphTest_Node>(); |
| 1972 expect(graph.getTails(node1), hasLength(0)); |
| 1973 graph.addEdge(node1, node2); |
| 1974 expect(graph.getTails(node1), hasLength(1)); |
| 1975 graph.addEdge(node1, node3); |
| 1976 expect(graph.getTails(node1), hasLength(2)); |
| 1977 } |
| 1978 |
| 1979 void test_removeAllNodes() { |
| 1980 DirectedGraphTest_Node node1 = new DirectedGraphTest_Node(); |
| 1981 DirectedGraphTest_Node node2 = new DirectedGraphTest_Node(); |
| 1982 List<DirectedGraphTest_Node> nodes = new List<DirectedGraphTest_Node>(); |
| 1983 nodes.add(node1); |
| 1984 nodes.add(node2); |
| 1985 DirectedGraph<DirectedGraphTest_Node> graph = |
| 1986 new DirectedGraph<DirectedGraphTest_Node>(); |
| 1987 graph.addEdge(node1, node2); |
| 1988 graph.addEdge(node2, node1); |
| 1989 expect(graph.isEmpty, isFalse); |
| 1990 graph.removeAllNodes(nodes); |
| 1991 expect(graph.isEmpty, isTrue); |
| 1992 } |
| 1993 |
| 1994 void test_removeEdge() { |
| 1995 DirectedGraphTest_Node node1 = new DirectedGraphTest_Node(); |
| 1996 DirectedGraphTest_Node node2 = new DirectedGraphTest_Node(); |
| 1997 DirectedGraphTest_Node node3 = new DirectedGraphTest_Node(); |
| 1998 DirectedGraph<DirectedGraphTest_Node> graph = |
| 1999 new DirectedGraph<DirectedGraphTest_Node>(); |
| 2000 graph.addEdge(node1, node2); |
| 2001 graph.addEdge(node1, node3); |
| 2002 expect(graph.getTails(node1), hasLength(2)); |
| 2003 graph.removeEdge(node1, node2); |
| 2004 expect(graph.getTails(node1), hasLength(1)); |
| 2005 } |
| 2006 |
| 2007 void test_removeNode() { |
| 2008 DirectedGraphTest_Node node1 = new DirectedGraphTest_Node(); |
| 2009 DirectedGraphTest_Node node2 = new DirectedGraphTest_Node(); |
| 2010 DirectedGraphTest_Node node3 = new DirectedGraphTest_Node(); |
| 2011 DirectedGraph<DirectedGraphTest_Node> graph = |
| 2012 new DirectedGraph<DirectedGraphTest_Node>(); |
| 2013 graph.addEdge(node1, node2); |
| 2014 graph.addEdge(node1, node3); |
| 2015 expect(graph.getTails(node1), hasLength(2)); |
| 2016 graph.removeNode(node2); |
| 2017 expect(graph.getTails(node1), hasLength(1)); |
| 2018 } |
| 2019 |
| 2020 void test_removeSink() { |
| 2021 DirectedGraphTest_Node node1 = new DirectedGraphTest_Node(); |
| 2022 DirectedGraphTest_Node node2 = new DirectedGraphTest_Node(); |
| 2023 DirectedGraph<DirectedGraphTest_Node> graph = |
| 2024 new DirectedGraph<DirectedGraphTest_Node>(); |
| 2025 graph.addEdge(node1, node2); |
| 2026 expect(graph.removeSink(), same(node2)); |
| 2027 expect(graph.removeSink(), same(node1)); |
| 2028 expect(graph.isEmpty, isTrue); |
| 2029 } |
| 2030 |
| 2031 void test_topologicalSort_noCycles() { |
| 2032 DirectedGraphTest_Node node1 = new DirectedGraphTest_Node(); |
| 2033 DirectedGraphTest_Node node2 = new DirectedGraphTest_Node(); |
| 2034 DirectedGraphTest_Node node3 = new DirectedGraphTest_Node(); |
| 2035 DirectedGraph<DirectedGraphTest_Node> graph = |
| 2036 new DirectedGraph<DirectedGraphTest_Node>(); |
| 2037 graph.addEdge(node1, node2); |
| 2038 graph.addEdge(node1, node3); |
| 2039 graph.addEdge(node2, node3); |
| 2040 List<List<DirectedGraphTest_Node>> topologicalSort = |
| 2041 graph.computeTopologicalSort(); |
| 2042 expect(topologicalSort, hasLength(3)); |
| 2043 expect(topologicalSort[0], hasLength(1)); |
| 2044 expect(topologicalSort[0][0], node3); |
| 2045 expect(topologicalSort[1], hasLength(1)); |
| 2046 expect(topologicalSort[1][0], node2); |
| 2047 expect(topologicalSort[2], hasLength(1)); |
| 2048 expect(topologicalSort[2][0], node1); |
| 2049 } |
| 2050 |
| 2051 void test_topologicalSort_withCycles() { |
| 2052 DirectedGraphTest_Node node1 = new DirectedGraphTest_Node(); |
| 2053 DirectedGraphTest_Node node2 = new DirectedGraphTest_Node(); |
| 2054 DirectedGraphTest_Node node3 = new DirectedGraphTest_Node(); |
| 2055 DirectedGraphTest_Node node4 = new DirectedGraphTest_Node(); |
| 2056 DirectedGraph<DirectedGraphTest_Node> graph = |
| 2057 new DirectedGraph<DirectedGraphTest_Node>(); |
| 2058 graph.addEdge(node1, node2); |
| 2059 graph.addEdge(node2, node1); |
| 2060 graph.addEdge(node1, node3); |
| 2061 graph.addEdge(node3, node4); |
| 2062 graph.addEdge(node4, node3); |
| 2063 List<List<DirectedGraphTest_Node>> topologicalSort = |
| 2064 graph.computeTopologicalSort(); |
| 2065 expect(topologicalSort, hasLength(2)); |
| 2066 expect(topologicalSort[0], unorderedEquals([node3, node4])); |
| 2067 expect(topologicalSort[1], unorderedEquals([node1, node2])); |
| 2068 } |
| 2069 } |
| 2070 |
| 2071 /** |
| 2072 * Instances of the class `Node` represent simple nodes used for testing purpose
s. |
| 2073 */ |
| 2074 class DirectedGraphTest_Node {} |
| 2075 |
| 2076 class Getter_NodeReplacerTest_test_annotation |
| 2077 implements NodeReplacerTest_Getter { |
| 2078 @override |
| 2079 ArgumentList get(Annotation node) => node.arguments; |
| 2080 } |
| 2081 |
| 2082 class Getter_NodeReplacerTest_test_annotation_2 |
| 2083 implements NodeReplacerTest_Getter { |
| 2084 @override |
| 2085 Identifier get(Annotation node) => node.name; |
| 2086 } |
| 2087 |
| 2088 class Getter_NodeReplacerTest_test_annotation_3 |
| 2089 implements NodeReplacerTest_Getter { |
| 2090 @override |
| 2091 SimpleIdentifier get(Annotation node) => node.constructorName; |
| 2092 } |
| 2093 |
| 2094 class Getter_NodeReplacerTest_test_asExpression |
| 2095 implements NodeReplacerTest_Getter { |
| 2096 @override |
| 2097 TypeName get(AsExpression node) => node.type; |
| 2098 } |
| 2099 |
| 2100 class Getter_NodeReplacerTest_test_asExpression_2 |
| 2101 implements NodeReplacerTest_Getter { |
| 2102 @override |
| 2103 Expression get(AsExpression node) => node.expression; |
| 2104 } |
| 2105 |
| 2106 class Getter_NodeReplacerTest_test_assertStatement |
| 2107 implements NodeReplacerTest_Getter { |
| 2108 @override |
| 2109 Expression get(AssertStatement node) => node.condition; |
| 2110 } |
| 2111 |
| 2112 class Getter_NodeReplacerTest_test_assignmentExpression |
| 2113 implements NodeReplacerTest_Getter { |
| 2114 @override |
| 2115 Expression get(AssignmentExpression node) => node.rightHandSide; |
| 2116 } |
| 2117 |
| 2118 class Getter_NodeReplacerTest_test_assignmentExpression_2 |
| 2119 implements NodeReplacerTest_Getter { |
| 2120 @override |
| 2121 Expression get(AssignmentExpression node) => node.leftHandSide; |
| 2122 } |
| 2123 |
| 2124 class Getter_NodeReplacerTest_test_awaitExpression |
| 2125 implements NodeReplacerTest_Getter { |
| 2126 @override |
| 2127 Expression get(AwaitExpression node) => node.expression; |
| 2128 } |
| 2129 |
| 2130 class Getter_NodeReplacerTest_test_binaryExpression |
| 2131 implements NodeReplacerTest_Getter { |
| 2132 @override |
| 2133 Expression get(BinaryExpression node) => node.leftOperand; |
| 2134 } |
| 2135 |
| 2136 class Getter_NodeReplacerTest_test_binaryExpression_2 |
| 2137 implements NodeReplacerTest_Getter { |
| 2138 @override |
| 2139 Expression get(BinaryExpression node) => node.rightOperand; |
| 2140 } |
| 2141 |
| 2142 class Getter_NodeReplacerTest_test_blockFunctionBody |
| 2143 implements NodeReplacerTest_Getter { |
| 2144 @override |
| 2145 Block get(BlockFunctionBody node) => node.block; |
| 2146 } |
| 2147 |
| 2148 class Getter_NodeReplacerTest_test_breakStatement |
| 2149 implements NodeReplacerTest_Getter { |
| 2150 @override |
| 2151 SimpleIdentifier get(BreakStatement node) => node.label; |
| 2152 } |
| 2153 |
| 2154 class Getter_NodeReplacerTest_test_cascadeExpression |
| 2155 implements NodeReplacerTest_Getter { |
| 2156 @override |
| 2157 Expression get(CascadeExpression node) => node.target; |
| 2158 } |
| 2159 |
| 2160 class Getter_NodeReplacerTest_test_catchClause |
| 2161 implements NodeReplacerTest_Getter { |
| 2162 @override |
| 2163 SimpleIdentifier get(CatchClause node) => node.stackTraceParameter; |
| 2164 } |
| 2165 |
| 2166 class Getter_NodeReplacerTest_test_catchClause_2 |
| 2167 implements NodeReplacerTest_Getter { |
| 2168 @override |
| 2169 SimpleIdentifier get(CatchClause node) => node.exceptionParameter; |
| 2170 } |
| 2171 |
| 2172 class Getter_NodeReplacerTest_test_catchClause_3 |
| 2173 implements NodeReplacerTest_Getter { |
| 2174 @override |
| 2175 TypeName get(CatchClause node) => node.exceptionType; |
| 2176 } |
| 2177 |
| 2178 class Getter_NodeReplacerTest_test_classDeclaration |
| 2179 implements NodeReplacerTest_Getter { |
| 2180 @override |
| 2181 ImplementsClause get(ClassDeclaration node) => node.implementsClause; |
| 2182 } |
| 2183 |
| 2184 class Getter_NodeReplacerTest_test_classDeclaration_2 |
| 2185 implements NodeReplacerTest_Getter { |
| 2186 @override |
| 2187 WithClause get(ClassDeclaration node) => node.withClause; |
| 2188 } |
| 2189 |
| 2190 class Getter_NodeReplacerTest_test_classDeclaration_3 |
| 2191 implements NodeReplacerTest_Getter { |
| 2192 @override |
| 2193 NativeClause get(ClassDeclaration node) => node.nativeClause; |
| 2194 } |
| 2195 |
| 2196 class Getter_NodeReplacerTest_test_classDeclaration_4 |
| 2197 implements NodeReplacerTest_Getter { |
| 2198 @override |
| 2199 ExtendsClause get(ClassDeclaration node) => node.extendsClause; |
| 2200 } |
| 2201 |
| 2202 class Getter_NodeReplacerTest_test_classDeclaration_5 |
| 2203 implements NodeReplacerTest_Getter { |
| 2204 @override |
| 2205 TypeParameterList get(ClassDeclaration node) => node.typeParameters; |
| 2206 } |
| 2207 |
| 2208 class Getter_NodeReplacerTest_test_classDeclaration_6 |
| 2209 implements NodeReplacerTest_Getter { |
| 2210 @override |
| 2211 SimpleIdentifier get(ClassDeclaration node) => node.name; |
| 2212 } |
| 2213 |
| 2214 class Getter_NodeReplacerTest_test_classTypeAlias |
| 2215 implements NodeReplacerTest_Getter { |
| 2216 @override |
| 2217 TypeName get(ClassTypeAlias node) => node.superclass; |
| 2218 } |
| 2219 |
| 2220 class Getter_NodeReplacerTest_test_classTypeAlias_2 |
| 2221 implements NodeReplacerTest_Getter { |
| 2222 @override |
| 2223 ImplementsClause get(ClassTypeAlias node) => node.implementsClause; |
| 2224 } |
| 2225 |
| 2226 class Getter_NodeReplacerTest_test_classTypeAlias_3 |
| 2227 implements NodeReplacerTest_Getter { |
| 2228 @override |
| 2229 WithClause get(ClassTypeAlias node) => node.withClause; |
| 2230 } |
| 2231 |
| 2232 class Getter_NodeReplacerTest_test_classTypeAlias_4 |
| 2233 implements NodeReplacerTest_Getter { |
| 2234 @override |
| 2235 SimpleIdentifier get(ClassTypeAlias node) => node.name; |
| 2236 } |
| 2237 |
| 2238 class Getter_NodeReplacerTest_test_classTypeAlias_5 |
| 2239 implements NodeReplacerTest_Getter { |
| 2240 @override |
| 2241 TypeParameterList get(ClassTypeAlias node) => node.typeParameters; |
| 2242 } |
| 2243 |
| 2244 class Getter_NodeReplacerTest_test_commentReference |
| 2245 implements NodeReplacerTest_Getter { |
| 2246 @override |
| 2247 Identifier get(CommentReference node) => node.identifier; |
| 2248 } |
| 2249 |
| 2250 class Getter_NodeReplacerTest_test_compilationUnit |
| 2251 implements NodeReplacerTest_Getter { |
| 2252 @override |
| 2253 ScriptTag get(CompilationUnit node) => node.scriptTag; |
| 2254 } |
| 2255 |
| 2256 class Getter_NodeReplacerTest_test_conditionalExpression |
| 2257 implements NodeReplacerTest_Getter { |
| 2258 @override |
| 2259 Expression get(ConditionalExpression node) => node.elseExpression; |
| 2260 } |
| 2261 |
| 2262 class Getter_NodeReplacerTest_test_conditionalExpression_2 |
| 2263 implements NodeReplacerTest_Getter { |
| 2264 @override |
| 2265 Expression get(ConditionalExpression node) => node.thenExpression; |
| 2266 } |
| 2267 |
| 2268 class Getter_NodeReplacerTest_test_conditionalExpression_3 |
| 2269 implements NodeReplacerTest_Getter { |
| 2270 @override |
| 2271 Expression get(ConditionalExpression node) => node.condition; |
| 2272 } |
| 2273 |
| 2274 class Getter_NodeReplacerTest_test_constructorDeclaration |
| 2275 implements NodeReplacerTest_Getter { |
| 2276 @override |
| 2277 ConstructorName get(ConstructorDeclaration node) => |
| 2278 node.redirectedConstructor; |
| 2279 } |
| 2280 |
| 2281 class Getter_NodeReplacerTest_test_constructorDeclaration_2 |
| 2282 implements NodeReplacerTest_Getter { |
| 2283 @override |
| 2284 SimpleIdentifier get(ConstructorDeclaration node) => node.name; |
| 2285 } |
| 2286 |
| 2287 class Getter_NodeReplacerTest_test_constructorDeclaration_3 |
| 2288 implements NodeReplacerTest_Getter { |
| 2289 @override |
| 2290 Identifier get(ConstructorDeclaration node) => node.returnType; |
| 2291 } |
| 2292 |
| 2293 class Getter_NodeReplacerTest_test_constructorDeclaration_4 |
| 2294 implements NodeReplacerTest_Getter { |
| 2295 @override |
| 2296 FormalParameterList get(ConstructorDeclaration node) => node.parameters; |
| 2297 } |
| 2298 |
| 2299 class Getter_NodeReplacerTest_test_constructorDeclaration_5 |
| 2300 implements NodeReplacerTest_Getter { |
| 2301 @override |
| 2302 FunctionBody get(ConstructorDeclaration node) => node.body; |
| 2303 } |
| 2304 |
| 2305 class Getter_NodeReplacerTest_test_constructorFieldInitializer |
| 2306 implements NodeReplacerTest_Getter { |
| 2307 @override |
| 2308 SimpleIdentifier get(ConstructorFieldInitializer node) => node.fieldName; |
| 2309 } |
| 2310 |
| 2311 class Getter_NodeReplacerTest_test_constructorFieldInitializer_2 |
| 2312 implements NodeReplacerTest_Getter { |
| 2313 @override |
| 2314 Expression get(ConstructorFieldInitializer node) => node.expression; |
| 2315 } |
| 2316 |
| 2317 class Getter_NodeReplacerTest_test_constructorName |
| 2318 implements NodeReplacerTest_Getter { |
| 2319 @override |
| 2320 TypeName get(ConstructorName node) => node.type; |
| 2321 } |
| 2322 |
| 2323 class Getter_NodeReplacerTest_test_constructorName_2 |
| 2324 implements NodeReplacerTest_Getter { |
| 2325 @override |
| 2326 SimpleIdentifier get(ConstructorName node) => node.name; |
| 2327 } |
| 2328 |
| 2329 class Getter_NodeReplacerTest_test_continueStatement |
| 2330 implements NodeReplacerTest_Getter { |
| 2331 @override |
| 2332 SimpleIdentifier get(ContinueStatement node) => node.label; |
| 2333 } |
| 2334 |
| 2335 class Getter_NodeReplacerTest_test_declaredIdentifier |
| 2336 implements NodeReplacerTest_Getter { |
| 2337 @override |
| 2338 TypeName get(DeclaredIdentifier node) => node.type; |
| 2339 } |
| 2340 |
| 2341 class Getter_NodeReplacerTest_test_declaredIdentifier_2 |
| 2342 implements NodeReplacerTest_Getter { |
| 2343 @override |
| 2344 SimpleIdentifier get(DeclaredIdentifier node) => node.identifier; |
| 2345 } |
| 2346 |
| 2347 class Getter_NodeReplacerTest_test_defaultFormalParameter |
| 2348 implements NodeReplacerTest_Getter { |
| 2349 @override |
| 2350 NormalFormalParameter get(DefaultFormalParameter node) => node.parameter; |
| 2351 } |
| 2352 |
| 2353 class Getter_NodeReplacerTest_test_defaultFormalParameter_2 |
| 2354 implements NodeReplacerTest_Getter { |
| 2355 @override |
| 2356 Expression get(DefaultFormalParameter node) => node.defaultValue; |
| 2357 } |
| 2358 |
| 2359 class Getter_NodeReplacerTest_test_doStatement |
| 2360 implements NodeReplacerTest_Getter { |
| 2361 @override |
| 2362 Expression get(DoStatement node) => node.condition; |
| 2363 } |
| 2364 |
| 2365 class Getter_NodeReplacerTest_test_doStatement_2 |
| 2366 implements NodeReplacerTest_Getter { |
| 2367 @override |
| 2368 Statement get(DoStatement node) => node.body; |
| 2369 } |
| 2370 |
| 2371 class Getter_NodeReplacerTest_test_enumConstantDeclaration |
| 2372 implements NodeReplacerTest_Getter { |
| 2373 @override |
| 2374 SimpleIdentifier get(EnumConstantDeclaration node) => node.name; |
| 2375 } |
| 2376 |
| 2377 class Getter_NodeReplacerTest_test_enumDeclaration |
| 2378 implements NodeReplacerTest_Getter { |
| 2379 @override |
| 2380 SimpleIdentifier get(EnumDeclaration node) => node.name; |
| 2381 } |
| 2382 |
| 2383 class Getter_NodeReplacerTest_test_expressionFunctionBody |
| 2384 implements NodeReplacerTest_Getter { |
| 2385 @override |
| 2386 Expression get(ExpressionFunctionBody node) => node.expression; |
| 2387 } |
| 2388 |
| 2389 class Getter_NodeReplacerTest_test_expressionStatement |
| 2390 implements NodeReplacerTest_Getter { |
| 2391 @override |
| 2392 Expression get(ExpressionStatement node) => node.expression; |
| 2393 } |
| 2394 |
| 2395 class Getter_NodeReplacerTest_test_extendsClause |
| 2396 implements NodeReplacerTest_Getter { |
| 2397 @override |
| 2398 TypeName get(ExtendsClause node) => node.superclass; |
| 2399 } |
| 2400 |
| 2401 class Getter_NodeReplacerTest_test_fieldDeclaration |
| 2402 implements NodeReplacerTest_Getter { |
| 2403 @override |
| 2404 VariableDeclarationList get(FieldDeclaration node) => node.fields; |
| 2405 } |
| 2406 |
| 2407 class Getter_NodeReplacerTest_test_fieldFormalParameter |
| 2408 implements NodeReplacerTest_Getter { |
| 2409 @override |
| 2410 FormalParameterList get(FieldFormalParameter node) => node.parameters; |
| 2411 } |
| 2412 |
| 2413 class Getter_NodeReplacerTest_test_fieldFormalParameter_2 |
| 2414 implements NodeReplacerTest_Getter { |
| 2415 @override |
| 2416 TypeName get(FieldFormalParameter node) => node.type; |
| 2417 } |
| 2418 |
| 2419 class Getter_NodeReplacerTest_test_forEachStatement_withIdentifier |
| 2420 implements NodeReplacerTest_Getter { |
| 2421 @override |
| 2422 Statement get(ForEachStatement node) => node.body; |
| 2423 } |
| 2424 |
| 2425 class Getter_NodeReplacerTest_test_forEachStatement_withIdentifier_2 |
| 2426 implements NodeReplacerTest_Getter { |
| 2427 @override |
| 2428 SimpleIdentifier get(ForEachStatement node) => node.identifier; |
| 2429 } |
| 2430 |
| 2431 class Getter_NodeReplacerTest_test_forEachStatement_withIdentifier_3 |
| 2432 implements NodeReplacerTest_Getter { |
| 2433 @override |
| 2434 Expression get(ForEachStatement node) => node.iterable; |
| 2435 } |
| 2436 |
| 2437 class Getter_NodeReplacerTest_test_forEachStatement_withLoopVariable |
| 2438 implements NodeReplacerTest_Getter { |
| 2439 @override |
| 2440 Expression get(ForEachStatement node) => node.iterable; |
| 2441 } |
| 2442 |
| 2443 class Getter_NodeReplacerTest_test_forEachStatement_withLoopVariable_2 |
| 2444 implements NodeReplacerTest_Getter { |
| 2445 @override |
| 2446 DeclaredIdentifier get(ForEachStatement node) => node.loopVariable; |
| 2447 } |
| 2448 |
| 2449 class Getter_NodeReplacerTest_test_forEachStatement_withLoopVariable_3 |
| 2450 implements NodeReplacerTest_Getter { |
| 2451 @override |
| 2452 Statement get(ForEachStatement node) => node.body; |
| 2453 } |
| 2454 |
| 2455 class Getter_NodeReplacerTest_test_forStatement_withInitialization |
| 2456 implements NodeReplacerTest_Getter { |
| 2457 @override |
| 2458 Statement get(ForStatement node) => node.body; |
| 2459 } |
| 2460 |
| 2461 class Getter_NodeReplacerTest_test_forStatement_withInitialization_2 |
| 2462 implements NodeReplacerTest_Getter { |
| 2463 @override |
| 2464 Expression get(ForStatement node) => node.condition; |
| 2465 } |
| 2466 |
| 2467 class Getter_NodeReplacerTest_test_forStatement_withInitialization_3 |
| 2468 implements NodeReplacerTest_Getter { |
| 2469 @override |
| 2470 Expression get(ForStatement node) => node.initialization; |
| 2471 } |
| 2472 |
| 2473 class Getter_NodeReplacerTest_test_forStatement_withVariables |
| 2474 implements NodeReplacerTest_Getter { |
| 2475 @override |
| 2476 Statement get(ForStatement node) => node.body; |
| 2477 } |
| 2478 |
| 2479 class Getter_NodeReplacerTest_test_forStatement_withVariables_2 |
| 2480 implements NodeReplacerTest_Getter { |
| 2481 @override |
| 2482 VariableDeclarationList get(ForStatement node) => node.variables; |
| 2483 } |
| 2484 |
| 2485 class Getter_NodeReplacerTest_test_forStatement_withVariables_3 |
| 2486 implements NodeReplacerTest_Getter { |
| 2487 @override |
| 2488 Expression get(ForStatement node) => node.condition; |
| 2489 } |
| 2490 |
| 2491 class Getter_NodeReplacerTest_test_functionDeclaration |
| 2492 implements NodeReplacerTest_Getter { |
| 2493 @override |
| 2494 TypeName get(FunctionDeclaration node) => node.returnType; |
| 2495 } |
| 2496 |
| 2497 class Getter_NodeReplacerTest_test_functionDeclaration_2 |
| 2498 implements NodeReplacerTest_Getter { |
| 2499 @override |
| 2500 FunctionExpression get(FunctionDeclaration node) => node.functionExpression; |
| 2501 } |
| 2502 |
| 2503 class Getter_NodeReplacerTest_test_functionDeclaration_3 |
| 2504 implements NodeReplacerTest_Getter { |
| 2505 @override |
| 2506 SimpleIdentifier get(FunctionDeclaration node) => node.name; |
| 2507 } |
| 2508 |
| 2509 class Getter_NodeReplacerTest_test_functionDeclarationStatement |
| 2510 implements NodeReplacerTest_Getter { |
| 2511 @override |
| 2512 FunctionDeclaration get(FunctionDeclarationStatement node) => |
| 2513 node.functionDeclaration; |
| 2514 } |
| 2515 |
| 2516 class Getter_NodeReplacerTest_test_functionExpression |
| 2517 implements NodeReplacerTest_Getter { |
| 2518 @override |
| 2519 FormalParameterList get(FunctionExpression node) => node.parameters; |
| 2520 } |
| 2521 |
| 2522 class Getter_NodeReplacerTest_test_functionExpression_2 |
| 2523 implements NodeReplacerTest_Getter { |
| 2524 @override |
| 2525 FunctionBody get(FunctionExpression node) => node.body; |
| 2526 } |
| 2527 |
| 2528 class Getter_NodeReplacerTest_test_functionExpressionInvocation |
| 2529 implements NodeReplacerTest_Getter { |
| 2530 @override |
| 2531 Expression get(FunctionExpressionInvocation node) => node.function; |
| 2532 } |
| 2533 |
| 2534 class Getter_NodeReplacerTest_test_functionExpressionInvocation_2 |
| 2535 implements NodeReplacerTest_Getter { |
| 2536 @override |
| 2537 ArgumentList get(FunctionExpressionInvocation node) => node.argumentList; |
| 2538 } |
| 2539 |
| 2540 class Getter_NodeReplacerTest_test_functionTypeAlias |
| 2541 implements NodeReplacerTest_Getter { |
| 2542 @override |
| 2543 TypeParameterList get(FunctionTypeAlias node) => node.typeParameters; |
| 2544 } |
| 2545 |
| 2546 class Getter_NodeReplacerTest_test_functionTypeAlias_2 |
| 2547 implements NodeReplacerTest_Getter { |
| 2548 @override |
| 2549 FormalParameterList get(FunctionTypeAlias node) => node.parameters; |
| 2550 } |
| 2551 |
| 2552 class Getter_NodeReplacerTest_test_functionTypeAlias_3 |
| 2553 implements NodeReplacerTest_Getter { |
| 2554 @override |
| 2555 TypeName get(FunctionTypeAlias node) => node.returnType; |
| 2556 } |
| 2557 |
| 2558 class Getter_NodeReplacerTest_test_functionTypeAlias_4 |
| 2559 implements NodeReplacerTest_Getter { |
| 2560 @override |
| 2561 SimpleIdentifier get(FunctionTypeAlias node) => node.name; |
| 2562 } |
| 2563 |
| 2564 class Getter_NodeReplacerTest_test_functionTypedFormalParameter |
| 2565 implements NodeReplacerTest_Getter { |
| 2566 @override |
| 2567 TypeName get(FunctionTypedFormalParameter node) => node.returnType; |
| 2568 } |
| 2569 |
| 2570 class Getter_NodeReplacerTest_test_functionTypedFormalParameter_2 |
| 2571 implements NodeReplacerTest_Getter { |
| 2572 @override |
| 2573 FormalParameterList get(FunctionTypedFormalParameter node) => node.parameters; |
| 2574 } |
| 2575 |
| 2576 class Getter_NodeReplacerTest_test_ifStatement |
| 2577 implements NodeReplacerTest_Getter { |
| 2578 @override |
| 2579 Expression get(IfStatement node) => node.condition; |
| 2580 } |
| 2581 |
| 2582 class Getter_NodeReplacerTest_test_ifStatement_2 |
| 2583 implements NodeReplacerTest_Getter { |
| 2584 @override |
| 2585 Statement get(IfStatement node) => node.elseStatement; |
| 2586 } |
| 2587 |
| 2588 class Getter_NodeReplacerTest_test_ifStatement_3 |
| 2589 implements NodeReplacerTest_Getter { |
| 2590 @override |
| 2591 Statement get(IfStatement node) => node.thenStatement; |
| 2592 } |
| 2593 |
| 2594 class Getter_NodeReplacerTest_test_importDirective |
| 2595 implements NodeReplacerTest_Getter { |
| 2596 @override |
| 2597 SimpleIdentifier get(ImportDirective node) => node.prefix; |
| 2598 } |
| 2599 |
| 2600 class Getter_NodeReplacerTest_test_indexExpression |
| 2601 implements NodeReplacerTest_Getter { |
| 2602 @override |
| 2603 Expression get(IndexExpression node) => node.target; |
| 2604 } |
| 2605 |
| 2606 class Getter_NodeReplacerTest_test_indexExpression_2 |
| 2607 implements NodeReplacerTest_Getter { |
| 2608 @override |
| 2609 Expression get(IndexExpression node) => node.index; |
| 2610 } |
| 2611 |
| 2612 class Getter_NodeReplacerTest_test_instanceCreationExpression |
| 2613 implements NodeReplacerTest_Getter { |
| 2614 @override |
| 2615 ArgumentList get(InstanceCreationExpression node) => node.argumentList; |
| 2616 } |
| 2617 |
| 2618 class Getter_NodeReplacerTest_test_instanceCreationExpression_2 |
| 2619 implements NodeReplacerTest_Getter { |
| 2620 @override |
| 2621 ConstructorName get(InstanceCreationExpression node) => node.constructorName; |
| 2622 } |
| 2623 |
| 2624 class Getter_NodeReplacerTest_test_interpolationExpression |
| 2625 implements NodeReplacerTest_Getter { |
| 2626 @override |
| 2627 Expression get(InterpolationExpression node) => node.expression; |
| 2628 } |
| 2629 |
| 2630 class Getter_NodeReplacerTest_test_isExpression |
| 2631 implements NodeReplacerTest_Getter { |
| 2632 @override |
| 2633 Expression get(IsExpression node) => node.expression; |
| 2634 } |
| 2635 |
| 2636 class Getter_NodeReplacerTest_test_isExpression_2 |
| 2637 implements NodeReplacerTest_Getter { |
| 2638 @override |
| 2639 TypeName get(IsExpression node) => node.type; |
| 2640 } |
| 2641 |
| 2642 class Getter_NodeReplacerTest_test_label implements NodeReplacerTest_Getter { |
| 2643 @override |
| 2644 SimpleIdentifier get(Label node) => node.label; |
| 2645 } |
| 2646 |
| 2647 class Getter_NodeReplacerTest_test_labeledStatement |
| 2648 implements NodeReplacerTest_Getter { |
| 2649 @override |
| 2650 Statement get(LabeledStatement node) => node.statement; |
| 2651 } |
| 2652 |
| 2653 class Getter_NodeReplacerTest_test_libraryDirective |
| 2654 implements NodeReplacerTest_Getter { |
| 2655 @override |
| 2656 LibraryIdentifier get(LibraryDirective node) => node.name; |
| 2657 } |
| 2658 |
| 2659 class Getter_NodeReplacerTest_test_mapLiteralEntry |
| 2660 implements NodeReplacerTest_Getter { |
| 2661 @override |
| 2662 Expression get(MapLiteralEntry node) => node.value; |
| 2663 } |
| 2664 |
| 2665 class Getter_NodeReplacerTest_test_mapLiteralEntry_2 |
| 2666 implements NodeReplacerTest_Getter { |
| 2667 @override |
| 2668 Expression get(MapLiteralEntry node) => node.key; |
| 2669 } |
| 2670 |
| 2671 class Getter_NodeReplacerTest_test_methodDeclaration |
| 2672 implements NodeReplacerTest_Getter { |
| 2673 @override |
| 2674 TypeName get(MethodDeclaration node) => node.returnType; |
| 2675 } |
| 2676 |
| 2677 class Getter_NodeReplacerTest_test_methodDeclaration_2 |
| 2678 implements NodeReplacerTest_Getter { |
| 2679 @override |
| 2680 FunctionBody get(MethodDeclaration node) => node.body; |
| 2681 } |
| 2682 |
| 2683 class Getter_NodeReplacerTest_test_methodDeclaration_3 |
| 2684 implements NodeReplacerTest_Getter { |
| 2685 @override |
| 2686 SimpleIdentifier get(MethodDeclaration node) => node.name; |
| 2687 } |
| 2688 |
| 2689 class Getter_NodeReplacerTest_test_methodDeclaration_4 |
| 2690 implements NodeReplacerTest_Getter { |
| 2691 @override |
| 2692 FormalParameterList get(MethodDeclaration node) => node.parameters; |
| 2693 } |
| 2694 |
| 2695 class Getter_NodeReplacerTest_test_methodInvocation |
| 2696 implements NodeReplacerTest_Getter { |
| 2697 @override |
| 2698 ArgumentList get(MethodInvocation node) => node.argumentList; |
| 2699 } |
| 2700 |
| 2701 class Getter_NodeReplacerTest_test_methodInvocation_2 |
| 2702 implements NodeReplacerTest_Getter { |
| 2703 @override |
| 2704 Expression get(MethodInvocation node) => node.target; |
| 2705 } |
| 2706 |
| 2707 class Getter_NodeReplacerTest_test_methodInvocation_3 |
| 2708 implements NodeReplacerTest_Getter { |
| 2709 @override |
| 2710 SimpleIdentifier get(MethodInvocation node) => node.methodName; |
| 2711 } |
| 2712 |
| 2713 class Getter_NodeReplacerTest_test_namedExpression |
| 2714 implements NodeReplacerTest_Getter { |
| 2715 @override |
| 2716 Label get(NamedExpression node) => node.name; |
| 2717 } |
| 2718 |
| 2719 class Getter_NodeReplacerTest_test_namedExpression_2 |
| 2720 implements NodeReplacerTest_Getter { |
| 2721 @override |
| 2722 Expression get(NamedExpression node) => node.expression; |
| 2723 } |
| 2724 |
| 2725 class Getter_NodeReplacerTest_test_nativeClause |
| 2726 implements NodeReplacerTest_Getter { |
| 2727 @override |
| 2728 StringLiteral get(NativeClause node) => node.name; |
| 2729 } |
| 2730 |
| 2731 class Getter_NodeReplacerTest_test_nativeFunctionBody |
| 2732 implements NodeReplacerTest_Getter { |
| 2733 @override |
| 2734 StringLiteral get(NativeFunctionBody node) => node.stringLiteral; |
| 2735 } |
| 2736 |
| 2737 class Getter_NodeReplacerTest_test_parenthesizedExpression |
| 2738 implements NodeReplacerTest_Getter { |
| 2739 @override |
| 2740 Expression get(ParenthesizedExpression node) => node.expression; |
| 2741 } |
| 2742 |
| 2743 class Getter_NodeReplacerTest_test_partOfDirective |
| 2744 implements NodeReplacerTest_Getter { |
| 2745 @override |
| 2746 LibraryIdentifier get(PartOfDirective node) => node.libraryName; |
| 2747 } |
| 2748 |
| 2749 class Getter_NodeReplacerTest_test_postfixExpression |
| 2750 implements NodeReplacerTest_Getter { |
| 2751 @override |
| 2752 Expression get(PostfixExpression node) => node.operand; |
| 2753 } |
| 2754 |
| 2755 class Getter_NodeReplacerTest_test_prefixedIdentifier |
| 2756 implements NodeReplacerTest_Getter { |
| 2757 @override |
| 2758 SimpleIdentifier get(PrefixedIdentifier node) => node.identifier; |
| 2759 } |
| 2760 |
| 2761 class Getter_NodeReplacerTest_test_prefixedIdentifier_2 |
| 2762 implements NodeReplacerTest_Getter { |
| 2763 @override |
| 2764 SimpleIdentifier get(PrefixedIdentifier node) => node.prefix; |
| 2765 } |
| 2766 |
| 2767 class Getter_NodeReplacerTest_test_prefixExpression |
| 2768 implements NodeReplacerTest_Getter { |
| 2769 @override |
| 2770 Expression get(PrefixExpression node) => node.operand; |
| 2771 } |
| 2772 |
| 2773 class Getter_NodeReplacerTest_test_propertyAccess |
| 2774 implements NodeReplacerTest_Getter { |
| 2775 @override |
| 2776 Expression get(PropertyAccess node) => node.target; |
| 2777 } |
| 2778 |
| 2779 class Getter_NodeReplacerTest_test_propertyAccess_2 |
| 2780 implements NodeReplacerTest_Getter { |
| 2781 @override |
| 2782 SimpleIdentifier get(PropertyAccess node) => node.propertyName; |
| 2783 } |
| 2784 |
| 2785 class Getter_NodeReplacerTest_test_redirectingConstructorInvocation |
| 2786 implements NodeReplacerTest_Getter { |
| 2787 @override |
| 2788 SimpleIdentifier get(RedirectingConstructorInvocation node) => |
| 2789 node.constructorName; |
| 2790 } |
| 2791 |
| 2792 class Getter_NodeReplacerTest_test_redirectingConstructorInvocation_2 |
| 2793 implements NodeReplacerTest_Getter { |
| 2794 @override |
| 2795 ArgumentList get(RedirectingConstructorInvocation node) => node.argumentList; |
| 2796 } |
| 2797 |
| 2798 class Getter_NodeReplacerTest_test_returnStatement |
| 2799 implements NodeReplacerTest_Getter { |
| 2800 @override |
| 2801 Expression get(ReturnStatement node) => node.expression; |
| 2802 } |
| 2803 |
| 2804 class Getter_NodeReplacerTest_test_simpleFormalParameter |
| 2805 implements NodeReplacerTest_Getter { |
| 2806 @override |
| 2807 TypeName get(SimpleFormalParameter node) => node.type; |
| 2808 } |
| 2809 |
| 2810 class Getter_NodeReplacerTest_test_superConstructorInvocation |
| 2811 implements NodeReplacerTest_Getter { |
| 2812 @override |
| 2813 SimpleIdentifier get(SuperConstructorInvocation node) => node.constructorName; |
| 2814 } |
| 2815 |
| 2816 class Getter_NodeReplacerTest_test_superConstructorInvocation_2 |
| 2817 implements NodeReplacerTest_Getter { |
| 2818 @override |
| 2819 ArgumentList get(SuperConstructorInvocation node) => node.argumentList; |
| 2820 } |
| 2821 |
| 2822 class Getter_NodeReplacerTest_test_switchCase |
| 2823 implements NodeReplacerTest_Getter { |
| 2824 @override |
| 2825 Expression get(SwitchCase node) => node.expression; |
| 2826 } |
| 2827 |
| 2828 class Getter_NodeReplacerTest_test_switchStatement |
| 2829 implements NodeReplacerTest_Getter { |
| 2830 @override |
| 2831 Expression get(SwitchStatement node) => node.expression; |
| 2832 } |
| 2833 |
| 2834 class Getter_NodeReplacerTest_test_throwExpression |
| 2835 implements NodeReplacerTest_Getter { |
| 2836 @override |
| 2837 Expression get(ThrowExpression node) => node.expression; |
| 2838 } |
| 2839 |
| 2840 class Getter_NodeReplacerTest_test_topLevelVariableDeclaration |
| 2841 implements NodeReplacerTest_Getter { |
| 2842 @override |
| 2843 VariableDeclarationList get(TopLevelVariableDeclaration node) => |
| 2844 node.variables; |
| 2845 } |
| 2846 |
| 2847 class Getter_NodeReplacerTest_test_tryStatement |
| 2848 implements NodeReplacerTest_Getter { |
| 2849 @override |
| 2850 Block get(TryStatement node) => node.finallyBlock; |
| 2851 } |
| 2852 |
| 2853 class Getter_NodeReplacerTest_test_tryStatement_2 |
| 2854 implements NodeReplacerTest_Getter { |
| 2855 @override |
| 2856 Block get(TryStatement node) => node.body; |
| 2857 } |
| 2858 |
| 2859 class Getter_NodeReplacerTest_test_typeName implements NodeReplacerTest_Getter { |
| 2860 @override |
| 2861 TypeArgumentList get(TypeName node) => node.typeArguments; |
| 2862 } |
| 2863 |
| 2864 class Getter_NodeReplacerTest_test_typeName_2 |
| 2865 implements NodeReplacerTest_Getter { |
| 2866 @override |
| 2867 Identifier get(TypeName node) => node.name; |
| 2868 } |
| 2869 |
| 2870 class Getter_NodeReplacerTest_test_typeParameter |
| 2871 implements NodeReplacerTest_Getter { |
| 2872 @override |
| 2873 TypeName get(TypeParameter node) => node.bound; |
| 2874 } |
| 2875 |
| 2876 class Getter_NodeReplacerTest_test_typeParameter_2 |
| 2877 implements NodeReplacerTest_Getter { |
| 2878 @override |
| 2879 SimpleIdentifier get(TypeParameter node) => node.name; |
| 2880 } |
| 2881 |
| 2882 class Getter_NodeReplacerTest_test_variableDeclaration |
| 2883 implements NodeReplacerTest_Getter { |
| 2884 @override |
| 2885 SimpleIdentifier get(VariableDeclaration node) => node.name; |
| 2886 } |
| 2887 |
| 2888 class Getter_NodeReplacerTest_test_variableDeclaration_2 |
| 2889 implements NodeReplacerTest_Getter { |
| 2890 @override |
| 2891 Expression get(VariableDeclaration node) => node.initializer; |
| 2892 } |
| 2893 |
| 2894 class Getter_NodeReplacerTest_test_variableDeclarationList |
| 2895 implements NodeReplacerTest_Getter { |
| 2896 @override |
| 2897 TypeName get(VariableDeclarationList node) => node.type; |
| 2898 } |
| 2899 |
| 2900 class Getter_NodeReplacerTest_test_variableDeclarationStatement |
| 2901 implements NodeReplacerTest_Getter { |
| 2902 @override |
| 2903 VariableDeclarationList get(VariableDeclarationStatement node) => |
| 2904 node.variables; |
| 2905 } |
| 2906 |
| 2907 class Getter_NodeReplacerTest_test_whileStatement |
| 2908 implements NodeReplacerTest_Getter { |
| 2909 @override |
| 2910 Expression get(WhileStatement node) => node.condition; |
| 2911 } |
| 2912 |
| 2913 class Getter_NodeReplacerTest_test_whileStatement_2 |
| 2914 implements NodeReplacerTest_Getter { |
| 2915 @override |
| 2916 Statement get(WhileStatement node) => node.body; |
| 2917 } |
| 2918 |
| 2919 class Getter_NodeReplacerTest_test_yieldStatement |
| 2920 implements NodeReplacerTest_Getter { |
| 2921 @override |
| 2922 Expression get(YieldStatement node) => node.expression; |
| 2923 } |
| 2924 |
| 2925 class Getter_NodeReplacerTest_testAnnotatedNode |
| 2926 implements NodeReplacerTest_Getter { |
| 2927 @override |
| 2928 Comment get(AnnotatedNode node) => node.documentationComment; |
| 2929 } |
| 2930 |
| 2931 class Getter_NodeReplacerTest_testNormalFormalParameter |
| 2932 implements NodeReplacerTest_Getter { |
| 2933 @override |
| 2934 SimpleIdentifier get(NormalFormalParameter node) => node.identifier; |
| 2935 } |
| 2936 |
| 2937 class Getter_NodeReplacerTest_testNormalFormalParameter_2 |
| 2938 implements NodeReplacerTest_Getter { |
| 2939 @override |
| 2940 Comment get(NormalFormalParameter node) => node.documentationComment; |
| 2941 } |
| 2942 |
| 2943 class Getter_NodeReplacerTest_testTypedLiteral |
| 2944 implements NodeReplacerTest_Getter { |
| 2945 @override |
| 2946 TypeArgumentList get(TypedLiteral node) => node.typeArguments; |
| 2947 } |
| 2948 |
| 2949 class Getter_NodeReplacerTest_testUriBasedDirective |
| 2950 implements NodeReplacerTest_Getter { |
| 2951 @override |
| 2952 StringLiteral get(UriBasedDirective node) => node.uri; |
| 2953 } |
| 2954 |
| 2955 @reflectiveTest |
| 2956 class LineInfoTest { |
| 2957 void test_creation() { |
| 2958 expect(new LineInfo(<int>[0]), isNotNull); |
| 2959 } |
| 2960 |
| 2961 void test_creation_empty() { |
| 2962 try { |
| 2963 new LineInfo(<int>[]); |
| 2964 fail("Expected IllegalArgumentException"); |
| 2965 } on IllegalArgumentException { |
| 2966 // Expected |
| 2967 } |
| 2968 } |
| 2969 |
| 2970 void test_creation_null() { |
| 2971 try { |
| 2972 new LineInfo(null); |
| 2973 fail("Expected IllegalArgumentException"); |
| 2974 } on IllegalArgumentException { |
| 2975 // Expected |
| 2976 } |
| 2977 } |
| 2978 |
| 2979 void test_firstLine() { |
| 2980 LineInfo info = new LineInfo(<int>[0, 12, 34]); |
| 2981 LineInfo_Location location = info.getLocation(4); |
| 2982 expect(location.lineNumber, 1); |
| 2983 expect(location.columnNumber, 5); |
| 2984 } |
| 2985 |
| 2986 void test_lastLine() { |
| 2987 LineInfo info = new LineInfo(<int>[0, 12, 34]); |
| 2988 LineInfo_Location location = info.getLocation(36); |
| 2989 expect(location.lineNumber, 3); |
| 2990 expect(location.columnNumber, 3); |
| 2991 } |
| 2992 |
| 2993 void test_middleLine() { |
| 2994 LineInfo info = new LineInfo(<int>[0, 12, 34]); |
| 2995 LineInfo_Location location = info.getLocation(12); |
| 2996 expect(location.lineNumber, 2); |
| 2997 expect(location.columnNumber, 1); |
| 2998 } |
| 2999 } |
| 3000 |
| 3001 class ListGetter_NodeReplacerTest_test_adjacentStrings |
| 3002 extends NodeReplacerTest_ListGetter<AdjacentStrings, StringLiteral> { |
| 3003 ListGetter_NodeReplacerTest_test_adjacentStrings(int arg0) : super(arg0); |
| 3004 |
| 3005 @override |
| 3006 NodeList<StringLiteral> getList(AdjacentStrings node) => node.strings; |
| 3007 } |
| 3008 |
| 3009 class ListGetter_NodeReplacerTest_test_adjacentStrings_2 |
| 3010 extends NodeReplacerTest_ListGetter<AdjacentStrings, StringLiteral> { |
| 3011 ListGetter_NodeReplacerTest_test_adjacentStrings_2(int arg0) : super(arg0); |
| 3012 |
| 3013 @override |
| 3014 NodeList<StringLiteral> getList(AdjacentStrings node) => node.strings; |
| 3015 } |
| 3016 |
| 3017 class ListGetter_NodeReplacerTest_test_argumentList |
| 3018 extends NodeReplacerTest_ListGetter<ArgumentList, Expression> { |
| 3019 ListGetter_NodeReplacerTest_test_argumentList(int arg0) : super(arg0); |
| 3020 |
| 3021 @override |
| 3022 NodeList<Expression> getList(ArgumentList node) => node.arguments; |
| 3023 } |
| 3024 |
| 3025 class ListGetter_NodeReplacerTest_test_block |
| 3026 extends NodeReplacerTest_ListGetter<Block, Statement> { |
| 3027 ListGetter_NodeReplacerTest_test_block(int arg0) : super(arg0); |
| 3028 |
| 3029 @override |
| 3030 NodeList<Statement> getList(Block node) => node.statements; |
| 3031 } |
| 3032 |
| 3033 class ListGetter_NodeReplacerTest_test_cascadeExpression |
| 3034 extends NodeReplacerTest_ListGetter<CascadeExpression, Expression> { |
| 3035 ListGetter_NodeReplacerTest_test_cascadeExpression(int arg0) : super(arg0); |
| 3036 |
| 3037 @override |
| 3038 NodeList<Expression> getList(CascadeExpression node) => node.cascadeSections; |
| 3039 } |
| 3040 |
| 3041 class ListGetter_NodeReplacerTest_test_classDeclaration |
| 3042 extends NodeReplacerTest_ListGetter<ClassDeclaration, ClassMember> { |
| 3043 ListGetter_NodeReplacerTest_test_classDeclaration(int arg0) : super(arg0); |
| 3044 |
| 3045 @override |
| 3046 NodeList<ClassMember> getList(ClassDeclaration node) => node.members; |
| 3047 } |
| 3048 |
| 3049 class ListGetter_NodeReplacerTest_test_comment |
| 3050 extends NodeReplacerTest_ListGetter<Comment, CommentReference> { |
| 3051 ListGetter_NodeReplacerTest_test_comment(int arg0) : super(arg0); |
| 3052 |
| 3053 @override |
| 3054 NodeList<CommentReference> getList(Comment node) => node.references; |
| 3055 } |
| 3056 |
| 3057 class ListGetter_NodeReplacerTest_test_compilationUnit |
| 3058 extends NodeReplacerTest_ListGetter<CompilationUnit, Directive> { |
| 3059 ListGetter_NodeReplacerTest_test_compilationUnit(int arg0) : super(arg0); |
| 3060 |
| 3061 @override |
| 3062 NodeList<Directive> getList(CompilationUnit node) => node.directives; |
| 3063 } |
| 3064 |
| 3065 class ListGetter_NodeReplacerTest_test_compilationUnit_2 |
| 3066 extends NodeReplacerTest_ListGetter<CompilationUnit, |
| 3067 CompilationUnitMember> { |
| 3068 ListGetter_NodeReplacerTest_test_compilationUnit_2(int arg0) : super(arg0); |
| 3069 |
| 3070 @override |
| 3071 NodeList<CompilationUnitMember> getList(CompilationUnit node) => |
| 3072 node.declarations; |
| 3073 } |
| 3074 |
| 3075 class ListGetter_NodeReplacerTest_test_constructorDeclaration |
| 3076 extends NodeReplacerTest_ListGetter<ConstructorDeclaration, |
| 3077 ConstructorInitializer> { |
| 3078 ListGetter_NodeReplacerTest_test_constructorDeclaration(int arg0) |
| 3079 : super(arg0); |
| 3080 |
| 3081 @override |
| 3082 NodeList<ConstructorInitializer> getList(ConstructorDeclaration node) => |
| 3083 node.initializers; |
| 3084 } |
| 3085 |
| 3086 class ListGetter_NodeReplacerTest_test_formalParameterList |
| 3087 extends NodeReplacerTest_ListGetter<FormalParameterList, FormalParameter> { |
| 3088 ListGetter_NodeReplacerTest_test_formalParameterList(int arg0) : super(arg0); |
| 3089 |
| 3090 @override |
| 3091 NodeList<FormalParameter> getList(FormalParameterList node) => |
| 3092 node.parameters; |
| 3093 } |
| 3094 |
| 3095 class ListGetter_NodeReplacerTest_test_forStatement_withInitialization |
| 3096 extends NodeReplacerTest_ListGetter<ForStatement, Expression> { |
| 3097 ListGetter_NodeReplacerTest_test_forStatement_withInitialization(int arg0) |
| 3098 : super(arg0); |
| 3099 |
| 3100 @override |
| 3101 NodeList<Expression> getList(ForStatement node) => node.updaters; |
| 3102 } |
| 3103 |
| 3104 class ListGetter_NodeReplacerTest_test_forStatement_withVariables |
| 3105 extends NodeReplacerTest_ListGetter<ForStatement, Expression> { |
| 3106 ListGetter_NodeReplacerTest_test_forStatement_withVariables(int arg0) |
| 3107 : super(arg0); |
| 3108 |
| 3109 @override |
| 3110 NodeList<Expression> getList(ForStatement node) => node.updaters; |
| 3111 } |
| 3112 |
| 3113 class ListGetter_NodeReplacerTest_test_hideCombinator |
| 3114 extends NodeReplacerTest_ListGetter<HideCombinator, SimpleIdentifier> { |
| 3115 ListGetter_NodeReplacerTest_test_hideCombinator(int arg0) : super(arg0); |
| 3116 |
| 3117 @override |
| 3118 NodeList<SimpleIdentifier> getList(HideCombinator node) => node.hiddenNames; |
| 3119 } |
| 3120 |
| 3121 class ListGetter_NodeReplacerTest_test_implementsClause |
| 3122 extends NodeReplacerTest_ListGetter<ImplementsClause, TypeName> { |
| 3123 ListGetter_NodeReplacerTest_test_implementsClause(int arg0) : super(arg0); |
| 3124 |
| 3125 @override |
| 3126 NodeList<TypeName> getList(ImplementsClause node) => node.interfaces; |
| 3127 } |
| 3128 |
| 3129 class ListGetter_NodeReplacerTest_test_labeledStatement |
| 3130 extends NodeReplacerTest_ListGetter<LabeledStatement, Label> { |
| 3131 ListGetter_NodeReplacerTest_test_labeledStatement(int arg0) : super(arg0); |
| 3132 |
| 3133 @override |
| 3134 NodeList<Label> getList(LabeledStatement node) => node.labels; |
| 3135 } |
| 3136 |
| 3137 class ListGetter_NodeReplacerTest_test_libraryIdentifier |
| 3138 extends NodeReplacerTest_ListGetter<LibraryIdentifier, SimpleIdentifier> { |
| 3139 ListGetter_NodeReplacerTest_test_libraryIdentifier(int arg0) : super(arg0); |
| 3140 |
| 3141 @override |
| 3142 NodeList<SimpleIdentifier> getList(LibraryIdentifier node) => node.components; |
| 3143 } |
| 3144 |
| 3145 class ListGetter_NodeReplacerTest_test_listLiteral |
| 3146 extends NodeReplacerTest_ListGetter<ListLiteral, Expression> { |
| 3147 ListGetter_NodeReplacerTest_test_listLiteral(int arg0) : super(arg0); |
| 3148 |
| 3149 @override |
| 3150 NodeList<Expression> getList(ListLiteral node) => node.elements; |
| 3151 } |
| 3152 |
| 3153 class ListGetter_NodeReplacerTest_test_mapLiteral |
| 3154 extends NodeReplacerTest_ListGetter<MapLiteral, MapLiteralEntry> { |
| 3155 ListGetter_NodeReplacerTest_test_mapLiteral(int arg0) : super(arg0); |
| 3156 |
| 3157 @override |
| 3158 NodeList<MapLiteralEntry> getList(MapLiteral node) => node.entries; |
| 3159 } |
| 3160 |
| 3161 class ListGetter_NodeReplacerTest_test_showCombinator |
| 3162 extends NodeReplacerTest_ListGetter<ShowCombinator, SimpleIdentifier> { |
| 3163 ListGetter_NodeReplacerTest_test_showCombinator(int arg0) : super(arg0); |
| 3164 |
| 3165 @override |
| 3166 NodeList<SimpleIdentifier> getList(ShowCombinator node) => node.shownNames; |
| 3167 } |
| 3168 |
| 3169 class ListGetter_NodeReplacerTest_test_stringInterpolation |
| 3170 extends NodeReplacerTest_ListGetter<StringInterpolation, |
| 3171 InterpolationElement> { |
| 3172 ListGetter_NodeReplacerTest_test_stringInterpolation(int arg0) : super(arg0); |
| 3173 |
| 3174 @override |
| 3175 NodeList<InterpolationElement> getList(StringInterpolation node) => |
| 3176 node.elements; |
| 3177 } |
| 3178 |
| 3179 class ListGetter_NodeReplacerTest_test_switchStatement |
| 3180 extends NodeReplacerTest_ListGetter<SwitchStatement, SwitchMember> { |
| 3181 ListGetter_NodeReplacerTest_test_switchStatement(int arg0) : super(arg0); |
| 3182 |
| 3183 @override |
| 3184 NodeList<SwitchMember> getList(SwitchStatement node) => node.members; |
| 3185 } |
| 3186 |
| 3187 class ListGetter_NodeReplacerTest_test_tryStatement |
| 3188 extends NodeReplacerTest_ListGetter<TryStatement, CatchClause> { |
| 3189 ListGetter_NodeReplacerTest_test_tryStatement(int arg0) : super(arg0); |
| 3190 |
| 3191 @override |
| 3192 NodeList<CatchClause> getList(TryStatement node) => node.catchClauses; |
| 3193 } |
| 3194 |
| 3195 class ListGetter_NodeReplacerTest_test_typeArgumentList |
| 3196 extends NodeReplacerTest_ListGetter<TypeArgumentList, TypeName> { |
| 3197 ListGetter_NodeReplacerTest_test_typeArgumentList(int arg0) : super(arg0); |
| 3198 |
| 3199 @override |
| 3200 NodeList<TypeName> getList(TypeArgumentList node) => node.arguments; |
| 3201 } |
| 3202 |
| 3203 class ListGetter_NodeReplacerTest_test_typeParameterList |
| 3204 extends NodeReplacerTest_ListGetter<TypeParameterList, TypeParameter> { |
| 3205 ListGetter_NodeReplacerTest_test_typeParameterList(int arg0) : super(arg0); |
| 3206 |
| 3207 @override |
| 3208 NodeList<TypeParameter> getList(TypeParameterList node) => |
| 3209 node.typeParameters; |
| 3210 } |
| 3211 |
| 3212 class ListGetter_NodeReplacerTest_test_variableDeclarationList |
| 3213 extends NodeReplacerTest_ListGetter<VariableDeclarationList, |
| 3214 VariableDeclaration> { |
| 3215 ListGetter_NodeReplacerTest_test_variableDeclarationList(int arg0) |
| 3216 : super(arg0); |
| 3217 |
| 3218 @override |
| 3219 NodeList<VariableDeclaration> getList(VariableDeclarationList node) => |
| 3220 node.variables; |
| 3221 } |
| 3222 |
| 3223 class ListGetter_NodeReplacerTest_test_withClause |
| 3224 extends NodeReplacerTest_ListGetter<WithClause, TypeName> { |
| 3225 ListGetter_NodeReplacerTest_test_withClause(int arg0) : super(arg0); |
| 3226 |
| 3227 @override |
| 3228 NodeList<TypeName> getList(WithClause node) => node.mixinTypes; |
| 3229 } |
| 3230 |
| 3231 class ListGetter_NodeReplacerTest_testAnnotatedNode |
| 3232 extends NodeReplacerTest_ListGetter<AnnotatedNode, Annotation> { |
| 3233 ListGetter_NodeReplacerTest_testAnnotatedNode(int arg0) : super(arg0); |
| 3234 |
| 3235 @override |
| 3236 NodeList<Annotation> getList(AnnotatedNode node) => node.metadata; |
| 3237 } |
| 3238 |
| 3239 class ListGetter_NodeReplacerTest_testNamespaceDirective |
| 3240 extends NodeReplacerTest_ListGetter<NamespaceDirective, Combinator> { |
| 3241 ListGetter_NodeReplacerTest_testNamespaceDirective(int arg0) : super(arg0); |
| 3242 |
| 3243 @override |
| 3244 NodeList<Combinator> getList(NamespaceDirective node) => node.combinators; |
| 3245 } |
| 3246 |
| 3247 class ListGetter_NodeReplacerTest_testNormalFormalParameter |
| 3248 extends NodeReplacerTest_ListGetter<NormalFormalParameter, Annotation> { |
| 3249 ListGetter_NodeReplacerTest_testNormalFormalParameter(int arg0) : super(arg0); |
| 3250 |
| 3251 @override |
| 3252 NodeList<Annotation> getList(NormalFormalParameter node) => node.metadata; |
| 3253 } |
| 3254 |
| 3255 class ListGetter_NodeReplacerTest_testSwitchMember |
| 3256 extends NodeReplacerTest_ListGetter<SwitchMember, Label> { |
| 3257 ListGetter_NodeReplacerTest_testSwitchMember(int arg0) : super(arg0); |
| 3258 |
| 3259 @override |
| 3260 NodeList<Label> getList(SwitchMember node) => node.labels; |
| 3261 } |
| 3262 |
| 3263 class ListGetter_NodeReplacerTest_testSwitchMember_2 |
| 3264 extends NodeReplacerTest_ListGetter<SwitchMember, Statement> { |
| 3265 ListGetter_NodeReplacerTest_testSwitchMember_2(int arg0) : super(arg0); |
| 3266 |
| 3267 @override |
| 3268 NodeList<Statement> getList(SwitchMember node) => node.statements; |
| 3269 } |
| 3270 |
| 3271 @reflectiveTest |
| 3272 class ListUtilitiesTest { |
| 3273 void test_addAll_emptyToEmpty() { |
| 3274 List<String> list = new List<String>(); |
| 3275 List<String> elements = <String>[]; |
| 3276 ListUtilities.addAll(list, elements); |
| 3277 expect(list.length, 0); |
| 3278 } |
| 3279 |
| 3280 void test_addAll_emptyToNonEmpty() { |
| 3281 List<String> list = new List<String>(); |
| 3282 list.add("a"); |
| 3283 List<String> elements = <String>[]; |
| 3284 ListUtilities.addAll(list, elements); |
| 3285 expect(list.length, 1); |
| 3286 } |
| 3287 |
| 3288 void test_addAll_nonEmptyToEmpty() { |
| 3289 List<String> list = new List<String>(); |
| 3290 List<String> elements = ["b", "c"]; |
| 3291 ListUtilities.addAll(list, elements); |
| 3292 expect(list.length, 2); |
| 3293 } |
| 3294 |
| 3295 void test_addAll_nonEmptyToNonEmpty() { |
| 3296 List<String> list = new List<String>(); |
| 3297 list.add("a"); |
| 3298 List<String> elements = ["b", "c"]; |
| 3299 ListUtilities.addAll(list, elements); |
| 3300 expect(list.length, 3); |
| 3301 } |
| 3302 } |
| 3303 |
| 3304 @reflectiveTest |
| 3305 class MultipleMapIteratorTest extends EngineTestCase { |
| 3306 void test_multipleMaps_firstEmpty() { |
| 3307 Map<String, String> map1 = new HashMap<String, String>(); |
| 3308 Map<String, String> map2 = new HashMap<String, String>(); |
| 3309 map2["k2"] = "v2"; |
| 3310 Map<String, String> map3 = new HashMap<String, String>(); |
| 3311 map3["k3"] = "v3"; |
| 3312 MultipleMapIterator<String, String> iterator = |
| 3313 _iterator([map1, map2, map3]); |
| 3314 expect(iterator.moveNext(), isTrue); |
| 3315 expect(iterator.moveNext(), isTrue); |
| 3316 expect(iterator.moveNext(), isFalse); |
| 3317 } |
| 3318 |
| 3319 void test_multipleMaps_lastEmpty() { |
| 3320 Map<String, String> map1 = new HashMap<String, String>(); |
| 3321 map1["k1"] = "v1"; |
| 3322 Map<String, String> map2 = new HashMap<String, String>(); |
| 3323 map2["k2"] = "v2"; |
| 3324 Map<String, String> map3 = new HashMap<String, String>(); |
| 3325 MultipleMapIterator<String, String> iterator = |
| 3326 _iterator([map1, map2, map3]); |
| 3327 expect(iterator.moveNext(), isTrue); |
| 3328 expect(iterator.moveNext(), isTrue); |
| 3329 expect(iterator.moveNext(), isFalse); |
| 3330 } |
| 3331 |
| 3332 void test_multipleMaps_middleEmpty() { |
| 3333 Map<String, String> map1 = new HashMap<String, String>(); |
| 3334 map1["k1"] = "v1"; |
| 3335 Map<String, String> map2 = new HashMap<String, String>(); |
| 3336 Map<String, String> map3 = new HashMap<String, String>(); |
| 3337 map3["k3"] = "v3"; |
| 3338 MultipleMapIterator<String, String> iterator = |
| 3339 _iterator([map1, map2, map3]); |
| 3340 expect(iterator.moveNext(), isTrue); |
| 3341 expect(iterator.moveNext(), isTrue); |
| 3342 expect(iterator.moveNext(), isFalse); |
| 3343 } |
| 3344 |
| 3345 void test_multipleMaps_nonEmpty() { |
| 3346 Map<String, String> map1 = new HashMap<String, String>(); |
| 3347 map1["k1"] = "v1"; |
| 3348 Map<String, String> map2 = new HashMap<String, String>(); |
| 3349 map2["k2"] = "v2"; |
| 3350 Map<String, String> map3 = new HashMap<String, String>(); |
| 3351 map3["k3"] = "v3"; |
| 3352 MultipleMapIterator<String, String> iterator = |
| 3353 _iterator([map1, map2, map3]); |
| 3354 expect(iterator.moveNext(), isTrue); |
| 3355 expect(iterator.moveNext(), isTrue); |
| 3356 expect(iterator.moveNext(), isTrue); |
| 3357 expect(iterator.moveNext(), isFalse); |
| 3358 } |
| 3359 |
| 3360 void test_noMap() { |
| 3361 MultipleMapIterator<String, String> iterator = _iterator([]); |
| 3362 expect(iterator.moveNext(), isFalse); |
| 3363 expect(iterator.moveNext(), isFalse); |
| 3364 } |
| 3365 |
| 3366 void test_singleMap_empty() { |
| 3367 Map<String, String> map = new HashMap<String, String>(); |
| 3368 MultipleMapIterator<String, String> iterator = _iterator(<Map>[map]); |
| 3369 expect(iterator.moveNext(), isFalse); |
| 3370 try { |
| 3371 iterator.key; |
| 3372 fail("Expected NoSuchElementException"); |
| 3373 } on NoSuchElementException { |
| 3374 // Expected |
| 3375 } |
| 3376 try { |
| 3377 iterator.value; |
| 3378 fail("Expected NoSuchElementException"); |
| 3379 } on NoSuchElementException { |
| 3380 // Expected |
| 3381 } |
| 3382 try { |
| 3383 iterator.value = "x"; |
| 3384 fail("Expected NoSuchElementException"); |
| 3385 } on NoSuchElementException { |
| 3386 // Expected |
| 3387 } |
| 3388 } |
| 3389 |
| 3390 void test_singleMap_multiple() { |
| 3391 Map<String, String> map = new HashMap<String, String>(); |
| 3392 map["k1"] = "v1"; |
| 3393 map["k2"] = "v2"; |
| 3394 map["k3"] = "v3"; |
| 3395 MultipleMapIterator<String, String> iterator = _iterator([map]); |
| 3396 expect(iterator.moveNext(), isTrue); |
| 3397 expect(iterator.moveNext(), isTrue); |
| 3398 expect(iterator.moveNext(), isTrue); |
| 3399 expect(iterator.moveNext(), isFalse); |
| 3400 } |
| 3401 |
| 3402 void test_singleMap_single() { |
| 3403 String key = "key"; |
| 3404 String value = "value"; |
| 3405 Map<String, String> map = new HashMap<String, String>(); |
| 3406 map[key] = value; |
| 3407 MultipleMapIterator<String, String> iterator = _iterator([map]); |
| 3408 expect(iterator.moveNext(), isTrue); |
| 3409 expect(iterator.key, same(key)); |
| 3410 expect(iterator.value, same(value)); |
| 3411 String newValue = "newValue"; |
| 3412 iterator.value = newValue; |
| 3413 expect(iterator.value, same(newValue)); |
| 3414 expect(iterator.moveNext(), isFalse); |
| 3415 } |
| 3416 |
| 3417 MultipleMapIterator<String, String> _iterator(List<Map> maps) { |
| 3418 return new MultipleMapIterator<String, String>(maps); |
| 3419 } |
| 3420 } |
| 3421 |
| 3422 @reflectiveTest |
| 3423 class NodeReplacerTest extends EngineTestCase { |
| 3424 /** |
| 3425 * An empty list of tokens. |
| 3426 */ |
| 3427 static const List<Token> EMPTY_TOKEN_LIST = const <Token>[]; |
| 3428 |
| 3429 void test_adjacentStrings() { |
| 3430 AdjacentStrings node = AstFactory |
| 3431 .adjacentStrings([AstFactory.string2("a"), AstFactory.string2("b")]); |
| 3432 _assertReplace( |
| 3433 node, new ListGetter_NodeReplacerTest_test_adjacentStrings_2(0)); |
| 3434 _assertReplace( |
| 3435 node, new ListGetter_NodeReplacerTest_test_adjacentStrings(1)); |
| 3436 } |
| 3437 |
| 3438 void test_annotation() { |
| 3439 Annotation node = AstFactory.annotation2( |
| 3440 AstFactory.identifier3("C"), |
| 3441 AstFactory.identifier3("c"), |
| 3442 AstFactory.argumentList([AstFactory.integer(0)])); |
| 3443 _assertReplace(node, new Getter_NodeReplacerTest_test_annotation()); |
| 3444 _assertReplace(node, new Getter_NodeReplacerTest_test_annotation_3()); |
| 3445 _assertReplace(node, new Getter_NodeReplacerTest_test_annotation_2()); |
| 3446 } |
| 3447 |
| 3448 void test_argumentList() { |
| 3449 ArgumentList node = AstFactory.argumentList([AstFactory.integer(0)]); |
| 3450 _assertReplace(node, new ListGetter_NodeReplacerTest_test_argumentList(0)); |
| 3451 } |
| 3452 |
| 3453 void test_asExpression() { |
| 3454 AsExpression node = AstFactory.asExpression( |
| 3455 AstFactory.integer(0), |
| 3456 AstFactory.typeName3( |
| 3457 AstFactory.identifier3("a"), [AstFactory.typeName4("C")])); |
| 3458 _assertReplace(node, new Getter_NodeReplacerTest_test_asExpression_2()); |
| 3459 _assertReplace(node, new Getter_NodeReplacerTest_test_asExpression()); |
| 3460 } |
| 3461 |
| 3462 void test_assertStatement() { |
| 3463 AssertStatement node = |
| 3464 AstFactory.assertStatement(AstFactory.booleanLiteral(true)); |
| 3465 _assertReplace(node, new Getter_NodeReplacerTest_test_assertStatement()); |
| 3466 } |
| 3467 |
| 3468 void test_assignmentExpression() { |
| 3469 AssignmentExpression node = AstFactory.assignmentExpression( |
| 3470 AstFactory.identifier3("l"), TokenType.EQ, AstFactory.identifier3("r")); |
| 3471 _assertReplace( |
| 3472 node, new Getter_NodeReplacerTest_test_assignmentExpression_2()); |
| 3473 _assertReplace( |
| 3474 node, new Getter_NodeReplacerTest_test_assignmentExpression()); |
| 3475 } |
| 3476 |
| 3477 void test_awaitExpression() { |
| 3478 var node = AstFactory.awaitExpression(AstFactory.identifier3("A")); |
| 3479 _assertReplace(node, new Getter_NodeReplacerTest_test_awaitExpression()); |
| 3480 } |
| 3481 |
| 3482 void test_binaryExpression() { |
| 3483 BinaryExpression node = AstFactory.binaryExpression( |
| 3484 AstFactory.identifier3("l"), |
| 3485 TokenType.PLUS, |
| 3486 AstFactory.identifier3("r")); |
| 3487 _assertReplace(node, new Getter_NodeReplacerTest_test_binaryExpression()); |
| 3488 _assertReplace(node, new Getter_NodeReplacerTest_test_binaryExpression_2()); |
| 3489 } |
| 3490 |
| 3491 void test_block() { |
| 3492 Block node = AstFactory.block([AstFactory.emptyStatement()]); |
| 3493 _assertReplace(node, new ListGetter_NodeReplacerTest_test_block(0)); |
| 3494 } |
| 3495 |
| 3496 void test_blockFunctionBody() { |
| 3497 BlockFunctionBody node = AstFactory.blockFunctionBody(AstFactory.block()); |
| 3498 _assertReplace(node, new Getter_NodeReplacerTest_test_blockFunctionBody()); |
| 3499 } |
| 3500 |
| 3501 void test_breakStatement() { |
| 3502 BreakStatement node = AstFactory.breakStatement2("l"); |
| 3503 _assertReplace(node, new Getter_NodeReplacerTest_test_breakStatement()); |
| 3504 } |
| 3505 |
| 3506 void test_cascadeExpression() { |
| 3507 CascadeExpression node = AstFactory.cascadeExpression(AstFactory.integer(0), |
| 3508 [AstFactory.propertyAccess(null, AstFactory.identifier3("b"))]); |
| 3509 _assertReplace(node, new Getter_NodeReplacerTest_test_cascadeExpression()); |
| 3510 _assertReplace( |
| 3511 node, new ListGetter_NodeReplacerTest_test_cascadeExpression(0)); |
| 3512 } |
| 3513 |
| 3514 void test_catchClause() { |
| 3515 CatchClause node = AstFactory.catchClause5( |
| 3516 AstFactory.typeName4("E"), "e", "s", [AstFactory.emptyStatement()]); |
| 3517 _assertReplace(node, new Getter_NodeReplacerTest_test_catchClause_3()); |
| 3518 _assertReplace(node, new Getter_NodeReplacerTest_test_catchClause_2()); |
| 3519 _assertReplace(node, new Getter_NodeReplacerTest_test_catchClause()); |
| 3520 } |
| 3521 |
| 3522 void test_classDeclaration() { |
| 3523 ClassDeclaration node = AstFactory.classDeclaration( |
| 3524 null, |
| 3525 "A", |
| 3526 AstFactory.typeParameterList(["E"]), |
| 3527 AstFactory.extendsClause(AstFactory.typeName4("B")), |
| 3528 AstFactory.withClause([AstFactory.typeName4("C")]), |
| 3529 AstFactory.implementsClause([AstFactory.typeName4("D")]), [ |
| 3530 AstFactory.fieldDeclaration2( |
| 3531 false, null, [AstFactory.variableDeclaration("f")]) |
| 3532 ]); |
| 3533 node.documentationComment = |
| 3534 Comment.createEndOfLineComment(EMPTY_TOKEN_LIST); |
| 3535 node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a"))); |
| 3536 node.nativeClause = AstFactory.nativeClause(""); |
| 3537 _assertReplace(node, new Getter_NodeReplacerTest_test_classDeclaration_6()); |
| 3538 _assertReplace(node, new Getter_NodeReplacerTest_test_classDeclaration_5()); |
| 3539 _assertReplace(node, new Getter_NodeReplacerTest_test_classDeclaration_4()); |
| 3540 _assertReplace(node, new Getter_NodeReplacerTest_test_classDeclaration_2()); |
| 3541 _assertReplace(node, new Getter_NodeReplacerTest_test_classDeclaration()); |
| 3542 _assertReplace(node, new Getter_NodeReplacerTest_test_classDeclaration_3()); |
| 3543 _assertReplace( |
| 3544 node, new ListGetter_NodeReplacerTest_test_classDeclaration(0)); |
| 3545 _testAnnotatedNode(node); |
| 3546 } |
| 3547 |
| 3548 void test_classTypeAlias() { |
| 3549 ClassTypeAlias node = AstFactory.classTypeAlias( |
| 3550 "A", |
| 3551 AstFactory.typeParameterList(["E"]), |
| 3552 null, |
| 3553 AstFactory.typeName4("B"), |
| 3554 AstFactory.withClause([AstFactory.typeName4("C")]), |
| 3555 AstFactory.implementsClause([AstFactory.typeName4("D")])); |
| 3556 node.documentationComment = |
| 3557 Comment.createEndOfLineComment(EMPTY_TOKEN_LIST); |
| 3558 node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a"))); |
| 3559 _assertReplace(node, new Getter_NodeReplacerTest_test_classTypeAlias_4()); |
| 3560 _assertReplace(node, new Getter_NodeReplacerTest_test_classTypeAlias_5()); |
| 3561 _assertReplace(node, new Getter_NodeReplacerTest_test_classTypeAlias()); |
| 3562 _assertReplace(node, new Getter_NodeReplacerTest_test_classTypeAlias_3()); |
| 3563 _assertReplace(node, new Getter_NodeReplacerTest_test_classTypeAlias_2()); |
| 3564 _testAnnotatedNode(node); |
| 3565 } |
| 3566 |
| 3567 void test_comment() { |
| 3568 Comment node = Comment.createEndOfLineComment(EMPTY_TOKEN_LIST); |
| 3569 node.references |
| 3570 .add(new CommentReference(null, AstFactory.identifier3("x"))); |
| 3571 _assertReplace(node, new ListGetter_NodeReplacerTest_test_comment(0)); |
| 3572 } |
| 3573 |
| 3574 void test_commentReference() { |
| 3575 CommentReference node = |
| 3576 new CommentReference(null, AstFactory.identifier3("x")); |
| 3577 _assertReplace(node, new Getter_NodeReplacerTest_test_commentReference()); |
| 3578 } |
| 3579 |
| 3580 void test_compilationUnit() { |
| 3581 CompilationUnit node = AstFactory.compilationUnit8("", [ |
| 3582 AstFactory.libraryDirective2("lib") |
| 3583 ], [ |
| 3584 AstFactory.topLevelVariableDeclaration2( |
| 3585 null, [AstFactory.variableDeclaration("X")]) |
| 3586 ]); |
| 3587 _assertReplace(node, new Getter_NodeReplacerTest_test_compilationUnit()); |
| 3588 _assertReplace( |
| 3589 node, new ListGetter_NodeReplacerTest_test_compilationUnit(0)); |
| 3590 _assertReplace( |
| 3591 node, new ListGetter_NodeReplacerTest_test_compilationUnit_2(0)); |
| 3592 } |
| 3593 |
| 3594 void test_conditionalExpression() { |
| 3595 ConditionalExpression node = AstFactory.conditionalExpression( |
| 3596 AstFactory.booleanLiteral(true), |
| 3597 AstFactory.integer(0), |
| 3598 AstFactory.integer(1)); |
| 3599 _assertReplace( |
| 3600 node, new Getter_NodeReplacerTest_test_conditionalExpression_3()); |
| 3601 _assertReplace( |
| 3602 node, new Getter_NodeReplacerTest_test_conditionalExpression_2()); |
| 3603 _assertReplace( |
| 3604 node, new Getter_NodeReplacerTest_test_conditionalExpression()); |
| 3605 } |
| 3606 |
| 3607 void test_constructorDeclaration() { |
| 3608 ConstructorDeclaration node = AstFactory.constructorDeclaration2( |
| 3609 null, |
| 3610 null, |
| 3611 AstFactory.identifier3("C"), |
| 3612 "d", |
| 3613 AstFactory.formalParameterList(), |
| 3614 [ |
| 3615 AstFactory.constructorFieldInitializer( |
| 3616 false, "x", AstFactory.integer(0)) |
| 3617 ], |
| 3618 AstFactory.emptyFunctionBody()); |
| 3619 node.documentationComment = |
| 3620 Comment.createEndOfLineComment(EMPTY_TOKEN_LIST); |
| 3621 node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a"))); |
| 3622 node.redirectedConstructor = |
| 3623 AstFactory.constructorName(AstFactory.typeName4("B"), "a"); |
| 3624 _assertReplace( |
| 3625 node, new Getter_NodeReplacerTest_test_constructorDeclaration_3()); |
| 3626 _assertReplace( |
| 3627 node, new Getter_NodeReplacerTest_test_constructorDeclaration_2()); |
| 3628 _assertReplace( |
| 3629 node, new Getter_NodeReplacerTest_test_constructorDeclaration_4()); |
| 3630 _assertReplace( |
| 3631 node, new Getter_NodeReplacerTest_test_constructorDeclaration()); |
| 3632 _assertReplace( |
| 3633 node, new Getter_NodeReplacerTest_test_constructorDeclaration_5()); |
| 3634 _assertReplace( |
| 3635 node, new ListGetter_NodeReplacerTest_test_constructorDeclaration(0)); |
| 3636 _testAnnotatedNode(node); |
| 3637 } |
| 3638 |
| 3639 void test_constructorFieldInitializer() { |
| 3640 ConstructorFieldInitializer node = AstFactory.constructorFieldInitializer( |
| 3641 false, "f", AstFactory.integer(0)); |
| 3642 _assertReplace( |
| 3643 node, new Getter_NodeReplacerTest_test_constructorFieldInitializer()); |
| 3644 _assertReplace( |
| 3645 node, new Getter_NodeReplacerTest_test_constructorFieldInitializer_2()); |
| 3646 } |
| 3647 |
| 3648 void test_constructorName() { |
| 3649 ConstructorName node = |
| 3650 AstFactory.constructorName(AstFactory.typeName4("C"), "n"); |
| 3651 _assertReplace(node, new Getter_NodeReplacerTest_test_constructorName()); |
| 3652 _assertReplace(node, new Getter_NodeReplacerTest_test_constructorName_2()); |
| 3653 } |
| 3654 |
| 3655 void test_continueStatement() { |
| 3656 ContinueStatement node = AstFactory.continueStatement("l"); |
| 3657 _assertReplace(node, new Getter_NodeReplacerTest_test_continueStatement()); |
| 3658 } |
| 3659 |
| 3660 void test_declaredIdentifier() { |
| 3661 DeclaredIdentifier node = |
| 3662 AstFactory.declaredIdentifier4(AstFactory.typeName4("C"), "i"); |
| 3663 node.documentationComment = |
| 3664 Comment.createEndOfLineComment(EMPTY_TOKEN_LIST); |
| 3665 node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a"))); |
| 3666 _assertReplace(node, new Getter_NodeReplacerTest_test_declaredIdentifier()); |
| 3667 _assertReplace( |
| 3668 node, new Getter_NodeReplacerTest_test_declaredIdentifier_2()); |
| 3669 _testAnnotatedNode(node); |
| 3670 } |
| 3671 |
| 3672 void test_defaultFormalParameter() { |
| 3673 DefaultFormalParameter node = AstFactory.positionalFormalParameter( |
| 3674 AstFactory.simpleFormalParameter3("p"), AstFactory.integer(0)); |
| 3675 _assertReplace( |
| 3676 node, new Getter_NodeReplacerTest_test_defaultFormalParameter()); |
| 3677 _assertReplace( |
| 3678 node, new Getter_NodeReplacerTest_test_defaultFormalParameter_2()); |
| 3679 } |
| 3680 |
| 3681 void test_doStatement() { |
| 3682 DoStatement node = AstFactory.doStatement( |
| 3683 AstFactory.block(), AstFactory.booleanLiteral(true)); |
| 3684 _assertReplace(node, new Getter_NodeReplacerTest_test_doStatement_2()); |
| 3685 _assertReplace(node, new Getter_NodeReplacerTest_test_doStatement()); |
| 3686 } |
| 3687 |
| 3688 void test_enumConstantDeclaration() { |
| 3689 EnumConstantDeclaration node = new EnumConstantDeclaration( |
| 3690 Comment.createEndOfLineComment(EMPTY_TOKEN_LIST), |
| 3691 [AstFactory.annotation(AstFactory.identifier3("a"))], |
| 3692 AstFactory.identifier3("C")); |
| 3693 _assertReplace( |
| 3694 node, new Getter_NodeReplacerTest_test_enumConstantDeclaration()); |
| 3695 _testAnnotatedNode(node); |
| 3696 } |
| 3697 |
| 3698 void test_enumDeclaration() { |
| 3699 EnumDeclaration node = AstFactory.enumDeclaration2("E", ["ONE", "TWO"]); |
| 3700 node.documentationComment = |
| 3701 Comment.createEndOfLineComment(EMPTY_TOKEN_LIST); |
| 3702 node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a"))); |
| 3703 _assertReplace(node, new Getter_NodeReplacerTest_test_enumDeclaration()); |
| 3704 _testAnnotatedNode(node); |
| 3705 } |
| 3706 |
| 3707 void test_exportDirective() { |
| 3708 ExportDirective node = AstFactory.exportDirective2("", [ |
| 3709 AstFactory.hideCombinator2(["C"]) |
| 3710 ]); |
| 3711 node.documentationComment = |
| 3712 Comment.createEndOfLineComment(EMPTY_TOKEN_LIST); |
| 3713 node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a"))); |
| 3714 _testNamespaceDirective(node); |
| 3715 } |
| 3716 |
| 3717 void test_expressionFunctionBody() { |
| 3718 ExpressionFunctionBody node = |
| 3719 AstFactory.expressionFunctionBody(AstFactory.integer(0)); |
| 3720 _assertReplace( |
| 3721 node, new Getter_NodeReplacerTest_test_expressionFunctionBody()); |
| 3722 } |
| 3723 |
| 3724 void test_expressionStatement() { |
| 3725 ExpressionStatement node = |
| 3726 AstFactory.expressionStatement(AstFactory.integer(0)); |
| 3727 _assertReplace( |
| 3728 node, new Getter_NodeReplacerTest_test_expressionStatement()); |
| 3729 } |
| 3730 |
| 3731 void test_extendsClause() { |
| 3732 ExtendsClause node = AstFactory.extendsClause(AstFactory.typeName4("S")); |
| 3733 _assertReplace(node, new Getter_NodeReplacerTest_test_extendsClause()); |
| 3734 } |
| 3735 |
| 3736 void test_fieldDeclaration() { |
| 3737 FieldDeclaration node = AstFactory.fieldDeclaration(false, null, |
| 3738 AstFactory.typeName4("C"), [AstFactory.variableDeclaration("c")]); |
| 3739 node.documentationComment = |
| 3740 Comment.createEndOfLineComment(EMPTY_TOKEN_LIST); |
| 3741 node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a"))); |
| 3742 _assertReplace(node, new Getter_NodeReplacerTest_test_fieldDeclaration()); |
| 3743 _testAnnotatedNode(node); |
| 3744 } |
| 3745 |
| 3746 void test_fieldFormalParameter() { |
| 3747 FieldFormalParameter node = AstFactory.fieldFormalParameter( |
| 3748 null, AstFactory.typeName4("C"), "f", AstFactory.formalParameterList()); |
| 3749 node.documentationComment = |
| 3750 Comment.createEndOfLineComment(EMPTY_TOKEN_LIST); |
| 3751 node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))]; |
| 3752 _assertReplace( |
| 3753 node, new Getter_NodeReplacerTest_test_fieldFormalParameter_2()); |
| 3754 _assertReplace( |
| 3755 node, new Getter_NodeReplacerTest_test_fieldFormalParameter()); |
| 3756 _testNormalFormalParameter(node); |
| 3757 } |
| 3758 |
| 3759 void test_forEachStatement_withIdentifier() { |
| 3760 ForEachStatement node = AstFactory.forEachStatement2( |
| 3761 AstFactory.identifier3("i"), |
| 3762 AstFactory.identifier3("l"), |
| 3763 AstFactory.block()); |
| 3764 _assertReplace(node, |
| 3765 new Getter_NodeReplacerTest_test_forEachStatement_withIdentifier_2()); |
| 3766 _assertReplace(node, |
| 3767 new Getter_NodeReplacerTest_test_forEachStatement_withIdentifier_3()); |
| 3768 _assertReplace(node, |
| 3769 new Getter_NodeReplacerTest_test_forEachStatement_withIdentifier()); |
| 3770 } |
| 3771 |
| 3772 void test_forEachStatement_withLoopVariable() { |
| 3773 ForEachStatement node = AstFactory.forEachStatement( |
| 3774 AstFactory.declaredIdentifier3("e"), |
| 3775 AstFactory.identifier3("l"), |
| 3776 AstFactory.block()); |
| 3777 _assertReplace(node, |
| 3778 new Getter_NodeReplacerTest_test_forEachStatement_withLoopVariable_2()); |
| 3779 _assertReplace(node, |
| 3780 new Getter_NodeReplacerTest_test_forEachStatement_withLoopVariable()); |
| 3781 _assertReplace(node, |
| 3782 new Getter_NodeReplacerTest_test_forEachStatement_withLoopVariable_3()); |
| 3783 } |
| 3784 |
| 3785 void test_formalParameterList() { |
| 3786 FormalParameterList node = AstFactory |
| 3787 .formalParameterList([AstFactory.simpleFormalParameter3("p")]); |
| 3788 _assertReplace( |
| 3789 node, new ListGetter_NodeReplacerTest_test_formalParameterList(0)); |
| 3790 } |
| 3791 |
| 3792 void test_forStatement_withInitialization() { |
| 3793 ForStatement node = AstFactory.forStatement( |
| 3794 AstFactory.identifier3("a"), |
| 3795 AstFactory.booleanLiteral(true), |
| 3796 [AstFactory.integer(0)], |
| 3797 AstFactory.block()); |
| 3798 _assertReplace(node, |
| 3799 new Getter_NodeReplacerTest_test_forStatement_withInitialization_3()); |
| 3800 _assertReplace(node, |
| 3801 new Getter_NodeReplacerTest_test_forStatement_withInitialization_2()); |
| 3802 _assertReplace(node, |
| 3803 new Getter_NodeReplacerTest_test_forStatement_withInitialization()); |
| 3804 _assertReplace( |
| 3805 node, |
| 3806 new ListGetter_NodeReplacerTest_test_forStatement_withInitialization( |
| 3807 0)); |
| 3808 } |
| 3809 |
| 3810 void test_forStatement_withVariables() { |
| 3811 ForStatement node = AstFactory.forStatement2( |
| 3812 AstFactory.variableDeclarationList2( |
| 3813 null, [AstFactory.variableDeclaration("i")]), |
| 3814 AstFactory.booleanLiteral(true), |
| 3815 [AstFactory.integer(0)], |
| 3816 AstFactory.block()); |
| 3817 _assertReplace( |
| 3818 node, new Getter_NodeReplacerTest_test_forStatement_withVariables_2()); |
| 3819 _assertReplace( |
| 3820 node, new Getter_NodeReplacerTest_test_forStatement_withVariables_3()); |
| 3821 _assertReplace( |
| 3822 node, new Getter_NodeReplacerTest_test_forStatement_withVariables()); |
| 3823 _assertReplace(node, |
| 3824 new ListGetter_NodeReplacerTest_test_forStatement_withVariables(0)); |
| 3825 } |
| 3826 |
| 3827 void test_functionDeclaration() { |
| 3828 FunctionDeclaration node = AstFactory.functionDeclaration( |
| 3829 AstFactory.typeName4("R"), |
| 3830 null, |
| 3831 "f", |
| 3832 AstFactory.functionExpression2(AstFactory.formalParameterList(), |
| 3833 AstFactory.blockFunctionBody(AstFactory.block()))); |
| 3834 node.documentationComment = |
| 3835 Comment.createEndOfLineComment(EMPTY_TOKEN_LIST); |
| 3836 node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a"))); |
| 3837 _assertReplace( |
| 3838 node, new Getter_NodeReplacerTest_test_functionDeclaration()); |
| 3839 _assertReplace( |
| 3840 node, new Getter_NodeReplacerTest_test_functionDeclaration_3()); |
| 3841 _assertReplace( |
| 3842 node, new Getter_NodeReplacerTest_test_functionDeclaration_2()); |
| 3843 _testAnnotatedNode(node); |
| 3844 } |
| 3845 |
| 3846 void test_functionDeclarationStatement() { |
| 3847 FunctionDeclarationStatement node = AstFactory.functionDeclarationStatement( |
| 3848 AstFactory.typeName4("R"), |
| 3849 null, |
| 3850 "f", |
| 3851 AstFactory.functionExpression2(AstFactory.formalParameterList(), |
| 3852 AstFactory.blockFunctionBody(AstFactory.block()))); |
| 3853 _assertReplace( |
| 3854 node, new Getter_NodeReplacerTest_test_functionDeclarationStatement()); |
| 3855 } |
| 3856 |
| 3857 void test_functionExpression() { |
| 3858 FunctionExpression node = AstFactory.functionExpression2( |
| 3859 AstFactory.formalParameterList(), |
| 3860 AstFactory.blockFunctionBody(AstFactory.block())); |
| 3861 _assertReplace(node, new Getter_NodeReplacerTest_test_functionExpression()); |
| 3862 _assertReplace( |
| 3863 node, new Getter_NodeReplacerTest_test_functionExpression_2()); |
| 3864 } |
| 3865 |
| 3866 void test_functionExpressionInvocation() { |
| 3867 FunctionExpressionInvocation node = AstFactory.functionExpressionInvocation( |
| 3868 AstFactory.identifier3("f"), [AstFactory.integer(0)]); |
| 3869 _assertReplace( |
| 3870 node, new Getter_NodeReplacerTest_test_functionExpressionInvocation()); |
| 3871 _assertReplace(node, |
| 3872 new Getter_NodeReplacerTest_test_functionExpressionInvocation_2()); |
| 3873 } |
| 3874 |
| 3875 void test_functionTypeAlias() { |
| 3876 FunctionTypeAlias node = AstFactory.typeAlias( |
| 3877 AstFactory.typeName4("R"), |
| 3878 "F", |
| 3879 AstFactory.typeParameterList(["E"]), |
| 3880 AstFactory.formalParameterList()); |
| 3881 node.documentationComment = |
| 3882 Comment.createEndOfLineComment(EMPTY_TOKEN_LIST); |
| 3883 node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a"))); |
| 3884 _assertReplace( |
| 3885 node, new Getter_NodeReplacerTest_test_functionTypeAlias_3()); |
| 3886 _assertReplace( |
| 3887 node, new Getter_NodeReplacerTest_test_functionTypeAlias_4()); |
| 3888 _assertReplace(node, new Getter_NodeReplacerTest_test_functionTypeAlias()); |
| 3889 _assertReplace( |
| 3890 node, new Getter_NodeReplacerTest_test_functionTypeAlias_2()); |
| 3891 _testAnnotatedNode(node); |
| 3892 } |
| 3893 |
| 3894 void test_functionTypedFormalParameter() { |
| 3895 FunctionTypedFormalParameter node = AstFactory.functionTypedFormalParameter( |
| 3896 AstFactory.typeName4("R"), |
| 3897 "f", |
| 3898 [AstFactory.simpleFormalParameter3("p")]); |
| 3899 node.documentationComment = |
| 3900 Comment.createEndOfLineComment(EMPTY_TOKEN_LIST); |
| 3901 node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))]; |
| 3902 _assertReplace( |
| 3903 node, new Getter_NodeReplacerTest_test_functionTypedFormalParameter()); |
| 3904 _assertReplace(node, |
| 3905 new Getter_NodeReplacerTest_test_functionTypedFormalParameter_2()); |
| 3906 _testNormalFormalParameter(node); |
| 3907 } |
| 3908 |
| 3909 void test_hideCombinator() { |
| 3910 HideCombinator node = AstFactory.hideCombinator2(["A", "B"]); |
| 3911 _assertReplace( |
| 3912 node, new ListGetter_NodeReplacerTest_test_hideCombinator(0)); |
| 3913 } |
| 3914 |
| 3915 void test_ifStatement() { |
| 3916 IfStatement node = AstFactory.ifStatement2(AstFactory.booleanLiteral(true), |
| 3917 AstFactory.block(), AstFactory.block()); |
| 3918 _assertReplace(node, new Getter_NodeReplacerTest_test_ifStatement()); |
| 3919 _assertReplace(node, new Getter_NodeReplacerTest_test_ifStatement_3()); |
| 3920 _assertReplace(node, new Getter_NodeReplacerTest_test_ifStatement_2()); |
| 3921 } |
| 3922 |
| 3923 void test_implementsClause() { |
| 3924 ImplementsClause node = AstFactory.implementsClause( |
| 3925 [AstFactory.typeName4("I"), AstFactory.typeName4("J")]); |
| 3926 _assertReplace( |
| 3927 node, new ListGetter_NodeReplacerTest_test_implementsClause(0)); |
| 3928 } |
| 3929 |
| 3930 void test_importDirective() { |
| 3931 ImportDirective node = AstFactory.importDirective3("", "p", [ |
| 3932 AstFactory.showCombinator2(["A"]), |
| 3933 AstFactory.hideCombinator2(["B"]) |
| 3934 ]); |
| 3935 node.documentationComment = |
| 3936 Comment.createEndOfLineComment(EMPTY_TOKEN_LIST); |
| 3937 node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a"))); |
| 3938 _assertReplace(node, new Getter_NodeReplacerTest_test_importDirective()); |
| 3939 _testNamespaceDirective(node); |
| 3940 } |
| 3941 |
| 3942 void test_indexExpression() { |
| 3943 IndexExpression node = AstFactory.indexExpression( |
| 3944 AstFactory.identifier3("a"), AstFactory.identifier3("i")); |
| 3945 _assertReplace(node, new Getter_NodeReplacerTest_test_indexExpression()); |
| 3946 _assertReplace(node, new Getter_NodeReplacerTest_test_indexExpression_2()); |
| 3947 } |
| 3948 |
| 3949 void test_instanceCreationExpression() { |
| 3950 InstanceCreationExpression node = AstFactory.instanceCreationExpression3( |
| 3951 null, AstFactory.typeName4("C"), "c", [AstFactory.integer(2)]); |
| 3952 _assertReplace( |
| 3953 node, new Getter_NodeReplacerTest_test_instanceCreationExpression_2()); |
| 3954 _assertReplace( |
| 3955 node, new Getter_NodeReplacerTest_test_instanceCreationExpression()); |
| 3956 } |
| 3957 |
| 3958 void test_interpolationExpression() { |
| 3959 InterpolationExpression node = AstFactory.interpolationExpression2("x"); |
| 3960 _assertReplace( |
| 3961 node, new Getter_NodeReplacerTest_test_interpolationExpression()); |
| 3962 } |
| 3963 |
| 3964 void test_isExpression() { |
| 3965 IsExpression node = AstFactory.isExpression( |
| 3966 AstFactory.identifier3("v"), false, AstFactory.typeName4("T")); |
| 3967 _assertReplace(node, new Getter_NodeReplacerTest_test_isExpression()); |
| 3968 _assertReplace(node, new Getter_NodeReplacerTest_test_isExpression_2()); |
| 3969 } |
| 3970 |
| 3971 void test_label() { |
| 3972 Label node = AstFactory.label2("l"); |
| 3973 _assertReplace(node, new Getter_NodeReplacerTest_test_label()); |
| 3974 } |
| 3975 |
| 3976 void test_labeledStatement() { |
| 3977 LabeledStatement node = AstFactory.labeledStatement( |
| 3978 [AstFactory.label2("l")], AstFactory.block()); |
| 3979 _assertReplace( |
| 3980 node, new ListGetter_NodeReplacerTest_test_labeledStatement(0)); |
| 3981 _assertReplace(node, new Getter_NodeReplacerTest_test_labeledStatement()); |
| 3982 } |
| 3983 |
| 3984 void test_libraryDirective() { |
| 3985 LibraryDirective node = AstFactory.libraryDirective2("lib"); |
| 3986 node.documentationComment = |
| 3987 Comment.createEndOfLineComment(EMPTY_TOKEN_LIST); |
| 3988 node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a"))); |
| 3989 _assertReplace(node, new Getter_NodeReplacerTest_test_libraryDirective()); |
| 3990 _testAnnotatedNode(node); |
| 3991 } |
| 3992 |
| 3993 void test_libraryIdentifier() { |
| 3994 LibraryIdentifier node = AstFactory.libraryIdentifier2(["lib"]); |
| 3995 _assertReplace( |
| 3996 node, new ListGetter_NodeReplacerTest_test_libraryIdentifier(0)); |
| 3997 } |
| 3998 |
| 3999 void test_listLiteral() { |
| 4000 ListLiteral node = AstFactory.listLiteral2( |
| 4001 null, |
| 4002 AstFactory.typeArgumentList([AstFactory.typeName4("E")]), |
| 4003 [AstFactory.identifier3("e")]); |
| 4004 _assertReplace(node, new ListGetter_NodeReplacerTest_test_listLiteral(0)); |
| 4005 _testTypedLiteral(node); |
| 4006 } |
| 4007 |
| 4008 void test_mapLiteral() { |
| 4009 MapLiteral node = AstFactory.mapLiteral( |
| 4010 null, |
| 4011 AstFactory.typeArgumentList([AstFactory.typeName4("E")]), |
| 4012 [AstFactory.mapLiteralEntry("k", AstFactory.identifier3("v"))]); |
| 4013 _assertReplace(node, new ListGetter_NodeReplacerTest_test_mapLiteral(0)); |
| 4014 _testTypedLiteral(node); |
| 4015 } |
| 4016 |
| 4017 void test_mapLiteralEntry() { |
| 4018 MapLiteralEntry node = |
| 4019 AstFactory.mapLiteralEntry("k", AstFactory.identifier3("v")); |
| 4020 _assertReplace(node, new Getter_NodeReplacerTest_test_mapLiteralEntry_2()); |
| 4021 _assertReplace(node, new Getter_NodeReplacerTest_test_mapLiteralEntry()); |
| 4022 } |
| 4023 |
| 4024 void test_methodDeclaration() { |
| 4025 MethodDeclaration node = AstFactory.methodDeclaration2( |
| 4026 null, |
| 4027 AstFactory.typeName4("A"), |
| 4028 null, |
| 4029 null, |
| 4030 AstFactory.identifier3("m"), |
| 4031 AstFactory.formalParameterList(), |
| 4032 AstFactory.blockFunctionBody(AstFactory.block())); |
| 4033 node.documentationComment = |
| 4034 Comment.createEndOfLineComment(EMPTY_TOKEN_LIST); |
| 4035 node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a"))); |
| 4036 _assertReplace(node, new Getter_NodeReplacerTest_test_methodDeclaration()); |
| 4037 _assertReplace( |
| 4038 node, new Getter_NodeReplacerTest_test_methodDeclaration_3()); |
| 4039 _assertReplace( |
| 4040 node, new Getter_NodeReplacerTest_test_methodDeclaration_4()); |
| 4041 _assertReplace( |
| 4042 node, new Getter_NodeReplacerTest_test_methodDeclaration_2()); |
| 4043 _testAnnotatedNode(node); |
| 4044 } |
| 4045 |
| 4046 void test_methodInvocation() { |
| 4047 MethodInvocation node = AstFactory.methodInvocation( |
| 4048 AstFactory.identifier3("t"), "m", [AstFactory.integer(0)]); |
| 4049 _assertReplace(node, new Getter_NodeReplacerTest_test_methodInvocation_2()); |
| 4050 _assertReplace(node, new Getter_NodeReplacerTest_test_methodInvocation_3()); |
| 4051 _assertReplace(node, new Getter_NodeReplacerTest_test_methodInvocation()); |
| 4052 } |
| 4053 |
| 4054 void test_namedExpression() { |
| 4055 NamedExpression node = |
| 4056 AstFactory.namedExpression2("l", AstFactory.identifier3("v")); |
| 4057 _assertReplace(node, new Getter_NodeReplacerTest_test_namedExpression()); |
| 4058 _assertReplace(node, new Getter_NodeReplacerTest_test_namedExpression_2()); |
| 4059 } |
| 4060 |
| 4061 void test_nativeClause() { |
| 4062 NativeClause node = AstFactory.nativeClause(""); |
| 4063 _assertReplace(node, new Getter_NodeReplacerTest_test_nativeClause()); |
| 4064 } |
| 4065 |
| 4066 void test_nativeFunctionBody() { |
| 4067 NativeFunctionBody node = AstFactory.nativeFunctionBody("m"); |
| 4068 _assertReplace(node, new Getter_NodeReplacerTest_test_nativeFunctionBody()); |
| 4069 } |
| 4070 |
| 4071 void test_parenthesizedExpression() { |
| 4072 ParenthesizedExpression node = |
| 4073 AstFactory.parenthesizedExpression(AstFactory.integer(0)); |
| 4074 _assertReplace( |
| 4075 node, new Getter_NodeReplacerTest_test_parenthesizedExpression()); |
| 4076 } |
| 4077 |
| 4078 void test_partDirective() { |
| 4079 PartDirective node = AstFactory.partDirective2(""); |
| 4080 node.documentationComment = |
| 4081 Comment.createEndOfLineComment(EMPTY_TOKEN_LIST); |
| 4082 node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a"))); |
| 4083 _testUriBasedDirective(node); |
| 4084 } |
| 4085 |
| 4086 void test_partOfDirective() { |
| 4087 PartOfDirective node = |
| 4088 AstFactory.partOfDirective(AstFactory.libraryIdentifier2(["lib"])); |
| 4089 node.documentationComment = |
| 4090 Comment.createEndOfLineComment(EMPTY_TOKEN_LIST); |
| 4091 node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a"))); |
| 4092 _assertReplace(node, new Getter_NodeReplacerTest_test_partOfDirective()); |
| 4093 _testAnnotatedNode(node); |
| 4094 } |
| 4095 |
| 4096 void test_postfixExpression() { |
| 4097 PostfixExpression node = AstFactory.postfixExpression( |
| 4098 AstFactory.identifier3("x"), TokenType.MINUS_MINUS); |
| 4099 _assertReplace(node, new Getter_NodeReplacerTest_test_postfixExpression()); |
| 4100 } |
| 4101 |
| 4102 void test_prefixedIdentifier() { |
| 4103 PrefixedIdentifier node = AstFactory.identifier5("a", "b"); |
| 4104 _assertReplace( |
| 4105 node, new Getter_NodeReplacerTest_test_prefixedIdentifier_2()); |
| 4106 _assertReplace(node, new Getter_NodeReplacerTest_test_prefixedIdentifier()); |
| 4107 } |
| 4108 |
| 4109 void test_prefixExpression() { |
| 4110 PrefixExpression node = AstFactory.prefixExpression( |
| 4111 TokenType.PLUS_PLUS, AstFactory.identifier3("y")); |
| 4112 _assertReplace(node, new Getter_NodeReplacerTest_test_prefixExpression()); |
| 4113 } |
| 4114 |
| 4115 void test_propertyAccess() { |
| 4116 PropertyAccess node = |
| 4117 AstFactory.propertyAccess2(AstFactory.identifier3("x"), "y"); |
| 4118 _assertReplace(node, new Getter_NodeReplacerTest_test_propertyAccess()); |
| 4119 _assertReplace(node, new Getter_NodeReplacerTest_test_propertyAccess_2()); |
| 4120 } |
| 4121 |
| 4122 void test_redirectingConstructorInvocation() { |
| 4123 RedirectingConstructorInvocation node = AstFactory |
| 4124 .redirectingConstructorInvocation2("c", [AstFactory.integer(0)]); |
| 4125 _assertReplace(node, |
| 4126 new Getter_NodeReplacerTest_test_redirectingConstructorInvocation()); |
| 4127 _assertReplace(node, |
| 4128 new Getter_NodeReplacerTest_test_redirectingConstructorInvocation_2()); |
| 4129 } |
| 4130 |
| 4131 void test_returnStatement() { |
| 4132 ReturnStatement node = AstFactory.returnStatement2(AstFactory.integer(0)); |
| 4133 _assertReplace(node, new Getter_NodeReplacerTest_test_returnStatement()); |
| 4134 } |
| 4135 |
| 4136 void test_showCombinator() { |
| 4137 ShowCombinator node = AstFactory.showCombinator2(["X", "Y"]); |
| 4138 _assertReplace( |
| 4139 node, new ListGetter_NodeReplacerTest_test_showCombinator(0)); |
| 4140 } |
| 4141 |
| 4142 void test_simpleFormalParameter() { |
| 4143 SimpleFormalParameter node = |
| 4144 AstFactory.simpleFormalParameter4(AstFactory.typeName4("T"), "p"); |
| 4145 node.documentationComment = |
| 4146 Comment.createEndOfLineComment(EMPTY_TOKEN_LIST); |
| 4147 node.metadata = [AstFactory.annotation(AstFactory.identifier3("a"))]; |
| 4148 _assertReplace( |
| 4149 node, new Getter_NodeReplacerTest_test_simpleFormalParameter()); |
| 4150 _testNormalFormalParameter(node); |
| 4151 } |
| 4152 |
| 4153 void test_stringInterpolation() { |
| 4154 StringInterpolation node = |
| 4155 AstFactory.string([AstFactory.interpolationExpression2("a")]); |
| 4156 _assertReplace( |
| 4157 node, new ListGetter_NodeReplacerTest_test_stringInterpolation(0)); |
| 4158 } |
| 4159 |
| 4160 void test_superConstructorInvocation() { |
| 4161 SuperConstructorInvocation node = |
| 4162 AstFactory.superConstructorInvocation2("s", [AstFactory.integer(1)]); |
| 4163 _assertReplace( |
| 4164 node, new Getter_NodeReplacerTest_test_superConstructorInvocation()); |
| 4165 _assertReplace( |
| 4166 node, new Getter_NodeReplacerTest_test_superConstructorInvocation_2()); |
| 4167 } |
| 4168 |
| 4169 void test_switchCase() { |
| 4170 SwitchCase node = AstFactory.switchCase2( |
| 4171 [AstFactory.label2("l")], AstFactory.integer(0), [AstFactory.block()]); |
| 4172 _assertReplace(node, new Getter_NodeReplacerTest_test_switchCase()); |
| 4173 _testSwitchMember(node); |
| 4174 } |
| 4175 |
| 4176 void test_switchDefault() { |
| 4177 SwitchDefault node = AstFactory.switchDefault( |
| 4178 [AstFactory.label2("l")], [AstFactory.block()]); |
| 4179 _testSwitchMember(node); |
| 4180 } |
| 4181 |
| 4182 void test_switchStatement() { |
| 4183 SwitchStatement node = |
| 4184 AstFactory.switchStatement(AstFactory.identifier3("x"), [ |
| 4185 AstFactory.switchCase2([AstFactory.label2("l")], AstFactory.integer(0), |
| 4186 [AstFactory.block()]), |
| 4187 AstFactory.switchDefault([AstFactory.label2("l")], [AstFactory.block()]) |
| 4188 ]); |
| 4189 _assertReplace(node, new Getter_NodeReplacerTest_test_switchStatement()); |
| 4190 _assertReplace( |
| 4191 node, new ListGetter_NodeReplacerTest_test_switchStatement(0)); |
| 4192 } |
| 4193 |
| 4194 void test_throwExpression() { |
| 4195 ThrowExpression node = |
| 4196 AstFactory.throwExpression2(AstFactory.identifier3("e")); |
| 4197 _assertReplace(node, new Getter_NodeReplacerTest_test_throwExpression()); |
| 4198 } |
| 4199 |
| 4200 void test_topLevelVariableDeclaration() { |
| 4201 TopLevelVariableDeclaration node = AstFactory.topLevelVariableDeclaration( |
| 4202 null, AstFactory.typeName4("T"), [AstFactory.variableDeclaration("t")]); |
| 4203 node.documentationComment = |
| 4204 Comment.createEndOfLineComment(EMPTY_TOKEN_LIST); |
| 4205 node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a"))); |
| 4206 _assertReplace( |
| 4207 node, new Getter_NodeReplacerTest_test_topLevelVariableDeclaration()); |
| 4208 _testAnnotatedNode(node); |
| 4209 } |
| 4210 |
| 4211 void test_tryStatement() { |
| 4212 TryStatement node = AstFactory.tryStatement3( |
| 4213 AstFactory.block(), |
| 4214 [ |
| 4215 AstFactory.catchClause("e", [AstFactory.block()]) |
| 4216 ], |
| 4217 AstFactory.block()); |
| 4218 _assertReplace(node, new Getter_NodeReplacerTest_test_tryStatement_2()); |
| 4219 _assertReplace(node, new Getter_NodeReplacerTest_test_tryStatement()); |
| 4220 _assertReplace(node, new ListGetter_NodeReplacerTest_test_tryStatement(0)); |
| 4221 } |
| 4222 |
| 4223 void test_typeArgumentList() { |
| 4224 TypeArgumentList node = |
| 4225 AstFactory.typeArgumentList([AstFactory.typeName4("A")]); |
| 4226 _assertReplace( |
| 4227 node, new ListGetter_NodeReplacerTest_test_typeArgumentList(0)); |
| 4228 } |
| 4229 |
| 4230 void test_typeName() { |
| 4231 TypeName node = AstFactory.typeName4( |
| 4232 "T", [AstFactory.typeName4("E"), AstFactory.typeName4("F")]); |
| 4233 _assertReplace(node, new Getter_NodeReplacerTest_test_typeName_2()); |
| 4234 _assertReplace(node, new Getter_NodeReplacerTest_test_typeName()); |
| 4235 } |
| 4236 |
| 4237 void test_typeParameter() { |
| 4238 TypeParameter node = |
| 4239 AstFactory.typeParameter2("E", AstFactory.typeName4("B")); |
| 4240 _assertReplace(node, new Getter_NodeReplacerTest_test_typeParameter_2()); |
| 4241 _assertReplace(node, new Getter_NodeReplacerTest_test_typeParameter()); |
| 4242 } |
| 4243 |
| 4244 void test_typeParameterList() { |
| 4245 TypeParameterList node = AstFactory.typeParameterList(["A", "B"]); |
| 4246 _assertReplace( |
| 4247 node, new ListGetter_NodeReplacerTest_test_typeParameterList(0)); |
| 4248 } |
| 4249 |
| 4250 void test_variableDeclaration() { |
| 4251 VariableDeclaration node = |
| 4252 AstFactory.variableDeclaration2("a", AstFactory.nullLiteral()); |
| 4253 node.documentationComment = |
| 4254 Comment.createEndOfLineComment(EMPTY_TOKEN_LIST); |
| 4255 node.metadata.add(AstFactory.annotation(AstFactory.identifier3("a"))); |
| 4256 _assertReplace( |
| 4257 node, new Getter_NodeReplacerTest_test_variableDeclaration()); |
| 4258 _assertReplace( |
| 4259 node, new Getter_NodeReplacerTest_test_variableDeclaration_2()); |
| 4260 _testAnnotatedNode(node); |
| 4261 } |
| 4262 |
| 4263 void test_variableDeclarationList() { |
| 4264 VariableDeclarationList node = AstFactory.variableDeclarationList( |
| 4265 null, AstFactory.typeName4("T"), [AstFactory.variableDeclaration("a")]); |
| 4266 _assertReplace( |
| 4267 node, new Getter_NodeReplacerTest_test_variableDeclarationList()); |
| 4268 _assertReplace( |
| 4269 node, new ListGetter_NodeReplacerTest_test_variableDeclarationList(0)); |
| 4270 } |
| 4271 |
| 4272 void test_variableDeclarationStatement() { |
| 4273 VariableDeclarationStatement node = AstFactory.variableDeclarationStatement( |
| 4274 null, AstFactory.typeName4("T"), [AstFactory.variableDeclaration("a")]); |
| 4275 _assertReplace( |
| 4276 node, new Getter_NodeReplacerTest_test_variableDeclarationStatement()); |
| 4277 } |
| 4278 |
| 4279 void test_whileStatement() { |
| 4280 WhileStatement node = AstFactory.whileStatement( |
| 4281 AstFactory.booleanLiteral(true), AstFactory.block()); |
| 4282 _assertReplace(node, new Getter_NodeReplacerTest_test_whileStatement()); |
| 4283 _assertReplace(node, new Getter_NodeReplacerTest_test_whileStatement_2()); |
| 4284 } |
| 4285 |
| 4286 void test_withClause() { |
| 4287 WithClause node = AstFactory.withClause([AstFactory.typeName4("M")]); |
| 4288 _assertReplace(node, new ListGetter_NodeReplacerTest_test_withClause(0)); |
| 4289 } |
| 4290 |
| 4291 void test_yieldStatement() { |
| 4292 var node = AstFactory.yieldStatement(AstFactory.identifier3("A")); |
| 4293 _assertReplace(node, new Getter_NodeReplacerTest_test_yieldStatement()); |
| 4294 } |
| 4295 |
| 4296 void _assertReplace(AstNode parent, NodeReplacerTest_Getter getter) { |
| 4297 AstNode child = getter.get(parent); |
| 4298 if (child != null) { |
| 4299 AstNode clone = child.accept(new AstCloner()); |
| 4300 NodeReplacer.replace(child, clone); |
| 4301 expect(getter.get(parent), clone); |
| 4302 expect(clone.parent, parent); |
| 4303 } |
| 4304 } |
| 4305 |
| 4306 void _testAnnotatedNode(AnnotatedNode node) { |
| 4307 _assertReplace(node, new Getter_NodeReplacerTest_testAnnotatedNode()); |
| 4308 _assertReplace(node, new ListGetter_NodeReplacerTest_testAnnotatedNode(0)); |
| 4309 } |
| 4310 |
| 4311 void _testNamespaceDirective(NamespaceDirective node) { |
| 4312 _assertReplace( |
| 4313 node, new ListGetter_NodeReplacerTest_testNamespaceDirective(0)); |
| 4314 _testUriBasedDirective(node); |
| 4315 } |
| 4316 |
| 4317 void _testNormalFormalParameter(NormalFormalParameter node) { |
| 4318 _assertReplace( |
| 4319 node, new Getter_NodeReplacerTest_testNormalFormalParameter_2()); |
| 4320 _assertReplace( |
| 4321 node, new Getter_NodeReplacerTest_testNormalFormalParameter()); |
| 4322 _assertReplace( |
| 4323 node, new ListGetter_NodeReplacerTest_testNormalFormalParameter(0)); |
| 4324 } |
| 4325 |
| 4326 void _testSwitchMember(SwitchMember node) { |
| 4327 _assertReplace(node, new ListGetter_NodeReplacerTest_testSwitchMember(0)); |
| 4328 _assertReplace(node, new ListGetter_NodeReplacerTest_testSwitchMember_2(0)); |
| 4329 } |
| 4330 |
| 4331 void _testTypedLiteral(TypedLiteral node) { |
| 4332 _assertReplace(node, new Getter_NodeReplacerTest_testTypedLiteral()); |
| 4333 } |
| 4334 |
| 4335 void _testUriBasedDirective(UriBasedDirective node) { |
| 4336 _assertReplace(node, new Getter_NodeReplacerTest_testUriBasedDirective()); |
| 4337 _testAnnotatedNode(node); |
| 4338 } |
| 4339 } |
| 4340 |
| 4341 abstract class NodeReplacerTest_Getter<P, C> { |
| 4342 C get(P parent); |
| 4343 } |
| 4344 |
| 4345 abstract class NodeReplacerTest_ListGetter<P extends AstNode, C extends AstNode> |
| 4346 implements NodeReplacerTest_Getter<P, C> { |
| 4347 final int _index; |
| 4348 |
| 4349 NodeReplacerTest_ListGetter(this._index); |
| 4350 |
| 4351 @override |
| 4352 C get(P parent) { |
| 4353 NodeList<C> list = getList(parent); |
| 4354 if (list.isEmpty) { |
| 4355 return null; |
| 4356 } |
| 4357 return list[_index]; |
| 4358 } |
| 4359 |
| 4360 NodeList<C> getList(P parent); |
| 4361 } |
| 4362 |
| 4363 @reflectiveTest |
| 4364 class SingleMapIteratorTest extends EngineTestCase { |
| 4365 void test_empty() { |
| 4366 Map<String, String> map = new HashMap<String, String>(); |
| 4367 SingleMapIterator<String, String> iterator = |
| 4368 new SingleMapIterator<String, String>(map); |
| 4369 expect(iterator.moveNext(), isFalse); |
| 4370 try { |
| 4371 iterator.key; |
| 4372 fail("Expected NoSuchElementException"); |
| 4373 } on NoSuchElementException { |
| 4374 // Expected |
| 4375 } |
| 4376 try { |
| 4377 iterator.value; |
| 4378 fail("Expected NoSuchElementException"); |
| 4379 } on NoSuchElementException { |
| 4380 // Expected |
| 4381 } |
| 4382 try { |
| 4383 iterator.value = "x"; |
| 4384 fail("Expected NoSuchElementException"); |
| 4385 } on NoSuchElementException { |
| 4386 // Expected |
| 4387 } |
| 4388 expect(iterator.moveNext(), isFalse); |
| 4389 } |
| 4390 |
| 4391 void test_multiple() { |
| 4392 Map<String, String> map = new HashMap<String, String>(); |
| 4393 map["k1"] = "v1"; |
| 4394 map["k2"] = "v2"; |
| 4395 map["k3"] = "v3"; |
| 4396 SingleMapIterator<String, String> iterator = |
| 4397 new SingleMapIterator<String, String>(map); |
| 4398 expect(iterator.moveNext(), isTrue); |
| 4399 expect(iterator.moveNext(), isTrue); |
| 4400 expect(iterator.moveNext(), isTrue); |
| 4401 expect(iterator.moveNext(), isFalse); |
| 4402 } |
| 4403 |
| 4404 void test_single() { |
| 4405 String key = "key"; |
| 4406 String value = "value"; |
| 4407 Map<String, String> map = new HashMap<String, String>(); |
| 4408 map[key] = value; |
| 4409 SingleMapIterator<String, String> iterator = |
| 4410 new SingleMapIterator<String, String>(map); |
| 4411 expect(iterator.moveNext(), isTrue); |
| 4412 expect(iterator.key, same(key)); |
| 4413 expect(iterator.value, same(value)); |
| 4414 String newValue = "newValue"; |
| 4415 iterator.value = newValue; |
| 4416 expect(iterator.value, same(newValue)); |
| 4417 expect(iterator.moveNext(), isFalse); |
| 4418 } |
| 4419 } |
| 4420 |
| 4421 @reflectiveTest |
| 4422 class SourceRangeTest { |
| 4423 void test_access() { |
| 4424 SourceRange r = new SourceRange(10, 1); |
| 4425 expect(r.offset, 10); |
| 4426 expect(r.length, 1); |
| 4427 expect(r.end, 10 + 1); |
| 4428 // to check |
| 4429 r.hashCode; |
| 4430 } |
| 4431 |
| 4432 void test_contains() { |
| 4433 SourceRange r = new SourceRange(5, 10); |
| 4434 expect(r.contains(5), isTrue); |
| 4435 expect(r.contains(10), isTrue); |
| 4436 expect(r.contains(14), isTrue); |
| 4437 expect(r.contains(0), isFalse); |
| 4438 expect(r.contains(15), isFalse); |
| 4439 } |
| 4440 |
| 4441 void test_containsExclusive() { |
| 4442 SourceRange r = new SourceRange(5, 10); |
| 4443 expect(r.containsExclusive(5), isFalse); |
| 4444 expect(r.containsExclusive(10), isTrue); |
| 4445 expect(r.containsExclusive(14), isTrue); |
| 4446 expect(r.containsExclusive(0), isFalse); |
| 4447 expect(r.containsExclusive(15), isFalse); |
| 4448 } |
| 4449 |
| 4450 void test_coveredBy() { |
| 4451 SourceRange r = new SourceRange(5, 10); |
| 4452 // ends before |
| 4453 expect(r.coveredBy(new SourceRange(20, 10)), isFalse); |
| 4454 // starts after |
| 4455 expect(r.coveredBy(new SourceRange(0, 3)), isFalse); |
| 4456 // only intersects |
| 4457 expect(r.coveredBy(new SourceRange(0, 10)), isFalse); |
| 4458 expect(r.coveredBy(new SourceRange(10, 10)), isFalse); |
| 4459 // covered |
| 4460 expect(r.coveredBy(new SourceRange(0, 20)), isTrue); |
| 4461 expect(r.coveredBy(new SourceRange(5, 10)), isTrue); |
| 4462 } |
| 4463 |
| 4464 void test_covers() { |
| 4465 SourceRange r = new SourceRange(5, 10); |
| 4466 // ends before |
| 4467 expect(r.covers(new SourceRange(0, 3)), isFalse); |
| 4468 // starts after |
| 4469 expect(r.covers(new SourceRange(20, 3)), isFalse); |
| 4470 // only intersects |
| 4471 expect(r.covers(new SourceRange(0, 10)), isFalse); |
| 4472 expect(r.covers(new SourceRange(10, 10)), isFalse); |
| 4473 // covers |
| 4474 expect(r.covers(new SourceRange(5, 10)), isTrue); |
| 4475 expect(r.covers(new SourceRange(6, 9)), isTrue); |
| 4476 expect(r.covers(new SourceRange(6, 8)), isTrue); |
| 4477 } |
| 4478 |
| 4479 void test_endsIn() { |
| 4480 SourceRange r = new SourceRange(5, 10); |
| 4481 // ends before |
| 4482 expect(r.endsIn(new SourceRange(20, 10)), isFalse); |
| 4483 // starts after |
| 4484 expect(r.endsIn(new SourceRange(0, 3)), isFalse); |
| 4485 // ends |
| 4486 expect(r.endsIn(new SourceRange(10, 20)), isTrue); |
| 4487 expect(r.endsIn(new SourceRange(0, 20)), isTrue); |
| 4488 } |
| 4489 |
| 4490 void test_equals() { |
| 4491 SourceRange r = new SourceRange(10, 1); |
| 4492 expect(r == null, isFalse); |
| 4493 expect(r == this, isFalse); |
| 4494 expect(r == new SourceRange(20, 2), isFalse); |
| 4495 expect(r == new SourceRange(10, 1), isTrue); |
| 4496 expect(r == r, isTrue); |
| 4497 } |
| 4498 |
| 4499 void test_getExpanded() { |
| 4500 SourceRange r = new SourceRange(5, 3); |
| 4501 expect(r.getExpanded(0), r); |
| 4502 expect(r.getExpanded(2), new SourceRange(3, 7)); |
| 4503 expect(r.getExpanded(-1), new SourceRange(6, 1)); |
| 4504 } |
| 4505 |
| 4506 void test_getMoveEnd() { |
| 4507 SourceRange r = new SourceRange(5, 3); |
| 4508 expect(r.getMoveEnd(0), r); |
| 4509 expect(r.getMoveEnd(3), new SourceRange(5, 6)); |
| 4510 expect(r.getMoveEnd(-1), new SourceRange(5, 2)); |
| 4511 } |
| 4512 |
| 4513 void test_getTranslated() { |
| 4514 SourceRange r = new SourceRange(5, 3); |
| 4515 expect(r.getTranslated(0), r); |
| 4516 expect(r.getTranslated(2), new SourceRange(7, 3)); |
| 4517 expect(r.getTranslated(-1), new SourceRange(4, 3)); |
| 4518 } |
| 4519 |
| 4520 void test_getUnion() { |
| 4521 expect(new SourceRange(10, 10).getUnion(new SourceRange(15, 10)), |
| 4522 new SourceRange(10, 15)); |
| 4523 expect(new SourceRange(15, 10).getUnion(new SourceRange(10, 10)), |
| 4524 new SourceRange(10, 15)); |
| 4525 // "other" is covered/covers |
| 4526 expect(new SourceRange(10, 10).getUnion(new SourceRange(15, 2)), |
| 4527 new SourceRange(10, 10)); |
| 4528 expect(new SourceRange(15, 2).getUnion(new SourceRange(10, 10)), |
| 4529 new SourceRange(10, 10)); |
| 4530 } |
| 4531 |
| 4532 void test_intersects() { |
| 4533 SourceRange r = new SourceRange(5, 3); |
| 4534 // null |
| 4535 expect(r.intersects(null), isFalse); |
| 4536 // ends before |
| 4537 expect(r.intersects(new SourceRange(0, 5)), isFalse); |
| 4538 // begins after |
| 4539 expect(r.intersects(new SourceRange(8, 5)), isFalse); |
| 4540 // begins on same offset |
| 4541 expect(r.intersects(new SourceRange(5, 1)), isTrue); |
| 4542 // begins inside, ends inside |
| 4543 expect(r.intersects(new SourceRange(6, 1)), isTrue); |
| 4544 // begins inside, ends after |
| 4545 expect(r.intersects(new SourceRange(6, 10)), isTrue); |
| 4546 // begins before, ends after |
| 4547 expect(r.intersects(new SourceRange(0, 10)), isTrue); |
| 4548 } |
| 4549 |
| 4550 void test_startsIn() { |
| 4551 SourceRange r = new SourceRange(5, 10); |
| 4552 // ends before |
| 4553 expect(r.startsIn(new SourceRange(20, 10)), isFalse); |
| 4554 // starts after |
| 4555 expect(r.startsIn(new SourceRange(0, 3)), isFalse); |
| 4556 // starts |
| 4557 expect(r.startsIn(new SourceRange(5, 1)), isTrue); |
| 4558 expect(r.startsIn(new SourceRange(0, 20)), isTrue); |
| 4559 } |
| 4560 |
| 4561 void test_toString() { |
| 4562 SourceRange r = new SourceRange(10, 1); |
| 4563 expect(r.toString(), "[offset=10, length=1]"); |
| 4564 } |
| 4565 } |
| 4566 |
| 4567 @reflectiveTest |
| 4568 class StringUtilitiesTest { |
| 4569 void test_EMPTY() { |
| 4570 expect(StringUtilities.EMPTY, ""); |
| 4571 expect(StringUtilities.EMPTY.isEmpty, isTrue); |
| 4572 } |
| 4573 |
| 4574 void test_EMPTY_ARRAY() { |
| 4575 expect(StringUtilities.EMPTY_ARRAY.length, 0); |
| 4576 } |
| 4577 |
| 4578 void test_endsWith3() { |
| 4579 expect(StringUtilities.endsWith3("abc", 0x61, 0x62, 0x63), isTrue); |
| 4580 expect(StringUtilities.endsWith3("abcdefghi", 0x67, 0x68, 0x69), isTrue); |
| 4581 expect(StringUtilities.endsWith3("abcdefghi", 0x64, 0x65, 0x61), isFalse); |
| 4582 // missing |
| 4583 } |
| 4584 |
| 4585 void test_endsWithChar() { |
| 4586 expect(StringUtilities.endsWithChar("a", 0x61), isTrue); |
| 4587 expect(StringUtilities.endsWithChar("b", 0x61), isFalse); |
| 4588 expect(StringUtilities.endsWithChar("", 0x61), isFalse); |
| 4589 } |
| 4590 |
| 4591 void test_indexOf1() { |
| 4592 expect(StringUtilities.indexOf1("a", 0, 0x61), 0); |
| 4593 expect(StringUtilities.indexOf1("abcdef", 0, 0x61), 0); |
| 4594 expect(StringUtilities.indexOf1("abcdef", 0, 0x63), 2); |
| 4595 expect(StringUtilities.indexOf1("abcdef", 0, 0x66), 5); |
| 4596 expect(StringUtilities.indexOf1("abcdef", 0, 0x7A), -1); |
| 4597 expect(StringUtilities.indexOf1("abcdef", 1, 0x61), -1); |
| 4598 // before start |
| 4599 } |
| 4600 |
| 4601 void test_indexOf2() { |
| 4602 expect(StringUtilities.indexOf2("ab", 0, 0x61, 0x62), 0); |
| 4603 expect(StringUtilities.indexOf2("abcdef", 0, 0x61, 0x62), 0); |
| 4604 expect(StringUtilities.indexOf2("abcdef", 0, 0x63, 0x64), 2); |
| 4605 expect(StringUtilities.indexOf2("abcdef", 0, 0x65, 0x66), 4); |
| 4606 expect(StringUtilities.indexOf2("abcdef", 0, 0x64, 0x61), -1); |
| 4607 expect(StringUtilities.indexOf2("abcdef", 1, 0x61, 0x62), -1); |
| 4608 // before start |
| 4609 } |
| 4610 |
| 4611 void test_indexOf4() { |
| 4612 expect(StringUtilities.indexOf4("abcd", 0, 0x61, 0x62, 0x63, 0x64), 0); |
| 4613 expect(StringUtilities.indexOf4("abcdefghi", 0, 0x61, 0x62, 0x63, 0x64), 0); |
| 4614 expect(StringUtilities.indexOf4("abcdefghi", 0, 0x63, 0x64, 0x65, 0x66), 2); |
| 4615 expect(StringUtilities.indexOf4("abcdefghi", 0, 0x66, 0x67, 0x68, 0x69), 5); |
| 4616 expect( |
| 4617 StringUtilities.indexOf4("abcdefghi", 0, 0x64, 0x65, 0x61, 0x64), -1); |
| 4618 expect( |
| 4619 StringUtilities.indexOf4("abcdefghi", 1, 0x61, 0x62, 0x63, 0x64), -1); |
| 4620 // before start |
| 4621 } |
| 4622 |
| 4623 void test_indexOf5() { |
| 4624 expect( |
| 4625 StringUtilities.indexOf5("abcde", 0, 0x61, 0x62, 0x63, 0x64, 0x65), 0); |
| 4626 expect( |
| 4627 StringUtilities.indexOf5("abcdefghi", 0, 0x61, 0x62, 0x63, 0x64, 0x65), |
| 4628 0); |
| 4629 expect( |
| 4630 StringUtilities.indexOf5("abcdefghi", 0, 0x63, 0x64, 0x65, 0x66, 0x67), |
| 4631 2); |
| 4632 expect( |
| 4633 StringUtilities.indexOf5("abcdefghi", 0, 0x65, 0x66, 0x67, 0x68, 0x69), |
| 4634 4); |
| 4635 expect( |
| 4636 StringUtilities.indexOf5("abcdefghi", 0, 0x64, 0x65, 0x66, 0x69, 0x6E), |
| 4637 -1); |
| 4638 expect( |
| 4639 StringUtilities.indexOf5("abcdefghi", 1, 0x61, 0x62, 0x63, 0x64, 0x65), |
| 4640 -1); |
| 4641 // before start |
| 4642 } |
| 4643 |
| 4644 void test_isEmpty() { |
| 4645 expect(StringUtilities.isEmpty(""), isTrue); |
| 4646 expect(StringUtilities.isEmpty(" "), isFalse); |
| 4647 expect(StringUtilities.isEmpty("a"), isFalse); |
| 4648 expect(StringUtilities.isEmpty(StringUtilities.EMPTY), isTrue); |
| 4649 } |
| 4650 |
| 4651 void test_isTagName() { |
| 4652 expect(StringUtilities.isTagName(null), isFalse); |
| 4653 expect(StringUtilities.isTagName(""), isFalse); |
| 4654 expect(StringUtilities.isTagName("-"), isFalse); |
| 4655 expect(StringUtilities.isTagName("0"), isFalse); |
| 4656 expect(StringUtilities.isTagName("0a"), isFalse); |
| 4657 expect(StringUtilities.isTagName("a b"), isFalse); |
| 4658 expect(StringUtilities.isTagName("a0"), isTrue); |
| 4659 expect(StringUtilities.isTagName("a"), isTrue); |
| 4660 expect(StringUtilities.isTagName("ab"), isTrue); |
| 4661 expect(StringUtilities.isTagName("a-b"), isTrue); |
| 4662 } |
| 4663 |
| 4664 void test_printListOfQuotedNames_empty() { |
| 4665 try { |
| 4666 StringUtilities.printListOfQuotedNames(new List<String>(0)); |
| 4667 fail("Expected IllegalArgumentException"); |
| 4668 } on IllegalArgumentException { |
| 4669 // Expected |
| 4670 } |
| 4671 } |
| 4672 |
| 4673 void test_printListOfQuotedNames_five() { |
| 4674 expect( |
| 4675 StringUtilities |
| 4676 .printListOfQuotedNames(<String>["a", "b", "c", "d", "e"]), |
| 4677 "'a', 'b', 'c', 'd' and 'e'"); |
| 4678 } |
| 4679 |
| 4680 void test_printListOfQuotedNames_null() { |
| 4681 try { |
| 4682 StringUtilities.printListOfQuotedNames(null); |
| 4683 fail("Expected IllegalArgumentException"); |
| 4684 } on IllegalArgumentException { |
| 4685 // Expected |
| 4686 } |
| 4687 } |
| 4688 |
| 4689 void test_printListOfQuotedNames_one() { |
| 4690 try { |
| 4691 StringUtilities.printListOfQuotedNames(<String>["a"]); |
| 4692 fail("Expected IllegalArgumentException"); |
| 4693 } on IllegalArgumentException { |
| 4694 // Expected |
| 4695 } |
| 4696 } |
| 4697 |
| 4698 void test_printListOfQuotedNames_three() { |
| 4699 expect(StringUtilities.printListOfQuotedNames(<String>["a", "b", "c"]), |
| 4700 "'a', 'b' and 'c'"); |
| 4701 } |
| 4702 |
| 4703 void test_printListOfQuotedNames_two() { |
| 4704 expect(StringUtilities.printListOfQuotedNames(<String>["a", "b"]), |
| 4705 "'a' and 'b'"); |
| 4706 } |
| 4707 |
| 4708 void test_startsWith2() { |
| 4709 expect(StringUtilities.startsWith2("ab", 0, 0x61, 0x62), isTrue); |
| 4710 expect(StringUtilities.startsWith2("abcdefghi", 0, 0x61, 0x62), isTrue); |
| 4711 expect(StringUtilities.startsWith2("abcdefghi", 2, 0x63, 0x64), isTrue); |
| 4712 expect(StringUtilities.startsWith2("abcdefghi", 5, 0x66, 0x67), isTrue); |
| 4713 expect(StringUtilities.startsWith2("abcdefghi", 0, 0x64, 0x64), isFalse); |
| 4714 // missing |
| 4715 } |
| 4716 |
| 4717 void test_startsWith3() { |
| 4718 expect(StringUtilities.startsWith3("abc", 0, 0x61, 0x62, 0x63), isTrue); |
| 4719 expect( |
| 4720 StringUtilities.startsWith3("abcdefghi", 0, 0x61, 0x62, 0x63), isTrue); |
| 4721 expect( |
| 4722 StringUtilities.startsWith3("abcdefghi", 2, 0x63, 0x64, 0x65), isTrue); |
| 4723 expect( |
| 4724 StringUtilities.startsWith3("abcdefghi", 6, 0x67, 0x68, 0x69), isTrue); |
| 4725 expect( |
| 4726 StringUtilities.startsWith3("abcdefghi", 0, 0x64, 0x65, 0x61), isFalse); |
| 4727 // missing |
| 4728 } |
| 4729 |
| 4730 void test_startsWith4() { |
| 4731 expect( |
| 4732 StringUtilities.startsWith4("abcd", 0, 0x61, 0x62, 0x63, 0x64), isTrue); |
| 4733 expect(StringUtilities.startsWith4("abcdefghi", 0, 0x61, 0x62, 0x63, 0x64), |
| 4734 isTrue); |
| 4735 expect(StringUtilities.startsWith4("abcdefghi", 2, 0x63, 0x64, 0x65, 0x66), |
| 4736 isTrue); |
| 4737 expect(StringUtilities.startsWith4("abcdefghi", 5, 0x66, 0x67, 0x68, 0x69), |
| 4738 isTrue); |
| 4739 expect(StringUtilities.startsWith4("abcdefghi", 0, 0x64, 0x65, 0x61, 0x64), |
| 4740 isFalse); |
| 4741 // missing |
| 4742 } |
| 4743 |
| 4744 void test_startsWith5() { |
| 4745 expect( |
| 4746 StringUtilities.startsWith5("abcde", 0, 0x61, 0x62, 0x63, 0x64, 0x65), |
| 4747 isTrue); |
| 4748 expect( |
| 4749 StringUtilities.startsWith5( |
| 4750 "abcdefghi", 0, 0x61, 0x62, 0x63, 0x64, 0x65), |
| 4751 isTrue); |
| 4752 expect( |
| 4753 StringUtilities.startsWith5( |
| 4754 "abcdefghi", 2, 0x63, 0x64, 0x65, 0x66, 0x67), |
| 4755 isTrue); |
| 4756 expect( |
| 4757 StringUtilities.startsWith5( |
| 4758 "abcdefghi", 4, 0x65, 0x66, 0x67, 0x68, 0x69), |
| 4759 isTrue); |
| 4760 expect( |
| 4761 StringUtilities.startsWith5( |
| 4762 "abcdefghi", 0, 0x61, 0x62, 0x63, 0x62, 0x61), |
| 4763 isFalse); |
| 4764 // missing |
| 4765 } |
| 4766 |
| 4767 void test_startsWith6() { |
| 4768 expect( |
| 4769 StringUtilities.startsWith6( |
| 4770 "abcdef", 0, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66), |
| 4771 isTrue); |
| 4772 expect( |
| 4773 StringUtilities.startsWith6( |
| 4774 "abcdefghi", 0, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66), |
| 4775 isTrue); |
| 4776 expect( |
| 4777 StringUtilities.startsWith6( |
| 4778 "abcdefghi", 2, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68), |
| 4779 isTrue); |
| 4780 expect( |
| 4781 StringUtilities.startsWith6( |
| 4782 "abcdefghi", 3, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69), |
| 4783 isTrue); |
| 4784 expect( |
| 4785 StringUtilities.startsWith6( |
| 4786 "abcdefghi", 0, 0x61, 0x62, 0x63, 0x64, 0x65, 0x67), |
| 4787 isFalse); |
| 4788 // missing |
| 4789 } |
| 4790 |
| 4791 void test_startsWithChar() { |
| 4792 expect(StringUtilities.startsWithChar("a", 0x61), isTrue); |
| 4793 expect(StringUtilities.startsWithChar("b", 0x61), isFalse); |
| 4794 expect(StringUtilities.startsWithChar("", 0x61), isFalse); |
| 4795 } |
| 4796 |
| 4797 void test_substringBefore() { |
| 4798 expect(StringUtilities.substringBefore(null, ""), null); |
| 4799 expect(StringUtilities.substringBefore(null, "a"), null); |
| 4800 expect(StringUtilities.substringBefore("", "a"), ""); |
| 4801 expect(StringUtilities.substringBefore("abc", "a"), ""); |
| 4802 expect(StringUtilities.substringBefore("abcba", "b"), "a"); |
| 4803 expect(StringUtilities.substringBefore("abc", "c"), "ab"); |
| 4804 expect(StringUtilities.substringBefore("abc", "d"), "abc"); |
| 4805 expect(StringUtilities.substringBefore("abc", ""), ""); |
| 4806 expect(StringUtilities.substringBefore("abc", null), "abc"); |
| 4807 } |
| 4808 |
| 4809 void test_substringBeforeChar() { |
| 4810 expect(StringUtilities.substringBeforeChar(null, 0x61), null); |
| 4811 expect(StringUtilities.substringBeforeChar("", 0x61), ""); |
| 4812 expect(StringUtilities.substringBeforeChar("abc", 0x61), ""); |
| 4813 expect(StringUtilities.substringBeforeChar("abcba", 0x62), "a"); |
| 4814 expect(StringUtilities.substringBeforeChar("abc", 0x63), "ab"); |
| 4815 expect(StringUtilities.substringBeforeChar("abc", 0x64), "abc"); |
| 4816 } |
| 4817 } |
| 4818 |
| 4819 @reflectiveTest |
| 4820 class TokenMapTest { |
| 4821 void test_creation() { |
| 4822 expect(new TokenMap(), isNotNull); |
| 4823 } |
| 4824 |
| 4825 void test_get_absent() { |
| 4826 TokenMap tokenMap = new TokenMap(); |
| 4827 expect(tokenMap.get(TokenFactory.tokenFromType(TokenType.AT)), isNull); |
| 4828 } |
| 4829 |
| 4830 void test_get_added() { |
| 4831 TokenMap tokenMap = new TokenMap(); |
| 4832 Token key = TokenFactory.tokenFromType(TokenType.AT); |
| 4833 Token value = TokenFactory.tokenFromType(TokenType.AT); |
| 4834 tokenMap.put(key, value); |
| 4835 expect(tokenMap.get(key), same(value)); |
| 4836 } |
| 4837 } |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1400473008:
Roll Observatory packages and add a roll script (Closed)
Base URL: git@github.com:dart-lang/observatory_pub_packages.git@master