Update the analysis server integration tests to always run on the analysis driver.

pkg/analysis_server/test/integration/analysis/error_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.
 
 import 'dart:async';
 
 import 'package:analysis_server/plugin/protocol/protocol.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import '../integration_tests.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(AnalysisErrorIntegrationTest);
     defineReflectiveTests(NoAnalysisErrorsIntegrationTest);
-    defineReflectiveTests(NoAnalysisErrorsIntegrationTest_Driver);
   });
 }
 
-class AbstractAnalysisErrorIntegrationTest
+@reflectiveTest
+class AnalysisErrorIntegrationTest
     extends AbstractAnalysisServerIntegrationTest {
   test_detect_simple_error() {
     String pathname = sourcePath('test.dart');
     writeFile(
         pathname,
         '''
 main() {
   print(null) // parse error: missing ';'
 }''');
     standardAnalysisSetup();
@@ skipping 32 matching lines @@
     expect(
         allErrorMessages,
         contains(
             "The class 'C' can't be used as a mixin because it extends a class other than Object."));
     expect(
         allErrorMessages,
         contains(
             "The class 'C' can't be used as a mixin because it references 'super'."));
   }
 
+  // We see errors here with the new driver (#28870).

[Brian Wilkerson, 2017/02/23 17:58:18]

Move comments like this inside the method (or at least after the annotation,
otherwise sort will eventually cause the comment to move away from the method
and we'll loose this information.

+  @failingTest
   test_super_mixins_enabled() async {
     String pathname = sourcePath('test.dart');
     writeFile(
         pathname,
         '''
 class Test extends Object with C {
   void foo() {}
 }
 abstract class B {
   void foo() {}
 }
 abstract class C extends B {
   void bar() {
     super.foo();
   }
 }
 ''');
     await sendAnalysisUpdateOptions(
         new AnalysisOptions()..enableSuperMixins = true);
     standardAnalysisSetup();
     await analysisFinished;
     expect(currentAnalysisErrors[pathname], isList);
     List<AnalysisError> errors = currentAnalysisErrors[pathname];
     expect(errors, isEmpty);
   }
 }
 
 @reflectiveTest
-class AnalysisErrorIntegrationTest
-    extends AbstractAnalysisErrorIntegrationTest {}
-
-@reflectiveTest
 class NoAnalysisErrorsIntegrationTest
     extends AbstractAnalysisServerIntegrationTest {
   @override
   Future startServer(
           {bool checked: true, int diagnosticPort, int servicesPort}) =>
       server.start(
           checked: checked,
           diagnosticPort: diagnosticPort,
-          enableNewAnalysisDriver: enableNewAnalysisDriver,
           noErrorNotification: true,
           servicesPort: servicesPort);
 
+  // Errors are reported with noErrorNotification: true (#28869).
+  @failingTest
   test_detect_simple_error() {
     String pathname = sourcePath('test.dart');
     writeFile(
         pathname,
         '''
 main() {
   print(null) // parse error: missing ';'
 }''');
     standardAnalysisSetup();
     return analysisFinished.then((_) {
       expect(currentAnalysisErrors[pathname], isNull);
     });
   }
 }
-
-@reflectiveTest
-class NoAnalysisErrorsIntegrationTest_Driver
-    extends NoAnalysisErrorsIntegrationTest {
-  @override
-  bool get enableNewAnalysisDriver => true;
-
-  @failingTest
-  @override
-  test_detect_simple_error() {
-    return super.test_detect_simple_error();
-  }
-}