sdk/pkg/test_runner/test/update_error_cmdline_test.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:io';
import 'package:path/path.dart' as p;
import 'package:test_runner/src/utils.dart';

void main() async {
  const testNamePartsCfe = [
    'language',
    'compile_time_constant',
    'compile_time_constant_test',
  ];
  const testNamePartsWeb = ['web', 'extension_type_assert_error_test'];
  const expectedLineCfe = 'Running CFE on 1 file...';
  final expectedUpdateTextCfe = '${testNamePartsCfe.last}.dart (2 errors)';
  final expectedLineCfeWeb =
      'Running dart2js on ${toFileNameParts(testNamePartsCfe).join('/')}...';

  final expectedLineWeb =
      'Running dart2js on ${toFileNameParts(testNamePartsWeb).join('/')}...';
  final expectedUpdateTextWeb = '${testNamePartsWeb.last}.dart (1 error)';

  await doTest(
    toFileNameParts(testNamePartsCfe),
    testNamePartsCfe,
    '--update=cfe',
    [expectedLineCfe],
    expectedUpdateTextCfe,
  );
  await doTest(
    toFileNameParts(testNamePartsCfe),
    testNamePartsCfe,
    '--update=cfe,web',
    [expectedLineCfe, expectedLineCfeWeb],
    expectedUpdateTextCfe,
    runAll: false,
  );
  await doTest(
    toFileNameParts(testNamePartsWeb),
    testNamePartsWeb,
    '--update=web',
    [expectedLineWeb],
    expectedUpdateTextWeb,
    runAll: false,
  );
  await doTest(
    toFileNameParts(testNamePartsWeb),
    testNamePartsWeb,
    '--update=web,cfe',
    [expectedLineCfe, expectedLineWeb],
    expectedUpdateTextWeb,
    runAll: false,
  );
}

List<String> toFileNameParts(List<String> testNameParts) => [
  'tests',
  ...testNameParts.take(testNameParts.length - 1),
  '${testNameParts.last}.dart',
];

String toFileName(List<String> fileNameParts) => p.joinAll(fileNameParts);

Future<void> doTest(
  List<String> fileNameParts,
  List<String> testNameParts,
  String target,
  List<String> expectedLines,
  String expectedUpdateText, {
  bool runAll = true,
}) async {
  var testFile = File(toFileName(fileNameParts));
  var testContent = testFile.readAsStringSync();
  try {
    var errorFound = false;

    var testName = testNameParts.join('/');
    errorFound |= await run(
      testName,
      target,
      expectedLines,
      expectedUpdateText,
    );

    if (runAll) {
      var relativeNativePath = p.joinAll(fileNameParts);
      errorFound |= await run(
        relativeNativePath,
        target,
        expectedLines,
        expectedUpdateText,
      );

      var relativeUriPath = fileNameParts.join('/');
      errorFound |= await run(
        relativeUriPath,
        target,
        expectedLines,
        expectedUpdateText,
      );

      var absoluteNativePath = File(relativeNativePath).absolute.path;
      errorFound |= await run(
        absoluteNativePath,
        target,
        expectedLines,
        expectedUpdateText,
      );
    }

    if (errorFound) {
      print('----------------------------------------------------------------');
      throw 'Error found!';
    }
  } finally {
    // Restore original test content.
    testFile.writeAsStringSync(testContent);
  }
}

Future<bool> run(
  String input,
  String target,
  List<String> expectedLines,
  String expectedUpdateText,
) async {
  const commonArguments = [
    'run',
    'pkg/test_runner/tool/update_static_error_tests.dart',
  ];

  var executable = Platform.resolvedExecutable;
  var arguments = [...commonArguments, target, input];
  print('--------------------------------------------------------------------');
  print('Running: $executable ${arguments.join(' ')}');
  var process = await Process.start(executable, runInShell: true, arguments);
  var lines = <String>[];
  process.stdout.forEach((e) => lines.add(decodeUtf8(e)));
  process.stderr.forEach((e) => lines.add(decodeUtf8(e)));
  var exitCode = await process.exitCode;
  var output = lines.join();
  print(output);
  print('Exit code: $exitCode');

  var hasError = false;
  for (var expectedLine in expectedLines) {
    if (!output.contains(expectedLine)) {
      print('Error: Expected output: $expectedLine');
      hasError = true;
    }
  }
  if (!output.contains(expectedUpdateText)) {
    print('Error: Expected update: $expectedUpdateText');
    hasError = true;
  }
  if (exitCode != 0) {
    print('Error: Expected exit code: 0');
    hasError = true;
  }
  return hasError;
}