Extract BaseAnalysisDriverTest.

pkg/analyzer/test/src/dart/analysis/driver_test.dart

 // Copyright (c) 2016, 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.driver;
 
 import 'dart:async';
 import 'dart:convert';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
-import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/src/dart/analysis/byte_store.dart';
 import 'package:analyzer/src/dart/analysis/driver.dart';
 import 'package:analyzer/src/dart/analysis/file_state.dart';
 import 'package:analyzer/src/dart/analysis/status.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/engine.dart' show AnalysisOptionsImpl;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:convert/convert.dart';
 import 'package:crypto/crypto.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import '../../context/mock_sdk.dart';
+import 'base.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(AnalysisDriverTest);
     defineReflectiveTests(AnalysisDriverSchedulerTest);
   });
 }
 
 /**
  * Returns a [Future] that completes after pumping the event queue [times]
@@ skipping 170 matching lines @@
     expect(allStatuses[0].isAnalyzing, isTrue);
     expect(allStatuses[1].isAnalyzing, isFalse);
 
     expect(allResults, hasLength(3));
   }
 
   String _p(String path) => provider.convertPath(path);
 }
 
 @reflectiveTest
-class AnalysisDriverTest {
-  static final MockSdk sdk = new MockSdk();
-
-  final MemoryResourceProvider provider = new MemoryResourceProvider();
-  final ByteStore byteStore = new MemoryByteStore();
-  final FileContentOverlay contentOverlay = new FileContentOverlay();
-
-  final StringBuffer logBuffer = new StringBuffer();
-  PerformanceLog logger;
-
-  AnalysisDriverScheduler scheduler;
-  AnalysisDriver driver;
-  final _Monitor idleStatusMonitor = new _Monitor();
-  final List<AnalysisStatus> allStatuses = <AnalysisStatus>[];
-  final List<AnalysisResult> allResults = <AnalysisResult>[];
-
-  String testProject;
-  String testFile;
-
-  void setUp() {
-    new MockSdk();
-    testProject = _p('/test/lib');
-    testFile = _p('/test/lib/test.dart');
-    logger = new PerformanceLog(logBuffer);
-    scheduler = new AnalysisDriverScheduler(logger);
-    driver = new AnalysisDriver(
-        scheduler,
-        logger,
-        provider,
-        byteStore,
-        contentOverlay,
-        new SourceFactory([
-          new DartUriResolver(sdk),
-          new PackageMapUriResolver(provider, <String, List<Folder>>{
-            'test': [provider.getFolder(testProject)]
-          }),
-          new ResourceUriResolver(provider)
-        ], null, provider),
-        new AnalysisOptionsImpl()..strongMode = true);
-    scheduler.start();
-    driver.status.lastWhere((status) {
-      allStatuses.add(status);
-      if (status.isIdle) {
-        idleStatusMonitor.notify();
-      }
-    });
-    driver.results.listen(allResults.add);
-  }
-
+class AnalysisDriverTest extends BaseAnalysisDriverTest {
   test_addedFiles() async {
     var a = _p('/test/lib/a.dart');
     var b = _p('/test/lib/b.dart');
 
     driver.addFile(a);
     expect(driver.addedFiles, contains(a));
     expect(driver.addedFiles, isNot(contains(b)));
 
     driver.removeFile(a);
     expect(driver.addedFiles, isNot(contains(a)));
@@ skipping 109 matching lines @@
       expect(_getTopLevelVarType(ar.unit, 'A1'), 'double');
       expect(_getTopLevelVarType(ar.unit, 'A2'), 'double');
     }
     {
       AnalysisResult br = allResults.firstWhere((r) => r.path == b);
       expect(_getTopLevelVarType(br.unit, 'B1'), 'double');
     }
   }
 
   test_changeFile_single() async {
-    _addTestFile('var V = 1;', priority: true);
+    addTestFile('var V = 1;', priority: true);
 
     // Initial analysis.
     {
       await _waitForIdle();
       expect(allResults, hasLength(1));
       AnalysisResult result = allResults[0];
       expect(result.path, testFile);
       expect(_getTopLevelVarType(result.unit, 'V'), 'int');
     }
 
@@ skipping 13 matching lines @@
       await _waitForIdle();
       expect(allResults, hasLength(1));
       AnalysisResult result = allResults[0];
       expect(result.path, testFile);
       expect(_getTopLevelVarType(result.unit, 'V'), 'double');
     }
   }
 
   test_getResult() async {
     String content = 'int f() => 42;';
-    _addTestFile(content, priority: true);
+    addTestFile(content, priority: true);
 
     AnalysisResult result = await driver.getResult(testFile);
     expect(result.path, testFile);
     expect(result.uri.toString(), 'package:test/test.dart');
     expect(result.content, content);
     expect(result.contentHash, _md5(content));
     expect(result.unit, isNotNull);
     expect(result.errors, hasLength(0));
 
     var f = result.unit.declarations[0] as FunctionDeclaration;
@@ skipping 21 matching lines @@
     driver.addFile(a);
     driver.addFile(b);
     await _waitForIdle();
 
     AnalysisResult result = await driver.getResult(b);
     expect(result.errors, isEmpty);
   }
 
   test_getResult_errors() async {
     String content = 'main() { int vv; }';
-    _addTestFile(content, priority: true);
+    addTestFile(content, priority: true);
 
     AnalysisResult result = await driver.getResult(testFile);
     expect(result.path, testFile);
     expect(result.errors, hasLength(1));
     {
       AnalysisError error = result.errors[0];
       expect(error.offset, 13);
       expect(error.length, 2);
       expect(error.errorCode, HintCode.UNUSED_LOCAL_VARIABLE);
       expect(error.message, "The value of the local variable 'vv' isn't used.");
       expect(error.correction, "Try removing the variable, or using it.");
     }
   }
 
   test_getResult_inferTypes_finalField() async {
-    _addTestFile(
+    addTestFile(
         r'''
 class C {
   final f = 42;
 }
 ''',
         priority: true);
     await _waitForIdle();
 
     AnalysisResult result = await driver.getResult(testFile);
     expect(_getClassFieldType(result.unit, 'C', 'f'), 'int');
   }
 
   test_getResult_inferTypes_instanceMethod() async {
-    _addTestFile(
+    addTestFile(
         r'''
 class A {
   int m(double p) => 1;
 }
 class B extends A {
   m(double p) => 2;
 }
 ''',
         priority: true);
     await _waitForIdle();
 
     AnalysisResult result = await driver.getResult(testFile);
     expect(_getClassMethodReturnType(result.unit, 'A', 'm'), 'int');
     expect(_getClassMethodReturnType(result.unit, 'B', 'm'), 'int');
   }
 
   test_getResult_invalidUri_exports_dart() async {
     String content = r'''
 export 'dart:async';
 export 'dart:noSuchLib';
 export 'dart:math';
 ''';
-    _addTestFile(content, priority: true);
+    addTestFile(content, priority: true);
 
     AnalysisResult result = await driver.getResult(testFile);
     expect(result.path, testFile);
     // Has only exports for valid URIs.
     List<ExportElement> imports = result.unit.element.library.exports;
     expect(
         imports.map((import) => import.exportedLibrary.source.uri.toString()),
         unorderedEquals(['dart:async', 'dart:math']));
   }
 
   test_getResult_invalidUri_imports_dart() async {
     String content = r'''
 import 'dart:async';
 import 'dart:noSuchLib';
 import 'dart:math';
 ''';
-    _addTestFile(content, priority: true);
+    addTestFile(content, priority: true);
 
     AnalysisResult result = await driver.getResult(testFile);
     expect(result.path, testFile);
     // Has only imports for valid URIs.
     List<ImportElement> imports = result.unit.element.library.imports;
     expect(
         imports.map((import) => import.importedLibrary.source.uri.toString()),
         unorderedEquals(['dart:async', 'dart:math', 'dart:core']));
   }
 
@@ skipping 138 matching lines @@
 var A2 = B1;
 ''');
     {
       AnalysisResult result = await driver.getResult(a);
       expect(_getTopLevelVarType(result.unit, 'A1'), 'double');
       expect(_getTopLevelVarType(result.unit, 'A2'), 'double');
     }
   }
 
   test_getResult_thenRemove() async {
-    _addTestFile('main() {}', priority: true);
+    addTestFile('main() {}', priority: true);
 
     Future<AnalysisResult> resultFuture = driver.getResult(testFile);
     driver.removeFile(testFile);
 
     AnalysisResult result = await resultFuture;
     expect(result, isNotNull);
     expect(result.path, testFile);
     expect(result.unit, isNotNull);
   }
 
   test_getResult_twoPendingFutures() async {
     String content = 'main() {}';
-    _addTestFile(content, priority: true);
+    addTestFile(content, priority: true);
 
     Future<AnalysisResult> future1 = driver.getResult(testFile);
     Future<AnalysisResult> future2 = driver.getResult(testFile);
 
     // Both futures complete, with the same result.
     AnalysisResult result1 = await future1;
     AnalysisResult result2 = await future2;
     expect(result2, same(result1));
     expect(result1.path, testFile);
     expect(result1.unit, isNotNull);
@@ skipping 311 matching lines @@
     // But the change causes "a" to be reanalyzed.
     await _waitForIdle();
     expect(allResults, hasLength(1));
     {
       AnalysisResult ar = allResults.firstWhere((r) => r.path == a);
       expect(_getTopLevelVarType(ar.unit, 'A'), 'double');
     }
   }
 
   test_removeFile_changeFile_notAnalyzed() async {
-    _addTestFile('main() {}');
+    addTestFile('main() {}');
 
     // We have a result.
     await _waitForIdle();
     expect(allResults, hasLength(1));
     expect(allResults[0].path, testFile);
     allResults.clear();
 
     // Remove the file and send the change notification.
     // The change notification does nothing, because the file is explicitly
     // or implicitly analyzed.
     driver.removeFile(testFile);
     driver.changeFile(testFile);
 
     await _waitForIdle();
     expect(allResults, isEmpty);
   }
 
   test_results_priority() async {
     String content = 'int f() => 42;';
-    _addTestFile(content, priority: true);
+    addTestFile(content, priority: true);
 
     await _waitForIdle();
 
     expect(allResults, hasLength(1));
     AnalysisResult result = allResults.single;
     expect(result.path, testFile);
     expect(result.uri.toString(), 'package:test/test.dart');
     expect(result.content, content);
     expect(result.contentHash, _md5(content));
     expect(result.unit, isNotNull);
@@ skipping 20 matching lines @@
 
     expect(allResults, hasLength(3));
     AnalysisResult result = allResults[0];
     expect(result.path, b);
     expect(result.unit, isNotNull);
     expect(result.errors, hasLength(0));
   }
 
   test_results_regular() async {
     String content = 'int f() => 42;';
-    _addTestFile(content);
+    addTestFile(content);
     await _waitForIdle();
 
     expect(allResults, hasLength(1));
     AnalysisResult result = allResults.single;
     expect(result.path, testFile);
     expect(result.uri.toString(), 'package:test/test.dart');
     expect(result.content, isNull);
     expect(result.contentHash, _md5(content));
     expect(result.unit, isNull);
     expect(result.errors, hasLength(0));
   }
 
   test_results_status() async {
-    _addTestFile('int f() => 42;');
+    addTestFile('int f() => 42;');
     await _waitForIdle();
 
     expect(allStatuses, hasLength(2));
     expect(allStatuses[0].isAnalyzing, isTrue);
     expect(allStatuses[0].isIdle, isFalse);
     expect(allStatuses[1].isAnalyzing, isFalse);
     expect(allStatuses[1].isIdle, isTrue);
   }
 
-  void _addTestFile(String content, {bool priority: false}) {
-    provider.newFile(testFile, content);
-    driver.addFile(testFile);
-    if (priority) {
-      driver.priorityFiles = [testFile];
-    }
-  }
-
   ClassDeclaration _getClass(CompilationUnit unit, String name) {
     for (CompilationUnitMember declaration in unit.declarations) {
       if (declaration is ClassDeclaration) {
         if (declaration.name.name == name) {
           return declaration;
         }
       }
     }
     fail('Cannot find the class $name in\n$unit');
     return null;
@@ skipping 76 matching lines @@
   String _p(String path) => provider.convertPath(path);
 
   Future<Null> _waitForIdle() async {
     await idleStatusMonitor.signal;
   }
 
   static String _md5(String content) {
     return hex.encode(md5.convert(UTF8.encode(content)).bytes);
   }
 }
-
-class _Monitor {
-  Completer<Null> _completer = new Completer<Null>();
-
-  Future<Null> get signal async {
-    await _completer.future;
-    _completer = new Completer<Null>();
-  }
-
-  void notify() {
-    if (!_completer.isCompleted) {
-      _completer.complete(null);
-    }
-  }
-}