More fixes for failures on the Windows bot

pkg/analyzer/test/generated/element_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.element_test;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisContext, AnalysisOptionsImpl;
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/testing/ast_factory.dart';
 import 'package:analyzer/src/generated/testing/element_factory.dart';
 import 'package:analyzer/src/generated/testing/test_type_provider.dart';
 import 'package:unittest/unittest.dart';
 
 import '../reflective_tests.dart';
+import '../utils.dart';
 import 'resolver_test.dart' show TestTypeProvider, AnalysisContextHelper;
 import 'test_support.dart';
 
 main() {
-  groupSep = ' | ';
+  initializeTestEnvironment();
   runReflectiveTests(ElementKindTest);
   runReflectiveTests(FieldElementImplTest);
   runReflectiveTests(FunctionTypeImplTest);
   runReflectiveTests(InterfaceTypeImplTest);
   runReflectiveTests(TypeParameterTypeImplTest);
   runReflectiveTests(VoidTypeImplTest);
   runReflectiveTests(ClassElementImplTest);
   runReflectiveTests(CompilationUnitElementImplTest);
   runReflectiveTests(ElementLocationImplTest);
   runReflectiveTests(ElementImplTest);
   runReflectiveTests(HtmlElementImplTest);
   runReflectiveTests(LibraryElementImplTest);
   runReflectiveTests(MethodElementImplTest);
   runReflectiveTests(MultiplyDefinedElementImplTest);
   runReflectiveTests(ParameterElementImplTest);
 }
 
 @reflectiveTest
 class ClassElementImplTest extends EngineTestCase {
   void test_computeNode_ClassDeclaration() {
     AnalysisContextHelper contextHelper = new AnalysisContextHelper();
     AnalysisContext context = contextHelper.context;
-    Source source = contextHelper.addSource("/test.dart", r'''
+    Source source = contextHelper.addSource(
+        "/test.dart",
+        r'''
 class A {}
 @deprecated class B {}
 enum C {C1, C2, C3}
 @deprecated enum D {D1, D2, D3}''');
     // prepare CompilationUnitElement
     LibraryElement libraryElement = context.computeLibraryElement(source);
     CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
     // A
     {
       ClassElement elementA = unitElement.getType("A");
@@ skipping 32 matching lines @@
       EnumDeclaration nodeC = elementD.computeNode();
       expect(nodeC, isNotNull);
       expect(nodeC.name.name, "D");
       expect(nodeC.element, same(elementD));
     }
   }
 
   void test_computeNode_ClassTypeAlias() {
     AnalysisContextHelper contextHelper = new AnalysisContextHelper();
     AnalysisContext context = contextHelper.context;
-    Source source = contextHelper.addSource("/test.dart", r'''
+    Source source = contextHelper.addSource(
+        "/test.dart",
+        r'''
 abstract class A<K, V> = Object with MapMixin<K, V>;
 ''');
     // prepare CompilationUnitElement
     LibraryElement libraryElement = context.computeLibraryElement(source);
     CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
     // A
     {
       ClassElement elementA = unitElement.getType("A");
       ClassTypeAlias nodeA = elementA.computeNode();
       expect(nodeA, isNotNull);
@@ skipping 870 matching lines @@
       expect(element.enclosingElement, mainElement);
       expect(element.name, 'localVar');
     }
     // null
     expect(unitElement.getElementAt(1000), isNull);
   }
 
   void test_getElementAt_multipleUnitsInLibrary() {
     AnalysisContextHelper contextHelper = new AnalysisContextHelper();
     AnalysisContext context = contextHelper.context;
-    Source libSource = contextHelper.addSource("/my_lib.dart", r'''
+    Source libSource = contextHelper.addSource(
+        "/my_lib.dart",
+        r'''
 library my_lib;
 part 'unit_a.dart';
 part 'unit_b.dart';
 ''');
     Source unitSourceA =
         contextHelper.addSource("/unit_a.dart", 'part of my_lib;class A {}');
     Source unitSourceB =
         contextHelper.addSource("/unit_b.dart", 'part of my_lib;class B {}');
     int offset = 'part of my_lib;class A {}'.indexOf('A {}');
     // prepare library/unit elements
@@ skipping 230 matching lines @@
     ElementLocationImpl second = new ElementLocationImpl.con2(encoding);
     expect(first.hashCode == second.hashCode, isTrue);
   }
 }
 
 @reflectiveTest
 class FieldElementImplTest extends EngineTestCase {
   void test_computeNode() {
     AnalysisContextHelper contextHelper = new AnalysisContextHelper();
     AnalysisContext context = contextHelper.context;
-    Source source = contextHelper.addSource("/test.dart", r'''
+    Source source = contextHelper.addSource(
+        "/test.dart",
+        r'''
 class A {
   int a;
 }
 enum B {B1, B2, B3}''');
     // prepare CompilationUnitElement
     LibraryElement libraryElement = context.computeLibraryElement(source);
     CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
     // A
     {
       FieldElement elementA = unitElement.getType("A").getField('a');
       VariableDeclaration nodeA = elementA.computeNode();
       expect(nodeA, isNotNull);
       expect(nodeA.name.name, "a");
       expect(nodeA.element, same(elementA));
     }
     // B
     {
       FieldElement elementB = unitElement.getEnum("B").getField('B2');
       EnumConstantDeclaration nodeB = elementB.computeNode();
       expect(nodeB, isNotNull);
       expect(nodeB.name.name, "B2");
       expect(nodeB.element, same(elementB));
     }
   }
 }
 
 @reflectiveTest
 class FunctionTypeImplTest extends EngineTestCase {
   void test_creation() {
-    expect(new FunctionTypeImpl(
+    expect(
+        new FunctionTypeImpl(
             new FunctionElementImpl.forNode(AstFactory.identifier3("f"))),
         isNotNull);
   }
 
   void test_equality_recursive() {
     FunctionTypeAliasElementImpl s =
         ElementFactory.functionTypeAliasElement('s');
     FunctionTypeAliasElementImpl t =
         ElementFactory.functionTypeAliasElement('t');
     FunctionTypeAliasElementImpl u =
@@ skipping 123 matching lines @@
     FunctionType t = ElementFactory.functionElement4(
         "t", null, null, <String>["name"], <ClassElement>[a]).type;
     FunctionType s = ElementFactory.functionElement4(
         "s", null, null, <String>["name"], <ClassElement>[b]).type;
     expect(t.isSubtypeOf(s), isTrue);
     expect(s.isSubtypeOf(t), isTrue);
   }
 
   void test_isSubtypeOf_namedParameters_isNotAssignable() {
     // ! ({name: A}) -> void <: ({name: B}) -> void
-    FunctionType t = ElementFactory.functionElement4("t", null, null,
+    FunctionType t = ElementFactory.functionElement4(
+        "t",
+        null,
+        null,
         <String>["name"],
         <ClassElement>[ElementFactory.classElement2("A")]).type;
-    FunctionType s = ElementFactory.functionElement4("s", null, null,
+    FunctionType s = ElementFactory.functionElement4(
+        "s",
+        null,
+        null,
         <String>["name"],
         <ClassElement>[ElementFactory.classElement2("B")]).type;
     expect(t.isSubtypeOf(s), isFalse);
   }
 
   void test_isSubtypeOf_namedParameters_namesDifferent() {
     // B extends A
     // void t({A name}) {}
     // void s({A diff}) {}
     // ! t <: s
@@ skipping 75 matching lines @@
         ElementFactory.functionElement6("t", null, <ClassElement>[a]).type;
     FunctionType s =
         ElementFactory.functionElement5("s", <ClassElement>[a]).type;
     expect(t.isSubtypeOf(s), isTrue);
     expect(s.isSubtypeOf(t), isFalse);
   }
 
   void test_isSubtypeOf_normalAndPositionalArgs_2() {
     // (a, [a]) -> void <: (a) -> void
     ClassElement a = ElementFactory.classElement2("A");
-    FunctionType t = ElementFactory.functionElement6(
-        "t", <ClassElement>[a], <ClassElement>[a]).type;
+    FunctionType t = ElementFactory
+        .functionElement6("t", <ClassElement>[a], <ClassElement>[a]).type;
     FunctionType s =
         ElementFactory.functionElement5("s", <ClassElement>[a]).type;
     expect(t.isSubtypeOf(s), isTrue);
     expect(s.isSubtypeOf(t), isFalse);
   }
 
   void test_isSubtypeOf_normalAndPositionalArgs_3() {
     // ([a]) -> void <: () -> void
     ClassElement a = ElementFactory.classElement2("A");
     FunctionType t =
         ElementFactory.functionElement6("t", null, <ClassElement>[a]).type;
     FunctionType s = ElementFactory.functionElement("s").type;
     expect(t.isSubtypeOf(s), isTrue);
     expect(s.isSubtypeOf(t), isFalse);
   }
 
   void test_isSubtypeOf_normalAndPositionalArgs_4() {
     // (a, b, [c, d, e]) -> void <: (a, b, c, [d]) -> void
     ClassElement a = ElementFactory.classElement2("A");
     ClassElement b = ElementFactory.classElement2("B");
     ClassElement c = ElementFactory.classElement2("C");
     ClassElement d = ElementFactory.classElement2("D");
     ClassElement e = ElementFactory.classElement2("E");
     FunctionType t = ElementFactory.functionElement6(
         "t", <ClassElement>[a, b], <ClassElement>[c, d, e]).type;
-    FunctionType s = ElementFactory.functionElement6(
-        "s", <ClassElement>[a, b, c], <ClassElement>[d]).type;
+    FunctionType s = ElementFactory
+        .functionElement6("s", <ClassElement>[a, b, c], <ClassElement>[d]).type;
     expect(t.isSubtypeOf(s), isTrue);
     expect(s.isSubtypeOf(t), isFalse);
   }
 
   void test_isSubtypeOf_normalParameters_isAssignable() {
     // B extends A
     // (a) -> void <: (b) -> void
     // (b) -> void <: (a) -> void
     ClassElement a = ElementFactory.classElement2("A");
     ClassElement b = ElementFactory.classElement("B", a.type);
@@ skipping 111 matching lines @@
     ClassElement a = ElementFactory.classElement2("A");
     ClassElement b = ElementFactory.classElement("B", a.type);
     FunctionType t = ElementFactory.functionElement2("t", a).type;
     FunctionType s = ElementFactory.functionElement2("s", b).type;
     expect(t.isSubtypeOf(s), isTrue);
     expect(s.isSubtypeOf(t), isTrue);
   }
 
   void test_isSubtypeOf_returnType_tNotAssignableToS() {
     // ! () -> A <: () -> B
-    FunctionType t = ElementFactory.functionElement2(
-        "t", ElementFactory.classElement2("A")).type;
-    FunctionType s = ElementFactory.functionElement2(
-        "s", ElementFactory.classElement2("B")).type;
+    FunctionType t = ElementFactory
+        .functionElement2("t", ElementFactory.classElement2("A"))
+        .type;
+    FunctionType s = ElementFactory
+        .functionElement2("s", ElementFactory.classElement2("B"))
+        .type;
     expect(t.isSubtypeOf(s), isFalse);
   }
 
   void test_isSubtypeOf_typeParameters_matchesBounds() {
     TestTypeProvider provider = new TestTypeProvider();
     InterfaceType boolType = provider.boolType;
     InterfaceType stringType = provider.stringType;
     TypeParameterElementImpl parameterB =
         new TypeParameterElementImpl.forNode(AstFactory.identifier3("B"));
     parameterB.bound = boolType;
@@ skipping 23 matching lines @@
     functionElement.type = functionType;
     expect(functionType.isAssignableTo(functionAliasType), isTrue);
   }
 
   void test_isSubtypeOf_wrongFunctionType_normal_named() {
     // ! (a) -> void <: ({name: A}) -> void
     // ! ({name: A}) -> void <: (a) -> void
     ClassElement a = ElementFactory.classElement2("A");
     FunctionType t =
         ElementFactory.functionElement5("t", <ClassElement>[a]).type;
-    FunctionType s = ElementFactory.functionElement7(
-        "s", null, <String>["name"], <ClassElement>[a]).type;
+    FunctionType s = ElementFactory
+        .functionElement7("s", null, <String>["name"], <ClassElement>[a]).type;
     expect(t.isSubtypeOf(s), isFalse);
     expect(s.isSubtypeOf(t), isFalse);
   }
 
   void test_isSubtypeOf_wrongFunctionType_optional_named() {
     // ! ([a]) -> void <: ({name: A}) -> void
     // ! ({name: A}) -> void <: ([a]) -> void
     ClassElement a = ElementFactory.classElement2("A");
     FunctionType t =
         ElementFactory.functionElement6("t", null, <ClassElement>[a]).type;
-    FunctionType s = ElementFactory.functionElement7(
-        "s", null, <String>["name"], <ClassElement>[a]).type;
+    FunctionType s = ElementFactory
+        .functionElement7("s", null, <String>["name"], <ClassElement>[a]).type;
     expect(t.isSubtypeOf(s), isFalse);
     expect(s.isSubtypeOf(t), isFalse);
   }
 
   void test_namedParameterTypes_pruned_no_type_arguments() {
     FunctionTypeAliasElementImpl f =
         ElementFactory.functionTypeAliasElement('f');
     FunctionTypeAliasElementImpl g =
         ElementFactory.functionTypeAliasElement('g');
     f.parameters = [ElementFactory.namedParameter2('x', g.type)];
@@ skipping 1384 matching lines @@
     // void f(String s) {}
     // class A {
     //   void call(String s) {}
     // }
     //
     InterfaceType stringType = _typeProvider.stringType;
     ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.methods = <MethodElement>[
       ElementFactory.methodElement("call", VoidTypeImpl.instance, [stringType])
     ];
-    FunctionType functionType = ElementFactory.functionElement5(
-        "f", <ClassElement>[stringType.element]).type;
+    FunctionType functionType = ElementFactory
+        .functionElement5("f", <ClassElement>[stringType.element]).type;
     expect(classA.type.isSubtypeOf(functionType), isTrue);
   }
 
   void test_isSubtypeOf_generic() {
     ClassElement classA = ElementFactory.classElement2("A", ["E"]);
     ClassElement classB = ElementFactory.classElement2("B");
     DartType dynamicType = DynamicTypeImpl.instance;
     InterfaceType typeAOfDynamic =
         classA.type.substitute4(<DartType>[dynamicType]);
     InterfaceType typeAOfB = classA.type.substitute4(<DartType>[classB.type]);
@@ skipping 556 matching lines @@
     expect(result.element, classA);
     List<DartType> resultArguments = result.typeArguments;
     expect(resultArguments, hasLength(1));
     expect(resultArguments[0], parameter);
   }
 }
 
 @reflectiveTest
 class LibraryElementImplTest extends EngineTestCase {
   void test_creation() {
-    expect(new LibraryElementImpl.forNode(
+    expect(
+        new LibraryElementImpl.forNode(
             createAnalysisContext(), AstFactory.libraryIdentifier2(["l"])),
         isNotNull);
   }
 
   void test_getImportedLibraries() {
     AnalysisContext context = createAnalysisContext();
     LibraryElementImpl library1 = ElementFactory.library(context, "l1");
     LibraryElementImpl library2 = ElementFactory.library(context, "l2");
     LibraryElementImpl library3 = ElementFactory.library(context, "l3");
     LibraryElementImpl library4 = ElementFactory.library(context, "l4");
@@ skipping 50 matching lines @@
         ElementFactory.compilationUnit("unit_b.dart", unitLib.source);
     library.parts = <CompilationUnitElement>[unitA, unitB];
     expect(library.units,
         unorderedEquals(<CompilationUnitElement>[unitLib, unitA, unitB]));
   }
 
   void test_getVisibleLibraries_cycle() {
     AnalysisContext context = createAnalysisContext();
     LibraryElementImpl library = ElementFactory.library(context, "app");
     LibraryElementImpl libraryA = ElementFactory.library(context, "A");
-    libraryA.imports =
-        <ImportElementImpl>[ElementFactory.importFor(library, null)];
-    library.imports =
-        <ImportElementImpl>[ElementFactory.importFor(libraryA, null)];
+    libraryA.imports = <ImportElementImpl>[
+      ElementFactory.importFor(library, null)
+    ];
+    library.imports = <ImportElementImpl>[
+      ElementFactory.importFor(libraryA, null)
+    ];
     List<LibraryElement> libraries = library.visibleLibraries;
     expect(libraries, unorderedEquals(<LibraryElement>[library, libraryA]));
   }
 
   void test_getVisibleLibraries_directExports() {
     AnalysisContext context = createAnalysisContext();
     LibraryElementImpl library = ElementFactory.library(context, "app");
     LibraryElementImpl libraryA = ElementFactory.library(context, "A");
     library.exports = <ExportElementImpl>[ElementFactory.exportFor(libraryA)];
     List<LibraryElement> libraries = library.visibleLibraries;
     expect(libraries, unorderedEquals(<LibraryElement>[library]));
   }
 
   void test_getVisibleLibraries_directImports() {
     AnalysisContext context = createAnalysisContext();
     LibraryElementImpl library = ElementFactory.library(context, "app");
     LibraryElementImpl libraryA = ElementFactory.library(context, "A");
-    library.imports =
-        <ImportElementImpl>[ElementFactory.importFor(libraryA, null)];
+    library.imports = <ImportElementImpl>[
+      ElementFactory.importFor(libraryA, null)
+    ];
     List<LibraryElement> libraries = library.visibleLibraries;
     expect(libraries, unorderedEquals(<LibraryElement>[library, libraryA]));
   }
 
   void test_getVisibleLibraries_indirectExports() {
     AnalysisContext context = createAnalysisContext();
     LibraryElementImpl library = ElementFactory.library(context, "app");
     LibraryElementImpl libraryA = ElementFactory.library(context, "A");
     LibraryElementImpl libraryAA = ElementFactory.library(context, "AA");
     libraryA.exports = <ExportElementImpl>[ElementFactory.exportFor(libraryAA)];
-    library.imports =
-        <ImportElementImpl>[ElementFactory.importFor(libraryA, null)];
+    library.imports = <ImportElementImpl>[
+      ElementFactory.importFor(libraryA, null)
+    ];
     List<LibraryElement> libraries = library.visibleLibraries;
     expect(libraries,
         unorderedEquals(<LibraryElement>[library, libraryA, libraryAA]));
   }
 
   void test_getVisibleLibraries_indirectImports() {
     AnalysisContext context = createAnalysisContext();
     LibraryElementImpl library = ElementFactory.library(context, "app");
     LibraryElementImpl libraryA = ElementFactory.library(context, "A");
     LibraryElementImpl libraryAA = ElementFactory.library(context, "AA");
     LibraryElementImpl libraryB = ElementFactory.library(context, "B");
-    libraryA.imports =
-        <ImportElementImpl>[ElementFactory.importFor(libraryAA, null)];
+    libraryA.imports = <ImportElementImpl>[
+      ElementFactory.importFor(libraryAA, null)
+    ];
     library.imports = <ImportElementImpl>[
       ElementFactory.importFor(libraryA, null),
       ElementFactory.importFor(libraryB, null)
     ];
     List<LibraryElement> libraries = library.visibleLibraries;
-    expect(libraries, unorderedEquals(
-        <LibraryElement>[library, libraryA, libraryAA, libraryB]));
+    expect(
+        libraries,
+        unorderedEquals(
+            <LibraryElement>[library, libraryA, libraryAA, libraryB]));
   }
 
   void test_getVisibleLibraries_noImports() {
     AnalysisContext context = createAnalysisContext();
     LibraryElementImpl library = ElementFactory.library(context, "app");
     expect(
         library.visibleLibraries, unorderedEquals(<LibraryElement>[library]));
   }
 
   void test_isUpToDate() {
@@ skipping 23 matching lines @@
       expect(actualImports[i], same(expectedImports[i]));
     }
   }
 }
 
 @reflectiveTest
 class MethodElementImplTest extends EngineTestCase {
   void test_computeNode() {
     AnalysisContextHelper contextHelper = new AnalysisContextHelper();
     AnalysisContext context = contextHelper.context;
-    Source source = contextHelper.addSource("/test.dart", r'''
+    Source source = contextHelper.addSource(
+        "/test.dart",
+        r'''
 abstract class A {
   String m1() => null;
   m2();
 }
 ''');
     // prepare CompilationUnitElement
     LibraryElement libraryElement = context.computeLibraryElement(source);
     CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
     // m1
     {
@@ skipping 11 matching lines @@
       expect(m2Node.name.name, "m2");
       expect(m2Node.element, same(m2Element));
     }
   }
 
   void test_computeNode_withoutFunctionBody() {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.analyzeFunctionBodies = false;
     AnalysisContextHelper contextHelper = new AnalysisContextHelper(options);
     AnalysisContext context = contextHelper.context;
-    Source source = contextHelper.addSource("/test.dart", r'''
+    Source source = contextHelper.addSource(
+        "/test.dart",
+        r'''
 abstract class A {
   String m1() => null;
   m2();
 }
 ''');
     // prepare CompilationUnitElement
     LibraryElement libraryElement = context.computeLibraryElement(source);
     CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
     // m1
     {
@@ skipping 29 matching lines @@
     for (int i = 0; i < elements.length; i++) {
       EngineTestCase.assertInstanceOf((obj) => obj is LocalVariableElement,
           LocalVariableElement, elements[i]);
     }
   }
 
   void test_fromElements_multiple() {
     Element firstElement = ElementFactory.localVariableElement2("xx");
     Element secondElement = ElementFactory.localVariableElement2("yy");
     Element thirdElement = ElementFactory.localVariableElement2("zz");
-    Element result = MultiplyDefinedElementImpl.fromElements(null,
+    Element result = MultiplyDefinedElementImpl.fromElements(
+        null,
         MultiplyDefinedElementImpl.fromElements(
-            null, firstElement, secondElement), thirdElement);
+            null, firstElement, secondElement),
+        thirdElement);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is MultiplyDefinedElement, MultiplyDefinedElement, result);
     List<Element> elements =
         (result as MultiplyDefinedElement).conflictingElements;
     expect(elements, hasLength(3));
     for (int i = 0; i < elements.length; i++) {
       EngineTestCase.assertInstanceOf((obj) => obj is LocalVariableElement,
           LocalVariableElement, elements[i]);
     }
   }
 
   void test_fromElements_nonConflicting() {
     Element element = ElementFactory.localVariableElement2("xx");
     expect(MultiplyDefinedElementImpl.fromElements(null, element, element),
         same(element));
   }
 }
 
 @reflectiveTest
 class ParameterElementImplTest extends EngineTestCase {
   void test_computeNode_DefaultFormalParameter() {
     AnalysisContextHelper contextHelper = new AnalysisContextHelper();
     AnalysisContext context = contextHelper.context;
-    Source source = contextHelper.addSource("/test.dart", r'''
+    Source source = contextHelper.addSource(
+        "/test.dart",
+        r'''
 main([int p = 42]) {
 }''');
     // prepare CompilationUnitElement
     LibraryElement libraryElement = context.computeLibraryElement(source);
     CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
     // p
     {
       ParameterElement element = unitElement.functions[0].parameters[0];
       DefaultFormalParameter node = element.computeNode();
       expect(node, isNotNull);
       expect(node.identifier.name, 'p');
       expect(node.element, same(element));
     }
   }
 
   void test_computeNode_FieldFormalParameter() {
     AnalysisContextHelper contextHelper = new AnalysisContextHelper();
     AnalysisContext context = contextHelper.context;
-    Source source = contextHelper.addSource("/test.dart", r'''
+    Source source = contextHelper.addSource(
+        "/test.dart",
+        r'''
 class A {
   int p;
   A(this.p) {
   }
 }''');
     // prepare CompilationUnitElement
     LibraryElement libraryElement = context.computeLibraryElement(source);
     CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
     // p
     {
       ClassElement classA = unitElement.types[0];
       ConstructorElement constructorA = classA.constructors[0];
       FieldFormalParameterElement element = constructorA.parameters[0];
       FieldFormalParameter node = element.computeNode();
       expect(node, isNotNull);
       expect(node.identifier.name, 'p');
       expect(node.element, same(element));
     }
   }
 
   void test_computeNode_FunctionTypedFormalParameter() {
     AnalysisContextHelper contextHelper = new AnalysisContextHelper();
     AnalysisContext context = contextHelper.context;
-    Source source = contextHelper.addSource("/test.dart", r'''
+    Source source = contextHelper.addSource(
+        "/test.dart",
+        r'''
 main(p(int a, int b)) {
 }''');
     // prepare CompilationUnitElement
     LibraryElement libraryElement = context.computeLibraryElement(source);
     CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
     // p
     {
       ParameterElement element = unitElement.functions[0].parameters[0];
       FunctionTypedFormalParameter node = element.computeNode();
       expect(node, isNotNull);
       expect(node.identifier.name, 'p');
       expect(node.element, same(element));
     }
   }
 
   void test_computeNode_SimpleFormalParameter() {
     AnalysisContextHelper contextHelper = new AnalysisContextHelper();
     AnalysisContext context = contextHelper.context;
-    Source source = contextHelper.addSource("/test.dart", r'''
+    Source source = contextHelper.addSource(
+        "/test.dart",
+        r'''
 main(int p) {
 }''');
     // prepare CompilationUnitElement
     LibraryElement libraryElement = context.computeLibraryElement(source);
     CompilationUnitElement unitElement = libraryElement.definingCompilationUnit;
     // p
     {
       ParameterElement element = unitElement.functions[0].parameters[0];
       SimpleFormalParameter node = element.computeNode();
       expect(node, isNotNull);
       expect(node.identifier.name, 'p');
       expect(node.element, same(element));
     }
   }
 }
 
 @reflectiveTest
 class TypeParameterTypeImplTest extends EngineTestCase {
   void test_creation() {
-    expect(new TypeParameterTypeImpl(
+    expect(
+        new TypeParameterTypeImpl(
             new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"))),
         isNotNull);
   }
 
   void test_getElement() {
     TypeParameterElementImpl element =
         new TypeParameterElementImpl.forNode(AstFactory.identifier3("E"));
     TypeParameterTypeImpl type = new TypeParameterTypeImpl(element);
     expect(type.element, element);
   }
@@ skipping 148 matching lines @@
 }
 
 class _FunctionTypeImplTest_isSubtypeOf_baseCase_classFunction
     extends InterfaceTypeImpl {
   _FunctionTypeImplTest_isSubtypeOf_baseCase_classFunction(ClassElement arg0)
       : super(arg0);
 
   @override
   bool get isDartCoreFunction => true;
 }