Remove EngineTestCase.createSource().

pkg/analyzer/test/generated/all_the_rest.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.all_the_rest_test;
 
 import 'dart:collection';
@@ skipping 443 matching lines @@
       }
       JUnitTestCase.fail(buffer.toString());
     }
     return firstToken;
   }
 }
 
 
 class AngularCompilationUnitBuilderTest extends AngularTest {
   void test_Decorator() {
-    String mainContent = _createAngularSource(
-        [
-            "@Decorator(selector: '[my-dir]',",
-            "             map: const {",
-            "               'my-dir' : '=>myPropA',",
-            "               '.' : '&myPropB',",
-            "             })",
-            "class MyDirective {",
-            "  set myPropA(value) {}",
-            "  set myPropB(value) {}",
-            "  @NgTwoWay('my-prop-c')",
-            "  String myPropC;",
-            "}"]);
+    String mainContent = _createAngularSource(r'''
+@Decorator(selector: '[my-dir]',
+             map: const {
+               'my-dir' : '=>myPropA',
+               '.' : '&myPropB',
+             })
+class MyDirective {
+  set myPropA(value) {}
+  set myPropB(value) {}
+  @NgTwoWay('my-prop-c')
+  String myPropC;
+}''');
     resolveMainSourceNoErrors(mainContent);
     // prepare AngularDirectiveElement
     ClassElement classElement = mainUnitElement.getType("MyDirective");
     AngularDecoratorElement directive =
         getAngularElement(classElement, (e) => e is AngularDecoratorElement);
     JUnitTestCase.assertNotNull(directive);
     // verify
     JUnitTestCase.assertEquals(null, directive.name);
     JUnitTestCase.assertEquals(-1, directive.nameOffset);
     _assertHasAttributeSelector(directive.selector, "my-dir");
@@ skipping 17 matching lines @@
     _assertProperty(
         properties[2],
         "my-prop-c",
         findMainOffset("my-prop-c'"),
         AngularPropertyKind.TWO_WAY,
         "myPropC",
         -1);
   }
 
   void test_Decorator_bad_cannotParseSelector() {
-    String mainContent = _createAngularSource(
-        [
-            "@Decorator(selector: '~bad-selector',",
-            "             map: const {",
-            "               'my-dir' : '=>myPropA',",
-            "               '.' : '&myPropB',",
-            "             })",
-            "class MyDirective {",
-            "  set myPropA(value) {}",
-            "  set myPropB(value) {}",
-            "}"]);
+    String mainContent = _createAngularSource(r'''
+@Decorator(selector: '~bad-selector',
+             map: const {
+               'my-dir' : '=>myPropA',
+               '.' : '&myPropB',
+             })
+class MyDirective {
+  set myPropA(value) {}
+  set myPropB(value) {}
+}''');
     resolveMainSource(mainContent);
     // has error
     assertMainErrors([AngularCode.CANNOT_PARSE_SELECTOR]);
   }
 
   void test_Decorator_bad_missingSelector() {
-    String mainContent = _createAngularSource(
-        [
-            "@Decorator(/*selector: '[my-dir]',*/",
-            "             map: const {",
-            "               'my-dir' : '=>myPropA',",
-            "               '.' : '&myPropB',",
-            "             })",
-            "class MyDirective {",
-            "  set myPropA(value) {}",
-            "  set myPropB(value) {}",
-            "}"]);
+    String mainContent = _createAngularSource(r'''
+@Decorator(/*selector: '[my-dir]',*/
+             map: const {
+               'my-dir' : '=>myPropA',
+               '.' : '&myPropB',
+             })
+class MyDirective {
+  set myPropA(value) {}
+  set myPropB(value) {}
+}''');
     resolveMainSource(mainContent);
     // has error
     assertMainErrors([AngularCode.MISSING_SELECTOR]);
   }
 
   void test_Formatter() {
-    String mainContent = _createAngularSource(
-        ["@Formatter(name: 'myFilter')", "class MyFilter {", "  call(p1, p2) {}", "}"]);
+    String mainContent = _createAngularSource(r'''
+@Formatter(name: 'myFilter')
+class MyFilter {
+  call(p1, p2) {}
+}''');
     resolveMainSourceNoErrors(mainContent);
     // prepare AngularFilterElement
     ClassElement classElement = mainUnitElement.getType("MyFilter");
     AngularFormatterElement filter =
         getAngularElement(classElement, (e) => e is AngularFormatterElement);
     JUnitTestCase.assertNotNull(filter);
     // verify
     JUnitTestCase.assertEquals("myFilter", filter.name);
     JUnitTestCase.assertEquals(
         AngularTest.findOffset(mainContent, "myFilter'"),
         filter.nameOffset);
   }
 
   void test_Formatter_missingName() {
-    String mainContent = _createAngularSource(
-        ["@Formatter()", "class MyFilter {", "  call(p1, p2) {}", "}"]);
+    String mainContent = _createAngularSource(r'''
+@Formatter()
+class MyFilter {
+  call(p1, p2) {}
+}''');
     resolveMainSource(mainContent);
     // has error
     assertMainErrors([AngularCode.MISSING_NAME]);
     // no filter
     ClassElement classElement = mainUnitElement.getType("MyFilter");
     AngularFormatterElement filter =
         getAngularElement(classElement, (e) => e is AngularFormatterElement);
     JUnitTestCase.assertNull(filter);
   }
 
   void test_NgComponent_bad_cannotParseSelector() {
     contextHelper.addSource("/my_template.html", "");
     contextHelper.addSource("/my_styles.css", "");
-    String mainContent = _createAngularSource(
-        [
-            "@Component(publishAs: 'ctrl', selector: '~myComp',",
-            "             templateUrl: 'my_template.html', cssUrl: 'my_styles.css')",
-            "class MyComponent {",
-            "}"]);
+    String mainContent = _createAngularSource(r'''
+@Component(publishAs: 'ctrl', selector: '~myComp',
+             templateUrl: 'my_template.html', cssUrl: 'my_styles.css')
+class MyComponent {
+}''');
     resolveMainSource(mainContent);
     // has error
     assertMainErrors([AngularCode.CANNOT_PARSE_SELECTOR]);
   }
 
   void test_NgComponent_bad_missingSelector() {
     contextHelper.addSource("/my_template.html", "");
     contextHelper.addSource("/my_styles.css", "");
-    String mainContent = _createAngularSource(
-        [
-            "@Component(publishAs: 'ctrl', /*selector: 'myComp',*/",
-            "             templateUrl: 'my_template.html', cssUrl: 'my_styles.css')",
-            "class MyComponent {",
-            "}"]);
+    String mainContent = _createAngularSource(r'''
+@Component(publishAs: 'ctrl', /*selector: 'myComp',*/
+             templateUrl: 'my_template.html', cssUrl: 'my_styles.css')
+class MyComponent {
+}''');
     resolveMainSource(mainContent);
     // has error
     assertMainErrors([AngularCode.MISSING_SELECTOR]);
   }
 
   /**
    *
    * https://code.google.com/p/dart/issues/detail?id=16346
    */
   void test_NgComponent_bad_notHtmlTemplate() {
     contextHelper.addSource("/my_template", "");
     contextHelper.addSource("/my_styles.css", "");
     addMainSource(
-        _createAngularSource(
-            [
-                "@NgComponent(publishAs: 'ctrl', selector: 'myComp',",
-                "             templateUrl: 'my_template', cssUrl: 'my_styles.css')",
-                "class MyComponent {",
-                "}"]));
+        _createAngularSource(r'''
+@NgComponent(publishAs: 'ctrl', selector: 'myComp',
+             templateUrl: 'my_template', cssUrl: 'my_styles.css')
+class MyComponent {
+}'''));
     contextHelper.runTasks();
   }
 
   void test_NgComponent_bad_properties_invalidBinding() {
     contextHelper.addSource("/my_template.html", "");
     contextHelper.addSource("/my_styles.css", "");
-    String mainContent = _createAngularSource(
-        [
-            "@Component(publishAs: 'ctrl', selector: 'myComp',",
-            "             templateUrl: 'my_template.html', cssUrl: 'my_styles.css',",
-            "             map: const {'name' : '?field'})",
-            "class MyComponent {",
-            "}"]);
+    String mainContent = _createAngularSource(r'''
+@Component(publishAs: 'ctrl', selector: 'myComp',
+             templateUrl: 'my_template.html', cssUrl: 'my_styles.css',
+             map: const {'name' : '?field'})
+class MyComponent {
+}''');
     resolveMainSource(mainContent);
     // has error
     assertMainErrors([AngularCode.INVALID_PROPERTY_KIND]);
   }
 
   void test_NgComponent_bad_properties_nameNotStringLiteral() {
     contextHelper.addSource("/my_template.html", "");
     contextHelper.addSource("/my_styles.css", "");
-    String mainContent = _createAngularSource(
-        [
-            "@Component(publishAs: 'ctrl', selector: 'myComp',",
-            "             templateUrl: 'my_template.html', cssUrl: 'my_styles.css',",
-            "             map: const {null : 'field'})",
-            "class MyComponent {",
-            "}"]);
+    String mainContent = _createAngularSource(r'''
+@Component(publishAs: 'ctrl', selector: 'myComp',
+             templateUrl: 'my_template.html', cssUrl: 'my_styles.css',
+             map: const {null : 'field'})
+class MyComponent {
+}''');
     resolveMainSource(mainContent);
     // has error
     assertMainErrors([AngularCode.INVALID_PROPERTY_NAME]);
   }
 
   void test_NgComponent_bad_properties_noSuchField() {
     contextHelper.addSource("/my_template.html", "");
     contextHelper.addSource("/my_styles.css", "");
-    String mainContent = _createAngularSource(
-        [
-            "@Component(publishAs: 'ctrl', selector: 'myComp',",
-            "             templateUrl: 'my_template.html', cssUrl: 'my_styles.css',",
-            "             map: const {'name' : '=>field'})",
-            "class MyComponent {",
-            "}"]);
+    String mainContent = _createAngularSource(r'''
+@Component(publishAs: 'ctrl', selector: 'myComp',
+             templateUrl: 'my_template.html', cssUrl: 'my_styles.css',
+             map: const {'name' : '=>field'})
+class MyComponent {
+}''');
     resolveMainSource(mainContent);
     // has error
     assertMainErrors([AngularCode.INVALID_PROPERTY_FIELD]);
   }
 
   void test_NgComponent_bad_properties_notMapLiteral() {
     contextHelper.addSource("/my_template.html", "");
     contextHelper.addSource("/my_styles.css", "");
-    String mainContent = _createAngularSource(
-        [
-            "@Component(publishAs: 'ctrl', selector: 'myComp',",
-            "             templateUrl: 'my_template.html', cssUrl: 'my_styles.css',",
-            "             map: null)",
-            "class MyComponent {",
-            "}"]);
+    String mainContent = _createAngularSource(r'''
+@Component(publishAs: 'ctrl', selector: 'myComp',
+             templateUrl: 'my_template.html', cssUrl: 'my_styles.css',
+             map: null)
+class MyComponent {
+}''');
     resolveMainSource(mainContent);
     // has error
     assertMainErrors([AngularCode.INVALID_PROPERTY_MAP]);
   }
 
   void test_NgComponent_bad_properties_specNotStringLiteral() {
     contextHelper.addSource("/my_template.html", "");
     contextHelper.addSource("/my_styles.css", "");
-    String mainContent = _createAngularSource(
-        [
-            "@Component(publishAs: 'ctrl', selector: 'myComp',",
-            "             templateUrl: 'my_template.html', cssUrl: 'my_styles.css',",
-            "             map: const {'name' : null})",
-            "class MyComponent {",
-            "}"]);
+    String mainContent = _createAngularSource(r'''
+@Component(publishAs: 'ctrl', selector: 'myComp',
+             templateUrl: 'my_template.html', cssUrl: 'my_styles.css',
+             map: const {'name' : null})
+class MyComponent {
+}''');
     resolveMainSource(mainContent);
     // has error
     assertMainErrors([AngularCode.INVALID_PROPERTY_SPEC]);
   }
 
   void test_NgComponent_no_cssUrl() {
     contextHelper.addSource("/my_template.html", "");
     contextHelper.addSource("/my_styles.css", "");
-    String mainContent = _createAngularSource(
-        [
-            "@Component(publishAs: 'ctrl', selector: 'myComp',",
-            "             templateUrl: 'my_template.html'/*, cssUrl: 'my_styles.css'*/)",
-            "class MyComponent {",
-            "}"]);
+    String mainContent = _createAngularSource(r'''
+@Component(publishAs: 'ctrl', selector: 'myComp',
+             templateUrl: 'my_template.html'/*, cssUrl: 'my_styles.css'*/)
+class MyComponent {
+}''');
     resolveMainSource(mainContent);
     // prepare AngularComponentElement
     ClassElement classElement = mainUnitElement.getType("MyComponent");
     AngularComponentElement component =
         getAngularElement(classElement, (e) => e is AngularComponentElement);
     JUnitTestCase.assertNotNull(component);
     // no CSS
     JUnitTestCase.assertEquals(null, component.styleUri);
     JUnitTestCase.assertEquals(-1, component.styleUriOffset);
   }
 
   void test_NgComponent_no_publishAs() {
     contextHelper.addSource("/my_template.html", "");
     contextHelper.addSource("/my_styles.css", "");
-    String mainContent = _createAngularSource(
-        [
-            "@Component(/*publishAs: 'ctrl',*/ selector: 'myComp',",
-            "             templateUrl: 'my_template.html', cssUrl: 'my_styles.css')",
-            "class MyComponent {",
-            "}"]);
+    String mainContent = _createAngularSource(r'''
+@Component(/*publishAs: 'ctrl',*/ selector: 'myComp',
+             templateUrl: 'my_template.html', cssUrl: 'my_styles.css')
+class MyComponent {
+}''');
     resolveMainSource(mainContent);
     // prepare AngularComponentElement
     ClassElement classElement = mainUnitElement.getType("MyComponent");
     AngularComponentElement component =
         getAngularElement(classElement, (e) => e is AngularComponentElement);
     JUnitTestCase.assertNotNull(component);
     // no name
     JUnitTestCase.assertEquals(null, component.name);
     JUnitTestCase.assertEquals(-1, component.nameOffset);
   }
 
   void test_NgComponent_no_templateUrl() {
     contextHelper.addSource("/my_template.html", "");
     contextHelper.addSource("/my_styles.css", "");
-    String mainContent = _createAngularSource(
-        [
-            "@Component(publishAs: 'ctrl', selector: 'myComp',",
-            "             /*templateUrl: 'my_template.html',*/ cssUrl: 'my_styles.css')",
-            "class MyComponent {",
-            "}"]);
+    String mainContent = _createAngularSource(r'''
+@Component(publishAs: 'ctrl', selector: 'myComp',
+             /*templateUrl: 'my_template.html',*/ cssUrl: 'my_styles.css')
+class MyComponent {
+}''');
     resolveMainSource(mainContent);
     // prepare AngularComponentElement
     ClassElement classElement = mainUnitElement.getType("MyComponent");
     AngularComponentElement component =
         getAngularElement(classElement, (e) => e is AngularComponentElement);
     JUnitTestCase.assertNotNull(component);
     // no template
     JUnitTestCase.assertEquals(null, component.templateUri);
     JUnitTestCase.assertEquals(null, component.templateSource);
     JUnitTestCase.assertEquals(-1, component.templateUriOffset);
@@ skipping 14 matching lines @@
 class MyComponent {
 }''';
     resolveMainSource(mainContent);
     assertNoMainErrors();
   }
 
   void test_NgComponent_properties_fieldFromSuper() {
     contextHelper.addSource("/my_template.html", "");
     contextHelper.addSource("/my_styles.css", "");
     resolveMainSourceNoErrors(
-        _createAngularSource(
-            [
-                "class MySuper {",
-                "  var myPropA;",
-                "}",
-                "",
-                "",
-                "",
-                "@Component(publishAs: 'ctrl', selector: 'myComp',",
-                "             templateUrl: 'my_template.html', cssUrl: 'my_styles.css',",
-                "             map: const {",
-                "               'prop-a' : '@myPropA'",
-                "             })",
-                "class MyComponent extends MySuper {",
-                "}"]));
+        _createAngularSource(r'''
+class MySuper {
+  var myPropA;
+}
+
+
+
+@Component(publishAs: 'ctrl', selector: 'myComp',
+             templateUrl: 'my_template.html', cssUrl: 'my_styles.css',
+             map: const {
+               'prop-a' : '@myPropA'
+             })
+class MyComponent extends MySuper {
+}'''));
     // prepare AngularComponentElement
     ClassElement classElement = mainUnitElement.getType("MyComponent");
     AngularComponentElement component =
         getAngularElement(classElement, (e) => e is AngularComponentElement);
     JUnitTestCase.assertNotNull(component);
     // verify
     List<AngularPropertyElement> properties = component.properties;
     EngineTestCase.assertLength(1, properties);
     _assertProperty(
         properties[0],
         "prop-a",
         findMainOffset("prop-a' :"),
         AngularPropertyKind.ATTR,
         "myPropA",
         findMainOffset("myPropA'"));
   }
 
   void test_NgComponent_properties_fromFields() {
     contextHelper.addSource("/my_template.html", "");
     contextHelper.addSource("/my_styles.css", "");
     resolveMainSourceNoErrors(
-        _createAngularSource(
-            [
-                "@Component(publishAs: 'ctrl', selector: 'myComp',",
-                "             templateUrl: 'my_template.html', cssUrl: 'my_styles.css')",
-                "class MyComponent {",
-                "  @NgAttr('prop-a')",
-                "  var myPropA;",
-                "  @NgCallback('prop-b')",
-                "  var myPropB;",
-                "  @NgOneWay('prop-c')",
-                "  var myPropC;",
-                "  @NgOneWayOneTime('prop-d')",
-                "  var myPropD;",
-                "  @NgTwoWay('prop-e')",
-                "  var myPropE;",
-                "}"]));
+        _createAngularSource(r'''
+@Component(publishAs: 'ctrl', selector: 'myComp',
+             templateUrl: 'my_template.html', cssUrl: 'my_styles.css')
+class MyComponent {
+  @NgAttr('prop-a')
+  var myPropA;
+  @NgCallback('prop-b')
+  var myPropB;
+  @NgOneWay('prop-c')
+  var myPropC;
+  @NgOneWayOneTime('prop-d')
+  var myPropD;
+  @NgTwoWay('prop-e')
+  var myPropE;
+}'''));
     // prepare AngularComponentElement
     ClassElement classElement = mainUnitElement.getType("MyComponent");
     AngularComponentElement component =
         getAngularElement(classElement, (e) => e is AngularComponentElement);
     JUnitTestCase.assertNotNull(component);
     // verify
     List<AngularPropertyElement> properties = component.properties;
     EngineTestCase.assertLength(5, properties);
     _assertProperty(
         properties[0],
@@ skipping 29 matching lines @@
         findMainOffset("prop-e')"),
         AngularPropertyKind.TWO_WAY,
         "myPropE",
         -1);
   }
 
   void test_NgComponent_properties_fromMap() {
     contextHelper.addSource("/my_template.html", "");
     contextHelper.addSource("/my_styles.css", "");
     resolveMainSourceNoErrors(
-        _createAngularSource(
-            [
-                "@Component(publishAs: 'ctrl', selector: 'myComp',",
-                "             templateUrl: 'my_template.html', cssUrl: 'my_styles.css',",
-                "             map: const {",
-                "               'prop-a' : '@myPropA',",
-                "               'prop-b' : '&myPropB',",
-                "               'prop-c' : '=>myPropC',",
-                "               'prop-d' : '=>!myPropD',",
-                "               'prop-e' : '<=>myPropE'",
-                "             })",
-                "class MyComponent {",
-                "  var myPropA;",
-                "  var myPropB;",
-                "  var myPropC;",
-                "  var myPropD;",
-                "  var myPropE;",
-                "}"]));
+        _createAngularSource(r'''
+@Component(publishAs: 'ctrl', selector: 'myComp',
+             templateUrl: 'my_template.html', cssUrl: 'my_styles.css',
+             map: const {
+               'prop-a' : '@myPropA',
+               'prop-b' : '&myPropB',
+               'prop-c' : '=>myPropC',
+               'prop-d' : '=>!myPropD',
+               'prop-e' : '<=>myPropE'
+             })
+class MyComponent {
+  var myPropA;
+  var myPropB;
+  var myPropC;
+  var myPropD;
+  var myPropE;
+}'''));
     // prepare AngularComponentElement
     ClassElement classElement = mainUnitElement.getType("MyComponent");
     AngularComponentElement component =
         getAngularElement(classElement, (e) => e is AngularComponentElement);
     JUnitTestCase.assertNotNull(component);
     // verify
     List<AngularPropertyElement> properties = component.properties;
     EngineTestCase.assertLength(5, properties);
     _assertProperty(
         properties[0],
@@ skipping 28 matching lines @@
         "prop-e",
         findMainOffset("prop-e' :"),
         AngularPropertyKind.TWO_WAY,
         "myPropE",
         findMainOffset("myPropE'"));
   }
 
   void test_NgComponent_properties_no() {
     contextHelper.addSource("/my_template.html", "");
     contextHelper.addSource("/my_styles.css", "");
-    String mainContent = _createAngularSource(
-        [
-            "@Component(publishAs: 'ctrl', selector: 'myComp',",
-            "             templateUrl: 'my_template.html', cssUrl: 'my_styles.css')",
-            "class MyComponent {",
-            "}"]);
+    String mainContent = _createAngularSource(r'''
+@Component(publishAs: 'ctrl', selector: 'myComp',
+             templateUrl: 'my_template.html', cssUrl: 'my_styles.css')
+class MyComponent {
+}''');
     resolveMainSourceNoErrors(mainContent);
     // prepare AngularComponentElement
     ClassElement classElement = mainUnitElement.getType("MyComponent");
     AngularComponentElement component =
         getAngularElement(classElement, (e) => e is AngularComponentElement);
     JUnitTestCase.assertNotNull(component);
     // verify
     JUnitTestCase.assertEquals("ctrl", component.name);
     JUnitTestCase.assertEquals(
         AngularTest.findOffset(mainContent, "ctrl'"),
         component.nameOffset);
     _assertIsTagSelector(component.selector, "myComp");
     JUnitTestCase.assertEquals("my_template.html", component.templateUri);
     JUnitTestCase.assertEquals(
         AngularTest.findOffset(mainContent, "my_template.html'"),
         component.templateUriOffset);
     JUnitTestCase.assertEquals("my_styles.css", component.styleUri);
     JUnitTestCase.assertEquals(
         AngularTest.findOffset(mainContent, "my_styles.css'"),
         component.styleUriOffset);
     EngineTestCase.assertLength(0, component.properties);
   }
 
   void test_NgComponent_scopeProperties() {
     contextHelper.addSource("/my_template.html", "");
     contextHelper.addSource("/my_styles.css", "");
-    String mainContent = _createAngularSource(
-        [
-            "@Component(publishAs: 'ctrl', selector: 'myComp',",
-            "             templateUrl: 'my_template.html', cssUrl: 'my_styles.css')",
-            "class MyComponent {",
-            "  MyComponent(Scope scope) {",
-            "    scope.context['boolProp'] = true;",
-            "    scope.context['intProp'] = 42;",
-            "    scope.context['stringProp'] = 'foo';",
-            "    // duplicate is ignored",
-            "    scope.context['boolProp'] = true;",
-            "    // LHS is not an IndexExpression",
-            "    var v1;",
-            "    v1 = 1;",
-            "    // LHS is not a Scope access",
-            "    var v2;",
-            "    v2['name'] = 2;",
-            "  }",
-            "}"]);
+    String mainContent = _createAngularSource(r'''
+@Component(publishAs: 'ctrl', selector: 'myComp',
+             templateUrl: 'my_template.html', cssUrl: 'my_styles.css')
+class MyComponent {
+  MyComponent(Scope scope) {
+    scope.context['boolProp'] = true;
+    scope.context['intProp'] = 42;
+    scope.context['stringProp'] = 'foo';
+    // duplicate is ignored
+    scope.context['boolProp'] = true;
+    // LHS is not an IndexExpression
+    var v1;
+    v1 = 1;
+    // LHS is not a Scope access
+    var v2;
+    v2['name'] = 2;
+  }
+}''');
     resolveMainSourceNoErrors(mainContent);
     // prepare AngularComponentElement
     ClassElement classElement = mainUnitElement.getType("MyComponent");
     AngularComponentElement component =
         getAngularElement(classElement, (e) => e is AngularComponentElement);
     JUnitTestCase.assertNotNull(component);
     // verify
     List<AngularScopePropertyElement> scopeProperties =
         component.scopeProperties;
     EngineTestCase.assertLength(3, scopeProperties);
@@ skipping 20 matching lines @@
       JUnitTestCase.assertSame(property, findMainElement2("stringProp"));
       JUnitTestCase.assertEquals("stringProp", property.name);
       JUnitTestCase.assertEquals(
           AngularTest.findOffset(mainContent, "stringProp'"),
           property.nameOffset);
       JUnitTestCase.assertEquals("String", property.type.name);
     }
   }
 
   void test_NgController() {
-    String mainContent = _createAngularSource(
-        [
-            "@Controller(publishAs: 'ctrl', selector: '[myApp]')",
-            "class MyController {",
-            "}"]);
+    String mainContent = _createAngularSource(r'''
+@Controller(publishAs: 'ctrl', selector: '[myApp]')
+class MyController {
+}''');
     resolveMainSourceNoErrors(mainContent);
     // prepare AngularControllerElement
     ClassElement classElement = mainUnitElement.getType("MyController");
     AngularControllerElement controller =
         getAngularElement(classElement, (e) => e is AngularControllerElement);
     JUnitTestCase.assertNotNull(controller);
     // verify
     JUnitTestCase.assertEquals("ctrl", controller.name);
     JUnitTestCase.assertEquals(
         AngularTest.findOffset(mainContent, "ctrl'"),
         controller.nameOffset);
     _assertHasAttributeSelector(controller.selector, "myApp");
   }
 
   void test_NgController_cannotParseSelector() {
-    String mainContent = _createAngularSource(
-        [
-            "@Controller(publishAs: 'ctrl', selector: '~unknown')",
-            "class MyController {",
-            "}"]);
+    String mainContent = _createAngularSource(r'''
+@Controller(publishAs: 'ctrl', selector: '~unknown')
+class MyController {
+}''');
     resolveMainSource(mainContent);
     // has error
     assertMainErrors([AngularCode.CANNOT_PARSE_SELECTOR]);
   }
 
   void test_NgController_missingPublishAs() {
-    String mainContent = _createAngularSource(
-        ["@Controller(selector: '[myApp]')", "class MyController {", "}"]);
+    String mainContent = _createAngularSource(r'''
+@Controller(selector: '[myApp]')
+class MyController {
+}''');
     resolveMainSource(mainContent);
     // has error
     assertMainErrors([AngularCode.MISSING_PUBLISH_AS]);
   }
 
   void test_NgController_missingSelector() {
-    String mainContent = _createAngularSource(
-        ["@Controller(publishAs: 'ctrl')", "class MyController {", "}"]);
+    String mainContent = _createAngularSource(r'''
+@Controller(publishAs: 'ctrl')
+class MyController {
+}''');
     resolveMainSource(mainContent);
     // has error
     assertMainErrors([AngularCode.MISSING_SELECTOR]);
   }
 
   void test_NgController_noAnnotationArguments() {
     String mainContent =
-        _createAngularSource(["@NgController", "class MyController {", "}"]);
+        _createAngularSource(r'''
+@NgController
+class MyController {
+}''');
     resolveMainSource(mainContent);
   }
 
   void test_bad_notConstructorAnnotation() {
     String mainContent = r'''
 const MY_ANNOTATION = null;
 @MY_ANNOTATION()
 class MyFilter {
 }''';
     resolveMainSource(mainContent);
     // prepare AngularFilterElement
     ClassElement classElement = mainUnitElement.getType("MyFilter");
     AngularFormatterElement filter =
         getAngularElement(classElement, (e) => e is AngularFormatterElement);
     JUnitTestCase.assertNull(filter);
   }
 
   void test_getElement_SimpleStringLiteral_withToolkitElement() {
     SimpleStringLiteral literal = AstFactory.string2("foo");
     Element element = new AngularScopePropertyElementImpl("foo", 0, null);
     literal.toolkitElement = element;
     JUnitTestCase.assertSame(
         element,
         AngularCompilationUnitBuilder.getElement(literal, -1));
   }
 
   void test_getElement_component_name() {
     resolveMainSource(
-        _createAngularSource(
-            [
-                "@Component(publishAs: 'ctrl', selector: 'myComp',",
-                "             templateUrl: 'my_template.html', cssUrl: 'my_styles.css')",
-                "class MyComponent {}"]));
+        _createAngularSource(r'''
+@Component(publishAs: 'ctrl', selector: 'myComp',
+             templateUrl: 'my_template.html', cssUrl: 'my_styles.css')
+class MyComponent {}'''));
     SimpleStringLiteral node =
         _findMainNode("ctrl'", (n) => n is SimpleStringLiteral);
     int offset = node.offset;
     // find AngularComponentElement
     Element element = AngularCompilationUnitBuilder.getElement(node, offset);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is AngularComponentElement,
         AngularComponentElement,
         element);
   }
 
   void test_getElement_component_property_fromFieldAnnotation() {
     resolveMainSource(
-        _createAngularSource(
-            [
-                "@Component(publishAs: 'ctrl', selector: 'myComp',",
-                "             templateUrl: 'my_template.html', cssUrl: 'my_styles.css')",
-                "class MyComponent {",
-                "  @NgOneWay('prop')",
-                "  var field;",
-                "}"]));
+        _createAngularSource(r'''
+@Component(publishAs: 'ctrl', selector: 'myComp',
+             templateUrl: 'my_template.html', cssUrl: 'my_styles.css')
+class MyComponent {
+  @NgOneWay('prop')
+  var field;
+}'''));
     // prepare node
     SimpleStringLiteral node =
         _findMainNode("prop'", (n) => n is SimpleStringLiteral);
     int offset = node.offset;
     // prepare Element
     Element element = AngularCompilationUnitBuilder.getElement(node, offset);
     JUnitTestCase.assertNotNull(element);
     // check AngularPropertyElement
     AngularPropertyElement property = element as AngularPropertyElement;
     JUnitTestCase.assertEquals("prop", property.name);
   }
 
   void test_getElement_component_property_fromMap() {
     resolveMainSource(
-        _createAngularSource(
-            [
-                "@Component(publishAs: 'ctrl', selector: 'myComp',",
-                "             templateUrl: 'my_template.html', cssUrl: 'my_styles.css',",
-                "             map: const {",
-                "               'prop' : '@field',",
-                "             })",
-                "class MyComponent {",
-                "  var field;",
-                "}"]));
+        _createAngularSource(r'''
+@Component(publishAs: 'ctrl', selector: 'myComp',
+             templateUrl: 'my_template.html', cssUrl: 'my_styles.css',
+             map: const {
+               'prop' : '@field',
+             })
+class MyComponent {
+  var field;
+}'''));
     // AngularPropertyElement
     {
       SimpleStringLiteral node =
           _findMainNode("prop'", (n) => n is SimpleStringLiteral);
       int offset = node.offset;
       // prepare Element
       Element element = AngularCompilationUnitBuilder.getElement(node, offset);
       JUnitTestCase.assertNotNull(element);
       // check AngularPropertyElement
       AngularPropertyElement property = element as AngularPropertyElement;
       JUnitTestCase.assertEquals("prop", property.name);
     }
     // FieldElement
     {
       SimpleStringLiteral node =
           _findMainNode("@field'", (n) => n is SimpleStringLiteral);
       int offset = node.offset;
       // prepare Element
       Element element = AngularCompilationUnitBuilder.getElement(node, offset);
       JUnitTestCase.assertNotNull(element);
       // check FieldElement
       FieldElement field = element as FieldElement;
       JUnitTestCase.assertEquals("field", field.name);
     }
   }
 
   void test_getElement_component_selector() {
     resolveMainSource(
-        _createAngularSource(
-            [
-                "@Component(publishAs: 'ctrl', selector: 'myComp',",
-                "             templateUrl: 'my_template.html', cssUrl: 'my_styles.css')",
-                "class MyComponent {}"]));
+        _createAngularSource(r'''
+@Component(publishAs: 'ctrl', selector: 'myComp',
+             templateUrl: 'my_template.html', cssUrl: 'my_styles.css')
+class MyComponent {}'''));
     SimpleStringLiteral node =
         _findMainNode("myComp'", (n) => n is SimpleStringLiteral);
     int offset = node.offset;
     // find AngularSelectorElement
     Element element = AngularCompilationUnitBuilder.getElement(node, offset);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is AngularSelectorElement,
         AngularSelectorElement,
         element);
   }
 
   void test_getElement_controller_name() {
     resolveMainSource(
-        _createAngularSource(
-            [
-                "@Controller(publishAs: 'ctrl', selector: '[myApp]')",
-                "class MyController {",
-                "}"]));
+        _createAngularSource(r'''
+@Controller(publishAs: 'ctrl', selector: '[myApp]')
+class MyController {
+}'''));
     SimpleStringLiteral node =
         _findMainNode("ctrl'", (n) => n is SimpleStringLiteral);
     int offset = node.offset;
     // find AngularControllerElement
     Element element = AngularCompilationUnitBuilder.getElement(node, offset);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is AngularControllerElement,
         AngularControllerElement,
         element);
   }
 
   void test_getElement_directive_property() {
     resolveMainSource(
-        _createAngularSource(
-            [
-                "@Decorator(selector: '[my-dir]',",
-                "             map: const {",
-                "               'my-dir' : '=>field'",
-                "             })",
-                "class MyDirective {",
-                "  set field(value) {}",
-                "}"]));
+        _createAngularSource(r'''
+@Decorator(selector: '[my-dir]',
+             map: const {
+               'my-dir' : '=>field'
+             })
+class MyDirective {
+  set field(value) {}
+}'''));
     // prepare node
     SimpleStringLiteral node =
         _findMainNode("my-dir'", (n) => n is SimpleStringLiteral);
     int offset = node.offset;
     // prepare Element
     Element element = AngularCompilationUnitBuilder.getElement(node, offset);
     JUnitTestCase.assertNotNull(element);
     // check AngularPropertyElement
     AngularPropertyElement property = element as AngularPropertyElement;
     JUnitTestCase.assertEquals("my-dir", property.name);
   }
 
   void test_getElement_directive_selector() {
     resolveMainSource(
-        _createAngularSource(
-            ["@Decorator(selector: '[my-dir]')", "class MyDirective {}"]));
+        _createAngularSource(r'''
+@Decorator(selector: '[my-dir]')
+class MyDirective {}'''));
     SimpleStringLiteral node =
         _findMainNode("my-dir]'", (n) => n is SimpleStringLiteral);
     int offset = node.offset;
     // find AngularSelectorElement
     Element element = AngularCompilationUnitBuilder.getElement(node, offset);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is AngularSelectorElement,
         AngularSelectorElement,
         element);
   }
 
   void test_getElement_filter_name() {
     resolveMainSource(
-        _createAngularSource(
-            [
-                "@Formatter(name: 'myFilter')",
-                "class MyFilter {",
-                "  call(p1, p2) {}",
-                "}"]));
+        _createAngularSource(r'''
+@Formatter(name: 'myFilter')
+class MyFilter {
+  call(p1, p2) {}
+}'''));
     SimpleStringLiteral node =
         _findMainNode("myFilter'", (n) => n is SimpleStringLiteral);
     int offset = node.offset;
     // find FilterElement
     Element element = AngularCompilationUnitBuilder.getElement(node, offset);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is AngularFormatterElement,
         AngularFormatterElement,
         element);
   }
@@ skipping 100 matching lines @@
   void test_parseSelector_unknown() {
     AngularSelectorElement selector =
         AngularCompilationUnitBuilder.parseSelector(0, "~unknown");
     JUnitTestCase.assertNull(selector);
   }
 
   void test_view() {
     contextHelper.addSource("/wrong.html", "");
     contextHelper.addSource("/my_templateA.html", "");
     contextHelper.addSource("/my_templateB.html", "");
-    String mainContent = _createAngularSource(
-        [
-            "class MyRouteInitializer {",
-            "  init(ViewFactory view, foo) {",
-            "    foo.view('wrong.html');   // has target",
-            "    foo();                    // less than one argument",
-            "    foo('wrong.html', 'bar'); // more than one argument",
-            "    foo('wrong' + '.html');   // not literal",
-            "    foo('wrong.html');        // not ViewFactory",
-            "    view('my_templateA.html');",
-            "    view('my_templateB.html');",
-            "  }",
-            "}"]);
+    String mainContent = _createAngularSource(r'''
+class MyRouteInitializer {
+  init(ViewFactory view, foo) {
+    foo.view('wrong.html');   // has target
+    foo();                    // less than one argument
+    foo('wrong.html', 'bar'); // more than one argument
+    foo('wrong' + '.html');   // not literal
+    foo('wrong.html');        // not ViewFactory
+    view('my_templateA.html');
+    view('my_templateB.html');
+  }
+}''');
     resolveMainSourceNoErrors(mainContent);
     // prepare AngularViewElement(s)
     List<AngularViewElement> views = mainUnitElement.angularViews;
     EngineTestCase.assertLength(2, views);
     {
       AngularViewElement view = views[0];
       JUnitTestCase.assertEquals("my_templateA.html", view.templateUri);
       JUnitTestCase.assertEquals(null, view.name);
       JUnitTestCase.assertEquals(-1, view.nameOffset);
       JUnitTestCase.assertEquals(
@@ skipping 64 matching lines @@
       String name) {
     EngineTestCase.assertInstanceOf(
         (obj) => obj is AngularTagSelectorElementImpl,
         AngularTagSelectorElementImpl,
         selector);
     JUnitTestCase.assertEquals(
         name,
         (selector as AngularTagSelectorElementImpl).name);
   }
 
-  static String _createAngularSource(List<String> lines) {
-    String source = "import 'angular.dart';\n";
-    source += EngineTestCase.createSource(lines);
-    return source;
+  static String _createAngularSource(String code) {
+    return "import 'angular.dart';\n" + code;
   }
 }
 
 
 class AngularHtmlUnitResolverTest extends AngularTest {
   void test_NgComponent_resolveTemplateFile() {
     addMainSource(r'''
 import 'angular.dart';
 
 @Component(
     templateUrl: 'my_template.html', cssUrl: 'my_styles.css',
     publishAs: 'ctrl',
     selector: 'myComponent')
 class MyComponent {
   String field;
 }''');
     contextHelper.addSource(
         "/entry-point.html",
-        AngularTest.createHtmlWithAngular([]));
+        AngularTest.createHtmlWithAngular(''));
     addIndexSource2(
         "/my_template.html",
         r'''
-    <div>
-      {{ctrl.field}}
-    </div>''');
+<div>
+  {{ctrl.field}}
+</div>''');
     contextHelper.addSource("/my_styles.css", "");
     contextHelper.runTasks();
     resolveIndex();
     assertNoErrors();
     assertResolvedIdentifier2("ctrl.", "MyComponent");
     assertResolvedIdentifier2("field}}", "String");
   }
 
   void test_NgComponent_updateDartFile() {
     Source componentSource = contextHelper.addSource(
         "/my_component.dart",
         r'''
 library my.component;
 import 'angular.dart';
 @Component(selector: 'myComponent')
 class MyComponent {
 }''');
     contextHelper.addSource(
         "/my_module.dart",
         r'''
 library my.module;
 import 'my_component.dart';''');
     addMainSource(r'''
 library main;
 import 'my_module.dart';''');
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(["<myComponent/>"]));
+        AngularTest.createHtmlWithMyController("<myComponent/>"));
     // "myComponent" tag was resolved
     {
       ht.XmlTagNode tagNode =
           ht.HtmlUnitUtils.getTagNode(indexUnit, findOffset2("myComponent"));
       AngularSelectorElement tagElement =
           tagNode.element as AngularSelectorElement;
       JUnitTestCase.assertNotNull(tagElement);
       JUnitTestCase.assertEquals("myComponent", tagElement.name);
     }
     // replace "myComponent" with "myComponent2"
@@ skipping 33 matching lines @@
 @Component(
     templateUrl: 'my_template.html', cssUrl: 'my_styles.css',
     publishAs: 'ctrl',
     selector: 'myComponent', // selector
     map: const {'attrA' : '=>setA', 'attrB' : '@setB'})
 class MyComponent {
   set setA(value) {}
   set setB(value) {}
 }''');
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(
-            [
-                "<input type='text' ng-model='someModel'/>",
-                "<myComponent attrA='someModel' attrB='bbb'/>"]));
+        AngularTest.createHtmlWithMyController(r'''
+<input type='text' ng-model='someModel'/>
+<myComponent attrA='someModel' attrB='bbb'/>'''));
     // "attrA" attribute expression was resolved
     JUnitTestCase.assertNotNull(findIdentifier("someModel"));
     // "myComponent" tag was resolved
     ht.XmlTagNode tagNode =
         ht.HtmlUnitUtils.getTagNode(indexUnit, findOffset2("myComponent"));
     AngularSelectorElement tagElement =
         tagNode.element as AngularSelectorElement;
     JUnitTestCase.assertNotNull(tagElement);
     JUnitTestCase.assertEquals("myComponent", tagElement.name);
     JUnitTestCase.assertEquals(
@@ skipping 22 matching lines @@
   void test_NgDirective_noAttribute() {
     addMainSource(r'''
 
 import 'angular.dart';
 
 @NgDirective(selector: '[my-directive]', map: const {'foo': '=>input'})
 class MyDirective {
   set input(value) {}
 }''');
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(["<div my-directive>", "</div>"]));
+        AngularTest.createHtmlWithMyController(r'''
+<div my-directive>
+</div>'''));
   }
 
   void test_NgDirective_noExpression() {
     addMainSource(r'''
 
 import 'angular.dart';
 
 @NgDirective(selector: '[my-directive]', map: const {'.': '=>input'})
 class MyDirective {
   set input(value) {}
 }''');
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(["<div my-directive>", "</div>"]));
+        AngularTest.createHtmlWithMyController(r'''
+<div my-directive>
+</div>'''));
   }
 
   void test_NgDirective_resolvedExpression() {
     addMainSource(r'''
 
 import 'angular.dart';
 
 @Decorator(selector: '[my-directive]')
 class MyDirective {
   @NgOneWay('my-property')
   String condition;
 }''');
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(
-            [
-                "<input type='text' ng-model='name'>",
-                "<div my-directive my-property='name != null'>",
-                "</div>"]));
+        AngularTest.createHtmlWithMyController(r'''
+<input type='text' ng-model='name'>
+<div my-directive my-property='name != null'>
+</div>'''));
     resolveMainNoErrors();
     // "my-directive" attribute was resolved
     {
       AngularSelectorElement selector =
           findMainElement(ElementKind.ANGULAR_SELECTOR, "my-directive");
       ht.XmlAttributeNode attrNodeSelector =
           ht.HtmlUnitUtils.getAttributeNode(indexUnit, findOffset2("my-directive"));
       JUnitTestCase.assertNotNull(attrNodeSelector);
       JUnitTestCase.assertSame(selector, attrNodeSelector.element);
     }
@@ skipping 17 matching lines @@
     addMainSource(r'''
 
 import 'angular.dart';
 
 @NgDirective(selector: '[my-directive])
 class MyDirective {
   @NgAttr('my-property')
   String property;
 }''');
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(
-            [
-                "<input type='text' ng-model='name'>",
-                "<div my-directive my-property='name != null'>",
-                "</div>"]));
+        AngularTest.createHtmlWithMyController(r'''
+<input type='text' ng-model='name'>
+<div my-directive my-property='name != null'>
+</div>'''));
     resolveMain();
     // @NgAttr means "string attribute", which we don't parse
     JUnitTestCase.assertNull(findIdentifierMaybe("name != null"));
   }
 
   void test_NgDirective_resolvedExpression_dotAsName() {
     addMainSource(r'''
 
 import 'angular.dart';
 
 @Decorator(
     selector: '[my-directive]',
     map: const {'.' : '=>condition'})
 class MyDirective {
   set condition(value) {}
 }''');
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(
-            [
-                "<input type='text' ng-model='name'>",
-                "<div my-directive='name != null'>",
-                "</div>"]));
+        AngularTest.createHtmlWithMyController(r'''
+<input type='text' ng-model='name'>
+<div my-directive='name != null'>
+</div>'''));
     // "name" attribute was resolved
     JUnitTestCase.assertNotNull(findIdentifier("name != null"));
   }
 
   void fail_analysisContext_changeDart_invalidateApplication() {
     addMainSource(r'''
 
 import 'angular.dart';
 
 @Component(
     templateUrl: 'my_template.html', cssUrl: 'my_styles.css',
     publishAs: 'ctrl',
     selector: 'myComponent')
 class MyComponent {
 }''');
     contextHelper.addSource(
         "/entry-point.html",
-        AngularTest.createHtmlWithAngular([]));
+        AngularTest.createHtmlWithAngular(''));
     addIndexSource2(
         "/my_template.html",
         r'''
-    <div>
-      {{ctrl.noMethod()}}
-    </div>''');
+<div>
+  {{ctrl.noMethod()}}
+</div>''');
     contextHelper.addSource("/my_styles.css", "");
     contextHelper.runTasks();
     // there are some errors in my_template.html
     {
       List<AnalysisError> errors = context.getErrors(indexSource).errors;
       JUnitTestCase.assertTrue(errors.length != 0);
     }
     // change main.dart, there are no MyComponent anymore
     context.setContents(mainSource, "");
     // ...errors in my_template.html should be removed
@@ skipping 10 matching lines @@
 import 'angular.dart';
 
 @Component(
     templateUrl: 'no-such-template.html', cssUrl: 'my_styles.css',
     publishAs: 'ctrl',
     selector: 'myComponent')
 class MyComponent {
 }''');
     Source entrySource = contextHelper.addSource(
         "/entry-point.html",
-        AngularTest.createHtmlWithAngular([]));
+        AngularTest.createHtmlWithAngular(''));
     contextHelper.addSource("/my_styles.css", "");
     contextHelper.runTasks();
     // there are some errors in MyComponent
     {
       List<AnalysisError> errors = context.getErrors(mainSource).errors;
       JUnitTestCase.assertTrue(errors.length != 0);
     }
     // make entry-point.html non-Angular
     context.setContents(entrySource, "<html/>");
     // ...errors in MyComponent should be removed
     {
       List<AnalysisError> errors = context.getErrors(mainSource).errors;
       JUnitTestCase.assertTrue(errors.length == 0);
     }
   }
 
   void test_analysisContext_changeEntryPoint_clearAngularErrors_inTemplate() {
     addMainSource(r'''
 
 import 'angular.dart';
 
 @Component(
     templateUrl: 'my_template.html', cssUrl: 'my_styles.css',
     publishAs: 'ctrl',
     selector: 'myComponent')
 class MyComponent {
 }''');
     Source entrySource = contextHelper.addSource(
         "/entry-point.html",
-        AngularTest.createHtmlWithAngular([]));
+        AngularTest.createHtmlWithAngular(''));
     addIndexSource2(
         "/my_template.html",
         r'''
-    <div>
-      {{ctrl.noMethod()}}
-    </div>''');
+<div>
+  {{ctrl.noMethod()}}
+</div>''');
     contextHelper.addSource("/my_styles.css", "");
     contextHelper.runTasks();
     // there are some errors in my_template.html
     {
       List<AnalysisError> errors = context.getErrors(indexSource).errors;
       JUnitTestCase.assertTrue(errors.length != 0);
     }
     // make entry-point.html non-Angular
     context.setContents(entrySource, "<html/>");
     // ...errors in my_template.html should be removed
     {
       List<AnalysisError> errors = context.getErrors(indexSource).errors;
       JUnitTestCase.assertTrue(errors.length == 0);
     }
   }
 
   void test_analysisContext_removeEntryPoint_clearAngularErrors_inDart() {
     addMainSource(r'''
 
 import 'angular.dart';
 
 @Component(
     templateUrl: 'no-such-template.html', cssUrl: 'my_styles.css',
     publishAs: 'ctrl',
     selector: 'myComponent')
 class MyComponent {
 }''');
     Source entrySource = contextHelper.addSource(
         "/entry-point.html",
-        AngularTest.createHtmlWithAngular([]));
+        AngularTest.createHtmlWithAngular(''));
     contextHelper.addSource("/my_styles.css", "");
     contextHelper.runTasks();
     // there are some errors in MyComponent
     {
       List<AnalysisError> errors = context.getErrors(mainSource).errors;
       JUnitTestCase.assertTrue(errors.length != 0);
     }
     // remove entry-point.html
     {
       ChangeSet changeSet = new ChangeSet();
       changeSet.removedSource(entrySource);
       context.applyChanges(changeSet);
     }
     // ...errors in MyComponent should be removed
     {
       List<AnalysisError> errors = context.getErrors(mainSource).errors;
       JUnitTestCase.assertTrue(errors.length == 0);
     }
   }
 
   void test_contextProperties() {
     addMyController();
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithAngular(
-            ["<div>", "  {{\$id}}", "  {{\$parent}}", "  {{\$root}}", "</div>"]));
+        AngularTest.createHtmlWithAngular(r'''
+<div>
+  {{$id}}
+  {{$parent}}
+  {{$root}}
+</div>'''));
     assertResolvedIdentifier("\$id");
     assertResolvedIdentifier("\$parent");
     assertResolvedIdentifier("\$root");
   }
 
   void test_getAngularElement_isAngular() {
     // prepare local variable "name" in compilation unit
     CompilationUnitElementImpl unit =
         ElementFactory.compilationUnit("test.dart");
     FunctionElementImpl function = ElementFactory.functionElement("main");
@@ skipping 20 matching lines @@
     JUnitTestCase.assertNull(
         AngularHtmlUnitResolver.getAngularElement(element));
   }
 
   /**
    * Test that we resolve "ng-click" expression.
    */
   void test_ngClick() {
     addMyController();
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(
-            ["<button ng-click='ctrl.doSomething(\$event)'/>"]));
+        AngularTest.createHtmlWithMyController(r"<button ng-click='ctrl.doSomething($event)'/>"));
     assertResolvedIdentifier("doSomething");
   }
 
   /**
    * Test that we resolve "ng-if" expression.
    */
   void test_ngIf() {
     addMyController();
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(["<div ng-if='ctrl.field != null'/>"]));
+        AngularTest.createHtmlWithMyController("<div ng-if='ctrl.field != null'/>"));
     assertResolvedIdentifier("field");
   }
 
   void test_ngModel_modelAfterUsage() {
     addMyController();
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(
-            ["<h3>Hello {{name}}!</h3>", "<input type='text' ng-model='name'>"]));
+        AngularTest.createHtmlWithMyController(r'''
+<h3>Hello {{name}}!</h3>
+<input type='text' ng-model='name'>'''));
     assertResolvedIdentifier2("name}}!", "String");
     assertResolvedIdentifier2("name'>", "String");
   }
 
   void test_ngModel_modelBeforeUsage() {
     addMyController();
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(
-            ["<input type='text' ng-model='name'>", "<h3>Hello {{name}}!</h3>"]));
+        AngularTest.createHtmlWithMyController(r'''
+<input type='text' ng-model='name'>
+<h3>Hello {{name}}!</h3>'''));
     assertResolvedIdentifier2("name}}!", "String");
     Element element = assertResolvedIdentifier2("name'>", "String");
     JUnitTestCase.assertEquals("name", element.name);
     JUnitTestCase.assertEquals(findOffset2("name'>"), element.nameOffset);
   }
 
   void test_ngModel_notIdentifier() {
     addMyController();
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(
-            ["<input type='text' ng-model='ctrl.field'>"]));
+        AngularTest.createHtmlWithMyController("<input type='text' ng-model='ctrl.field'>"));
     assertResolvedIdentifier2("field'>", "String");
   }
 
   /**
    * Test that we resolve "ng-mouseout" expression.
    */
   void test_ngMouseOut() {
     addMyController();
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(
-            ["<button ng-mouseout='ctrl.doSomething(\$event)'/>"]));
+        AngularTest.createHtmlWithMyController(r"<button ng-mouseout='ctrl.doSomething($event)'/>"));
     assertResolvedIdentifier("doSomething");
   }
 
   void fail_ngRepeat_additionalVariables() {
     addMyController();
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(
-            [
-                "<li ng-repeat='name in ctrl.names'>",
-                "  {{\$index}} {{\$first}} {{\$middle}} {{\$last}} {{\$even}} {{\$odd}}",
-                "</li>"]));
+        AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat='name in ctrl.names'>
+  {{$index}} {{$first}} {{$middle}} {{$last}} {{$even}} {{$odd}}
+</li>'''));
     assertResolvedIdentifier2("\$index", "int");
     assertResolvedIdentifier2("\$first", "bool");
     assertResolvedIdentifier2("\$middle", "bool");
     assertResolvedIdentifier2("\$last", "bool");
     assertResolvedIdentifier2("\$even", "bool");
     assertResolvedIdentifier2("\$odd", "bool");
   }
 
   void fail_ngRepeat_bad_expectedIdentifier() {
     addMyController();
     resolveIndex2(
-        AngularTest.createHtmlWithMyController(
-            ["<li ng-repeat='name + 42 in ctrl.names'>", "</li>"]));
+        AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat='name + 42 in ctrl.names'>
+</li>'''));
     assertErrors(indexSource, [AngularCode.INVALID_REPEAT_ITEM_SYNTAX]);
   }
 
   void fail_ngRepeat_bad_expectedIn() {
     addMyController();
     resolveIndex2(
-        AngularTest.createHtmlWithMyController(
-            ["<li ng-repeat='name : ctrl.names'>", "</li>"]));
+        AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat='name : ctrl.names'>
+</li>'''));
     assertErrors(indexSource, [AngularCode.INVALID_REPEAT_SYNTAX]);
   }
 
   void fail_ngRepeat_filters_filter_literal() {
     addMyController();
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(
-            ["<li ng-repeat='item in ctrl.items | filter:42:null'/>", "</li>"]));
+        AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat='item in ctrl.items | filter:42:null'/>
+</li>'''));
     // filter "filter" is resolved
     Element filterElement = assertResolvedIdentifier("filter");
     EngineTestCase.assertInstanceOf(
         (obj) => obj is AngularFormatterElement,
         AngularFormatterElement,
         filterElement);
   }
 
   void fail_ngRepeat_filters_filter_propertyMap() {
     addMyController();
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(
-            [
-                "<li ng-repeat='item in ctrl.items | filter:{name:null, done:false}'/>",
-                "</li>"]));
+        AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat='item in ctrl.items | filter:{name:null, done:false}'/>
+</li>'''));
     assertResolvedIdentifier2("name:", "String");
     assertResolvedIdentifier2("done:", "bool");
   }
 
   void fail_ngRepeat_filters_missingColon() {
     addMyController();
     resolveIndex2(
-        AngularTest.createHtmlWithMyController(
-            ["<li ng-repeat=\"item in ctrl.items | orderBy:'' true\"/>", "</li>"]));
+        AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat="item in ctrl.items | orderBy:'' true"/>
+</li>'''));
     assertErrors(indexSource, [AngularCode.MISSING_FORMATTER_COLON]);
   }
 
   void fail_ngRepeat_filters_noArgs() {
     addMyController();
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(
-            ["<li ng-repeat=\"item in ctrl.items | orderBy\"/>", "</li>"]));
+        AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat="item in ctrl.items | orderBy"/>
+</li>'''));
     // filter "orderBy" is resolved
     Element filterElement = assertResolvedIdentifier("orderBy");
     EngineTestCase.assertInstanceOf(
         (obj) => obj is AngularFormatterElement,
         AngularFormatterElement,
         filterElement);
   }
 
   void fail_ngRepeat_filters_orderBy_emptyString() {
     addMyController();
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(
-            ["<li ng-repeat=\"item in ctrl.items | orderBy:'':true\"/>", "</li>"]));
+        AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat="item in ctrl.items | orderBy:'':true"/>
+</li>'''));
     // filter "orderBy" is resolved
     Element filterElement = assertResolvedIdentifier("orderBy");
     EngineTestCase.assertInstanceOf(
         (obj) => obj is AngularFormatterElement,
         AngularFormatterElement,
         filterElement);
   }
 
   void fail_ngRepeat_filters_orderBy_propertyList() {
     addMyController();
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(
-            [
-                "<li ng-repeat=\"item in ctrl.items | orderBy:['name', 'done']\"/>",
-                "</li>"]));
+        AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat="item in ctrl.items | orderBy:['name', 'done']"/>
+</li>'''));
     assertResolvedIdentifier2("name'", "String");
     assertResolvedIdentifier2("done'", "bool");
   }
 
   void fail_ngRepeat_filters_orderBy_propertyName() {
     addMyController();
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(
-            ["<li ng-repeat=\"item in ctrl.items | orderBy:'name'\"/>", "</li>"]));
+        AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat="item in ctrl.items | orderBy:'name'"/>
+</li>'''));
     assertResolvedIdentifier2("name'", "String");
   }
 
   void fail_ngRepeat_filters_orderBy_propertyName_minus() {
     addMyController();
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(
-            ["<li ng-repeat=\"item in ctrl.items | orderBy:'-name'\"/>", "</li>"]));
+        AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat="item in ctrl.items | orderBy:'-name'"/>
+</li>'''));
     assertResolvedIdentifier2("name'", "String");
   }
 
   void fail_ngRepeat_filters_orderBy_propertyName_plus() {
     addMyController();
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(
-            ["<li ng-repeat=\"item in ctrl.items | orderBy:'+name'\"/>", "</li>"]));
+        AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat="item in ctrl.items | orderBy:'+name'"/>
+</li>'''));
     assertResolvedIdentifier2("name'", "String");
   }
 
   void fail_ngRepeat_filters_orderBy_propertyName_untypedItems() {
     addMyController();
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(
-            ["<li ng-repeat=\"item in ctrl.untypedItems | orderBy:'name'\"/>", "</li>"]));
+        AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat="item in ctrl.untypedItems | orderBy:'name'"/>
+</li>'''));
     assertResolvedIdentifier2("name'", "dynamic");
   }
 
   void fail_ngRepeat_filters_two() {
     addMyController();
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(
-            [
-                "<li ng-repeat=\"item in ctrl.items | orderBy:'+' | orderBy:'-'\"/>",
-                "</li>"]));
+        AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat="item in ctrl.items | orderBy:'+' | orderBy:'-'"/>
+</li>'''));
     EngineTestCase.assertInstanceOf(
         (obj) => obj is AngularFormatterElement,
         AngularFormatterElement,
         assertResolvedIdentifier("orderBy:'+'"));
     EngineTestCase.assertInstanceOf(
         (obj) => obj is AngularFormatterElement,
         AngularFormatterElement,
         assertResolvedIdentifier("orderBy:'-'"));
   }
 
   void fail_ngRepeat_resolvedExpressions() {
     addMyController();
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(
-            ["<li ng-repeat='name in ctrl.names'>", "  {{name}}", "</li>"]));
+        AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat='name in ctrl.names'>
+  {{name}}
+</li>'''));
     assertResolvedIdentifier2("name in", "String");
     assertResolvedIdentifier2("ctrl.", "MyController");
     assertResolvedIdentifier2("names'", "List<String>");
     assertResolvedIdentifier2("name}}", "String");
   }
 
   void fail_ngRepeat_trackBy() {
     addMyController();
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(
-            ["<li ng-repeat='name in ctrl.names track by name.length'/>", "</li>"]));
+        AngularTest.createHtmlWithMyController(r'''
+<li ng-repeat='name in ctrl.names track by name.length'/>
+</li>'''));
     assertResolvedIdentifier2("length'", "int");
   }
 
   /**
    * Test that we resolve "ng-show" expression.
    */
   void test_ngShow() {
     addMyController();
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(
-            ["<div ng-show='ctrl.field != null'/>"]));
+        AngularTest.createHtmlWithMyController("<div ng-show='ctrl.field != null'/>"));
     assertResolvedIdentifier("field");
   }
 
   void test_notResolved_noDartScript() {
     resolveIndex2(r'''
 <html ng-app>
   <body>
     <div my-marker>
       {{ctrl.field}}
     </div>
@@ skipping 95 matching lines @@
     // ...but not "invisibleScopeProperty"
     {
       SimpleIdentifier identifier = findIdentifier("invisibleScopeProperty");
       JUnitTestCase.assertNull(identifier.bestElement);
     }
   }
 
   void test_resolveExpression_inAttribute() {
     addMyController();
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(
-            ["<button title='{{ctrl.field}}'></button>"]));
+        AngularTest.createHtmlWithMyController("<button title='{{ctrl.field}}'></button>"));
     assertResolvedIdentifier2("ctrl", "MyController");
   }
 
   void test_resolveExpression_ngApp_onBody() {
     addMyController();
     _resolveIndexNoErrors(r'''
 <html>
   <body ng-app>
     <div my-controller>
       {{ctrl.field}}
     </div>
     <script type='application/dart' src='main.dart'></script>
   </body>
 </html>''');
     assertResolvedIdentifier2("ctrl", "MyController");
   }
 
   void test_resolveExpression_withFilter() {
     addMyController();
     _resolveIndexNoErrors(
-        AngularTest.createHtmlWithMyController(["{{ctrl.field | uppercase}}"]));
+        AngularTest.createHtmlWithMyController("{{ctrl.field | uppercase}}"));
     assertResolvedIdentifier2("ctrl", "MyController");
     assertResolvedIdentifier("uppercase");
   }
 
   void test_resolveExpression_withFilter_notSimpleIdentifier() {
     addMyController();
     resolveIndex2(
-        AngularTest.createHtmlWithMyController(["{{ctrl.field | not.supported}}"]));
+        AngularTest.createHtmlWithMyController("{{ctrl.field | not.supported}}"));
     assertErrors(indexSource, [AngularCode.INVALID_FORMATTER_NAME]);
   }
 
   void test_scopeProperties() {
     addMainSource(r'''
 
 import 'angular.dart';
 
 @Component(
     templateUrl: 'my_template.html', cssUrl: 'my_styles.css',
     publishAs: 'ctrl',
     selector: 'myComponent')
 class MyComponent {
   String field;
   MyComponent(Scope scope) {
     scope.context['scopeProperty'] = 'abc';
   }
 }
 ''');
     contextHelper.addSource(
         "/entry-point.html",
-        AngularTest.createHtmlWithAngular([]));
+        AngularTest.createHtmlWithAngular(''));
     addIndexSource2(
         "/my_template.html",
         r'''
-    <div>
-      {{scopeProperty}}
-    </div>''');
+<div>
+  {{scopeProperty}}
+</div>''');
     contextHelper.addSource("/my_styles.css", "");
     contextHelper.runTasks();
     resolveIndex();
     assertNoErrors();
     // "scopeProperty" is resolved
     Element element = assertResolvedIdentifier2("scopeProperty}}", "String");
     EngineTestCase.assertInstanceOf(
         (obj) => obj is AngularScopePropertyElement,
         AngularScopePropertyElement,
         AngularHtmlUnitResolver.getAngularElement(element));
@@ skipping 10 matching lines @@
     selector: 'myComponent')
 class MyComponent {
 }
 
 void setScopeProperties(Scope scope) {
   scope.context['ctrl'] = 1;
 }
 ''');
     contextHelper.addSource(
         "/entry-point.html",
-        AngularTest.createHtmlWithAngular([]));
+        AngularTest.createHtmlWithAngular(''));
     addIndexSource2(
         "/my_template.html",
         r'''
-    <div>
-      {{ctrl}}
-    </div>''');
+<div>
+  {{ctrl}}
+</div>''');
     contextHelper.addSource("/my_styles.css", "");
     contextHelper.runTasks();
     resolveIndex();
     assertNoErrors();
     // "ctrl" is resolved
     LocalVariableElement element =
         assertResolvedIdentifier("ctrl}}") as LocalVariableElement;
     List<ToolkitObjectElement> toolkitObjects = element.toolkitObjects;
     EngineTestCase.assertInstanceOf(
         (obj) => obj is AngularComponentElement,
@@ skipping 13 matching lines @@
   String field;
 }
 
 class MyRouteInitializer {
   init(ViewFactory view) {
     view('my_template.html');
   }
 }''');
     contextHelper.addSource(
         "/entry-point.html",
-        AngularTest.createHtmlWithAngular([]));
+        AngularTest.createHtmlWithAngular(''));
     addIndexSource2(
         "/my_template.html",
         r'''
-    <div my-controller>
-      {{ctrl.field}}
-    </div>''');
+<div my-controller>
+  {{ctrl.field}}
+</div>''');
     contextHelper.addSource("/my_styles.css", "");
     contextHelper.runTasks();
     resolveIndex();
     assertNoErrors();
     assertResolvedIdentifier2("ctrl.", "MyController");
     assertResolvedIdentifier2("field}}", "String");
   }
 
   String _getSourceContent(Source source) {
     return context.getContents(source).data.toString();
@@ skipping 577 matching lines @@
 Injector ngBootstrap({
         Module module: null,
         List<Module> modules: null,
         /*dom.Element*/ element: null,
         String selector: '[ng-app]',
         /*Injector*/ injectorFactory/*(List<Module> modules): _defaultInjectorFactory*/}) {}
 ''');
   }
 
   /**
-   * Creates an HTML content that has Angular marker and script with "main.dart" reference.
+   * Creates an HTML content that has Angular marker and script with
+   * the "main.dart" reference.
    */
-  static String createHtmlWithAngular(List<String> lines) {
-    String source = r'''
+  static String createHtmlWithAngular(String innerCode) {
+    String source = '''
 <html ng-app>
-  <body>''';
-    source += EngineTestCase.createSource(lines);
-    source += r'''
+  <body>
+$innerCode
     <script type='application/dart' src='main.dart'></script>
   </body>
 </html>''';
     return source;
   }
 
   /**
    * Creates an HTML content that has Angular marker, script with "main.dart" reference and
    * "MyController" injected.
    */
-  static String createHtmlWithMyController(List<String> lines) {
-    String source = r'''
+  static String createHtmlWithMyController(String innerHtml) {
+    String source = '''
 <html ng-app>
   <body>
-    <div my-controller>''';
-    source += EngineTestCase.createSource(lines);
-    source += r'''
+    <div my-controller>
+$innerHtml
     </div>
     <script type='application/dart' src='main.dart'></script>
   </body>
 </html>''';
     return source;
   }
 
   /**
    * Finds an [Element] with the given names inside of the given root [Element].
    *
@@ skipping 5391 matching lines @@
         null,
         AstFactory.identifier3("main"),
         AstFactory.formalParameterList([formalParameter]),
         body);
   }
 }
 
 
 class ElementLocatorTest extends ResolverTestCase {
   void fail_locate_ExportDirective() {
-    AstNode id = _findNodeIn("export", ["export 'dart:core';"]);
+    AstNode id = _findNodeIn("export", "export 'dart:core';");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ImportElement,
         ImportElement,
         element);
   }
 
   void fail_locate_Identifier_libraryDirective() {
-    AstNode id = _findNodeIn("foo", ["library foo.bar;"]);
+    AstNode id = _findNodeIn("foo", "library foo.bar;");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is LibraryElement,
         LibraryElement,
         element);
   }
 
   void fail_locate_Identifier_partOfDirective() {
     // Can't resolve the library element without the library declaration.
     //    AstNode id = findNodeIn("foo", "part of foo.bar;");
     //    Element element = ElementLocator.locate(id);
     //    assertInstanceOf(LibraryElement.class, element);
     JUnitTestCase.fail("Test this case");
   }
 
   @override
   void reset() {
     AnalysisOptionsImpl analysisOptions = new AnalysisOptionsImpl();
     analysisOptions.hint = false;
     resetWithOptions(analysisOptions);
   }
 
   void test_locateWithOffset_BinaryExpression() {
-    AstNode id = _findNodeIn("+", ["var x = 3 + 4;"]);
+    AstNode id = _findNodeIn("+", "var x = 3 + 4;");
     Element element = ElementLocator.locateWithOffset(id, 0);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is MethodElement,
         MethodElement,
         element);
   }
 
   void test_locateWithOffset_StringLiteral() {
-    AstNode id = _findNodeIn("abc", ["var x = 'abc';"]);
+    AstNode id = _findNodeIn("abc", "var x = 'abc';");
     Element element = ElementLocator.locateWithOffset(id, 1);
     JUnitTestCase.assertNull(element);
   }
 
   void test_locate_AssignmentExpression() {
     AstNode id =
-        _findNodeIn("+=", ["int x = 0;", "void main() {", "  x += 1;", "}"]);
+        _findNodeIn("+=", r'''
+int x = 0;
+void main() {
+  x += 1;
+}''');
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is MethodElement,
         MethodElement,
         element);
   }
 
   void test_locate_BinaryExpression() {
-    AstNode id = _findNodeIn("+", ["var x = 3 + 4;"]);
+    AstNode id = _findNodeIn("+", "var x = 3 + 4;");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is MethodElement,
         MethodElement,
         element);
   }
 
   void test_locate_ClassDeclaration() {
-    AstNode id = _findNodeIn("class", ["class A { }"]);
+    AstNode id = _findNodeIn("class", "class A { }");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ClassElement,
         ClassElement,
         element);
   }
 
   void test_locate_CompilationUnit() {
-    CompilationUnit cu = _resolveContents(["// only comment"]);
+    CompilationUnit cu = _resolveContents("// only comment");
     JUnitTestCase.assertNotNull(cu.element);
     Element element = ElementLocator.locate(cu);
     JUnitTestCase.assertSame(cu.element, element);
   }
 
   void test_locate_ConstructorDeclaration() {
     AstNode id =
-        _findNodeIndexedIn("bar", 0, ["class A {", "  A.bar() {}", "}"]);
+        _findNodeIndexedIn("bar", 0, r'''
+class A {
+  A.bar() {}
+}''');
     ConstructorDeclaration declaration =
         id.getAncestor((node) => node is ConstructorDeclaration);
     Element element = ElementLocator.locate(declaration);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ConstructorElement,
         ConstructorElement,
         element);
   }
 
   void test_locate_FunctionDeclaration() {
-    AstNode id = _findNodeIn("f", ["int f() => 3;"]);
+    AstNode id = _findNodeIn("f", "int f() => 3;");
     FunctionDeclaration declaration =
         id.getAncestor((node) => node is FunctionDeclaration);
     Element element = ElementLocator.locate(declaration);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FunctionElement,
         FunctionElement,
         element);
   }
 
   void
       test_locate_Identifier_annotationClass_namedConstructor_forSimpleFormalParameter() {
     AstNode id = _findNodeIndexedIn(
         "Class",
         2,
-        [
-            "class Class {",
-            "  const Class.name();",
-            "}",
-            "void main(@Class.name() parameter) {",
-            "}"]);
+        r'''
+class Class {
+  const Class.name();
+}
+void main(@Class.name() parameter) {
+}''');
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ClassElement,
         ClassElement,
         element);
   }
 
   void
       test_locate_Identifier_annotationClass_unnamedConstructor_forSimpleFormalParameter() {
     AstNode id = _findNodeIndexedIn(
         "Class",
         2,
-        [
-            "class Class {",
-            "  const Class();",
-            "}",
-            "void main(@Class() parameter) {",
-            "}"]);
+        r'''
+class Class {
+  const Class();
+}
+void main(@Class() parameter) {
+}''');
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ConstructorElement,
         ConstructorElement,
         element);
   }
 
   void test_locate_Identifier_className() {
-    AstNode id = _findNodeIn("A", ["class A { }"]);
+    AstNode id = _findNodeIn("A", "class A { }");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ClassElement,
         ClassElement,
         element);
   }
 
   void test_locate_Identifier_constructor_named() {
     AstNode id =
-        _findNodeIndexedIn("bar", 0, ["class A {", "  A.bar() {}", "}"]);
+        _findNodeIndexedIn("bar", 0, r'''
+class A {
+  A.bar() {}
+}''');
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ConstructorElement,
         ConstructorElement,
         element);
   }
 
   void test_locate_Identifier_constructor_unnamed() {
-    AstNode id = _findNodeIndexedIn("A", 1, ["class A {", "  A() {}", "}"]);
+    AstNode id = _findNodeIndexedIn("A", 1, r'''
+class A {
+  A() {}
+}''');
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ConstructorElement,
         ConstructorElement,
         element);
   }
 
   void test_locate_Identifier_fieldName() {
-    AstNode id = _findNodeIn("x", ["class A { var x; }"]);
+    AstNode id = _findNodeIn("x", "class A { var x; }");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FieldElement,
         FieldElement,
         element);
   }
 
   void test_locate_Identifier_propertAccess() {
     AstNode id =
-        _findNodeIn("length", ["void main() {", " int x = 'foo'.length;", "}"]);
+        _findNodeIn("length", r'''
+void main() {
+ int x = 'foo'.length;
+}''');
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is PropertyAccessorElement,
         PropertyAccessorElement,
         element);
   }
 
   void test_locate_ImportDirective() {
-    AstNode id = _findNodeIn("import", ["import 'dart:core';"]);
+    AstNode id = _findNodeIn("import", "import 'dart:core';");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ImportElement,
         ImportElement,
         element);
   }
 
   void test_locate_IndexExpression() {
     AstNode id = _findNodeIndexedIn(
         "\\[",
         1,
-        ["void main() {", "  List x = [1, 2];", "  var y = x[0];", "}"]);
+        r'''
+void main() {
+  List x = [1, 2];
+  var y = x[0];
+}''');
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is MethodElement,
         MethodElement,
         element);
   }
 
   void test_locate_InstanceCreationExpression() {
     AstNode node =
-        _findNodeIndexedIn("A(", 0, ["class A {}", "void main() {", " new A();", "}"]);
+        _findNodeIndexedIn("A(", 0, r'''
+class A {}
+void main() {
+ new A();
+}''');
     Element element = ElementLocator.locate(node);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ConstructorElement,
         ConstructorElement,
         element);
   }
 
   void test_locate_InstanceCreationExpression_type_prefixedIdentifier() {
     // prepare: new pref.A()
     SimpleIdentifier identifier = AstFactory.identifier3("A");
@@ skipping 30 matching lines @@
     // set ConstructorElement
     ConstructorElement constructorElement =
         ElementFactory.constructorElement2(classElement, null, []);
     creation.constructorName.staticElement = constructorElement;
     // verify that "A" is resolved to ConstructorElement
     Element element = ElementLocator.locate(identifier);
     JUnitTestCase.assertSame(classElement, element);
   }
 
   void test_locate_LibraryDirective() {
-    AstNode id = _findNodeIn("library", ["library foo;"]);
+    AstNode id = _findNodeIn("library", "library foo;");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is LibraryElement,
         LibraryElement,
         element);
   }
 
   void test_locate_MethodDeclaration() {
-    AstNode id = _findNodeIn("m", ["class A {", "  void m() {}", "}"]);
+    AstNode id = _findNodeIn("m", r'''
+class A {
+  void m() {}
+}''');
     MethodDeclaration declaration =
         id.getAncestor((node) => node is MethodDeclaration);
     Element element = ElementLocator.locate(declaration);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is MethodElement,
         MethodElement,
         element);
   }
 
   void test_locate_MethodInvocation_method() {
     AstNode id = _findNodeIndexedIn(
         "bar",
         1,
-        [
-            "class A {",
-            "  int bar() => 42;",
-            "}",
-            "void main() {",
-            " var f = new A().bar();",
-            "}"]);
+        r'''
+class A {
+  int bar() => 42;
+}
+void main() {
+ var f = new A().bar();
+}''');
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is MethodElement,
         MethodElement,
         element);
   }
 
   void test_locate_MethodInvocation_topLevel() {
-    String contents =
+    String code =
         r'''
 foo(x) {}
 void main() {
  foo(0);
 }''';
-    CompilationUnit cu = _resolveContents([contents]);
-    int offset = contents.indexOf('foo(0)');
+    CompilationUnit cu = _resolveContents(code);
+    int offset = code.indexOf('foo(0)');
     AstNode node = new NodeLocator.con1(offset).searchWithin(cu);
     MethodInvocation invocation =
         node.getAncestor((n) => n is MethodInvocation);
     Element element = ElementLocator.locate(invocation);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FunctionElement,
         FunctionElement,
         element);
   }
 
   void test_locate_PostfixExpression() {
-    AstNode id = _findNodeIn("++", ["int addOne(int x) => x++;"]);
+    AstNode id = _findNodeIn("++", "int addOne(int x) => x++;");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is MethodElement,
         MethodElement,
         element);
   }
 
   void test_locate_PrefixExpression() {
-    AstNode id = _findNodeIn("++", ["int addOne(int x) => ++x;"]);
+    AstNode id = _findNodeIn("++", "int addOne(int x) => ++x;");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is MethodElement,
         MethodElement,
         element);
   }
 
   void test_locate_PrefixedIdentifier() {
     AstNode id =
-        _findNodeIn("int", ["import 'dart:core' as core;", "core.int value;"]);
+        _findNodeIn("int", r'''
+import 'dart:core' as core;
+core.int value;''');
     PrefixedIdentifier identifier =
         id.getAncestor((node) => node is PrefixedIdentifier);
     Element element = ElementLocator.locate(identifier);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ClassElement,
         ClassElement,
         element);
   }
 
   void test_locate_StringLiteral_exportUri() {
     addNamedSource("/foo.dart", "library foo;");
-    AstNode id = _findNodeIn("'foo.dart'", ["export 'foo.dart';"]);
+    AstNode id = _findNodeIn("'foo.dart'", "export 'foo.dart';");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is LibraryElement,
         LibraryElement,
         element);
   }
 
   void test_locate_StringLiteral_expression() {
-    AstNode id = _findNodeIn("abc", ["var x = 'abc';"]);
+    AstNode id = _findNodeIn("abc", "var x = 'abc';");
     Element element = ElementLocator.locate(id);
     JUnitTestCase.assertNull(element);
   }
 
   void test_locate_StringLiteral_importUri() {
     addNamedSource("/foo.dart", "library foo; class A {}");
     AstNode id =
-        _findNodeIn("'foo.dart'", ["import 'foo.dart'; class B extends A {}"]);
+        _findNodeIn("'foo.dart'", "import 'foo.dart'; class B extends A {}");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is LibraryElement,
         LibraryElement,
         element);
   }
 
   void test_locate_StringLiteral_partUri() {
     addNamedSource("/foo.dart", "part of app;");
-    AstNode id = _findNodeIn("'foo.dart'", ["library app; part 'foo.dart';"]);
+    AstNode id = _findNodeIn("'foo.dart'", "library app; part 'foo.dart';");
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is CompilationUnitElement,
         CompilationUnitElement,
         element);
   }
 
   void test_locate_VariableDeclaration() {
-    AstNode id = _findNodeIn("x", ["var x = 'abc';"]);
+    AstNode id = _findNodeIn("x", "var x = 'abc';");
     VariableDeclaration declaration =
         id.getAncestor((node) => node is VariableDeclaration);
     Element element = ElementLocator.locate(declaration);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is TopLevelVariableElement,
         TopLevelVariableElement,
         element);
   }
 
   /**
    * Find the first AST node matching a pattern in the resolved AST for the given source.
    *
-   * @param nodePattern the (unique) pattern used to identify the node of interest
-   * @param lines the lines to be merged into a single source string
-   * @return the matched node in the resolved AST for the given source lines
-   * @throws Exception if source cannot be verified
+   * [nodePattern] the (unique) pattern used to identify the node of interest.
+   * [code] the code to resolve.
+   * Returns the matched node in the resolved AST for the given source lines.
    */
-  AstNode _findNodeIn(String nodePattern, List<String> lines) {
-    return _findNodeIndexedIn(nodePattern, 0, lines);
+  AstNode _findNodeIn(String nodePattern, String code) {
+    return _findNodeIndexedIn(nodePattern, 0, code);
   }
 
   /**
    * Find the AST node matching the given indexed occurrence of a pattern in the resolved AST for
    * the given source.
    *
-   * @param nodePattern the pattern used to identify the node of interest
-   * @param index the index of the pattern match of interest
-   * @param lines the lines to be merged into a single source string
-   * @return the matched node in the resolved AST for the given source lines
-   * @throws Exception if source cannot be verified
+   * [nodePattern] the pattern used to identify the node of interest.
+   * [index] the index of the pattern match of interest.
+   * [code] the code to resolve.
+   * Returns the matched node in the resolved AST for the given source lines
    */
   AstNode _findNodeIndexedIn(String nodePattern, int index,
-      List<String> lines) {
-    String contents = EngineTestCase.createSource(lines);
-    CompilationUnit cu = _resolveContents([contents]);
-    int start = _getOffsetOfMatch(contents, nodePattern, index);
+                             String code) {
+    CompilationUnit cu = _resolveContents(code);
+    int start = _getOffsetOfMatch(code, nodePattern, index);
     int end = start + nodePattern.length;
     return new NodeLocator.con2(start, end).searchWithin(cu);
   }
 
   int _getOffsetOfMatch(String contents, String pattern, int matchIndex) {
     if (matchIndex == 0) {
       return contents.indexOf(pattern);
     }
     JavaPatternMatcher matcher =
         new JavaPatternMatcher(new RegExp(pattern), contents);
     int count = 0;
     while (matcher.find()) {
       if (count == matchIndex) {
         return matcher.start();
       }
       ++count;
     }
     return -1;
   }
 
   /**
-   * Parse, resolve and verify the given source lines to produce a fully resolved AST.
+   * Parse, resolve and verify the given source lines to produce a fully
+   * resolved AST.
    *
-   * @param lines the lines to be merged into a single source string
-   * @return the result of resolving the AST structure representing the content of the source
-   * @throws Exception if source cannot be verified
+   * [code] the code to resolve.
+   *
+   * Returns the result of resolving the AST structure representing the content
+   * of the source.
+   *
+   * Throws if source cannot be verified.
    */
-  CompilationUnit _resolveContents(List<String> lines) {
-    Source source = addSource(EngineTestCase.createSource(lines));
+  CompilationUnit _resolveContents(String code) {
+    Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     return analysisContext.resolveCompilationUnit(source, library);
   }
 }
 
 
 class EnumMemberBuilderTest extends EngineTestCase {
   void test_visitEnumDeclaration_multiple() {
@@ skipping 2181 matching lines @@
     } else {
       JUnitTestCase.assertNotNullMsg("script ${scriptIndex}", scriptSource);
       String actualExternalScriptName = scriptSource.shortName;
       JUnitTestCase.assertEqualsMsg(
           "script ${scriptIndex}",
           _expectedExternalScriptName,
           actualExternalScriptName);
     }
   }
 }