Remove the unused operations queue

pkg/analysis_server/test/analysis_server_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/protocol/protocol.dart';
 import 'package:analysis_server/protocol/protocol_generated.dart';
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/constants.dart';
 import 'package:analysis_server/src/domain_server.dart';
-import 'package:analysis_server/src/operation/operation.dart';
 import 'package:analysis_server/src/plugin/server_plugin.dart';
-import 'package:analyzer/exception/exception.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/sdk.dart';
-import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer_plugin/protocol/protocol_common.dart';
 import 'package:plugin/manager.dart';
 import 'package:plugin/plugin.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
-import 'package:typed_mock/typed_mock.dart';
 
 import 'mock_sdk.dart';
 import 'mocks.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(AnalysisServerTest);
   });
 }
 
@@ skipping 71 matching lines @@
     new MockSdk(resourceProvider: resourceProvider);
     packageMapProvider = new MockPackageMapProvider();
     server = new AnalysisServer(
         channel,
         resourceProvider,
         packageMapProvider,
         null,
         serverPlugin,
         new AnalysisServerOptions(),
         new DartSdkManager('/', false),
-        InstrumentationService.NULL_SERVICE,
-        rethrowExceptions: true);
+        InstrumentationService.NULL_SERVICE);
   }
 
   Future test_echo() {
     server.handlers = [new EchoHandler()];
     var request = new Request('my22', 'echo');
     return channel.sendRequest(request).then((Response response) {
       expect(response.id, equals('my22'));
       expect(response.error, isNull);
     });
   }
 
-  void test_rethrowExceptions() {
-    Exception exceptionToThrow = new Exception('test exception');
-    MockServerOperation operation =
-        new MockServerOperation(ServerOperationPriority.ANALYSIS, (_) {
-      throw exceptionToThrow;
-    });
-    server.operationQueue.add(operation);
-    server.performOperationPending = true;
-    try {
-      server.performOperation();
-      fail('exception not rethrown');
-    } on AnalysisException catch (exception) {
-      expect(exception.cause.exception, equals(exceptionToThrow));
-    }
-  }
-
   Future test_serverStatusNotifications() {
-    MockAnalysisContext context = new MockAnalysisContext('context');
-    MockSource source = new MockSource('source');
-    when(source.fullName).thenReturn('foo.dart');
-    when(source.isInSystemLibrary).thenReturn(false);
-    ChangeNoticeImpl notice = new ChangeNoticeImpl(source);
-    notice.setErrors([], new LineInfo([0]));
-    AnalysisResult firstResult = new AnalysisResult([notice], 0, '', 0);
-    AnalysisResult lastResult = new AnalysisResult(null, 1, '', 1);
-    when(context.analysisOptions).thenReturn(new AnalysisOptionsImpl());
-    when(context.performAnalysisTask)
-        .thenReturnList([firstResult, firstResult, firstResult, lastResult]);
     server.serverServices.add(ServerService.STATUS);
-    server.schedulePerformAnalysisOperation(context);
+    resourceProvider.newFolder('/pkg');
+    resourceProvider.newFolder('/pkg/lib');
+    resourceProvider.newFile('/pkg/lib/test.dart', 'class C {}');
+    server.setAnalysisRoots('0', ['/pkg'], [], {});
     // Pump the event queue to make sure the server has finished any
     // analysis.
     return pumpEventQueue().then((_) {
       List<Notification> notifications = channel.notificationsReceived;
       expect(notifications, isNotEmpty);
       // expect at least one notification indicating analysis is in progress
       expect(notifications.any((Notification notification) {
         if (notification.event == SERVER_STATUS) {
           var params = new ServerStatusParams.fromNotification(notification);
-          return params.analysis.isAnalyzing;
+          if (params.analysis != null) {
+            return params.analysis.isAnalyzing;
+          }
         }
         return false;
       }), isTrue);
       // the last notification should indicate that analysis is complete
       Notification notification = notifications[notifications.length - 1];
       var params = new ServerStatusParams.fromNotification(notification);
       expect(params.analysis.isAnalyzing, isFalse);
     });
   }
 
@@ skipping 60 matching lines @@
 
 class EchoHandler implements RequestHandler {
   @override
   Response handleRequest(Request request) {
     if (request.method == 'echo') {
       return new Response(request.id, result: {'echo': true});
     }
     return null;
   }
 }