[test_runner] Support update_static_error_tests on Windows

A previous change inadvertently broke the support for Windows. This fixes this and adds an end-to-end test to avoid this.

Change-Id: I6f8563665038a7ecb0b30b5dfb7051b606d90620
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/420660
Commit-Queue: Johnni Winther <[email protected]>
Reviewed-by: Bob Nystrom <[email protected]>

Author: johnniwinther

pkg/test_runner/lib/src/path.dart

@@ -21,6 +21,11 @@ class Path {
 
   Path._internal(this._path, this.isWindowsShare);
 
+  /// Normalizes [source] to use '/' as delimiter.
+  static String normalize(String source) {
+    return Path(source)._path;
+  }
+
   static String _clean(String source) {
     if (Platform.operatingSystem == 'windows') return _cleanWindows(source);
     // Remove trailing slash from directories:

pkg/test_runner/lib/src/test_file.dart

@@ -108,10 +108,7 @@ abstract class _TestFileBase {
     return originPath.relativeTo(_suiteDirectory).toString().hashCode;
   }
 
-  _TestFileBase(this._suiteDirectory, this.path, this.expectedErrors) {
-    // The VM C++ unit tests have a special fake TestFile with no path.
-    assert(path.isAbsolute);
-  }
+  _TestFileBase(this._suiteDirectory, this.path, this.expectedErrors);
 
   /// The logical name of the test.
   ///

pkg/test_runner/test/update_error_cmdline_test.dart

@@ -0,0 +1,98 @@
+// 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';
+
+const commonArguments = [
+  'run',
+  'pkg/test_runner/tool/update_static_error_tests.dart',
+  '--update=cfe',
+];
+
+const testNameParts = [
+  'language',
+  'compile_time_constant',
+  'compile_time_constant_test'
+];
+
+final fileNameParts = [
+  'tests',
+  ...testNameParts.take(testNameParts.length - 1),
+  '${testNameParts.last}.dart',
+];
+
+const expectedLine = 'Running CFE on 1 file...';
+final expectedUpdateText = '${testNameParts.last}.dart (3 errors)';
+
+void main() async {
+  var testFile = File(p.joinAll(fileNameParts));
+  var testContent = testFile.readAsStringSync();
+  try {
+    var errorFound = false;
+
+    var testName = testNameParts.join('/');
+    errorFound |= await run(testName);
+
+    var relativeNativePath = p.joinAll(fileNameParts);
+    errorFound |= await run(relativeNativePath);
+
+    var relativeUriPath = fileNameParts.join('/');
+    errorFound |= await run(relativeUriPath);
+
+    var absoluteNativePath = File(relativeNativePath).absolute.path;
+    var result = await run(absoluteNativePath);
+    if (Platform.isWindows) {
+      // TODO(johnniwinther,rnystrom): Support absolute paths on Windows.
+      if (!result) {
+        print('Error: Expected failure on Windows. '
+            'Update test to expect success on all platforms.');
+        errorFound = true;
+      } else {
+        print('Error on Windows is expected.');
+      }
+    } else {
+      errorFound |= result;
+    }
+
+    if (errorFound) {
+      print('----------------------------------------------------------------');
+      throw 'Error found!';
+    }
+  } finally {
+    // Restore original test content.
+    testFile.writeAsStringSync(testContent);
+  }
+}
+
+Future<bool> run(String input) async {
+  var executable = Platform.resolvedExecutable;
+  var arguments = [...commonArguments, 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;
+  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;
+}

pkg/test_runner/tool/update_static_error_tests.dart

@@ -188,6 +188,11 @@ List<TestFile> _listFiles(List<String> pathGlobs,
     // or relative to the current directory.
     var root = pathGlob.startsWith("tests") ? "." : "tests";
 
+    // [Glob] doesn't handle Windows path delimiters, so we normalize it using
+    // [Path]. [Glob] doesn't handle absolute Windows paths, though, so this
+    // only supports the relative paths.
+    pathGlob = Path.normalize(pathGlob);
+
     for (var file in Glob(pathGlob, recursive: true).listSync(root: root)) {
       if (file is! File) continue;
 
@@ -404,7 +409,7 @@ Future<Map<TestFile, List<StaticError>>> _runCfe(
         result.stdout as String, parsedErrors, parsedErrors);
     for (var error in parsedErrors) {
       var testFile =
-          testFiles.firstWhere((test) => test.path.toString() == error.path);
+          testFiles.firstWhere((test) => test.path == Path(error.path));
       errors.putIfAbsent(testFile, () => []).add(error);
     }
   }
@@ -468,20 +473,21 @@ void _updateErrors(TestFile testFile, List<StaticError> errors,
   // Error expectations can be in imported libraries or part files. Iterate
   // over the set of paths that is the main file path plus all paths mentioned
   // in expectations, updating them.
-  var paths = {testFile.path.toString(), for (var error in errors) error.path};
+  var paths = {testFile.path, for (var error in errors) Path(error.path)};
 
   for (var path in paths) {
-    var file = File(path);
-    var pathErrors = errors.where((e) => e.path == path).toList();
+    var nativePath = path.toNativePath();
+    var file = File(nativePath);
+    var pathErrors = errors.where((e) => Path(e.path) == path).toList();
     var result = updateErrorExpectations(
-        path, file.readAsStringSync(), pathErrors,
+        nativePath, file.readAsStringSync(), pathErrors,
         remove: remove, includeContext: includeContext);
 
     if (dryRun) {
       print(result);
     } else {
       file.writeAsString(result);
-      print('- $path (${_plural(pathErrors, 'error')})');
+      print('- $nativePath (${_plural(pathErrors, 'error')})');
     }
   }
 }