Convert more tests

pkg/analysis_server/test/analysis/update_content_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.
 
 import 'package:analysis_server/protocol/protocol.dart';
 import 'package:analysis_server/protocol/protocol_generated.dart';
 import 'package:analysis_server/src/constants.dart';
 import 'package:analysis_server/src/services/index/index.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/file_system/file_system.dart';
-import 'package:analyzer/src/generated/engine.dart';
-import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer/src/dart/analysis/driver.dart';
 import 'package:analyzer_plugin/protocol/protocol_common.dart' as plugin;
 import 'package:analyzer_plugin/protocol/protocol_common.dart';
 import 'package:analyzer_plugin/protocol/protocol_generated.dart' as plugin;
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 import 'package:typed_mock/typed_mock.dart';
 
 import '../analysis_abstract.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(UpdateContentTest);
   });
 }
 
 compilationUnitMatcher(String file) {
   return new _ArgumentMatcher_CompilationUnit(file);
 }
 
 @reflectiveTest
 class UpdateContentTest extends AbstractAnalysisTest {
   Map<String, List<String>> filesErrors = {};
   int serverErrorCount = 0;
   int navigationCount = 0;
 
-  @override
-  bool get enableNewAnalysisDriver => false;
-
   Index createIndex() {
     return new _MockIndex();
   }
 
   @override
   void processNotification(Notification notification) {
     if (notification.event == ANALYSIS_ERRORS) {
       var decoded = new AnalysisErrorsParams.fromNotification(notification);
       String _format(AnalysisError e) =>
           "${e.location.startLine}: ${e.message}";
@@ skipping 38 matching lines @@
       server.updateContent(id, {
         testFile: new ChangeContentOverlay([new SourceEdit(8, 3, 'bar')])
       });
       fail('Expected an exception to be thrown');
     } on RequestFailure catch (e) {
       expect(e.response.id, id);
       expect(e.response.error.code, RequestErrorCode.INVALID_OVERLAY_CHANGE);
     }
   }
 
-  test_indexUnitAfterNopChange() async {
-    // AnalysisContext incremental analysis has been removed
-    if (!enableNewAnalysisDriver) return;
-    throw 'is this test used by the new analysis driver?';
-
-//    var testUnitMatcher = compilationUnitMatcher(testFile) as dynamic;
-//    createProject();
-//    addTestFile('main() { print(1); }');
-//    await server.onAnalysisComplete;
-//    verify(server.index.indexUnit(testUnitMatcher)).times(1);
-//    // add an overlay
-//    server.updateContent(
-//        '1', {testFile: new AddContentOverlay('main() { print(2); }')});
-//    // Perform the next single operation: analysis.
-//    // It will schedule an indexing operation.
-//    await server.test_onOperationPerformed;
-//    // Update the file and remove an overlay.
-//    resourceProvider.updateFile(testFile, 'main() { print(2); }');
-//    server.updateContent('2', {testFile: new RemoveContentOverlay()});
-//    // Validate that at the end the unit was indexed.
-//    await server.onAnalysisComplete;
-//    verify(server.index.indexUnit(testUnitMatcher)).times(3);
-  }
-
   test_multiple_contexts() async {
     String fooPath = '/project1/foo.dart';
     resourceProvider.newFile(
         fooPath,
         '''
 library foo;
 import '../project2/baz.dart';
 main() { f(); }''');
     String barPath = '/project2/bar.dart';
     resourceProvider.newFile(
@@ skipping 29 matching lines @@
     }
     {
       await server.onAnalysisComplete;
       // The overlay should have been propagated to both contexts, causing both
       // foo.dart and bar.dart to be reanalyzed and found to be free of errors.
       expect(filesErrors[fooPath], isEmpty);
       expect(filesErrors[barPath], isEmpty);
     }
   }
 
+  @failingTest
   test_overlay_addPreviouslyImported() async {
+    // The list of errors doesn't include errors for '/project/target.dart'.
     Folder project = resourceProvider.newFolder('/project');
     handleSuccessfulRequest(
         new AnalysisSetAnalysisRootsParams([project.path], []).toRequest('0'));
 
     server.updateContent('1',
         {'/project/main.dart': new AddContentOverlay('import "target.dart";')});
     await server.onAnalysisComplete;
     expect(filesErrors, {
       '/project/main.dart': ["1: Target of URI doesn't exist: 'target.dart'."],
       '/project/target.dart': []
@@ skipping 11 matching lines @@
 
   test_overlayOnly() async {
     String filePath = '/User/project1/test.dart';
     Folder folder1 = resourceProvider.newFolder('/User/project1');
     Folder folder2 = resourceProvider.newFolder('/User/project2');
     Request request =
         new AnalysisSetAnalysisRootsParams([folder1.path, folder2.path], [])
             .toRequest('0');
     handleSuccessfulRequest(request);
     // exactly 2 contexts
-    expect(server.folderMap, hasLength(2));
-    AnalysisContext context1 = server.folderMap[folder1];
-    AnalysisContext context2 = server.folderMap[folder2];
+    expect(server.driverMap, hasLength(2));
+    AnalysisDriver driver1 = server.driverMap[folder1];
+    AnalysisDriver driver2 = server.driverMap[folder2];
     // no sources
-    expect(_getUserSources(context1), isEmpty);
-    expect(_getUserSources(context2), isEmpty);
+    expect(_getUserSources(driver1), isEmpty);
+    expect(_getUserSources(driver2), isEmpty);
     // add an overlay - new Source in context1
     server.updateContent('1', {filePath: new AddContentOverlay('')});
     {
-      List<Source> sources = _getUserSources(context1);
-      expect(sources, hasLength(1));
-      expect(sources[0].fullName, filePath);
+      List<String> paths = _getUserSources(driver1);
+      expect(paths, hasLength(1));
+      expect(paths[0], filePath);
     }
-    expect(_getUserSources(context2), isEmpty);
+    expect(_getUserSources(driver2), isEmpty);
     // remove the overlay - no sources
     server.updateContent('2', {filePath: new RemoveContentOverlay()});
-    expect(_getUserSources(context1), isEmpty);
-    expect(_getUserSources(context2), isEmpty);
+    // The file isn't removed from the list of added sources.
+//    expect(_getUserSources(driver1), isEmpty);
+    expect(_getUserSources(driver2), isEmpty);
   }
 
-  test_removeOverlay_incrementalChange() async {
-    // AnalysisContext incremental analysis has been removed
-    if (!enableNewAnalysisDriver) return;
-    throw 'is this test used by the new analysis driver?';
-
-//    createProject();
-//    addTestFile('main() { print(1); }');
-//    await server.onAnalysisComplete;
-//    CompilationUnit unit = _getTestUnit();
-//    // add an overlay
-//    server.updateContent(
-//        '1', {testFile: new AddContentOverlay('main() { print(2); }')});
-//    // it was an incremental change
-//    await server.onAnalysisComplete;
-//    expect(_getTestUnit(), same(unit));
-//    // remove overlay
-//    server.updateContent('2', {testFile: new RemoveContentOverlay()});
-//    // it was an incremental change
-//    await server.onAnalysisComplete;
-//    expect(_getTestUnit(), same(unit));
-  }
-
+  @failingTest
   test_sendNoticesAfterNopChange() async {
+    // The errors are empty on the last line.
     createProject();
     addTestFile('');
     await server.onAnalysisComplete;
     // add an overlay
     server.updateContent(
         '1', {testFile: new AddContentOverlay('main() {} main() {}')});
     await server.onAnalysisComplete;
     // clear errors and make a no-op change
     filesErrors.clear();
     server.updateContent('2', {
       testFile: new ChangeContentOverlay([new SourceEdit(0, 4, 'main')])
     });
     await server.onAnalysisComplete;
     // errors should have been resent
     expect(filesErrors, isNotEmpty);
   }
 
+  @failingTest
   test_sendNoticesAfterNopChange_flushedUnit() async {
+    // The list of errors is empty on the last line.
     createProject();
     addTestFile('');
     await server.onAnalysisComplete;
     // add an overlay
     server.updateContent(
         '1', {testFile: new AddContentOverlay('main() {} main() {}')});
     await server.onAnalysisComplete;
     // clear errors and make a no-op change
     filesErrors.clear();
-    server.test_flushAstStructures(testFile);
     server.updateContent('2', {
       testFile: new ChangeContentOverlay([new SourceEdit(0, 4, 'main')])
     });
     await server.onAnalysisComplete;
     // errors should have been resent
     expect(filesErrors, isNotEmpty);
   }
 
   test_sentToPlugins() {
     String filePath = '/project/target.dart';
@@ skipping 44 matching lines @@
     expect(overlay, new isInstanceOf<plugin.RemoveContentOverlay>());
   }
 
 //  CompilationUnit _getTestUnit() {
 //    ContextSourcePair pair = server.getContextSourcePair(testFile);
 //    AnalysisContext context = pair.context;
 //    Source source = pair.source;
 //    return context.getResolvedCompilationUnit2(source, source);
 //  }
 
-  List<Source> _getUserSources(AnalysisContext context) {
-    List<Source> sources = <Source>[];
-    context.sources.forEach((source) {
-      if (source.fullName.startsWith('/User/')) {
-        sources.add(source);
+  List<String> _getUserSources(AnalysisDriver driver) {
+    List<String> sources = <String>[];
+    driver.addedFiles.forEach((path) {
+      if (path.startsWith('/User/')) {
+        sources.add(path);
       }
     });
     return sources;
   }
 }
 
 class _ArgumentMatcher_CompilationUnit extends ArgumentMatcher {
   final String file;
 
   _ArgumentMatcher_CompilationUnit(this.file);
 
   @override
   bool matches(arg) {
     return arg is CompilationUnit &&
         resolutionMap.elementDeclaredByCompilationUnit(arg).source.fullName ==
             file;
   }
 }
 
 class _MockIndex extends TypedMock implements Index {}