Get some tests running using the analysis driver

pkg/analysis_server/test/analysis/notification_analysis_options_test.dart

 // Copyright (c) 2015, 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 test.analysis.notification_analysis_options_test;
 
-import 'package:analysis_server/plugin/protocol/protocol.dart';
+import 'package:analysis_server/plugin/protocol/protocol.dart'
+    hide AnalysisOptions;
 import 'package:analysis_server/src/constants.dart';
 import 'package:analysis_server/src/domain_analysis.dart';
 import 'package:analyzer/src/generated/engine.dart';
-import 'package:analyzer/src/services/lint.dart';
 import 'package:linter/src/rules.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import '../analysis_abstract.dart';
 import '../mocks.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(NewAnalysisOptionsFileNotificationTest);
     defineReflectiveTests(OldAnalysisOptionsFileNotificationTest);
+    // These tests all fail, presumably because we are not updating the analysis
+    // options when the file changes and because we are not analyzing the
+    // analysis options file.
+//    defineReflectiveTests(NewAnalysisOptionsFileNotificationTest_Driver);
+//    defineReflectiveTests(OldAnalysisOptionsFileNotificationTest_Driver);
   });
 }
 
 abstract class AnalysisOptionsFileNotificationTest
     extends AbstractAnalysisTest {
   Map<String, List<AnalysisError>> filesErrors = {};
 
   final testSource = '''
 main() {
   var x = '';
   int y = x; // Not assignable in strong-mode
   print(y);
 }''';
 
   List<AnalysisError> get errors => filesErrors[testFile];
 
   List<AnalysisError> get optionsFileErrors => filesErrors[optionsFilePath];
 
   String get optionsFilePath;
 
-  AnalysisContext get testContext => server.getContainingContext(testFile);
-
   List<AnalysisError> get testFileErrors => filesErrors[testFile];
 
   void addOptionsFile(String contents) {
     addFile(optionsFilePath, contents);
   }
 
   void deleteFile(String filePath) {
     resourceProvider.deleteFile(filePath);
   }
 
@@ skipping 43 matching lines @@
 main() {
   String unused = "";
 }
 ''');
 
     setAnalysisRoot();
 
     await waitForTasksFinished();
 
     // Verify options file.
+    expect(optionsFileErrors, isNotNull);
     expect(optionsFileErrors, isEmpty);
 
     // Verify test file.
+    expect(testFileErrors, isNotNull);
     expect(testFileErrors, isEmpty);
   }
 
   test_error_filter_removed() async {
     addOptionsFile('''
 analyzer:
   errors:
     unused_local_variable: ignore
 ''');
 
     addTestFile('''
 main() {
   String unused = "";
 }
 ''');
 
     setAnalysisRoot();
 
     await waitForTasksFinished();
 
     // Verify options file.
+    expect(optionsFileErrors, isNotNull);
     expect(optionsFileErrors, isEmpty);
 
     // Verify test file.
+    expect(testFileErrors, isNotNull);
     expect(testFileErrors, isEmpty);
 
     addOptionsFile('''
 analyzer:
   errors:
   #  unused_local_variable: ignore
 ''');
 
     await pumpEventQueue();
     await waitForTasksFinished();
@@ skipping 137 matching lines @@
 
     setStrongMode(true);
 
     await pumpEventQueue();
     await waitForTasksFinished();
 
     verifyStrongMode(enabled: true);
   }
 
   void verifyLintsEnabled(List<String> lints) {
-    expect(testContext.analysisOptions.lint, true);
-    var rules = getLints(testContext).map((rule) => rule.name);
+    AnalysisOptions options = analysisOptions;
+    expect(options.lint, true);
+    var rules = options.lintRules.map((rule) => rule.name);
     expect(rules, unorderedEquals(lints));
   }
 
   verifyStrongMode({bool enabled}) {
     // Verify strong-mode enabled.
-    expect(testContext.analysisOptions.strongMode, enabled);
+    expect(analysisOptions.strongMode, enabled);
 
     if (enabled) {
       // Should produce a type warning.
       expect(errors.map((error) => error.type),
           unorderedEquals([AnalysisErrorType.STATIC_TYPE_WARNING]));
     } else {
       // Should only produce a hint.
       expect(errors.map((error) => error.type),
           unorderedEquals([AnalysisErrorType.HINT]));
     }
   }
 }
 
 @reflectiveTest
 class NewAnalysisOptionsFileNotificationTest
     extends AnalysisOptionsFileNotificationTest {
+  @override
   String get optionsFilePath => '$projectPath/analysis_options.yaml';
 }
 
 @reflectiveTest
+class NewAnalysisOptionsFileNotificationTest_Driver
+    extends NewAnalysisOptionsFileNotificationTest {
+  @override
+  void setUp() {
+    enableNewAnalysisDriver = true;
+    generateSummaryFiles = true;
+    super.setUp();
+  }
+}
+
+@reflectiveTest
 class OldAnalysisOptionsFileNotificationTest
     extends AnalysisOptionsFileNotificationTest {
+  @override
   String get optionsFilePath => '$projectPath/.analysis_options';
 }
+
+@reflectiveTest
+class OldAnalysisOptionsFileNotificationTest_Driver
+    extends OldAnalysisOptionsFileNotificationTest {
+  @override
+  void setUp() {
+    enableNewAnalysisDriver = true;
+    generateSummaryFiles = true;
+    super.setUp();
+  }
+}