| // Copyright 2014 The Flutter Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // @dart = 2.8 |
| |
| import 'package:coverage/coverage.dart' as coverage; |
| import 'package:meta/meta.dart'; |
| import 'package:vm_service/vm_service.dart' as vm_service; |
| |
| import '../base/file_system.dart'; |
| import '../base/io.dart'; |
| import '../base/process.dart'; |
| import '../globals_null_migrated.dart' as globals; |
| import '../vmservice.dart'; |
| |
| import 'test_device.dart'; |
| import 'watcher.dart'; |
| |
| /// A class that's used to collect coverage data during tests. |
| class CoverageCollector extends TestWatcher { |
| CoverageCollector({this.libraryPredicate, this.verbose = true, @required this.packagesPath}); |
| |
| final bool verbose; |
| final String packagesPath; |
| Map<String, Map<int, int>> _globalHitmap; |
| bool Function(String) libraryPredicate; |
| |
| @override |
| Future<void> handleFinishedTest(TestDevice testDevice) async { |
| _logMessage('Starting coverage collection'); |
| await collectCoverage(testDevice); |
| } |
| |
| void _logMessage(String line, { bool error = false }) { |
| if (!verbose) { |
| return; |
| } |
| if (error) { |
| globals.printError(line); |
| } else { |
| globals.printTrace(line); |
| } |
| } |
| |
| void _addHitmap(Map<String, Map<int, int>> hitmap) { |
| if (_globalHitmap == null) { |
| _globalHitmap = hitmap; |
| } else { |
| coverage.mergeHitmaps(hitmap, _globalHitmap); |
| } |
| } |
| |
| /// Collects coverage for an isolate using the given `port`. |
| /// |
| /// This should be called when the code whose coverage data is being collected |
| /// has been run to completion so that all coverage data has been recorded. |
| /// |
| /// The returned [Future] completes when the coverage is collected. |
| Future<void> collectCoverageIsolate(Uri observatoryUri) async { |
| assert(observatoryUri != null); |
| _logMessage('collecting coverage data from $observatoryUri...'); |
| final Map<String, dynamic> data = await collect(observatoryUri, libraryPredicate); |
| if (data == null) { |
| throw Exception('Failed to collect coverage.'); |
| } |
| assert(data != null); |
| |
| _logMessage('($observatoryUri): collected coverage data; merging...'); |
| _addHitmap(await coverage.createHitmap( |
| data['coverage'] as List<Map<String, dynamic>>, |
| packagesPath: packagesPath, |
| checkIgnoredLines: true, |
| )); |
| _logMessage('($observatoryUri): done merging coverage data into global coverage map.'); |
| } |
| |
| /// Collects coverage for the given [Process] using the given `port`. |
| /// |
| /// This should be called when the code whose coverage data is being collected |
| /// has been run to completion so that all coverage data has been recorded. |
| /// |
| /// The returned [Future] completes when the coverage is collected. |
| Future<void> collectCoverage(TestDevice testDevice) async { |
| assert(testDevice != null); |
| |
| Map<String, dynamic> data; |
| |
| final Future<void> processComplete = testDevice.finished.catchError( |
| (Object error) => throw Exception( |
| 'Failed to collect coverage, test device terminated prematurely with ' |
| 'error: ${(error as TestDeviceException).message}.'), |
| test: (Object error) => error is TestDeviceException, |
| ); |
| |
| final Future<void> collectionComplete = testDevice.observatoryUri |
| .then((Uri observatoryUri) { |
| _logMessage('collecting coverage data from $testDevice at $observatoryUri...'); |
| return collect(observatoryUri, libraryPredicate) |
| .then<void>((Map<String, dynamic> result) { |
| if (result == null) { |
| throw Exception('Failed to collect coverage.'); |
| } |
| _logMessage('Collected coverage data.'); |
| data = result; |
| }); |
| }); |
| |
| await Future.any<void>(<Future<void>>[ processComplete, collectionComplete ]); |
| assert(data != null); |
| |
| _logMessage('Merging coverage data...'); |
| _addHitmap(await coverage.createHitmap( |
| data['coverage'] as List<Map<String, dynamic>>, |
| packagesPath: packagesPath, |
| checkIgnoredLines: true, |
| )); |
| _logMessage('Done merging coverage data into global coverage map.'); |
| } |
| |
| /// Returns a future that will complete with the formatted coverage data |
| /// (using [formatter]) once all coverage data has been collected. |
| /// |
| /// This will not start any collection tasks. It us up to the caller of to |
| /// call [collectCoverage] for each process first. |
| Future<String> finalizeCoverage({ |
| coverage.Formatter formatter, |
| Directory coverageDirectory, |
| }) async { |
| if (_globalHitmap == null) { |
| return null; |
| } |
| if (formatter == null) { |
| final coverage.Resolver resolver = coverage.Resolver(packagesPath: packagesPath); |
| final String packagePath = globals.fs.currentDirectory.path; |
| final List<String> reportOn = coverageDirectory == null |
| ? <String>[globals.fs.path.join(packagePath, 'lib')] |
| : <String>[coverageDirectory.path]; |
| formatter = coverage.LcovFormatter(resolver, reportOn: reportOn, basePath: packagePath); |
| } |
| final String result = await formatter.format(_globalHitmap); |
| _globalHitmap = null; |
| return result; |
| } |
| |
| Future<bool> collectCoverageData(String coveragePath, { bool mergeCoverageData = false, Directory coverageDirectory }) async { |
| final String coverageData = await finalizeCoverage( |
| coverageDirectory: coverageDirectory, |
| ); |
| _logMessage('coverage information collection complete'); |
| if (coverageData == null) { |
| return false; |
| } |
| |
| final File coverageFile = globals.fs.file(coveragePath) |
| ..createSync(recursive: true) |
| ..writeAsStringSync(coverageData, flush: true); |
| _logMessage('wrote coverage data to $coveragePath (size=${coverageData.length})'); |
| |
| const String baseCoverageData = 'coverage/lcov.base.info'; |
| if (mergeCoverageData) { |
| if (!globals.fs.isFileSync(baseCoverageData)) { |
| _logMessage('Missing "$baseCoverageData". Unable to merge coverage data.', error: true); |
| return false; |
| } |
| |
| if (globals.os.which('lcov') == null) { |
| String installMessage = 'Please install lcov.'; |
| if (globals.platform.isLinux) { |
| installMessage = 'Consider running "sudo apt-get install lcov".'; |
| } else if (globals.platform.isMacOS) { |
| installMessage = 'Consider running "brew install lcov".'; |
| } |
| _logMessage('Missing "lcov" tool. Unable to merge coverage data.\n$installMessage', error: true); |
| return false; |
| } |
| |
| final Directory tempDir = globals.fs.systemTempDirectory.createTempSync('flutter_tools_test_coverage.'); |
| try { |
| final File sourceFile = coverageFile.copySync(globals.fs.path.join(tempDir.path, 'lcov.source.info')); |
| final RunResult result = globals.processUtils.runSync(<String>[ |
| 'lcov', |
| '--add-tracefile', baseCoverageData, |
| '--add-tracefile', sourceFile.path, |
| '--output-file', coverageFile.path, |
| ]); |
| if (result.exitCode != 0) { |
| return false; |
| } |
| } finally { |
| tempDir.deleteSync(recursive: true); |
| } |
| } |
| return true; |
| } |
| |
| @override |
| Future<void> handleTestCrashed(TestDevice testDevice) async { } |
| |
| @override |
| Future<void> handleTestTimedOut(TestDevice testDevice) async { } |
| } |
| |
| Future<FlutterVmService> _defaultConnect(Uri serviceUri) { |
| return connectToVmService( |
| serviceUri, compression: CompressionOptions.compressionOff, logger: globals.logger,); |
| } |
| |
| Future<Map<String, dynamic>> collect(Uri serviceUri, bool Function(String) libraryPredicate, { |
| bool waitPaused = false, |
| String debugName, |
| Future<FlutterVmService> Function(Uri) connector = _defaultConnect, |
| @visibleForTesting bool forceSequential = false, |
| }) async { |
| final FlutterVmService vmService = await connector(serviceUri); |
| final Map<String, dynamic> result = await _getAllCoverage(vmService.service, libraryPredicate, forceSequential); |
| await vmService.dispose(); |
| return result; |
| } |
| |
| Future<Map<String, dynamic>> _getAllCoverage( |
| vm_service.VmService service, |
| bool Function(String) libraryPredicate, |
| bool forceSequential, |
| ) async { |
| final vm_service.Version version = await service.getVersion(); |
| final bool reportLines = (version.major == 3 && version.minor >= 51) || version.major > 3; |
| final vm_service.VM vm = await service.getVM(); |
| final List<Map<String, dynamic>> coverage = <Map<String, dynamic>>[]; |
| for (final vm_service.IsolateRef isolateRef in vm.isolates) { |
| if (isolateRef.isSystemIsolate) { |
| continue; |
| } |
| vm_service.ScriptList scriptList; |
| try { |
| scriptList = await service.getScripts(isolateRef.id); |
| } on vm_service.SentinelException { |
| continue; |
| } |
| |
| final List<Future<void>> futures = <Future<void>>[]; |
| final Map<String, vm_service.Script> scripts = <String, vm_service.Script>{}; |
| final Map<String, vm_service.SourceReport> sourceReports = <String, vm_service.SourceReport>{}; |
| // For each ScriptRef loaded into the VM, load the corresponding Script and |
| // SourceReport object. |
| |
| for (final vm_service.ScriptRef script in scriptList.scripts) { |
| final String libraryUri = script.uri; |
| if (!libraryPredicate(libraryUri)) { |
| continue; |
| } |
| final String scriptId = script.id; |
| final Future<void> getSourceReport = service.getSourceReport( |
| isolateRef.id, |
| <String>['Coverage'], |
| scriptId: scriptId, |
| forceCompile: true, |
| reportLines: reportLines ? true : null, |
| ) |
| .then((vm_service.SourceReport report) { |
| sourceReports[scriptId] = report; |
| }); |
| if (forceSequential) { |
| await null; |
| } |
| futures.add(getSourceReport); |
| if (reportLines) { |
| continue; |
| } |
| final Future<void> getObject = service |
| .getObject(isolateRef.id, scriptId) |
| .then((vm_service.Obj response) { |
| final vm_service.Script script = response as vm_service.Script; |
| scripts[scriptId] = script; |
| }); |
| futures.add(getObject); |
| } |
| await Future.wait(futures); |
| _buildCoverageMap(scripts, sourceReports, coverage, reportLines); |
| } |
| return <String, dynamic>{'type': 'CodeCoverage', 'coverage': coverage}; |
| } |
| |
| // Build a hitmap of Uri -> Line -> Hit Count for each script object. |
| void _buildCoverageMap( |
| Map<String, vm_service.Script> scripts, |
| Map<String, vm_service.SourceReport> sourceReports, |
| List<Map<String, dynamic>> coverage, |
| bool reportLines, |
| ) { |
| final Map<String, Map<int, int>> hitMaps = <String, Map<int, int>>{}; |
| for (final String scriptId in sourceReports.keys) { |
| final vm_service.SourceReport sourceReport = sourceReports[scriptId]; |
| for (final vm_service.SourceReportRange range in sourceReport.ranges) { |
| final vm_service.SourceReportCoverage coverage = range.coverage; |
| // Coverage reports may sometimes be null for a Script. |
| if (coverage == null) { |
| continue; |
| } |
| final vm_service.ScriptRef scriptRef = sourceReport.scripts[range.scriptIndex]; |
| final String uri = scriptRef.uri; |
| |
| hitMaps[uri] ??= <int, int>{}; |
| final Map<int, int> hitMap = hitMaps[uri]; |
| final List<int> hits = coverage.hits; |
| final List<int> misses = coverage.misses; |
| final List<dynamic> tokenPositions = scripts[scriptRef.id]?.tokenPosTable; |
| // The token positions can be null if the script has no lines that may be |
| // covered. It will also be null if reportLines is true. |
| if (tokenPositions == null && !reportLines) { |
| continue; |
| } |
| if (hits != null) { |
| for (final int hit in hits) { |
| final int line = |
| reportLines ? hit : _lineAndColumn(hit, tokenPositions)[0]; |
| final int current = hitMap[line] ?? 0; |
| hitMap[line] = current + 1; |
| } |
| } |
| if (misses != null) { |
| for (final int miss in misses) { |
| final int line = |
| reportLines ? miss : _lineAndColumn(miss, tokenPositions)[0]; |
| hitMap[line] ??= 0; |
| } |
| } |
| } |
| } |
| hitMaps.forEach((String uri, Map<int, int> hitMap) { |
| coverage.add(_toScriptCoverageJson(uri, hitMap)); |
| }); |
| } |
| |
| // Binary search the token position table for the line and column which |
| // corresponds to each token position. |
| // The format of this table is described in https://github.com/dart-lang/sdk/blob/main/runtime/vm/service/service.md#script |
| List<int> _lineAndColumn(int position, List<dynamic> tokenPositions) { |
| int min = 0; |
| int max = tokenPositions.length; |
| while (min < max) { |
| final int mid = min + ((max - min) >> 1); |
| final List<int> row = (tokenPositions[mid] as List<dynamic>).cast<int>(); |
| if (row[1] > position) { |
| max = mid; |
| } else { |
| for (int i = 1; i < row.length; i += 2) { |
| if (row[i] == position) { |
| return <int>[row.first, row[i + 1]]; |
| } |
| } |
| min = mid + 1; |
| } |
| } |
| throw StateError('Unreachable'); |
| } |
| |
| // Returns a JSON hit map backward-compatible with pre-1.16.0 SDKs. |
| Map<String, dynamic> _toScriptCoverageJson(String scriptUri, Map<int, int> hitMap) { |
| final Map<String, dynamic> json = <String, dynamic>{}; |
| final List<int> hits = <int>[]; |
| hitMap.forEach((int line, int hitCount) { |
| hits.add(line); |
| hits.add(hitCount); |
| }); |
| json['source'] = scriptUri; |
| json['script'] = <String, dynamic>{ |
| 'type': '@Script', |
| 'fixedId': true, |
| 'id': 'libraries/1/scripts/${Uri.encodeComponent(scriptUri)}', |
| 'uri': scriptUri, |
| '_kind': 'library', |
| }; |
| json['hits'] = hits; |
| return json; |
| } |