Clean up some copy/paste in a test.

pkg/analyzer/test/generated/static_type_warning_code_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.test.generated.static_type_warning_code_test;
 
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/java_core.dart' show formatList;
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:unittest/unittest.dart';
 
 import '../reflective_tests.dart';
 import '../utils.dart';
 import 'resolver_test.dart';
 
 main() {
   initializeTestEnvironment();
   runReflectiveTests(StaticTypeWarningCodeTest);
   runReflectiveTests(StrongModeStaticTypeWarningCodeTest);
 }
 
 @reflectiveTest
 class StaticTypeWarningCodeTest extends ResolverTestCase {
   void fail_inaccessibleSetter() {
-    Source source = addSource(r'''
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.INACCESSIBLE_SETTER]);
-    verify([source]);
+    // TODO(rnystrom): This doesn't look right.

[Brian Wilkerson, 2016/03/09 01:37:38]

Note that the method's name is "fail", indicating that the test is expected to
fail. What this likely means is that someone wrote the skeleton of a test for
the INACCESSIBLE_SETTER warning, but forgot to come back and write test code for
it.

[Bob Nystrom, 2016/03/09 01:46:47]

That's what I figured. :) Tests that are just expected to fail in some blanket
way tend to be brittle to code rot in that way.

+    assertErrorsInCode(
+        r'''
+''',
+        [StaticTypeWarningCode.INACCESSIBLE_SETTER]);
   }
 
   void fail_method_lookup_mixin_of_extends() {
     // See dartbug.com/25605
     resetWithOptions(new AnalysisOptionsImpl()..enableSuperMixins = true);
-    Source source = addSource('''
+    assertErrorsInUnverifiedCode(
+        '''
 class A { a() => null; }
 class B {}
 abstract class M extends A {}
 class T = B with M; // Warning: B does not extend A
 main() {
   new T().a(); // Warning: The method 'a' is not defined for the class 'T'
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [
-      // TODO(paulberry): when dartbug.com/25614 is fixed, add static warning
-      // code for "B does not extend A".
-      StaticTypeWarningCode.UNDEFINED_METHOD
-    ]);
+''',
+        [
+          // TODO(paulberry): when dartbug.com/25614 is fixed, add static warning
+          // code for "B does not extend A".
+          StaticTypeWarningCode.UNDEFINED_METHOD
+        ]);
   }
 
   void fail_method_lookup_mixin_of_implements() {
     // See dartbug.com/25605
     resetWithOptions(new AnalysisOptionsImpl()..enableSuperMixins = true);
-    Source source = addSource('''
+    assertErrorsInUnverifiedCode(
+        '''
 class A { a() => null; }
 class B {}
 abstract class M implements A {}
 class T = B with M; // Warning: Missing concrete implementation of 'A.a'
 main() {
   new T().a(); // Warning: The method 'a' is not defined for the class 'T'
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [
-      StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE,
-      StaticTypeWarningCode.UNDEFINED_METHOD
-    ]);
+''',
+        [
+          StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE,
+          StaticTypeWarningCode.UNDEFINED_METHOD
+        ]);
   }
 
   void fail_method_lookup_mixin_of_mixin() {
     // See dartbug.com/25605
     resetWithOptions(new AnalysisOptionsImpl()..enableSuperMixins = true);
-    Source source = addSource('''
+    assertErrorsInUnverifiedCode(
+        '''
 class A {}
 class B { b() => null; }
 class C {}
 class M extends A with B {}
 class T = C with M;
 main() {
   new T().b();
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_METHOD]);
+''',
+        [StaticTypeWarningCode.UNDEFINED_METHOD]);
   }
 
   void fail_method_lookup_mixin_of_mixin_application() {
     // See dartbug.com/25605
     resetWithOptions(new AnalysisOptionsImpl()..enableSuperMixins = true);
-    Source source = addSource('''
+    assertErrorsInUnverifiedCode(
+        '''
 class A { a() => null; }
 class B {}
 class C {}
 class M = A with B;
 class T = C with M;
 main() {
   new T().a();
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_METHOD]);
+''',
+        [StaticTypeWarningCode.UNDEFINED_METHOD]);
   }
 
   void fail_undefinedEnumConstant() {
     // We need a way to set the parseEnum flag in the parser to true.
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 enum E { ONE }
 E e() {
   return E.TWO;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_ENUM_CONSTANT]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_ENUM_CONSTANT]);
   }
 
   void test_ambiguousImport_function() {
     Source source = addSource(r'''
 import 'lib1.dart';
 import 'lib2.dart';
 g() { return f(); }''');
     addNamedSource(
         "/lib1.dart",
         r'''
 library lib1;
 f() {}''');
     addNamedSource(
         "/lib2.dart",
         r'''
 library lib2;
 f() {}''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [StaticWarningCode.AMBIGUOUS_IMPORT]);
   }
 
   void test_assert_message_suppresses_type_promotion() {
     // If a variable is assigned to inside the expression for an assert
     // message, type promotion should be suppressed, just as it would be if the
     // assignment occurred outside an assert statement.  (Note that it is a
     // dubious practice for the computation of an assert message to have side
     // effects, since it is only evaluated if the assert fails).
     resetWithOptions(new AnalysisOptionsImpl()..enableAssertMessage = true);
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 class C {
   void foo() {}
 }
 
 f(Object x) {
   if (x is C) {
     x.foo();
     assert(true, () { x = new C(); return 'msg'; }());
   }
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_METHOD]);
+''',
+        [StaticTypeWarningCode.UNDEFINED_METHOD]);
     // Do not verify since `x.foo()` fails to resolve.
   }
 
   void test_await_flattened() {
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 import 'dart:async';
 Future<Future<int>> ffi() => null;
 f() async {
   Future<int> b = await ffi(); // Warning: int not assignable to Future<int>
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
-    verify([source]);
+''',
+        [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
   }
 
   void test_await_simple() {
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 import 'dart:async';
 Future<int> fi() => null;
 f() async {
   String a = await fi(); // Warning: int not assignable to String
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
-    verify([source]);
+''',
+        [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
   }
 
   void test_bug21912() {
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 class A {}
 class B extends A {}
 
 typedef T Function2<S, T>(S z);
 typedef B AToB(A x);
 typedef A BToA(B x);
 
 void main() {
   {
     Function2<Function2<A, B>, Function2<B, A>> t1;
     Function2<AToB, BToA> t2;
 
     Function2<Function2<int, double>, Function2<int, double>> left;
 
     left = t1;
     left = t2;
   }
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [
-      StaticTypeWarningCode.INVALID_ASSIGNMENT,
-      StaticTypeWarningCode.INVALID_ASSIGNMENT
-    ]);
-    verify([source]);
+''',
+        [
+          StaticTypeWarningCode.INVALID_ASSIGNMENT,
+          StaticTypeWarningCode.INVALID_ASSIGNMENT
+        ]);
   }
 
   void test_expectedOneListTypeArgument() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 main() {
   <int, int> [];
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.EXPECTED_ONE_LIST_TYPE_ARGUMENTS]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.EXPECTED_ONE_LIST_TYPE_ARGUMENTS]);
   }
 
   void test_expectedTwoMapTypeArguments_one() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 main() {
   <int> {};
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.EXPECTED_TWO_MAP_TYPE_ARGUMENTS]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.EXPECTED_TWO_MAP_TYPE_ARGUMENTS]);
   }
 
   void test_expectedTwoMapTypeArguments_three() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 main() {
   <int, int, int> {};
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.EXPECTED_TWO_MAP_TYPE_ARGUMENTS]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.EXPECTED_TWO_MAP_TYPE_ARGUMENTS]);
   }
 
   void test_illegal_return_type_async_function() {
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 int f() async {}
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [
-      StaticTypeWarningCode.ILLEGAL_ASYNC_RETURN_TYPE,
-      HintCode.MISSING_RETURN
-    ]);
-    verify([source]);
+''',
+        [
+          StaticTypeWarningCode.ILLEGAL_ASYNC_RETURN_TYPE,
+          HintCode.MISSING_RETURN
+        ]);
   }
 
   void test_illegal_return_type_async_generator_function() {
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 int f() async* {}
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.ILLEGAL_ASYNC_GENERATOR_RETURN_TYPE]);
-    verify([source]);
+''',
+        [StaticTypeWarningCode.ILLEGAL_ASYNC_GENERATOR_RETURN_TYPE]);
   }
 
   void test_illegal_return_type_async_generator_method() {
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 class C {
   int f() async* {}
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.ILLEGAL_ASYNC_GENERATOR_RETURN_TYPE]);
-    verify([source]);
+''',
+        [StaticTypeWarningCode.ILLEGAL_ASYNC_GENERATOR_RETURN_TYPE]);
   }
 
   void test_illegal_return_type_async_method() {
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 class C {
   int f() async {}
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [
-      StaticTypeWarningCode.ILLEGAL_ASYNC_RETURN_TYPE,
-      HintCode.MISSING_RETURN
-    ]);
-    verify([source]);
+''',
+        [
+          StaticTypeWarningCode.ILLEGAL_ASYNC_RETURN_TYPE,
+          HintCode.MISSING_RETURN
+        ]);
   }
 
   void test_illegal_return_type_sync_generator_function() {
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 int f() sync* {}
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.ILLEGAL_SYNC_GENERATOR_RETURN_TYPE]);
-    verify([source]);
+''',
+        [StaticTypeWarningCode.ILLEGAL_SYNC_GENERATOR_RETURN_TYPE]);
   }
 
   void test_illegal_return_type_sync_generator_method() {
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 class C {
   int f() sync* {}
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.ILLEGAL_SYNC_GENERATOR_RETURN_TYPE]);
-    verify([source]);
+''',
+        [StaticTypeWarningCode.ILLEGAL_SYNC_GENERATOR_RETURN_TYPE]);
   }
 
   void test_inconsistentMethodInheritance_paramCount() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 abstract class A {
   int x();
 }
 abstract class B {
   int x(int y);
 }
 class C implements A, B {
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE]);
   }
 
   void test_inconsistentMethodInheritance_paramType() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 abstract class A {
   x(int i);
 }
 abstract class B {
   x(String s);
 }
-abstract class C implements A, B {}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE]);
-    verify([source]);
+abstract class C implements A, B {}
+''',
+        [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE]);
   }
 
   void test_inconsistentMethodInheritance_returnType() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 abstract class A {
   int x();
 }
 abstract class B {
   String x();
 }
-abstract class C implements A, B {}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE]);
-    verify([source]);
+abstract class C implements A, B {}
+''',
+        [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE]);
   }
 
   void test_instanceAccessToStaticMember_method_invocation() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {
   static m() {}
 }
 main(A a) {
   a.m();
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER]);
   }
 
   void test_instanceAccessToStaticMember_method_reference() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {
   static m() {}
 }
 main(A a) {
   a.m;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER]);
   }
 
   void test_instanceAccessToStaticMember_propertyAccess_field() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {
   static var f;
 }
 main(A a) {
   a.f;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER]);
   }
 
   void test_instanceAccessToStaticMember_propertyAccess_getter() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {
   static get f => 42;
 }
 main(A a) {
   a.f;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER]);
   }
 
   void test_instanceAccessToStaticMember_propertyAccess_setter() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {
   static set f(x) {}
 }
 main(A a) {
   a.f = 42;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER]);
   }
 
   void test_invalidAssignment_compoundAssignment() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class byte {
   int _value;
   byte(this._value);
   int operator +(int val) { return 0; }
 }
 
 void main() {
   byte b = new byte(52);
   b += 3;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
   }
 
   void test_invalidAssignment_defaultValue_named() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 f({String x: 0}) {
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
   }
 
   void test_invalidAssignment_defaultValue_optional() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 f([String x = 0]) {
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
   }
 
   void test_invalidAssignment_dynamic() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 main() {
   dynamic = 1;
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
-    verify([source]);
+''',
+        [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
   }
 
   void test_invalidAssignment_functionExpressionInvocation() {
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 main() {
   String x = (() => 5)();
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
   }
 
   void test_invalidAssignment_ifNullAssignment() {
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 void f(int i) {
   double d;
   d ??= i;
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
-    verify([source]);
+''',
+        [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
   }
 
   void test_invalidAssignment_instanceVariable() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {
   int x;
 }
 f() {
   A a;
   a.x = '0';
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
   }
 
   void test_invalidAssignment_localVariable() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 f() {
   int x;
   x = '0';
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
   }
 
   void test_invalidAssignment_regressionInIssue18468Fix() {
     // https://code.google.com/p/dart/issues/detail?id=18628
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class C<T> {
   T t = int;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
   }
 
   void test_invalidAssignment_staticVariable() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {
   static int x;
 }
 f() {
   A.x = '0';
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
   }
 
   void test_invalidAssignment_topLevelVariableDeclaration() {
-    Source source = addSource("int x = 'string';");
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
-    verify([source]);
+    assertErrorsInCode(
+        "int x = 'string';", [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
   }
 
   void test_invalidAssignment_typeParameter() {
     // 14221
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class B<T> {
   T value;
   void test(num n) {
     value = n;
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
   }
 
   void test_invalidAssignment_variableDeclaration() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {
   int x = 'string';
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
   }
 
   void test_invocationOfNonFunction_class() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {
   void m() {
     A();
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
+}''',
+        [StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
   }
 
   void test_invocationOfNonFunction_localGenericFunction() {
     // Objects having a specific function type may be invoked, but objects
     // having type Function may not, because type Function lacks a call method
     // (this is because it is impossible to know what signature the call should
     // have).
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.enableStrictCallChecks = true;
     resetWithOptions(options);
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 f(Function f) {
   return f();
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
   }
 
   void test_invocationOfNonFunction_localObject() {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.enableStrictCallChecks = true;
     resetWithOptions(options);
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 f(Object o) {
   return o();
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
   }
 
   void test_invocationOfNonFunction_localVariable() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 f() {
   int x;
   return x();
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
   }
 
   void test_invocationOfNonFunction_ordinaryInvocation() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {
   static int x;
 }
 class B {
   m() {
     A.x();
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
+}''',
+        [StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
     // A call to verify(source) fails as A.x() cannot be resolved.
   }
 
   void test_invocationOfNonFunction_staticInvocation() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {
   static int get g => 0;
   f() {
     A.g();
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
+}''',
+        [StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
     // A call to verify(source) fails as g() cannot be resolved.
   }
 
   void test_invocationOfNonFunction_superExpression() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {
   int get g => 0;
 }
 class B extends A {
   m() {
     var v = super.g();
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION]);
   }
 
   void test_invocationOfNonFunctionExpression_literal() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 f() {
   3(5);
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION_EXPRESSION]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION_EXPRESSION]);
   }
 
   void test_nonBoolCondition_conditional() {
-    Source source = addSource("f() { return 3 ? 2 : 1; }");
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.NON_BOOL_CONDITION]);
-    verify([source]);
+    assertErrorsInCode("f() { return 3 ? 2 : 1; }",
+        [StaticTypeWarningCode.NON_BOOL_CONDITION]);
   }
 
   void test_nonBoolCondition_do() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 f() {
   do {} while (3);
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.NON_BOOL_CONDITION]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.NON_BOOL_CONDITION]);
   }
 
   void test_nonBoolCondition_for() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 f() {
   for (;3;) {}
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.NON_BOOL_CONDITION]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.NON_BOOL_CONDITION]);
   }
 
   void test_nonBoolCondition_if() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 f() {
   if (3) return 2; else return 1;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.NON_BOOL_CONDITION]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.NON_BOOL_CONDITION]);
   }
 
   void test_nonBoolCondition_while() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 f() {
   while (3) {}
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.NON_BOOL_CONDITION]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.NON_BOOL_CONDITION]);
   }
 
   void test_nonBoolExpression_functionType() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 int makeAssertion() => 1;
 f() {
   assert(makeAssertion);
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.NON_BOOL_EXPRESSION]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.NON_BOOL_EXPRESSION]);
   }
 
   void test_nonBoolExpression_interfaceType() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 f() {
   assert(0);
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.NON_BOOL_EXPRESSION]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.NON_BOOL_EXPRESSION]);
   }
 
   void test_nonBoolNegationExpression() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 f() {
   !42;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.NON_BOOL_NEGATION_EXPRESSION]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.NON_BOOL_NEGATION_EXPRESSION]);
   }
 
   void test_nonBoolOperand_and_left() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 bool f(int left, bool right) {
   return left && right;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.NON_BOOL_OPERAND]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.NON_BOOL_OPERAND]);
   }
 
   void test_nonBoolOperand_and_right() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 bool f(bool left, String right) {
   return left && right;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.NON_BOOL_OPERAND]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.NON_BOOL_OPERAND]);
   }
 
   void test_nonBoolOperand_or_left() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 bool f(List<int> left, bool right) {
   return left || right;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.NON_BOOL_OPERAND]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.NON_BOOL_OPERAND]);
   }
 
   void test_nonBoolOperand_or_right() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 bool f(bool left, double right) {
   return left || right;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.NON_BOOL_OPERAND]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.NON_BOOL_OPERAND]);
   }
 
   void test_nonTypeAsTypeArgument_notAType() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 int A;
 class B<E> {}
-f(B<A> b) {}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT]);
-    verify([source]);
+f(B<A> b) {}''',
+        [StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT]);
   }
 
   void test_nonTypeAsTypeArgument_undefinedIdentifier() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class B<E> {}
-f(B<A> b) {}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT]);
-    verify([source]);
+f(B<A> b) {}''',
+        [StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT]);
   }
 
   void test_returnOfInvalidType_async_future_int_mismatches_future_null() {
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 import 'dart:async';
 Future<Null> f() async {
   return 5;
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
-    verify([source]);
+''',
+        [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
   }
 
   void test_returnOfInvalidType_async_future_int_mismatches_future_string() {
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 import 'dart:async';
 Future<String> f() async {
   return 5;
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
-    verify([source]);
+''',
+        [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
   }
 
   void test_returnOfInvalidType_async_future_int_mismatches_int() {
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 int f() async {
   return 5;
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [
-      StaticTypeWarningCode.RETURN_OF_INVALID_TYPE,
-      StaticTypeWarningCode.ILLEGAL_ASYNC_RETURN_TYPE
-    ]);
-    verify([source]);
+''',
+        [
+          StaticTypeWarningCode.RETURN_OF_INVALID_TYPE,
+          StaticTypeWarningCode.ILLEGAL_ASYNC_RETURN_TYPE
+        ]);
   }
 
   void test_returnOfInvalidType_expressionFunctionBody_function() {
-    Source source = addSource("int f() => '0';");
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
-    verify([source]);
+    assertErrorsInCode(
+        "int f() => '0';", [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
   }
 
   void test_returnOfInvalidType_expressionFunctionBody_getter() {
-    Source source = addSource("int get g => '0';");
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
-    verify([source]);
+    assertErrorsInCode(
+        "int get g => '0';", [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
   }
 
   void test_returnOfInvalidType_expressionFunctionBody_localFunction() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {
   String m() {
     int f() => '0';
     return '0';
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
   }
 
   void test_returnOfInvalidType_expressionFunctionBody_method() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {
   int f() => '0';
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
   }
 
   void test_returnOfInvalidType_expressionFunctionBody_void() {
-    Source source = addSource("void f() => 42;");
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
-    verify([source]);
+    assertErrorsInCode(
+        "void f() => 42;", [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
   }
 
   void test_returnOfInvalidType_function() {
-    Source source = addSource("int f() { return '0'; }");
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
-    verify([source]);
+    assertErrorsInCode("int f() { return '0'; }",
+        [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
   }
 
   void test_returnOfInvalidType_getter() {
-    Source source = addSource("int get g { return '0'; }");
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
-    verify([source]);
+    assertErrorsInCode("int get g { return '0'; }",
+        [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
   }
 
   void test_returnOfInvalidType_localFunction() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {
   String m() {
     int f() { return '0'; }
     return '0';
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
   }
 
   void test_returnOfInvalidType_method() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {
   int f() { return '0'; }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
   }
 
   // https://github.com/dart-lang/sdk/issues/24713
   void test_returnOfInvalidType_not_issued_for_valid_generic_return() {
-    Source source = addSource(r'''
+    assertNoErrorsInCode(r'''
 abstract class F<T, U>  {
   U get value;
 }
 
 abstract class G<T> {
   T test(F<int, T> arg) => arg.value;
 }
 
 abstract class H<S> {
   S test(F<int, S> arg) => arg.value;
 }
 
 void main() { }''');
-    computeLibrarySourceErrors(source);
-    assertNoErrors(source);
-    verify([source]);
   }
 
   void test_returnOfInvalidType_void() {
-    Source source = addSource("void f() { return 42; }");
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
-    verify([source]);
+    assertErrorsInCode("void f() { return 42; }",
+        [StaticTypeWarningCode.RETURN_OF_INVALID_TYPE]);
   }
 
   void test_typeArgumentNotMatchingBounds_classTypeAlias() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {}
 class B {}
 class C {}
 class G<E extends A> {}
-class D = G<B> with C;''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
-    verify([source]);
+class D = G<B> with C;
+''',
+        [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
   }
 
   void test_typeArgumentNotMatchingBounds_extends() {
-    Source source = addSource(r'''
-class A {}
-class B {}
-class G<E extends A> {}
-class C extends G<B>{}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
-    verify([source]);
+    assertErrorsInCode(
+        r'''
+class A {}
+class B {}
+class G<E extends A> {}
+class C extends G<B>{}
+''',
+        [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
   }
 
   void test_typeArgumentNotMatchingBounds_extends_regressionInIssue18468Fix() {
     // https://code.google.com/p/dart/issues/detail?id=18628
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class X<T extends Type> {}
-class Y<U> extends X<U> {}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
-    verify([source]);
+class Y<U> extends X<U> {}
+''',
+        [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
   }
 
   void test_typeArgumentNotMatchingBounds_fieldFormalParameter() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {}
 class B {}
 class G<E extends A> {}
 class C {
   var f;
   C(G<B> this.f) {}
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
   }
 
   void test_typeArgumentNotMatchingBounds_functionReturnType() {
-    Source source = addSource(r'''
-class A {}
-class B {}
-class G<E extends A> {}
-G<B> f() { return null; }''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
-    verify([source]);
+    assertErrorsInCode(
+        r'''
+class A {}
+class B {}
+class G<E extends A> {}
+G<B> f() { return null; }
+''',
+        [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
   }
 
   void test_typeArgumentNotMatchingBounds_functionTypeAlias() {
-    Source source = addSource(r'''
-class A {}
-class B {}
-class G<E extends A> {}
-typedef G<B> f();''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
-    verify([source]);
+    assertErrorsInCode(
+        r'''
+class A {}
+class B {}
+class G<E extends A> {}
+typedef G<B> f();
+''',
+        [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
   }
 
   void test_typeArgumentNotMatchingBounds_functionTypedFormalParameter() {
-    Source source = addSource(r'''
-class A {}
-class B {}
-class G<E extends A> {}
-f(G<B> h()) {}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
-    verify([source]);
+    assertErrorsInCode(
+        r'''
+class A {}
+class B {}
+class G<E extends A> {}
+f(G<B> h()) {}
+''',
+        [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
   }
 
   void test_typeArgumentNotMatchingBounds_implements() {
-    Source source = addSource(r'''
-class A {}
-class B {}
-class G<E extends A> {}
-class C implements G<B>{}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
-    verify([source]);
+    assertErrorsInCode(
+        r'''
+class A {}
+class B {}
+class G<E extends A> {}
+class C implements G<B>{}
+''',
+        [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
   }
 
   void test_typeArgumentNotMatchingBounds_is() {
-    Source source = addSource(r'''
-class A {}
-class B {}
-class G<E extends A> {}
-var b = 1 is G<B>;''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
-    verify([source]);
+    assertErrorsInCode(
+        r'''
+class A {}
+class B {}
+class G<E extends A> {}
+var b = 1 is G<B>;
+''',
+        [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
   }
 
   void test_typeArgumentNotMatchingBounds_methodReturnType() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {}
 class B {}
 class G<E extends A> {}
 class C {
   G<B> m() { return null; }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
   }
 
   void test_typeArgumentNotMatchingBounds_new() {
-    Source source = addSource(r'''
-class A {}
-class B {}
-class G<E extends A> {}
-f() { return new G<B>(); }''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
-    verify([source]);
+    assertErrorsInCode(
+        r'''
+class A {}
+class B {}
+class G<E extends A> {}
+f() { return new G<B>(); }
+''',
+        [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
   }
 
   void test_typeArgumentNotMatchingBounds_new_superTypeOfUpperBound() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {}
 class B extends A {}
 class C extends B {}
 class G<E extends B> {}
-f() { return new G<A>(); }''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
-    verify([source]);
+f() { return new G<A>(); }
+''',
+        [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
   }
 
   void test_typeArgumentNotMatchingBounds_parameter() {
-    Source source = addSource(r'''
-class A {}
-class B {}
-class G<E extends A> {}
-f(G<B> g) {}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
-    verify([source]);
+    assertErrorsInCode(
+        r'''
+class A {}
+class B {}
+class G<E extends A> {}
+f(G<B> g) {}
+''',
+        [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
   }
 
   void test_typeArgumentNotMatchingBounds_redirectingConstructor() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {}
 class B {}
 class X<T extends A> {
   X(int x, int y) {}
   factory X.name(int x, int y) = X<B>;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [
-      StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS,
-      StaticWarningCode.REDIRECT_TO_INVALID_RETURN_TYPE
-    ]);
-    verify([source]);
+}''',
+        [
+          StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS,
+          StaticWarningCode.REDIRECT_TO_INVALID_RETURN_TYPE
+        ]);
   }
 
   void test_typeArgumentNotMatchingBounds_typeArgumentList() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {}
 class B {}
 class C<E> {}
 class D<E extends A> {}
-C<D<B>> Var;''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
-    verify([source]);
+C<D<B>> Var;
+''',
+        [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
   }
 
   void test_typeArgumentNotMatchingBounds_typeParameter() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {}
 class B {}
 class C {}
 class G<E extends A> {}
-class D<F extends G<B>> {}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
-    verify([source]);
+class D<F extends G<B>> {}
+''',
+        [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
   }
 
   void test_typeArgumentNotMatchingBounds_variableDeclaration() {
-    Source source = addSource(r'''
-class A {}
-class B {}
-class G<E extends A> {}
-G<B> g;''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
-    verify([source]);
+    assertErrorsInCode(
+        r'''
+class A {}
+class B {}
+class G<E extends A> {}
+G<B> g;
+''',
+        [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
   }
 
   void test_typeArgumentNotMatchingBounds_with() {
-    Source source = addSource(r'''
-class A {}
-class B {}
-class G<E extends A> {}
-class C extends Object with G<B>{}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
-    verify([source]);
+    assertErrorsInCode(
+        r'''
+class A {}
+class B {}
+class G<E extends A> {}
+class C extends Object with G<B>{}
+''',
+        [StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
   }
 
   void test_typeParameterSupertypeOfItsBound() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A<T extends T> {
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND]);
-    verify([source]);
+}
+''',
+        [StaticTypeWarningCode.TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND]);
   }
 
   void
       test_typePromotion_booleanAnd_useInRight_accessedInClosureRight_mutated() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 callMe(f()) { f(); }
 main(Object p) {
   (p is String) && callMe(() { p.length; });
   p = 0;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
 
   void test_typePromotion_booleanAnd_useInRight_mutatedInLeft() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 main(Object p) {
   ((p is String) && ((p = 42) == 42)) && p.length != 0;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
 
   void test_typePromotion_booleanAnd_useInRight_mutatedInRight() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 main(Object p) {
   (p is String) && (((p = 42) == 42) && p.length != 0);
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
 
   void
       test_typePromotion_conditional_useInThen_accessedInClosure_hasAssignment_after() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 callMe(f()) { f(); }
 main(Object p) {
   p is String ? callMe(() { p.length; }) : 0;
   p = 42;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
 
   void
       test_typePromotion_conditional_useInThen_accessedInClosure_hasAssignment_before() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 callMe(f()) { f(); }
 main(Object p) {
   p = 42;
   p is String ? callMe(() { p.length; }) : 0;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
 
   void test_typePromotion_conditional_useInThen_hasAssignment() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 main(Object p) {
   p is String ? (p.length + (p = 42)) : 0;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
 
   void test_typePromotion_if_accessedInClosure_hasAssignment() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 callMe(f()) { f(); }
 main(Object p) {
   if (p is String) {
     callMe(() {
       p.length;
     });
   }
   p = 0;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
 
   void test_typePromotion_if_and_right_hasAssignment() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 main(Object p) {
   if (p is String && (p = null) == null) {
     p.length;
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
 
   void test_typePromotion_if_extends_notMoreSpecific_dynamic() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 class V {}
 class A<T> {}
 class B<S> extends A<S> {
   var b;
 }
 
 main(A<V> p) {
   if (p is B) {
     p.b;
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
 
   void test_typePromotion_if_extends_notMoreSpecific_notMoreSpecificTypeArg() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 class V {}
 class A<T> {}
 class B<S> extends A<S> {
   var b;
 }
 
 main(A<V> p) {
   if (p is B<int>) {
     p.b;
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
 
   void test_typePromotion_if_hasAssignment_after() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 main(Object p) {
   if (p is String) {
     p.length;
     p = 0;
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
 
   void test_typePromotion_if_hasAssignment_before() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 main(Object p) {
   if (p is String) {
     p = 0;
     p.length;
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
 
   void test_typePromotion_if_hasAssignment_inClosure_anonymous_after() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 main(Object p) {
   if (p is String) {
     p.length;
   }
   () {p = 0;};
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
 
   void test_typePromotion_if_hasAssignment_inClosure_anonymous_before() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 main(Object p) {
   () {p = 0;};
   if (p is String) {
     p.length;
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
 
   void test_typePromotion_if_hasAssignment_inClosure_function_after() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 main(Object p) {
   if (p is String) {
     p.length;
   }
   f() {p = 0;};
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
 
   void test_typePromotion_if_hasAssignment_inClosure_function_before() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 main(Object p) {
   f() {p = 0;};
   if (p is String) {
     p.length;
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
 
   void test_typePromotion_if_implements_notMoreSpecific_dynamic() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 class V {}
 class A<T> {}
 class B<S> implements A<S> {
   var b;
 }
 
 main(A<V> p) {
   if (p is B) {
     p.b;
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
 
   void test_typePromotion_if_with_notMoreSpecific_dynamic() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 class V {}
 class A<T> {}
 class B<S> extends Object with A<S> {
   var b;
 }
 
 main(A<V> p) {
   if (p is B) {
     p.b;
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
 
   void test_undefinedFunction() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 void f() {
   g();
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_FUNCTION]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_FUNCTION]);
   }
 
   void test_undefinedFunction_inCatch() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 void f() {
   try {
   } on Object {
     g();
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_FUNCTION]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_FUNCTION]);
   }
 
   void test_undefinedFunction_inImportedLib() {
     Source source = addSource(r'''
 import 'lib.dart' as f;
 main() { return f.g(); }''');
     addNamedSource(
         "/lib.dart",
         r'''
 library lib;
 h() {}''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [StaticTypeWarningCode.UNDEFINED_FUNCTION]);
   }
 
   void test_undefinedGetter() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 class T {}
-f(T e) { return e.m; }''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+f(T e) { return e.m; }''',
+        [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
 
   void test_undefinedGetter_generic_function_call() {
     // Objects having a specific function type have a call() method, but
     // objects having type Function do not (this is because it is impossible to
     // know what signature the call should have).
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.enableStrictCallChecks = true;
     resetWithOptions(options);
-    Source source = addSource('''
+    assertErrorsInUnverifiedCode(
+        '''
 f(Function f) {
   return f.call;
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+''',
+        [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
 
   void test_undefinedGetter_object_call() {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.enableStrictCallChecks = true;
     resetWithOptions(options);
-    Source source = addSource('''
+    assertErrorsInUnverifiedCode(
+        '''
 f(Object o) {
   return o.call;
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+''',
+        [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
 
   void test_undefinedGetter_proxy_annotation_fakeProxy() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 library L;
 class Fake {
   const Fake();
 }
 const proxy = const Fake();
 @proxy class PrefixProxy {}
 main() {
   new PrefixProxy().foo;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
 
   void test_undefinedGetter_static() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 class A {}
-var a = A.B;''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+var a = A.B;''',
+        [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
 
   void test_undefinedGetter_typeLiteral_cascadeTarget() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class T {
   static int get foo => 42;
 }
 main() {
   T..foo;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
 
   void test_undefinedGetter_typeLiteral_conditionalAccess() {
     // When applied to a type literal, the conditional access operator '?.'
     // cannot be used to access instance getters of Type.
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 class A {}
 f() => A?.hashCode;
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+''',
+        [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
 
   void test_undefinedGetter_void() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class T {
   void m() {}
 }
-f(T e) { return e.m().f; }''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_GETTER]);
+f(T e) { return e.m().f; }''',
+        [StaticTypeWarningCode.UNDEFINED_GETTER]);
   }
 
   void test_undefinedGetter_wrongNumberOfTypeArguments_tooLittle() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A<K, V> {
   K element;
 }
 main(A<int> a) {
   a.element.anyGetterExistsInDynamic;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
   }
 
   void test_undefinedGetter_wrongNumberOfTypeArguments_tooMany() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A<E> {
   E element;
 }
 main(A<int,int> a) {
   a.element.anyGetterExistsInDynamic;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
   }
 
   void test_undefinedGetter_wrongOfTypeArgument() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A<E> {
   E element;
 }
 main(A<NoSuchType> a) {
   a.element.anyGetterExistsInDynamic;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT]);
   }
 
   void test_undefinedMethod() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {
   void m() {
     n();
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_METHOD]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_METHOD]);
   }
 
   void test_undefinedMethod_assignmentExpression() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {}
 class B {
   f(A a) {
     A a2 = new A();
     a += a2;
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_METHOD]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_METHOD]);
   }
 
   void test_undefinedMethod_generic_function_call() {
     // Objects having a specific function type have a call() method, but
     // objects having type Function do not (this is because it is impossible to
     // know what signature the call should have).
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.enableStrictCallChecks = true;
     resetWithOptions(options);
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 f(Function f) {
   f.call();
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_METHOD]);
+''',
+        [StaticTypeWarningCode.UNDEFINED_METHOD]);
   }
 
   void test_undefinedMethod_ignoreTypePropagation() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {}
 class B extends A {
   m() {}
 }
 class C {
   f() {
     A a = new B();
     a.m();
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_METHOD]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_METHOD]);
   }
 
   void test_undefinedMethod_leastUpperBoundWithNull() {
-    Source source = addSource('f(bool b, int i) => (b ? null : i).foo();');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_METHOD]);
+    assertErrorsInCode('f(bool b, int i) => (b ? null : i).foo();',
+        [StaticTypeWarningCode.UNDEFINED_METHOD]);
   }
 
   void test_undefinedMethod_object_call() {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.enableStrictCallChecks = true;
     resetWithOptions(options);
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 f(Object o) {
   o.call();
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_METHOD]);
+''',
+        [StaticTypeWarningCode.UNDEFINED_METHOD]);
   }
 
   void test_undefinedMethod_private() {
     addNamedSource(
         "/lib.dart",
         r'''
 library lib;
 class A {
   _foo() {}
 }''');
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 import 'lib.dart';
 class B extends A {
   test() {
     _foo();
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_METHOD]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_METHOD]);
   }
 
   void test_undefinedMethod_proxy_annotation_fakeProxy() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 library L;
 class Fake {
   const Fake();
 }
 const proxy = const Fake();
 @proxy class PrefixProxy {}
 main() {
   new PrefixProxy().foo();
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_METHOD]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_METHOD]);
   }
 
   void test_undefinedMethod_typeLiteral_cascadeTarget() {
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 class T {
   static void foo() {}
 }
 main() {
   T..foo();
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_METHOD]);
+''',
+        [StaticTypeWarningCode.UNDEFINED_METHOD]);
   }
 
   void test_undefinedMethod_typeLiteral_conditionalAccess() {
     // When applied to a type literal, the conditional access operator '?.'
     // cannot be used to access instance methods of Type.
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 class A {}
 f() => A?.toString();
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_METHOD]);
+''',
+        [StaticTypeWarningCode.UNDEFINED_METHOD]);
   }
 
   void test_undefinedMethodWithConstructor() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class C {
   C.m();
 }
 f() {
   C c = C.m();
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.UNDEFINED_METHOD_WITH_CONSTRUCTOR]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_METHOD_WITH_CONSTRUCTOR]);
   }
 
   void test_undefinedOperator_indexBoth() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 class A {}
 f(A a) {
   a[0]++;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   void test_undefinedOperator_indexGetter() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 class A {}
 f(A a) {
   a[0];
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   void test_undefinedOperator_indexSetter() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 class A {}
 f(A a) {
   a[0] = 1;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   void test_undefinedOperator_plus() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 class A {}
 f(A a) {
   a + 1;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   void test_undefinedOperator_postfixExpression() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {}
 f(A a) {
   a++;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   void test_undefinedOperator_prefixExpression() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {}
 f(A a) {
   ++a;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_OPERATOR]);
   }
 
   void test_undefinedSetter() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 class T {}
-f(T e1) { e1.m = 0; }''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_SETTER]);
+f(T e1) { e1.m = 0; }''',
+        [StaticTypeWarningCode.UNDEFINED_SETTER]);
   }
 
   void test_undefinedSetter_static() {
-    Source source = addSource(r'''
-class A {}
-f() { A.B = 0;}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_SETTER]);
+    assertErrorsInUnverifiedCode(
+        r'''
+class A {}
+f() { A.B = 0;}''',
+        [StaticTypeWarningCode.UNDEFINED_SETTER]);
   }
 
   void test_undefinedSetter_typeLiteral_cascadeTarget() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class T {
   static void set foo(_) {}
 }
 main() {
   T..foo = 42;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_SETTER]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_SETTER]);
   }
 
   void test_undefinedSetter_void() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class T {
   void m() {}
 }
-f(T e) { e.m().f = 0; }''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_SETTER]);
+f(T e) { e.m().f = 0; }''',
+        [StaticTypeWarningCode.UNDEFINED_SETTER]);
   }
 
   void test_undefinedSuperGetter() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {}
 class B extends A {
   get g {
     return super.g;
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_SUPER_GETTER]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_SUPER_GETTER]);
   }
 
   void test_undefinedSuperMethod() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {}
 class B extends A {
   m() { return super.m(); }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_SUPER_METHOD]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_SUPER_METHOD]);
   }
 
   void test_undefinedSuperOperator_binaryExpression() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 class A {}
 class B extends A {
   operator +(value) {
     return super + value;
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_SUPER_OPERATOR]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_SUPER_OPERATOR]);
   }
 
   void test_undefinedSuperOperator_indexBoth() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 class A {}
 class B extends A {
   operator [](index) {
     return super[index]++;
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_SUPER_OPERATOR]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_SUPER_OPERATOR]);
   }
 
   void test_undefinedSuperOperator_indexGetter() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 class A {}
 class B extends A {
   operator [](index) {
     return super[index + 1];
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_SUPER_OPERATOR]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_SUPER_OPERATOR]);
   }
 
   void test_undefinedSuperOperator_indexSetter() {
-    Source source = addSource(r'''
+    assertErrorsInUnverifiedCode(
+        r'''
 class A {}
 class B extends A {
   operator []=(index, value) {
     return super[index] = 0;
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_SUPER_OPERATOR]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_SUPER_OPERATOR]);
   }
 
   void test_undefinedSuperSetter() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {}
 class B extends A {
   f() {
     super.m = 0;
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.UNDEFINED_SUPER_SETTER]);
+}''',
+        [StaticTypeWarningCode.UNDEFINED_SUPER_SETTER]);
   }
 
   void test_unqualifiedReferenceToNonLocalStaticMember_getter() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {
   static int get a => 0;
 }
 class B extends A {
   int b() {
     return a;
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [
-      StaticTypeWarningCode.UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER
-    ]);
-    verify([source]);
+}''',
+        [
+          StaticTypeWarningCode.UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER
+        ]);
   }
 
   void test_unqualifiedReferenceToNonLocalStaticMember_method() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {
   static void a() {}
 }
 class B extends A {
   void b() {
     a();
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [
-      StaticTypeWarningCode.UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER
-    ]);
-    verify([source]);
+}''',
+        [
+          StaticTypeWarningCode.UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER
+        ]);
   }
 
   void test_unqualifiedReferenceToNonLocalStaticMember_setter() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {
   static set a(x) {}
 }
 class B extends A {
   b(y) {
     a = y;
   }
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [
-      StaticTypeWarningCode.UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER
-    ]);
-    verify([source]);
+}''',
+        [
+          StaticTypeWarningCode.UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER
+        ]);
   }
 
   void test_wrongNumberOfTypeArguments_classAlias() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {}
 class M {}
-class B<F extends num> = A<F> with M;''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
-    verify([source]);
+class B<F extends num> = A<F> with M;''',
+        [StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
   }
 
   void test_wrongNumberOfTypeArguments_tooFew() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A<E, F> {}
-A<A> a = null;''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
-    verify([source]);
+A<A> a = null;''',
+        [StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
   }
 
   void test_wrongNumberOfTypeArguments_tooMany() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A<E> {}
-A<A, A> a = null;''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
-    verify([source]);
+A<A, A> a = null;''',
+        [StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
   }
 
   void test_wrongNumberOfTypeArguments_typeTest_tooFew() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {}
 class C<K, V> {}
 f(p) {
   return p is C<A>;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
   }
 
   void test_wrongNumberOfTypeArguments_typeTest_tooMany() {
-    Source source = addSource(r'''
+    assertErrorsInCode(
+        r'''
 class A {}
 class C<E> {}
 f(p) {
   return p is C<A, A>;
-}''');
-    computeLibrarySourceErrors(source);
-    assertErrors(
-        source, [StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
-    verify([source]);
+}''',
+        [StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS]);
   }
 
   void test_forIn_notIterable() {
-    assertErrorsInCode('''
+    assertErrorsInCode(
+        '''
 f() {
   for (var i in true) {}
 }
-''', [StaticTypeWarningCode.FOR_IN_OF_INVALID_TYPE]);
+''',
+        [StaticTypeWarningCode.FOR_IN_OF_INVALID_TYPE]);
   }
 
   void test_forIn_declaredVariableWrongType() {
-    assertErrorsInCode('''
+    assertErrorsInCode(
+        '''
 f() {
   for (int i in <String>[]) {}
 }
-''', [StaticTypeWarningCode.FOR_IN_OF_INVALID_ELEMENT_TYPE]);
+''',
+        [StaticTypeWarningCode.FOR_IN_OF_INVALID_ELEMENT_TYPE]);
   }
 
   void test_forIn_existingVariableWrongType() {
-    assertErrorsInCode('''
+    assertErrorsInCode(
+        '''
 f() {
   int i;
   for (i in <String>[]) {}
 }
-''', [StaticTypeWarningCode.FOR_IN_OF_INVALID_ELEMENT_TYPE]);
+''',
+        [StaticTypeWarningCode.FOR_IN_OF_INVALID_ELEMENT_TYPE]);
   }
 
   void test_forIn_declaredVariableRightType() {
     assertNoErrorsInCode('''
 f() {
   for (int i in <int>[]) {}
 }
 ''');
   }
 
@@ skipping 41 matching lines @@
 
   void test_forIn_downcast() {
     assertNoErrorsInCode('''
 f() {
   for (int i in <num>[]) {}
 }
 ''');
   }
 
   void test_forIn_typeBoundBad() {
-    assertErrorsInCode('''
+    assertErrorsInCode(
+        '''
 class Foo<T extends Iterable<int>> {
   void method(T iterable) {
     for (String i in iterable) {}
   }
 }
-''', [StaticTypeWarningCode.FOR_IN_OF_INVALID_ELEMENT_TYPE]);
+''',
+        [StaticTypeWarningCode.FOR_IN_OF_INVALID_ELEMENT_TYPE]);
   }
 
   void test_forIn_typeBoundGood() {
     assertNoErrorsInCode('''
 class Foo<T extends Iterable<int>> {
   void method(T iterable) {
     for (var i in iterable) {}
   }
 }
 ''');
   }
 
   void test_awaitForIn_notStream() {
-    assertErrorsInCode('''
+    assertErrorsInCode(
+        '''
 f() async {
   await for (var i in true) {}
 }
-''', [StaticTypeWarningCode.FOR_IN_OF_INVALID_TYPE]);
+''',
+        [StaticTypeWarningCode.FOR_IN_OF_INVALID_TYPE]);
   }
 
   void test_awaitForIn_declaredVariableWrongType() {
-    assertErrorsInCode('''
+    assertErrorsInCode(
+        '''
 import 'dart:async';
 f() async {
   Stream<String> stream;
   await for (int i in stream) {}
 }
-''', [StaticTypeWarningCode.FOR_IN_OF_INVALID_ELEMENT_TYPE]);
+''',
+        [StaticTypeWarningCode.FOR_IN_OF_INVALID_ELEMENT_TYPE]);
   }
 
   void test_awaitForIn_existingVariableWrongType() {
-    assertErrorsInCode('''
+    assertErrorsInCode(
+        '''
 import 'dart:async';
 f() async {
   Stream<String> stream;
   int i;
   await for (i in stream) {}
 }
-''', [StaticTypeWarningCode.FOR_IN_OF_INVALID_ELEMENT_TYPE]);
+''',
+        [StaticTypeWarningCode.FOR_IN_OF_INVALID_ELEMENT_TYPE]);
   }
 
   void test_awaitForIn_declaredVariableRightType() {
     assertNoErrorsInCode('''
 import 'dart:async';
 f() async {
   Stream<int> stream;
   await for (int i in stream) {}
 }
 ''');
@@ skipping 53 matching lines @@
     assertNoErrorsInCode('''
 import 'dart:async';
 f() async {
   Stream<num> stream;
   await for (int i in stream) {}
 }
 ''');
   }
 
   void test_yield_async_to_basic_type() {
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 int f() async* {
   yield 3;
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [
-      StaticTypeWarningCode.YIELD_OF_INVALID_TYPE,
-      StaticTypeWarningCode.ILLEGAL_ASYNC_GENERATOR_RETURN_TYPE
-    ]);
-    verify([source]);
+''',
+        [
+          StaticTypeWarningCode.YIELD_OF_INVALID_TYPE,
+          StaticTypeWarningCode.ILLEGAL_ASYNC_GENERATOR_RETURN_TYPE
+        ]);
   }
 
   void test_yield_async_to_iterable() {
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 Iterable<int> f() async* {
   yield 3;
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [
-      StaticTypeWarningCode.YIELD_OF_INVALID_TYPE,
-      StaticTypeWarningCode.ILLEGAL_ASYNC_GENERATOR_RETURN_TYPE
-    ]);
-    verify([source]);
+''',
+        [
+          StaticTypeWarningCode.YIELD_OF_INVALID_TYPE,
+          StaticTypeWarningCode.ILLEGAL_ASYNC_GENERATOR_RETURN_TYPE
+        ]);
   }
 
   void test_yield_async_to_mistyped_stream() {
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 import 'dart:async';
 Stream<int> f() async* {
   yield "foo";
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.YIELD_OF_INVALID_TYPE]);
-    verify([source]);
+''',
+        [StaticTypeWarningCode.YIELD_OF_INVALID_TYPE]);
   }
 
   void test_yield_each_async_non_stream() {
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 f() async* {
   yield* 0;
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.YIELD_OF_INVALID_TYPE]);
-    verify([source]);
+''',
+        [StaticTypeWarningCode.YIELD_OF_INVALID_TYPE]);
   }
 
   void test_yield_each_async_to_mistyped_stream() {
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 import 'dart:async';
 Stream<int> f() async* {
   yield* g();
 }
 Stream<String> g() => null;
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.YIELD_OF_INVALID_TYPE]);
-    verify([source]);
+''',
+        [StaticTypeWarningCode.YIELD_OF_INVALID_TYPE]);
   }
 
   void test_yield_each_sync_non_iterable() {
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 f() sync* {
   yield* 0;
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.YIELD_OF_INVALID_TYPE]);
-    verify([source]);
+''',
+        [StaticTypeWarningCode.YIELD_OF_INVALID_TYPE]);
   }
 
   void test_yield_each_sync_to_mistyped_iterable() {
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 Iterable<int> f() sync* {
   yield* g();
 }
 Iterable<String> g() => null;
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.YIELD_OF_INVALID_TYPE]);
-    verify([source]);
+''',
+        [StaticTypeWarningCode.YIELD_OF_INVALID_TYPE]);
   }
 
   void test_yield_sync_to_basic_type() {
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 int f() sync* {
   yield 3;
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [
-      StaticTypeWarningCode.YIELD_OF_INVALID_TYPE,
-      StaticTypeWarningCode.ILLEGAL_SYNC_GENERATOR_RETURN_TYPE
-    ]);
-    verify([source]);
+''',
+        [
+          StaticTypeWarningCode.YIELD_OF_INVALID_TYPE,
+          StaticTypeWarningCode.ILLEGAL_SYNC_GENERATOR_RETURN_TYPE
+        ]);
   }
 
   void test_yield_sync_to_mistyped_iterable() {
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 Iterable<int> f() sync* {
   yield "foo";
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [StaticTypeWarningCode.YIELD_OF_INVALID_TYPE]);
-    verify([source]);
+''',
+        [StaticTypeWarningCode.YIELD_OF_INVALID_TYPE]);
   }
 
   void test_yield_sync_to_stream() {
-    Source source = addSource('''
+    assertErrorsInCode(
+        '''
 import 'dart:async';
 Stream<int> f() sync* {
   yield 3;
 }
-''');
-    computeLibrarySourceErrors(source);
-    assertErrors(source, [
-      StaticTypeWarningCode.YIELD_OF_INVALID_TYPE,
-      StaticTypeWarningCode.ILLEGAL_SYNC_GENERATOR_RETURN_TYPE
-    ]);
-    verify([source]);
+''',
+        [
+          StaticTypeWarningCode.YIELD_OF_INVALID_TYPE,
+          StaticTypeWarningCode.ILLEGAL_SYNC_GENERATOR_RETURN_TYPE
+        ]);
   }
 }
 
 @reflectiveTest
 class StrongModeStaticTypeWarningCodeTest extends ResolverTestCase {
   void setUp() {
     super.setUp();
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.strongMode = true;
     resetWithOptions(options);
@@ skipping 12 matching lines @@
     for (AnalysisError error in analysisContext2.computeErrors(source)) {
       if (error.errorCode ==
           StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS) {
         expect(error.message,
             formatList(error.errorCode.message, ['() → dynamic', 0, 1]));
       }
     }
     verify([source]);
   }
 }