pkg/front_end/test/coverage_merger_suite.dart

// Copyright (c) 2025, 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 'dart:io';

import 'package:testing/testing.dart'
    show
        Chain,
        ChainContext,
        Result,
        Step,
        TestDescription,
        ExpectationSet,
        Expectation;

import '../tool/coverage_merger.dart' as coverageMerger;
import 'coverage_helper.dart';
import 'testing/environment_keys.dart';
import 'testing_utils.dart' show checkEnvironment;
import 'utils/kernel_chain.dart';
import 'utils/suite_utils.dart';
import 'vm_service_coverage.dart';

void main([List<String> arguments = const []]) => internalMain(
  createContext,
  arguments: arguments,
  displayName: "coverage merger suite",
  configurationPath: "../testing.json",
);

const List<Map<String, String>> EXPECTATIONS = [
  {"name": "ExpectationFileMismatch", "group": "Fail"},
  {"name": "ExpectationFileMissing", "group": "Fail"},
];

Future<Context> createContext(Chain suite, Map<String, String> environment) {
  const Set<String> knownEnvironmentKeys = {EnvironmentKeys.updateExpectations};
  checkEnvironment(environment, knownEnvironmentKeys);

  return new Future.value(new Context(suite.name, environment));
}

class CheckCoverageData extends Step<TestDescription, void, Context> {
  const CheckCoverageData();

  @override
  String get name => "CheckCoverageData";

  @override
  Future<Result<void>> run(TestDescription description, Context context) async {
    Directory tmpDir = Directory.systemTemp.createTempSync(
      "coverage_merger_test",
    );
    try {
      Directory dartToolDir = new Directory.fromUri(
        tmpDir.uri.resolve(".dart_tool/"),
      );
      dartToolDir.createSync(recursive: true);
      File packageConfig = new File.fromUri(
        tmpDir.uri.resolve(".dart_tool/package_config.json"),
      );
      // We claim it being called 'front_end' as that's (currently at least) the
      // only package we process (almost) all files for.
      packageConfig.writeAsStringSync("""{
  "configVersion": 2,
  "packages": [
    {
      "name": "front_end",
      "rootUri": "../",
      "packageUri": "lib/",
      "languageVersion": "3.8"
    }
  ]
}""");
      Directory libDir = new Directory.fromUri(tmpDir.uri.resolve("lib/"));
      libDir.createSync(recursive: true);
      File main = new File.fromUri(tmpDir.uri.resolve("lib/main.dart"));
      File sourceFile = new File.fromUri(description.uri);
      main.writeAsStringSync(sourceFile.readAsStringSync().trim());

      CollectingCoverageHelper helper = new CollectingCoverageHelper();
      await helper.start(
        [
          "--disable-dart-dev",
          "--enable-asserts",
          "--pause_isolates_on_exit",
          main.path,
        ],
        stdoutReceiver: (String line) {
          print(" > $line");
        },
        stderrReceiver: (String line) {
          print("e> $line");
        },
      );
      Coverage coverage = await helper.completer.future;
      Directory coverageDir = new Directory.fromUri(
        tmpDir.uri.resolve("coverage/"),
      );
      coverageDir.createSync(recursive: true);
      File coverageFile = new File.fromUri(
        tmpDir.uri.resolve("coverage/coverage.json"),
      );
      coverage.writeToFile(coverageFile);

      Map<Uri, coverageMerger.CoverageInfo> coverageData = (await coverageMerger
          .mergeFromDirUri(
            packageConfig.uri,
            coverageDir.uri,
            silent: true,
            extraCoverageIgnores: ["coverage-ignore(suite):"],
            extraCoverageBlockIgnores: ["coverage-ignore-block(suite):"],
            addAndRemoveCommentsInFiles: false,
            stdoutReceiver: (String line) {
              print(" > $line");
            },
            stderrReceiver: (String line) {
              print("e> $line");
            },
          ))!;
      if (coverageData.values.first.error) {
        print("Warning: Got an error.");
      }

      Result<TestDescription> expectMatch = await context
          .match<TestDescription>(
            ".visualization.expect",
            coverageData.values.first.visualization.trim(),
            description.uri,
            description,
          );
      if (expectMatch.outcome != Expectation.pass) return expectMatch;

      coverageData = (await coverageMerger.mergeFromDirUri(
        packageConfig.uri,
        coverageDir.uri,
        silent: true,
        extraCoverageIgnores: ["coverage-ignore(suite):"],
        extraCoverageBlockIgnores: ["coverage-ignore-block(suite):"],
        addAndRemoveCommentsInFiles: true,
        stdoutReceiver: (String line) {
          print(" > $line");
        },
        stderrReceiver: (String line) {
          print("e> $line");
        },
      ))!;

      print("Reading ${main.path}");

      String outputWithComments = main.readAsStringSync().trim();
      return await context.match<TestDescription>(
        ".commented.expect",
        outputWithComments,
        description.uri,
        description,
      );
    } finally {
      try {
        tmpDir.deleteSync(recursive: true);
      } catch (e) {
        // Wait a little and retry.
        sleep(const Duration(milliseconds: 42));
        try {
          tmpDir.deleteSync(recursive: true);
        } catch (e) {
          print('Warning: $e');
        }
      }
    }
  }
}

class CollectingCoverageHelper extends CoverageHelper {
  Completer<Coverage> completer = new Completer();

  CollectingCoverageHelper() : super(doPrint: false, forceCompilation: true);

  @override
  void gotCoverage(Coverage coverage) {
    completer.complete(coverage);
  }
}

class Context extends ChainContext with MatchContext {
  final String suiteName;

  @override
  final List<Step> steps = const <Step>[const CheckCoverageData()];

  @override
  final bool updateExpectations;

  @override
  final ExpectationSet expectationSet = new ExpectationSet.fromJsonList(
    EXPECTATIONS,
  );

  Context(this.suiteName, Map<String, String> environment)
    : updateExpectations =
          environment[EnvironmentKeys.updateExpectations] == "true";

  @override
  bool get canBeFixWithUpdateExpectations => true;

  @override
  String get updateExpectationsOption =>
      '${EnvironmentKeys.updateExpectations}=true';
}