Implement a better diff print on failing tests.

Use it for printing failing element model tests.

Expectations in theses tests are often quite long, and it is hard to see
what was changed in the original form of printing.

The algorithm implemented is the Longest Common Sequence algorithm: https://en.wikipedia.org/wiki/Longest_common_subsequence

BUG: #61015

Change-Id: I6f2af52b52a6b3365f36bb536172ad2d625ec93c
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/439082
Reviewed-by: Paul Berry <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: fshcheglov

pkg/analyzer/test/src/summary/elements_base.dart

@@ -9,6 +9,7 @@ import 'package:analyzer/src/dart/element/element.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
+import '../../util/diff.dart';
 import '../dart/resolution/context_collection_resolution.dart';
 import '../dart/resolution/node_text_expectations.dart';
 import 'element_text.dart';
@@ -49,11 +50,10 @@ abstract class ElementsBaseTest extends PubPackageResolutionTest {
   void checkElementText(LibraryElementImpl library, String expected) {
     var actual = getLibraryText(library: library, configuration: configuration);
     if (actual != expected) {
-      print('-------- Actual --------');
-      print('$actual------------------------');
       NodeTextExpectationsCollector.add(actual);
+      printPrettyDiff(expected, actual);
+      fail('See the difference above.');
     }
-    expect(actual, expected);
   }
 
   Future<LibraryElementImpl> testContextLibrary(String uriStr) async {

pkg/analyzer/test/util/diff.dart

@@ -0,0 +1,155 @@
+// 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:math';
+
+/// Generates a "focused" unified diff, showing only the changed lines
+/// plus a few lines of context around them.
+String generateFocusedDiff(
+  String expected,
+  String actual, {
+  int contextLines = 3,
+}) {
+  var fullDiff = _createDiff(expected, actual);
+  var outputLines = <String>[];
+
+  var indicesToInclude = <int>{};
+
+  for (var (i, result) in fullDiff.indexed) {
+    if (result.type != _DiffType.common) {
+      indicesToInclude.add(i);
+      for (
+        int j = max(0, i - contextLines);
+        j < min(fullDiff.length, i + contextLines + 1);
+        j++
+      ) {
+        indicesToInclude.add(j);
+      }
+    }
+  }
+
+  if (indicesToInclude.isEmpty) {
+    return 'No differences found.';
+  }
+
+  int lastIncludedIndex = -1;
+  var sortedIndices = indicesToInclude.toList()..sort();
+
+  for (int i in sortedIndices) {
+    if (lastIncludedIndex != -1 && i > lastIncludedIndex + 1) {
+      outputLines.add('...');
+    }
+
+    outputLines.add(_formatLine(fullDiff[i]));
+    lastIncludedIndex = i;
+  }
+
+  return outputLines.join('\n');
+}
+
+/// Generates a "full" unified diff, showing every line from the comparison.
+String generateFullDiff(String expected, String actual) {
+  var diffResults = _createDiff(expected, actual);
+  return diffResults.map(_formatLine).join('\n');
+}
+
+void printPrettyDiff(String expected, String actual, {int context = 3}) {
+  var full = generateFullDiff(expected, actual);
+  var short = generateFocusedDiff(expected, actual);
+  print('-------- Short diff --------');
+  print(short);
+  print('-------- Full diff ---------');
+  print(full);
+  print('---------- Actual ----------');
+  print(actual.trimRight());
+  print('------------------------');
+}
+
+/// Backtracks through the LCS table to build the list of diff results.
+List<_DiffResult> _backtrack(
+  List<List<int>> table,
+  List<String> list1,
+  List<String> list2,
+) {
+  var diff = <_DiffResult>[];
+  int i = list1.length;
+  int j = list2.length;
+
+  while (i > 0 || j > 0) {
+    if (i == 0) {
+      diff.add(_DiffResult(_DiffType.added, list2[j - 1]));
+      j--;
+      continue;
+    }
+    if (j == 0) {
+      diff.add(_DiffResult(_DiffType.removed, list1[i - 1]));
+      i--;
+      continue;
+    }
+    if (list1[i - 1] == list2[j - 1]) {
+      diff.add(_DiffResult(_DiffType.common, list1[i - 1]));
+      i--;
+      j--;
+    } else if (table[i - 1][j] >= table[i][j - 1]) {
+      diff.add(_DiffResult(_DiffType.removed, list1[i - 1]));
+      i--;
+    } else {
+      diff.add(_DiffResult(_DiffType.added, list2[j - 1]));
+      j--;
+    }
+  }
+
+  return diff.reversed.toList();
+}
+
+List<List<int>> _computeLcsTable(List<String> list1, List<String> list2) {
+  var n = list1.length;
+  var m = list2.length;
+
+  var table = List.generate(n + 1, (_) => List.filled(m + 1, 0));
+
+  for (int i = 1; i <= n; i++) {
+    for (int j = 1; j <= m; j++) {
+      if (list1[i - 1] == list2[j - 1]) {
+        table[i][j] = table[i - 1][j - 1] + 1;
+      } else {
+        table[i][j] = max(table[i - 1][j], table[i][j - 1]);
+      }
+    }
+  }
+  return table;
+}
+
+/// Returns a line by line difference between [actual] and [expected].
+///
+/// It uses Longest Common Sequence Algorithm to generate a table
+/// (https://en.wikipedia.org/wiki/Longest_common_subsequence)
+List<_DiffResult> _createDiff(String expected, String actual) {
+  var expectedLines = expected.split('\n');
+  var actualLines = actual.split('\n');
+
+  var lcsTable = _computeLcsTable(expectedLines, actualLines);
+
+  return _backtrack(lcsTable, expectedLines, actualLines);
+}
+
+String _formatLine(_DiffResult result) {
+  switch (result.type) {
+    case _DiffType.added:
+      return '+ ${result.line}';
+    case _DiffType.removed:
+      return '- ${result.line}';
+    case _DiffType.common:
+      return '  ${result.line}';
+  }
+}
+
+class _DiffResult {
+  final _DiffType type;
+  final String line;
+
+  _DiffResult(this.type, this.line);
+}
+
+enum _DiffType { added, removed, common }