Dart Test Coverage

int add(int a, int b) => a + b;
int subtract(int a, int b) => a - b;
int multiply(int a, int b) => a * b;
int divide(int a, int b) {
  if (b == 0) throw ArgumentError('Cannot divide by zero');
  return a ~/ b;
}

name: dummy_pkg
publish_to: none

environment:
  sdk: ^3.9.0
resolution: workspace

dev_dependencies:
  test: ^1.24.0

import 'package:dummy_pkg/src/calculator.dart';
import 'package:test/test.dart';

void main() {
  test('add', () {
    expect(add(1, 2), 3);
  });
  test('subtract', () {
    expect(subtract(2, 1), 1);
  });
}

#!/usr/bin/env dart

import 'dart:convert';
import 'dart:io';

void main(List<String> args) {
  if (args.isEmpty) {
    print(
      'Usage: dart interpret_coverage.dart <coverage_directory> [package_name]',
    );
    exitCode = 64; // Bad usage
    return;
  }
  final dirPath = args[0];
  final packageName = args.length > 1 ? args[1] : null;

  final dir = Directory(dirPath);
  if (!dir.existsSync()) {
    print('Directory not found: $dirPath');
    exitCode = 78; // Configuration error
    return;
  }

  final files = dir
      .listSync(recursive: true)
      .whereType<File>()
      .where((f) => f.path.endsWith('.vm.json'));

  final coverageData = processCoverage(files, packageName);

  if (coverageData.isEmpty) {
    print('No coverage data found for the specified criteria.');
    return;
  }

  // Print summary
  coverageData.forEach((source, lineHits) {
    final totalLines = lineHits.length;
    final coveredLines = lineHits.values.where((hits) => hits > 0).length;
    final percent = totalLines > 0
        ? (coveredLines / totalLines * 100).toStringAsFixed(1)
        : '100';

    print('$source: $percent% ($coveredLines/$totalLines lines)');

    // Show missed lines
    final missed =
        lineHits.entries.where((e) => e.value == 0).map((e) => e.key).toList()
          ..sort();

    if (missed.isNotEmpty) {
      print('  Missed lines: ${missed.join(', ')}');
    }
  });
}

/// Processes a list of coverage files and returns a map of file paths to line hit counts.
///
/// The returned map structure is: `{ file_uri: { line_number: hit_count } }`.
///
/// If [packageName] is provided, only files starting with `package:$packageName/` are included.
/// Files containing `/test/` are skipped.
Map<String, Map<int, int>> processCoverage(
  Iterable<File> files,
  String? packageName,
) {
  final coverageData = <String, Map<int, int>>{}; // file -> (line -> hits)
  for (final file in files) {
    final content = file.readAsStringSync();
    final json = jsonDecode(content) as Map<String, dynamic>;
    final coverage = json['coverage'] as List<dynamic>;

    for (final item in coverage) {
      final source = item['source'] as String;

      // Filter by package name if provided
      if (packageName != null && !source.startsWith('package:$packageName/')) {
        continue;
      }

      // Skip test files usually
      if (source.contains('/test/')) continue;

      final hits = item['hits'] as List<dynamic>;
      final fileData = coverageData.putIfAbsent(source, () => <int, int>{});

      for (var i = 0; i < hits.length; i += 2) {
        final line = hits[i] as int;
        final count = hits[i + 1] as int;
        fileData[line] = (fileData[line] ?? 0) + count;
      }
    }
  }
  return coverageData;
}

name: interpret_coverage
environment:
  sdk: '^3.9.0'
resolution: workspace

dev_dependencies:
  test: ^1.24.0

import 'dart:convert';
import 'dart:io';
import 'package:test/test.dart';
import '../interpret_coverage.dart';

void main() {
  /// Helper to create a mock coverage file.
  /// Takes a list of items where 'hits' is a Map<int, int> (line -> hits).
  File createMockCoverageFile(
    Directory dir,
    String filename,
    List<Map<String, dynamic>> coverageItems,
  ) {
    final file = File('${dir.path}/$filename');

    final processedItems = coverageItems.map((item) {
      final source = item['source'] as String;
      final hitsMap = item['hits'] as Map<int, int>;
      final flatHits = <int>[];
      hitsMap.forEach((line, count) {
        flatHits.add(line);
        flatHits.add(count);
      });
      return {'source': source, 'hits': flatHits};
    }).toList();

    final json = {'coverage': processedItems};
    file.writeAsStringSync(jsonEncode(json));
    return file;
  }

  test('processCoverage extracts data correctly', () {
    final tempDir = Directory.systemTemp.createTempSync('coverage_test');
    final coverageFile = createMockCoverageFile(tempDir, 'test.vm.json', [
      {
        'source': 'package:foo/bar.dart',
        'hits': {1: 1, 2: 0},
      },
    ]);

    try {
      final result = processCoverage([coverageFile], null);
      expect(result, contains('package:foo/bar.dart'));
      expect(result['package:foo/bar.dart'], {1: 1, 2: 0});
    } finally {
      tempDir.deleteSync(recursive: true);
    }
  });

  test('processCoverage filters by package name', () {
    final tempDir = Directory.systemTemp.createTempSync('coverage_test');
    final coverageFile = createMockCoverageFile(tempDir, 'test.vm.json', [
      {
        'source': 'package:foo/bar.dart',
        'hits': {1: 1},
      },
      {
        'source': 'package:baz/qux.dart',
        'hits': {1: 1},
      },
    ]);

    try {
      final result = processCoverage([coverageFile], 'foo');
      expect(result, contains('package:foo/bar.dart'));
      expect(result, isNot(contains('package:baz/qux.dart')));
    } finally {
      tempDir.deleteSync(recursive: true);
    }
  });

  test('processCoverage skips test files', () {
    final tempDir = Directory.systemTemp.createTempSync('coverage_test');
    final coverageFile = createMockCoverageFile(tempDir, 'test.vm.json', [
      {
        'source': 'package:foo/test/bar_test.dart',
        'hits': {1: 1},
      },
      {
        'source': 'package:foo/bar.dart',
        'hits': {1: 1},
      },
    ]);

    try {
      final result = processCoverage([coverageFile], 'foo');
      expect(result, contains('package:foo/bar.dart'));
      expect(result, isNot(contains('package:foo/test/bar_test.dart')));
    } finally {
      tempDir.deleteSync(recursive: true);
    }
  });
}