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