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

pkg/analyzer/test/generated/resolver_test.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.
 
 library engine.resolver_test;
 
 import 'dart:collection';
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_junit.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
@@ skipping 402 matching lines @@
     changeSet.removedContainer(new SourceContainer_ChangeSetTest_test_toString());
     JUnitTestCase.assertNotNull(changeSet.toString());
   }
 }
 
 class CheckedModeCompileTimeErrorCodeTest extends ResolverTestCase {
   void test_fieldFormalParameterAssignableToField_extends() {
     // According to checked-mode type checking rules, a value of type B is
     // assignable to a field of type A, because B extends A (and hence is a
     // subtype of A).
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  const A();",
-        "}",
-        "class B extends A {",
-        "  const B();",
-        "}",
-        "class C {",
-        "  final A a;",
-        "  const C(this.a);",
-        "}",
-        "var v = const C(const B());"]));
+    Source source = addSource(r'''
+class A {
+  const A();
+}
+class B extends A {
+  const B();
+}
+class C {
+  final A a;
+  const C(this.a);
+}
+var v = const C(const B());''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldFormalParameterAssignableToField_fieldType_unresolved_null() {
     // Null always passes runtime type checks, even when the type is
     // unresolved.
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  final Unresolved x;",
-        "  const A(String this.x);",
-        "}",
-        "var v = const A(null);"]));
+    Source source = addSource(r'''
+class A {
+  final Unresolved x;
+  const A(String this.x);
+}
+var v = const A(null);''');
     resolve(source);
     assertErrors(source, [
         StaticWarningCode.UNDEFINED_CLASS]);
     verify([source]);
   }
 
   void test_fieldFormalParameterAssignableToField_implements() {
     // According to checked-mode type checking rules, a value of type B is
     // assignable to a field of type A, because B implements A (and hence is a
     // subtype of A).
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "class B implements A {",
-        "  const B();",
-        "}",
-        "class C {",
-        "  final A a;",
-        "  const C(this.a);",
-        "}",
-        "var v = const C(const B());"]));
+    Source source = addSource(r'''
+class A {}
+class B implements A {
+  const B();
+}
+class C {
+  final A a;
+  const C(this.a);
+}
+var v = const C(const B());''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldFormalParameterAssignableToField_list_dynamic() {
     // [1, 2, 3] has type List<dynamic>, which is a subtype of List<int>.
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  const A(List<int> x);",
-        "}",
-        "var x = const A(const [1, 2, 3]);"]));
+    Source source = addSource(r'''
+class A {
+  const A(List<int> x);
+}
+var x = const A(const [1, 2, 3]);''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldFormalParameterAssignableToField_list_nonDynamic() {
     // <int>[1, 2, 3] has type List<int>, which is a subtype of List<num>.
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  const A(List<num> x);",
-        "}",
-        "var x = const A(const <int>[1, 2, 3]);"]));
+    Source source = addSource(r'''
+class A {
+  const A(List<num> x);
+}
+var x = const A(const <int>[1, 2, 3]);''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldFormalParameterAssignableToField_map_dynamic() {
     // {1: 2} has type Map<dynamic, dynamic>, which is a subtype of
     // Map<int, int>.
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  const A(Map<int, int> x);",
-        "}",
-        "var x = const A(const {1: 2});"]));
+    Source source = addSource(r'''
+class A {
+  const A(Map<int, int> x);
+}
+var x = const A(const {1: 2});''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldFormalParameterAssignableToField_map_keyDifferent() {
     // <int, int>{1: 2} has type Map<int, int>, which is a subtype of
     // Map<num, int>.
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  const A(Map<num, int> x);",
-        "}",
-        "var x = const A(const <int, int>{1: 2});"]));
+    Source source = addSource(r'''
+class A {
+  const A(Map<num, int> x);
+}
+var x = const A(const <int, int>{1: 2});''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldFormalParameterAssignableToField_map_valueDifferent() {
     // <int, int>{1: 2} has type Map<int, int>, which is a subtype of
     // Map<int, num>.
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  const A(Map<int, num> x);",
-        "}",
-        "var x = const A(const <int, int>{1: 2});"]));
+    Source source = addSource(r'''
+class A {
+  const A(Map<int, num> x);
+}
+var x = const A(const <int, int>{1: 2});''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldFormalParameterAssignableToField_notype() {
     // If a field is declared without a type, then any value may be assigned to
     // it.
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  final x;",
-        "  const A(this.x);",
-        "}",
-        "var v = const A(5);"]));
+    Source source = addSource(r'''
+class A {
+  final x;
+  const A(this.x);
+}
+var v = const A(5);''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldFormalParameterAssignableToField_null() {
     // Null is assignable to anything.
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  final int x;",
-        "  const A(this.x);",
-        "}",
-        "var v = const A(null);"]));
+    Source source = addSource(r'''
+class A {
+  final int x;
+  const A(this.x);
+}
+var v = const A(null);''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldFormalParameterAssignableToField_typeSubstitution() {
     // foo has the runtime type dynamic -> dynamic, so it should be assignable
     // to A.f.
-    Source source = addSource(EngineTestCase.createSource([
-        "class A<T> {",
-        "  final T x;",
-        "  const A(this.x);",
-        "}",
-        "var v = const A<int>(3);"]));
+    Source source = addSource(r'''
+class A<T> {
+  final T x;
+  const A(this.x);
+}
+var v = const A<int>(3);''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldFormalParameterAssignableToField_typedef() {
     // foo has the runtime type dynamic -> dynamic, so it should be assignable
     // to A.f.
-    Source source = addSource(EngineTestCase.createSource([
-        "typedef String Int2String(int x);",
-        "class A {",
-        "  final Int2String f;",
-        "  const A(this.f);",
-        "}",
-        "foo(x) => 1;"
-        "var v = const A(foo);"]));
+    Source source = addSource(r'''
+typedef String Int2String(int x);
+class A {
+  final Int2String f;
+  const A(this.f);
+}
+foo(x) => 1;
+var v = const A(foo);''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldFormalParameterNotAssignableToField() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  final int x;",
-        "  const A(this.x);",
-        "}",
-        "var v = const A('foo');"]));
+    Source source = addSource(r'''
+class A {
+  final int x;
+  const A(this.x);
+}
+var v = const A('foo');''');
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
         StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
 
   void test_fieldFormalParameterNotAssignableToField_fieldType() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  final int x;",
-        "  const A(String this.x);",
-        "}",
-        "var v = const A('foo');"]));
+    Source source = addSource(r'''
+class A {
+  final int x;
+  const A(String this.x);
+}
+var v = const A('foo');''');
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
         StaticWarningCode.FIELD_INITIALIZING_FORMAL_NOT_ASSIGNABLE]);
     verify([source]);
   }
 
   void test_fieldFormalParameterNotAssignableToField_fieldType_unresolved() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  final Unresolved x;",
-        "  const A(String this.x);",
-        "}",
-        "var v = const A('foo');"]));
+    Source source = addSource(r'''
+class A {
+  final Unresolved x;
+  const A(String this.x);
+}
+var v = const A('foo');''');
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
         StaticWarningCode.UNDEFINED_CLASS]);
     verify([source]);
   }
 
   void test_fieldFormalParameterNotAssignableToField_extends() {
     // According to checked-mode type checking rules, a value of type A is not
     // assignable to a field of type B, because B extends A (the subtyping
     // relationship is in the wrong direction).
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  const A();",
-        "}",
-        "class B extends A {",
-        "  const B();",
-        "}",
-        "class C {",
-        "  final B b;",
-        "  const C(this.b);",
-        "}",
-        "var v = const C(const A());"]));
+    Source source = addSource(r'''
+class A {
+  const A();
+}
+class B extends A {
+  const B();
+}
+class C {
+  final B b;
+  const C(this.b);
+}
+var v = const C(const A());''');
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH]);
     verify([source]);
   }
 
   void test_fieldFormalParameterNotAssignableToField_implements() {
     // According to checked-mode type checking rules, a value of type A is not
     // assignable to a field of type B, because B implements A (the subtyping
     // relationship is in the wrong direction).
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  const A();",
-        "}",
-        "class B implements A {}",
-        "class C {",
-        "  final B b;",
-        "  const C(this.b);",
-        "}",
-        "var v = const C(const A());"]));
+    Source source = addSource(r'''
+class A {
+  const A();
+}
+class B implements A {}
+class C {
+  final B b;
+  const C(this.b);
+}
+var v = const C(const A());''');
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH]);
     verify([source]);
   }
 
   void test_fieldFormalParameterNotAssignableToField_list() {
     // <num>[1, 2, 3] has type List<num>, which is not a subtype of List<int>.
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  const A(List<int> x);",
-        "}",
-        "var x = const A(const <num>[1, 2, 3]);"]));
+    Source source = addSource(r'''
+class A {
+  const A(List<int> x);
+}
+var x = const A(const <num>[1, 2, 3]);''');
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH]);
     verify([source]);
   }
 
   void test_fieldFormalParameterNotAssignableToField_map_keyMismatch() {
     // <num, int>{1: 2} has type Map<num, int>, which is not a subtype of
     // Map<int, int>.
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  const A(Map<int, int> x);",
-        "}",
-        "var x = const A(const <num, int>{1: 2});"]));
+    Source source = addSource(r'''
+class A {
+  const A(Map<int, int> x);
+}
+var x = const A(const <num, int>{1: 2});''');
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH]);
     verify([source]);
   }
 
   void test_fieldFormalParameterNotAssignableToField_map_valueMismatch() {
     // <int, num>{1: 2} has type Map<int, num>, which is not a subtype of
     // Map<int, int>.
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  const A(Map<int, int> x);",
-        "}",
-        "var x = const A(const <int, num>{1: 2});"]));
+    Source source = addSource(r'''
+class A {
+  const A(Map<int, int> x);
+}
+var x = const A(const <int, num>{1: 2});''');
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH]);
     verify([source]);
   }
 
   void test_fieldFormalParameterNotAssignableToField_optional() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  final int x;",
-        "  const A([this.x = 'foo']);",
-        "}",
-        "var v = const A();"]));
+    Source source = addSource(r'''
+class A {
+  final int x;
+  const A([this.x = 'foo']);
+}
+var v = const A();''');
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
         StaticTypeWarningCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
 
   void test_fieldFormalParameterNotAssignableToField_typedef() {
     // foo has the runtime type String -> int, so it should not be assignable
     // to A.f (A.f requires it to be int -> String).
-    Source source = addSource(EngineTestCase.createSource([
-        "typedef String Int2String(int x);",
-        "class A {",
-        "  final Int2String f;",
-        "  const A(this.f);",
-        "}",
-        "int foo(String x) => 1;"
-        "var v = const A(foo);"]));
+    Source source = addSource(r'''
+typedef String Int2String(int x);
+class A {
+  final Int2String f;
+  const A(this.f);
+}
+int foo(String x) => 1;
+var v = const A(foo);''');
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
         StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
 
   void test_fieldInitializerNotAssignable() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  final int x;",
-        "  const A() : x = '';",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  final int x;
+  const A() : x = '';
+}''');
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE,
         StaticWarningCode.FIELD_INITIALIZER_NOT_ASSIGNABLE]);
     verify([source]);
   }
 
   void test_fieldTypeMismatch() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  const A(x) : y = x;",
-        "  final int y;",
-        "}",
-        "var v = const A('foo');"]));
+    Source source = addSource(r'''
+class A {
+  const A(x) : y = x;
+  final int y;
+}
+var v = const A('foo');''');
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_FIELD_TYPE_MISMATCH]);
     verify([source]);
   }
 
   void test_fieldTypeMismatch_unresolved() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  const A(x) : y = x;",
-        "  final Unresolved y;",
-        "}",
-        "var v = const A('foo');"]));
+    Source source = addSource(r'''
+class A {
+  const A(x) : y = x;
+  final Unresolved y;
+}
+var v = const A('foo');''');
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_FIELD_TYPE_MISMATCH,
         StaticWarningCode.UNDEFINED_CLASS]);
     verify([source]);
   }
 
   void test_fieldTypeOk_null() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  const A(x) : y = x;",
-        "  final int y;",
-        "}",
-        "var v = const A(null);"]));
+    Source source = addSource(r'''
+class A {
+  const A(x) : y = x;
+  final int y;
+}
+var v = const A(null);''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldTypeOk_unresolved_null() {
     // Null always passes runtime type checks, even when the type is
     // unresolved.
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  const A(x) : y = x;",
-        "  final Unresolved y;",
-        "}",
-        "var v = const A(null);"]));
+    Source source = addSource(r'''
+class A {
+  const A(x) : y = x;
+  final Unresolved y;
+}
+var v = const A(null);''');
     resolve(source);
     assertErrors(source, [
         StaticWarningCode.UNDEFINED_CLASS]);
     verify([source]);
   }
 
   void test_listElementTypeNotAssignable() {
-    Source source = addSource(EngineTestCase.createSource(["var v = const <String> [42];"]));
+    Source source = addSource("var v = const <String> [42];");
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE,
         StaticWarningCode.LIST_ELEMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
 
   void test_mapKeyTypeNotAssignable() {
-    Source source = addSource(EngineTestCase.createSource(["var v = const <String, int > {1 : 2};"]));
+    Source source = addSource("var v = const <String, int > {1 : 2};");
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.MAP_KEY_TYPE_NOT_ASSIGNABLE,
         StaticWarningCode.MAP_KEY_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
 
   void test_mapValueTypeNotAssignable() {
-    Source source = addSource(EngineTestCase.createSource(["var v = const <String, String> {'a' : 2};"]));
+    Source source = addSource("var v = const <String, String> {'a' : 2};");
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE,
         StaticWarningCode.MAP_VALUE_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
 
   void test_redirectingConstructor_paramTypeMismatch() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  const A.a1(x) : this.a2(x);",
-        "  const A.a2(String x);",
-        "}",
-        "var v = const A.a1(0);"]));
+    Source source = addSource(r'''
+class A {
+  const A.a1(x) : this.a2(x);
+  const A.a2(String x);
+}
+var v = const A.a1(0);''');
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH]);
     verify([source]);
   }
 
   void test_parameterAssignable_null() {
     // Null is assignable to anything.
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  const A(int x);",
-        "}",
-        "var v = const A(null);"]));
+    Source source = addSource(r'''
+class A {
+  const A(int x);
+}
+var v = const A(null);''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_parameterAssignable_undefined_null() {
     // Null always passes runtime type checks, even when the type is
     // unresolved.
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  const A(Unresolved x);",
-        "}",
-        "var v = const A(null);"]));
+    Source source = addSource(r'''
+class A {
+  const A(Unresolved x);
+}
+var v = const A(null);''');
     resolve(source);
     assertErrors(source, [
         StaticWarningCode.UNDEFINED_CLASS]);
     verify([source]);
   }
 
   void test_parameterAssignable_typeSubstitution() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A<T> {",
-        "  const A(T x);",
-        "}",
-        "var v = const A<int>(3);"]));
+    Source source = addSource(r'''
+class A<T> {
+  const A(T x);
+}
+var v = const A<int>(3);''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_parameterNotAssignable() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  const A(int x);",
-        "}",
-        "var v = const A('foo');"]));
+    Source source = addSource(r'''
+class A {
+  const A(int x);
+}
+var v = const A('foo');''');
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
         StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
 
   void test_parameterNotAssignable_undefined() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  const A(Unresolved x);",
-        "}",
-        "var v = const A('foo');"]));
+    Source source = addSource(r'''
+class A {
+  const A(Unresolved x);
+}
+var v = const A('foo');''');
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
         StaticWarningCode.UNDEFINED_CLASS]);
     verify([source]);
   }
 
   void test_parameterNotAssignable_typeSubstitution() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A<T> {",
-        "  const A(T x);",
-        "}",
-        "var v = const A<int>('foo');"]));
+    Source source = addSource(r'''
+class A<T> {
+  const A(T x);
+}
+var v = const A<int>('foo');''');
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH,
         StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
 
   void test_topLevelVarAssignable_null() {
-    Source source = addSource(EngineTestCase.createSource([
-        "const int x = null;"]));
+    Source source = addSource("const int x = null;");
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_topLevelVarAssignable_undefined_null() {
     // Null always passes runtime type checks, even when the type is
     // unresolved.
-    Source source = addSource(EngineTestCase.createSource([
-        "const Unresolved x = null;"]));
+    Source source = addSource("const Unresolved x = null;");
     resolve(source);
     assertErrors(source, [
         StaticWarningCode.UNDEFINED_CLASS]);
     verify([source]);
   }
 
   void test_topLevelVarNotAssignable() {
-    Source source = addSource(EngineTestCase.createSource([
-        "const int x = 'foo';"]));
+    Source source = addSource("const int x = 'foo';");
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.VARIABLE_TYPE_MISMATCH,
         StaticTypeWarningCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
 
   void test_topLevelVarNotAssignable_undefined() {
-    Source source = addSource(EngineTestCase.createSource([
-        "const Unresolved x = 'foo';"]));
+    Source source = addSource("const Unresolved x = 'foo';");
     resolve(source);
     assertErrors(source, [
         CheckedModeCompileTimeErrorCode.VARIABLE_TYPE_MISMATCH,
         StaticWarningCode.UNDEFINED_CLASS]);
     verify([source]);
   }
 }
 
 class DeclarationMatcherTest extends ResolverTestCase {
   void test_compilationUnitMatches_false_topLevelVariable() {
-    _assertCompilationUnitMatches(false, EngineTestCase.createSource([
-        "class C {",
-        "  int m(int p) {",
-        "    return p + p;",
-        "  }",
-        "}"]), EngineTestCase.createSource([
-        "const int ZERO = 0;",
-        "class C {",
-        "  int m(int p) {",
-        "    return (p * p) + (p * p) + ZERO;",
-        "  }",
-        "}"]));
+    _assertCompilationUnitMatches(false, r'''
+class C {
+  int m(int p) {
+    return p + p;
+  }
+}''', r'''
+const int ZERO = 0;
+class C {
+  int m(int p) {
+    return (p * p) + (p * p) + ZERO;
+  }
+}''');
   }
 
   void test_compilationUnitMatches_true_different() {
-    _assertCompilationUnitMatches(true, EngineTestCase.createSource([
-        "class C {",
-        "  int m(int p) {",
-        "    return p + p;",
-        "  }",
-        "}"]), EngineTestCase.createSource([
-        "class C {",
-        "  int m(int p) {",
-        "    return (p * p) + (p * p);",
-        "  }",
-        "}"]));
+    _assertCompilationUnitMatches(true, r'''
+class C {
+  int m(int p) {
+    return p + p;
+  }
+}''', r'''
+class C {
+  int m(int p) {
+    return (p * p) + (p * p);
+  }
+}''');
   }
 
   void test_compilationUnitMatches_true_same() {
-    String content = EngineTestCase.createSource([
-        "class C {",
-        "  int m(int p) {",
-        "    return p + p;",
-        "  }",
-        "}"]);
+    String content = r'''
+class C {
+  int m(int p) {
+    return p + p;
+  }
+}''';
     _assertCompilationUnitMatches(true, content, content);
   }
 
   void test_methodDeclarationMatches_false_localVariable() {
-    _assertMethodMatches(false, EngineTestCase.createSource([
-        "class C {",
-        "  int m(int p) {",
-        "    return p + p;",
-        "  }",
-        "}"]), EngineTestCase.createSource([
-        "class C {",
-        "  int m(int p) {",
-        "    int product = p * p;",
-        "    return product + product;",
-        "  }",
-        "}"]));
+    _assertMethodMatches(false, r'''
+class C {
+  int m(int p) {
+    return p + p;
+  }
+}''', r'''
+class C {
+  int m(int p) {
+    int product = p * p;
+    return product + product;
+  }
+}''');
   }
 
   void test_methodDeclarationMatches_false_parameter() {
-    _assertMethodMatches(false, EngineTestCase.createSource([
-        "class C {",
-        "  int m(int p) {",
-        "    return p + p;",
-        "  }",
-        "}"]), EngineTestCase.createSource([
-        "class C {",
-        "  int m(int p, int q) {",
-        "    return (p * q) + (q * p);",
-        "  }",
-        "}"]));
+    _assertMethodMatches(false, r'''
+class C {
+  int m(int p) {
+    return p + p;
+  }
+}''', r'''
+class C {
+  int m(int p, int q) {
+    return (p * q) + (q * p);
+  }
+}''');
   }
 
   void test_methodDeclarationMatches_true_different() {
-    _assertMethodMatches(true, EngineTestCase.createSource([
-        "class C {",
-        "  int m(int p) {",
-        "    return p + p;",
-        "  }",
-        "}"]), EngineTestCase.createSource([
-        "class C {",
-        "  int m(int p) {",
-        "    return (p * p) + (p * p);",
-        "  }",
-        "}"]));
+    _assertMethodMatches(true, r'''
+class C {
+  int m(int p) {
+    return p + p;
+  }
+}''', r'''
+class C {
+  int m(int p) {
+    return (p * p) + (p * p);
+  }
+}''');
   }
 
   void test_methodDeclarationMatches_true_same() {
-    String content = EngineTestCase.createSource([
-        "class C {",
-        "  int m(int p) {",
-        "    return p + p;",
-        "  }",
-        "}"]);
+    String content = r'''
+class C {
+  int m(int p) {
+    return p + p;
+  }
+}''';
     _assertMethodMatches(true, content, content);
   }
 
   void _assertCompilationUnitMatches(bool expectMatch, String oldContent, String newContent) {
     Source source = addSource(oldContent);
     LibraryElement library = resolve(source);
     CompilationUnit oldUnit = resolveCompilationUnit(source, library);
     AnalysisContext context = analysisContext;
     context.setContents(source, newContent);
     CompilationUnit newUnit = context.parseCompilationUnit(source);
@@ skipping 807 matching lines @@
     VariableElement element1 = ElementFactory.localVariableElement(AstFactory.identifier3("v1"));
     VariableElement element2 = ElementFactory.localVariableElement(AstFactory.identifier3("v2"));
     outerScope.define(element1);
     innerScope.define(element2);
     listener.assertNoErrors();
   }
 }
 
 class ErrorResolverTest extends ResolverTestCase {
   void test_breakLabelOnSwitchMember() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  void m(int i) {",
-        "    switch (i) {",
-        "      l: case 0:",
-        "        break;",
-        "      case 1:",
-        "        break l;",
-        "    }",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  void m(int i) {
+    switch (i) {
+      l: case 0:
+        break;
+      case 1:
+        break l;
+    }
+  }
+}''');
     resolve(source);
     assertErrors(source, [ResolverErrorCode.BREAK_LABEL_ON_SWITCH_MEMBER]);
     verify([source]);
   }
 
   void test_continueLabelOnSwitch() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  void m(int i) {",
-        "    l: switch (i) {",
-        "      case 0:",
-        "        continue l;",
-        "    }",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  void m(int i) {
+    l: switch (i) {
+      case 0:
+        continue l;
+    }
+  }
+}''');
     resolve(source);
     assertErrors(source, [ResolverErrorCode.CONTINUE_LABEL_ON_SWITCH]);
     verify([source]);
   }
 
   void test_enclosingElement_invalidLocalFunction() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class C {",
-        "  C() {",
-        "    int get x => 0;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class C {
+  C() {
+    int get x => 0;
+  }
+}''');
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     var unit = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     var types = unit.types;
     JUnitTestCase.assertNotNull(types);
     EngineTestCase.assertSizeOfList(1, types);
     var type = types[0];
     JUnitTestCase.assertNotNull(type);
     var constructors = type.constructors;
     JUnitTestCase.assertNotNull(constructors);
     EngineTestCase.assertSizeOfList(1, constructors);
     ConstructorElement constructor = constructors[0];
     JUnitTestCase.assertNotNull(constructor);
     List<FunctionElement> functions = constructor.functions;
     JUnitTestCase.assertNotNull(functions);
     EngineTestCase.assertSizeOfList(1, functions);
     JUnitTestCase.assertEquals(constructor, functions[0].enclosingElement);
     assertErrors(source, [ParserErrorCode.GETTER_IN_FUNCTION]);
   }
 }
 
 class HintCodeTest extends ResolverTestCase {
   void fail_deadCode_statementAfterRehrow() {
-    Source source = addSource(EngineTestCase.createSource([
-        "f() {",
-        "  try {",
-        "    var one = 1;",
-        "  } catch (e) {",
-        "    rethrow;",
-        "    var two = 2;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+f() {
+  try {
+    var one = 1;
+  } catch (e) {
+    rethrow;
+    var two = 2;
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void fail_deadCode_statementAfterThrow() {
-    Source source = addSource(EngineTestCase.createSource([
-        "f() {",
-        "  var one = 1;",
-        "  throw 'Stop here';",
-        "  var two = 2;",
-        "}"]));
+    Source source = addSource(r'''
+f() {
+  var one = 1;
+  throw 'Stop here';
+  var two = 2;
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void fail_isInt() {
-    Source source = addSource(EngineTestCase.createSource(["var v = 1 is int;"]));
+    Source source = addSource("var v = 1 is int;");
     resolve(source);
     assertErrors(source, [HintCode.IS_INT]);
     verify([source]);
   }
 
   void fail_isNotInt() {
-    Source source = addSource(EngineTestCase.createSource(["var v = 1 is! int;"]));
+    Source source = addSource("var v = 1 is! int;");
     resolve(source);
     assertErrors(source, [HintCode.IS_NOT_INT]);
     verify([source]);
   }
 
   void fail_overrideEqualsButNotHashCode() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  bool operator ==(x) {}", "}"]));
+    Source source = addSource(r'''
+class A {
+  bool operator ==(x) {}
+}''');
     resolve(source);
     assertErrors(source, [HintCode.OVERRIDE_EQUALS_BUT_NOT_HASH_CODE]);
     verify([source]);
   }
 
   void fail_unusedImport_as_equalPrefixes() {
     // See todo at ImportsVerifier.prefixElementMap.
-    Source source = addSource(EngineTestCase.createSource([
-        "library L;",
-        "import 'lib1.dart' as one;",
-        "import 'lib2.dart' as one;",
-        "one.A a;"]));
-    Source source2 = addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}"]));
-    Source source3 = addNamedSource("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class B {}"]));
+    Source source = addSource(r'''
+library L;
+import 'lib1.dart' as one;
+import 'lib2.dart' as one;
+one.A a;''');
+    Source source2 = addNamedSource("/lib1.dart", r'''
+library lib1;
+class A {}''');
+    Source source3 = addNamedSource("/lib2.dart", r'''
+library lib2;
+class B {}''');
     resolve(source);
     assertErrors(source, [HintCode.UNUSED_IMPORT]);
     assertNoErrors(source2);
     assertNoErrors(source3);
     verify([source, source2, source3]);
   }
 
   void test_argumentTypeNotAssignable_functionType() {
-    Source source = addSource(EngineTestCase.createSource([
-        "m() {",
-        "  var a = new A();",
-        "  a.n(() => 0);",
-        "}",
-        "class A {",
-        "  n(void f(int i)) {}",
-        "}"]));
+    Source source = addSource(r'''
+m() {
+  var a = new A();
+  a.n(() => 0);
+}
+class A {
+  n(void f(int i)) {}
+}''');
     resolve(source);
     assertErrors(source, [HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
 
   void test_argumentTypeNotAssignable_message() {
     // The implementation of HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE assumes that
     // StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE has the same message.
     JUnitTestCase.assertEquals(HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE.message, StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE.message);
   }
 
   void test_argumentTypeNotAssignable_type() {
-    Source source = addSource(EngineTestCase.createSource(["m() {", "  var i = '';", "  n(i);", "}", "n(int i) {}"]));
+    Source source = addSource(r'''
+m() {
+  var i = '';
+  n(i);
+}
+n(int i) {}''');
     resolve(source);
     assertErrors(source, [HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
 
   void test_argumentTypeNotAssignable_unionTypeMethodMerge() {
     enableUnionTypes(false);
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  int m(int x) => 0;",
-        "}",
-        "class B {",
-        "  String m(String x) => '0';",
-        "}",
-        "f(A a, B b) {",
-        "  var ab;",
-        "  if (0 < 1) {",
-        "    ab = a;",
-        "  } else {",
-        "    ab = b;",
-        "  }",
-        "  ab.m(0.5);",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  int m(int x) => 0;
+}
+class B {
+  String m(String x) => '0';
+}
+f(A a, B b) {
+  var ab;
+  if (0 < 1) {
+    ab = a;
+  } else {
+    ab = b;
+  }
+  ab.m(0.5);
+}''');
     resolve(source);
     assertErrors(source, [HintCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_conditionalElse() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  true ? 1 : 2;", "}"]));
+    Source source = addSource(r'''
+f() {
+  true ? 1 : 2;
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_conditionalElse_nested() {
     // test that a dead else-statement can't generate additional violations
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  true ? true : false && false;", "}"]));
+    Source source = addSource(r'''
+f() {
+  true ? true : false && false;
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_conditionalIf() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  false ? 1 : 2;", "}"]));
+    Source source = addSource(r'''
+f() {
+  false ? 1 : 2;
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_conditionalIf_nested() {
     // test that a dead then-statement can't generate additional violations
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  false ? false && false : true;", "}"]));
+    Source source = addSource(r'''
+f() {
+  false ? false && false : true;
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_else() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  if(true) {} else {}", "}"]));
+    Source source = addSource(r'''
+f() {
+  if(true) {} else {}
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_else_nested() {
     // test that a dead else-statement can't generate additional violations
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  if(true) {} else {if (false) {}}", "}"]));
+    Source source = addSource(r'''
+f() {
+  if(true) {} else {if (false) {}}
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_if() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  if(false) {}", "}"]));
+    Source source = addSource(r'''
+f() {
+  if(false) {}
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_if_nested() {
     // test that a dead then-statement can't generate additional violations
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  if(false) {if(false) {}}", "}"]));
+    Source source = addSource(r'''
+f() {
+  if(false) {if(false) {}}
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_while() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  while(false) {}", "}"]));
+    Source source = addSource(r'''
+f() {
+  while(false) {}
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_while_nested() {
     // test that a dead while body can't generate additional violations
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  while(false) {if(false) {}}", "}"]));
+    Source source = addSource(r'''
+f() {
+  while(false) {if(false) {}}
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadCatch_catchFollowingCatch() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "f() {",
-        "  try {} catch (e) {} catch (e) {}",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+f() {
+  try {} catch (e) {} catch (e) {}
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH]);
     verify([source]);
   }
 
   void test_deadCode_deadCatch_catchFollowingCatch_nested() {
     // test that a dead catch clause can't generate additional violations
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "f() {",
-        "  try {} catch (e) {} catch (e) {if(false) {}}",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+f() {
+  try {} catch (e) {} catch (e) {if(false) {}}
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH]);
     verify([source]);
   }
 
   void test_deadCode_deadCatch_catchFollowingCatch_object() {
-    Source source = addSource(EngineTestCase.createSource([
-        "f() {",
-        "  try {} on Object catch (e) {} catch (e) {}",
-        "}"]));
+    Source source = addSource(r'''
+f() {
+  try {} on Object catch (e) {} catch (e) {}
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH]);
     verify([source]);
   }
 
   void test_deadCode_deadCatch_catchFollowingCatch_object_nested() {
     // test that a dead catch clause can't generate additional violations
-    Source source = addSource(EngineTestCase.createSource([
-        "f() {",
-        "  try {} on Object catch (e) {} catch (e) {if(false) {}}",
-        "}"]));
+    Source source = addSource(r'''
+f() {
+  try {} on Object catch (e) {} catch (e) {if(false) {}}
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE_CATCH_FOLLOWING_CATCH]);
     verify([source]);
   }
 
   void test_deadCode_deadCatch_onCatchSubtype() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "class B extends A {}",
-        "f() {",
-        "  try {} on A catch (e) {} on B catch (e) {}",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+class B extends A {}
+f() {
+  try {} on A catch (e) {} on B catch (e) {}
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE_ON_CATCH_SUBTYPE]);
     verify([source]);
   }
 
   void test_deadCode_deadCatch_onCatchSubtype_nested() {
     // test that a dead catch clause can't generate additional violations
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "class B extends A {}",
-        "f() {",
-        "  try {} on A catch (e) {} on B catch (e) {if(false) {}}",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+class B extends A {}
+f() {
+  try {} on A catch (e) {} on B catch (e) {if(false) {}}
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE_ON_CATCH_SUBTYPE]);
     verify([source]);
   }
 
   void test_deadCode_deadOperandLHS_and() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  bool b = false && false;", "}"]));
+    Source source = addSource(r'''
+f() {
+  bool b = false && false;
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadOperandLHS_and_nested() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  bool b = false && (false && false);", "}"]));
+    Source source = addSource(r'''
+f() {
+  bool b = false && (false && false);
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadOperandLHS_or() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  bool b = true || true;", "}"]));
+    Source source = addSource(r'''
+f() {
+  bool b = true || true;
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_deadOperandLHS_or_nested() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  bool b = true || (false && false);", "}"]));
+    Source source = addSource(r'''
+f() {
+  bool b = true || (false && false);
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_statementAfterBreak_inDefaultCase() {
-    Source source = addSource(EngineTestCase.createSource([
-        "f(v) {",
-        "  switch(v) {",
-        "    case 1:",
-        "    default:",
-        "      break;",
-        "      var a;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+f(v) {
+  switch(v) {
+    case 1:
+    default:
+      break;
+      var a;
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_statementAfterBreak_inForEachStatement() {
-    Source source = addSource(EngineTestCase.createSource([
-        "f() {",
-        "  var list;",
-        "  for(var l in list) {",
-        "    break;",
-        "    var a;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+f() {
+  var list;
+  for(var l in list) {
+    break;
+    var a;
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_statementAfterBreak_inForStatement() {
-    Source source = addSource(EngineTestCase.createSource([
-        "f() {",
-        "  for(;;) {",
-        "    break;",
-        "    var a;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+f() {
+  for(;;) {
+    break;
+    var a;
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_statementAfterBreak_inSwitchCase() {
-    Source source = addSource(EngineTestCase.createSource([
-        "f(v) {",
-        "  switch(v) {",
-        "    case 1:",
-        "      break;",
-        "      var a;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+f(v) {
+  switch(v) {
+    case 1:
+      break;
+      var a;
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_statementAfterBreak_inWhileStatement() {
-    Source source = addSource(EngineTestCase.createSource([
-        "f(v) {",
-        "  while(v) {",
-        "    break;",
-        "    var a;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+f(v) {
+  while(v) {
+    break;
+    var a;
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_statementAfterContinue_inForEachStatement() {
-    Source source = addSource(EngineTestCase.createSource([
-        "f() {",
-        "  var list;",
-        "  for(var l in list) {",
-        "    continue;",
-        "    var a;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+f() {
+  var list;
+  for(var l in list) {
+    continue;
+    var a;
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_statementAfterContinue_inForStatement() {
-    Source source = addSource(EngineTestCase.createSource([
-        "f() {",
-        "  for(;;) {",
-        "    continue;",
-        "    var a;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+f() {
+  for(;;) {
+    continue;
+    var a;
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_statementAfterContinue_inWhileStatement() {
-    Source source = addSource(EngineTestCase.createSource([
-        "f(v) {",
-        "  while(v) {",
-        "    continue;",
-        "    var a;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+f(v) {
+  while(v) {
+    continue;
+    var a;
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_statementAfterReturn_function() {
-    Source source = addSource(EngineTestCase.createSource([
-        "f() {",
-        "  var one = 1;",
-        "  return;",
-        "  var two = 2;",
-        "}"]));
+    Source source = addSource(r'''
+f() {
+  var one = 1;
+  return;
+  var two = 2;
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_statementAfterReturn_ifStatement() {
-    Source source = addSource(EngineTestCase.createSource([
-        "f(bool b) {",
-        "  if(b) {",
-        "    var one = 1;",
-        "    return;",
-        "    var two = 2;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+f(bool b) {
+  if(b) {
+    var one = 1;
+    return;
+    var two = 2;
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_statementAfterReturn_method() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  m() {",
-        "    var one = 1;",
-        "    return;",
-        "    var two = 2;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  m() {
+    var one = 1;
+    return;
+    var two = 2;
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_statementAfterReturn_nested() {
-    Source source = addSource(EngineTestCase.createSource([
-        "f() {",
-        "  var one = 1;",
-        "  return;",
-        "  if(false) {}",
-        "}"]));
+    Source source = addSource(r'''
+f() {
+  var one = 1;
+  return;
+  if(false) {}
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deadCode_statementAfterReturn_twoReturns() {
-    Source source = addSource(EngineTestCase.createSource([
-        "f() {",
-        "  var one = 1;",
-        "  return;",
-        "  var two = 2;",
-        "  return;",
-        "  var three = 3;",
-        "}"]));
+    Source source = addSource(r'''
+f() {
+  var one = 1;
+  return;
+  var two = 2;
+  return;
+  var three = 3;
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEAD_CODE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_assignment() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  @deprecated",
-        "  A operator+(A a) { return a; }",
-        "}",
-        "f(A a) {",
-        "  A b;",
-        "  a += b;",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  @deprecated
+  A operator+(A a) { return a; }
+}
+f(A a) {
+  A b;
+  a += b;
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_deprecated() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  @deprecated",
-        "  m() {}",
-        "  n() {m();}",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  @deprecated
+  m() {}
+  n() {m();}
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_Deprecated() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  @Deprecated('0.9')",
-        "  m() {}",
-        "  n() {m();}",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  @Deprecated('0.9')
+  m() {}
+  n() {m();}
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_deprecatedMethodCalledOnUnionType() {
     enableUnionTypes(false);
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  @deprecated f() => 0;",
-        "}",
-        "class B extends A {}",
-        "main(A a, B b) {",
-        "  var x;",
-        "  if (0 < 1) {",
-        "    x = a;",
-        "  } else {",
-        "    x = b;",
-        "  }",
-        "  x.f(); // Here [x] has type [{A,B}] but we still want the deprecation warning.",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  @deprecated f() => 0;
+}
+class B extends A {}
+main(A a, B b) {
+  var x;
+  if (0 < 1) {
+    x = a;
+  } else {
+    x = b;
+  }
+  x.f(); // Here [x] has type [{A,B}] but we still want the deprecation warning.
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_export() {
-    Source source = addSource(EngineTestCase.createSource(["export 'deprecated_library.dart';"]));
-    addNamedSource("/deprecated_library.dart", EngineTestCase.createSource([
-        "@deprecated",
-        "library deprecated_library;",
-        "class A {}"]));
+    Source source = addSource("export 'deprecated_library.dart';");
+    addNamedSource("/deprecated_library.dart", r'''
+@deprecated
+library deprecated_library;
+class A {}''');
     resolve(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_getter() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  @deprecated",
-        "  get m => 1;",
-        "}",
-        "f(A a) {",
-        "  return a.m;",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  @deprecated
+  get m => 1;
+}
+f(A a) {
+  return a.m;
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_import() {
-    Source source = addSource(EngineTestCase.createSource(["import 'deprecated_library.dart';", "f(A a) {}"]));
-    addNamedSource("/deprecated_library.dart", EngineTestCase.createSource([
-        "@deprecated",
-        "library deprecated_library;",
-        "class A {}"]));
+    Source source = addSource(r'''
+import 'deprecated_library.dart';
+f(A a) {}''');
+    addNamedSource("/deprecated_library.dart", r'''
+@deprecated
+library deprecated_library;
+class A {}''');
     resolve(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_indexExpression() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  @deprecated",
-        "  operator[](int i) {}",
-        "}",
-        "f(A a) {",
-        "  return a[1];",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  @deprecated
+  operator[](int i) {}
+}
+f(A a) {
+  return a[1];
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_instanceCreation() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  @deprecated",
-        "  A(int i) {}",
-        "}",
-        "f() {",
-        "  A a = new A(1);",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  @deprecated
+  A(int i) {}
+}
+f() {
+  A a = new A(1);
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_instanceCreation_namedConstructor() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  @deprecated",
-        "  A.named(int i) {}",
-        "}",
-        "f() {",
-        "  A a = new A.named(1);",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  @deprecated
+  A.named(int i) {}
+}
+f() {
+  A a = new A.named(1);
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_operator() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  @deprecated",
-        "  operator+(A a) {}",
-        "}",
-        "f(A a) {",
-        "  A b;",
-        "  return a + b;",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  @deprecated
+  operator+(A a) {}
+}
+f(A a) {
+  A b;
+  return a + b;
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_setter() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  @deprecated",
-        "  set s(v) {}",
-        "}",
-        "f(A a) {",
-        "  return a.s = 1;",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  @deprecated
+  set s(v) {}
+}
+f(A a) {
+  return a.s = 1;
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_superConstructor() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  @deprecated",
-        "  A() {}",
-        "}",
-        "class B extends A {",
-        "  B() : super() {}",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  @deprecated
+  A() {}
+}
+class B extends A {
+  B() : super() {}
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_deprecatedAnnotationUse_superConstructor_namedConstructor() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  @deprecated",
-        "  A.named() {}",
-        "}",
-        "class B extends A {",
-        "  B() : super.named() {}",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  @deprecated
+  A.named() {}
+}
+class B extends A {
+  B() : super.named() {}
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DEPRECATED_MEMBER_USE]);
     verify([source]);
   }
 
   void test_divisionOptimization_double() {
-    Source source = addSource(EngineTestCase.createSource([
-        "f(double x, double y) {",
-        "  var v = (x / y).toInt();",
-        "}"]));
+    Source source = addSource(r'''
+f(double x, double y) {
+  var v = (x / y).toInt();
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DIVISION_OPTIMIZATION]);
     verify([source]);
   }
 
   void test_divisionOptimization_int() {
-    Source source = addSource(EngineTestCase.createSource(["f(int x, int y) {", "  var v = (x / y).toInt();", "}"]));
+    Source source = addSource(r'''
+f(int x, int y) {
+  var v = (x / y).toInt();
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DIVISION_OPTIMIZATION]);
     verify([source]);
   }
 
   void test_divisionOptimization_propagatedType() {
     // Tests the propagated type information of the '/' method
-    Source source = addSource(EngineTestCase.createSource([
-        "f(x, y) {",
-        "  x = 1;",
-        "  y = 1;",
-        "  var v = (x / y).toInt();",
-        "}"]));
+    Source source = addSource(r'''
+f(x, y) {
+  x = 1;
+  y = 1;
+  var v = (x / y).toInt();
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DIVISION_OPTIMIZATION]);
     verify([source]);
   }
 
   void test_divisionOptimization_wrappedBinaryExpression() {
-    Source source = addSource(EngineTestCase.createSource([
-        "f(int x, int y) {",
-        "  var v = (((x / y))).toInt();",
-        "}"]));
+    Source source = addSource(r'''
+f(int x, int y) {
+  var v = (((x / y))).toInt();
+}''');
     resolve(source);
     assertErrors(source, [HintCode.DIVISION_OPTIMIZATION]);
     verify([source]);
   }
 
   void test_duplicateImport() {
-    Source source = addSource(EngineTestCase.createSource([
-        "library L;",
-        "import 'lib1.dart';",
-        "import 'lib1.dart';",
-        "A a;"]));
-    addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}"]));
+    Source source = addSource(r'''
+library L;
+import 'lib1.dart';
+import 'lib1.dart';
+A a;''');
+    addNamedSource("/lib1.dart", r'''
+library lib1;
+class A {}''');
     resolve(source);
     assertErrors(source, [HintCode.DUPLICATE_IMPORT]);
     verify([source]);
   }
 
   void test_duplicateImport2() {
-    Source source = addSource(EngineTestCase.createSource([
-        "library L;",
-        "import 'lib1.dart';",
-        "import 'lib1.dart';",
-        "import 'lib1.dart';",
-        "A a;"]));
-    addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}"]));
+    Source source = addSource(r'''
+library L;
+import 'lib1.dart';
+import 'lib1.dart';
+import 'lib1.dart';
+A a;''');
+    addNamedSource("/lib1.dart", r'''
+library lib1;
+class A {}''');
     resolve(source);
     assertErrors(source, [HintCode.DUPLICATE_IMPORT, HintCode.DUPLICATE_IMPORT]);
     verify([source]);
   }
 
   void test_duplicateImport3() {
-    Source source = addSource(EngineTestCase.createSource([
-        "library L;",
-        "import 'lib1.dart' as M show A hide B;",
-        "import 'lib1.dart' as M show A hide B;",
-        "M.A a;"]));
-    addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}", "class B {}"]));
+    Source source = addSource(r'''
+library L;
+import 'lib1.dart' as M show A hide B;
+import 'lib1.dart' as M show A hide B;
+M.A a;''');
+    addNamedSource("/lib1.dart", r'''
+library lib1;
+class A {}
+class B {}''');
     resolve(source);
     assertErrors(source, [HintCode.DUPLICATE_IMPORT]);
     verify([source]);
   }
 
   void test_importDeferredLibraryWithLoadFunction() {
     resolveWithAndWithoutExperimental(<String> [
-        EngineTestCase.createSource(["library lib1;", "loadLibrary() {}", "f() {}"]),
-        EngineTestCase.createSource([
-        "library root;",
-        "import 'lib1.dart' deferred as lib1;",
-        "main() { lib1.f(); }"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [HintCode.IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION]);
+        r'''
+library lib1;
+loadLibrary() {}
+f() {}''',
+        r'''
+library root;
+import 'lib1.dart' deferred as lib1;
+main() { lib1.f(); }'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [HintCode.IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION]);
   }
 
   void test_invalidAssignment_instanceVariable() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  int x;",
-        "}",
-        "f(var y) {",
-        "  A a;",
-        "  if(y is String) {",
-        "    a.x = y;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  int x;
+}
+f(var y) {
+  A a;
+  if(y is String) {
+    a.x = y;
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
 
   void test_invalidAssignment_localVariable() {
-    Source source = addSource(EngineTestCase.createSource([
-        "f(var y) {",
-        "  if(y is String) {",
-        "    int x = y;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+f(var y) {
+  if(y is String) {
+    int x = y;
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
 
   void test_invalidAssignment_message() {
     // The implementation of HintCode.INVALID_ASSIGNMENT assumes that
     // StaticTypeWarningCode.INVALID_ASSIGNMENT has the same message.
     JUnitTestCase.assertEquals(HintCode.INVALID_ASSIGNMENT.message, StaticTypeWarningCode.INVALID_ASSIGNMENT.message);
   }
 
   void test_invalidAssignment_staticVariable() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  static int x;",
-        "}",
-        "f(var y) {",
-        "  if(y is String) {",
-        "    A.x = y;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  static int x;
+}
+f(var y) {
+  if(y is String) {
+    A.x = y;
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
 
   void test_invalidAssignment_variableDeclaration() {
     // 17971
-    Source source = addSource(EngineTestCase.createSource([
-        "class Point {",
-        "  final num x, y;",
-        "  Point(this.x, this.y);",
-        "  Point operator +(Point other) {",
-        "    return new Point(x+other.x, y+other.y);",
-        "  }",
-        "}",
-        "main() {",
-        "  var p1 = new Point(0, 0);",
-        "  var p2 = new Point(10, 10);",
-        "  int n = p1 + p2;",
-        "}"]));
+    Source source = addSource(r'''
+class Point {
+  final num x, y;
+  Point(this.x, this.y);
+  Point operator +(Point other) {
+    return new Point(x+other.x, y+other.y);
+  }
+}
+main() {
+  var p1 = new Point(0, 0);
+  var p2 = new Point(10, 10);
+  int n = p1 + p2;
+}''');
     resolve(source);
     assertErrors(source, [HintCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
 
   void test_isDouble() {
-    Source source = addSource(EngineTestCase.createSource(["var v = 1 is double;"]));
+    Source source = addSource("var v = 1 is double;");
     resolve(source);
     assertErrors(source, [HintCode.IS_DOUBLE]);
     verify([source]);
   }
 
   void test_isNotDouble() {
-    Source source = addSource(EngineTestCase.createSource(["var v = 1 is! double;"]));
+    Source source = addSource("var v = 1 is! double;");
     resolve(source);
     assertErrors(source, [HintCode.IS_NOT_DOUBLE]);
     verify([source]);
   }
 
   void test_missingReturn_function() {
-    Source source = addSource(EngineTestCase.createSource(["int f() {}"]));
+    Source source = addSource("int f() {}");
     resolve(source);
     assertErrors(source, [HintCode.MISSING_RETURN]);
     verify([source]);
   }
 
   void test_missingReturn_method() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  int m() {}", "}"]));
+    Source source = addSource(r'''
+class A {
+  int m() {}
+}''');
     resolve(source);
     assertErrors(source, [HintCode.MISSING_RETURN]);
     verify([source]);
   }
 
   void test_overrideOnNonOverridingGetter_invalid() {
-    Source source = addSource(EngineTestCase.createSource([
-        "library dart.core;",
-        "const override = null;",
-        "class A {",
-        "}",
-        "class B extends A {",
-        "  @override",
-        "  int get m => 1;",
-        "}"]));
+    Source source = addSource(r'''
+library dart.core;
+const override = null;
+class A {
+}
+class B extends A {
+  @override
+  int get m => 1;
+}''');
     resolve(source);
     assertErrors(source, [HintCode.OVERRIDE_ON_NON_OVERRIDING_GETTER]);
     verify([source]);
   }
 
   void test_overrideOnNonOverridingMethod_invalid() {
-    Source source = addSource(EngineTestCase.createSource([
-        "library dart.core;",
-        "const override = null;",
-        "class A {",
-        "}",
-        "class B extends A {",
-        "  @override",
-        "  int m() => 1;",
-        "}"]));
+    Source source = addSource(r'''
+library dart.core;
+const override = null;
+class A {
+}
+class B extends A {
+  @override
+  int m() => 1;
+}''');
     resolve(source);
     assertErrors(source, [HintCode.OVERRIDE_ON_NON_OVERRIDING_METHOD]);
     verify([source]);
   }
 
   void test_overrideOnNonOverridingSetter_invalid() {
-    Source source = addSource(EngineTestCase.createSource([
-        "library dart.core;",
-        "const override = null;",
-        "class A {",
-        "}",
-        "class B extends A {",
-        "  @override",
-        "  set m(int x) {}",
-        "}"]));
+    Source source = addSource(r'''
+library dart.core;
+const override = null;
+class A {
+}
+class B extends A {
+  @override
+  set m(int x) {}
+}''');
     resolve(source);
     assertErrors(source, [HintCode.OVERRIDE_ON_NON_OVERRIDING_SETTER]);
     verify([source]);
   }
 
   void test_typeCheck_type_is_Null() {
-    Source source = addSource(EngineTestCase.createSource(["m(i) {", "  bool b = i is Null;", "}"]));
+    Source source = addSource(r'''
+m(i) {
+  bool b = i is Null;
+}''');
     resolve(source);
     assertErrors(source, [HintCode.TYPE_CHECK_IS_NULL]);
     verify([source]);
   }
 
   void test_typeCheck_type_not_Null() {
-    Source source = addSource(EngineTestCase.createSource(["m(i) {", "  bool b = i is! Null;", "}"]));
+    Source source = addSource(r'''
+m(i) {
+  bool b = i is! Null;
+}''');
     resolve(source);
     assertErrors(source, [HintCode.TYPE_CHECK_IS_NOT_NULL]);
     verify([source]);
   }
 
   void test_undefinedGetter() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "f(var a) {",
-        "  if(a is A) {",
-        "    return a.m;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+f(var a) {
+  if(a is A) {
+    return a.m;
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.UNDEFINED_GETTER]);
   }
 
   void test_undefinedGetter_message() {
     // The implementation of HintCode.UNDEFINED_SETTER assumes that UNDEFINED_SETTER in
     // StaticTypeWarningCode and StaticWarningCode are the same, this verifies that assumption.
     JUnitTestCase.assertEquals(StaticTypeWarningCode.UNDEFINED_GETTER.message, StaticWarningCode.UNDEFINED_GETTER.message);
   }
 
   void test_undefinedMethod() {
-    Source source = addSource(EngineTestCase.createSource([
-        "f() {",
-        "  var a = 'str';",
-        "  a.notAMethodOnString();",
-        "}"]));
+    Source source = addSource(r'''
+f() {
+  var a = 'str';
+  a.notAMethodOnString();
+}''');
     resolve(source);
     assertErrors(source, [HintCode.UNDEFINED_METHOD]);
   }
 
   void test_undefinedMethod_assignmentExpression() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "class B {",
-        "  f(var a, var a2) {",
-        "    a = new A();",
-        "    a2 = new A();",
-        "    a += a2;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+class B {
+  f(var a, var a2) {
+    a = new A();
+    a2 = new A();
+    a += a2;
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.UNDEFINED_METHOD]);
   }
 
   void test_undefinedMethod_unionType_noSuchMethod() {
     enableUnionTypes(false);
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  int m(int x) => 0;",
-        "}",
-        "class B {",
-        "  String m() => '0';",
-        "}",
-        "f(A a, B b) {",
-        "  var ab;",
-        "  if (0 < 1) {",
-        "    ab = a;",
-        "  } else {",
-        "    ab = b;",
-        "  }",
-        "  ab.n();",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  int m(int x) => 0;
+}
+class B {
+  String m() => '0';
+}
+f(A a, B b) {
+  var ab;
+  if (0 < 1) {
+    ab = a;
+  } else {
+    ab = b;
+  }
+  ab.n();
+}''');
     resolve(source);
     assertErrors(source, [HintCode.UNDEFINED_METHOD]);
   }
 
   void test_undefinedOperator_binaryExpression() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "f(var a) {",
-        "  if(a is A) {",
-        "    a + 1;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+f(var a) {
+  if(a is A) {
+    a + 1;
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.UNDEFINED_OPERATOR]);
   }
 
   void test_undefinedOperator_indexBoth() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "f(var a) {",
-        "  if(a is A) {",
-        "    a[0]++;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+f(var a) {
+  if(a is A) {
+    a[0]++;
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.UNDEFINED_OPERATOR]);
   }
 
   void test_undefinedOperator_indexGetter() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "f(var a) {",
-        "  if(a is A) {",
-        "    a[0];",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+f(var a) {
+  if(a is A) {
+    a[0];
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.UNDEFINED_OPERATOR]);
   }
 
   void test_undefinedOperator_indexSetter() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "f(var a) {",
-        "  if(a is A) {",
-        "    a[0] = 1;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+f(var a) {
+  if(a is A) {
+    a[0] = 1;
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.UNDEFINED_OPERATOR]);
   }
 
   void test_undefinedOperator_postfixExpression() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "f(var a) {",
-        "  if(a is A) {",
-        "    a++;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+f(var a) {
+  if(a is A) {
+    a++;
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.UNDEFINED_OPERATOR]);
   }
 
   void test_undefinedOperator_prefixExpression() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "f(var a) {",
-        "  if(a is A) {",
-        "    ++a;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+f(var a) {
+  if(a is A) {
+    ++a;
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.UNDEFINED_OPERATOR]);
   }
 
   void test_undefinedSetter() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "f(var a) {",
-        "  if(a is A) {",
-        "    a.m = 0;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+f(var a) {
+  if(a is A) {
+    a.m = 0;
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.UNDEFINED_SETTER]);
   }
 
   void test_undefinedSetter_message() {
     // The implementation of HintCode.UNDEFINED_SETTER assumes that UNDEFINED_SETTER in
     // StaticTypeWarningCode and StaticWarningCode are the same, this verifies that assumption.
     JUnitTestCase.assertEquals(StaticTypeWarningCode.UNDEFINED_SETTER.message, StaticWarningCode.UNDEFINED_SETTER.message);
   }
 
   void test_unnecessaryCast_type_supertype() {
-    Source source = addSource(EngineTestCase.createSource(["m(int i) {", "  var b = i as Object;", "}"]));
+    Source source = addSource(r'''
+m(int i) {
+  var b = i as Object;
+}''');
     resolve(source);
     assertErrors(source, [HintCode.UNNECESSARY_CAST]);
     verify([source]);
   }
 
   void test_unnecessaryCast_type_type() {
-    Source source = addSource(EngineTestCase.createSource(["m(num i) {", "  var b = i as num;", "}"]));
+    Source source = addSource(r'''
+m(num i) {
+  var b = i as num;
+}''');
     resolve(source);
     assertErrors(source, [HintCode.UNNECESSARY_CAST]);
     verify([source]);
   }
 
   void test_unnecessaryTypeCheck_null_is_Null() {
-    Source source = addSource(EngineTestCase.createSource(["bool b = null is Null;"]));
+    Source source = addSource("bool b = null is Null;");
     resolve(source);
     assertErrors(source, [HintCode.UNNECESSARY_TYPE_CHECK_TRUE]);
     verify([source]);
   }
 
   void test_unnecessaryTypeCheck_null_not_Null() {
-    Source source = addSource(EngineTestCase.createSource(["bool b = null is! Null;"]));
+    Source source = addSource("bool b = null is! Null;");
     resolve(source);
     assertErrors(source, [HintCode.UNNECESSARY_TYPE_CHECK_FALSE]);
     verify([source]);
   }
 
   void test_unnecessaryTypeCheck_type_is_dynamic() {
-    Source source = addSource(EngineTestCase.createSource(["m(i) {", "  bool b = i is dynamic;", "}"]));
+    Source source = addSource(r'''
+m(i) {
+  bool b = i is dynamic;
+}''');
     resolve(source);
     assertErrors(source, [HintCode.UNNECESSARY_TYPE_CHECK_TRUE]);
     verify([source]);
   }
 
   void test_unnecessaryTypeCheck_type_is_object() {
-    Source source = addSource(EngineTestCase.createSource(["m(i) {", "  bool b = i is Object;", "}"]));
+    Source source = addSource(r'''
+m(i) {
+  bool b = i is Object;
+}''');
     resolve(source);
     assertErrors(source, [HintCode.UNNECESSARY_TYPE_CHECK_TRUE]);
     verify([source]);
   }
 
   void test_unnecessaryTypeCheck_type_not_dynamic() {
-    Source source = addSource(EngineTestCase.createSource(["m(i) {", "  bool b = i is! dynamic;", "}"]));
+    Source source = addSource(r'''
+m(i) {
+  bool b = i is! dynamic;
+}''');
     resolve(source);
     assertErrors(source, [HintCode.UNNECESSARY_TYPE_CHECK_FALSE]);
     verify([source]);
   }
 
   void test_unnecessaryTypeCheck_type_not_object() {
-    Source source = addSource(EngineTestCase.createSource(["m(i) {", "  bool b = i is! Object;", "}"]));
+    Source source = addSource(r'''
+m(i) {
+  bool b = i is! Object;
+}''');
     resolve(source);
     assertErrors(source, [HintCode.UNNECESSARY_TYPE_CHECK_FALSE]);
     verify([source]);
   }
 
   void test_unusedImport() {
-    Source source = addSource(EngineTestCase.createSource(["library L;", "import 'lib1.dart';"]));
-    Source source2 = addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;"]));
+    Source source = addSource(r'''
+library L;
+import 'lib1.dart';''');
+    Source source2 = addNamedSource("/lib1.dart", "library lib1;");
     resolve(source);
     assertErrors(source, [HintCode.UNUSED_IMPORT]);
     assertNoErrors(source2);
     verify([source, source2]);
   }
 
   void test_unusedImport_as() {
-    Source source = addSource(EngineTestCase.createSource([
-        "library L;",
-        "import 'lib1.dart';",
-        "import 'lib1.dart' as one;",
-        "one.A a;"]));
-    Source source2 = addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}"]));
+    Source source = addSource(r'''
+library L;
+import 'lib1.dart';
+import 'lib1.dart' as one;
+one.A a;''');
+    Source source2 = addNamedSource("/lib1.dart", r'''
+library lib1;
+class A {}''');
     resolve(source);
     assertErrors(source, [HintCode.UNUSED_IMPORT]);
     assertNoErrors(source2);
     verify([source, source2]);
   }
 
   void test_unusedImport_hide() {
-    Source source = addSource(EngineTestCase.createSource([
-        "library L;",
-        "import 'lib1.dart';",
-        "import 'lib1.dart' hide A;",
-        "A a;"]));
-    Source source2 = addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}"]));
+    Source source = addSource(r'''
+library L;
+import 'lib1.dart';
+import 'lib1.dart' hide A;
+A a;''');
+    Source source2 = addNamedSource("/lib1.dart", r'''
+library lib1;
+class A {}''');
     resolve(source);
     assertErrors(source, [HintCode.UNUSED_IMPORT]);
     assertNoErrors(source2);
     verify([source, source2]);
   }
 
   void test_unusedImport_show() {
-    Source source = addSource(EngineTestCase.createSource([
-        "library L;",
-        "import 'lib1.dart' show A;",
-        "import 'lib1.dart' show B;",
-        "A a;"]));
-    Source source2 = addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}", "class B {}"]));
+    Source source = addSource(r'''
+library L;
+import 'lib1.dart' show A;
+import 'lib1.dart' show B;
+A a;''');
+    Source source2 = addNamedSource("/lib1.dart", r'''
+library lib1;
+class A {}
+class B {}''');
     resolve(source);
     assertErrors(source, [HintCode.UNUSED_IMPORT]);
     assertNoErrors(source2);
     verify([source, source2]);
   }
 
   void test_useOfVoidResult_assignmentExpression_function() {
-    Source source = addSource(EngineTestCase.createSource([
-        "void f() {}",
-        "class A {",
-        "  n() {",
-        "    var a;",
-        "    a = f();",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+void f() {}
+class A {
+  n() {
+    var a;
+    a = f();
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.USE_OF_VOID_RESULT]);
     verify([source]);
   }
 
   void test_useOfVoidResult_assignmentExpression_method() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  void m() {}",
-        "  n() {",
-        "    var a;",
-        "    a = m();",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  void m() {}
+  n() {
+    var a;
+    a = m();
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.USE_OF_VOID_RESULT]);
     verify([source]);
   }
 
   void test_useOfVoidResult_inForLoop() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  void m() {}",
-        "  n() {",
-        "    for(var a = m();;) {}",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  void m() {}
+  n() {
+    for(var a = m();;) {}
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.USE_OF_VOID_RESULT]);
     verify([source]);
   }
 
   void test_useOfVoidResult_variableDeclaration_function() {
-    Source source = addSource(EngineTestCase.createSource([
-        "void f() {}",
-        "class A {",
-        "  n() {",
-        "    var a = f();",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+void f() {}
+class A {
+  n() {
+    var a = f();
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.USE_OF_VOID_RESULT]);
     verify([source]);
   }
 
   void test_useOfVoidResult_variableDeclaration_method() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  void m() {}",
-        "  n() {",
-        "    var a = m();",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  void m() {}
+  n() {
+    var a = m();
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.USE_OF_VOID_RESULT]);
     verify([source]);
   }
 
   void test_useOfVoidResult_variableDeclaration_method2() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  void m() {}",
-        "  n() {",
-        "    var a = m(), b = m();",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  void m() {}
+  n() {
+    var a = m(), b = m();
+  }
+}''');
     resolve(source);
     assertErrors(source, [HintCode.USE_OF_VOID_RESULT, HintCode.USE_OF_VOID_RESULT]);
     verify([source]);
   }
 }
 
 class IncrementalResolverTest extends ResolverTestCase {
   void test_resolve() {
-    MethodDeclaration method = _resolveMethod(EngineTestCase.createSource([
-        "class C {",
-        "  int m(int a) {",
-        "    return a + a;",
-        "  }",
-        "}"]));
+    MethodDeclaration method = _resolveMethod(r'''
+class C {
+  int m(int a) {
+    return a + a;
+  }
+}''');
     BlockFunctionBody body = method.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[0] as ReturnStatement;
     BinaryExpression expression = statement.expression as BinaryExpression;
     SimpleIdentifier left = expression.leftOperand as SimpleIdentifier;
     Element leftElement = left.staticElement;
     SimpleIdentifier right = expression.rightOperand as SimpleIdentifier;
     Element rightElement = right.staticElement;
     JUnitTestCase.assertNotNull(leftElement);
     JUnitTestCase.assertSame(leftElement, rightElement);
   }
@@ skipping 1030 matching lines @@
   @override
   void setUp() {
     SourceFactory sourceFactory = new SourceFactory([
         new DartUriResolver(DirectoryBasedDartSdk.defaultSdk),
         new FileUriResolver()]);
     _context = new AnalysisContextImpl();
     _context.sourceFactory = sourceFactory;
   }
 
   void test_accessorsAcrossFiles() {
-    Source librarySource = addSource("/lib.dart", EngineTestCase.createSource([
-        "library lib;",
-        "part 'first.dart';",
-        "part 'second.dart';"]));
-    addSource("/first.dart", EngineTestCase.createSource(["part of lib;", "int get V => 0;"]));
-    addSource("/second.dart", EngineTestCase.createSource(["part of lib;", "void set V(int v) {}"]));
+    Source librarySource = addSource("/lib.dart", r'''
+library lib;
+part 'first.dart';
+part 'second.dart';''');
+    addSource("/first.dart", r'''
+part of lib;
+int get V => 0;''');
+    addSource("/second.dart", r'''
+part of lib;
+void set V(int v) {}''');
     LibraryElement element = _buildLibrary(librarySource, []);
     JUnitTestCase.assertNotNull(element);
     List<CompilationUnitElement> sourcedUnits = element.parts;
     EngineTestCase.assertLength(2, sourcedUnits);
     List<PropertyAccessorElement> firstAccessors = sourcedUnits[0].accessors;
     EngineTestCase.assertLength(1, firstAccessors);
     List<PropertyAccessorElement> secondAccessors = sourcedUnits[1].accessors;
     EngineTestCase.assertLength(1, secondAccessors);
     JUnitTestCase.assertSame(firstAccessors[0].variable, secondAccessors[0].variable);
   }
@@ skipping 14 matching lines @@
     JUnitTestCase.assertEquals("lib.dart", unit.name);
     JUnitTestCase.assertEquals(element, unit.library);
     EngineTestCase.assertLength(0, unit.accessors);
     EngineTestCase.assertLength(0, unit.functions);
     EngineTestCase.assertLength(0, unit.functionTypeAliases);
     EngineTestCase.assertLength(0, unit.types);
     EngineTestCase.assertLength(0, unit.topLevelVariables);
   }
 
   void test_missingLibraryDirectiveWithPart() {
-    addSource("/a.dart", EngineTestCase.createSource(["part of lib;"]));
-    Source librarySource = addSource("/lib.dart", EngineTestCase.createSource(["part 'a.dart';"]));
+    addSource("/a.dart", "part of lib;");
+    Source librarySource = addSource("/lib.dart", "part 'a.dart';");
     LibraryElement element = _buildLibrary(librarySource, [ResolverErrorCode.MISSING_LIBRARY_DIRECTIVE_WITH_PART]);
     JUnitTestCase.assertNotNull(element);
   }
 
   void test_missingPartOfDirective() {
     addSource("/a.dart", "class A {}");
-    Source librarySource = addSource("/lib.dart", EngineTestCase.createSource(["library lib;", "", "part 'a.dart';"]));
+    Source librarySource = addSource("/lib.dart", r'''
+library lib;
+
+part 'a.dart';''');
     LibraryElement element = _buildLibrary(librarySource, [CompileTimeErrorCode.PART_OF_NON_PART]);
     JUnitTestCase.assertNotNull(element);
   }
 
   void test_multipleFiles() {
-    Source librarySource = addSource("/lib.dart", EngineTestCase.createSource([
-        "library lib;",
-        "part 'first.dart';",
-        "part 'second.dart';",
-        "",
-        "class A {}"]));
-    addSource("/first.dart", EngineTestCase.createSource(["part of lib;", "class B {}"]));
-    addSource("/second.dart", EngineTestCase.createSource(["part of lib;", "class C {}"]));
+    Source librarySource = addSource("/lib.dart", r'''
+library lib;
+part 'first.dart';
+part 'second.dart';
+
+class A {}''');
+    addSource("/first.dart", r'''
+part of lib;
+class B {}''');
+    addSource("/second.dart", r'''
+part of lib;
+class C {}''');
     LibraryElement element = _buildLibrary(librarySource, []);
     JUnitTestCase.assertNotNull(element);
     List<CompilationUnitElement> sourcedUnits = element.parts;
     EngineTestCase.assertLength(2, sourcedUnits);
     _assertTypes(element.definingCompilationUnit, ["A"]);
     if (sourcedUnits[0].name == "first.dart") {
       _assertTypes(sourcedUnits[0], ["B"]);
       _assertTypes(sourcedUnits[1], ["C"]);
     } else {
       _assertTypes(sourcedUnits[0], ["C"]);
       _assertTypes(sourcedUnits[1], ["B"]);
     }
   }
 
   void test_singleFile() {
-    Source librarySource = addSource("/lib.dart", EngineTestCase.createSource(["library lib;", "", "class A {}"]));
+    Source librarySource = addSource("/lib.dart", r'''
+library lib;
+
+class A {}''');
     LibraryElement element = _buildLibrary(librarySource, []);
     JUnitTestCase.assertNotNull(element);
     _assertTypes(element.definingCompilationUnit, ["A"]);
   }
 
   /**
    * Add a source file to the content provider. The file path should be absolute.
    *
    * @param filePath the path of the file being added
    * @param contents the contents to be returned by the content provider for the specified file
@@ skipping 205 matching lines @@
   Source _coreLibrarySource;
 
   @override
   void setUp() {
     super.setUp();
     _resolver = new LibraryResolver2(analysisContext2);
     _coreLibrarySource = analysisContext2.sourceFactory.forUri(DartSdk.DART_CORE);
   }
 
   void test_imports_relative() {
-    Source sourceA = addSource(EngineTestCase.createSource(["library libA;", "import 'libB.dart';", "class A {}"]));
-    Source sourceB = addNamedSource("/libB.dart", EngineTestCase.createSource(["library libB;", "import 'test.dart", "class B {}"]));
+    Source sourceA = addSource(r'''
+library libA;
+import 'libB.dart';
+class A {}''');
+    Source sourceB = addNamedSource("/libB.dart", r'''
+library libB;
+import 'test.dart
+class B {}''');
     List<ResolvableLibrary> cycle = new List<ResolvableLibrary>();
     ResolvableLibrary coreLib = _createResolvableLibrary(_coreLibrarySource);
     coreLib.libraryElement = analysisContext2.computeLibraryElement(_coreLibrarySource) as LibraryElementImpl;
     ResolvableLibrary libA = _createResolvableLibrary(sourceA);
     ResolvableLibrary libB = _createResolvableLibrary(sourceB);
     libA.importedLibraries = <ResolvableLibrary> [coreLib, libB];
     libB.importedLibraries = <ResolvableLibrary> [coreLib, libA];
     cycle.add(libA);
     cycle.add(libB);
     LibraryElement library = _resolver.resolveLibrary(sourceA, cycle);
@@ skipping 14 matching lines @@
 class LibraryResolverTest extends ResolverTestCase {
   LibraryResolver _resolver;
 
   @override
   void setUp() {
     super.setUp();
     _resolver = new LibraryResolver(analysisContext2);
   }
 
   void test_imports_dart_html() {
-    Source source = addSource(EngineTestCase.createSource(["library libA;", "import 'dart:html';", "class A {}"]));
+    Source source = addSource(r'''
+library libA;
+import 'dart:html';
+class A {}''');
     LibraryElement library = _resolver.resolveLibrary(source, true);
     List<LibraryElement> importedLibraries = library.importedLibraries;
     assertNamedElements(importedLibraries, ["dart.core", "dart.dom.html"]);
   }
 
   void test_imports_none() {
-    Source source = addSource(EngineTestCase.createSource(["library libA;", "class A {}"]));
+    Source source = addSource(r'''
+library libA;
+class A {}''');
     LibraryElement library = _resolver.resolveLibrary(source, true);
     List<LibraryElement> importedLibraries = library.importedLibraries;
     assertNamedElements(importedLibraries, ["dart.core"]);
   }
 
   void test_imports_relative() {
     addNamedSource("/libB.dart", "library libB;");
-    Source source = addSource(EngineTestCase.createSource(["library libA;", "import 'libB.dart';", "class A {}"]));
+    Source source = addSource(r'''
+library libA;
+import 'libB.dart';
+class A {}''');
     LibraryElement library = _resolver.resolveLibrary(source, true);
     List<LibraryElement> importedLibraries = library.importedLibraries;
     assertNamedElements(importedLibraries, ["dart.core", "libB"]);
   }
 }
 
 class LibraryScopeTest extends ResolverTestCase {
   void test_creation_empty() {
     LibraryElement definingLibrary = createDefaultTestLibrary();
     GatheringErrorListener errorListener = new GatheringErrorListener();
@@ skipping 171 matching lines @@
     MemberMap map = new MemberMap();
     JUnitTestCase.assertEquals(0, map.size);
     map.put(m1.name, m1);
     JUnitTestCase.assertEquals(1, map.size);
     JUnitTestCase.assertEquals(m1, map.get("m1"));
   }
 }
 
 class NonHintCodeTest extends ResolverTestCase {
   void test_deadCode_deadBlock_conditionalElse_debugConst() {
-    Source source = addSource(EngineTestCase.createSource([
-        "const bool DEBUG = true;",
-        "f() {",
-        "  DEBUG ? 1 : 2;",
-        "}"]));
+    Source source = addSource(r'''
+const bool DEBUG = true;
+f() {
+  DEBUG ? 1 : 2;
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_conditionalIf_debugConst() {
-    Source source = addSource(EngineTestCase.createSource([
-        "const bool DEBUG = false;",
-        "f() {",
-        "  DEBUG ? 1 : 2;",
-        "}"]));
+    Source source = addSource(r'''
+const bool DEBUG = false;
+f() {
+  DEBUG ? 1 : 2;
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_else() {
-    Source source = addSource(EngineTestCase.createSource([
-        "const bool DEBUG = true;",
-        "f() {",
-        "  if(DEBUG) {} else {}",
-        "}"]));
+    Source source = addSource(r'''
+const bool DEBUG = true;
+f() {
+  if(DEBUG) {} else {}
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_if_debugConst_prefixedIdentifier() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  static const bool DEBUG = false;",
-        "}",
-        "f() {",
-        "  if(A.DEBUG) {}",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  static const bool DEBUG = false;
+}
+f() {
+  if(A.DEBUG) {}
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_if_debugConst_prefixedIdentifier2() {
-    Source source = addSource(EngineTestCase.createSource([
-        "library L;",
-        "import 'lib2.dart';",
-        "f() {",
-        "  if(A.DEBUG) {}",
-        "}"]));
-    addNamedSource("/lib2.dart", EngineTestCase.createSource([
-        "library lib2;",
-        "class A {",
-        "  static const bool DEBUG = false;",
-        "}"]));
+    Source source = addSource(r'''
+library L;
+import 'lib2.dart';
+f() {
+  if(A.DEBUG) {}
+}''');
+    addNamedSource("/lib2.dart", r'''
+library lib2;
+class A {
+  static const bool DEBUG = false;
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_if_debugConst_propertyAccessor() {
-    Source source = addSource(EngineTestCase.createSource([
-        "library L;",
-        "import 'lib2.dart' as LIB;",
-        "f() {",
-        "  if(LIB.A.DEBUG) {}",
-        "}"]));
-    addNamedSource("/lib2.dart", EngineTestCase.createSource([
-        "library lib2;",
-        "class A {",
-        "  static const bool DEBUG = false;",
-        "}"]));
+    Source source = addSource(r'''
+library L;
+import 'lib2.dart' as LIB;
+f() {
+  if(LIB.A.DEBUG) {}
+}''');
+    addNamedSource("/lib2.dart", r'''
+library lib2;
+class A {
+  static const bool DEBUG = false;
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_if_debugConst_simpleIdentifier() {
-    Source source = addSource(EngineTestCase.createSource([
-        "const bool DEBUG = false;",
-        "f() {",
-        "  if(DEBUG) {}",
-        "}"]));
+    Source source = addSource(r'''
+const bool DEBUG = false;
+f() {
+  if(DEBUG) {}
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_deadCode_deadBlock_while_debugConst() {
-    Source source = addSource(EngineTestCase.createSource([
-        "const bool DEBUG = false;",
-        "f() {",
-        "  while(DEBUG) {}",
-        "}"]));
+    Source source = addSource(r'''
+const bool DEBUG = false;
+f() {
+  while(DEBUG) {}
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_deadCode_deadCatch_onCatchSubtype() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "class B extends A {}",
-        "f() {",
-        "  try {} on B catch (e) {} on A catch (e) {} catch (e) {}",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+class B extends A {}
+f() {
+  try {} on B catch (e) {} on A catch (e) {} catch (e) {}
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_deadCode_deadOperandLHS_and_debugConst() {
-    Source source = addSource(EngineTestCase.createSource([
-        "const bool DEBUG = false;",
-        "f() {",
-        "  bool b = DEBUG && false;",
-        "}"]));
+    Source source = addSource(r'''
+const bool DEBUG = false;
+f() {
+  bool b = DEBUG && false;
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_deadCode_deadOperandLHS_or_debugConst() {
-    Source source = addSource(EngineTestCase.createSource([
-        "const bool DEBUG = true;",
-        "f() {",
-        "  bool b = DEBUG || true;",
-        "}"]));
+    Source source = addSource(r'''
+const bool DEBUG = true;
+f() {
+  bool b = DEBUG || true;
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_divisionOptimization() {
-    Source source = addSource(EngineTestCase.createSource(["f(int x, int y) {", "  var v = x / y.toInt();", "}"]));
+    Source source = addSource(r'''
+f(int x, int y) {
+  var v = x / y.toInt();
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_divisionOptimization_supressIfDivisionNotDefinedInCore() {
-    Source source = addSource(EngineTestCase.createSource(["f(x, y) {", "  var v = (x / y).toInt();", "}"]));
+    Source source = addSource(r'''
+f(x, y) {
+  var v = (x / y).toInt();
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_divisionOptimization_supressIfDivisionOverridden() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  num operator /(x) { return x; }",
-        "}",
-        "f(A x, A y) {",
-        "  var v = (x / y).toInt();",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  num operator /(x) { return x; }
+}
+f(A x, A y) {
+  var v = (x / y).toInt();
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_duplicateImport_as() {
-    Source source = addSource(EngineTestCase.createSource([
-        "library L;",
-        "import 'lib1.dart';",
-        "import 'lib1.dart' as one;",
-        "A a;",
-        "one.A a2;"]));
-    addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}"]));
+    Source source = addSource(r'''
+library L;
+import 'lib1.dart';
+import 'lib1.dart' as one;
+A a;
+one.A a2;''');
+    addNamedSource("/lib1.dart", r'''
+library lib1;
+class A {}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_duplicateImport_hide() {
-    Source source = addSource(EngineTestCase.createSource([
-        "library L;",
-        "import 'lib1.dart';",
-        "import 'lib1.dart' hide A;",
-        "A a;",
-        "B b;"]));
-    addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}", "class B {}"]));
+    Source source = addSource(r'''
+library L;
+import 'lib1.dart';
+import 'lib1.dart' hide A;
+A a;
+B b;''');
+    addNamedSource("/lib1.dart", r'''
+library lib1;
+class A {}
+class B {}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_duplicateImport_show() {
-    Source source = addSource(EngineTestCase.createSource([
-        "library L;",
-        "import 'lib1.dart';",
-        "import 'lib1.dart' show A;",
-        "A a;",
-        "B b;"]));
-    addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}", "class B {}"]));
-    resolve(source);
-    assertNoErrors(source);
-    verify([source]);
+    Source source = addSource(r'''
+library L;
+import 'lib1.dart';
+import 'lib1.dart' show A;
+A a;
+B b;''');
+    addNamedSource("/lib1.dart", r'''
+library lib1;
+class A {}
+class B {}''');
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
   }
 
   void test_importDeferredLibraryWithLoadFunction() {
     resolveWithAndWithoutExperimental(<String> [
-        EngineTestCase.createSource(["library lib1;", "f() {}"]),
-        EngineTestCase.createSource([
-        "library root;",
-        "import 'lib1.dart' deferred as lib1;",
-        "main() { lib1.f(); }"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> []);
+        r'''
+library lib1;
+f() {}''',
+        r'''
+library root;
+import 'lib1.dart' deferred as lib1;
+main() { lib1.f(); }'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> []);
   }
 
   void test_issue20904BuggyTypePromotionAtIfJoin_1() {
     // https://code.google.com/p/dart/issues/detail?id=20904
-    Source source = addSource(EngineTestCase.createSource([
-        "f(var message, var dynamic_) {",
-        "  if (message is Function) {",
-        "    message = dynamic_;",
-        "  }",
-        "  int s = message;",
-        "}"]));
+    Source source = addSource(r'''
+f(var message, var dynamic_) {
+  if (message is Function) {
+    message = dynamic_;
+  }
+  int s = message;
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_issue20904BuggyTypePromotionAtIfJoin_2() {
     // https://code.google.com/p/dart/issues/detail?id=20904
     enableUnionTypes(false);
-    Source source = addSource(EngineTestCase.createSource([
-        "f(var message) {",
-        "  if (message is Function) {",
-        "    message = '';",
-        "  }",
-        "  int s = message;",
-        "}"]));
+    Source source = addSource(r'''
+f(var message) {
+  if (message is Function) {
+    message = '';
+  }
+  int s = message;
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_issue20904BuggyTypePromotionAtIfJoin_3() {
     // https://code.google.com/p/dart/issues/detail?id=20904
-    Source source = addSource(EngineTestCase.createSource([
-        "f(var message) {",
-        "  var dynamic_;",
-        "  if (message is Function) {",
-        "    message = dynamic_;",
-        "  } else {",
-        "    return;",
-        "  }",
-        "  int s = message;",
-        "}"]));
+    Source source = addSource(r'''
+f(var message) {
+  var dynamic_;
+  if (message is Function) {
+    message = dynamic_;
+  } else {
+    return;
+  }
+  int s = message;
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_issue20904BuggyTypePromotionAtIfJoin_4() {
     // https://code.google.com/p/dart/issues/detail?id=20904
-    Source source = addSource(EngineTestCase.createSource([
-        "f(var message) {",
-        "  if (message is Function) {",
-        "    message = '';",
-        "  } else {",
-        "    return;",
-        "  }",
-        "  String s = message;",
-        "}"]));
+    Source source = addSource(r'''
+f(var message) {
+  if (message is Function) {
+    message = '';
+  } else {
+    return;
+  }
+  String s = message;
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_missingReturn_emptyFunctionBody() {
-    Source source = addSource(EngineTestCase.createSource(["abstract class A {", "  int m();", "}"]));
+    Source source = addSource(r'''
+abstract class A {
+  int m();
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_missingReturn_expressionFunctionBody() {
-    Source source = addSource(EngineTestCase.createSource(["int f() => 0;"]));
+    Source source = addSource("int f() => 0;");
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_missingReturn_noReturnType() {
-    Source source = addSource(EngineTestCase.createSource(["f() {}"]));
+    Source source = addSource("f() {}");
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_missingReturn_voidReturnType() {
-    Source source = addSource(EngineTestCase.createSource(["void f() {}"]));
+    Source source = addSource("void f() {}");
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_overrideEqualsButNotHashCode() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  bool operator ==(x) { return x; }",
-        "  get hashCode => 0;",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  bool operator ==(x) { return x; }
+  get hashCode => 0;
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_overrideOnNonOverridingGetter_inInterface() {
-    Source source = addSource(EngineTestCase.createSource([
-        "library dart.core;",
-        "const override = null;",
-        "class A {",
-        "  int get m => 0;",
-        "}",
-        "class B implements A {",
-        "  @override",
-        "  int get m => 1;",
-        "}"]));
+    Source source = addSource(r'''
+library dart.core;
+const override = null;
+class A {
+  int get m => 0;
+}
+class B implements A {
+  @override
+  int get m => 1;
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_overrideOnNonOverridingGetter_inSuperclass() {
-    Source source = addSource(EngineTestCase.createSource([
-        "library dart.core;",
-        "const override = null;",
-        "class A {",
-        "  int get m => 0;",
-        "}",
-        "class B extends A {",
-        "  @override",
-        "  int get m => 1;",
-        "}"]));
+    Source source = addSource(r'''
+library dart.core;
+const override = null;
+class A {
+  int get m => 0;
+}
+class B extends A {
+  @override
+  int get m => 1;
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_overrideOnNonOverridingMethod_inInterface() {
-    Source source = addSource(EngineTestCase.createSource([
-        "library dart.core;",
-        "const override = null;",
-        "class A {",
-        "  int m() => 0;",
-        "}",
-        "class B implements A {",
-        "  @override",
-        "  int m() => 1;",
-        "}"]));
+    Source source = addSource(r'''
+library dart.core;
+const override = null;
+class A {
+  int m() => 0;
+}
+class B implements A {
+  @override
+  int m() => 1;
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_overrideOnNonOverridingMethod_inSuperclass() {
-    Source source = addSource(EngineTestCase.createSource([
-        "library dart.core;",
-        "const override = null;",
-        "class A {",
-        "  int m() => 0;",
-        "}",
-        "class B extends A {",
-        "  @override",
-        "  int m() => 1;",
-        "}"]));
+    Source source = addSource(r'''
+library dart.core;
+const override = null;
+class A {
+  int m() => 0;
+}
+class B extends A {
+  @override
+  int m() => 1;
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_overrideOnNonOverridingSetter_inInterface() {
-    Source source = addSource(EngineTestCase.createSource([
-        "library dart.core;",
-        "const override = null;",
-        "class A {",
-        "  set m(int x) {}",
-        "}",
-        "class B implements A {",
-        "  @override",
-        "  set m(int x) {}",
-        "}"]));
+    Source source = addSource(r'''
+library dart.core;
+const override = null;
+class A {
+  set m(int x) {}
+}
+class B implements A {
+  @override
+  set m(int x) {}
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_overrideOnNonOverridingSetter_inSuperclass() {
-    Source source = addSource(EngineTestCase.createSource([
-        "library dart.core;",
-        "const override = null;",
-        "class A {",
-        "  set m(int x) {}",
-        "}",
-        "class B extends A {",
-        "  @override",
-        "  set m(int x) {}",
-        "}"]));
+    Source source = addSource(r'''
+library dart.core;
+const override = null;
+class A {
+  set m(int x) {}
+}
+class B extends A {
+  @override
+  set m(int x) {}
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_propagatedFieldType() {
     // From dartbug.com/20019
-    Source source = addSource(EngineTestCase.createSource([
-        "class A { }",
-        "class X<T> {",
-        "  final x = new List<T>();",
-        "}",
-        "class Z {",
-        "  final X<A> y = new X<A>();",
-        "  foo() {",
-        "    y.x.add(new A());",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A { }
+class X<T> {
+  final x = new List<T>();
+}
+class Z {
+  final X<A> y = new X<A>();
+  foo() {
+    y.x.add(new A());
+  }
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_proxy_annotation_prefixed() {
-    Source source = addSource(EngineTestCase.createSource([
-        "library L;",
-        "@proxy",
-        "class A {}",
-        "f(var a) {",
-        "  a = new A();",
-        "  a.m();",
-        "  var x = a.g;",
-        "  a.s = 1;",
-        "  var y = a + a;",
-        "  a++;",
-        "  ++a;",
-        "}"]));
+    Source source = addSource(r'''
+library L;
+@proxy
+class A {}
+f(var a) {
+  a = new A();
+  a.m();
+  var x = a.g;
+  a.s = 1;
+  var y = a + a;
+  a++;
+  ++a;
+}''');
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_proxy_annotation_prefixed2() {
-    Source source = addSource(EngineTestCase.createSource([
-        "library L;",
-        "@proxy",
-        "class A {}",
-        "class B {",
-        "  f(var a) {",
-        "    a = new A();",
-        "    a.m();",
-        "    var x = a.g;",
-        "    a.s = 1;",
-        "    var y = a + a;",
-        "    a++;",
-        "    ++a;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+library L;
+@proxy
+class A {}
+class B {
+  f(var a) {
+    a = new A();
+    a.m();
+    var x = a.g;
+    a.s = 1;
+    var y = a + a;
+    a++;
+    ++a;
+  }
+}''');
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_proxy_annotation_prefixed3() {
-    Source source = addSource(EngineTestCase.createSource([
-        "library L;",
-        "class B {",
-        "  f(var a) {",
-        "    a = new A();",
-        "    a.m();",
-        "    var x = a.g;",
-        "    a.s = 1;",
-        "    var y = a + a;",
-        "    a++;",
-        "    ++a;",
-        "  }",
-        "}",
-        "@proxy",
-        "class A {}"]));
+    Source source = addSource(r'''
+library L;
+class B {
+  f(var a) {
+    a = new A();
+    a.m();
+    var x = a.g;
+    a.s = 1;
+    var y = a + a;
+    a++;
+    ++a;
+  }
+}
+@proxy
+class A {}''');
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_undefinedGetter_inSubtype() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "class B extends A {",
-        "  get b => 0;",
-        "}",
-        "f(var a) {",
-        "  if(a is A) {",
-        "    return a.b;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+class B extends A {
+  get b => 0;
+}
+f(var a) {
+  if(a is A) {
+    return a.b;
+  }
+}''');
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_undefinedMethod_assignmentExpression_inSubtype() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "class B extends A {",
-        "  operator +(B b) {return new B();}",
-        "}",
-        "f(var a, var a2) {",
-        "  a = new A();",
-        "  a2 = new A();",
-        "  a += a2;",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+class B extends A {
+  operator +(B b) {return new B();}
+}
+f(var a, var a2) {
+  a = new A();
+  a2 = new A();
+  a += a2;
+}''');
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_undefinedMethod_inSubtype() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "class B extends A {",
-        "  b() {}",
-        "}",
-        "f() {",
-        "  var a = new A();",
-        "  a.b();",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+class B extends A {
+  b() {}
+}
+f() {
+  var a = new A();
+  a.b();
+}''');
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_undefinedMethod_unionType_all() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  int m(int x) => 0;",
-        "}",
-        "class B {",
-        "  String m() => '0';",
-        "}",
-        "f(A a, B b) {",
-        "  var ab;",
-        "  if (0 < 1) {",
-        "    ab = a;",
-        "  } else {",
-        "    ab = b;",
-        "  }",
-        "  ab.m();",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  int m(int x) => 0;
+}
+class B {
+  String m() => '0';
+}
+f(A a, B b) {
+  var ab;
+  if (0 < 1) {
+    ab = a;
+  } else {
+    ab = b;
+  }
+  ab.m();
+}''');
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_undefinedMethod_unionType_some() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  int m(int x) => 0;",
-        "}",
-        "class B {}",
-        "f(A a, B b) {",
-        "  var ab;",
-        "  if (0 < 1) {",
-        "    ab = a;",
-        "  } else {",
-        "    ab = b;",
-        "  }",
-        "  ab.m(0);",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  int m(int x) => 0;
+}
+class B {}
+f(A a, B b) {
+  var ab;
+  if (0 < 1) {
+    ab = a;
+  } else {
+    ab = b;
+  }
+  ab.m(0);
+}''');
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_undefinedOperator_binaryExpression_inSubtype() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "class B extends A {",
-        "  operator +(B b) {}",
-        "}",
-        "f(var a) {",
-        "  if(a is A) {",
-        "    a + 1;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+class B extends A {
+  operator +(B b) {}
+}
+f(var a) {
+  if(a is A) {
+    a + 1;
+  }
+}''');
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_undefinedOperator_indexBoth_inSubtype() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "class B extends A {",
-        "  operator [](int index) {}",
-        "}",
-        "f(var a) {",
-        "  if(a is A) {",
-        "    a[0]++;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+class B extends A {
+  operator [](int index) {}
+}
+f(var a) {
+  if(a is A) {
+    a[0]++;
+  }
+}''');
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_undefinedOperator_indexGetter_inSubtype() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "class B extends A {",
-        "  operator [](int index) {}",
-        "}",
-        "f(var a) {",
-        "  if(a is A) {",
-        "    a[0];",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+class B extends A {
+  operator [](int index) {}
+}
+f(var a) {
+  if(a is A) {
+    a[0];
+  }
+}''');
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_undefinedOperator_indexSetter_inSubtype() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "class B extends A {",
-        "  operator []=(i, v) {}",
-        "}",
-        "f(var a) {",
-        "  if(a is A) {",
-        "    a[0] = 1;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+class B extends A {
+  operator []=(i, v) {}
+}
+f(var a) {
+  if(a is A) {
+    a[0] = 1;
+  }
+}''');
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_undefinedOperator_postfixExpression() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "class B extends A {",
-        "  operator +(B b) {return new B();}",
-        "}",
-        "f(var a) {",
-        "  if(a is A) {",
-        "    a++;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+class B extends A {
+  operator +(B b) {return new B();}
+}
+f(var a) {
+  if(a is A) {
+    a++;
+  }
+}''');
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_undefinedOperator_prefixExpression() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "class B extends A {",
-        "  operator +(B b) {return new B();}",
-        "}",
-        "f(var a) {",
-        "  if(a is A) {",
-        "    ++a;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+class B extends A {
+  operator +(B b) {return new B();}
+}
+f(var a) {
+  if(a is A) {
+    ++a;
+  }
+}''');
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_undefinedSetter_inSubtype() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "class B extends A {",
-        "  set b(x) {}",
-        "}",
-        "f(var a) {",
-        "  if(a is A) {",
-        "    a.b = 0;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+class B extends A {
+  set b(x) {}
+}
+f(var a) {
+  if(a is A) {
+    a.b = 0;
+  }
+}''');
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_unnecessaryCast_13855_parameter_A() {
     // dartbug.com/13855, dartbug.com/13732
-    Source source = addSource(EngineTestCase.createSource([
-        "class A{",
-        "  a() {}",
-        "}",
-        "class B<E> {",
-        "  E e;",
-        "  m() {",
-        "    (e as A).a();",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A{
+  a() {}
+}
+class B<E> {
+  E e;
+  m() {
+    (e as A).a();
+  }
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unnecessaryCast_dynamic_type() {
-    Source source = addSource(EngineTestCase.createSource(["m(v) {", "  var b = v as Object;", "}"]));
+    Source source = addSource(r'''
+m(v) {
+  var b = v as Object;
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unnecessaryCast_generics() {
     // dartbug.com/18953
-    Source source = addSource(EngineTestCase.createSource([
-        "import 'dart:async';",
-        "Future<int> f() => new Future.value(0);",
-        "void g(bool c) {",
-        "  (c ? f(): new Future.value(0) as Future<int>).then((int value) {});",
-        "}"]));
+    Source source = addSource(r'''
+import 'dart:async';
+Future<int> f() => new Future.value(0);
+void g(bool c) {
+  (c ? f(): new Future.value(0) as Future<int>).then((int value) {});
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unnecessaryCast_type_dynamic() {
-    Source source = addSource(EngineTestCase.createSource(["m(v) {", "  var b = Object as dynamic;", "}"]));
+    Source source = addSource(r'''
+m(v) {
+  var b = Object as dynamic;
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedImport_annotationOnDirective() {
-    Source source = addSource(EngineTestCase.createSource(["library L;", "@A()", "import 'lib1.dart';"]));
-    Source source2 = addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {", "  const A() {}", "}"]));
+    Source source = addSource(r'''
+library L;
+@A()
+import 'lib1.dart';''');
+    Source source2 = addNamedSource("/lib1.dart", r'''
+library lib1;
+class A {
+  const A() {}
+}''');
     resolve(source);
     assertErrors(source, []);
     verify([source, source2]);
   }
 
   void test_unusedImport_as_equalPrefixes() {
     // 18818
-    Source source = addSource(EngineTestCase.createSource([
-        "library L;",
-        "import 'lib1.dart' as one;",
-        "import 'lib2.dart' as one;",
-        "one.A a;",
-        "one.B b;"]));
-    Source source2 = addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class A {}"]));
-    Source source3 = addNamedSource("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class B {}"]));
+    Source source = addSource(r'''
+library L;
+import 'lib1.dart' as one;
+import 'lib2.dart' as one;
+one.A a;
+one.B b;''');
+    Source source2 = addNamedSource("/lib1.dart", r'''
+library lib1;
+class A {}''');
+    Source source3 = addNamedSource("/lib2.dart", r'''
+library lib2;
+class B {}''');
     resolve(source);
     assertErrors(source, []);
     assertNoErrors(source2);
     assertNoErrors(source3);
     verify([source, source2, source3]);
   }
 
   void test_unusedImport_core_library() {
-    Source source = addSource(EngineTestCase.createSource(["library L;", "import 'dart:core';"]));
+    Source source = addSource(r'''
+library L;
+import 'dart:core';''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedImport_export() {
-    Source source = addSource(EngineTestCase.createSource(["library L;", "import 'lib1.dart';", "Two two;"]));
-    addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "export 'lib2.dart';", "class One {}"]));
-    addNamedSource("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class Two {}"]));
+    Source source = addSource(r'''
+library L;
+import 'lib1.dart';
+Two two;''');
+    addNamedSource("/lib1.dart", r'''
+library lib1;
+export 'lib2.dart';
+class One {}''');
+    addNamedSource("/lib2.dart", r'''
+library lib2;
+class Two {}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedImport_export_infiniteLoop() {
-    Source source = addSource(EngineTestCase.createSource(["library L;", "import 'lib1.dart';", "Two two;"]));
-    addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "export 'lib2.dart';", "class One {}"]));
-    addNamedSource("/lib2.dart", EngineTestCase.createSource(["library lib2;", "export 'lib3.dart';", "class Two {}"]));
-    addNamedSource("/lib3.dart", EngineTestCase.createSource(["library lib3;", "export 'lib2.dart';", "class Three {}"]));
+    Source source = addSource(r'''
+library L;
+import 'lib1.dart';
+Two two;''');
+    addNamedSource("/lib1.dart", r'''
+library lib1;
+export 'lib2.dart';
+class One {}''');
+    addNamedSource("/lib2.dart", r'''
+library lib2;
+export 'lib3.dart';
+class Two {}''');
+    addNamedSource("/lib3.dart", r'''
+library lib3;
+export 'lib2.dart';
+class Three {}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedImport_export2() {
-    Source source = addSource(EngineTestCase.createSource(["library L;", "import 'lib1.dart';", "Three three;"]));
-    addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "export 'lib2.dart';", "class One {}"]));
-    addNamedSource("/lib2.dart", EngineTestCase.createSource(["library lib2;", "export 'lib3.dart';", "class Two {}"]));
-    addNamedSource("/lib3.dart", EngineTestCase.createSource(["library lib3;", "class Three {}"]));
+    Source source = addSource(r'''
+library L;
+import 'lib1.dart';
+Three three;''');
+    addNamedSource("/lib1.dart", r'''
+library lib1;
+export 'lib2.dart';
+class One {}''');
+    addNamedSource("/lib2.dart", r'''
+library lib2;
+export 'lib3.dart';
+class Two {}''');
+    addNamedSource("/lib3.dart", r'''
+library lib3;
+class Three {}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedImport_metadata() {
-    Source source = addSource(EngineTestCase.createSource([
-        "library L;",
-        "@A(x)",
-        "import 'lib1.dart';",
-        "class A {",
-        "  final int value;",
-        "  const A(this.value);",
-        "}"]));
-    addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "const x = 0;"]));
+    Source source = addSource(r'''
+library L;
+@A(x)
+import 'lib1.dart';
+class A {
+  final int value;
+  const A(this.value);
+}''');
+    addNamedSource("/lib1.dart", r'''
+library lib1;
+const x = 0;''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_unusedImport_prefix_topLevelFunction() {
-    Source source = addSource(EngineTestCase.createSource([
-        "library L;",
-        "import 'lib1.dart' hide topLevelFunction;",
-        "import 'lib1.dart' as one show topLevelFunction;",
-        "class A {",
-        "  static void x() {",
-        "    One o;",
-        "    one.topLevelFunction();",
-        "  }",
-        "}"]));
-    addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class One {}", "topLevelFunction() {}"]));
+    Source source = addSource(r'''
+library L;
+import 'lib1.dart' hide topLevelFunction;
+import 'lib1.dart' as one show topLevelFunction;
+class A {
+  static void x() {
+    One o;
+    one.topLevelFunction();
+  }
+}''');
+    addNamedSource("/lib1.dart", r'''
+library lib1;
+class One {}
+topLevelFunction() {}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_useOfVoidResult_implicitReturnValue() {
-    Source source = addSource(EngineTestCase.createSource([
-        "f() {}",
-        "class A {",
-        "  n() {",
-        "    var a = f();",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+f() {}
+class A {
+  n() {
+    var a = f();
+  }
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_useOfVoidResult_nonVoidReturnValue() {
-    Source source = addSource(EngineTestCase.createSource(["int f() => 1;", "g() {", "  var a = f();", "}"]));
+    Source source = addSource(r'''
+int f() => 1;
+g() {
+  var a = f();
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 }
 
 class PubSuggestionCodeTest extends ResolverTestCase {
   void test_import_package() {
-    Source source = addSource(EngineTestCase.createSource(["import 'package:somepackage/other.dart';"]));
+    Source source = addSource("import 'package:somepackage/other.dart';");
     resolve(source);
     assertErrors(source, [CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
   }
 
   void test_import_packageWithDotDot() {
-    Source source = addSource(EngineTestCase.createSource(["import 'package:somepackage/../other.dart';"]));
+    Source source = addSource("import 'package:somepackage/../other.dart';");
     resolve(source);
     assertErrors(source, [
         CompileTimeErrorCode.URI_DOES_NOT_EXIST,
         HintCode.PACKAGE_IMPORT_CONTAINS_DOT_DOT]);
   }
 
   void test_import_packageWithLeadingDotDot() {
-    Source source = addSource(EngineTestCase.createSource(["import 'package:../other.dart';"]));
+    Source source = addSource("import 'package:../other.dart';");
     resolve(source);
     assertErrors(source, [
         CompileTimeErrorCode.URI_DOES_NOT_EXIST,
         HintCode.PACKAGE_IMPORT_CONTAINS_DOT_DOT]);
   }
 
   void test_import_referenceIntoLibDirectory() {
     cacheSource("/myproj/pubspec.yaml", "");
     cacheSource("/myproj/lib/other.dart", "");
-    Source source = addNamedSource("/myproj/web/test.dart", EngineTestCase.createSource(["import '../lib/other.dart';"]));
+    Source source = addNamedSource("/myproj/web/test.dart", "import '../lib/other.dart';");
     resolve(source);
     assertErrors(source, [HintCode.FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE]);
   }
 
   void test_import_referenceIntoLibDirectory_no_pubspec() {
     cacheSource("/myproj/lib/other.dart", "");
-    Source source = addNamedSource("/myproj/web/test.dart", EngineTestCase.createSource(["import '../lib/other.dart';"]));
+    Source source = addNamedSource("/myproj/web/test.dart", "import '../lib/other.dart';");
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_import_referenceOutOfLibDirectory() {
     cacheSource("/myproj/pubspec.yaml", "");
     cacheSource("/myproj/web/other.dart", "");
-    Source source = addNamedSource("/myproj/lib/test.dart", EngineTestCase.createSource(["import '../web/other.dart';"]));
+    Source source = addNamedSource("/myproj/lib/test.dart", "import '../web/other.dart';");
     resolve(source);
     assertErrors(source, [HintCode.FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE]);
   }
 
   void test_import_referenceOutOfLibDirectory_no_pubspec() {
     cacheSource("/myproj/web/other.dart", "");
-    Source source = addNamedSource("/myproj/lib/test.dart", EngineTestCase.createSource(["import '../web/other.dart';"]));
+    Source source = addNamedSource("/myproj/lib/test.dart", "import '../web/other.dart';");
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_import_valid_inside_lib1() {
     cacheSource("/myproj/pubspec.yaml", "");
     cacheSource("/myproj/lib/other.dart", "");
-    Source source = addNamedSource("/myproj/lib/test.dart", EngineTestCase.createSource(["import 'other.dart';"]));
+    Source source = addNamedSource("/myproj/lib/test.dart", "import 'other.dart';");
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_import_valid_inside_lib2() {
     cacheSource("/myproj/pubspec.yaml", "");
     cacheSource("/myproj/lib/bar/other.dart", "");
-    Source source = addNamedSource("/myproj/lib/foo/test.dart", EngineTestCase.createSource(["import '../bar/other.dart';"]));
+    Source source = addNamedSource("/myproj/lib/foo/test.dart", "import '../bar/other.dart';");
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_import_valid_outside_lib() {
     cacheSource("/myproj/pubspec.yaml", "");
     cacheSource("/myproj/web/other.dart", "");
-    Source source = addNamedSource("/myproj/lib2/test.dart", EngineTestCase.createSource(["import '../web/other.dart';"]));
+    Source source = addNamedSource("/myproj/lib2/test.dart", "import '../web/other.dart';");
     resolve(source);
     assertNoErrors(source);
   }
 }
 
 class RecursiveAstVisitor_SimpleResolverTest_test_localVariable_types_invoked extends RecursiveAstVisitor<Object> {
   final SimpleResolverTest SimpleResolverTest_this;
 
   List<bool> found;
 
@@ skipping 796 matching lines @@
 
   @override
   AnalysisErrorListener get errorListener => listener;
 
   @override
   Element internalLookup(Identifier identifier, String name, LibraryElement referencingLibrary) => null;
 }
 
 class SimpleResolverTest extends ResolverTestCase {
   void fail_staticInvocation() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  static int get g => (a,b) => 0;",
-        "}",
-        "class B {",
-        "  f() {",
-        "    A.g(1,0);",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  static int get g => (a,b) => 0;
+}
+class B {
+  f() {
+    A.g(1,0);
+  }
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_argumentResolution_required_matching() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  void f() {",
-        "    g(1, 2, 3);",
-        "  }",
-        "  void g(a, b, c) {}",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  void f() {
+    g(1, 2, 3);
+  }
+  void g(a, b, c) {}
+}''');
     _validateArgumentResolution(source, [0, 1, 2]);
   }
 
   void test_argumentResolution_required_tooFew() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  void f() {",
-        "    g(1, 2);",
-        "  }",
-        "  void g(a, b, c) {}",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  void f() {
+    g(1, 2);
+  }
+  void g(a, b, c) {}
+}''');
     _validateArgumentResolution(source, [0, 1]);
   }
 
   void test_argumentResolution_required_tooMany() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  void f() {",
-        "    g(1, 2, 3);",
-        "  }",
-        "  void g(a, b) {}",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  void f() {
+    g(1, 2, 3);
+  }
+  void g(a, b) {}
+}''');
     _validateArgumentResolution(source, [0, 1, -1]);
   }
 
   void test_argumentResolution_requiredAndNamed_extra() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  void f() {",
-        "    g(1, 2, c: 3, d: 4);",
-        "  }",
-        "  void g(a, b, {c}) {}",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  void f() {
+    g(1, 2, c: 3, d: 4);
+  }
+  void g(a, b, {c}) {}
+}''');
     _validateArgumentResolution(source, [0, 1, 2, -1]);
   }
 
   void test_argumentResolution_requiredAndNamed_matching() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  void f() {",
-        "    g(1, 2, c: 3);",
-        "  }",
-        "  void g(a, b, {c}) {}",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  void f() {
+    g(1, 2, c: 3);
+  }
+  void g(a, b, {c}) {}
+}''');
     _validateArgumentResolution(source, [0, 1, 2]);
   }
 
   void test_argumentResolution_requiredAndNamed_missing() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  void f() {",
-        "    g(1, 2, d: 3);",
-        "  }",
-        "  void g(a, b, {c, d}) {}",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  void f() {
+    g(1, 2, d: 3);
+  }
+  void g(a, b, {c, d}) {}
+}''');
     _validateArgumentResolution(source, [0, 1, 3]);
   }
 
   void test_argumentResolution_requiredAndPositional_fewer() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  void f() {",
-        "    g(1, 2, 3);",
-        "  }",
-        "  void g(a, b, [c, d]) {}",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  void f() {
+    g(1, 2, 3);
+  }
+  void g(a, b, [c, d]) {}
+}''');
     _validateArgumentResolution(source, [0, 1, 2]);
   }
 
   void test_argumentResolution_requiredAndPositional_matching() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  void f() {",
-        "    g(1, 2, 3, 4);",
-        "  }",
-        "  void g(a, b, [c, d]) {}",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  void f() {
+    g(1, 2, 3, 4);
+  }
+  void g(a, b, [c, d]) {}
+}''');
     _validateArgumentResolution(source, [0, 1, 2, 3]);
   }
 
   void test_argumentResolution_requiredAndPositional_more() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  void f() {",
-        "    g(1, 2, 3, 4);",
-        "  }",
-        "  void g(a, b, [c]) {}",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  void f() {
+    g(1, 2, 3, 4);
+  }
+  void g(a, b, [c]) {}
+}''');
     _validateArgumentResolution(source, [0, 1, 2, -1]);
   }
 
   void test_argumentResolution_setter_propagated() {
-    Source source = addSource(EngineTestCase.createSource([
-        "main() {",
-        "  var a = new A();",
-        "  a.sss = 0;",
-        "}",
-        "class A {",
-        "  set sss(x) {}",
-        "}"]));
+    Source source = addSource(r'''
+main() {
+  var a = new A();
+  a.sss = 0;
+}
+class A {
+  set sss(x) {}
+}''');
     LibraryElement library = resolve(source);
     CompilationUnitElement unit = library.definingCompilationUnit;
     // find "a.sss = 0"
     AssignmentExpression assignment;
     {
       FunctionElement mainElement = unit.functions[0];
       FunctionBody mainBody = mainElement.node.functionExpression.body;
       Statement statement = (mainBody as BlockFunctionBody).block.statements[1];
       ExpressionStatement expressionStatement = statement as ExpressionStatement;
       assignment = expressionStatement.expression as AssignmentExpression;
     }
     // get parameter
     Expression rhs = assignment.rightHandSide;
     JUnitTestCase.assertNull(rhs.staticParameterElement);
     ParameterElement parameter = rhs.propagatedParameterElement;
     JUnitTestCase.assertNotNull(parameter);
     JUnitTestCase.assertEquals("x", parameter.displayName);
     // validate
     ClassElement classA = unit.types[0];
     PropertyAccessorElement setter = classA.accessors[0];
     JUnitTestCase.assertSame(parameter, setter.parameters[0]);
   }
 
   void test_argumentResolution_setter_propagated_propertyAccess() {
-    Source source = addSource(EngineTestCase.createSource([
-        "main() {",
-        "  var a = new A();",
-        "  a.b.sss = 0;",
-        "}",
-        "class A {",
-        "  B b = new B();",
-        "}",
-        "class B {",
-        "  set sss(x) {}",
-        "}"]));
+    Source source = addSource(r'''
+main() {
+  var a = new A();
+  a.b.sss = 0;
+}
+class A {
+  B b = new B();
+}
+class B {
+  set sss(x) {}
+}''');
     LibraryElement library = resolve(source);
     CompilationUnitElement unit = library.definingCompilationUnit;
     // find "a.b.sss = 0"
     AssignmentExpression assignment;
     {
       FunctionElement mainElement = unit.functions[0];
       FunctionBody mainBody = mainElement.node.functionExpression.body;
       Statement statement = (mainBody as BlockFunctionBody).block.statements[1];
       ExpressionStatement expressionStatement = statement as ExpressionStatement;
       assignment = expressionStatement.expression as AssignmentExpression;
     }
     // get parameter
     Expression rhs = assignment.rightHandSide;
     JUnitTestCase.assertNull(rhs.staticParameterElement);
     ParameterElement parameter = rhs.propagatedParameterElement;
     JUnitTestCase.assertNotNull(parameter);
     JUnitTestCase.assertEquals("x", parameter.displayName);
     // validate
     ClassElement classB = unit.types[1];
     PropertyAccessorElement setter = classB.accessors[0];
     JUnitTestCase.assertSame(parameter, setter.parameters[0]);
   }
 
   void test_argumentResolution_setter_static() {
-    Source source = addSource(EngineTestCase.createSource([
-        "main() {",
-        "  A a = new A();",
-        "  a.sss = 0;",
-        "}",
-        "class A {",
-        "  set sss(x) {}",
-        "}"]));
+    Source source = addSource(r'''
+main() {
+  A a = new A();
+  a.sss = 0;
+}
+class A {
+  set sss(x) {}
+}''');
     LibraryElement library = resolve(source);
     CompilationUnitElement unit = library.definingCompilationUnit;
     // find "a.sss = 0"
     AssignmentExpression assignment;
     {
       FunctionElement mainElement = unit.functions[0];
       FunctionBody mainBody = mainElement.node.functionExpression.body;
       Statement statement = (mainBody as BlockFunctionBody).block.statements[1];
       ExpressionStatement expressionStatement = statement as ExpressionStatement;
       assignment = expressionStatement.expression as AssignmentExpression;
     }
     // get parameter
     Expression rhs = assignment.rightHandSide;
     ParameterElement parameter = rhs.staticParameterElement;
     JUnitTestCase.assertNotNull(parameter);
     JUnitTestCase.assertEquals("x", parameter.displayName);
     // validate
     ClassElement classA = unit.types[0];
     PropertyAccessorElement setter = classA.accessors[0];
     JUnitTestCase.assertSame(parameter, setter.parameters[0]);
   }
 
   void test_argumentResolution_setter_static_propertyAccess() {
-    Source source = addSource(EngineTestCase.createSource([
-        "main() {",
-        "  A a = new A();",
-        "  a.b.sss = 0;",
-        "}",
-        "class A {",
-        "  B b = new B();",
-        "}",
-        "class B {",
-        "  set sss(x) {}",
-        "}"]));
+    Source source = addSource(r'''
+main() {
+  A a = new A();
+  a.b.sss = 0;
+}
+class A {
+  B b = new B();
+}
+class B {
+  set sss(x) {}
+}''');
     LibraryElement library = resolve(source);
     CompilationUnitElement unit = library.definingCompilationUnit;
     // find "a.b.sss = 0"
     AssignmentExpression assignment;
     {
       FunctionElement mainElement = unit.functions[0];
       FunctionBody mainBody = mainElement.node.functionExpression.body;
       Statement statement = (mainBody as BlockFunctionBody).block.statements[1];
       ExpressionStatement expressionStatement = statement as ExpressionStatement;
       assignment = expressionStatement.expression as AssignmentExpression;
     }
     // get parameter
     Expression rhs = assignment.rightHandSide;
     ParameterElement parameter = rhs.staticParameterElement;
     JUnitTestCase.assertNotNull(parameter);
     JUnitTestCase.assertEquals("x", parameter.displayName);
     // validate
     ClassElement classB = unit.types[1];
     PropertyAccessorElement setter = classB.accessors[0];
     JUnitTestCase.assertSame(parameter, setter.parameters[0]);
   }
 
   void test_class_definesCall() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  int call(int x) { return x; }",
-        "}",
-        "int f(A a) {",
-        "  return a(0);",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  int call(int x) { return x; }
+}
+int f(A a) {
+  return a(0);
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_class_extends_implements() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A extends B implements C {}",
-        "class B {}",
-        "class C {}"]));
+    Source source = addSource(r'''
+class A extends B implements C {}
+class B {}
+class C {}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_commentReference_class() {
-    Source source = addSource(EngineTestCase.createSource([
-        "f() {}",
-        "/** [A] [new A] [A.n] [new A.n] [m] [f] */",
-        "class A {",
-        "  A() {}",
-        "  A.n() {}",
-        "  m() {}",
-        "}"]));
+    Source source = addSource(r'''
+f() {}
+/** [A] [new A] [A.n] [new A.n] [m] [f] */
+class A {
+  A() {}
+  A.n() {}
+  m() {}
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_commentReference_parameter() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  A() {}",
-        "  A.n() {}",
-        "  /** [e] [f] */",
-        "  m(e, f()) {}",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  A() {}
+  A.n() {}
+  /** [e] [f] */
+  m(e, f()) {}
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_commentReference_singleLine() {
-    Source source = addSource(EngineTestCase.createSource(["/// [A]", "class A {}"]));
+    Source source = addSource(r'''
+/// [A]
+class A {}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_empty() {
     Source source = addSource("");
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_entryPoint_exported() {
-    addNamedSource("/two.dart", EngineTestCase.createSource(["library two;", "main() {}"]));
-    Source source = addNamedSource("/one.dart", EngineTestCase.createSource(["library one;", "export 'two.dart';"]));
+    addNamedSource("/two.dart", r'''
+library two;
+main() {}''');
+    Source source = addNamedSource("/one.dart", r'''
+library one;
+export 'two.dart';''');
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     FunctionElement main = library.entryPoint;
     JUnitTestCase.assertNotNull(main);
     JUnitTestCase.assertNotSame(library, main.library);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_entryPoint_local() {
-    Source source = addNamedSource("/one.dart", EngineTestCase.createSource(["library one;", "main() {}"]));
+    Source source = addNamedSource("/one.dart", r'''
+library one;
+main() {}''');
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     FunctionElement main = library.entryPoint;
     JUnitTestCase.assertNotNull(main);
     JUnitTestCase.assertSame(library, main.library);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_entryPoint_none() {
-    Source source = addNamedSource("/one.dart", EngineTestCase.createSource(["library one;"]));
+    Source source = addNamedSource("/one.dart", "library one;");
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     JUnitTestCase.assertNull(library.entryPoint);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_extractedMethodAsConstant() {
-    Source source = addSource(EngineTestCase.createSource([
-        "abstract class Comparable<T> {",
-        "  int compareTo(T other);",
-        "  static int compare(Comparable a, Comparable b) => a.compareTo(b);",
-        "}",
-        "class A {",
-        "  void sort([compare = Comparable.compare]) {}",
-        "}"]));
+    Source source = addSource(r'''
+abstract class Comparable<T> {
+  int compareTo(T other);
+  static int compare(Comparable a, Comparable b) => a.compareTo(b);
+}
+class A {
+  void sort([compare = Comparable.compare]) {}
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_fieldFormalParameter() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  int x;", "  A(this.x) {}", "}"]));
+    Source source = addSource(r'''
+class A {
+  int x;
+  A(this.x) {}
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_forEachLoops_nonConflicting() {
-    Source source = addSource(EngineTestCase.createSource([
-        "f() {",
-        "  List list = [1,2,3];",
-        "  for (int x in list) {}",
-        "  for (int x in list) {}",
-        "}"]));
+    Source source = addSource(r'''
+f() {
+  List list = [1,2,3];
+  for (int x in list) {}
+  for (int x in list) {}
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_forLoops_nonConflicting() {
-    Source source = addSource(EngineTestCase.createSource([
-        "f() {",
-        "  for (int i = 0; i < 3; i++) {",
-        "  }",
-        "  for (int i = 0; i < 3; i++) {",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+f() {
+  for (int i = 0; i < 3; i++) {
+  }
+  for (int i = 0; i < 3; i++) {
+  }
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_functionTypeAlias() {
-    Source source = addSource(EngineTestCase.createSource([
-        "typedef bool P(e);",
-        "class A {",
-        "  P p;",
-        "  m(e) {",
-        "    if (p(e)) {}",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+typedef bool P(e);
+class A {
+  P p;
+  m(e) {
+    if (p(e)) {}
+  }
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_getterAndSetterWithDifferentTypes() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  int get f => 0;",
-        "  void set f(String s) {}",
-        "}",
-        "g (A a) {",
-        "  a.f = a.f.toString();",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  int get f => 0;
+  void set f(String s) {}
+}
+g (A a) {
+  a.f = a.f.toString();
+}''');
     resolve(source);
     assertErrors(source, [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]);
     verify([source]);
   }
 
   void test_hasReferenceToSuper() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {toString() => super.toString();}"]));
+    Source source = addSource(r'''
+class A {}
+class B {toString() => super.toString();}''');
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     CompilationUnitElement unit = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(2, classes);
     JUnitTestCase.assertFalse(classes[0].hasReferenceToSuper);
     JUnitTestCase.assertTrue(classes[1].hasReferenceToSuper);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_import_hide() {
-    addNamedSource("lib1.dart", EngineTestCase.createSource(["library lib1;", "set foo(value) {}", "class A {}"]));
-    addNamedSource("lib2.dart", EngineTestCase.createSource(["library lib2;", "set foo(value) {}"]));
-    Source source = addNamedSource("lib3.dart", EngineTestCase.createSource([
-        "import 'lib1.dart' hide foo;",
-        "import 'lib2.dart';",
-        "",
-        "main() {",
-        "  foo = 0;",
-        "}",
-        "A a;"]));
+    addNamedSource("lib1.dart", r'''
+library lib1;
+set foo(value) {}
+class A {}''');
+    addNamedSource("lib2.dart", r'''
+library lib2;
+set foo(value) {}''');
+    Source source = addNamedSource("lib3.dart", r'''
+import 'lib1.dart' hide foo;
+import 'lib2.dart';
+
+main() {
+  foo = 0;
+}
+A a;''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_import_prefix() {
-    addNamedSource("/two.dart", EngineTestCase.createSource(["library two;", "f(int x) {", "  return x * x;", "}"]));
-    Source source = addNamedSource("/one.dart", EngineTestCase.createSource([
-        "library one;",
-        "import 'two.dart' as _two;",
-        "main() {",
-        "  _two.f(0);",
-        "}"]));
+    addNamedSource("/two.dart", r'''
+library two;
+f(int x) {
+  return x * x;
+}''');
+    Source source = addNamedSource("/one.dart", r'''
+library one;
+import 'two.dart' as _two;
+main() {
+  _two.f(0);
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_import_spaceInUri() {
-    addNamedSource("sub folder/lib.dart", EngineTestCase.createSource(["library lib;", "foo() {}"]));
-    Source source = addNamedSource("app.dart", EngineTestCase.createSource([
-        "import 'sub folder/lib.dart';",
-        "",
-        "main() {",
-        "  foo();",
-        "}"]));
+    addNamedSource("sub folder/lib.dart", r'''
+library lib;
+foo() {}''');
+    Source source = addNamedSource("app.dart", r'''
+import 'sub folder/lib.dart';
+
+main() {
+  foo();
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_indexExpression_typeParameters() {
-    Source source = addSource(EngineTestCase.createSource([
-        "f() {",
-        "  List<int> a;",
-        "  a[0];",
-        "  List<List<int>> b;",
-        "  b[0][0];",
-        "  List<List<List<int>>> c;",
-        "  c[0][0][0];",
-        "}"]));
+    Source source = addSource(r'''
+f() {
+  List<int> a;
+  a[0];
+  List<List<int>> b;
+  b[0][0];
+  List<List<List<int>>> c;
+  c[0][0][0];
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_indexExpression_typeParameters_invalidAssignmentWarning() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  List<List<int>> b;", "  b[0][0] = 'hi';", "}"]));
+    Source source = addSource(r'''
+f() {
+  List<List<int>> b;
+  b[0][0] = 'hi';
+}''');
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
     verify([source]);
   }
 
   void test_indirectOperatorThroughCall() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  B call() { return new B(); }",
-        "}",
-        "",
-        "class B {",
-        "  int operator [](int i) { return i; }",
-        "}",
-        "",
-        "A f = new A();",
-        "",
-        "g(int x) {}",
-        "",
-        "main() {",
-        "  g(f()[0]);",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  B call() { return new B(); }
+}
+
+class B {
+  int operator [](int i) { return i; }
+}
+
+A f = new A();
+
+g(int x) {}
+
+main() {
+  g(f()[0]);
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_invoke_dynamicThroughGetter() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  List get X => [() => 0];",
-        "  m(A a) {",
-        "    X.last;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  List get X => [() => 0];
+  m(A a) {
+    X.last;
+  }
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_isValidMixin_badSuperclass() {
-    Source source = addSource(EngineTestCase.createSource(["class A extends B {}", "class B {}"]));
+    Source source = addSource(r'''
+class A extends B {}
+class B {}''');
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     CompilationUnitElement unit = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(2, classes);
     JUnitTestCase.assertFalse(classes[0].isValidMixin);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_isValidMixin_constructor() {
-    Source source = addSource(EngineTestCase.createSource(["class A {", "  A() {}", "}"]));
+    Source source = addSource(r'''
+class A {
+  A() {}
+}''');
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     CompilationUnitElement unit = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(1, classes);
     JUnitTestCase.assertFalse(classes[0].isValidMixin);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_isValidMixin_super() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  toString() {",
-        "    return super.toString();",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  toString() {
+    return super.toString();
+  }
+}''');
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     CompilationUnitElement unit = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(1, classes);
     JUnitTestCase.assertFalse(classes[0].isValidMixin);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_isValidMixin_valid() {
-    Source source = addSource(EngineTestCase.createSource(["class A {}"]));
+    Source source = addSource("class A {}");
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     CompilationUnitElement unit = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(1, classes);
     JUnitTestCase.assertTrue(classes[0].isValidMixin);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_labels_switch() {
-    Source source = addSource(EngineTestCase.createSource([
-        "void doSwitch(int target) {",
-        "  switch (target) {",
-        "    l0: case 0:",
-        "      continue l1;",
-        "    l1: case 1:",
-        "      continue l0;",
-        "    default:",
-        "      continue l1;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+void doSwitch(int target) {
+  switch (target) {
+    l0: case 0:
+      continue l1;
+    l1: case 1:
+      continue l0;
+    default:
+      continue l1;
+  }
+}''');
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_localVariable_types_invoked() {
-    Source source = addSource(EngineTestCase.createSource([
-        "const A = null;",
-        "main() {",
-        "  var myVar = (int p) => 'foo';",
-        "  myVar(42);",
-        "}"]));
+    Source source = addSource(r'''
+const A = null;
+main() {
+  var myVar = (int p) => 'foo';
+  myVar(42);
+}''');
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     CompilationUnit unit = analysisContext.getResolvedCompilationUnit(source, library);
     JUnitTestCase.assertNotNull(unit);
     List<bool> found = [false];
     List<CaughtException> thrownException = new List<CaughtException>(1);
     unit.accept(new RecursiveAstVisitor_SimpleResolverTest_test_localVariable_types_invoked(this, found, thrownException));
     if (thrownException[0] != null) {
       throw new AnalysisException("Exception", new CaughtException(thrownException[0], null));
     }
     JUnitTestCase.assertTrue(found[0]);
   }
 
   void test_metadata_class() {
-    Source source = addSource(EngineTestCase.createSource(["const A = null;", "@A class C<A> {}"]));
+    Source source = addSource(r'''
+const A = null;
+@A class C<A> {}''');
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     CompilationUnitElement unitElement = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unitElement);
     List<ClassElement> classes = unitElement.types;
     EngineTestCase.assertLength(1, classes);
     List<ElementAnnotation> annotations = classes[0].metadata;
     EngineTestCase.assertLength(1, annotations);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     EngineTestCase.assertSizeOfList(2, declarations);
     Element expectedElement = (declarations[0] as TopLevelVariableDeclaration).variables.variables[0].name.staticElement;
     EngineTestCase.assertInstanceOf((obj) => obj is PropertyInducingElement, PropertyInducingElement, expectedElement);
     expectedElement = (expectedElement as PropertyInducingElement).getter;
     Element actualElement = (declarations[1] as ClassDeclaration).metadata[0].name.staticElement;
     JUnitTestCase.assertSame(expectedElement, actualElement);
   }
 
   void test_metadata_field() {
-    Source source = addSource(EngineTestCase.createSource(["const A = null;", "class C {", "  @A int f;", "}"]));
+    Source source = addSource(r'''
+const A = null;
+class C {
+  @A int f;
+}''');
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     CompilationUnitElement unit = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(1, classes);
     FieldElement field = classes[0].fields[0];
     List<ElementAnnotation> annotations = field.metadata;
     EngineTestCase.assertLength(1, annotations);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_fieldFormalParameter() {
-    Source source = addSource(EngineTestCase.createSource([
-        "const A = null;",
-        "class C {",
-        "  int f;",
-        "  C(@A this.f);",
-        "}"]));
+    Source source = addSource(r'''
+const A = null;
+class C {
+  int f;
+  C(@A this.f);
+}''');
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     CompilationUnitElement unit = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(1, classes);
     List<ConstructorElement> constructors = classes[0].constructors;
     EngineTestCase.assertLength(1, constructors);
     List<ParameterElement> parameters = constructors[0].parameters;
     EngineTestCase.assertLength(1, parameters);
     List<ElementAnnotation> annotations = parameters[0].metadata;
     EngineTestCase.assertLength(1, annotations);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_function() {
-    Source source = addSource(EngineTestCase.createSource(["const A = null;", "@A f() {}"]));
+    Source source = addSource(r'''
+const A = null;
+@A f() {}''');
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     CompilationUnitElement unit = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     List<FunctionElement> functions = unit.functions;
     EngineTestCase.assertLength(1, functions);
     List<ElementAnnotation> annotations = functions[0].metadata;
     EngineTestCase.assertLength(1, annotations);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_functionTypedParameter() {
-    Source source = addSource(EngineTestCase.createSource(["const A = null;", "f(@A int p(int x)) {}"]));
+    Source source = addSource(r'''
+const A = null;
+f(@A int p(int x)) {}''');
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     CompilationUnitElement unit = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     List<FunctionElement> functions = unit.functions;
     EngineTestCase.assertLength(1, functions);
     List<ParameterElement> parameters = functions[0].parameters;
     EngineTestCase.assertLength(1, parameters);
     List<ElementAnnotation> annotations1 = parameters[0].metadata;
     EngineTestCase.assertLength(1, annotations1);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_libraryDirective() {
-    Source source = addSource(EngineTestCase.createSource(["@A library lib;", "const A = null;"]));
+    Source source = addSource(r'''
+@A library lib;
+const A = null;''');
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     List<ElementAnnotation> annotations = library.metadata;
     EngineTestCase.assertLength(1, annotations);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_method() {
-    Source source = addSource(EngineTestCase.createSource(["const A = null;", "class C {", "  @A void m() {}", "}"]));
+    Source source = addSource(r'''
+const A = null;
+class C {
+  @A void m() {}
+}''');
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     CompilationUnitElement unit = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     List<ClassElement> classes = unit.types;
     EngineTestCase.assertLength(1, classes);
     MethodElement method = classes[0].methods[0];
     List<ElementAnnotation> annotations = method.metadata;
     EngineTestCase.assertLength(1, annotations);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_namedParameter() {
-    Source source = addSource(EngineTestCase.createSource(["const A = null;", "f({@A int p : 0}) {}"]));
+    Source source = addSource(r'''
+const A = null;
+f({@A int p : 0}) {}''');
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     CompilationUnitElement unit = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     List<FunctionElement> functions = unit.functions;
     EngineTestCase.assertLength(1, functions);
     List<ParameterElement> parameters = functions[0].parameters;
     EngineTestCase.assertLength(1, parameters);
     List<ElementAnnotation> annotations1 = parameters[0].metadata;
     EngineTestCase.assertLength(1, annotations1);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_positionalParameter() {
-    Source source = addSource(EngineTestCase.createSource(["const A = null;", "f([@A int p = 0]) {}"]));
+    Source source = addSource(r'''
+const A = null;
+f([@A int p = 0]) {}''');
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     CompilationUnitElement unit = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     List<FunctionElement> functions = unit.functions;
     EngineTestCase.assertLength(1, functions);
     List<ParameterElement> parameters = functions[0].parameters;
     EngineTestCase.assertLength(1, parameters);
     List<ElementAnnotation> annotations1 = parameters[0].metadata;
     EngineTestCase.assertLength(1, annotations1);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_simpleParameter() {
-    Source source = addSource(EngineTestCase.createSource(["const A = null;", "f(@A p1, @A int p2) {}"]));
+    Source source = addSource(r'''
+const A = null;
+f(@A p1, @A int p2) {}''');
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     CompilationUnitElement unit = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unit);
     List<FunctionElement> functions = unit.functions;
     EngineTestCase.assertLength(1, functions);
     List<ParameterElement> parameters = functions[0].parameters;
     EngineTestCase.assertLength(2, parameters);
     List<ElementAnnotation> annotations1 = parameters[0].metadata;
     EngineTestCase.assertLength(1, annotations1);
     List<ElementAnnotation> annotations2 = parameters[1].metadata;
     EngineTestCase.assertLength(1, annotations2);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_metadata_typedef() {
-    Source source = addSource(EngineTestCase.createSource(["const A = null;", "@A typedef F<A>();"]));
+    Source source = addSource(r'''
+const A = null;
+@A typedef F<A>();''');
     LibraryElement library = resolve(source);
     JUnitTestCase.assertNotNull(library);
     CompilationUnitElement unitElement = library.definingCompilationUnit;
     JUnitTestCase.assertNotNull(unitElement);
     List<FunctionTypeAliasElement> aliases = unitElement.functionTypeAliases;
     EngineTestCase.assertLength(1, aliases);
     List<ElementAnnotation> annotations = aliases[0].metadata;
     EngineTestCase.assertLength(1, annotations);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     EngineTestCase.assertSizeOfList(2, declarations);
     Element expectedElement = (declarations[0] as TopLevelVariableDeclaration).variables.variables[0].name.staticElement;
     EngineTestCase.assertInstanceOf((obj) => obj is PropertyInducingElement, PropertyInducingElement, expectedElement);
     expectedElement = (expectedElement as PropertyInducingElement).getter;
     Element actualElement = (declarations[1] as FunctionTypeAlias).metadata[0].name.staticElement;
     JUnitTestCase.assertSame(expectedElement, actualElement);
   }
 
   void test_method_fromMixin() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class B {",
-        "  bar() => 1;",
-        "}",
-        "class A {",
-        "  foo() => 2;",
-        "}",
-        "",
-        "class C extends B with A {",
-        "  bar() => super.bar();",
-        "  foo() => super.foo();",
-        "}"]));
+    Source source = addSource(r'''
+class B {
+  bar() => 1;
+}
+class A {
+  foo() => 2;
+}
+
+class C extends B with A {
+  bar() => super.bar();
+  foo() => super.foo();
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_method_fromSuperclassMixin() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  void m1() {}",
-        "}",
-        "class B extends Object with A {",
-        "}",
-        "class C extends B {",
-        "}",
-        "f(C c) {",
-        "  c.m1();",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  void m1() {}
+}
+class B extends Object with A {
+}
+class C extends B {
+}
+f(C c) {
+  c.m1();
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_methodCascades() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  void m1() {}",
-        "  void m2() {}",
-        "  void m() {",
-        "    A a = new A();",
-        "    a..m1()",
-        "     ..m2();",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  void m1() {}
+  void m2() {}
+  void m() {
+    A a = new A();
+    a..m1()
+     ..m2();
+  }
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_methodCascades_withSetter() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  String name;",
-        "  void m1() {}",
-        "  void m2() {}",
-        "  void m() {",
-        "    A a = new A();",
-        "    a..m1()",
-        "     ..name = 'name'",
-        "     ..m2();",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  String name;
+  void m1() {}
+  void m2() {}
+  void m() {
+    A a = new A();
+    a..m1()
+     ..name = 'name'
+     ..m2();
+  }
+}''');
     resolve(source);
     // failing with error code: INVOCATION_OF_NON_FUNCTION
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_resolveAgainstNull() {
-    Source source = addSource(EngineTestCase.createSource(["f(var p) {", "  return null == p;", "}"]));
+    Source source = addSource(r'''
+f(var p) {
+  return null == p;
+}''');
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_setter_inherited() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  int get x => 0;",
-        "  set x(int p) {}",
-        "}",
-        "class B extends A {",
-        "  int get x => super.x == null ? 0 : super.x;",
-        "  int f() => x = 1;",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  int get x => 0;
+  set x(int p) {}
+}
+class B extends A {
+  int get x => super.x == null ? 0 : super.x;
+  int f() => x = 1;
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   void test_setter_static() {
-    Source source = addSource(EngineTestCase.createSource(["set s(x) {", "}", "", "main() {", "  s = 123;", "}"]));
+    Source source = addSource(r'''
+set s(x) {
+}
+
+main() {
+  s = 123;
+}''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
   /**
    * Resolve the given source and verify that the arguments in a specific method invocation were
    * correctly resolved.
    *
    * The source is expected to be source for a compilation unit, the first declaration is expected
@@ skipping 1302 matching lines @@
     return "<unknown file- ASTNode is null>";
   }
 }
 
 /**
  * The class `StrictModeTest` contains tests to ensure that the correct errors and warnings
  * are reported when the analysis engine is run in strict mode.
  */
 class StrictModeTest extends ResolverTestCase {
   void fail_for() {
-    Source source = addSource(EngineTestCase.createSource([
-        "int f(List<int> list) {",
-        "  num sum = 0;",
-        "  for (num i = 0; i < list.length; i++) {",
-        "    sum += list[i];",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+int f(List<int> list) {
+  num sum = 0;
+  for (num i = 0; i < list.length; i++) {
+    sum += list[i];
+  }
+}''');
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   @override
   void setUp() {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.hint = false;
     resetWithOptions(options);
   }
 
   void test_assert_is() {
-    Source source = addSource(EngineTestCase.createSource([
-        "int f(num n) {",
-        "  assert (n is int);",
-        "  return n & 0x0F;",
-        "}"]));
+    Source source = addSource(r'''
+int f(num n) {
+  assert (n is int);
+  return n & 0x0F;
+}''');
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   void test_conditional_and_is() {
-    Source source = addSource(EngineTestCase.createSource([
-        "int f(num n) {",
-        "  return (n is int && n > 0) ? n & 0x0F : 0;",
-        "}"]));
+    Source source = addSource(r'''
+int f(num n) {
+  return (n is int && n > 0) ? n & 0x0F : 0;
+}''');
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_conditional_is() {
-    Source source = addSource(EngineTestCase.createSource([
-        "int f(num n) {",
-        "  return (n is int) ? n & 0x0F : 0;",
-        "}"]));
+    Source source = addSource(r'''
+int f(num n) {
+  return (n is int) ? n & 0x0F : 0;
+}''');
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_conditional_isNot() {
-    Source source = addSource(EngineTestCase.createSource([
-        "int f(num n) {",
-        "  return (n is! int) ? 0 : n & 0x0F;",
-        "}"]));
+    Source source = addSource(r'''
+int f(num n) {
+  return (n is! int) ? 0 : n & 0x0F;
+}''');
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   void test_conditional_or_is() {
-    Source source = addSource(EngineTestCase.createSource([
-        "int f(num n) {",
-        "  return (n is! int || n < 0) ? 0 : n & 0x0F;",
-        "}"]));
+    Source source = addSource(r'''
+int f(num n) {
+  return (n is! int || n < 0) ? 0 : n & 0x0F;
+}''');
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   void test_forEach() {
-    Source source = addSource(EngineTestCase.createSource([
-        "int f(List<int> list) {",
-        "  num sum = 0;",
-        "  for (num n in list) {",
-        "    sum += n & 0x0F;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+int f(List<int> list) {
+  num sum = 0;
+  for (num n in list) {
+    sum += n & 0x0F;
+  }
+}''');
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   void test_if_and_is() {
-    Source source = addSource(EngineTestCase.createSource([
-        "int f(num n) {",
-        "  if (n is int && n > 0) {",
-        "    return n & 0x0F;",
-        "  }",
-        "  return 0;",
-        "}"]));
+    Source source = addSource(r'''
+int f(num n) {
+  if (n is int && n > 0) {
+    return n & 0x0F;
+  }
+  return 0;
+}''');
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_if_is() {
-    Source source = addSource(EngineTestCase.createSource([
-        "int f(num n) {",
-        "  if (n is int) {",
-        "    return n & 0x0F;",
-        "  }",
-        "  return 0;",
-        "}"]));
+    Source source = addSource(r'''
+int f(num n) {
+  if (n is int) {
+    return n & 0x0F;
+  }
+  return 0;
+}''');
     resolve(source);
     assertNoErrors(source);
   }
 
   void test_if_isNot() {
-    Source source = addSource(EngineTestCase.createSource([
-        "int f(num n) {",
-        "  if (n is! int) {",
-        "    return 0;",
-        "  } else {",
-        "    return n & 0x0F;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+int f(num n) {
+  if (n is! int) {
+    return 0;
+  } else {
+    return n & 0x0F;
+  }
+}''');
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   void test_if_isNot_abrupt() {
-    Source source = addSource(EngineTestCase.createSource([
-        "int f(num n) {",
-        "  if (n is! int) {",
-        "    return 0;",
-        "  }",
-        "  return n & 0x0F;",
-        "}"]));
+    Source source = addSource(r'''
+int f(num n) {
+  if (n is! int) {
+    return 0;
+  }
+  return n & 0x0F;
+}''');
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   void test_if_or_is() {
-    Source source = addSource(EngineTestCase.createSource([
-        "int f(num n) {",
-        "  if (n is! int || n < 0) {",
-        "    return 0;",
-        "  } else {",
-        "    return n & 0x0F;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+int f(num n) {
+  if (n is! int || n < 0) {
+    return 0;
+  } else {
+    return n & 0x0F;
+  }
+}''');
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   void test_localVar() {
-    Source source = addSource(EngineTestCase.createSource(["int f() {", "  num n = 1234;", "  return n & 0x0F;", "}"]));
+    Source source = addSource(r'''
+int f() {
+  num n = 1234;
+  return n & 0x0F;
+}''');
     resolve(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 }
 
 class SubtypeManagerTest extends EngineTestCase {
   /**
    * The inheritance manager being tested.
    */
   SubtypeManager _subtypeManager;
@@ skipping 584 matching lines @@
   void test_getType_noScope() {
     TypeOverrideManager manager = new TypeOverrideManager();
     JUnitTestCase.assertNull(manager.getType(ElementFactory.localVariableElement2("v")));
   }
 }
 
 
 class TypePropagationTest extends ResolverTestCase {
   void fail_mergePropagatedTypesAtJoinPoint_1() {
     // https://code.google.com/p/dart/issues/detail?id=19929
-    _assertTypeOfMarkedExpression(EngineTestCase.createSource([
-        "f1(x) {",
-        "  var y = [];",
-        "  if (x) {",
-        "    y = 0;",
-        "  } else {",
-        "    y = '';",
-        "  }",
-        "  // Propagated type is [List] here: incorrect.",
-        "  // Best we can do is [Object]?",
-        "  return y; // marker",
-        "}"]), null, typeProvider.dynamicType);
+    _assertTypeOfMarkedExpression(r'''
+f1(x) {
+  var y = [];
+  if (x) {
+    y = 0;
+  } else {
+    y = '';
+  }
+  // Propagated type is [List] here: incorrect.
+  // Best we can do is [Object]?
+  return y; // marker
+}''', null, typeProvider.dynamicType);
   }
 
   void fail_mergePropagatedTypesAtJoinPoint_2() {
     // https://code.google.com/p/dart/issues/detail?id=19929
-    _assertTypeOfMarkedExpression(EngineTestCase.createSource([
-        "f2(x) {",
-        "  var y = [];",
-        "  if (x) {",
-        "    y = 0;",
-        "  } else {",
-        "  }",
-        "  // Propagated type is [List] here: incorrect.",
-        "  // Best we can do is [Object]?",
-        "  return y; // marker",
-        "}"]), null, typeProvider.dynamicType);
+    _assertTypeOfMarkedExpression(r'''
+f2(x) {
+  var y = [];
+  if (x) {
+    y = 0;
+  } else {
+  }
+  // Propagated type is [List] here: incorrect.
+  // Best we can do is [Object]?
+  return y; // marker
+}''', null, typeProvider.dynamicType);
   }
 
   void fail_mergePropagatedTypesAtJoinPoint_3() {
     // https://code.google.com/p/dart/issues/detail?id=19929
-    _assertTypeOfMarkedExpression(EngineTestCase.createSource([
-        "f4(x) {",
-        "  var y = [];",
-        "  if (x) {",
-        "    y = 0;",
-        "  } else {",
-        "    y = 1.5;",
-        "  }",
-        "  // Propagated type is [List] here: incorrect.",
-        "  // A correct answer is the least upper bound of [int] and [double],",
-        "  // i.e. [num].",
-        "  return y; // marker",
-        "}"]), null, typeProvider.numType);
+    _assertTypeOfMarkedExpression(r'''
+f4(x) {
+  var y = [];
+  if (x) {
+    y = 0;
+  } else {
+    y = 1.5;
+  }
+  // Propagated type is [List] here: incorrect.
+  // A correct answer is the least upper bound of [int] and [double],
+  // i.e. [num].
+  return y; // marker
+}''', null, typeProvider.numType);
   }
 
   void fail_mergePropagatedTypesAtJoinPoint_5() {
     // https://code.google.com/p/dart/issues/detail?id=19929
-    _assertTypeOfMarkedExpression(EngineTestCase.createSource([
-        "f6(x,y) {",
-        "  var z = [];",
-        "  if (x || (z = y) < 0) {",
-        "  } else {",
-        "    z = 0;",
-        "  }",
-        "  // Propagated type is [List] here: incorrect.",
-        "  // Best we can do is [Object]?",
-        "  return z; // marker",
-        "}"]), null, typeProvider.dynamicType);
+    _assertTypeOfMarkedExpression(r'''
+f6(x,y) {
+  var z = [];
+  if (x || (z = y) < 0) {
+  } else {
+    z = 0;
+  }
+  // Propagated type is [List] here: incorrect.
+  // Best we can do is [Object]?
+  return z; // marker
+}''', null, typeProvider.dynamicType);
   }
 
   void fail_mergePropagatedTypesAtJoinPoint_7() {
     // https://code.google.com/p/dart/issues/detail?id=19929
     //
     // In general [continue]s are unsafe for the purposes of [isAbruptTerminationStatement].
     //
     // This is like example 6, but less tricky: the code in the branch that
     // [continue]s is in effect after the [if].
-    String code = EngineTestCase.createSource([
-        "f() {",
-        "  var x = 0;",
-        "  var c = false;",
-        "  var d = true;",
-        "  while (d) {",
-        "    if (c) {",
-        "      d = false;",
-        "    } else {",
-        "      x = '';",
-        "      c = true;",
-        "      continue;",
-        "    }",
-        "    x; // marker",
-        "  }",
-        "}"]);
+    String code = r'''
+f() {
+  var x = 0;
+  var c = false;
+  var d = true;
+  while (d) {
+    if (c) {
+      d = false;
+    } else {
+      x = '';
+      c = true;
+      continue;
+    }
+    x; // marker
+  }
+}''';
     DartType t = _findMarkedIdentifier(code, "; // marker").propagatedType;
     JUnitTestCase.assertTrue(typeProvider.intType.isSubtypeOf(t));
     JUnitTestCase.assertTrue(typeProvider.stringType.isSubtypeOf(t));
   }
 
   void fail_mergePropagatedTypesAtJoinPoint_8() {
     // https://code.google.com/p/dart/issues/detail?id=19929
     //
     // In nested loops [breaks]s are unsafe for the purposes of [isAbruptTerminationStatement].
     //
     // This is a combination of 6 and 7: we use an unlabeled [break]
     // like a continue for the outer loop / like a labeled [break] to
     // jump just above the [if].
-    String code = EngineTestCase.createSource([
-        "f() {",
-        "  var x = 0;",
-        "  var c = false;",
-        "  var d = true;",
-        "  while (d) {",
-        "    while (d) {",
-        "      if (c) {",
-        "        d = false;",
-        "      } else {",
-        "        x = '';",
-        "        c = true;",
-        "        break;",
-        "      }",
-        "      x; // marker",
-        "    }",
-        "  }",
-        "}"]);
+    String code = r'''
+f() {
+  var x = 0;
+  var c = false;
+  var d = true;
+  while (d) {
+    while (d) {
+      if (c) {
+        d = false;
+      } else {
+        x = '';
+        c = true;
+        break;
+      }
+      x; // marker
+    }
+  }
+}''';
     DartType t = _findMarkedIdentifier(code, "; // marker").propagatedType;
     JUnitTestCase.assertTrue(typeProvider.intType.isSubtypeOf(t));
     JUnitTestCase.assertTrue(typeProvider.stringType.isSubtypeOf(t));
   }
 
   void fail_propagatedReturnType_functionExpression() {
     // TODO(scheglov) disabled because we don't resolve function expression
-    String code = EngineTestCase.createSource(["main() {", "  var v = (() {return 42;})();", "}"]);
+    String code = r'''
+main() {
+  var v = (() {return 42;})();
+}''';
     _assertPropagatedReturnType(code, typeProvider.dynamicType, typeProvider.intType);
   }
 
   void test_as() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {",
-        "  bool get g => true;",
-        "}",
-        "A f(var p) {",
-        "  if ((p as A).g) {",
-        "    return p;",
-        "  } else {",
-        "    return null;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {
+  bool get g => true;
+}
+A f(var p) {
+  if ((p as A).g) {
+    return p;
+  } else {
+    return null;
+  }
+}''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
 
   void test_assert() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "A f(var p) {",
-        "  assert (p is A);",
-        "  return p;",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+A f(var p) {
+  assert (p is A);
+  return p;
+}''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
 
   void test_assignment() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  var v;", "  v = 0;", "  return v;", "}"]));
+    Source source = addSource(r'''
+f() {
+  var v;
+  v = 0;
+  return v;
+}''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[2] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeProvider.intType, variableName.propagatedType);
   }
 
   void test_assignment_afterInitializer() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  var v = 0;", "  v = 1.0;", "  return v;", "}"]));
+    Source source = addSource(r'''
+f() {
+  var v = 0;
+  v = 1.0;
+  return v;
+}''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[2] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeProvider.doubleType, variableName.propagatedType);
   }
 
   void test_assignment_null() {
-    String code = EngineTestCase.createSource([
-        "main() {",
-        "  int v; // declare",
-        "  v = null;",
-        "  return v; // return",
-        "}"]);
+    String code = r'''
+main() {
+  int v; // declare
+  v = null;
+  return v; // return
+}''';
     CompilationUnit unit;
     {
       Source source = addSource(code);
       LibraryElement library = resolve(source);
       assertNoErrors(source);
       verify([source]);
       unit = resolveCompilationUnit(source, library);
     }
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(unit, code, "v; // declare", (node) => node is SimpleIdentifier);
       JUnitTestCase.assertSame(typeProvider.intType, identifier.staticType);
       JUnitTestCase.assertSame(null, identifier.propagatedType);
     }
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(unit, code, "v = null;", (node) => node is SimpleIdentifier);
       JUnitTestCase.assertSame(typeProvider.intType, identifier.staticType);
       JUnitTestCase.assertSame(null, identifier.propagatedType);
     }
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(unit, code, "v; // return", (node) => node is SimpleIdentifier);
       JUnitTestCase.assertSame(typeProvider.intType, identifier.staticType);
       JUnitTestCase.assertSame(null, identifier.propagatedType);
     }
   }
 
   void test_CanvasElement_getContext() {
-    String code = EngineTestCase.createSource([
-        "import 'dart:html';",
-        "main(CanvasElement canvas) {",
-        "  var context = canvas.getContext('2d');",
-        "}"]);
+    String code = r'''
+import 'dart:html';
+main(CanvasElement canvas) {
+  var context = canvas.getContext('2d');
+}''';
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     SimpleIdentifier identifier = EngineTestCase.findNode(unit, code, "context", (node) => node is SimpleIdentifier);
     JUnitTestCase.assertEquals("CanvasRenderingContext2D", identifier.propagatedType.name);
   }
 
   void test_finalPropertyInducingVariable_classMember_instance() {
-    addNamedSource("/lib.dart", EngineTestCase.createSource(["class A {", "  final v = 0;", "}"]));
-    String code = EngineTestCase.createSource([
-        "import 'lib.dart';",
-        "f(A a) {",
-        "  return a.v; // marker",
-        "}"]);
+    addNamedSource("/lib.dart", r'''
+class A {
+  final v = 0;
+}''');
+    String code = r'''
+import 'lib.dart';
+f(A a) {
+  return a.v; // marker
+}''';
     _assertTypeOfMarkedExpression(code, typeProvider.dynamicType, typeProvider.intType);
   }
 
   void test_finalPropertyInducingVariable_classMember_instance_inherited() {
-    addNamedSource("/lib.dart", EngineTestCase.createSource(["class A {", "  final v = 0;", "}"]));
-    String code = EngineTestCase.createSource([
-        "import 'lib.dart';",
-        "class B extends A {",
-        "  m() {",
-        "    return v; // marker",
-        "  }",
-        "}"]);
+    addNamedSource("/lib.dart", r'''
+class A {
+  final v = 0;
+}''');
+    String code = r'''
+import 'lib.dart';
+class B extends A {
+  m() {
+    return v; // marker
+  }
+}''';
     _assertTypeOfMarkedExpression(code, typeProvider.dynamicType, typeProvider.intType);
   }
 
   void test_finalPropertyInducingVariable_classMember_instance_propagatedTarget() {
-    addNamedSource("/lib.dart", EngineTestCase.createSource(["class A {", "  final v = 0;", "}"]));
-    String code = EngineTestCase.createSource([
-        "import 'lib.dart';",
-        "f(p) {",
-        "  if (p is A) {",
-        "    return p.v; // marker",
-        "  }",
-        "}"]);
+    addNamedSource("/lib.dart", r'''
+class A {
+  final v = 0;
+}''');
+    String code = r'''
+import 'lib.dart';
+f(p) {
+  if (p is A) {
+    return p.v; // marker
+  }
+}''';
     _assertTypeOfMarkedExpression(code, typeProvider.dynamicType, typeProvider.intType);
   }
 
   void test_finalPropertyInducingVariable_classMember_static() {
-    addNamedSource("/lib.dart", EngineTestCase.createSource(["class A {", "  static final V = 0;", "}"]));
-    String code = EngineTestCase.createSource([
-        "import 'lib.dart';",
-        "f() {",
-        "  return A.V; // marker",
-        "}"]);
+    addNamedSource("/lib.dart", r'''
+class A {
+  static final V = 0;
+}''');
+    String code = r'''
+import 'lib.dart';
+f() {
+  return A.V; // marker
+}''';
     _assertTypeOfMarkedExpression(code, typeProvider.dynamicType, typeProvider.intType);
   }
 
   void test_finalPropertyInducingVariable_topLevelVaraible_prefixed() {
     addNamedSource("/lib.dart", "final V = 0;");
-    String code = EngineTestCase.createSource([
-        "import 'lib.dart' as p;",
-        "f() {",
-        "  var v2 = p.V; // marker prefixed",
-        "}"]);
+    String code = r'''
+import 'lib.dart' as p;
+f() {
+  var v2 = p.V; // marker prefixed
+}''';
     _assertTypeOfMarkedExpression(code, typeProvider.dynamicType, typeProvider.intType);
   }
 
   void test_finalPropertyInducingVariable_topLevelVaraible_simple() {
     addNamedSource("/lib.dart", "final V = 0;");
-    String code = EngineTestCase.createSource([
-        "import 'lib.dart';",
-        "f() {",
-        "  return V; // marker simple",
-        "}"]);
+    String code = r'''
+import 'lib.dart';
+f() {
+  return V; // marker simple
+}''';
     _assertTypeOfMarkedExpression(code, typeProvider.dynamicType, typeProvider.intType);
   }
 
   void test_forEach() {
-    String code = EngineTestCase.createSource([
-        "main() {",
-        "  var list = <String> [];",
-        "  for (var e in list) {",
-        "    e;",
-        "  }",
-        "}"]);
+    String code = r'''
+main() {
+  var list = <String> [];
+  for (var e in list) {
+    e;
+  }
+}''';
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     InterfaceType stringType = typeProvider.stringType;
     // in the declaration
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(unit, code, "e in", (node) => node is SimpleIdentifier);
       JUnitTestCase.assertSame(stringType, identifier.propagatedType);
     }
     // in the loop body
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(unit, code, "e;", (node) => node is SimpleIdentifier);
       JUnitTestCase.assertSame(stringType, identifier.propagatedType);
     }
   }
 
   void test_functionExpression_asInvocationArgument() {
-    String code = EngineTestCase.createSource([
-        "class MyMap<K, V> {",
-        "  forEach(f(K key, V value)) {}",
-        "}",
-        "f(MyMap<int, String> m) {",
-        "  m.forEach((k, v) {",
-        "    k;",
-        "    v;",
-        "  });",
-        "}"]);
+    String code = r'''
+class MyMap<K, V> {
+  forEach(f(K key, V value)) {}
+}
+f(MyMap<int, String> m) {
+  m.forEach((k, v) {
+    k;
+    v;
+  });
+}''';
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // k
     DartType intType = typeProvider.intType;
     FormalParameter kParameter = EngineTestCase.findNode(unit, code, "k, ", (node) => node is SimpleFormalParameter);
     JUnitTestCase.assertSame(intType, kParameter.identifier.propagatedType);
     SimpleIdentifier kIdentifier = EngineTestCase.findNode(unit, code, "k;", (node) => node is SimpleIdentifier);
     JUnitTestCase.assertSame(intType, kIdentifier.propagatedType);
     JUnitTestCase.assertSame(typeProvider.dynamicType, kIdentifier.staticType);
     // v
     DartType stringType = typeProvider.stringType;
     FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", (node) => node is SimpleFormalParameter);
     JUnitTestCase.assertSame(stringType, vParameter.identifier.propagatedType);
     SimpleIdentifier vIdentifier = EngineTestCase.findNode(unit, code, "v;", (node) => node is SimpleIdentifier);
     JUnitTestCase.assertSame(stringType, vIdentifier.propagatedType);
     JUnitTestCase.assertSame(typeProvider.dynamicType, vIdentifier.staticType);
   }
 
   void test_functionExpression_asInvocationArgument_fromInferredInvocation() {
-    String code = EngineTestCase.createSource([
-        "class MyMap<K, V> {",
-        "  forEach(f(K key, V value)) {}",
-        "}",
-        "f(MyMap<int, String> m) {",
-        "  var m2 = m;",
-        "  m2.forEach((k, v) {});",
-        "}"]);
+    String code = r'''
+class MyMap<K, V> {
+  forEach(f(K key, V value)) {}
+}
+f(MyMap<int, String> m) {
+  var m2 = m;
+  m2.forEach((k, v) {});
+}''';
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // k
     DartType intType = typeProvider.intType;
     FormalParameter kParameter = EngineTestCase.findNode(unit, code, "k, ", (node) => node is SimpleFormalParameter);
     JUnitTestCase.assertSame(intType, kParameter.identifier.propagatedType);
     // v
     DartType stringType = typeProvider.stringType;
     FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", (node) => node is SimpleFormalParameter);
     JUnitTestCase.assertSame(stringType, vParameter.identifier.propagatedType);
   }
 
   void test_functionExpression_asInvocationArgument_functionExpressionInvocation() {
-    String code = EngineTestCase.createSource([
-        "main() {",
-        "  (f(String value)) {} ((v) {",
-        "    v;",
-        "  });",
-        "}"]);
+    String code = r'''
+main() {
+  (f(String value)) {} ((v) {
+    v;
+  });
+}''';
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // v
     DartType dynamicType = typeProvider.dynamicType;
     DartType stringType = typeProvider.stringType;
     FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", (node) => node is FormalParameter);
     JUnitTestCase.assertSame(stringType, vParameter.identifier.propagatedType);
     JUnitTestCase.assertSame(dynamicType, vParameter.identifier.staticType);
     SimpleIdentifier vIdentifier = EngineTestCase.findNode(unit, code, "v;", (node) => node is SimpleIdentifier);
     JUnitTestCase.assertSame(stringType, vIdentifier.propagatedType);
     JUnitTestCase.assertSame(dynamicType, vIdentifier.staticType);
   }
 
   void test_functionExpression_asInvocationArgument_keepIfLessSpecific() {
-    String code = EngineTestCase.createSource([
-        "class MyList {",
-        "  forEach(f(Object value)) {}",
-        "}",
-        "f(MyList list) {",
-        "  list.forEach((int v) {",
-        "    v;",
-        "  });",
-        "}"]);
+    String code = r'''
+class MyList {
+  forEach(f(Object value)) {}
+}
+f(MyList list) {
+  list.forEach((int v) {
+    v;
+  });
+}''';
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // v
     DartType intType = typeProvider.intType;
     FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", (node) => node is SimpleFormalParameter);
     JUnitTestCase.assertSame(null, vParameter.identifier.propagatedType);
     JUnitTestCase.assertSame(intType, vParameter.identifier.staticType);
     SimpleIdentifier vIdentifier = EngineTestCase.findNode(unit, code, "v;", (node) => node is SimpleIdentifier);
     JUnitTestCase.assertSame(intType, vIdentifier.staticType);
     JUnitTestCase.assertSame(null, vIdentifier.propagatedType);
   }
 
   void test_functionExpression_asInvocationArgument_notSubtypeOfStaticType() {
-    String code = EngineTestCase.createSource([
-        "class A {",
-        "  m(void f(int i)) {}",
-        "}",
-        "x() {",
-        "  A a = new A();",
-        "  a.m(() => 0);",
-        "}"]);
+    String code = r'''
+class A {
+  m(void f(int i)) {}
+}
+x() {
+  A a = new A();
+  a.m(() => 0);
+}''';
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // () => 0
     FunctionExpression functionExpression = EngineTestCase.findNode(unit, code, "() => 0)", (node) => node is FunctionExpression);
     JUnitTestCase.assertSame(0, (functionExpression.staticType as FunctionType).parameters.length);
     JUnitTestCase.assertSame(null, functionExpression.propagatedType);
   }
 
   void test_functionExpression_asInvocationArgument_replaceIfMoreSpecific() {
-    String code = EngineTestCase.createSource([
-        "class MyList<E> {",
-        "  forEach(f(E value)) {}",
-        "}",
-        "f(MyList<String> list) {",
-        "  list.forEach((Object v) {",
-        "    v;",
-        "  });",
-        "}"]);
+    String code = r'''
+class MyList<E> {
+  forEach(f(E value)) {}
+}
+f(MyList<String> list) {
+  list.forEach((Object v) {
+    v;
+  });
+}''';
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // v
     DartType stringType = typeProvider.stringType;
     FormalParameter vParameter = EngineTestCase.findNode(unit, code, "v)", (node) => node is SimpleFormalParameter);
     JUnitTestCase.assertSame(stringType, vParameter.identifier.propagatedType);
     JUnitTestCase.assertSame(typeProvider.objectType, vParameter.identifier.staticType);
     SimpleIdentifier vIdentifier = EngineTestCase.findNode(unit, code, "v;", (node) => node is SimpleIdentifier);
     JUnitTestCase.assertSame(stringType, vIdentifier.propagatedType);
   }
 
   void test_Future_then() {
-    String code = EngineTestCase.createSource([
-        "import 'dart:async';",
-        "main(Future<int> firstFuture) {",
-        "  firstFuture.then((p1) {",
-        "    return 1.0;",
-        "  }).then((p2) {",
-        "    return new Future<String>.value('str');",
-        "  }).then((p3) {",
-        "  });",
-        "}"]);
+    String code = r'''
+import 'dart:async';
+main(Future<int> firstFuture) {
+  firstFuture.then((p1) {
+    return 1.0;
+  }).then((p2) {
+    return new Future<String>.value('str');
+  }).then((p3) {
+  });
+}''';
     Source source = addSource(code);
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // p1
     FormalParameter p1 = EngineTestCase.findNode(unit, code, "p1) {", (node) => node is SimpleFormalParameter);
     JUnitTestCase.assertSame(typeProvider.intType, p1.identifier.propagatedType);
     // p2
     FormalParameter p2 = EngineTestCase.findNode(unit, code, "p2) {", (node) => node is SimpleFormalParameter);
     JUnitTestCase.assertSame(typeProvider.doubleType, p2.identifier.propagatedType);
     // p3
     FormalParameter p3 = EngineTestCase.findNode(unit, code, "p3) {", (node) => node is SimpleFormalParameter);
     JUnitTestCase.assertSame(typeProvider.stringType, p3.identifier.propagatedType);
   }
 
   void test_initializer() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  var v = 0;", "  return v;", "}"]));
+    Source source = addSource(r'''
+f() {
+  var v = 0;
+  return v;
+}''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     NodeList<Statement> statements = body.block.statements;
     // Type of 'v' in declaration.
     {
       VariableDeclarationStatement statement = statements[0] as VariableDeclarationStatement;
       SimpleIdentifier variableName = statement.variables.variables[0].name;
       JUnitTestCase.assertSame(typeProvider.dynamicType, variableName.staticType);
       JUnitTestCase.assertSame(typeProvider.intType, variableName.propagatedType);
     }
     // Type of 'v' in reference.
     {
       ReturnStatement statement = statements[1] as ReturnStatement;
       SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
       JUnitTestCase.assertSame(typeProvider.intType, variableName.propagatedType);
     }
   }
 
   void test_initializer_dereference() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  var v = 'String';", "  v.", "}"]));
+    Source source = addSource(r'''
+f() {
+  var v = 'String';
+  v.
+}''');
     LibraryElement library = resolve(source);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ExpressionStatement statement = body.block.statements[1] as ExpressionStatement;
     PrefixedIdentifier invocation = statement.expression as PrefixedIdentifier;
     SimpleIdentifier variableName = invocation.prefix;
     JUnitTestCase.assertSame(typeProvider.stringType, variableName.propagatedType);
   }
 
   void test_initializer_null() {
-    String code = EngineTestCase.createSource([
-        "main() {",
-        "  int v = null;",
-        "  return v; // marker",
-        "}"]);
+    String code = r'''
+main() {
+  int v = null;
+  return v; // marker
+}''';
     CompilationUnit unit;
     {
       Source source = addSource(code);
       LibraryElement library = resolve(source);
       assertNoErrors(source);
       verify([source]);
       unit = resolveCompilationUnit(source, library);
     }
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(unit, code, "v = null;", (node) => node is SimpleIdentifier);
       JUnitTestCase.assertSame(typeProvider.intType, identifier.staticType);
       JUnitTestCase.assertSame(null, identifier.propagatedType);
     }
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(unit, code, "v; // marker", (node) => node is SimpleIdentifier);
       JUnitTestCase.assertSame(typeProvider.intType, identifier.staticType);
       JUnitTestCase.assertSame(null, identifier.propagatedType);
     }
   }
 
   void test_is_conditional() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "A f(var p) {",
-        "  return (p is A) ? p : null;",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+A f(var p) {
+  return (p is A) ? p : null;
+}''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[0] as ReturnStatement;
     ConditionalExpression conditional = statement.expression as ConditionalExpression;
     SimpleIdentifier variableName = conditional.thenExpression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
 
   void test_is_if() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "A f(var p) {",
-        "  if (p is A) {",
-        "    return p;",
-        "  } else {",
-        "    return null;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+A f(var p) {
+  if (p is A) {
+    return p;
+  } else {
+    return null;
+  }
+}''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
 
   void test_is_if_lessSpecific() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "A f(A p) {",
-        "  if (p is String) {",
-        "    return p;",
-        "  } else {",
-        "    return null;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+A f(A p) {
+  if (p is String) {
+    return p;
+  } else {
+    return null;
+  }
+}''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     //    ClassDeclaration classA = (ClassDeclaration) unit.getDeclarations().get(0);
     //    InterfaceType typeA = classA.getElement().getType();
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(null, variableName.propagatedType);
   }
 
   void test_is_if_logicalAnd() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "A f(var p) {",
-        "  if (p is A && p != null) {",
-        "    return p;",
-        "  } else {",
-        "    return null;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+A f(var p) {
+  if (p is A && p != null) {
+    return p;
+  } else {
+    return null;
+  }
+}''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
 
   void test_is_postConditional() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "A f(var p) {",
-        "  A a = (p is A) ? p : throw null;",
-        "  return p;",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+A f(var p) {
+  A a = (p is A) ? p : throw null;
+  return p;
+}''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
 
   void test_is_postIf() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "A f(var p) {",
-        "  if (p is A) {",
-        "    A a = p;",
-        "  } else {",
-        "    return null;",
-        "  }",
-        "  return p;",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+A f(var p) {
+  if (p is A) {
+    A a = p;
+  } else {
+    return null;
+  }
+  return p;
+}''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
 
   void test_is_subclass() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "class B extends A {",
-        "  B m() => this;",
-        "}",
-        "A f(A p) {",
-        "  if (p is B) {",
-        "    return p.m();",
-        "  }",
-        "  return p;",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+class B extends A {
+  B m() => this;
+}
+A f(A p) {
+  if (p is B) {
+    return p.m();
+  }
+  return p;
+}''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[2] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
     MethodInvocation invocation = statement.expression as MethodInvocation;
     JUnitTestCase.assertNotNull(invocation.methodName.propagatedElement);
   }
 
   void test_is_while() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "A f(var p) {",
-        "  while (p is A) {",
-        "    return p;",
-        "  }",
-        "  return p;",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+A f(var p) {
+  while (p is A) {
+    return p;
+  }
+  return p;
+}''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     WhileStatement whileStatement = body.block.statements[0] as WhileStatement;
     ReturnStatement statement = (whileStatement.body as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
 
   void test_isNot_conditional() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "A f(var p) {",
-        "  return (p is! A) ? null : p;",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+A f(var p) {
+  return (p is! A) ? null : p;
+}''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[0] as ReturnStatement;
     ConditionalExpression conditional = statement.expression as ConditionalExpression;
     SimpleIdentifier variableName = conditional.elseExpression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
 
   void test_isNot_if() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "A f(var p) {",
-        "  if (p is! A) {",
-        "    return null;",
-        "  } else {",
-        "    return p;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+A f(var p) {
+  if (p is! A) {
+    return null;
+  } else {
+    return p;
+  }
+}''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = (ifStatement.elseStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
 
   void test_isNot_if_logicalOr() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "A f(var p) {",
-        "  if (p is! A || null == p) {",
-        "    return null;",
-        "  } else {",
-        "    return p;",
-        "  }",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+A f(var p) {
+  if (p is! A || null == p) {
+    return null;
+  } else {
+    return p;
+  }
+}''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement = (ifStatement.elseStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
 
   void test_isNot_postConditional() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "A f(var p) {",
-        "  A a = (p is! A) ? throw null : p;",
-        "  return p;",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+A f(var p) {
+  A a = (p is! A) ? throw null : p;
+  return p;
+}''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
 
   void test_isNot_postIf() {
-    Source source = addSource(EngineTestCase.createSource([
-        "class A {}",
-        "A f(var p) {",
-        "  if (p is! A) {",
-        "    return null;",
-        "  }",
-        "  return p;",
-        "}"]));
+    Source source = addSource(r'''
+class A {}
+A f(var p) {
+  if (p is! A) {
+    return null;
+  }
+  return p;
+}''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     JUnitTestCase.assertSame(typeA, variableName.propagatedType);
   }
 
   void test_issue20904BuggyTypePromotionAtIfJoin_2() {
     // https://code.google.com/p/dart/issues/detail?id=20904
     enableUnionTypes(false);
-    String code = EngineTestCase.createSource([
-        "f(var message) {",
-        "  if (message is Function) {",
-        "    message = '';",
-        "  }",
-        "  message; // marker",
-        "}"]);
+    String code = r'''
+f(var message) {
+  if (message is Function) {
+    message = '';
+  }
+  message; // marker
+}''';
     DartType t = _findMarkedIdentifier(code, "; // marker").propagatedType;
     JUnitTestCase.assertFalse(typeProvider.stringType == t);
     JUnitTestCase.assertFalse(typeProvider.functionType == t);
   }
 
   void test_issue20904BuggyTypePromotionAtIfJoin_5() {
     // https://code.google.com/p/dart/issues/detail?id=20904
     //
     // This is not an example of the 20904 bug, but rather,
     // an example of something that one obvious fix changes inadvertently: we
     // want to avoid using type information from is-checks when it
     // loses precision. I can't see how to get a bad hint this way, since
     // it seems the propagated type is not used to generate hints when a
     // more precise type would cause no hint. For example, for code like the
     // following, when the propagated type of [x] is [A] -- as happens for the
     // fix these tests aim to warn against -- there is no warning for
     // calling a method defined on [B] but not [A] (there aren't any, but pretend),
     // but there is for calling a method not defined on either.
     // By not overriding the propagated type via an is-check that loses
     // precision, we get more precise completion under an is-check. However,
     // I can only imagine strange code would make use of this feature.
     //
     // Here the is-check improves precision, so we use it.
-    String code = EngineTestCase.createSource([
-        "class A {}",
-        "class B extends A {}",
-        "f() {",
-        "  var a = new A();",
-        "  var b = new B();",
-        "  b; // B",
-        "  if (a is B) {",
-        "    return a; // marker",
-        "  }",
-        "}"]);
+    String code = r'''
+class A {}
+class B extends A {}
+f() {
+  var a = new A();
+  var b = new B();
+  b; // B
+  if (a is B) {
+    return a; // marker
+  }
+}''';
     DartType tB = _findMarkedIdentifier(code, "; // B").propagatedType;
     _assertTypeOfMarkedExpression(code, null, tB);
   }
 
   void test_issue20904BuggyTypePromotionAtIfJoin_6() {
     // https://code.google.com/p/dart/issues/detail?id=20904
     //
     // The other half of the *_5() test.
     //
     // Here the is-check loses precision, so we don't use it.
-    String code = EngineTestCase.createSource([
-        "class A {}",
-        "class B extends A {}",
-        "f() {",
-        "  var b = new B();",
-        "  b; // B",
-        "  if (b is A) {",
-        "    return b; // marker",
-        "  }",
-        "}"]);
+    String code = r'''
+class A {}
+class B extends A {}
+f() {
+  var b = new B();
+  b; // B
+  if (b is A) {
+    return b; // marker
+  }
+}''';
     DartType tB = _findMarkedIdentifier(code, "; // B").propagatedType;
     _assertTypeOfMarkedExpression(code, null, tB);
   }
 
   void test_listLiteral_different() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  var v = [0, '1', 2];", "  return v[2];", "}"]));
+    Source source = addSource(r'''
+f() {
+  var v = [0, '1', 2];
+  return v[2];
+}''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     IndexExpression indexExpression = statement.expression as IndexExpression;
     JUnitTestCase.assertNull(indexExpression.propagatedType);
   }
 
   void test_listLiteral_same() {
-    Source source = addSource(EngineTestCase.createSource(["f() {", "  var v = [0, 1, 2];", "  return v[2];", "}"]));
+    Source source = addSource(r'''
+f() {
+  var v = [0, 1, 2];
+  return v[2];
+}''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     IndexExpression indexExpression = statement.expression as IndexExpression;
     JUnitTestCase.assertNull(indexExpression.propagatedType);
     Expression v = indexExpression.target;
     InterfaceType propagatedType = v.propagatedType as InterfaceType;
     JUnitTestCase.assertSame(typeProvider.listType.element, propagatedType.element);
     List<DartType> typeArguments = propagatedType.typeArguments;
     EngineTestCase.assertLength(1, typeArguments);
     JUnitTestCase.assertSame(typeProvider.dynamicType, typeArguments[0]);
   }
 
   void test_mapLiteral_different() {
-    Source source = addSource(EngineTestCase.createSource([
-        "f() {",
-        "  var v = {'0' : 0, 1 : '1', '2' : 2};",
-        "  return v;",
-        "}"]));
+    Source source = addSource(r'''
+f() {
+  var v = {'0' : 0, 1 : '1', '2' : 2};
+  return v;
+}''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier identifier = statement.expression as SimpleIdentifier;
     InterfaceType propagatedType = identifier.propagatedType as InterfaceType;
     JUnitTestCase.assertSame(typeProvider.mapType.element, propagatedType.element);
     List<DartType> typeArguments = propagatedType.typeArguments;
     EngineTestCase.assertLength(2, typeArguments);
     JUnitTestCase.assertSame(typeProvider.dynamicType, typeArguments[0]);
     JUnitTestCase.assertSame(typeProvider.dynamicType, typeArguments[1]);
   }
 
   void test_mapLiteral_same() {
-    Source source = addSource(EngineTestCase.createSource([
-        "f() {",
-        "  var v = {'a' : 0, 'b' : 1, 'c' : 2};",
-        "  return v;",
-        "}"]));
+    Source source = addSource(r'''
+f() {
+  var v = {'a' : 0, 'b' : 1, 'c' : 2};
+  return v;
+}''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier identifier = statement.expression as SimpleIdentifier;
     InterfaceType propagatedType = identifier.propagatedType as InterfaceType;
     JUnitTestCase.assertSame(typeProvider.mapType.element, propagatedType.element);
     List<DartType> typeArguments = propagatedType.typeArguments;
     EngineTestCase.assertLength(2, typeArguments);
     JUnitTestCase.assertSame(typeProvider.dynamicType, typeArguments[0]);
     JUnitTestCase.assertSame(typeProvider.dynamicType, typeArguments[1]);
   }
 
   void test_mergePropagatedTypesAtJoinPoint_4() {
     // https://code.google.com/p/dart/issues/detail?id=19929
-    _assertTypeOfMarkedExpression(EngineTestCase.createSource([
-        "f5(x) {",
-        "  var y = [];",
-        "  if (x) {",
-        "    y = 0;",
-        "  } else {",
-        "    return y;",
-        "  }",
-        "  // Propagated type is [int] here: correct.",
-        "  return y; // marker",
-        "}"]), null, typeProvider.intType);
+    _assertTypeOfMarkedExpression(r'''
+f5(x) {
+  var y = [];
+  if (x) {
+    y = 0;
+  } else {
+    return y;
+  }
+  // Propagated type is [int] here: correct.
+  return y; // marker
+}''', null, typeProvider.intType);
   }
 
   void test_mergePropagatedTypesAtJoinPoint_6() {
     // https://code.google.com/p/dart/issues/detail?id=19929
     //
     // Labeled [break]s are unsafe for the purposes of [isAbruptTerminationStatement].
     //
     // This is tricky: the [break] jumps back above the [if], making
     // it into a loop of sorts. The [if] type-propagation code assumes
     // that [break] does not introduce a loop.
     enableUnionTypes(false);
-    String code = EngineTestCase.createSource([
-        "f() {",
-        "  var x = 0;",
-        "  var c = false;",
-        "  L: ",
-        "  if (c) {",
-        "  } else {",
-        "    x = '';",
-        "    c = true;",
-        "    break L;",
-        "  }",
-        "  x; // marker",
-        "}"]);
+    String code = r'''
+f() {
+  var x = 0;
+  var c = false;
+  L: 
+  if (c) {
+  } else {
+    x = '';
+    c = true;
+    break L;
+  }
+  x; // marker
+}''';
     DartType t = _findMarkedIdentifier(code, "; // marker").propagatedType;
     JUnitTestCase.assertTrue(typeProvider.intType.isSubtypeOf(t));
     JUnitTestCase.assertTrue(typeProvider.stringType.isSubtypeOf(t));
   }
 
   void test_objectMethodOnDynamicExpression_doubleEquals() {
     // https://code.google.com/p/dart/issues/detail?id=20342
     //
     // This was not actually part of Issue 20342, since the spec specifies a
     // static type of [bool] for [==] comparison and the implementation
     // was already consistent with the spec there. But, it's another
     // [Object] method, so it's included here.
-    _assertTypeOfMarkedExpression(EngineTestCase.createSource([
-        "f1(x) {",
-        "  var v = (x == x);",
-        "  return v; // marker",
-        "}"]), null, typeProvider.boolType);
+    _assertTypeOfMarkedExpression(r'''
+f1(x) {
+  var v = (x == x);
+  return v; // marker
+}''', null, typeProvider.boolType);
   }
 
   void test_objectMethodOnDynamicExpression_hashCode() {
     // https://code.google.com/p/dart/issues/detail?id=20342
-    _assertTypeOfMarkedExpression(EngineTestCase.createSource([
-        "f1(x) {",
-        "  var v = x.hashCode;",
-        "  return v; // marker",
-        "}"]), null, typeProvider.intType);
+    _assertTypeOfMarkedExpression(r'''
+f1(x) {
+  var v = x.hashCode;
+  return v; // marker
+}''', null, typeProvider.intType);
   }
 
   void test_objectMethodOnDynamicExpression_runtimeType() {
     // https://code.google.com/p/dart/issues/detail?id=20342
-    _assertTypeOfMarkedExpression(EngineTestCase.createSource([
-        "f1(x) {",
-        "  var v = x.runtimeType;",
-        "  return v; // marker",
-        "}"]), null, typeProvider.typeType);
+    _assertTypeOfMarkedExpression(r'''
+f1(x) {
+  var v = x.runtimeType;
+  return v; // marker
+}''', null, typeProvider.typeType);
   }
 
   void test_objectMethodOnDynamicExpression_toString() {
     // https://code.google.com/p/dart/issues/detail?id=20342
-    _assertTypeOfMarkedExpression(EngineTestCase.createSource([
-        "f1(x) {",
-        "  var v = x.toString();",
-        "  return v; // marker",
-        "}"]), null, typeProvider.stringType);
+    _assertTypeOfMarkedExpression(r'''
+f1(x) {
+  var v = x.toString();
+  return v; // marker
+}''', null, typeProvider.stringType);
   }
 
   void test_propagatedReturnType_function_hasReturnType_returnsNull() {
-    String code = EngineTestCase.createSource(["String f() => null;", "main() {", "  var v = f();", "}"]);
+    String code = r'''
+String f() => null;
+main() {
+  var v = f();
+}''';
     _assertPropagatedReturnType(code, typeProvider.dynamicType, typeProvider.stringType);
   }
 
   void test_propagatedReturnType_function_lessSpecificStaticReturnType() {
-    String code = EngineTestCase.createSource(["Object f() => 42;", "main() {", "  var v = f();", "}"]);
+    String code = r'''
+Object f() => 42;
+main() {
+  var v = f();
+}''';
     _assertPropagatedReturnType(code, typeProvider.dynamicType, typeProvider.intType);
   }
 
   void test_propagatedReturnType_function_moreSpecificStaticReturnType() {
-    String code = EngineTestCase.createSource([
-        "int f(v) => (v as num);",
-        "main() {",
-        "  var v = f(3);",
-        "}"]);
+    String code = r'''
+int f(v) => (v as num);
+main() {
+  var v = f(3);
+}''';
     _assertPropagatedReturnType(code, typeProvider.dynamicType, typeProvider.intType);
   }
 
   void test_propagatedReturnType_function_noReturnTypeName_blockBody_multipleReturns() {
-    String code = EngineTestCase.createSource([
-        "f() {",
-        "  if (true) return 0;",
-        "  return 1.0;",
-        "}",
-        "main() {",
-        "  var v = f();",
-        "}"]);
+    String code = r'''
+f() {
+  if (true) return 0;
+  return 1.0;
+}
+main() {
+  var v = f();
+}''';
     _assertPropagatedReturnType(code, typeProvider.dynamicType, typeProvider.numType);
   }
 
   void test_propagatedReturnType_function_noReturnTypeName_blockBody_oneReturn() {
-    String code = EngineTestCase.createSource([
-        "f() {",
-        "  var z = 42;",
-        "  return z;",
-        "}",
-        "main() {",
-        "  var v = f();",
-        "}"]);
+    String code = r'''
+f() {
+  var z = 42;
+  return z;
+}
+main() {
+  var v = f();
+}''';
     _assertPropagatedReturnType(code, typeProvider.dynamicType, typeProvider.intType);
   }
 
   void test_propagatedReturnType_function_noReturnTypeName_expressionBody() {
-    String code = EngineTestCase.createSource(["f() => 42;", "main() {", "  var v = f();", "}"]);
+    String code = r'''
+f() => 42;
+main() {
+  var v = f();
+}''';
     _assertPropagatedReturnType(code, typeProvider.dynamicType, typeProvider.intType);
   }
 
   void test_propagatedReturnType_localFunction() {
-    String code = EngineTestCase.createSource(["main() {", "  f() => 42;", "  var v = f();", "}"]);
+    String code = r'''
+main() {
+  f() => 42;
+  var v = f();
+}''';
     _assertPropagatedReturnType(code, typeProvider.dynamicType, typeProvider.intType);
   }
 
   void test_query() {
-    Source source = addSource(EngineTestCase.createSource([
-        "import 'dart:html';",
-        "",
-        "main() {",
-        "  var v1 = query('a');",
-        "  var v2 = query('A');",
-        "  var v3 = query('body:active');",
-        "  var v4 = query('button[foo=\"bar\"]');",
-        "  var v5 = query('div.class');",
-        "  var v6 = query('input#id');",
-        "  var v7 = query('select#id');",
-        "  // invocation of method",
-        "  var m1 = document.query('div');",
-        " // unsupported currently",
-        "  var b1 = query('noSuchTag');",
-        "  var b2 = query('DART_EDITOR_NO_SUCH_TYPE');",
-        "  var b3 = query('body div');",
-        "  return [v1, v2, v3, v4, v5, v6, v7, m1, b1, b2, b3];",
-        "}"]));
+    Source source = addSource(r'''
+import 'dart:html';
+
+main() {
+  var v1 = query('a');
+  var v2 = query('A');
+  var v3 = query('body:active');
+  var v4 = query('button[foo="bar"]');
+  var v5 = query('div.class');
+  var v6 = query('input#id');
+  var v7 = query('select#id');
+  // invocation of method
+  var m1 = document.query('div');
+ // unsupported currently
+  var b1 = query('noSuchTag');
+  var b2 = query('DART_EDITOR_NO_SUCH_TYPE');
+  var b3 = query('body div');
+  return [v1, v2, v3, v4, v5, v6, v7, m1, b1, b2, b3];
+}''');
     LibraryElement library = resolve(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration main = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = main.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[11] as ReturnStatement;
     NodeList<Expression> elements = (statement.expression as ListLiteral).elements;
     JUnitTestCase.assertEquals("AnchorElement", elements[0].propagatedType.name);
     JUnitTestCase.assertEquals("AnchorElement", elements[1].propagatedType.name);
@@ skipping 503 matching lines @@
   runReflectiveTests(TypeResolverVisitorTest);
   runReflectiveTests(CheckedModeCompileTimeErrorCodeTest);
   runReflectiveTests(ErrorResolverTest);
   runReflectiveTests(HintCodeTest);
   runReflectiveTests(MemberMapTest);
   runReflectiveTests(NonHintCodeTest);
   runReflectiveTests(SimpleResolverTest);
   runReflectiveTests(StrictModeTest);
   runReflectiveTests(TypePropagationTest);
 }