diff --git a/pkg/analyzer/test/generated/declaration_resolver_test.dart b/pkg/analyzer/test/generated/declaration_resolver_test.dart
index db29c01dd2a..c6b9afb1d16 100644
--- a/pkg/analyzer/test/generated/declaration_resolver_test.dart
+++ b/pkg/analyzer/test/generated/declaration_resolver_test.dart
@@ -6,7 +6,6 @@ import 'dart:async';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
-import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/ast/utilities.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/generated/declaration_resolver.dart';
@@ -17,7 +16,6 @@ import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import '../src/dart/resolution/driver_resolution.dart';
 import '../util/element_type_matchers.dart';
-import 'test_support.dart';
 
 main() {
   defineReflectiveSuite(() {
@@ -245,9 +243,8 @@ const b = null;
     await setupCode('f() { @a g() {} }');
     // Note: metadata on local function declarations is ignored by the
     // analyzer.  TODO(paulberry): is this a bug?
-    FunctionDeclaration node = EngineTestCase.findNode(
-        unit, code, 'g', (AstNode n) => n is FunctionDeclaration);
-    NodeList<Annotation> metadata = (node as FunctionDeclarationImpl).metadata;
+    var node = FindNode(code, unit).functionDeclaration('g()');
+    NodeList<Annotation> metadata = node.metadata;
     if (Parser.useFasta) {
       expect(metadata, hasLength(1));
     } else {
@@ -354,8 +351,7 @@ const b = null;
   }
 
   NodeList<Annotation> _findMetadata(CompilationUnit unit, String search) {
-    AstNode node =
-        EngineTestCase.findNode(unit, code, search, (AstNode _) => true);
+    var node = FindNode(code, unit).any(search);
     while (node != null) {
       if (node is AnnotatedNode && node.metadata.isNotEmpty) {
         return node.metadata;
diff --git a/pkg/analyzer/test/generated/resolver_test.dart b/pkg/analyzer/test/generated/resolver_test.dart
index 00e4834e27c..5143f403782 100644
--- a/pkg/analyzer/test/generated/resolver_test.dart
+++ b/pkg/analyzer/test/generated/resolver_test.dart
@@ -2,7 +2,6 @@
 // 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.
 
-import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/dart/analysis/features.dart';
@@ -189,7 +188,7 @@ class GenericMethodResolverTest extends StaticTypeAnalyzer2TestShared {
     // therefore discard the propagated type.
     //
     // So this test does not use strong mode.
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 abstract class Iter {
   List<S> map<S>(S f(x));
 }
@@ -867,7 +866,7 @@ int f() {
 }
 
 @reflectiveTest
-class TypePropagationTest extends ResolverTestCase {
+class TypePropagationTest extends DriverResolutionTest {
   test_assignment_null() async {
     String code = r'''
 main() {
@@ -875,144 +874,81 @@ main() {
   v = null;
   return v; // return
 }''';
-    CompilationUnit unit;
-    {
-      Source source = addSource(code);
-      TestAnalysisResult analysisResult = await computeAnalysisResult(source);
-      assertNoErrors(source);
-      verify([source]);
-      unit = analysisResult.unit;
-    }
-    {
-      SimpleIdentifier identifier = EngineTestCase.findNode(
-          unit, code, "v; // declare", (node) => node is SimpleIdentifier);
-      expect(identifier.staticType, typeProvider.intType);
-    }
-    {
-      SimpleIdentifier identifier = EngineTestCase.findNode(
-          unit, code, "v = null;", (node) => node is SimpleIdentifier);
-      expect(identifier.staticType, typeProvider.intType);
-    }
-    {
-      SimpleIdentifier identifier = EngineTestCase.findNode(
-          unit, code, "v; // return", (node) => node is SimpleIdentifier);
-      expect(identifier.staticType, typeProvider.intType);
-    }
+    addTestFile(code);
+    await resolveTestFile();
+
+    assertType(findNode.simple('v; // declare'), 'int');
+    assertType(findNode.simple('v = null;'), 'int');
+    assertType(findNode.simple('v; // return'), 'int');
   }
 
   test_functionExpression_asInvocationArgument_notSubtypeOfStaticType() async {
-    String code = r'''
+    await assertErrorsInCode(r'''
 class A {
   m(void f(int i)) {}
 }
 x() {
   A a = new A();
   a.m(() => 0);
-}''';
-    Source source = addSource(code);
-    CompilationUnit unit = await _computeResolvedUnit(source, noErrors: false);
-    assertErrors(source, [StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
-    // () => 0
-    FunctionExpression functionExpression = EngineTestCase.findNode(
-        unit, code, "() => 0)", (node) => node is FunctionExpression);
-    expect((functionExpression.staticType as FunctionType).parameters.length,
-        same(0));
+}''', [
+      error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 63, 7),
+    ]);
+    assertType(findNode.functionExpression('() => 0'), 'int Function()');
   }
 
   test_initializer_hasStaticType() async {
-    Source source = addSource(r'''
+    addTestFile(r'''
 f() {
   int v = 0;
   return v;
 }''');
-    CompilationUnit unit = await _computeResolvedUnit(source);
-    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;
-      expect(variableName.staticType, typeProvider.intType);
-    }
-    // Type of 'v' in reference.
-    {
-      ReturnStatement statement = statements[1] as ReturnStatement;
-      SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
-      expect(variableName.staticType, typeProvider.intType);
-    }
+    await resolveTestFile();
+    assertType(findNode.simple('v = 0;'), 'int');
+    assertType(findNode.simple('v;'), 'int');
   }
 
   test_initializer_hasStaticType_parameterized() async {
-    Source source = addSource(r'''
+    addTestFile(r'''
 f() {
   List<int> v = <int>[];
   return v;
 }''');
-    CompilationUnit unit = await _computeResolvedUnit(source);
-    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;
-      expect(variableName.staticType, isNotNull);
-    }
-    // Type of 'v' in reference.
-    {
-      ReturnStatement statement = statements[1] as ReturnStatement;
-      SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
-      expect(variableName.staticType, isNotNull);
-    }
+    await resolveTestFile();
+    assertType(findNode.simple('v ='), 'List<int>');
+    assertType(findNode.simple('v;'), 'List<int>');
   }
 
   test_initializer_null() async {
-    String code = r'''
+    addTestFile(r'''
 main() {
   int v = null;
-  return v; // marker
-}''';
-    CompilationUnit unit;
-    {
-      Source source = addSource(code);
-      unit = await _computeResolvedUnit(source);
-    }
-    {
-      SimpleIdentifier identifier = EngineTestCase.findNode(
-          unit, code, "v = null;", (node) => node is SimpleIdentifier);
-      expect(identifier.staticType, typeProvider.intType);
-    }
-    {
-      SimpleIdentifier identifier = EngineTestCase.findNode(
-          unit, code, "v; // marker", (node) => node is SimpleIdentifier);
-      expect(identifier.staticType, typeProvider.intType);
-    }
+  return v;
+}''');
+    await resolveTestFile();
+
+    assertType(findNode.simple('v ='), 'int');
+    assertType(findNode.simple('v;'), 'int');
   }
 
   test_invocation_target_prefixed() async {
-    addNamedSource('/helper.dart', '''
-library helper;
+    newFile('/test/lib/a.dart', content: r'''
 int max(int x, int y) => 0;
 ''');
-    String code = '''
-import 'helper.dart' as helper;
+    addTestFile('''
+import 'a.dart' as helper;
 main() {
   helper.max(10, 10); // marker
-}''';
-    CompilationUnit unit = await resolveSource(code);
-    SimpleIdentifier methodName =
-        findMarkedIdentifier(code, unit, "(10, 10); // marker");
-    MethodInvocation methodInvoke = methodName.parent;
-    expect(methodInvoke.methodName.staticElement, isNotNull);
+}''');
+    await resolveTestFile();
+
+    assertElement(
+      findNode.simple('max(10, 10)'),
+      findElement.importFind('package:test/a.dart').topFunction('max'),
+    );
   }
 
   test_is_subclass() async {
-    Source source = addSource(r'''
+    addTestFile(r'''
 class A {}
 class B extends A {
   B m() => this;
@@ -1023,20 +959,17 @@ A f(A p) {
   }
   return p;
 }''');
-    CompilationUnit unit = await _computeResolvedUnit(source);
-    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;
-    expect(invocation.methodName.staticElement, isNotNull);
+    await resolveTestFile();
+
+    assertElement(
+      findNode.methodInvocation('p.m()'),
+      findElement.method('m', of: 'B'),
+    );
   }
 
   test_mutatedOutsideScope() async {
     // https://code.google.com/p/dart/issues/detail?id=22732
-    Source source = addSource(r'''
+    await assertNoErrorsInCode(r'''
 class Base {
 }
 
@@ -1061,104 +994,62 @@ void g() {
   }
   x = null;
 }''');
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
   }
 
   test_objectAccessInference_disabled_for_library_prefix() async {
-    String name = 'hashCode';
-    addNamedSource('/helper.dart', '''
-library helper;
-dynamic get $name => 42;
+    newFile('/test/lib/a.dart', content: '''
+dynamic get hashCode => 42;
 ''');
-    String code = '''
-import 'helper.dart' as helper;
+    await assertNoErrorsInCode('''
+import 'a.dart' as helper;
 main() {
-  helper.$name; // marker
-}''';
-
-    CompilationUnit unit = await resolveSource(code);
-    SimpleIdentifier id = findMarkedIdentifier(code, unit, "; // marker");
-    PrefixedIdentifier prefixedId = id.parent;
-    expect(id.staticType, typeProvider.dynamicType);
-    expect(prefixedId.staticType, typeProvider.dynamicType);
+  helper.hashCode;
+}''');
+    assertTypeDynamic(findNode.prefixed('helper.hashCode'));
   }
 
   test_objectAccessInference_disabled_for_local_getter() async {
-    String name = 'hashCode';
-    String code = '''
-dynamic get $name => null;
+    await assertNoErrorsInCode('''
+dynamic get hashCode => null;
 main() {
-  $name; // marker
-}''';
-
-    CompilationUnit unit = await resolveSource(code);
-    SimpleIdentifier getter = findMarkedIdentifier(code, unit, "; // marker");
-    expect(getter.staticType, typeProvider.dynamicType);
+  hashCode; // marker
+}''');
+    assertTypeDynamic(findNode.simple('hashCode; // marker'));
   }
 
   test_objectMethodInference_disabled_for_library_prefix() async {
-    String name = 'toString';
-    addNamedSource('/helper.dart', '''
-library helper;
+    newFile('/test/lib/a.dart', content: '''
 dynamic toString = (int x) => x + 42;
 ''');
-    String code = '''
-import 'helper.dart' as helper;
+    await assertNoErrorsInCode('''
+import 'a.dart' as helper;
 main() {
-  helper.$name(); // marker
-}''';
-    CompilationUnit unit = await resolveSource(code);
-    SimpleIdentifier methodName =
-        findMarkedIdentifier(code, unit, "(); // marker");
-    MethodInvocation methodInvoke = methodName.parent;
-    expect(methodName.staticType, typeProvider.dynamicType);
-    expect(methodInvoke.staticType, typeProvider.dynamicType);
+  helper.toString();
+}''');
+    assertTypeDynamic(findNode.methodInvocation('helper.toString()'));
   }
 
   test_objectMethodInference_disabled_for_local_function() async {
-    String name = 'toString';
-    String code = '''
+    addTestFile('''
 main() {
-  dynamic $name = () => null;
-  $name(); // marker
-}''';
-    CompilationUnit unit = await resolveSource(code);
-
-    SimpleIdentifier identifier = findMarkedIdentifier(code, unit, "$name = ");
-    expect(identifier.staticType, typeProvider.dynamicType);
-
-    SimpleIdentifier methodName =
-        findMarkedIdentifier(code, unit, "(); // marker");
-    MethodInvocation methodInvoke = methodName.parent;
-    expect(methodName.staticType, typeProvider.dynamicType);
-    expect(methodInvoke.staticType, typeProvider.dynamicType);
+  dynamic toString = () => null;
+  toString(); // marker
+}''');
+    await resolveTestFile();
+    assertTypeDynamic(findNode.simple('toString ='));
+    assertTypeDynamic(findNode.simple('toString(); // marker'));
   }
 
   @failingTest
   test_propagatedReturnType_functionExpression() async {
     // TODO(scheglov) disabled because we don't resolve function expression
-    String code = r'''
+    addTestFile(r'''
 main() {
   var v = (() {return 42;})();
-}''';
-    CompilationUnit unit = await resolveSource(code);
-    assertAssignedType(code, unit, typeProvider.dynamicType);
-  }
+}''');
+    await resolveTestFile();
 
-  /**
-   * Return the resolved unit for the given [source].
-   *
-   * If [noErrors] is not specified or is not `true`, [assertNoErrors].
-   */
-  Future<CompilationUnit> _computeResolvedUnit(Source source,
-      {bool noErrors: true}) async {
-    TestAnalysisResult analysisResult = await computeAnalysisResult(source);
-    if (noErrors) {
-      assertNoErrors(source);
-      verify([source]);
-    }
-    return analysisResult.unit;
+    assertTypeDynamic(findNode.simple('v = '));
   }
 }
 
diff --git a/pkg/analyzer/test/generated/resolver_test_case.dart b/pkg/analyzer/test/generated/resolver_test_case.dart
index aa995d16399..3f21d1719be 100644
--- a/pkg/analyzer/test/generated/resolver_test_case.dart
+++ b/pkg/analyzer/test/generated/resolver_test_case.dart
@@ -32,6 +32,7 @@ import 'package:analyzer/src/test_utilities/mock_sdk.dart';
 import 'package:analyzer/src/test_utilities/resource_provider_mixin.dart';
 import 'package:test/test.dart';
 
+import '../src/dart/resolution/driver_resolution.dart';
 import 'test_analysis_context.dart';
 import 'test_support.dart';
 
@@ -738,11 +739,7 @@ class ResolverTestCase extends EngineTestCase with ResourceProviderMixin {
  * Shared infrastructure for [StaticTypeAnalyzer2Test] and
  * [StrongModeStaticTypeAnalyzer2Test].
  */
-class StaticTypeAnalyzer2TestShared extends ResolverTestCase {
-  String testCode;
-  Source testSource;
-  CompilationUnit testUnit;
-
+class StaticTypeAnalyzer2TestShared extends DriverResolutionTest {
   /**
    * Find the expression that starts at the offset of [search] and validate its
    * that its static type matches the given [type].
@@ -752,7 +749,7 @@ class StaticTypeAnalyzer2TestShared extends ResolverTestCase {
    * to match the type.
    */
   void expectExpressionType(String search, type) {
-    Expression expression = findExpression(search);
+    Expression expression = findNode.expression(search);
     _expectType(expression.staticType, type);
   }
 
@@ -778,7 +775,7 @@ class StaticTypeAnalyzer2TestShared extends ResolverTestCase {
       fail('Wrong element type: ${element.runtimeType}');
     }
 
-    SimpleIdentifier identifier = findIdentifier(name);
+    SimpleIdentifier identifier = findNode.simple(name);
     // Element is either ExecutableElement or ParameterElement.
     var element = identifier.staticElement;
     FunctionTypeImpl functionType = (element as dynamic).type;
@@ -797,7 +794,7 @@ class StaticTypeAnalyzer2TestShared extends ResolverTestCase {
    * output.
    */
   FunctionTypeImpl expectFunctionType2(String name, String type) {
-    SimpleIdentifier identifier = findIdentifier(name);
+    SimpleIdentifier identifier = findNode.simple(name);
     FunctionTypeImpl functionType = identifier.staticType;
     expect('$functionType', type);
     return functionType;
@@ -811,7 +808,7 @@ class StaticTypeAnalyzer2TestShared extends ResolverTestCase {
    * to match the type.
    */
   void expectIdentifierType(String name, type) {
-    SimpleIdentifier identifier = findIdentifier(name);
+    SimpleIdentifier identifier = findNode.simple(name);
     _expectType(identifier.staticType, type);
   }
 
@@ -824,34 +821,13 @@ class StaticTypeAnalyzer2TestShared extends ResolverTestCase {
    * to match the type.
    */
   void expectInitializerType(String name, type) {
-    SimpleIdentifier identifier = findIdentifier(name);
+    SimpleIdentifier identifier = findNode.simple(name);
     VariableDeclaration declaration =
         identifier.thisOrAncestorOfType<VariableDeclaration>();
     Expression initializer = declaration.initializer;
     _expectType(initializer.staticType, type);
   }
 
-  Expression findExpression(String search) {
-    return EngineTestCase.findNode(
-        testUnit, testCode, search, (node) => node is Expression);
-  }
-
-  SimpleIdentifier findIdentifier(String search) {
-    return EngineTestCase.findNode(
-        testUnit, testCode, search, (node) => node is SimpleIdentifier);
-  }
-
-  Future<void> resolveTestUnit(String code, {bool noErrors: true}) async {
-    testCode = code;
-    testSource = addSource(testCode);
-    TestAnalysisResult analysisResult = await computeAnalysisResult(testSource);
-    if (noErrors) {
-      assertNoErrors(testSource);
-    }
-    verify([testSource]);
-    testUnit = analysisResult.unit;
-  }
-
   /**
    * Validates that [type] matches [expected].
    *
diff --git a/pkg/analyzer/test/generated/static_type_analyzer_test.dart b/pkg/analyzer/test/generated/static_type_analyzer_test.dart
index c9246a05c86..1d2a7f365a8 100644
--- a/pkg/analyzer/test/generated/static_type_analyzer_test.dart
+++ b/pkg/analyzer/test/generated/static_type_analyzer_test.dart
@@ -53,14 +53,13 @@ void _fail(String message) {
 @reflectiveTest
 class SetLiteralsTest extends StaticTypeAnalyzer2TestShared {
   test_emptySetLiteral_parameter_typed() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 main() {
   useSet({});
 }
 void useSet(Set<int> s) {
 }
-''';
-    await resolveTestUnit(code);
+''');
     expectExpressionType('{}', 'Set<int>');
   }
 }
@@ -71,90 +70,83 @@ void useSet(Set<int> s) {
 @reflectiveTest
 class StaticTypeAnalyzer2Test extends StaticTypeAnalyzer2TestShared {
   test_FunctionExpressionInvocation_block() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 main() {
   var foo = (() { return 1; })();
 }
-''';
-    await resolveTestUnit(code);
+''');
     expectInitializerType('foo', 'int');
   }
 
   test_FunctionExpressionInvocation_curried() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 typedef int F();
 F f() => null;
 main() {
   var foo = f()();
 }
-''';
-    await resolveTestUnit(code);
+''');
     expectInitializerType('foo', 'int');
   }
 
   test_FunctionExpressionInvocation_expression() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 main() {
   var foo = (() => 1)();
 }
-''';
-    await resolveTestUnit(code);
+''');
     expectInitializerType('foo', 'int');
   }
 
   test_MethodInvocation_nameType_localVariable() async {
-    String code = r"""
+    await assertNoErrorsInCode(r"""
 typedef Foo();
 main() {
   Foo foo;
   foo();
 }
-""";
-    await resolveTestUnit(code);
+""");
     // "foo" should be resolved to the "Foo" type
     expectIdentifierType("foo();", new TypeMatcher<FunctionType>());
   }
 
   test_MethodInvocation_nameType_parameter_FunctionTypeAlias() async {
-    String code = r"""
+    await assertNoErrorsInCode(r"""
 typedef Foo();
 main(Foo foo) {
   foo();
 }
-""";
-    await resolveTestUnit(code);
+""");
     // "foo" should be resolved to the "Foo" type
     expectIdentifierType("foo();", new TypeMatcher<FunctionType>());
   }
 
   test_MethodInvocation_nameType_parameter_propagatedType() async {
-    String code = r"""
+    await assertNoErrorsInCode(r"""
 typedef Foo();
 main(p) {
   if (p is Foo) {
     p();
   }
 }
-""";
-    await resolveTestUnit(code);
+""");
     expectIdentifierType("p()", 'dynamic Function()');
   }
 
   test_staticMethods_classTypeParameters() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 class C<T> {
   static void m() => null;
 }
 main() {
   print(C.m);
 }
-''';
-    await resolveTestUnit(code);
+''');
     expectFunctionType('m);', 'void Function()');
   }
 
   test_staticMethods_classTypeParameters_genericMethod() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 class C<T> {
   static void m<S>(S s) {
     void f<U>(S s, U u) {}
@@ -164,8 +156,7 @@ class C<T> {
 main() {
   print(C.m);
 }
-''';
-    await resolveTestUnit(code);
+''');
     // C - m
     TypeParameterType typeS;
     {
@@ -208,24 +199,22 @@ main() {
 @reflectiveTest
 class StaticTypeAnalyzer3Test extends StaticTypeAnalyzer2TestShared {
   test_emptyMapLiteral_initializer_var() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 main() {
   var v = {};
 }
-''';
-    await resolveTestUnit(code);
+''');
     expectExpressionType('{}', 'Map<dynamic, dynamic>');
   }
 
   test_emptyMapLiteral_parameter_typed() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 main() {
   useMap({});
 }
 void useMap(Map<int, int> m) {
 }
-''';
-    await resolveTestUnit(code);
+''');
     expectExpressionType('{}', 'Map<int, int>');
   }
 }
@@ -1490,20 +1479,19 @@ class StaticTypeAnalyzerTest extends EngineTestCase
 class StaticTypeAnalyzerWithSetLiteralsTest
     extends StaticTypeAnalyzer2TestShared {
   test_emptySetLiteral_inferredFromLinkedHashSet() async {
-    String code = r'''
+    await assertErrorsInCode(r'''
 import 'dart:collection';
 LinkedHashSet<int> test4() => {};
-''';
-    await resolveTestUnit(code, noErrors: false);
+''', [
+      error(StrongModeCode.INVALID_CAST_LITERAL_SET, 56, 2),
+    ]);
     expectExpressionType('{}', 'Set<dynamic>');
-    await assertErrorsInCode(code, [StrongModeCode.INVALID_CAST_LITERAL_SET]);
   }
 
   test_emptySetLiteral_initializer_typed_nested() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 Set<Set<int>> ints = {{}};
-''';
-    await resolveTestUnit(code);
+''');
     expectExpressionType('{}', 'Set<int>');
     expectExpressionType('{{}}', 'Set<Set<int>>');
   }
diff --git a/pkg/analyzer/test/generated/strong_mode_test.dart b/pkg/analyzer/test/generated/strong_mode_test.dart
index bac33e69a71..5c5dae9f11f 100644
--- a/pkg/analyzer/test/generated/strong_mode_test.dart
+++ b/pkg/analyzer/test/generated/strong_mode_test.dart
@@ -4134,16 +4134,10 @@ noCasts() {
 @reflectiveTest
 class StrongModeStaticTypeAnalyzer2Test extends StaticTypeAnalyzer2TestShared {
   void expectStaticInvokeType(String search, String type) {
-    var invocation = findIdentifier(search).parent as MethodInvocation;
+    var invocation = findNode.simple(search).parent as MethodInvocation;
     expect(invocation.staticInvokeType.toString(), type);
   }
 
-  void setUp() {
-    super.setUp();
-    AnalysisOptionsImpl options = new AnalysisOptionsImpl();
-    resetWith(options: options);
-  }
-
   test_dynamicObjectGetter_hashCode() async {
     String code = r'''
 main() {
@@ -4151,7 +4145,7 @@ main() {
   var foo = a.hashCode;
 }
 ''';
-    await resolveTestUnit(code);
+    await assertNoErrorsInCode(code);
     expectInitializerType('foo', 'int');
   }
 
@@ -4161,7 +4155,7 @@ main() {
     import "dart:async";
     dynamic test(FutureOr<int> x) => (x is int) && (x.abs() == 0);
    ''';
-    await resolveTestUnit(code);
+    await assertNoErrorsInCode(code);
   }
 
   test_futureOr_promotion2() async {
@@ -4172,7 +4166,7 @@ main() {
     dynamic test(FutureOr<int> x) => (x is Future<int>) &&
                                      (x.then((x) => x) == null);
    ''';
-    await resolveTestUnit(code);
+    await assertNoErrorsInCode(code);
   }
 
   test_futureOr_promotion3() async {
@@ -4183,7 +4177,7 @@ main() {
     dynamic test<T extends num>(FutureOr<T> x) => (x is T) &&
                                                   (x.abs() == 0);
    ''';
-    await resolveTestUnit(code);
+    await assertNoErrorsInCode(code);
   }
 
   test_futureOr_promotion4() async {
@@ -4194,32 +4188,30 @@ main() {
     dynamic test<T extends num>(FutureOr<T> x) => (x is Future<T>) &&
                                                   (x.then((x) => x) == null);
    ''';
-    await resolveTestUnit(code);
+    await assertNoErrorsInCode(code);
   }
 
   test_generalizedVoid_assignToVoidOk() async {
-    Source source = addSource(r'''
+    await assertNoErrorsInCode(r'''
 void main() {
   void x;
   x = 42;
 }
 ''');
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
   }
 
   test_genericFunction() async {
-    await resolveTestUnit(r'T f<T>(T x) => null;');
+    await assertNoErrorsInCode(r'T f<T>(T x) => null;');
     expectFunctionType('f', 'T Function<T>(T)',
         elementTypeParams: '[T]', typeFormals: '[T]');
-    SimpleIdentifier f = findIdentifier('f');
+    SimpleIdentifier f = findNode.simple('f');
     FunctionElementImpl e = f.staticElement;
     FunctionType ft = e.type.instantiate([typeProvider.stringType]);
     expect(ft.toString(), 'String Function(String)');
   }
 
   test_genericFunction_bounds() async {
-    await resolveTestUnit(r'T f<T extends num>(T x) => null;');
+    await assertNoErrorsInCode(r'T f<T extends num>(T x) => null;');
     expectFunctionType('f', 'T Function<T extends num>(T)',
         elementTypeParams: '[T extends num]', typeFormals: '[T extends num]');
   }
@@ -4228,7 +4220,7 @@ void main() {
     // TODO(paulberry): remove when dartbug.com/28515 fixed.
     if (!AnalysisDriver.useSummary2) return;
 
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 void g(T f<T>(T x)) {}
 ''');
     var type = expectFunctionType2('f', 'T Function<T>(T)');
@@ -4237,14 +4229,14 @@ void g(T f<T>(T x)) {}
   }
 
   test_genericFunction_static() async {
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 class C<E> {
   static T f<T>(T x) => null;
 }
 ''');
     expectFunctionType('f', 'T Function<T>(T)',
         elementTypeParams: '[T]', typeFormals: '[T]');
-    SimpleIdentifier f = findIdentifier('f');
+    SimpleIdentifier f = findNode.simple('f');
     MethodElementImpl e = f.staticElement;
     FunctionType ft = e.type.instantiate([typeProvider.stringType]);
     expect(ft.toString(), 'String Function(String)');
@@ -4258,7 +4250,7 @@ F f0;
 class C {
   static F f1;
   F f2;
-  void g(F f3) {
+  void g(F f3) { // C
     F f4;
     f0(3);
     f1(3);
@@ -4271,7 +4263,7 @@ class C {
 class D<S> {
   static F f1;
   F f2;
-  void g(F f3) {
+  void g(F f3) { // D
     F f4;
     f0(3);
     f1(3);
@@ -4281,11 +4273,10 @@ class D<S> {
   }
 }
 ''';
-    await resolveTestUnit(code);
+    await assertNoErrorsInCode(code);
 
     checkBody(String className) {
-      List<Statement> statements =
-          AstFinder.getStatementsInMethod(testUnit, className, "g");
+      var statements = findNode.block('{ // $className').statements;
 
       for (int i = 1; i <= 5; i++) {
         Expression exp = (statements[i] as ExpressionStatement).expression;
@@ -4299,13 +4290,13 @@ class D<S> {
 
   test_genericFunction_upwardsAndDownwards() async {
     // Regression tests for https://github.com/dart-lang/sdk/issues/27586.
-    await resolveTestUnit(r'List<num> x = [1, 2];');
+    await assertNoErrorsInCode(r'List<num> x = [1, 2];');
     expectInitializerType('x', 'List<num>');
   }
 
   test_genericFunction_upwardsAndDownwards_Object() async {
     // Regression tests for https://github.com/dart-lang/sdk/issues/27625.
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 List<Object> aaa = [];
 List<Object> bbb = [1, 2, 3];
 List<Object> ccc = [null];
@@ -4320,7 +4311,7 @@ List<Object> eee = [new Object()];
   }
 
   test_genericMethod() async {
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 class C<E> {
   List<T> f<T>(E e) => null;
 }
@@ -4328,12 +4319,12 @@ main() {
   C<String> cOfString;
 }
 ''');
-    expectFunctionType('f', 'List<T> Function<T>(E)',
+    expectFunctionType('f<T>', 'List<T> Function<T>(E)',
         elementTypeParams: '[T]',
         typeParams: '[E]',
         typeArgs: '[E]',
         typeFormals: '[T]');
-    SimpleIdentifier c = findIdentifier('cOfString');
+    SimpleIdentifier c = findNode.simple('cOfString');
     FunctionType ft = (c.staticType as InterfaceType).getMethod('f').type;
     expect(ft.toString(), 'List<T> Function<T>(String)');
     ft = ft.instantiate([typeProvider.intType]);
@@ -4341,7 +4332,7 @@ main() {
   }
 
   test_genericMethod_explicitTypeParams() async {
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 class C<E> {
   List<T> f<T>(E e) => null;
 }
@@ -4350,16 +4341,16 @@ main() {
   var x = cOfString.f<int>('hi');
 }
 ''');
-    MethodInvocation f = findIdentifier('f<int>').parent;
+    MethodInvocation f = findNode.simple('f<int>').parent;
     FunctionType ft = f.staticInvokeType;
     expect(ft.toString(), 'List<int> Function(String)');
 
-    SimpleIdentifier x = findIdentifier('x');
+    SimpleIdentifier x = findNode.simple('x');
     expect(x.staticType, typeProvider.listType2(typeProvider.intType));
   }
 
   test_genericMethod_functionExpressionInvocation_explicit() async {
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 class C<E> {
   T f<T>(T e) => null;
   static T g<T>(T e) => null;
@@ -4396,7 +4387,7 @@ void test<S>(T Function<T>(T) pf) {
     // TODO(paulberry): remove when dartbug.com/28515 fixed.
     if (!AnalysisDriver.useSummary2) return;
 
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 void test<S>(T pf<T>(T e)) {
   var paramCall = (pf)<int>(3);
 }
@@ -4408,7 +4399,7 @@ void test<S>(T pf<T>(T e)) {
     // TODO(paulberry): remove when dartbug.com/28515 fixed.
     if (!AnalysisDriver.useSummary2) return;
 
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 void test<S>(T pf<T>(T e)) {
   var paramCall = (pf)(3);
 }
@@ -4420,7 +4411,7 @@ void test<S>(T pf<T>(T e)) {
     // TODO(paulberry): remove when dartbug.com/28515 fixed.
     if (!AnalysisDriver.useSummary2) return;
 
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 class C<E> {
   T f<T>(T e) => null;
   static T g<T>(T e) => null;
@@ -4454,7 +4445,7 @@ void test<S>(T Function<T>(T) pf) {
   }
 
   test_genericMethod_functionInvocation_explicit() async {
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 class C<E> {
   T f<T>(T e) => null;
   static T g<T>(T e) => null;
@@ -4488,7 +4479,7 @@ void test<S>(T Function<T>(T) pf) {
     // TODO(paulberry): remove when dartbug.com/28515 fixed.
     if (!AnalysisDriver.useSummary2) return;
 
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 void test<S>(T pf<T>(T e)) {
   var paramCall = pf<int>(3);
 }
@@ -4500,7 +4491,7 @@ void test<S>(T pf<T>(T e)) {
     // TODO(paulberry): remove when dartbug.com/28515 fixed.
     if (!AnalysisDriver.useSummary2) return;
 
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 void test<S>(T pf<T>(T e)) {
   var paramCall = pf(3);
 }
@@ -4509,7 +4500,7 @@ void test<S>(T pf<T>(T e)) {
   }
 
   test_genericMethod_functionInvocation_inferred() async {
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 class C<E> {
   T f<T>(T e) => null;
   static T g<T>(T e) => null;
@@ -4540,7 +4531,7 @@ void test<S>(T Function<T>(T) pf) {
   }
 
   test_genericMethod_functionTypedParameter() async {
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 class C<E> {
   List<T> f<T>(T f(E e)) => null;
 }
@@ -4548,13 +4539,13 @@ main() {
   C<String> cOfString;
 }
 ''');
-    expectFunctionType('f', 'List<T> Function<T>(T Function(E))',
+    expectFunctionType('f<T>', 'List<T> Function<T>(T Function(E))',
         elementTypeParams: '[T]',
         typeParams: '[E]',
         typeArgs: '[E]',
         typeFormals: '[T]');
 
-    SimpleIdentifier c = findIdentifier('cOfString');
+    SimpleIdentifier c = findNode.simple('cOfString');
     FunctionType ft = (c.staticType as InterfaceType).getMethod('f').type;
     expect(ft.toString(), 'List<T> Function<T>(T Function(String))');
     ft = ft.instantiate([typeProvider.intType]);
@@ -4565,7 +4556,7 @@ main() {
     // TODO(paulberry): remove when dartbug.com/28515 fixed.
     if (!AnalysisDriver.useSummary2) return;
 
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 void test<S>(T pf<T>(T e)) {
   var paramTearOff = pf;
 }
@@ -4577,7 +4568,7 @@ void test<S>(T pf<T>(T e)) {
     // Regression test for:
     // https://github.com/dart-lang/sdk/issues/25100#issuecomment-162047588
     // These should not cause any hints or warnings.
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 class List<E> {
   T map<T>(T f(E e)) => null;
 }
@@ -4591,83 +4582,77 @@ void foo() {
     expectIdentifierType(
         'map((e) => 3);', 'T Function<T>(T Function(dynamic))');
 
-    MethodInvocation m1 = findIdentifier('map((e) => e);').parent;
+    MethodInvocation m1 = findNode.methodInvocation('map((e) => e);');
     expect(m1.staticInvokeType.toString(),
         'dynamic Function(dynamic Function(dynamic))');
-    MethodInvocation m2 = findIdentifier('map((e) => 3);').parent;
+    MethodInvocation m2 = findNode.methodInvocation('map((e) => 3);');
     expect(
         m2.staticInvokeType.toString(), 'int Function(int Function(dynamic))');
   }
 
   test_genericMethod_max_doubleDouble() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 import 'dart:math';
 main() {
   var foo = max(1.0, 2.0);
 }
-''';
-    await resolveTestUnit(code);
+''');
     expectInitializerType('foo', 'double');
   }
 
   test_genericMethod_max_doubleDouble_prefixed() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 import 'dart:math' as math;
 main() {
   var foo = math.max(1.0, 2.0);
 }
-''';
-    await resolveTestUnit(code);
+''');
     expectInitializerType('foo', 'double');
   }
 
   test_genericMethod_max_doubleInt() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 import 'dart:math';
 main() {
   var foo = max(1.0, 2);
 }
-''';
-    await resolveTestUnit(code);
+''');
     expectInitializerType('foo', 'num');
   }
 
   test_genericMethod_max_intDouble() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 import 'dart:math';
 main() {
   var foo = max(1, 2.0);
 }
-''';
-    await resolveTestUnit(code);
+''');
     expectInitializerType('foo', 'num');
   }
 
   test_genericMethod_max_intInt() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 import 'dart:math';
 main() {
   var foo = max(1, 2);
 }
-''';
-    await resolveTestUnit(code);
+''');
     expectInitializerType('foo', 'int');
   }
 
   test_genericMethod_nestedBound() async {
-    String code = r'''
+    // Just validate that there is no warning on the call to `.abs()`.
+    await assertNoErrorsInCode(r'''
 class Foo<T extends num> {
   void method<U extends T>(U u) {
     u.abs();
   }
 }
-''';
-    // Just validate that there is no warning on the call to `.abs()`.
-    await resolveTestUnit(code);
+''');
   }
 
   test_genericMethod_nestedCapture() async {
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 class C<T> {
   T f<S>(S x) {
     new C<S>().f<int>(3);
@@ -4676,7 +4661,7 @@ class C<T> {
   }
 }
 ''');
-    MethodInvocation f = findIdentifier('f<int>(3);').parent;
+    MethodInvocation f = findNode.methodInvocation('f<int>(3);');
     expect(f.staticInvokeType.toString(), 'S Function(int)');
 
     expectIdentifierType('f;', 'S Function<S₀>(S₀)');
@@ -4684,7 +4669,7 @@ class C<T> {
 
   @FailingTest(issue: 'https://github.com/dart-lang/sdk/issues/30236')
   test_genericMethod_nestedCaptureBounds() async {
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 class C<T> {
   T f<S extends T>(S x) {
     new C<S>().f<int>(3);
@@ -4693,7 +4678,7 @@ class C<T> {
   }
 }
 ''');
-    MethodInvocation f = findIdentifier('f<int>(3);').parent;
+    MethodInvocation f = findNode.methodInvocation('f<int>(3);');
     expect(f.staticInvokeType.toString(), 'S Function(int)');
     FunctionType ft = f.staticInvokeType;
     expect('${ft.typeArguments}/${ft.typeParameters}',
@@ -4703,18 +4688,18 @@ class C<T> {
   }
 
   test_genericMethod_nestedFunctions() async {
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 S f<S>(S x) {
   g<S>(S x) => f;
   return null;
 }
 ''');
-    expectIdentifierType('f', 'S Function<S>(S)');
-    expectIdentifierType('g', 'S Function<S>(S) Function<S>(S)');
+    expectIdentifierType('f<S>', 'S Function<S>(S)');
+    expectIdentifierType('g<S>', 'S Function<S>(S) Function<S>(S)');
   }
 
   test_genericMethod_override() async {
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 class C {
   T f<T>(T x) => null;
 }
@@ -4724,14 +4709,14 @@ class D extends C {
 ''');
     expectFunctionType('f<T>(T x) => null; // from D', 'T Function<T>(T)',
         elementTypeParams: '[T]', typeFormals: '[T]');
-    SimpleIdentifier f = findIdentifier('f<T>(T x) => null; // from D');
+    SimpleIdentifier f = findNode.simple('f<T>(T x) => null; // from D');
     MethodElementImpl e = f.staticElement;
     FunctionType ft = e.type.instantiate([typeProvider.stringType]);
     expect(ft.toString(), 'String Function(String)');
   }
 
   test_genericMethod_override_bounds() async {
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 class A {}
 class B {
   T f<T extends A>(T x) => null;
@@ -4748,7 +4733,7 @@ class D extends B {
   }
 
   test_genericMethod_override_covariant_field() async {
-    Source source = addSource(r'''
+    await assertNoErrorsInCode(r'''
 abstract class A {
   num get x;
   set x(covariant num _);
@@ -4758,13 +4743,10 @@ class B extends A {
   int x;
 }
 ''');
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
   }
 
   test_genericMethod_override_differentContextsSameBounds() async {
-    Source source = addSource(r'''
+    await assertNoErrorsInCode(r'''
         class GenericMethodBounds<T> {
   Type get t => T;
   GenericMethodBounds<E> foo<E extends T>() => new GenericMethodBounds<E>();
@@ -4778,13 +4760,10 @@ class GenericMethodBoundsDerived extends GenericMethodBounds<num> {
       new GenericMethodBounds<E>();
 }
 ''');
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
   }
 
   test_genericMethod_override_invalidContravariantTypeParamBounds() async {
-    Source source = addSource(r'''
+    await assertErrorsInCode(r'''
 class A {}
 class B extends A {}
 class C {
@@ -4792,14 +4771,13 @@ class C {
 }
 class D extends C {
   T f<T extends B>(T x) => null;
-}''');
-    await computeAnalysisResult(source);
-    assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
-    verify([source]);
+}''', [
+      error(CompileTimeErrorCode.INVALID_OVERRIDE, 101, 1),
+    ]);
   }
 
   test_genericMethod_override_invalidCovariantTypeParamBounds() async {
-    Source source = addSource(r'''
+    await assertErrorsInCode(r'''
 class A {}
 class B extends A {}
 class C {
@@ -4807,36 +4785,33 @@ class C {
 }
 class D extends C {
   T f<T extends A>(T x) => null;
-}''');
-    await computeAnalysisResult(source);
-    assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
-    verify([source]);
+}''', [
+      error(CompileTimeErrorCode.INVALID_OVERRIDE, 101, 1),
+    ]);
   }
 
   test_genericMethod_override_invalidReturnType() async {
-    Source source = addSource(r'''
+    await assertErrorsInCode(r'''
 class C {
   Iterable<T> f<T>(T x) => null;
 }
 class D extends C {
   String f<S>(S x) => null;
-}''');
-    await computeAnalysisResult(source);
-    assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
-    verify([source]);
+}''', [
+      error(CompileTimeErrorCode.INVALID_OVERRIDE, 74, 1),
+    ]);
   }
 
   test_genericMethod_override_invalidTypeParamCount() async {
-    Source source = addSource(r'''
+    await assertErrorsInCode(r'''
 class C {
   T f<T>(T x) => null;
 }
 class D extends C {
   S f<T, S>(T x) => null;
-}''');
-    await computeAnalysisResult(source);
-    assertErrors(source, [CompileTimeErrorCode.INVALID_OVERRIDE]);
-    verify([source]);
+}''', [
+      error(CompileTimeErrorCode.INVALID_OVERRIDE, 59, 1),
+    ]);
   }
 
   test_genericMethod_propagatedType_promotion() async {
@@ -4847,7 +4822,7 @@ class D extends C {
     // example won't work, as we now compute a static type and therefore discard
     // the propagated type. So a new test was created that doesn't run under
     // strong mode.
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 abstract class Iter {
   List<S> map<S>(S f(x));
 }
@@ -4862,7 +4837,7 @@ C toSpan(dynamic element) {
   }
 
   test_genericMethod_tearoff() async {
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 class C<E> {
   T f<T>(E e) => null;
   static T g<T>(T e) => null;
@@ -4894,7 +4869,7 @@ void test<S>(T Function<T>(T) pf) {
 
   @failingTest
   test_genericMethod_tearoff_instantiated() async {
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 class C<E> {
   T f<T>(E e) => null;
   static T g<T>(T e) => null;
@@ -4925,42 +4900,42 @@ void test<S>(T pf<T>(T e)) {
   }
 
   test_genericMethod_then() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 import 'dart:async';
 String toString(int x) => x.toString();
 main() {
   Future<int> bar = null;
   var foo = bar.then(toString);
 }
-''';
-    await resolveTestUnit(code);
+''');
 
     expectInitializerType('foo', 'Future<String>');
   }
 
   test_genericMethod_then_prefixed() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 import 'dart:async' as async;
 String toString(int x) => x.toString();
 main() {
   async.Future<int> bar = null;
   var foo = bar.then(toString);
 }
-''';
-    await resolveTestUnit(code);
+''');
     expectInitializerType('foo', 'Future<String>');
   }
 
   test_genericMethod_then_propagatedType() async {
     // Regression test for https://github.com/dart-lang/sdk/issues/25482.
-    String code = r'''
+    await assertErrorsInCode(r'''
 import 'dart:async';
 void main() {
   Future<String> p;
   var foo = p.then((r) => new Future<String>.value(3));
 }
-''';
-    await resolveTestUnit(code, noErrors: false);
+''', [
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 61, 3),
+      error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 106, 1),
+    ]);
     // Note: this correctly reports the error
     // StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE when run with the driver;
     // when run without the driver, it reports no errors.  So we don't bother
@@ -4969,7 +4944,7 @@ void main() {
   }
 
   test_genericMethod_toplevel_field_staticTearoff() async {
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 class C<E> {
   static T g<T>(T e) => null;
   static T Function<T>(T) h = null;
@@ -4983,7 +4958,7 @@ void test() {
   }
 
   test_implicitBounds() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 class A<T> {}
 
 class B<T extends num> {}
@@ -4999,8 +4974,7 @@ void test() {
   var bb = new B();
   var cc = new C();
 }
-''';
-    await resolveTestUnit(code);
+''');
     expectIdentifierType('ai', "A<dynamic>");
     expectIdentifierType('bi', "B<num>");
     expectIdentifierType('ci', "C<int, B<int>, A<dynamic>>");
@@ -5009,154 +4983,119 @@ void test() {
     expectIdentifierType('cc', "C<int, B<int>, A<dynamic>>");
   }
 
-  test_inferClosureType_parameters() async {
-    Source source = addSource(r'''
-typedef F({bool p});
-foo(callback(F f)) {}
-main() {
-  foo((f) {
-    f(p: false);
-  });
-}
-''');
-    var result = await computeAnalysisResult(source);
-    var main = result.unit.declarations[2] as FunctionDeclaration;
-    var body = main.functionExpression.body as BlockFunctionBody;
-    var statement = body.block.statements[0] as ExpressionStatement;
-    var invocation = statement.expression as MethodInvocation;
-    var closure = invocation.argumentList.arguments[0] as FunctionExpression;
-    var closureType = closure.staticType as FunctionType;
-    var fType = closureType.parameters[0].type as FunctionType;
-    // The inferred type of "f" in "foo()" invocation must own its parameters.
-    ParameterElement p = fType.parameters[0];
-    expect(p.name, 'p');
-    expect(p.enclosingElement, same(fType.element));
-  }
-
   test_instantiateToBounds_class_error_extension_malbounded() async {
     // Test that superclasses are strictly checked for malbounded default
     // types
-    String code = r'''
+    await assertErrorsInCode(r'''
 class C<T0 extends List<T1>, T1 extends List<T0>> {}
 class D extends C {}
-''';
-    await resolveTestUnit(code, noErrors: false);
-    assertErrors(
-        testSource, [CompileTimeErrorCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
+''', [
+      error(CompileTimeErrorCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS, 69, 1),
+    ]);
   }
 
   test_instantiateToBounds_class_error_instantiation_malbounded() async {
     // Test that instance creations are strictly checked for malbounded default
     // types
-    String code = r'''
+    await assertErrorsInCode(r'''
 class C<T0 extends List<T1>, T1 extends List<T0>> {}
 void test() {
   var c = new C();
 }
-''';
-    await resolveTestUnit(code, noErrors: false);
-    assertErrors(testSource, [
-      StrongModeCode.COULD_NOT_INFER,
-      CompileTimeErrorCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
+''', [
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 73, 1),
+      error(CompileTimeErrorCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS, 81, 1),
+      error(StrongModeCode.COULD_NOT_INFER, 81, 1),
     ]);
     expectIdentifierType('c =', 'C<List<dynamic>, List<List<dynamic>>>');
   }
 
   test_instantiateToBounds_class_error_recursion() async {
-    String code = r'''
+    await assertErrorsInCode(r'''
 class C<T0 extends List<T1>, T1 extends List<T0>> {}
 C c;
-''';
-    await resolveTestUnit(code, noErrors: false);
-    assertNoErrors(testSource);
+''', []);
+
     expectIdentifierType('c;', 'C<List<dynamic>, List<dynamic>>');
   }
 
   test_instantiateToBounds_class_error_recursion_self() async {
-    String code = r'''
+    await assertErrorsInCode(r'''
 class C<T extends C<T>> {}
 C c;
-''';
-    await resolveTestUnit(code, noErrors: false);
-    assertNoErrors(testSource);
+''', []);
+
     expectIdentifierType('c;', 'C<C<dynamic>>');
   }
 
   test_instantiateToBounds_class_error_recursion_self2() async {
-    String code = r'''
+    await assertErrorsInCode(r'''
 class A<E> {}
 class C<T extends A<T>> {}
 C c;
-''';
-    await resolveTestUnit(code, noErrors: false);
-    assertNoErrors(testSource);
+''', []);
+
     expectIdentifierType('c;', 'C<A<dynamic>>');
   }
 
   test_instantiateToBounds_class_error_typedef() async {
-    String code = r'''
+    await assertErrorsInCode(r'''
 typedef T F<T>(T x);
 class C<T extends F<T>> {}
 C c;
-''';
-    await resolveTestUnit(code, noErrors: false);
-    assertNoErrors(testSource);
+''', []);
+
     expectIdentifierType('c;', 'C<dynamic Function(dynamic)>');
   }
 
   test_instantiateToBounds_class_ok_implicitDynamic_multi() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 class C<T0 extends Map<T1, T2>, T1 extends List, T2 extends int> {}
 C c;
-''';
-    await resolveTestUnit(code);
-    assertNoErrors(testSource);
+''');
+
     expectIdentifierType(
         'c;', 'C<Map<List<dynamic>, int>, List<dynamic>, int>');
   }
 
   test_instantiateToBounds_class_ok_referenceOther_after() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 class C<T0 extends T1, T1 extends int> {}
 C c;
-''';
-    await resolveTestUnit(code);
-    assertNoErrors(testSource);
+''');
+
     expectIdentifierType('c;', 'C<int, int>');
   }
 
   test_instantiateToBounds_class_ok_referenceOther_after2() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 class C<T0 extends Map<T1, T1>, T1 extends int> {}
 C c;
-''';
-    await resolveTestUnit(code);
-    assertNoErrors(testSource);
+''');
+
     expectIdentifierType('c;', 'C<Map<int, int>, int>');
   }
 
   test_instantiateToBounds_class_ok_referenceOther_before() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 class C<T0 extends int, T1 extends T0> {}
 C c;
-''';
-    await resolveTestUnit(code);
-    assertNoErrors(testSource);
+''');
+
     expectIdentifierType('c;', 'C<int, int>');
   }
 
   test_instantiateToBounds_class_ok_referenceOther_multi() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 class C<T0 extends Map<T1, T2>, T1 extends List<T2>, T2 extends int> {}
 C c;
-''';
-    await resolveTestUnit(code);
-    assertNoErrors(testSource);
+''');
+
     expectIdentifierType('c;', 'C<Map<List<int>, int>, List<int>, int>');
   }
 
   test_instantiateToBounds_class_ok_simpleBounds() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 class A<T> {}
 class B<T extends num> {}
 class C<T extends List<int>> {}
@@ -5167,9 +5106,8 @@ void main() {
   C c;
   D d;
 }
-''';
-    await resolveTestUnit(code);
-    assertNoErrors(testSource);
+''');
+
     expectIdentifierType('a;', 'A<dynamic>');
     expectIdentifierType('b;', 'B<num>');
     expectIdentifierType('c;', 'C<List<int>>');
@@ -5179,21 +5117,22 @@ void main() {
   test_instantiateToBounds_generic_function_error_malbounded() async {
     // Test that generic methods are strictly checked for malbounded default
     // types
-    String code = r'''
+    await assertErrorsInCode(r'''
 T0 f<T0 extends List<T1>, T1 extends List<T0>>() {}
 void g() {
   var c = f();
   return;
 }
-''';
-    await resolveTestUnit(code, noErrors: false);
-    assertErrors(
-        testSource, [HintCode.MISSING_RETURN, StrongModeCode.COULD_NOT_INFER]);
+''', [
+      error(HintCode.MISSING_RETURN, 0, 2),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 69, 1),
+      error(StrongModeCode.COULD_NOT_INFER, 73, 1),
+    ]);
     expectIdentifierType('c =', 'List<dynamic>');
   }
 
   test_instantiateToBounds_method_ok_referenceOther_before() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 class C<T> {
   void m<S0 extends T, S1 extends List<S0>>(S0 p0, S1 p1) {}
 
@@ -5201,14 +5140,13 @@ class C<T> {
     m(null, null);
   }
 }
-''';
-    await resolveTestUnit(code);
-    assertNoErrors(testSource);
+''');
+
     expectStaticInvokeType('m(null', 'void Function(Null, Null)');
   }
 
   test_instantiateToBounds_method_ok_referenceOther_before2() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 class C<T> {
   Map<S0, S1> m<S0 extends T, S1 extends List<S0>>() => null;
 
@@ -5216,14 +5154,13 @@ class C<T> {
     m();
   }
 }
-''';
-    await resolveTestUnit(code);
-    assertNoErrors(testSource);
+''');
+
     expectStaticInvokeType('m();', 'Map<T, List<T>> Function()');
   }
 
   test_instantiateToBounds_method_ok_simpleBounds() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 class C<T> {
   void m<S extends T>(S p0) {}
 
@@ -5231,14 +5168,13 @@ class C<T> {
     m(null);
   }
 }
-''';
-    await resolveTestUnit(code);
-    assertNoErrors(testSource);
+''');
+
     expectStaticInvokeType('m(null)', 'void Function(Null)');
   }
 
   test_instantiateToBounds_method_ok_simpleBounds2() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 class C<T> {
   S m<S extends T>() => null;
 
@@ -5246,14 +5182,13 @@ class C<T> {
     m();
   }
 }
-''';
-    await resolveTestUnit(code);
-    assertNoErrors(testSource);
+''');
+
     expectStaticInvokeType('m();', 'T Function()');
   }
 
   test_issue32396() async {
-    await resolveTestUnit(r'''
+    await assertNoErrorsInCode(r'''
 class C<E> {
   static T g<T>(T e) => null;
   static final h = g;
@@ -5262,190 +5197,169 @@ class C<E> {
   }
 
   test_notInstantiatedBound_class_error_recursion() async {
-    String code = r'''
+    await assertErrorsInCode(r'''
 class A<T extends B> {} // points to a
 class B<T extends A> {} // points to b
 class C<T extends A> {} // points to a cyclical type
-''';
-    await resolveTestUnit(code, noErrors: false);
-    assertErrors(testSource, [
-      StrongModeCode.NOT_INSTANTIATED_BOUND,
-      StrongModeCode.NOT_INSTANTIATED_BOUND,
-      StrongModeCode.NOT_INSTANTIATED_BOUND,
+''', [
+      error(StrongModeCode.NOT_INSTANTIATED_BOUND, 18, 1),
+      error(StrongModeCode.NOT_INSTANTIATED_BOUND, 57, 1),
+      error(StrongModeCode.NOT_INSTANTIATED_BOUND, 96, 1),
     ]);
   }
 
   test_notInstantiatedBound_class_error_recursion_less_direct() async {
-    String code = r'''
+    await assertErrorsInCode(r'''
 class A<T extends B<A>> {}
 class B<T extends A<B>> {}
-''';
-    await resolveTestUnit(code, noErrors: false);
-    assertErrors(testSource, [
-      StrongModeCode.NOT_INSTANTIATED_BOUND,
-      StrongModeCode.NOT_INSTANTIATED_BOUND,
+''', [
+      error(StrongModeCode.NOT_INSTANTIATED_BOUND, 20, 1),
+      error(StrongModeCode.NOT_INSTANTIATED_BOUND, 47, 1),
     ]);
   }
 
   test_notInstantiatedBound_class_error_recursion_typedef() async {
-    String code = r'''
+    await assertErrorsInCode(r'''
 typedef F(C value);
 class C<T extends F> {}
 class D<T extends C> {}
-''';
-    await resolveTestUnit(code, noErrors: false);
-    assertErrors(testSource, [
-      StrongModeCode.NOT_INSTANTIATED_BOUND,
-      StrongModeCode.NOT_INSTANTIATED_BOUND,
-      CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF,
+''', [
+      error(CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF, 0, 19),
+      error(StrongModeCode.NOT_INSTANTIATED_BOUND, 38, 1),
+      error(StrongModeCode.NOT_INSTANTIATED_BOUND, 62, 1),
     ]);
   }
 
   test_notInstantiatedBound_error_class_argument() async {
-    String code = r'''
+    await assertErrorsInCode(r'''
 class A<K, V extends List<K>> {}
 class C<T extends A> {}
-''';
-    await resolveTestUnit(code, noErrors: false);
-    assertErrors(testSource, [StrongModeCode.NOT_INSTANTIATED_BOUND]);
+''', [
+      error(StrongModeCode.NOT_INSTANTIATED_BOUND, 51, 1),
+    ]);
   }
 
   test_notInstantiatedBound_error_class_argument2() async {
-    String code = r'''
+    await assertErrorsInCode(r'''
 class A<K, V extends List<List<K>>> {}
 class C<T extends A> {}
-''';
-    await resolveTestUnit(code, noErrors: false);
-    assertErrors(testSource, [StrongModeCode.NOT_INSTANTIATED_BOUND]);
+''', [
+      error(StrongModeCode.NOT_INSTANTIATED_BOUND, 57, 1),
+    ]);
   }
 
   test_notInstantiatedBound_error_class_direct() async {
-    String code = r'''
+    await assertErrorsInCode(r'''
 class A<K, V extends K> {}
 class C<T extends A> {}
-''';
-    await resolveTestUnit(code, noErrors: false);
-    assertErrors(testSource, [StrongModeCode.NOT_INSTANTIATED_BOUND]);
+''', [
+      error(StrongModeCode.NOT_INSTANTIATED_BOUND, 45, 1),
+    ]);
   }
 
   test_notInstantiatedBound_error_class_indirect() async {
-    String code = r'''
+    await assertErrorsInCode(r'''
 class A<K, V extends K> {}
 class C<T extends List<A>> {}
-''';
-    await resolveTestUnit(code, noErrors: false);
-    assertErrors(testSource, [StrongModeCode.NOT_INSTANTIATED_BOUND]);
+''', [
+      error(StrongModeCode.NOT_INSTANTIATED_BOUND, 50, 1),
+    ]);
   }
 
   test_notInstantiatedBound_error_functionType() async {
-    await resolveTestUnit(r'''
+    await assertErrorsInCode(r'''
 class A<T extends Function(T)> {}
 class B<T extends T Function()> {}
 class C<T extends A> {}
 class D<T extends B> {}
-''', noErrors: false);
-    assertErrors(testSource, [
-      StrongModeCode.NOT_INSTANTIATED_BOUND,
-      StrongModeCode.NOT_INSTANTIATED_BOUND
+''', [
+      error(StrongModeCode.NOT_INSTANTIATED_BOUND, 87, 1),
+      error(StrongModeCode.NOT_INSTANTIATED_BOUND, 111, 1),
     ]);
   }
 
   test_notInstantiatedBound_error_typedef_argument() async {
-    String code = r'''
+    await assertErrorsInCode(r'''
 class A<K, V extends List<K>> {}
 typedef void F<T extends A>();
-''';
-    await resolveTestUnit(code, noErrors: false);
-    assertErrors(testSource, [StrongModeCode.NOT_INSTANTIATED_BOUND]);
+''', [
+      error(StrongModeCode.NOT_INSTANTIATED_BOUND, 58, 1),
+    ]);
   }
 
   test_notInstantiatedBound_error_typedef_argument2() async {
-    String code = r'''
+    await assertErrorsInCode(r'''
 class A<K, V extends List<List<K>>> {}
 typedef void F<T extends A>();
-''';
-    await resolveTestUnit(code, noErrors: false);
-    assertErrors(testSource, [StrongModeCode.NOT_INSTANTIATED_BOUND]);
+''', [
+      error(StrongModeCode.NOT_INSTANTIATED_BOUND, 64, 1),
+    ]);
   }
 
   test_notInstantiatedBound_error_typedef_direct() async {
-    String code = r'''
+    await assertErrorsInCode(r'''
 class A<K, V extends K> {}
 typedef void F<T extends A>();
-''';
-    await resolveTestUnit(code, noErrors: false);
-    assertErrors(testSource, [StrongModeCode.NOT_INSTANTIATED_BOUND]);
+''', [
+      error(StrongModeCode.NOT_INSTANTIATED_BOUND, 52, 1),
+    ]);
   }
 
   test_notInstantiatedBound_ok_class() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 class A<T extends int> {}
 class C1<T extends A> {}
 class C2<T extends List<A>> {}
-''';
-    await resolveTestUnit(code);
-    assertNoErrors(testSource);
+''');
   }
 
   test_notInstantiatedBound_ok_class_class2() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 class A<T> {}
 class C<T extends A<int>> {}
 class D<T extends C> {}
-''';
-    await resolveTestUnit(code);
-    assertNoErrors(testSource);
+''');
   }
 
   test_notInstantiatedBound_ok_class_class3() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 class A<T> {}
 class B<T extends int> {}
 class C<T extends A<B>> {}
-''';
-    await resolveTestUnit(code);
-    assertNoErrors(testSource);
+''');
   }
 
   test_notInstantiatedBound_ok_class_class4() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 class A<K, V> {}
 class B<T extends int> {}
 class C<T extends A<B, B>> {}
-''';
-    await resolveTestUnit(code);
-    assertNoErrors(testSource);
+''');
   }
 
   test_notInstantiatedBound_ok_class_function() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 class A<T extends void Function()> {}
 class B<T extends A> {}
-''';
-    await resolveTestUnit(code);
-    assertNoErrors(testSource);
+''');
   }
 
   test_notInstantiatedBound_ok_class_typedef() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 typedef void F<T extends int>();
 class C<T extends F> {}
-''';
-    await resolveTestUnit(code);
-    assertNoErrors(testSource);
+''');
   }
 
   test_notInstantiatedBound_ok_typedef_class() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 class C<T extends int> {}
 typedef void F<T extends C>();
-''';
-    await resolveTestUnit(code);
-    assertNoErrors(testSource);
+''');
   }
 
   test_objectMethodOnFunctions_Anonymous() async {
-    String code = r'''
+    await _objectMethodOnFunctions_helper2(r'''
 void main() {
   var f = (x) => 3;
   // No errors, correct type
@@ -5467,12 +5381,11 @@ void main() {
   (f)..toString();
   (f)..toString;
   (f)..hashCode;
-}''';
-    await _objectMethodOnFunctions_helper2(code);
+}''');
   }
 
   test_objectMethodOnFunctions_Function() async {
-    String code = r'''
+    await _objectMethodOnFunctions_helper2(r'''
 void main() {
   Function f;
   // No errors, correct type
@@ -5494,12 +5407,11 @@ void main() {
   (f)..toString();
   (f)..toString;
   (f)..hashCode;
-}''';
-    await _objectMethodOnFunctions_helper2(code);
+}''');
   }
 
   test_objectMethodOnFunctions_Static() async {
-    String code = r'''
+    await _objectMethodOnFunctions_helper2(r'''
 int f(int x) => null;
 void main() {
   // No errors, correct type
@@ -5521,12 +5433,11 @@ void main() {
   (f)..toString();
   (f)..toString;
   (f)..hashCode;
-}''';
-    await _objectMethodOnFunctions_helper2(code);
+}''');
   }
 
   test_objectMethodOnFunctions_Typedef() async {
-    String code = r'''
+    await _objectMethodOnFunctions_helper2(r'''
 typedef bool Predicate<T>(T object);
 
 void main() {
@@ -5550,110 +5461,93 @@ void main() {
   (f)..toString();
   (f)..toString;
   (f)..hashCode;
-}''';
-    await _objectMethodOnFunctions_helper2(code);
+}''');
   }
 
   test_returnOfInvalidType_object_void() async {
     await assertErrorsInCode(
-        "Object f() { void voidFn() => null; return voidFn(); }",
-        [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
+        "Object f() { void voidFn() => null; return voidFn(); }", [
+      error(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, 43, 8),
+    ]);
   }
 
   test_setterWithDynamicTypeIsError() async {
-    Source source = addSource(r'''
+    await assertErrorsInCode(r'''
 class A {
   dynamic set f(String s) => null;
 }
 dynamic set g(int x) => null;
-''');
-    await computeAnalysisResult(source);
-    assertErrors(source, [
-      StaticWarningCode.NON_VOID_RETURN_FOR_SETTER,
-      StaticWarningCode.NON_VOID_RETURN_FOR_SETTER
+''', [
+      error(StaticWarningCode.NON_VOID_RETURN_FOR_SETTER, 12, 7),
+      error(StaticWarningCode.NON_VOID_RETURN_FOR_SETTER, 47, 7),
     ]);
-    verify([source]);
   }
 
   test_setterWithExplicitVoidType_returningVoid() async {
-    Source source = addSource(r'''
+    await assertNoErrorsInCode(r'''
 void returnsVoid() {}
 class A {
   void set f(String s) => returnsVoid();
 }
 void set g(int x) => returnsVoid();
 ''');
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
   }
 
   test_setterWithNoVoidType() async {
-    Source source = addSource(r'''
+    await assertErrorsInCode(r'''
 class A {
   set f(String s) {
     return '42';
   }
 }
 set g(int x) => 42;
-''');
-    await computeAnalysisResult(source);
-    assertErrors(source, [
-      StaticTypeWarningCode.RETURN_OF_INVALID_TYPE,
+''', [
+      error(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, 41, 4),
     ]);
-    verify([source]);
   }
 
   test_setterWithNoVoidType_returningVoid() async {
-    Source source = addSource(r'''
+    await assertNoErrorsInCode(r'''
 void returnsVoid() {}
 class A {
   set f(String s) => returnsVoid();
 }
 set g(int x) => returnsVoid();
 ''');
-    await computeAnalysisResult(source);
-    assertNoErrors(source);
-    verify([source]);
   }
 
   test_setterWithOtherTypeIsError() async {
-    Source source = addSource(r'''
+    await assertErrorsInCode(r'''
 class A {
   String set f(String s) => null;
 }
 Object set g(x) => null;
-''');
-    await computeAnalysisResult(source);
-    assertErrors(source, [
-      StaticWarningCode.NON_VOID_RETURN_FOR_SETTER,
-      StaticWarningCode.NON_VOID_RETURN_FOR_SETTER
+''', [
+      error(StaticWarningCode.NON_VOID_RETURN_FOR_SETTER, 12, 6),
+      error(StaticWarningCode.NON_VOID_RETURN_FOR_SETTER, 46, 6),
     ]);
-    verify([source]);
   }
 
   test_ternaryOperator_null_left() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 main() {
   var foo = (true) ? null : 3;
 }
-''';
-    await resolveTestUnit(code);
+''');
     expectInitializerType('foo', 'int');
   }
 
   test_ternaryOperator_null_right() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 main() {
   var foo = (true) ? 3 : null;
 }
-''';
-    await resolveTestUnit(code);
+''');
     expectInitializerType('foo', 'int');
   }
 
   Future<void> _objectMethodOnFunctions_helper2(String code) async {
-    await resolveTestUnit(code);
+    await assertNoErrorsInCode(code);
     expectIdentifierType('t0', "String");
     expectIdentifierType('t1', "String Function()");
     expectIdentifierType('t2', "int");
@@ -5665,13 +5559,6 @@ main() {
 
 @reflectiveTest
 class StrongModeTypePropagationTest extends ResolverTestCase {
-  @override
-  void setUp() {
-    super.setUp();
-    AnalysisOptionsImpl options = new AnalysisOptionsImpl();
-    resetWith(options: options);
-  }
-
   test_foreachInference_dynamic_disabled() async {
     String code = r'''
 main() {
diff --git a/pkg/analyzer/test/src/diagnostics/inference_failure_on_uninitialized_variable_test.dart b/pkg/analyzer/test/src/diagnostics/inference_failure_on_uninitialized_variable_test.dart
index 736554b81ea..846fd9cb850 100644
--- a/pkg/analyzer/test/src/diagnostics/inference_failure_on_uninitialized_variable_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/inference_failure_on_uninitialized_variable_test.dart
@@ -20,111 +20,21 @@ main() {
 class InferenceFailureOnUninitializedVariableTest
     extends StaticTypeAnalyzer2TestShared {
   @override
-  void setUp() {
-    super.setUp();
-    AnalysisOptionsImpl options = new AnalysisOptionsImpl();
-    options.strictInference = true;
-    resetWith(options: options);
-  }
-
-  test_localVariable() async {
-    String code = r'''
-void f() {
-  var a;
-}
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertErrorsInCode(
-        code, [HintCode.INFERENCE_FAILURE_ON_UNINITIALIZED_VARIABLE]);
-  }
-
-  test_localVariable_withInitializer() async {
-    String code = r'''
-void f() {
-  var a = 7;
-}
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertNoErrorsInCode(code);
-  }
-
-  test_localVariable_withType() async {
-    String code = r'''
-void f() {
-  int a;
-  dynamic b;
-  Object c;
-  Null d;
-}
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertNoErrorsInCode(code);
-  }
-
-  test_topLevelVariable() async {
-    String code = r'''
-var a;
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertErrorsInCode(
-        code, [HintCode.INFERENCE_FAILURE_ON_UNINITIALIZED_VARIABLE]);
-  }
-
-  test_topLevelVariable_withInitializer() async {
-    String code = r'''
-var a = 7;
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertNoErrorsInCode(code);
-  }
-
-  test_topLevelVariable_withType() async {
-    String code = r'''
-int a;
-dynamic b;
-Object c;
-Null d;
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertNoErrorsInCode(code);
-  }
+  AnalysisOptionsImpl get analysisOptions =>
+      AnalysisOptionsImpl()..strictInference = true;
 
   test_field() async {
-    String code = r'''
+    await assertErrorsInCode(r'''
 class C {
   var a;
 }
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertErrorsInCode(
-        code, [HintCode.INFERENCE_FAILURE_ON_UNINITIALIZED_VARIABLE]);
-  }
-
-  test_finalField() async {
-    String code = r'''
-class C {
-  final a;
-  C(this.a);
-}
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertErrorsInCode(
-        code, [HintCode.INFERENCE_FAILURE_ON_UNINITIALIZED_VARIABLE]);
-  }
-
-  test_staticField() async {
-    String code = r'''
-class C {
-  static var a;
-}
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertErrorsInCode(
-        code, [HintCode.INFERENCE_FAILURE_ON_UNINITIALIZED_VARIABLE]);
+''', [
+      error(HintCode.INFERENCE_FAILURE_ON_UNINITIALIZED_VARIABLE, 16, 1),
+    ]);
   }
 
   test_field_withInitializer() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 class C {
   static var c = 3;
   static final d = 5;
@@ -132,13 +42,11 @@ class C {
   var a = 7;
   final b = 9;
 }
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertNoErrorsInCode(code);
+''');
   }
 
   test_field_withType() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 class C {
   static int c;
   static final int d = 5;
@@ -148,8 +56,87 @@ class C {
 
   C(this.b);
 }
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertNoErrorsInCode(code);
+''');
+  }
+
+  test_finalField() async {
+    await assertErrorsInCode(r'''
+class C {
+  final a;
+  C(this.a);
+}
+''', [
+      error(HintCode.INFERENCE_FAILURE_ON_UNINITIALIZED_VARIABLE, 18, 1),
+    ]);
+  }
+
+  test_localVariable() async {
+    await assertErrorsInCode(r'''
+void f() {
+  var a;
+}
+''', [
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 17, 1),
+      error(HintCode.INFERENCE_FAILURE_ON_UNINITIALIZED_VARIABLE, 17, 1),
+    ]);
+  }
+
+  test_localVariable_withInitializer() async {
+    await assertErrorsInCode(r'''
+void f() {
+  var a = 7;
+}
+''', [
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 17, 1),
+    ]);
+  }
+
+  test_localVariable_withType() async {
+    await assertErrorsInCode(r'''
+void f() {
+  int a;
+  dynamic b;
+  Object c;
+  Null d;
+}
+''', [
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 17, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 30, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 42, 1),
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 52, 1),
+    ]);
+  }
+
+  test_staticField() async {
+    await assertErrorsInCode(r'''
+class C {
+  static var a;
+}
+''', [
+      error(HintCode.INFERENCE_FAILURE_ON_UNINITIALIZED_VARIABLE, 23, 1),
+    ]);
+  }
+
+  test_topLevelVariable() async {
+    await assertErrorsInCode(r'''
+var a;
+''', [
+      error(HintCode.INFERENCE_FAILURE_ON_UNINITIALIZED_VARIABLE, 4, 1),
+    ]);
+  }
+
+  test_topLevelVariable_withInitializer() async {
+    await assertNoErrorsInCode(r'''
+var a = 7;
+''');
+  }
+
+  test_topLevelVariable_withType() async {
+    await assertNoErrorsInCode(r'''
+int a;
+dynamic b;
+Object c;
+Null d;
+''');
   }
 }
diff --git a/pkg/analyzer/test/src/diagnostics/inference_failure_on_untyped_parameter_test.dart b/pkg/analyzer/test/src/diagnostics/inference_failure_on_untyped_parameter_test.dart
index e1cf2550bed..c7db5f1f620 100644
--- a/pkg/analyzer/test/src/diagnostics/inference_failure_on_untyped_parameter_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/inference_failure_on_untyped_parameter_test.dart
@@ -20,104 +20,117 @@ main() {
 class InferenceFailureOnUntypedParameterTest
     extends StaticTypeAnalyzer2TestShared {
   @override
-  void setUp() {
-    super.setUp();
-    AnalysisOptionsImpl options = new AnalysisOptionsImpl();
-    options.strictInference = true;
-    resetWith(options: options);
+  AnalysisOptionsImpl get analysisOptions =>
+      AnalysisOptionsImpl()..strictInference = true;
+
+  test_fieldParameter() async {
+    await assertNoErrorsInCode(r'''
+class C {
+  int a;
+  C(this.a) {}
+}
+''');
   }
 
-  test_parameter() async {
-    String code = r'''
-void fn(a) => print(a);
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertErrorsInCode(
-        code, [HintCode.INFERENCE_FAILURE_ON_UNTYPED_PARAMETER]);
+  test_functionTypeParameter_withType() async {
+    await assertNoErrorsInCode(r'''
+void fn(String cb(int x)) => print(cb(7));
+''');
   }
 
-  test_parameter_withVar() async {
-    String code = r'''
-void fn(var a) => print(a);
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertErrorsInCode(
-        code, [HintCode.INFERENCE_FAILURE_ON_UNTYPED_PARAMETER]);
-  }
-
-  test_parameter_withType() async {
-    String code = r'''
-void fn(int a) => print(a);
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertNoErrorsInCode(code);
-  }
-
-  test_parameter_inGenericFunction_withType() async {
-    String code = r'''
-void fn<T>(T a) => print(a);
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertNoErrorsInCode(code);
-  }
-
-  test_parameter_withVarAndDefault() async {
-    String code = r'''
-void fn([var a = 7]) => print(a);
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertErrorsInCode(
-        code, [HintCode.INFERENCE_FAILURE_ON_UNTYPED_PARAMETER]);
-  }
-
-  test_parameter_withTypeAndDefault() async {
-    String code = r'''
-void fn([int a = 7]) => print(a);
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertNoErrorsInCode(code);
-  }
-
-  test_namedParameter_withVar() async {
-    String code = r'''
-void fn({var a}) => print(a);
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertErrorsInCode(
-        code, [HintCode.INFERENCE_FAILURE_ON_UNTYPED_PARAMETER]);
+  test_functionTypeParameter_withVar() async {
+    await assertErrorsInCode(r'''
+void fn(String cb(var x)) => print(cb(7));
+''', [
+      error(HintCode.INFERENCE_FAILURE_ON_UNTYPED_PARAMETER, 18, 5),
+    ]);
   }
 
   test_namedParameter_withType() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 void fn({int a}) => print(a);
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertNoErrorsInCode(code);
+''');
+  }
+
+  test_namedParameter_withVar() async {
+    await assertErrorsInCode(r'''
+void fn({var a}) => print(a);
+''', [
+      error(HintCode.INFERENCE_FAILURE_ON_UNTYPED_PARAMETER, 9, 5),
+    ]);
+  }
+
+  test_parameter() async {
+    await assertErrorsInCode(r'''
+void fn(a) => print(a);
+''', [
+      error(HintCode.INFERENCE_FAILURE_ON_UNTYPED_PARAMETER, 8, 1),
+    ]);
+  }
+
+  test_parameter_inConstructor() async {
+    await assertErrorsInCode(r'''
+class C {
+  C(var a) {}
+}
+''', [
+      error(HintCode.INFERENCE_FAILURE_ON_UNTYPED_PARAMETER, 14, 5),
+    ]);
+  }
+
+  test_parameter_inConstructor_withType() async {
+    await assertNoErrorsInCode(r'''
+class C {
+  C(int a) {}
+}
+''');
+  }
+
+  test_parameter_inFunctionLiteral() async {
+    await assertErrorsInCode(r'''
+void fn() {
+  var f = (var a) {};
+}
+''', [
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 18, 1),
+      error(HintCode.INFERENCE_FAILURE_ON_UNTYPED_PARAMETER, 23, 5),
+    ]);
+  }
+
+  test_parameter_inFunctionLiteral_withType() async {
+    await assertNoErrorsInCode(r'''
+void fn() {
+  var f = (int a) {};
+}
+''');
+  }
+
+  test_parameter_inGenericFunction_withType() async {
+    await assertNoErrorsInCode(r'''
+void fn<T>(T a) => print(a);
+''');
   }
 
   test_parameter_inMethod() async {
-    String code = r'''
+    await assertErrorsInCode(r'''
 class C {
   void fn(var a) => print(a);
 }
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertErrorsInCode(
-        code, [HintCode.INFERENCE_FAILURE_ON_UNTYPED_PARAMETER]);
+''', [
+      error(HintCode.INFERENCE_FAILURE_ON_UNTYPED_PARAMETER, 20, 5),
+    ]);
   }
 
   test_parameter_inMethod_withType() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 class C {
   void fn(String a) => print(a);
 }
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertNoErrorsInCode(code);
+''');
   }
 
   test_parameter_inOverridingMethod() async {
-    String code = r'''
+    await assertErrorsInCode(r'''
 class C {
   void fn(int a) => print(a);
 }
@@ -126,29 +139,13 @@ class D extends C {
   @override
   void fn(var a) => print(a);
 }
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertErrorsInCode(
-        code, [HintCode.INFERENCE_FAILURE_ON_UNTYPED_PARAMETER]);
-  }
-
-  test_parameter_inOverridingMethod_withType() async {
-    String code = r'''
-class C {
-  void fn(int a) => print(a);
-}
-
-class D extends C {
-  @override
-  void fn(num a) => print(a);
-}
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertNoErrorsInCode(code);
+''', [
+      error(HintCode.INFERENCE_FAILURE_ON_UNTYPED_PARAMETER, 85, 5),
+    ]);
   }
 
   test_parameter_inOverridingMethod_withDefault() async {
-    String code = r'''
+    await assertErrorsInCode(r'''
 class C {
   void fn([int a = 7]) => print(a);
 }
@@ -157,14 +154,13 @@ class D extends C {
   @override
   void fn([var a = 7]) => print(a);
 }
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertErrorsInCode(
-        code, [HintCode.INFERENCE_FAILURE_ON_UNTYPED_PARAMETER]);
+''', [
+      error(HintCode.INFERENCE_FAILURE_ON_UNTYPED_PARAMETER, 92, 5),
+    ]);
   }
 
   test_parameter_inOverridingMethod_withDefaultAndType() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 class C {
   void fn([int a = 7]) => print(a);
 }
@@ -173,86 +169,53 @@ class D extends C {
   @override
   void fn([num a = 7]) => print(a);
 }
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertNoErrorsInCode(code);
+''');
   }
 
-  test_parameter_inConstructor() async {
-    String code = r'''
+  test_parameter_inOverridingMethod_withType() async {
+    await assertNoErrorsInCode(r'''
 class C {
-  C(var a) {}
+  void fn(int a) => print(a);
 }
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertErrorsInCode(
-        code, [HintCode.INFERENCE_FAILURE_ON_UNTYPED_PARAMETER]);
-  }
 
-  test_parameter_inConstructor_withType() async {
-    String code = r'''
-class C {
-  C(int a) {}
+class D extends C {
+  @override
+  void fn(num a) => print(a);
 }
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertNoErrorsInCode(code);
-  }
-
-  test_fieldParameter() async {
-    String code = r'''
-class C {
-  int a;
-  C(this.a) {}
-}
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertNoErrorsInCode(code);
-  }
-
-  test_parameter_inFunctionLiteral() async {
-    String code = r'''
-void fn() {
-  var f = (var a) {};
-}
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertErrorsInCode(
-        code, [HintCode.INFERENCE_FAILURE_ON_UNTYPED_PARAMETER]);
-  }
-
-  test_parameter_inFunctionLiteral_withType() async {
-    String code = r'''
-void fn() {
-  var f = (int a) {};
-}
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertNoErrorsInCode(code);
-  }
-
-  test_functionTypeParameter_withVar() async {
-    String code = r'''
-void fn(String cb(var x)) => print(cb(7));
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertErrorsInCode(
-        code, [HintCode.INFERENCE_FAILURE_ON_UNTYPED_PARAMETER]);
-  }
-
-  test_functionTypeParameter_withType() async {
-    String code = r'''
-void fn(String cb(int x)) => print(cb(7));
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertNoErrorsInCode(code);
+''');
   }
 
   test_parameter_inTypedef_withType() async {
-    String code = r'''
+    await assertNoErrorsInCode(r'''
 typedef cb = void Function(int a);
-''';
-    await resolveTestUnit(code, noErrors: false);
-    await assertNoErrorsInCode(code);
+''');
+  }
+
+  test_parameter_withType() async {
+    await assertNoErrorsInCode(r'''
+void fn(int a) => print(a);
+''');
+  }
+
+  test_parameter_withTypeAndDefault() async {
+    await assertNoErrorsInCode(r'''
+void fn([int a = 7]) => print(a);
+''');
+  }
+
+  test_parameter_withVar() async {
+    await assertErrorsInCode(r'''
+void fn(var a) => print(a);
+''', [
+      error(HintCode.INFERENCE_FAILURE_ON_UNTYPED_PARAMETER, 8, 5),
+    ]);
+  }
+
+  test_parameter_withVarAndDefault() async {
+    await assertErrorsInCode(r'''
+void fn([var a = 7]) => print(a);
+''', [
+      error(HintCode.INFERENCE_FAILURE_ON_UNTYPED_PARAMETER, 9, 5),
+    ]);
   }
 }