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

pkg/analyzer/test/generated/parser_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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.parser_test;
 
 import 'package:analyzer/src/generated/java_core.dart';
@@ skipping 257 matching lines @@
       JUnitTestCase.assertSame(target, index.realTarget);
     }
   }
 
   void test_conditionalExpression_precedence_logicalOrExpression() {
     ConditionalExpression expression = ParserTestCase.parseExpression("a | b ? y : z", []);
     EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.condition);
   }
 
   void test_constructor_initializer_withParenthesizedExpression() {
-    CompilationUnit unit = ParserTestCase.parseCompilationUnit(EngineTestCase.createSource([
-        "class C {",
-        "  C() :",
-        "    this.a = (b == null ? c : d) {",
-        "  }",
-        "}"]), []);
+    CompilationUnit unit = ParserTestCase.parseCompilationUnit(r'''
+class C {
+  C() :
+    this.a = (b == null ? c : d) {
+  }
+}''', []);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     EngineTestCase.assertSizeOfList(1, declarations);
   }
 
   void test_equalityExpression_normal() {
     BinaryExpression expression = ParserTestCase.parseExpression("x == y != z", [ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND]);
     EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_equalityExpression_precedence_relational_left() {
@@ skipping 1810 matching lines @@
     parseFunctionBodies = true;
   }
 }
 
 /**
  * The class `RecoveryParserTest` defines parser tests that test the parsing of invalid code
  * sequences to ensure that the correct recovery steps are taken in the parser.
  */
 class RecoveryParserTest extends ParserTestCase {
   void fail_incomplete_returnType() {
-    ParserTestCase.parseCompilationUnit(EngineTestCase.createSource([
-        "Map<Symbol, convertStringToSymbolMap(Map<String, dynamic> map) {",
-        "  if (map == null) return null;",
-        "  Map<Symbol, dynamic> result = new Map<Symbol, dynamic>();",
-        "  map.forEach((name, value) {",
-        "    result[new Symbol(name)] = value;",
-        "  });",
-        "  return result;",
-        "}"]), []);
+    ParserTestCase.parseCompilationUnit(r'''
+Map<Symbol, convertStringToSymbolMap(Map<String, dynamic> map) {
+  if (map == null) return null;
+  Map<Symbol, dynamic> result = new Map<Symbol, dynamic>();
+  map.forEach((name, value) {
+    result[new Symbol(name)] = value;
+  });
+  return result;
+}''', []);
   }
 
   void test_additiveExpression_missing_LHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("+ y", [ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.leftOperand);
     JUnitTestCase.assertTrue(expression.leftOperand.isSynthetic);
   }
 
   void test_additiveExpression_missing_LHS_RHS() {
     BinaryExpression expression = ParserTestCase.parseExpression("+", [
@@ skipping 220 matching lines @@
   }
 
   void test_bitwiseXorExpression_super() {
     BinaryExpression expression = ParserTestCase.parseExpression("super ^  ^", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.leftOperand);
   }
 
   void test_classTypeAlias_withBody() {
-    ParserTestCase.parseCompilationUnit(EngineTestCase.createSource(["class A {}", "class B = Object with A {}"]), [ParserErrorCode.EXPECTED_TOKEN]);
+    ParserTestCase.parseCompilationUnit(r'''
+class A {}
+class B = Object with A {}''', [ParserErrorCode.EXPECTED_TOKEN]);
   }
 
   void test_conditionalExpression_missingElse() {
     ConditionalExpression expression = ParserTestCase.parse4("parseConditionalExpression", "x ? y :", [ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertInstanceOf((obj) => obj is SimpleIdentifier, SimpleIdentifier, expression.elseExpression);
     JUnitTestCase.assertTrue(expression.elseExpression.isSynthetic);
   }
 
   void test_conditionalExpression_missingThen() {
     ConditionalExpression expression = ParserTestCase.parse4("parseConditionalExpression", "x ? : z", [ParserErrorCode.MISSING_IDENTIFIER]);
@@ skipping 139 matching lines @@
     EngineTestCase.assertSizeOfList(1, declarations);
     CompilationUnitMember member = declarations[0];
     EngineTestCase.assertInstanceOf((obj) => obj is TopLevelVariableDeclaration, TopLevelVariableDeclaration, member);
     NodeList<VariableDeclaration> variables = (member as TopLevelVariableDeclaration).variables.variables;
     EngineTestCase.assertSizeOfList(1, variables);
     SimpleIdentifier name = variables[0].name;
     JUnitTestCase.assertTrue(name.isSynthetic);
   }
 
   void test_incompleteField_const() {
-    CompilationUnit unit = ParserTestCase.parseCompilationUnit(EngineTestCase.createSource(["class C {", "  const", "}"]), [
+    CompilationUnit unit = ParserTestCase.parseCompilationUnit(r'''
+class C {
+  const
+}''', [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.EXPECTED_TOKEN]);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     EngineTestCase.assertSizeOfList(1, declarations);
     CompilationUnitMember unitMember = declarations[0];
     EngineTestCase.assertInstanceOf((obj) => obj is ClassDeclaration, ClassDeclaration, unitMember);
     NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
     EngineTestCase.assertSizeOfList(1, members);
     ClassMember classMember = members[0];
     EngineTestCase.assertInstanceOf((obj) => obj is FieldDeclaration, FieldDeclaration, classMember);
     VariableDeclarationList fieldList = (classMember as FieldDeclaration).fields;
     JUnitTestCase.assertEquals(Keyword.CONST, (fieldList.keyword as KeywordToken).keyword);
     NodeList<VariableDeclaration> fields = fieldList.variables;
     EngineTestCase.assertSizeOfList(1, fields);
     VariableDeclaration field = fields[0];
     JUnitTestCase.assertTrue(field.name.isSynthetic);
   }
 
   void test_incompleteField_final() {
-    CompilationUnit unit = ParserTestCase.parseCompilationUnit(EngineTestCase.createSource(["class C {", "  final", "}"]), [
+    CompilationUnit unit = ParserTestCase.parseCompilationUnit(r'''
+class C {
+  final
+}''', [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.EXPECTED_TOKEN]);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     EngineTestCase.assertSizeOfList(1, declarations);
     CompilationUnitMember unitMember = declarations[0];
     EngineTestCase.assertInstanceOf((obj) => obj is ClassDeclaration, ClassDeclaration, unitMember);
     NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
     EngineTestCase.assertSizeOfList(1, members);
     ClassMember classMember = members[0];
     EngineTestCase.assertInstanceOf((obj) => obj is FieldDeclaration, FieldDeclaration, classMember);
     VariableDeclarationList fieldList = (classMember as FieldDeclaration).fields;
     JUnitTestCase.assertEquals(Keyword.FINAL, (fieldList.keyword as KeywordToken).keyword);
     NodeList<VariableDeclaration> fields = fieldList.variables;
     EngineTestCase.assertSizeOfList(1, fields);
     VariableDeclaration field = fields[0];
     JUnitTestCase.assertTrue(field.name.isSynthetic);
   }
 
   void test_incompleteField_var() {
-    CompilationUnit unit = ParserTestCase.parseCompilationUnit(EngineTestCase.createSource(["class C {", "  var", "}"]), [
+    CompilationUnit unit = ParserTestCase.parseCompilationUnit(r'''
+class C {
+  var
+}''', [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.EXPECTED_TOKEN]);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     EngineTestCase.assertSizeOfList(1, declarations);
     CompilationUnitMember unitMember = declarations[0];
     EngineTestCase.assertInstanceOf((obj) => obj is ClassDeclaration, ClassDeclaration, unitMember);
     NodeList<ClassMember> members = (unitMember as ClassDeclaration).members;
     EngineTestCase.assertSizeOfList(1, members);
     ClassMember classMember = members[0];
     EngineTestCase.assertInstanceOf((obj) => obj is FieldDeclaration, FieldDeclaration, classMember);
@@ skipping 94 matching lines @@
 
   void test_logicalOrExpression_precedence_logicalAnd_right() {
     BinaryExpression expression = ParserTestCase.parseExpression("|| &&", [
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER,
         ParserErrorCode.MISSING_IDENTIFIER]);
     EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression.rightOperand);
   }
 
   void test_missingGet() {
-    CompilationUnit unit = ParserTestCase.parseCompilationUnit(EngineTestCase.createSource(["class C {", "  int length {}", "  void foo() {}", "}"]), [ParserErrorCode.MISSING_GET]);
+    CompilationUnit unit = ParserTestCase.parseCompilationUnit(r'''
+class C {
+  int length {}
+  void foo() {}
+}''', [ParserErrorCode.MISSING_GET]);
     JUnitTestCase.assertNotNull(unit);
     ClassDeclaration classDeclaration = unit.declarations[0] as ClassDeclaration;
     NodeList<ClassMember> members = classDeclaration.members;
     EngineTestCase.assertSizeOfList(2, members);
     EngineTestCase.assertInstanceOf((obj) => obj is MethodDeclaration, MethodDeclaration, members[0]);
     ClassMember member = members[1];
     EngineTestCase.assertInstanceOf((obj) => obj is MethodDeclaration, MethodDeclaration, member);
     JUnitTestCase.assertEquals("foo", (member as MethodDeclaration).name.name);
   }
 
@@ skipping 1207 matching lines @@
     JUnitTestCase.assertNotNull(selector);
   }
 
   void test_parseAwaitExpression() {
     AwaitExpression expression = ParserTestCase.parse4("parseAwaitExpression", "await x;", []);
     JUnitTestCase.assertNotNull(expression.awaitKeyword);
     JUnitTestCase.assertNotNull(expression.expression);
   }
 
   void test_parseAwaitExpression_asStatement_inAsync() {
-    MethodDeclaration method = ParserTestCase.parse("parseClassMember", <Object> ["C"], EngineTestCase.createSource(["m() async { await x; }"]));
+    MethodDeclaration method = ParserTestCase.parse("parseClassMember", <Object> ["C"], "m() async { await x; }");
     FunctionBody body = method.body;
     EngineTestCase.assertInstanceOf((obj) => obj is BlockFunctionBody, BlockFunctionBody, body);
     Statement statement = (body as BlockFunctionBody).block.statements[0];
     EngineTestCase.assertInstanceOf((obj) => obj is ExpressionStatement, ExpressionStatement, statement);
     Expression expression = (statement as ExpressionStatement).expression;
     EngineTestCase.assertInstanceOf((obj) => obj is AwaitExpression, AwaitExpression, expression);
     JUnitTestCase.assertNotNull((expression as AwaitExpression).awaitKeyword);
     JUnitTestCase.assertNotNull((expression as AwaitExpression).expression);
   }
 
   void test_parseAwaitExpression_asStatement_inSync() {
-    MethodDeclaration method = ParserTestCase.parse("parseClassMember", <Object> ["C"], EngineTestCase.createSource(["m() { await x; }"]));
+    MethodDeclaration method = ParserTestCase.parse("parseClassMember", <Object> ["C"], "m() { await x; }");
     FunctionBody body = method.body;
     EngineTestCase.assertInstanceOf((obj) => obj is BlockFunctionBody, BlockFunctionBody, body);
     Statement statement = (body as BlockFunctionBody).block.statements[0];
     EngineTestCase.assertInstanceOf((obj) => obj is VariableDeclarationStatement, VariableDeclarationStatement, statement);
   }
 
   void test_parseAwaitExpression_inSync() {
-    MethodDeclaration method = ParserTestCase.parse("parseClassMember", <Object> ["C"], EngineTestCase.createSource(["m() { return await x + await y; }"]));
+    MethodDeclaration method = ParserTestCase.parse("parseClassMember", <Object> ["C"], "m() { return await x + await y; }");
     FunctionBody body = method.body;
     EngineTestCase.assertInstanceOf((obj) => obj is BlockFunctionBody, BlockFunctionBody, body);
     Statement statement = (body as BlockFunctionBody).block.statements[0];
     EngineTestCase.assertInstanceOf((obj) => obj is ReturnStatement, ReturnStatement, statement);
     Expression expression = (statement as ReturnStatement).expression;
     EngineTestCase.assertInstanceOf((obj) => obj is BinaryExpression, BinaryExpression, expression);
     EngineTestCase.assertInstanceOf((obj) => obj is AwaitExpression, AwaitExpression, (expression as BinaryExpression).leftOperand);
     EngineTestCase.assertInstanceOf((obj) => obj is AwaitExpression, AwaitExpression, (expression as BinaryExpression).rightOperand);
   }
 
@@ skipping 763 matching lines @@
     EngineTestCase.assertSizeOfList(2, commentAndMetadata.metadata);
   }
 
   void test_parseCommentAndMetadata_none() {
     CommentAndMetadata commentAndMetadata = ParserTestCase.parse4("parseCommentAndMetadata", "void", []);
     JUnitTestCase.assertNull(commentAndMetadata.comment);
     EngineTestCase.assertSizeOfList(0, commentAndMetadata.metadata);
   }
 
   void test_parseCommentAndMetadata_singleLine() {
-    CommentAndMetadata commentAndMetadata = ParserTestCase.parse4("parseCommentAndMetadata", EngineTestCase.createSource(["/// 1", "/// 2", "void"]), []);
+    CommentAndMetadata commentAndMetadata = ParserTestCase.parse4("parseCommentAndMetadata", r'''
+/// 1
+/// 2
+void''', []);
     JUnitTestCase.assertNotNull(commentAndMetadata.comment);
     EngineTestCase.assertSizeOfList(0, commentAndMetadata.metadata);
   }
 
   void test_parseCommentReference_new_prefixed() {
     CommentReference reference = ParserTestCase.parse("parseCommentReference", <Object> ["new a.b", 7], "");
     PrefixedIdentifier prefixedIdentifier = EngineTestCase.assertInstanceOf((obj) => obj is PrefixedIdentifier, PrefixedIdentifier, reference.identifier);
     SimpleIdentifier prefix = prefixedIdentifier.prefix;
     JUnitTestCase.assertNotNull(prefix.token);
     JUnitTestCase.assertEquals("a", prefix.name);
@@ skipping 3539 matching lines @@
 main() {
   _ut.groupSep = ' | ';
   runReflectiveTests(ComplexParserTest);
   runReflectiveTests(ErrorParserTest);
   runReflectiveTests(IncrementalParserTest);
   runReflectiveTests(NonErrorParserTest);
   runReflectiveTests(RecoveryParserTest);
   runReflectiveTests(ResolutionCopierTest);
   runReflectiveTests(SimpleParserTest);
 }