Convert most of the EngineTestCase.createSource invocations into multi-line String literals.

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 742 matching lines @@
     JUnitTestCase.assertEquals(null, component.templateSource);
     JUnitTestCase.assertEquals(-1, component.templateUriOffset);
   }
 
   /**
    * https://code.google.com/p/dart/issues/detail?id=19023
    */
   void test_NgComponent_notAngular() {
     contextHelper.addSource("/my_template.html", "");
     contextHelper.addSource("/my_styles.css", "");
-    String mainContent = EngineTestCase.createSource(
-        [
-            "class Component {",
-            "  const Component(a, b);",
-            "}",
-            "",
-            "@Component('foo', 42)",
-            "class MyComponent {",
-            "}"]);
+    String mainContent = r'''
+class Component {
+  const Component(a, b);
+}
+
+@Component('foo', 42)
+class MyComponent {
+}''';
     resolveMainSource(mainContent);
     assertNoMainErrors();
   }
 
   void test_NgComponent_properties_fieldFromSuper() {
     contextHelper.addSource("/my_template.html", "");
     contextHelper.addSource("/my_styles.css", "");
     resolveMainSourceNoErrors(
         _createAngularSource(
             [
@@ skipping 299 matching lines @@
     assertMainErrors([AngularCode.MISSING_SELECTOR]);
   }
 
   void test_NgController_noAnnotationArguments() {
     String mainContent =
         _createAngularSource(["@NgController", "class MyController {", "}"]);
     resolveMainSource(mainContent);
   }
 
   void test_bad_notConstructorAnnotation() {
-    String mainContent = EngineTestCase.createSource(
-        ["const MY_ANNOTATION = null;", "@MY_ANNOTATION()", "class MyFilter {", "}"]);
+    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");
@@ skipping 177 matching lines @@
 
   void test_getElement_noClassDeclaration() {
     resolveMainSource("var foo = 'bar';");
     SimpleStringLiteral node =
         _findMainNode("bar'", (n) => n is SimpleStringLiteral);
     Element element = AngularCompilationUnitBuilder.getElement(node, 0);
     JUnitTestCase.assertNull(element);
   }
 
   void test_getElement_noClassElement() {
-    resolveMainSource(
-        EngineTestCase.createSource(
-            ["class A {", "  const A(p);", "}", "", "@A('bar')", "class B {}"]));
+    resolveMainSource(r'''
+class A {
+  const A(p);
+}
+
+@A('bar')
+class B {}''');
     SimpleStringLiteral node =
         _findMainNode("bar'", (n) => n is SimpleStringLiteral);
     // reset B element
     ClassDeclaration classDeclaration =
         node.getAncestor((node) => node is ClassDeclaration);
     classDeclaration.name.staticElement = null;
     // class is not resolved - no element
     Element element = AngularCompilationUnitBuilder.getElement(node, 0);
     JUnitTestCase.assertNull(element);
   }
 
   void test_getElement_noNode() {
     Element element = AngularCompilationUnitBuilder.getElement(null, 0);
     JUnitTestCase.assertNull(element);
   }
 
   void test_getElement_notFound() {
-    resolveMainSource(
-        EngineTestCase.createSource(
-            ["class MyComponent {", "  var str = 'some string';", "}"]));
+    resolveMainSource(r'''
+class MyComponent {
+  var str = 'some string';
+}''');
     // prepare node
     SimpleStringLiteral node =
         _findMainNode("some string'", (n) => n is SimpleStringLiteral);
     int offset = node.offset;
     // no Element
     Element element = AngularCompilationUnitBuilder.getElement(node, offset);
     JUnitTestCase.assertNull(element);
   }
 
   void test_parseSelector_hasAttribute() {
@@ skipping 159 matching lines @@
   static String _createAngularSource(List<String> lines) {
     String source = "import 'angular.dart';\n";
     source += EngineTestCase.createSource(lines);
     return source;
   }
 }
 
 
 class AngularHtmlUnitResolverTest extends AngularTest {
   void test_NgComponent_resolveTemplateFile() {
-    addMainSource(
-        EngineTestCase.createSource(
-            [
-                "",
-                "import 'angular.dart';",
-                "",
-                "@Component(",
-                "    templateUrl: 'my_template.html', cssUrl: 'my_styles.css',",
-                "    publishAs: 'ctrl',",
-                "    selector: 'myComponent')",
-                "class MyComponent {",
-                "  String field;",
-                "}"]));
+    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([]));
     addIndexSource2(
         "/my_template.html",
-        EngineTestCase.createSource(
-            ["    <div>", "      {{ctrl.field}}", "    </div>"]));
+        r'''
+    <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",
-        EngineTestCase.createSource(
-            [
-                "library my.component;",
-                "import 'angular.dart';",
-                "@Component(selector: 'myComponent')",
-                "class MyComponent {",
-                "}"]));
+        r'''
+library my.component;
+import 'angular.dart';
+@Component(selector: 'myComponent')
+class MyComponent {
+}''');
     contextHelper.addSource(
         "/my_module.dart",
-        EngineTestCase.createSource(
-            ["library my.module;", "import 'my_component.dart';"]));
-    addMainSource(
-        EngineTestCase.createSource(["library main;", "import 'my_module.dart';"]));
+        r'''
+library my.module;
+import 'my_component.dart';''');
+    addMainSource(r'''
+library main;
+import 'my_module.dart';''');
     _resolveIndexNoErrors(
         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);
@@ skipping 17 matching lines @@
       AngularSelectorElement tagElement =
           tagNode.element as AngularSelectorElement;
       JUnitTestCase.assertNotNull(tagElement);
       JUnitTestCase.assertEquals("myComponent2", tagElement.name);
     }
   }
 
   void test_NgComponent_use_resolveAttributes() {
     contextHelper.addSource(
         "/my_template.html",
-        EngineTestCase.createSource(
-            ["    <div>", "      {{ctrl.field}}", "    </div>"]));
-    addMainSource(
-        EngineTestCase.createSource(
-            [
-                "",
-                "import 'angular.dart';",
-                "",
-                "@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) {}",
-                "}"]));
+        r'''
+    <div>
+      {{ctrl.field}}
+    </div>''');
+    addMainSource(r'''
+
+import 'angular.dart';
+
+@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'/>"]));
     // "attrA" attribute expression was resolved
     JUnitTestCase.assertNotNull(findIdentifier("someModel"));
     // "myComponent" tag was resolved
     ht.XmlTagNode tagNode =
         ht.HtmlUnitUtils.getTagNode(indexUnit, findOffset2("myComponent"));
@@ skipping 18 matching lines @@
       ht.XmlAttributeNode node =
           ht.HtmlUnitUtils.getAttributeNode(indexUnit, findOffset2("attrB='"));
       AngularPropertyElement element = node.element as AngularPropertyElement;
       JUnitTestCase.assertNotNull(element);
       JUnitTestCase.assertEquals("attrB", element.name);
       JUnitTestCase.assertEquals("setB", element.field.name);
     }
   }
 
   void test_NgDirective_noAttribute() {
-    addMainSource(
-        EngineTestCase.createSource(
-            [
-                "",
-                "import 'angular.dart';",
-                "",
-                "@NgDirective(selector: '[my-directive]', map: const {'foo': '=>input'})",
-                "class MyDirective {",
-                "  set input(value) {}",
-                "}"]));
+    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>"]));
   }
 
   void test_NgDirective_noExpression() {
-    addMainSource(
-        EngineTestCase.createSource(
-            [
-                "",
-                "import 'angular.dart';",
-                "",
-                "@NgDirective(selector: '[my-directive]', map: const {'.': '=>input'})",
-                "class MyDirective {",
-                "  set input(value) {}",
-                "}"]));
+    addMainSource(r'''
+
+import 'angular.dart';
+
+@NgDirective(selector: '[my-directive]', map: const {'.': '=>input'})
+class MyDirective {
+  set input(value) {}
+}''');
     _resolveIndexNoErrors(
         AngularTest.createHtmlWithMyController(["<div my-directive>", "</div>"]));
   }
 
   void test_NgDirective_resolvedExpression() {
-    addMainSource(
-        EngineTestCase.createSource(
-            [
-                "",
-                "import 'angular.dart';",
-                "",
-                "@Decorator(selector: '[my-directive]')",
-                "class MyDirective {",
-                "  @NgOneWay('my-property')",
-                "  String condition;",
-                "}"]));
+    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>"]));
     resolveMainNoErrors();
     // "my-directive" attribute was resolved
     {
       AngularSelectorElement selector =
@@ skipping 13 matching lines @@
       JUnitTestCase.assertSame(
           AngularPropertyKind.ONE_WAY,
           propertyElement.propertyKind);
       JUnitTestCase.assertEquals("condition", propertyElement.field.name);
     }
     // "name" expression was resolved
     JUnitTestCase.assertNotNull(findIdentifier("name != null"));
   }
 
   void test_NgDirective_resolvedExpression_attrString() {
-    addMainSource(
-        EngineTestCase.createSource(
-            [
-                "",
-                "import 'angular.dart';",
-                "",
-                "@NgDirective(selector: '[my-directive])",
-                "class MyDirective {",
-                "  @NgAttr('my-property')",
-                "  String property;",
-                "}"]));
+    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>"]));
     resolveMain();
     // @NgAttr means "string attribute", which we don't parse
     JUnitTestCase.assertNull(findIdentifierMaybe("name != null"));
   }
 
   void test_NgDirective_resolvedExpression_dotAsName() {
-    addMainSource(
-        EngineTestCase.createSource(
-            [
-                "",
-                "import 'angular.dart';",
-                "",
-                "@Decorator(",
-                "    selector: '[my-directive]',",
-                "    map: const {'.' : '=>condition'})",
-                "class MyDirective {",
-                "  set condition(value) {}",
-                "}"]));
+    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>"]));
     // "name" attribute was resolved
     JUnitTestCase.assertNotNull(findIdentifier("name != null"));
   }
 
   void fail_analysisContext_changeDart_invalidateApplication() {
-    addMainSource(
-        EngineTestCase.createSource(
-            [
-                "",
-                "import 'angular.dart';",
-                "",
-                "@Component(",
-                "    templateUrl: 'my_template.html', cssUrl: 'my_styles.css',",
-                "    publishAs: 'ctrl',",
-                "    selector: 'myComponent')",
-                "class MyComponent {",
-                "}"]));
+    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([]));
     addIndexSource2(
         "/my_template.html",
-        EngineTestCase.createSource(
-            ["    <div>", "      {{ctrl.noMethod()}}", "    </div>"]));
+        r'''
+    <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
     {
       List<AnalysisError> errors = context.getErrors(indexSource).errors;
       _ut.expect(errors, _ut.isEmpty);
       JUnitTestCase.assertTrue(errors.length == 0);
     }
   }
 
   void test_analysisContext_changeEntryPoint_clearAngularErrors_inDart() {
-    addMainSource(
-        EngineTestCase.createSource(
-            [
-                "",
-                "import 'angular.dart';",
-                "",
-                "@Component(",
-                "    templateUrl: 'no-such-template.html', cssUrl: 'my_styles.css',",
-                "    publishAs: 'ctrl',",
-                "    selector: 'myComponent')",
-                "class MyComponent {",
-                "}"]));
+    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([]));
     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(
-        EngineTestCase.createSource(
-            [
-                "",
-                "import 'angular.dart';",
-                "",
-                "@Component(",
-                "    templateUrl: 'my_template.html', cssUrl: 'my_styles.css',",
-                "    publishAs: 'ctrl',",
-                "    selector: 'myComponent')",
-                "class MyComponent {",
-                "}"]));
+    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([]));
     addIndexSource2(
         "/my_template.html",
-        EngineTestCase.createSource(
-            ["    <div>", "      {{ctrl.noMethod()}}", "    </div>"]));
+        r'''
+    <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(
-        EngineTestCase.createSource(
-            [
-                "",
-                "import 'angular.dart';",
-                "",
-                "@Component(",
-                "    templateUrl: 'no-such-template.html', cssUrl: 'my_styles.css',",
-                "    publishAs: 'ctrl',",
-                "    selector: 'myComponent')",
-                "class MyComponent {",
-                "}"]));
+    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([]));
     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);
     }
@@ skipping 283 matching lines @@
    */
   void test_ngShow() {
     addMyController();
     _resolveIndexNoErrors(
         AngularTest.createHtmlWithMyController(
             ["<div ng-show='ctrl.field != null'/>"]));
     assertResolvedIdentifier("field");
   }
 
   void test_notResolved_noDartScript() {
-    resolveIndex2(
-        EngineTestCase.createSource(
-            [
-                "<html ng-app>",
-                "  <body>",
-                "    <div my-marker>",
-                "      {{ctrl.field}}",
-                "    </div>",
-                "  </body>",
-                "</html>"]));
+    resolveIndex2(r'''
+<html ng-app>
+  <body>
+    <div my-marker>
+      {{ctrl.field}}
+    </div>
+  </body>
+</html>''');
     assertNoErrors();
     // Angular is not initialized, so "ctrl" is not parsed
     Expression expression =
         ht.HtmlUnitUtils.getExpression(indexUnit, findOffset2("ctrl"));
     JUnitTestCase.assertNull(expression);
   }
 
   void test_notResolved_notAngular() {
-    resolveIndex2(
-        EngineTestCase.createSource(
-            [
-                "<html no-ng-app>",
-                "  <body>",
-                "    <div my-marker>",
-                "      {{ctrl.field}}",
-                "    </div>",
-                "  </body>",
-                "</html>"]));
+    resolveIndex2(r'''
+<html no-ng-app>
+  <body>
+    <div my-marker>
+      {{ctrl.field}}
+    </div>
+  </body>
+</html>''');
     assertNoErrors();
     // Angular is not initialized, so "ctrl" is not parsed
     Expression expression =
         ht.HtmlUnitUtils.getExpression(indexUnit, findOffset2("ctrl"));
     JUnitTestCase.assertNull(expression);
   }
 
   void test_notResolved_wrongControllerMarker() {
     addMyController();
-    addIndexSource(
-        EngineTestCase.createSource(
-            [
-                "<html ng-app>",
-                "  <body>",
-                "    <div not-my-marker>",
-                "      {{ctrl.field}}",
-                "    </div>",
-                "    <script type='application/dart' src='main.dart'></script>",
-                "  </body>",
-                "</html>"]));
+    addIndexSource(r'''
+<html ng-app>
+  <body>
+    <div not-my-marker>
+      {{ctrl.field}}
+    </div>
+    <script type='application/dart' src='main.dart'></script>
+  </body>
+</html>''');
     contextHelper.runTasks();
     resolveIndex();
     // no errors, because we decided to ignore them at the moment
     assertNoErrors();
     // "ctrl" is not resolved
     SimpleIdentifier identifier = findIdentifier("ctrl");
     JUnitTestCase.assertNull(identifier.bestElement);
   }
 
   void test_resolveExpression_evenWithout_ngBootstrap() {
-    resolveMainSource(
-        EngineTestCase.createSource(
-            [
-                "",
-                "import 'angular.dart';",
-                "",
-                "@Controller(",
-                "    selector: '[my-controller]',",
-                "    publishAs: 'ctrl')",
-                "class MyController {",
-                "  String field;",
-                "}"]));
-    _resolveIndexNoErrors(
-        EngineTestCase.createSource(
-            [
-                "<html ng-app>",
-                "  <body>",
-                "    <div my-controller>",
-                "      {{ctrl.field}}",
-                "    </div>",
-                "    <script type='application/dart' src='main.dart'></script>",
-                "  </body>",
-                "</html>"]));
+    resolveMainSource(r'''
+
+import 'angular.dart';
+
+@Controller(
+    selector: '[my-controller]',
+    publishAs: 'ctrl')
+class MyController {
+  String field;
+}''');
+    _resolveIndexNoErrors(r'''
+<html ng-app>
+  <body>
+    <div my-controller>
+      {{ctrl.field}}
+    </div>
+    <script type='application/dart' src='main.dart'></script>
+  </body>
+</html>''');
     assertResolvedIdentifier2("ctrl.", "MyController");
   }
 
   void test_resolveExpression_ignoreUnresolved() {
-    resolveMainSource(
-        EngineTestCase.createSource(
-            [
-                "",
-                "import 'angular.dart';",
-                "",
-                "@Controller(",
-                "    selector: '[my-controller]',",
-                "    publishAs: 'ctrl')",
-                "class MyController {",
-                "  Map map;",
-                "  Object obj;",
-                "}"]));
-    resolveIndex2(
-        EngineTestCase.createSource(
-            [
-                "<html ng-app>",
-                "  <body>",
-                "    <div my-controller>",
-                "      {{ctrl.map.property}}",
-                "      {{ctrl.obj.property}}",
-                "      {{invisibleScopeProperty}}",
-                "    </div>",
-                "    <script type='application/dart' src='main.dart'></script>",
-                "  </body>",
-                "</html>"]));
+    resolveMainSource(r'''
+
+import 'angular.dart';
+
+@Controller(
+    selector: '[my-controller]',
+    publishAs: 'ctrl')
+class MyController {
+  Map map;
+  Object obj;
+}''');
+    resolveIndex2(r'''
+<html ng-app>
+  <body>
+    <div my-controller>
+      {{ctrl.map.property}}
+      {{ctrl.obj.property}}
+      {{invisibleScopeProperty}}
+    </div>
+    <script type='application/dart' src='main.dart'></script>
+  </body>
+</html>''');
     assertNoErrors();
     // "ctrl.map" and "ctrl.obj" are resolved
     assertResolvedIdentifier2("map", "Map<dynamic, dynamic>");
     assertResolvedIdentifier2("obj", "Object");
     // ...but not "invisibleScopeProperty"
     {
       SimpleIdentifier identifier = findIdentifier("invisibleScopeProperty");
       JUnitTestCase.assertNull(identifier.bestElement);
     }
   }
 
   void test_resolveExpression_inAttribute() {
     addMyController();
     _resolveIndexNoErrors(
         AngularTest.createHtmlWithMyController(
             ["<button title='{{ctrl.field}}'></button>"]));
     assertResolvedIdentifier2("ctrl", "MyController");
   }
 
   void test_resolveExpression_ngApp_onBody() {
     addMyController();
-    _resolveIndexNoErrors(
-        EngineTestCase.createSource(
-            [
-                "<html>",
-                "  <body ng-app>",
-                "    <div my-controller>",
-                "      {{ctrl.field}}",
-                "    </div>",
-                "    <script type='application/dart' src='main.dart'></script>",
-                "  </body>",
-                "</html>"]));
+    _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}}"]));
     assertResolvedIdentifier2("ctrl", "MyController");
     assertResolvedIdentifier("uppercase");
   }
 
   void test_resolveExpression_withFilter_notSimpleIdentifier() {
     addMyController();
     resolveIndex2(
         AngularTest.createHtmlWithMyController(["{{ctrl.field | not.supported}}"]));
     assertErrors(indexSource, [AngularCode.INVALID_FORMATTER_NAME]);
   }
 
   void test_scopeProperties() {
-    addMainSource(
-        EngineTestCase.createSource(
-            [
-                "",
-                "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';",
-                "  }",
-                "}",
-                ""]));
+    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([]));
     addIndexSource2(
         "/my_template.html",
-        EngineTestCase.createSource(
-            ["    <div>", "      {{scopeProperty}}", "    </div>"]));
+        r'''
+    <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));
   }
 
   void test_scopeProperties_hideWithComponent() {
-    addMainSource(
-        EngineTestCase.createSource(
-            [
-                "",
-                "import 'angular.dart';",
-                "",
-                "@Component(",
-                "    templateUrl: 'my_template.html', cssUrl: 'my_styles.css',",
-                "    publishAs: 'ctrl',",
-                "    selector: 'myComponent')",
-                "class MyComponent {",
-                "}",
-                "",
-                "void setScopeProperties(Scope scope) {",
-                "  scope.context['ctrl'] = 1;",
-                "}",
-                ""]));
+    addMainSource(r'''
+
+import 'angular.dart';
+
+@Component(
+    templateUrl: 'my_template.html', cssUrl: 'my_styles.css',
+    publishAs: 'ctrl',
+    selector: 'myComponent')
+class MyComponent {
+}
+
+void setScopeProperties(Scope scope) {
+  scope.context['ctrl'] = 1;
+}
+''');
     contextHelper.addSource(
         "/entry-point.html",
         AngularTest.createHtmlWithAngular([]));
     addIndexSource2(
         "/my_template.html",
-        EngineTestCase.createSource(["    <div>", "      {{ctrl}}", "    </div>"]));
+        r'''
+    <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,
         AngularComponentElement,
         toolkitObjects[0]);
   }
 
   void test_view_resolveTemplateFile() {
-    addMainSource(
-        EngineTestCase.createSource(
-            [
-                "",
-                "import 'angular.dart';",
-                "",
-                "@Controller(",
-                "    selector: '[my-controller]',",
-                "    publishAs: 'ctrl')",
-                "class MyController {",
-                "  String field;",
-                "}",
-                "",
-                "class MyRouteInitializer {",
-                "  init(ViewFactory view) {",
-                "    view('my_template.html');",
-                "  }",
-                "}"]));
+    addMainSource(r'''
+
+import 'angular.dart';
+
+@Controller(
+    selector: '[my-controller]',
+    publishAs: 'ctrl')
+class MyController {
+  String field;
+}
+
+class MyRouteInitializer {
+  init(ViewFactory view) {
+    view('my_template.html');
+  }
+}''');
     contextHelper.addSource(
         "/entry-point.html",
         AngularTest.createHtmlWithAngular([]));
     addIndexSource2(
         "/my_template.html",
-        EngineTestCase.createSource(
-            ["    <div my-controller>", "      {{ctrl.field}}", "    </div>"]));
+        r'''
+    <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 75 matching lines @@
       Element element = ht.HtmlUnitUtils.getElementAtOffset(indexUnit, offset);
       EngineTestCase.assertInstanceOf(
           (obj) => obj is PropertyAccessorElement,
           PropertyAccessorElement,
           element);
       JUnitTestCase.assertEquals("field", element.name);
     }
   }
 
   void test_getEnclosingTagNode() {
-    resolveIndex2(
-        EngineTestCase.createSource(
-            [
-                "<html>",
-                "  <body ng-app>",
-                "    <badge name='abc'> 123 </badge>",
-                "  </body>",
-                "</html>"]));
+    resolveIndex2(r'''
+<html>
+  <body ng-app>
+    <badge name='abc'> 123 </badge>
+  </body>
+</html>''');
     // no unit
     JUnitTestCase.assertNull(ht.HtmlUnitUtils.getEnclosingTagNode(null, 0));
     // wrong offset
     JUnitTestCase.assertNull(
         ht.HtmlUnitUtils.getEnclosingTagNode(indexUnit, -1));
     // valid offset
     ht.XmlTagNode expected = _getEnclosingTagNode("<badge");
     JUnitTestCase.assertNotNull(expected);
     JUnitTestCase.assertEquals("badge", expected.tag);
     JUnitTestCase.assertSame(expected, _getEnclosingTagNode("badge"));
@@ skipping 15 matching lines @@
         ht.HtmlUnitUtils.getExpression(indexUnit, offset + 1));
     JUnitTestCase.assertNotNull(
         ht.HtmlUnitUtils.getExpression(indexUnit, offset + 2));
     JUnitTestCase.assertNotNull(
         ht.HtmlUnitUtils.getExpression(indexUnit, offset + "ctrl.field".length));
     // try without unit
     JUnitTestCase.assertNull(ht.HtmlUnitUtils.getExpression(null, offset));
   }
 
   void test_getTagNode() {
-    resolveIndex2(
-        EngineTestCase.createSource(
-            [
-                "<html>",
-                "  <body ng-app>",
-                "    <badge name='abc'> 123 </badge> done",
-                "  </body>",
-                "</html>"]));
+    resolveIndex2(r'''
+<html>
+  <body ng-app>
+    <badge name='abc'> 123 </badge> done
+  </body>
+</html>''');
     // no unit
     JUnitTestCase.assertNull(ht.HtmlUnitUtils.getTagNode(null, 0));
     // wrong offset
     JUnitTestCase.assertNull(ht.HtmlUnitUtils.getTagNode(indexUnit, -1));
     // on tag name
     ht.XmlTagNode expected = _getTagNode("badge name=");
     JUnitTestCase.assertNotNull(expected);
     JUnitTestCase.assertEquals("badge", expected.tag);
     JUnitTestCase.assertSame(expected, _getTagNode("badge"));
     JUnitTestCase.assertSame(expected, _getTagNode(" name="));
@@ skipping 10 matching lines @@
     return ht.HtmlUnitUtils.getEnclosingTagNode(
         indexUnit,
         indexContent.indexOf(search));
   }
 
   ht.XmlTagNode _getTagNode(String search) {
     return ht.HtmlUnitUtils.getTagNode(indexUnit, indexContent.indexOf(search));
   }
 
   void _resolveSimpleCtrlFieldHtml() {
-    resolveIndex2(
-        EngineTestCase.createSource(
-            [
-                "<html>",
-                "  <body ng-app>",
-                "    <div my-controller>",
-                "      {{ctrl.field}}",
-                "    </div>",
-                "    <script type='application/dart' src='main.dart'></script>",
-                "  </body>",
-                "</html>"]));
+    resolveIndex2(r'''
+<html>
+  <body ng-app>
+    <div my-controller>
+      {{ctrl.field}}
+    </div>
+    <script type='application/dart' src='main.dart'></script>
+  </body>
+</html>''');
   }
 }
 
 
 abstract class AngularTest extends EngineTestCase {
   AnalysisContextHelper contextHelper = new AnalysisContextHelper();
 
   AnalysisContext context;
 
   String mainContent;
@@ skipping 22 matching lines @@
     indexSource = contextHelper.addSource(name, indexContent);
   }
   /**
    * Fills [mainContent] and [mainSource].
    */
   void addMainSource(String content) {
     mainContent = content;
     mainSource = contextHelper.addSource("/main.dart", content);
   }
   void addMyController() {
-    resolveMainSource(
-        EngineTestCase.createSource(
-            [
-                "",
-                "import 'angular.dart';",
-                "",
-                "class Item {",
-                "  String name;",
-                "  bool done;",
-                "}",
-                "",
-                "@Controller(",
-                "    selector: '[my-controller]',",
-                "    publishAs: 'ctrl')",
-                "class MyController {",
-                "  String field;",
-                "  List<String> names;",
-                "  List<Item> items;",
-                "  var untypedItems;",
-                "  doSomething(event) {}",
-                "}"]));
+    resolveMainSource(r'''
+
+import 'angular.dart';
+
+class Item {
+  String name;
+  bool done;
+}
+
+@Controller(
+    selector: '[my-controller]',
+    publishAs: 'ctrl')
+class MyController {
+  String field;
+  List<String> names;
+  List<Item> items;
+  var untypedItems;
+  doSomething(event) {}
+}''');
   }
   /**
    * Assert that the number of errors reported against the given source matches the number of errors
    * that are given and that they have the expected error codes. The order in which the errors were
    * gathered is ignored.
    *
    * @param source the source against which the errors should have been reported
    * @param expectedErrorCodes the error codes of the errors that should have been reported
    * @throws AnalysisException if the reported errors could not be computed
    * @throws AssertionFailedError if a different number of errors have been reported than were
@@ skipping 200 matching lines @@
     for (Source source in sources) {
       ht.HtmlUnit htmlUnit = context.getResolvedHtmlUnit(source);
       htmlUnit.accept(new ExpressionVisitor_AngularTest_verify(verifier));
     }
     verifier.assertResolved();
   }
 
   void _configureForAngular(AnalysisContextHelper contextHelper) {
     contextHelper.addSource(
         "/angular.dart",
-        EngineTestCase.createSource(
-            [
-                "library angular;",
-                "",
-                "class Scope {",
-                "  Map context;",
-                "}",
-                "",
-                "class Formatter {",
-                "  final String name;",
-                "  const Formatter({this.name});",
-                "}",
-                "",
-                "class Directive {",
-                "  const Directive({",
-                "    selector,",
-                "    children,",
-                "    visibility,",
-                "    module,",
-                "    map,",
-                "    exportedExpressions,",
-                "    exportedExpressionAttrs",
-                "  });",
-                "}",
-                "",
-                "class Decorator {",
-                "  const Decorator({",
-                "    children/*: Directive.COMPILE_CHILDREN*/,",
-                "    map,",
-                "    selector,",
-                "    module,",
-                "    visibility,",
-                "    exportedExpressions,",
-                "    exportedExpressionAttrs",
-                "  });",
-                "}",
-                "",
-                "class Controller {",
-                "  const Controller({",
-                "    children,",
-                "    publishAs,",
-                "    map,",
-                "    selector,",
-                "    visibility,",
-                "    publishTypes,",
-                "    exportedExpressions,",
-                "    exportedExpressionAttrs",
-                "  });",
-                "}",
-                "",
-                "class NgAttr {",
-                "  const NgAttr(String name);",
-                "}",
-                "class NgCallback {",
-                "  const NgCallback(String name);",
-                "}",
-                "class NgOneWay {",
-                "  const NgOneWay(String name);",
-                "}",
-                "class NgOneWayOneTime {",
-                "  const NgOneWayOneTime(String name);",
-                "}",
-                "class NgTwoWay {",
-                "  const NgTwoWay(String name);",
-                "}",
-                "",
-                "class Component extends Directive {",
-                "  const Component({",
-                "    this.template,",
-                "    this.templateUrl,",
-                "    this.cssUrl,",
-                "    this.applyAuthorStyles,",
-                "    this.resetStyleInheritance,",
-                "    publishAs,",
-                "    module,",
-                "    map,",
-                "    selector,",
-                "    visibility,",
-                "    exportExpressions,",
-                "    exportExpressionAttrs",
-                "  }) : super(selector: selector,",
-                "             children: null/*NgAnnotation.COMPILE_CHILDREN*/,",
-                "             visibility: visibility,",
-                "             map: map,",
-                "             module: module,",
-                "             exportExpressions: exportExpressions,",
-                "             exportExpressionAttrs: exportExpressionAttrs);",
-                "}",
-                "",
-                "@Decorator(selector: '[ng-click]', map: const {'ng-click': '&onEvent'})",
-                "@Decorator(selector: '[ng-mouseout]', map: const {'ng-mouseout': '&onEvent'})",
-                "class NgEventDirective {",
-                "  set onEvent(value) {}",
-                "}",
-                "",
-                "@Decorator(selector: '[ng-if]', map: const {'ng-if': '=>condition'})",
-                "class NgIfDirective {",
-                "  set condition(value) {}",
-                "}",
-                "",
-                "@Decorator(selector: '[ng-show]', map: const {'ng-show': '=>show'})",
-                "class NgShowDirective {",
-                "  set show(value) {}",
-                "}",
-                "",
-                "@Formatter(name: 'filter')",
-                "class FilterFormatter {}",
-                "",
-                "@Formatter(name: 'orderBy')",
-                "class OrderByFilter {}",
-                "",
-                "@Formatter(name: 'uppercase')",
-                "class UppercaseFilter {}",
-                "",
-                "class ViewFactory {",
-                "  call(String templateUrl) => null;",
-                "}",
-                "",
-                "class Module {",
-                "  install(Module m) {}",
-                "  type(Type t) {}",
-                "  value(Type t, value) {}",
-                "}",
-                "",
-                "class Injector {}",
-                "",
-                "Injector ngBootstrap({",
-                "        Module module: null,",
-                "        List<Module> modules: null,",
-                "        /*dom.Element*/ element: null,",
-                "        String selector: '[ng-app]',",
-                "        /*Injector*/ injectorFactory/*(List<Module> modules): _defaultInjectorFactory*/}) {}",
-                ""]));
+        r'''
+library angular;
+
+class Scope {
+  Map context;
+}
+
+class Formatter {
+  final String name;
+  const Formatter({this.name});
+}
+
+class Directive {
+  const Directive({
+    selector,
+    children,
+    visibility,
+    module,
+    map,
+    exportedExpressions,
+    exportedExpressionAttrs
+  });
+}
+
+class Decorator {
+  const Decorator({
+    children/*: Directive.COMPILE_CHILDREN*/,
+    map,
+    selector,
+    module,
+    visibility,
+    exportedExpressions,
+    exportedExpressionAttrs
+  });
+}
+
+class Controller {
+  const Controller({
+    children,
+    publishAs,
+    map,
+    selector,
+    visibility,
+    publishTypes,
+    exportedExpressions,
+    exportedExpressionAttrs
+  });
+}
+
+class NgAttr {
+  const NgAttr(String name);
+}
+class NgCallback {
+  const NgCallback(String name);
+}
+class NgOneWay {
+  const NgOneWay(String name);
+}
+class NgOneWayOneTime {
+  const NgOneWayOneTime(String name);
+}
+class NgTwoWay {
+  const NgTwoWay(String name);
+}
+
+class Component extends Directive {
+  const Component({
+    this.template,
+    this.templateUrl,
+    this.cssUrl,
+    this.applyAuthorStyles,
+    this.resetStyleInheritance,
+    publishAs,
+    module,
+    map,
+    selector,
+    visibility,
+    exportExpressions,
+    exportExpressionAttrs
+  }) : super(selector: selector,
+             children: null/*NgAnnotation.COMPILE_CHILDREN*/,
+             visibility: visibility,
+             map: map,
+             module: module,
+             exportExpressions: exportExpressions,
+             exportExpressionAttrs: exportExpressionAttrs);
+}
+
+@Decorator(selector: '[ng-click]', map: const {'ng-click': '&onEvent'})
+@Decorator(selector: '[ng-mouseout]', map: const {'ng-mouseout': '&onEvent'})
+class NgEventDirective {
+  set onEvent(value) {}
+}
+
+@Decorator(selector: '[ng-if]', map: const {'ng-if': '=>condition'})
+class NgIfDirective {
+  set condition(value) {}
+}
+
+@Decorator(selector: '[ng-show]', map: const {'ng-show': '=>show'})
+class NgShowDirective {
+  set show(value) {}
+}
+
+@Formatter(name: 'filter')
+class FilterFormatter {}
+
+@Formatter(name: 'orderBy')
+class OrderByFilter {}
+
+@Formatter(name: 'uppercase')
+class UppercaseFilter {}
+
+class ViewFactory {
+  call(String templateUrl) => null;
+}
+
+class Module {
+  install(Module m) {}
+  type(Type t) {}
+  value(Type t, value) {}
+}
+
+class Injector {}
+
+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.
    */
   static String createHtmlWithAngular(List<String> lines) {
-    String source = EngineTestCase.createSource(["<html ng-app>", "  <body>"]);
+    String source = r'''
+<html ng-app>
+  <body>''';
     source += EngineTestCase.createSource(lines);
-    source += EngineTestCase.createSource(
-        [
-            "    <script type='application/dart' src='main.dart'></script>",
-            "  </body>",
-            "</html>"]);
+    source += r'''
+    <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 = EngineTestCase.createSource(
-        ["<html ng-app>", "  <body>", "    <div my-controller>"]);
+    String source = r'''
+<html ng-app>
+  <body>
+    <div my-controller>''';
     source += EngineTestCase.createSource(lines);
-    source += EngineTestCase.createSource(
-        [
-            "    </div>",
-            "    <script type='application/dart' src='main.dart'></script>",
-            "  </body>",
-            "</html>"]);
+    source += r'''
+    </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].
    *
    * TODO(scheglov) maybe move this method to Element
    *
    * @param root the root [Element] to start searching from
    * @param kind the kind of the [Element] to find, if `null` then any kind
@@ skipping 517 matching lines @@
     _node = variableDeclaration;
     return element;
   }
 }
 
 
 class ConstantValueComputerTest extends ResolverTestCase {
   void test_computeValues_cycle() {
     TestLogger logger = new TestLogger();
     AnalysisEngine.instance.logger = logger;
-    Source librarySource = addSource(
-        EngineTestCase.createSource(
-            ["const int a = c;", "const int b = a;", "const int c = b;"]));
+    Source librarySource = addSource(r'''
+const int a = c;
+const int b = a;
+const int c = b;''');
     LibraryElement libraryElement = resolve(librarySource);
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit(librarySource, libraryElement);
     analysisContext.computeErrors(librarySource);
     JUnitTestCase.assertNotNull(unit);
     ConstantValueComputer computer = _makeConstantValueComputer();
     computer.add(unit);
     computer.computeValues();
     NodeList<CompilationUnitMember> members = unit.declarations;
     EngineTestCase.assertSizeOfList(3, members);
     _validate(false, (members[0] as TopLevelVariableDeclaration).variables);
     _validate(false, (members[1] as TopLevelVariableDeclaration).variables);
     _validate(false, (members[2] as TopLevelVariableDeclaration).variables);
   }
 
   void test_computeValues_dependentVariables() {
-    Source librarySource = addSource(
-        EngineTestCase.createSource(["const int b = a;", "const int a = 0;"]));
+    Source librarySource = addSource(r'''
+const int b = a;
+const int a = 0;''');
     LibraryElement libraryElement = resolve(librarySource);
     CompilationUnit unit =
         analysisContext.resolveCompilationUnit(librarySource, libraryElement);
     JUnitTestCase.assertNotNull(unit);
     ConstantValueComputer computer = _makeConstantValueComputer();
     computer.add(unit);
     computer.computeValues();
     NodeList<CompilationUnitMember> members = unit.declarations;
     EngineTestCase.assertSizeOfList(2, members);
     _validate(true, (members[0] as TopLevelVariableDeclaration).variables);
     _validate(true, (members[1] as TopLevelVariableDeclaration).variables);
   }
 
   void test_computeValues_empty() {
     ConstantValueComputer computer = _makeConstantValueComputer();
     computer.computeValues();
   }
 
   void test_computeValues_multipleSources() {
     Source librarySource = addNamedSource(
         "/lib.dart",
-        EngineTestCase.createSource(
-            ["library lib;", "part 'part.dart';", "const int c = b;", "const int a = 0;"]));
+        r'''
+library lib;
+part 'part.dart';
+const int c = b;
+const int a = 0;''');
     Source partSource = addNamedSource(
         "/part.dart",
-        EngineTestCase.createSource(
-            ["part of lib;", "const int b = a;", "const int d = c;"]));
+        r'''
+part of lib;
+const int b = a;
+const int d = c;''');
     LibraryElement libraryElement = resolve(librarySource);
     CompilationUnit libraryUnit =
         analysisContext.resolveCompilationUnit(librarySource, libraryElement);
     JUnitTestCase.assertNotNull(libraryUnit);
     CompilationUnit partUnit =
         analysisContext.resolveCompilationUnit(partSource, libraryElement);
     JUnitTestCase.assertNotNull(partUnit);
     ConstantValueComputer computer = _makeConstantValueComputer();
     computer.add(libraryUnit);
     computer.add(partUnit);
@@ skipping 21 matching lines @@
     ConstantValueComputer computer = _makeConstantValueComputer();
     computer.add(unit);
     computer.computeValues();
     NodeList<CompilationUnitMember> members = unit.declarations;
     EngineTestCase.assertSizeOfList(1, members);
     _validate(true, (members[0] as TopLevelVariableDeclaration).variables);
   }
 
   void test_dependencyOnConstructor() {
     // x depends on "const A()"
-    _assertProperDependencies(
-        EngineTestCase.createSource(
-            ["class A {", "  const A();", "}", "const x = const A();"]),
+    _assertProperDependencies(r'''
+class A {
+  const A();
+}
+const x = const A();''',
         []);
   }
 
   void test_dependencyOnConstructorArgument() {
     // "const A(x)" depends on x
-    _assertProperDependencies(
-        EngineTestCase.createSource(
-            [
-                "class A {",
-                "  const A(this.next);",
-                "  final A next;",
-                "}",
-                "const A x = const A(null);",
-                "const A y = const A(x);"]),
+    _assertProperDependencies(r'''
+class A {
+  const A(this.next);
+  final A next;
+}
+const A x = const A(null);
+const A y = const A(x);''',
         []);
   }
 
   void test_dependencyOnConstructorArgument_unresolvedConstructor() {
     // "const A.a(x)" depends on x even if the constructor A.a can't be found.
-    _assertProperDependencies(
-        EngineTestCase.createSource(
-            ["class A {", "}", "const int x = 1;", "const A y = const A.a(x);"]),
+    _assertProperDependencies(r'''
+class A {
+}
+const int x = 1;
+const A y = const A.a(x);''',
         [CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR]);
   }
 
   void test_dependencyOnConstructorInitializer() {
     // "const A()" depends on x
-    _assertProperDependencies(
-        EngineTestCase.createSource(
-            [
-                "const int x = 1;",
-                "class A {",
-                "  const A() : v = x;",
-                "  final int v;",
-                "}"]),
+    _assertProperDependencies(r'''
+const int x = 1;
+class A {
+  const A() : v = x;
+  final int v;
+}''',
         []);
   }
 
   void test_dependencyOnExplicitSuperConstructor() {
     // b depends on B() depends on A()
-    _assertProperDependencies(
-        EngineTestCase.createSource(
-            [
-                "class A {",
-                "  const A(this.x);",
-                "  final int x;",
-                "}",
-                "class B extends A {",
-                "  const B() : super(5);",
-                "}",
-                "const B b = const B();"]),
+    _assertProperDependencies(r'''
+class A {
+  const A(this.x);
+  final int x;
+}
+class B extends A {
+  const B() : super(5);
+}
+const B b = const B();''',
         []);
   }
 
   void test_dependencyOnExplicitSuperConstructorParameters() {
     // b depends on B() depends on i
-    _assertProperDependencies(
-        EngineTestCase.createSource(
-            [
-                "class A {",
-                "  const A(this.x);",
-                "  final int x;",
-                "}",
-                "class B extends A {",
-                "  const B() : super(i);",
-                "}",
-                "const B b = const B();",
-                "const int i = 5;"]),
+    _assertProperDependencies(r'''
+class A {
+  const A(this.x);
+  final int x;
+}
+class B extends A {
+  const B() : super(i);
+}
+const B b = const B();
+const int i = 5;''',
         []);
   }
 
   void test_dependencyOnFactoryRedirect() {
     // a depends on A.foo() depends on A.bar()
-    _assertProperDependencies(
-        EngineTestCase.createSource(
-            [
-                "const A a = const A.foo();",
-                "class A {",
-                "  factory const A.foo() = A.bar;",
-                "  const A.bar();",
-                "}"]),
+    _assertProperDependencies(r'''
+const A a = const A.foo();
+class A {
+  factory const A.foo() = A.bar;
+  const A.bar();
+}''',
         []);
   }
 
   void test_dependencyOnFactoryRedirectWithTypeParams() {
-    _assertProperDependencies(
-        EngineTestCase.createSource(
-            [
-                "class A {",
-                "  const factory A(var a) = B<int>;",
-                "}",
-                "",
-                "class B<T> implements A {",
-                "  final T x;",
-                "  const B(this.x);",
-                "}",
-                "",
-                "const A a = const A(10);"]),
+    _assertProperDependencies(r'''
+class A {
+  const factory A(var a) = B<int>;
+}
+
+class B<T> implements A {
+  final T x;
+  const B(this.x);
+}
+
+const A a = const A(10);''',
         []);
   }
 
   void test_dependencyOnImplicitSuperConstructor() {
     // b depends on B() depends on A()
-    _assertProperDependencies(
-        EngineTestCase.createSource(
-            [
-                "class A {",
-                "  const A() : x = 5;",
-                "  final int x;",
-                "}",
-                "class B extends A {",
-                "  const B();",
-                "}",
-                "const B b = const B();"]),
+    _assertProperDependencies(r'''
+class A {
+  const A() : x = 5;
+  final int x;
+}
+class B extends A {
+  const B();
+}
+const B b = const B();''',
         []);
   }
 
   void test_dependencyOnNonFactoryRedirect() {
     // a depends on A.foo() depends on A.bar()
-    _assertProperDependencies(
-        EngineTestCase.createSource(
-            [
-                "const A a = const A.foo();",
-                "class A {",
-                "  const A.foo() : this.bar();",
-                "  const A.bar();",
-                "}"]),
+    _assertProperDependencies(r'''
+const A a = const A.foo();
+class A {
+  const A.foo() : this.bar();
+  const A.bar();
+}''',
         []);
   }
 
   void test_dependencyOnNonFactoryRedirect_arg() {
     // a depends on A.foo() depends on b
-    _assertProperDependencies(
-        EngineTestCase.createSource(
-            [
-                "const A a = const A.foo();",
-                "const int b = 1;",
-                "class A {",
-                "  const A.foo() : this.bar(b);",
-                "  const A.bar(x) : y = x;",
-                "  final int y;"
-                "}"]),
+    _assertProperDependencies(r'''
+const A a = const A.foo();
+const int b = 1;
+class A {
+  const A.foo() : this.bar(b);
+  const A.bar(x) : y = x;
+  final int y;
+}''',
         []);
   }
 
   void test_dependencyOnNonFactoryRedirect_defaultValue() {
     // a depends on A.foo() depends on A.bar() depends on b
-    _assertProperDependencies(
-        EngineTestCase.createSource(
-            [
-                "const A a = const A.foo();",
-                "const int b = 1;",
-                "class A {",
-                "  const A.foo() : this.bar();",
-                "  const A.bar([x = b]) : y = x;",
-                "  final int y;",
-                "}"]),
+    _assertProperDependencies(r'''
+const A a = const A.foo();
+const int b = 1;
+class A {
+  const A.foo() : this.bar();
+  const A.bar([x = b]) : y = x;
+  final int y;
+}''',
         []);
   }
 
   void test_dependencyOnNonFactoryRedirect_toMissing() {
     // a depends on A.foo() which depends on nothing, since A.bar() is
     // missing.
-    _assertProperDependencies(
-        EngineTestCase.createSource(
-            [
-                "const A a = const A.foo();",
-                "class A {",
-                "  const A.foo() : this.bar();",
-                "}"]),
+    _assertProperDependencies(r'''
+const A a = const A.foo();
+class A {
+  const A.foo() : this.bar();
+}''',
         [CompileTimeErrorCode.REDIRECT_GENERATIVE_TO_MISSING_CONSTRUCTOR]);
   }
 
   void test_dependencyOnNonFactoryRedirect_toNonConst() {
     // a depends on A.foo() which depends on nothing, since A.bar() is
     // non-const.
-    _assertProperDependencies(
-        EngineTestCase.createSource(
-            [
-                "const A a = const A.foo();",
-                "class A {",
-                "  const A.foo() : this.bar();",
-                "  A.bar();",
-                "}"]),
+    _assertProperDependencies(r'''
+const A a = const A.foo();
+class A {
+  const A.foo() : this.bar();
+  A.bar();
+}''',
         []);
   }
 
   void test_dependencyOnNonFactoryRedirect_unnamed() {
     // a depends on A.foo() depends on A()
-    _assertProperDependencies(
-        EngineTestCase.createSource(
-            [
-                "const A a = const A.foo();",
-                "class A {",
-                "  const A.foo() : this();",
-                "  const A();",
-                "}"]),
+    _assertProperDependencies(r'''
+const A a = const A.foo();
+class A {
+  const A.foo() : this();
+  const A();
+}''',
         []);
   }
 
   void test_dependencyOnOptionalParameterDefault() {
     // a depends on A() depends on B()
-    _assertProperDependencies(
-        EngineTestCase.createSource(
-            [
-                "class A {",
-                "  const A([x = const B()]) : b = x;",
-                "  final B b;",
-                "}",
-                "class B {",
-                "  const B();",
-                "}",
-                "const A a = const A();"]),
+    _assertProperDependencies(r'''
+class A {
+  const A([x = const B()]) : b = x;
+  final B b;
+}
+class B {
+  const B();
+}
+const A a = const A();''',
         []);
   }
 
   void test_dependencyOnVariable() {
     // x depends on y
-    _assertProperDependencies(
-        EngineTestCase.createSource(["const x = y + 1;", "const y = 2;"]),
-        []);
-  }
-
+    _assertProperDependencies(r'''
+const x = y + 1;
+const y = 2;''',
+        []);
+  }
+
   void test_fromEnvironment_bool_default_false() {
     JUnitTestCase.assertEquals(
         false,
         _assertValidBool(_check_fromEnvironment_bool(null, "false")));
   }
 
   void test_fromEnvironment_bool_default_overridden() {
     JUnitTestCase.assertEquals(
         false,
         _assertValidBool(_check_fromEnvironment_bool("false", "true")));
@@ skipping 99 matching lines @@
 
   void test_fromEnvironment_string_undeclared() {
     _assertValidUnknown(_check_fromEnvironment_string(null, null));
   }
 
   void test_fromEnvironment_string_undeclared_nullDefault() {
     _assertValidNull(_check_fromEnvironment_string(null, "null"));
   }
 
   void test_instanceCreationExpression_computedField() {
-    CompilationUnit compilationUnit = resolveSource(
-        EngineTestCase.createSource(
-            [
-                "const foo = const A(4, 5);",
-                "class A {",
-                "  const A(int i, int j) : k = 2 * i + j;",
-                "  final int k;",
-                "}"]));
+    CompilationUnit compilationUnit = resolveSource(r'''
+const foo = const A(4, 5);
+class A {
+  const A(int i, int j) : k = 2 * i + j;
+  final int k;
+}''');
     EvaluationResultImpl result =
         _evaluateInstanceCreationExpression(compilationUnit, "foo");
     Map<String, DartObjectImpl> fields = _assertType(result, "A");
     EngineTestCase.assertSizeOfMap(1, fields);
     _assertIntField(fields, "k", 13);
   }
 
   void
       test_instanceCreationExpression_computedField_namedOptionalWithDefault() {
     _checkInstanceCreationOptionalParams(false, true, true);
   }
 
   void
       test_instanceCreationExpression_computedField_namedOptionalWithoutDefault() {
     _checkInstanceCreationOptionalParams(false, true, false);
   }
 
   void
       test_instanceCreationExpression_computedField_unnamedOptionalWithDefault() {
     _checkInstanceCreationOptionalParams(false, false, true);
   }
 
   void
       test_instanceCreationExpression_computedField_unnamedOptionalWithoutDefault() {
     _checkInstanceCreationOptionalParams(false, false, false);
   }
 
   void test_instanceCreationExpression_computedField_usesConstConstructor() {
-    CompilationUnit compilationUnit = resolveSource(
-        EngineTestCase.createSource(
-            [
-                "const foo = const A(3);",
-                "class A {",
-                "  const A(int i) : b = const B(4);",
-                "  final int b;",
-                "}",
-                "class B {",
-                "  const B(this.k);",
-                "  final int k;",
-                "}"]));
+    CompilationUnit compilationUnit = resolveSource(r'''
+const foo = const A(3);
+class A {
+  const A(int i) : b = const B(4);
+  final int b;
+}
+class B {
+  const B(this.k);
+  final int k;
+}''');
     EvaluationResultImpl result =
         _evaluateInstanceCreationExpression(compilationUnit, "foo");
     Map<String, DartObjectImpl> fieldsOfA = _assertType(result, "A");
     EngineTestCase.assertSizeOfMap(1, fieldsOfA);
     Map<String, DartObjectImpl> fieldsOfB =
         _assertFieldType(fieldsOfA, "b", "B");
     EngineTestCase.assertSizeOfMap(1, fieldsOfB);
     _assertIntField(fieldsOfB, "k", 4);
   }
 
   void test_instanceCreationExpression_computedField_usesStaticConst() {
-    CompilationUnit compilationUnit = resolveSource(
-        EngineTestCase.createSource(
-            [
-                "const foo = const A(3);",
-                "class A {",
-                "  const A(int i) : k = i + B.bar;",
-                "  final int k;",
-                "}",
-                "class B {",
-                "  static const bar = 4;",
-                "}"]));
+    CompilationUnit compilationUnit = resolveSource(r'''
+const foo = const A(3);
+class A {
+  const A(int i) : k = i + B.bar;
+  final int k;
+}
+class B {
+  static const bar = 4;
+}''');
     EvaluationResultImpl result =
         _evaluateInstanceCreationExpression(compilationUnit, "foo");
     Map<String, DartObjectImpl> fields = _assertType(result, "A");
     EngineTestCase.assertSizeOfMap(1, fields);
     _assertIntField(fields, "k", 7);
   }
 
   void test_instanceCreationExpression_computedField_usesToplevelConst() {
-    CompilationUnit compilationUnit = resolveSource(
-        EngineTestCase.createSource(
-            [
-                "const foo = const A(3);",
-                "const bar = 4;",
-                "class A {",
-                "  const A(int i) : k = i + bar;",
-                "  final int k;",
-                "}"]));
+    CompilationUnit compilationUnit = resolveSource(r'''
+const foo = const A(3);
+const bar = 4;
+class A {
+  const A(int i) : k = i + bar;
+  final int k;
+}''');
     EvaluationResultImpl result =
         _evaluateInstanceCreationExpression(compilationUnit, "foo");
     Map<String, DartObjectImpl> fields = _assertType(result, "A");
     EngineTestCase.assertSizeOfMap(1, fields);
     _assertIntField(fields, "k", 7);
   }
 
   void test_instanceCreationExpression_explicitSuper() {
-    CompilationUnit compilationUnit = resolveSource(
-        EngineTestCase.createSource(
-            [
-                "const foo = const B(4, 5);",
-                "class A {",
-                "  const A(this.x);",
-                "  final int x;",
-                "}",
-                "class B extends A {",
-                "  const B(int x, this.y) : super(x * 2);",
-                "  final int y;",
-                "}"]));
+    CompilationUnit compilationUnit = resolveSource(r'''
+const foo = const B(4, 5);
+class A {
+  const A(this.x);
+  final int x;
+}
+class B extends A {
+  const B(int x, this.y) : super(x * 2);
+  final int y;
+}''');
     EvaluationResultImpl result =
         _evaluateInstanceCreationExpression(compilationUnit, "foo");
     Map<String, DartObjectImpl> fields = _assertType(result, "B");
     EngineTestCase.assertSizeOfMap(2, fields);
     _assertIntField(fields, "y", 5);
     Map<String, DartObjectImpl> superclassFields =
         _assertFieldType(fields, GenericState.SUPERCLASS_FIELD, "A");
     EngineTestCase.assertSizeOfMap(1, superclassFields);
     _assertIntField(superclassFields, "x", 8);
   }
 
   void test_instanceCreationExpression_fieldFormalParameter() {
-    CompilationUnit compilationUnit = resolveSource(
-        EngineTestCase.createSource(
-            [
-                "const foo = const A(42);",
-                "class A {",
-                "  int x;",
-                "  const A(this.x)",
-                "}"]));
+    CompilationUnit compilationUnit = resolveSource(r'''
+const foo = const A(42);
+class A {
+  int x;
+  const A(this.x)
+}''');
     EvaluationResultImpl result =
         _evaluateInstanceCreationExpression(compilationUnit, "foo");
     Map<String, DartObjectImpl> fields = _assertType(result, "A");
     EngineTestCase.assertSizeOfMap(1, fields);
     _assertIntField(fields, "x", 42);
   }
 
   void
       test_instanceCreationExpression_fieldFormalParameter_namedOptionalWithDefault() {
     _checkInstanceCreationOptionalParams(true, true, true);
   }
 
   void
       test_instanceCreationExpression_fieldFormalParameter_namedOptionalWithoutDefault() {
     _checkInstanceCreationOptionalParams(true, true, false);
   }
 
   void
       test_instanceCreationExpression_fieldFormalParameter_unnamedOptionalWithDefault() {
     _checkInstanceCreationOptionalParams(true, false, true);
   }
 
   void
       test_instanceCreationExpression_fieldFormalParameter_unnamedOptionalWithoutDefault() {
     _checkInstanceCreationOptionalParams(true, false, false);
   }
 
   void test_instanceCreationExpression_implicitSuper() {
-    CompilationUnit compilationUnit = resolveSource(
-        EngineTestCase.createSource(
-            [
-                "const foo = const B(4);",
-                "class A {",
-                "  const A() : x(3);",
-                "  final int x;",
-                "}",
-                "class B extends A {",
-                "  const B(this.y);",
-                "  final int y;",
-                "}"]));
+    CompilationUnit compilationUnit = resolveSource(r'''
+const foo = const B(4);
+class A {
+  const A() : x(3);
+  final int x;
+}
+class B extends A {
+  const B(this.y);
+  final int y;
+}''');
     EvaluationResultImpl result =
         _evaluateInstanceCreationExpression(compilationUnit, "foo");
     Map<String, DartObjectImpl> fields = _assertType(result, "B");
     EngineTestCase.assertSizeOfMap(2, fields);
     _assertIntField(fields, "y", 4);
     Map<String, DartObjectImpl> superclassFields =
         _assertFieldType(fields, GenericState.SUPERCLASS_FIELD, "A");
     EngineTestCase.assertSizeOfMap(1, superclassFields);
     _assertIntField(superclassFields, "x", 3);
   }
 
   void test_instanceCreationExpression_nonFactoryRedirect() {
-    CompilationUnit compilationUnit = resolveSource(
-        EngineTestCase.createSource(
-            [
-                "const foo = const A.a1();",
-                "class A {",
-                "  const A.a1() : this.a2();",
-                "  const A.a2() : x = 5;",
-                "  final int x;",
-                "}"]));
+    CompilationUnit compilationUnit = resolveSource(r'''
+const foo = const A.a1();
+class A {
+  const A.a1() : this.a2();
+  const A.a2() : x = 5;
+  final int x;
+}''');
     Map<String, DartObjectImpl> aFields = _assertType(
         _evaluateInstanceCreationExpression(compilationUnit, "foo"),
         "A");
     _assertIntField(aFields, 'x', 5);
   }
 
   void test_instanceCreationExpression_nonFactoryRedirect_arg() {
-    CompilationUnit compilationUnit = resolveSource(
-        EngineTestCase.createSource(
-            [
-                "const foo = const A.a1(1);",
-                "class A {",
-                "  const A.a1(x) : this.a2(x + 100);",
-                "  const A.a2(x) : y = x + 10;",
-                "  final int y;",
-                "}"]));
+    CompilationUnit compilationUnit = resolveSource(r'''
+const foo = const A.a1(1);
+class A {
+  const A.a1(x) : this.a2(x + 100);
+  const A.a2(x) : y = x + 10;
+  final int y;
+}''');
     Map<String, DartObjectImpl> aFields = _assertType(
         _evaluateInstanceCreationExpression(compilationUnit, "foo"),
         "A");
     _assertIntField(aFields, 'y', 111);
   }
 
   void test_instanceCreationExpression_nonFactoryRedirect_cycle() {
     // It is an error to have a cycle in non-factory redirects; however, we
     // need to make sure that even if the error occurs, attempting to evaluate
     // the constant will terminate.
-    CompilationUnit compilationUnit = resolveSource(
-        EngineTestCase.createSource(
-            [
-                "const foo = const A();",
-                "class A {",
-                "  const A() : this.b();",
-                "  const A.b() : this();",
-                "}"]));
+    CompilationUnit compilationUnit = resolveSource(r'''
+const foo = const A();
+class A {
+  const A() : this.b();
+  const A.b() : this();
+}''');
     _assertValidUnknown(
         _evaluateInstanceCreationExpression(compilationUnit, "foo"));
   }
 
   void test_instanceCreationExpression_nonFactoryRedirect_defaultArg() {
-    CompilationUnit compilationUnit = resolveSource(
-        EngineTestCase.createSource(
-            [
-                "const foo = const A.a1();",
-                "class A {",
-                "  const A.a1() : this.a2();",
-                "  const A.a2([x = 100]) : y = x + 10;",
-                "  final int y;",
-                "}"]));
+    CompilationUnit compilationUnit = resolveSource(r'''
+const foo = const A.a1();
+class A {
+  const A.a1() : this.a2();
+  const A.a2([x = 100]) : y = x + 10;
+  final int y;
+}''');
     Map<String, DartObjectImpl> aFields = _assertType(
         _evaluateInstanceCreationExpression(compilationUnit, "foo"),
         "A");
     _assertIntField(aFields, 'y', 110);
   }
 
   void test_instanceCreationExpression_nonFactoryRedirect_toMissing() {
-    CompilationUnit compilationUnit = resolveSource(
-        EngineTestCase.createSource(
-            [
-                "const foo = const A.a1();",
-                "class A {",
-                "  const A.a1() : this.a2();",
-                "}"]));
+    CompilationUnit compilationUnit = resolveSource(r'''
+const foo = const A.a1();
+class A {
+  const A.a1() : this.a2();
+}''');
     // We don't care what value foo evaluates to (since there is a compile
     // error), but we shouldn't crash, and we should figure
     // out that it evaluates to an instance of class A.
     _assertType(
         _evaluateInstanceCreationExpression(compilationUnit, "foo"),
         "A");
   }
 
   void test_instanceCreationExpression_nonFactoryRedirect_toNonConst() {
-    CompilationUnit compilationUnit = resolveSource(
-        EngineTestCase.createSource(
-            [
-                "const foo = const A.a1();",
-                "class A {",
-                "  const A.a1() : this.a2();",
-                "  A.a2();",
-                "}"]));
+    CompilationUnit compilationUnit = resolveSource(r'''
+const foo = const A.a1();
+class A {
+  const A.a1() : this.a2();
+  A.a2();
+}''');
     // We don't care what value foo evaluates to (since there is a compile
     // error), but we shouldn't crash, and we should figure
     // out that it evaluates to an instance of class A.
     _assertType(
         _evaluateInstanceCreationExpression(compilationUnit, "foo"),
         "A");
   }
 
   void test_instanceCreationExpression_nonFactoryRedirect_unnamed() {
-    CompilationUnit compilationUnit = resolveSource(
-        EngineTestCase.createSource(
-            [
-                "const foo = const A.a1();",
-                "class A {",
-                "  const A.a1() : this();",
-                "  const A() : x = 5;",
-                "  final int x;",
-                "}"]));
+    CompilationUnit compilationUnit = resolveSource(r'''
+const foo = const A.a1();
+class A {
+  const A.a1() : this();
+  const A() : x = 5;
+  final int x;
+}''');
     Map<String, DartObjectImpl> aFields = _assertType(
         _evaluateInstanceCreationExpression(compilationUnit, "foo"),
         "A");
     _assertIntField(aFields, 'x', 5);
   }
 
   void test_instanceCreationExpression_redirect() {
-    CompilationUnit compilationUnit = resolveSource(
-        EngineTestCase.createSource(
-            [
-                "const foo = const A();",
-                "class A {",
-                "  const factory A() = B;",
-                "}",
-                "class B implements A {",
-                "  const B();",
-                "}"]));
+    CompilationUnit compilationUnit = resolveSource(r'''
+const foo = const A();
+class A {
+  const factory A() = B;
+}
+class B implements A {
+  const B();
+}''');
     _assertType(
         _evaluateInstanceCreationExpression(compilationUnit, "foo"),
         "B");
   }
 
   void test_instanceCreationExpression_redirectWithTypeParams() {
-    CompilationUnit compilationUnit = resolveSource(
-        EngineTestCase.createSource(
-            [
-                "class A {",
-                "  const factory A(var a) = B<int>;",
-                "}",
-                "",
-                "class B<T> implements A {",
-                "  final T x;",
-                "  const B(this.x);",
-                "}",
-                "",
-                "const A a = const A(10);"]));
+    CompilationUnit compilationUnit = resolveSource(r'''
+class A {
+  const factory A(var a) = B<int>;
+}
+
+class B<T> implements A {
+  final T x;
+  const B(this.x);
+}
+
+const A a = const A(10);''');
     EvaluationResultImpl result =
         _evaluateInstanceCreationExpression(compilationUnit, "a");
     Map<String, DartObjectImpl> fields = _assertType(result, "B<int>");
     EngineTestCase.assertSizeOfMap(1, fields);
     _assertIntField(fields, "x", 10);
   }
 
   void test_instanceCreationExpression_redirectWithTypeSubstitution() {
     // To evaluate the redirection of A<int>,
     // A's template argument (T=int) must be substituted
     // into B's template argument (B<U> where U=T) to get B<int>.
-    CompilationUnit compilationUnit = resolveSource(
-        EngineTestCase.createSource(
-            [
-                "class A<T> {",
-                "  const factory A(var a) = B<T>;",
-                "}",
-                "",
-                "class B<U> implements A {",
-                "  final U x;",
-                "  const B(this.x);",
-                "}",
-                "",
-                "const A<int> a = const A<int>(10);"]));
+    CompilationUnit compilationUnit = resolveSource(r'''
+class A<T> {
+  const factory A(var a) = B<T>;
+}
+
+class B<U> implements A {
+  final U x;
+  const B(this.x);
+}
+
+const A<int> a = const A<int>(10);''');
     EvaluationResultImpl result =
         _evaluateInstanceCreationExpression(compilationUnit, "a");
     Map<String, DartObjectImpl> fields = _assertType(result, "B<int>");
     EngineTestCase.assertSizeOfMap(1, fields);
     _assertIntField(fields, "x", 10);
   }
 
   void test_instanceCreationExpression_redirect_cycle() {
     // It is an error to have a cycle in factory redirects; however, we need
     // to make sure that even if the error occurs, attempting to evaluate the
     // constant will terminate.
-    CompilationUnit compilationUnit = resolveSource(
-        EngineTestCase.createSource(
-            [
-                "const foo = const A();",
-                "class A {",
-                "  const factory A() = A.b;",
-                "  const factory A.b() = A;",
-                "}"]));
+    CompilationUnit compilationUnit = resolveSource(r'''
+const foo = const A();
+class A {
+  const factory A() = A.b;
+  const factory A.b() = A;
+}''');
     _assertValidUnknown(
         _evaluateInstanceCreationExpression(compilationUnit, "foo"));
   }
 
   void test_instanceCreationExpression_redirect_extern() {
-    CompilationUnit compilationUnit = resolveSource(
-        EngineTestCase.createSource(
-            ["const foo = const A();", "class A {", "  external const factory A();", "}"]));
+    CompilationUnit compilationUnit = resolveSource(r'''
+const foo = const A();
+class A {
+  external const factory A();
+}''');
     _assertValidUnknown(
         _evaluateInstanceCreationExpression(compilationUnit, "foo"));
   }
 
   void test_instanceCreationExpression_redirect_nonConst() {
     // It is an error for a const factory constructor redirect to a non-const
     // constructor; however, we need to make sure that even if the error
     // attempting to evaluate the constant won't cause a crash.
-    CompilationUnit compilationUnit = resolveSource(
-        EngineTestCase.createSource(
-            [
-                "const foo = const A();",
-                "class A {",
-                "  const factory A() = A.b;",
-                "  A.b();",
-                "}"]));
+    CompilationUnit compilationUnit = resolveSource(r'''
+const foo = const A();
+class A {
+  const factory A() = A.b;
+  A.b();
+}''');
     _assertValidUnknown(
         _evaluateInstanceCreationExpression(compilationUnit, "foo"));
   }
 
   void test_instanceCreationExpression_symbol() {
     CompilationUnit compilationUnit =
-        resolveSource(EngineTestCase.createSource(["const foo = const Symbol('a');"]));
+        resolveSource("const foo = const Symbol('a');");
     EvaluationResultImpl evaluationResult =
         _evaluateInstanceCreationExpression(compilationUnit, "foo");
     JUnitTestCase.assertNotNull(evaluationResult.value);
     DartObjectImpl value = evaluationResult.value;
     JUnitTestCase.assertEquals(typeProvider.symbolType, value.type);
     JUnitTestCase.assertEquals("a", value.value);
   }
 
   void test_instanceCreationExpression_withSupertypeParams_explicit() {
     _checkInstanceCreation_withSupertypeParams(true);
   }
 
   void test_instanceCreationExpression_withSupertypeParams_implicit() {
     _checkInstanceCreation_withSupertypeParams(false);
   }
 
   void test_instanceCreationExpression_withTypeParams() {
-    CompilationUnit compilationUnit = resolveSource(
-        EngineTestCase.createSource(
-            [
-                "class C<E> {",
-                "  const C();",
-                "}",
-                "const c_int = const C<int>();",
-                "const c_num = const C<num>();"]));
+    CompilationUnit compilationUnit = resolveSource(r'''
+class C<E> {
+  const C();
+}
+const c_int = const C<int>();
+const c_num = const C<num>();''');
     EvaluationResultImpl c_int =
         _evaluateInstanceCreationExpression(compilationUnit, "c_int");
     _assertType(c_int, "C<int>");
     DartObjectImpl c_int_value = c_int.value;
     EvaluationResultImpl c_num =
         _evaluateInstanceCreationExpression(compilationUnit, "c_num");
     _assertType(c_num, "C<num>");
     DartObjectImpl c_num_value = c_num.value;
     JUnitTestCase.assertFalse(c_int_value == c_num_value);
   }
@@ skipping 35 matching lines @@
     JUnitTestCase.assertFalse(
         ConstantValueComputer.isValidPublicSymbol("+.foo"));
     JUnitTestCase.assertFalse(
         ConstantValueComputer.isValidPublicSymbol("void.foo"));
     JUnitTestCase.assertFalse(
         ConstantValueComputer.isValidPublicSymbol("foo.void"));
   }
 
   void test_symbolLiteral_void() {
     CompilationUnit compilationUnit =
-        resolveSource(EngineTestCase.createSource(["const voidSymbol = #void;"]));
+        resolveSource("const voidSymbol = #void;");
     VariableDeclaration voidSymbol =
         findTopLevelDeclaration(compilationUnit, "voidSymbol");
     EvaluationResultImpl voidSymbolResult =
         (voidSymbol.element as VariableElementImpl).evaluationResult;
     DartObjectImpl value = voidSymbolResult.value;
     JUnitTestCase.assertEquals(typeProvider.symbolType, value.type);
     JUnitTestCase.assertEquals("void", value.value);
   }
 
   Map<String, DartObjectImpl> _assertFieldType(Map<String,
@@ skipping 70 matching lines @@
     DartObjectImpl value = result.value;
     JUnitTestCase.assertTrue(value.isUnknown);
   }
 
   void _checkInstanceCreationOptionalParams(bool isFieldFormal, bool isNamed,
       bool hasDefault) {
     String fieldName = "j";
     String paramName = isFieldFormal ? fieldName : "i";
     String formalParam =
         "${(isFieldFormal ? "this." : "int ")}${paramName}${(hasDefault ? " = 3" : "")}";
-    CompilationUnit compilationUnit = resolveSource(
-        EngineTestCase.createSource(
-            [
-                "const x = const A();",
-                "const y = const A(${(isNamed ? "${paramName}: " : "")}10);",
-                "class A {",
-                "  const A(${(isNamed ? "{${formalParam}}" : "[${formalParam}]")})${(isFieldFormal ? "" : " : ${fieldName} = ${paramName}")};",
-                "  final int ${fieldName};",
-                "}"]));
+    CompilationUnit compilationUnit = resolveSource("""
+const x = const A();
+const y = const A(${isNamed ? '$paramName: ' : ''}10);
+class A {
+  const A(${isNamed ? "{${formalParam}}" : "[${formalParam}]"})${isFieldFormal ? "" : " : ${fieldName} = ${paramName}"};
+  final int ${fieldName};
+}""");
     EvaluationResultImpl x =
         _evaluateInstanceCreationExpression(compilationUnit, "x");
     Map<String, DartObjectImpl> fieldsOfX = _assertType(x, "A");
     EngineTestCase.assertSizeOfMap(1, fieldsOfX);
     if (hasDefault) {
       _assertIntField(fieldsOfX, fieldName, 3);
     } else {
       _assertNullField(fieldsOfX, fieldName);
     }
     EvaluationResultImpl y =
         _evaluateInstanceCreationExpression(compilationUnit, "y");
     Map<String, DartObjectImpl> fieldsOfY = _assertType(y, "A");
     EngineTestCase.assertSizeOfMap(1, fieldsOfY);
     _assertIntField(fieldsOfY, fieldName, 10);
   }
 
   void _checkInstanceCreation_withSupertypeParams(bool isExplicit) {
     String superCall = isExplicit ? " : super()" : "";
-    CompilationUnit compilationUnit = resolveSource(
-        EngineTestCase.createSource(
-            [
-                "class A<T> {",
-                "  const A();",
-                "}",
-                "class B<T, U> extends A<T> {",
-                "  const B()${superCall};",
-                "}",
-                "class C<T, U> extends A<U> {",
-                "  const C()${superCall};",
-                "}",
-                "const b_int_num = const B<int, num>();",
-                "const c_int_num = const C<int, num>();"]));
+    CompilationUnit compilationUnit = resolveSource("""
+class A<T> {
+  const A();
+}
+class B<T, U> extends A<T> {
+  const B()$superCall;
+}
+class C<T, U> extends A<U> {
+  const C()${superCall};
+}
+const b_int_num = const B<int, num>();
+const c_int_num = const C<int, num>();""");
     EvaluationResultImpl b_int_num =
         _evaluateInstanceCreationExpression(compilationUnit, "b_int_num");
     Map<String, DartObjectImpl> b_int_num_fields =
         _assertType(b_int_num, "B<int, num>");
     _assertFieldType(b_int_num_fields, GenericState.SUPERCLASS_FIELD, "A<int>");
     EvaluationResultImpl c_int_num =
         _evaluateInstanceCreationExpression(compilationUnit, "c_int_num");
     Map<String, DartObjectImpl> c_int_num_fields =
         _assertType(c_int_num, "C<int, num>");
     _assertFieldType(c_int_num_fields, GenericState.SUPERCLASS_FIELD, "A<num>");
   }
 
   EvaluationResultImpl _check_fromEnvironment_bool(String valueInEnvironment,
       String defaultExpr) {
     String envVarName = "x";
     String varName = "foo";
     if (valueInEnvironment != null) {
       analysisContext2.declaredVariables.define(envVarName, valueInEnvironment);
     }
     String defaultArg =
         defaultExpr == null ? "" : ", defaultValue: ${defaultExpr}";
     CompilationUnit compilationUnit = resolveSource(
-        EngineTestCase.createSource(
-            [
-                "const ${varName} = const bool.fromEnvironment('${envVarName}'${defaultArg});"]));
+                "const ${varName} = const bool.fromEnvironment('${envVarName}'${defaultArg});");
     return _evaluateInstanceCreationExpression(compilationUnit, varName);
   }
 
   EvaluationResultImpl _check_fromEnvironment_int(String valueInEnvironment,
       String defaultExpr) {
     String envVarName = "x";
     String varName = "foo";
     if (valueInEnvironment != null) {
       analysisContext2.declaredVariables.define(envVarName, valueInEnvironment);
     }
     String defaultArg =
         defaultExpr == null ? "" : ", defaultValue: ${defaultExpr}";
     CompilationUnit compilationUnit = resolveSource(
-        EngineTestCase.createSource(
-            [
-                "const ${varName} = const int.fromEnvironment('${envVarName}'${defaultArg});"]));
+                "const ${varName} = const int.fromEnvironment('${envVarName}'${defaultArg});");
     return _evaluateInstanceCreationExpression(compilationUnit, varName);
   }
 
   EvaluationResultImpl _check_fromEnvironment_string(String valueInEnvironment,
       String defaultExpr) {
     String envVarName = "x";
     String varName = "foo";
     if (valueInEnvironment != null) {
       analysisContext2.declaredVariables.define(envVarName, valueInEnvironment);
     }
     String defaultArg =
         defaultExpr == null ? "" : ", defaultValue: ${defaultExpr}";
     CompilationUnit compilationUnit = resolveSource(
-        EngineTestCase.createSource(
-            [
-                "const ${varName} = const String.fromEnvironment('${envVarName}'${defaultArg});"]));
+                "const ${varName} = const String.fromEnvironment('${envVarName}'${defaultArg});");
     return _evaluateInstanceCreationExpression(compilationUnit, varName);
   }
 
   EvaluationResultImpl
       _evaluateInstanceCreationExpression(CompilationUnit compilationUnit,
       String name) {
     Expression expression =
         findTopLevelConstantExpression(compilationUnit, name);
     return (expression as InstanceCreationExpression).evaluationResult;
   }
@@ skipping 153 matching lines @@
         new ErrorReporter(errorListener, _dummySource());
     _assertValue(
         1,
         expression.accept(
             new ConstantVisitor.con1(new TestTypeProvider(), errorReporter)));
     errorListener.assertNoErrors();
   }
 
   void test_visitSimpleIdentifier_inEnvironment() {
     CompilationUnit compilationUnit =
-        resolveSource(EngineTestCase.createSource(["const a = b;", "const b = 3;"]));
+        resolveSource(r'''
+const a = b;
+const b = 3;''');
     Map<String, DartObjectImpl> environment = new Map<String, DartObjectImpl>();
     DartObjectImpl six =
         new DartObjectImpl(typeProvider.intType, new IntState(6));
     environment["b"] = six;
     _assertValue(6, _evaluateConstant(compilationUnit, "a", environment));
   }
 
   void test_visitSimpleIdentifier_notInEnvironment() {
     CompilationUnit compilationUnit =
-        resolveSource(EngineTestCase.createSource(["const a = b;", "const b = 3;"]));
+        resolveSource(r'''
+const a = b;
+const b = 3;''');
     Map<String, DartObjectImpl> environment = new Map<String, DartObjectImpl>();
     DartObjectImpl six =
         new DartObjectImpl(typeProvider.intType, new IntState(6));
     environment["c"] = six;
     _assertValue(3, _evaluateConstant(compilationUnit, "a", environment));
   }
 
   void test_visitSimpleIdentifier_withoutEnvironment() {
     CompilationUnit compilationUnit =
-        resolveSource(EngineTestCase.createSource(["const a = b;", "const b = 3;"]));
+        resolveSource(r'''
+const a = b;
+const b = 3;''');
     _assertValue(3, _evaluateConstant(compilationUnit, "a", null));
   }
 
   void _assertValue(int expectedValue, DartObjectImpl result) {
     JUnitTestCase.assertNotNull(result);
     JUnitTestCase.assertEquals("int", result.type.name);
     JUnitTestCase.assertEquals(expectedValue, result.intValue);
   }
 
   NonExistingSource _dummySource() {
@@ skipping 3917 matching lines @@
             "}"]);
     Element element = ElementLocator.locate(id);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is MethodElement,
         MethodElement,
         element);
   }
 
   void test_locate_MethodInvocation_topLevel() {
     String contents =
-        EngineTestCase.createSource(["foo(x) {}", "void main() {", " foo(0);", "}"]);
+        r'''
+foo(x) {}
+void main() {
+ foo(0);
+}''';
     CompilationUnit cu = _resolveContents([contents]);
     int offset = contents.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);
@@ skipping 1051 matching lines @@
   }
 }
 
 
 class HtmlParserTest extends EngineTestCase {
   /**
    * The name of the 'script' tag in an HTML file.
    */
   static String _TAG_SCRIPT = "script";
   void fail_parse_scriptWithComment() {
-    String scriptBody = EngineTestCase.createSource(
-        [
-            "      /**",
-            "       *     <editable-label bind-value=\"dartAsignableValue\">",
-            "       *     </editable-label>",
-            "       */",
-            "      class Foo {}"]);
-    ht.HtmlUnit htmlUnit = parse(
-        EngineTestCase.createSource(
-            [
-                "  <html>",
-                "    <body>",
-                "      <script type=\"application/dart\">",
-                scriptBody,
-                "      </script>",
-                "    </body>",
-                "  </html>"]));
+    String scriptBody = r'''
+      /**
+       *     <editable-label bind-value="dartAsignableValue">
+       *     </editable-label>
+       */
+      class Foo {}''';
+    ht.HtmlUnit htmlUnit = parse("""
+<html>
+  <body>
+    <script type='application/dart'>
+$scriptBody
+    </script>
+  </body>
+</html>""");
     _validate(
         htmlUnit,
         [
             _t4(
                 "html",
                 [
                     _t4(
                         "body",
-                        [_t("script", _a(["type", "\"application/dart\""]), scriptBody, [])])])]);
+                        [_t("script", _a(["type", "'application/dart'"]), scriptBody, [])])])]);
   }
   ht.HtmlUnit parse(String contents) {
 //    TestSource source =
 //        new TestSource.con1(FileUtilities2.createFile("/test.dart"), contents);
     ht.AbstractScanner scanner = new ht.StringScanner(null, contents);
     scanner.passThroughElements = <String>[_TAG_SCRIPT];
     ht.Token token = scanner.tokenize();
     LineInfo lineInfo = new LineInfo(scanner.lineStarts);
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ht.HtmlUnit unit =
@@ skipping 88 matching lines @@
   }
   void test_parse_getAttributeText() {
     ht.HtmlUnit htmlUnit = parse("<html><body foo=\"sdfsdf\"></body></html>");
     ht.XmlTagNode htmlNode = htmlUnit.tagNodes[0];
     ht.XmlTagNode bodyNode = htmlNode.tagNodes[0];
     JUnitTestCase.assertEquals("sdfsdf", bodyNode.getAttributeText("foo"));
     JUnitTestCase.assertEquals(null, bodyNode.getAttributeText("bar"));
     JUnitTestCase.assertEquals(null, bodyNode.getAttributeText(null));
   }
   void test_parse_headers() {
-    String code = EngineTestCase.createSource(
-        [
-            "<html>",
-            "  <body>",
-            "    <h2>000</h2>",
-            "    <div>",
-            "      111",
-            "    </div>",
-            "  </body>",
-            "</html>"]);
+    String code = r'''
+<html>
+  <body>
+    <h2>000</h2>
+    <div>
+      111
+    </div>
+  </body>
+</html>''';
     ht.HtmlUnit htmlUnit = parse(code);
     _validate(
         htmlUnit,
         [_t4("html", [_t4("body", [_t3("h2", "000", []), _t4("div", [])])])]);
   }
   void test_parse_script() {
     ht.HtmlUnit htmlUnit =
         parse("<html><script >here is <p> some</script></html>");
     _validate(htmlUnit, [_t4("html", [_t3("script", "here is <p> some", [])])]);
   }
@@ skipping 23 matching lines @@
     validator.expectTags(expectedTags);
     htmlUnit.accept(validator);
     validator.assertValid();
   }
 }
 
 
 class HtmlTagInfoBuilderTest extends HtmlParserTest {
   void test_builder() {
     HtmlTagInfoBuilder builder = new HtmlTagInfoBuilder();
-    ht.HtmlUnit unit = parse(
-        EngineTestCase.createSource(
-            [
-                "<html>",
-                "  <body>",
-                "    <div id=\"x\"></div>",
-                "    <p class='c'></p>",
-                "    <div class='c'></div>",
-                "  </body>",
-                "</html>"]));
+    ht.HtmlUnit unit = parse(r'''
+<html>
+  <body>
+    <div id="x"></div>
+    <p class='c'></p>
+    <div class='c'></div>
+  </body>
+</html>''');
     unit.accept(builder);
     HtmlTagInfo info = builder.getTagInfo();
     JUnitTestCase.assertNotNull(info);
     List<String> allTags = info.allTags;
     EngineTestCase.assertLength(4, allTags);
     JUnitTestCase.assertEquals("div", info.getTagWithId("x"));
     List<String> tagsWithClass = info.getTagsWithClass("c");
     EngineTestCase.assertLength(2, tagsWithClass);
   }
 }
 
 
 class HtmlUnitBuilderTest extends EngineTestCase {
   AnalysisContextImpl _context;
   @override
   void setUp() {
     _context = AnalysisContextFactory.contextWithCore();
   }
   @override
   void tearDown() {
     _context = null;
     super.tearDown();
   }
   void test_embedded_script() {
-    HtmlElementImpl element = _build(
-        EngineTestCase.createSource(
-            ["<html>", "<script type=\"application/dart\">foo=2;</script>", "</html>"]));
+    HtmlElementImpl element = _build(r'''
+<html>
+<script type="application/dart">foo=2;</script>
+</html>''');
     _validate(element, [_s(_l([_v("foo")]))]);
   }
   void test_embedded_script_no_content() {
-    HtmlElementImpl element = _build(
-        EngineTestCase.createSource(
-            ["<html>", "<script type=\"application/dart\"></script>", "</html>"]));
+    HtmlElementImpl element = _build(r'''
+<html>
+<script type="application/dart"></script>
+</html>''');
     _validate(element, [_s(_l([]))]);
   }
   void test_external_script() {
-    HtmlElementImpl element = _build(
-        EngineTestCase.createSource(
-            [
-                "<html>",
-                "<script type=\"application/dart\" src=\"other.dart\"/>",
-                "</html>"]));
+    HtmlElementImpl element = _build(r'''
+<html>
+<script type="application/dart" src="other.dart"/>
+</html>''');
     _validate(element, [_s2("other.dart")]);
   }
   void test_external_script_no_source() {
-    HtmlElementImpl element = _build(
-        EngineTestCase.createSource(
-            ["<html>", "<script type=\"application/dart\"/>", "</html>"]));
+    HtmlElementImpl element = _build(r'''
+<html>
+<script type="application/dart"/>
+</html>''');
     _validate(element, [_s2(null)]);
   }
   void test_external_script_with_content() {
-    HtmlElementImpl element = _build(
-        EngineTestCase.createSource(
-            [
-                "<html>",
-                "<script type=\"application/dart\" src=\"other.dart\">blat=2;</script>",
-                "</html>"]));
+    HtmlElementImpl element = _build(r'''
+<html>
+<script type="application/dart" src="other.dart">blat=2;</script>
+</html>''');
     _validate(element, [_s2("other.dart")]);
   }
   void test_no_scripts() {
-    HtmlElementImpl element = _build(
-        EngineTestCase.createSource(["<!DOCTYPE html>", "<html><p></p></html>"]));
+    HtmlElementImpl element = _build(r'''
+<!DOCTYPE html>
+<html><p></p></html>''');
     _validate(element, []);
   }
   void test_two_dart_scripts() {
-    HtmlElementImpl element = _build(
-        EngineTestCase.createSource(
-            [
-                "<html>",
-                "<script type=\"application/dart\">bar=2;</script>",
-                "<script type=\"application/dart\" src=\"other.dart\"/>",
-                "<script src=\"dart.js\"/>",
-                "</html>"]));
+    HtmlElementImpl element = _build(r'''
+<html>
+<script type="application/dart">bar=2;</script>
+<script type="application/dart" src="other.dart"/>
+<script src="dart.js"/>
+</html>''');
     _validate(element, [_s(_l([_v("bar")])), _s2("other.dart")]);
   }
   HtmlElementImpl _build(String contents) {
     TestSource source = new TestSource(
         FileUtilities2.createFile("/test.html").getAbsolutePath(),
         contents);
     ChangeSet changeSet = new ChangeSet();
     changeSet.addedSource(source);
     _context.applyChanges(changeSet);
     HtmlUnitBuilder builder = new HtmlUnitBuilder(_context);
@@ skipping 97 matching lines @@
   @override
   void tearDown() {
     _sourceFactory = null;
     _context = null;
     _contents = null;
     _errors = null;
     super.tearDown();
   }
 
   void test_invalidUri() {
-    _verify(
-        EngineTestCase.createSource(
-            ["<html>", "<script type='application/dart' src='ht:'/>", "</html>"]),
+    _verify(r'''
+<html>
+<script type='application/dart' src='ht:'/>
+</html>''',
         [HtmlWarningCode.INVALID_URI]);
     _assertErrorLocation2(_errors[0], "ht:");
   }
 
   void test_uriDoesNotExist() {
-    _verify(
-        EngineTestCase.createSource(
-            ["<html>", "<script type='application/dart' src='other.dart'/>", "</html>"]),
+    _verify(r'''
+<html>
+<script type='application/dart' src='other.dart'/>
+</html>''',
         [HtmlWarningCode.URI_DOES_NOT_EXIST]);
     _assertErrorLocation2(_errors[0], "other.dart");
   }
 
   void _assertErrorLocation(AnalysisError error, int expectedOffset,
       int expectedLength) {
     JUnitTestCase.assertEqualsMsg(
         error.toString(),
         expectedOffset,
         error.offset);
@@ skipping 219 matching lines @@
     node.accept(_createReferenceFinder(_head));
   }
 }
 
 
 class SDKLibrariesReaderTest extends EngineTestCase {
   void test_readFrom_dart2js() {
     LibraryMap libraryMap = new SdkLibrariesReader(
         true).readFromFile(
             FileUtilities2.createFile("/libs.dart"),
-            EngineTestCase.createSource(
-                [
-                    "final Map<String, LibraryInfo> LIBRARIES = const <String, LibraryInfo> {",
-                    "  'first' : const LibraryInfo(",
-                    "    'first/first.dart',",
-                    "    category: 'First',",
-                    "    documented: true,",
-                    "    platforms: VM_PLATFORM,",
-                    "    dart2jsPath: 'first/first_dart2js.dart'),",
-                    "};"]));
+            r'''
+final Map<String, LibraryInfo> LIBRARIES = const <String, LibraryInfo> {
+  'first' : const LibraryInfo(
+    'first/first.dart',
+    category: 'First',
+    documented: true,
+    platforms: VM_PLATFORM,
+    dart2jsPath: 'first/first_dart2js.dart'),
+};''');
     JUnitTestCase.assertNotNull(libraryMap);
     JUnitTestCase.assertEquals(1, libraryMap.size());
     SdkLibrary first = libraryMap.getLibrary("dart:first");
     JUnitTestCase.assertNotNull(first);
     JUnitTestCase.assertEquals("First", first.category);
     JUnitTestCase.assertEquals("first/first_dart2js.dart", first.path);
     JUnitTestCase.assertEquals("dart:first", first.shortName);
     JUnitTestCase.assertEquals(false, first.isDart2JsLibrary);
     JUnitTestCase.assertEquals(true, first.isDocumented);
     JUnitTestCase.assertEquals(false, first.isImplementation);
     JUnitTestCase.assertEquals(true, first.isVmLibrary);
   }
   void test_readFrom_empty() {
     LibraryMap libraryMap = new SdkLibrariesReader(
         false).readFromFile(FileUtilities2.createFile("/libs.dart"), "");
     JUnitTestCase.assertNotNull(libraryMap);
     JUnitTestCase.assertEquals(0, libraryMap.size());
   }
   void test_readFrom_normal() {
     LibraryMap libraryMap = new SdkLibrariesReader(
         false).readFromFile(
             FileUtilities2.createFile("/libs.dart"),
-            EngineTestCase.createSource(
-                [
-                    "final Map<String, LibraryInfo> LIBRARIES = const <String, LibraryInfo> {",
-                    "  'first' : const LibraryInfo(",
-                    "    'first/first.dart',",
-                    "    category: 'First',",
-                    "    documented: true,",
-                    "    platforms: VM_PLATFORM),",
-                    "",
-                    "  'second' : const LibraryInfo(",
-                    "    'second/second.dart',",
-                    "    category: 'Second',",
-                    "    documented: false,",
-                    "    implementation: true,",
-                    "    platforms: 0),",
-                    "};"]));
+            r'''
+final Map<String, LibraryInfo> LIBRARIES = const <String, LibraryInfo> {
+  'first' : const LibraryInfo(
+    'first/first.dart',
+    category: 'First',
+    documented: true,
+    platforms: VM_PLATFORM),
+
+  'second' : const LibraryInfo(
+    'second/second.dart',
+    category: 'Second',
+    documented: false,
+    implementation: true,
+    platforms: 0),
+};''');
     JUnitTestCase.assertNotNull(libraryMap);
     JUnitTestCase.assertEquals(2, libraryMap.size());
     SdkLibrary first = libraryMap.getLibrary("dart:first");
     JUnitTestCase.assertNotNull(first);
     JUnitTestCase.assertEquals("First", first.category);
     JUnitTestCase.assertEquals("first/first.dart", first.path);
     JUnitTestCase.assertEquals("dart:first", first.shortName);
     JUnitTestCase.assertEquals(false, first.isDart2JsLibrary);
     JUnitTestCase.assertEquals(true, first.isDocumented);
     JUnitTestCase.assertEquals(false, first.isImplementation);
@@ skipping 579 matching lines @@
     } else {
       JUnitTestCase.assertNotNullMsg("script ${scriptIndex}", scriptSource);
       String actualExternalScriptName = scriptSource.shortName;
       JUnitTestCase.assertEqualsMsg(
           "script ${scriptIndex}",
           _expectedExternalScriptName,
           actualExternalScriptName);
     }
   }
 }