Run test_difflib against both pure-Python and C implementations

When the _difflib C accelerator is built, programmatically generate a
parallel ``*_PurePython`` TestCase for each existing test class so the
same suite covers both implementations.  Pure-Python coverage is
obtained by patching ``difflib.SequenceMatcher`` to
``_pydifflib.SequenceMatcher`` in setUp / restoring it in tearDown;
internal helpers like ``unified_diff`` and ``ndiff`` resolve
``SequenceMatcher`` on ``difflib`` at call time, so patching the module
attribute covers the whole pipeline.

This mirrors the dual-implementation test pattern used by test_decimal
(C* / Py* class pairs) without requiring every existing test method to
be parameterised.

``test_html_diff`` also gets a single-line fix: it depended on
``HtmlDiff._default_prefix`` starting at 0, which only held because it
ran first.  Resetting the counter at the top of the test makes it
order-independent.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: blhsing

Lib/test/test_difflib.py

@@ -1,4 +1,5 @@
 import difflib
+import _pydifflib
 from test import support
 from test.support import findfile, force_colorized
 from test.support.import_helper import ensure_lazy_imports
@@ -7,6 +8,28 @@
 import sys
 
 
+# Tests below reference ``difflib.SequenceMatcher``.  By default that is the
+# C-accelerated subclass (when ``_difflib`` is available) or the pure-Python
+# class otherwise.  The mixin below temporarily swaps it to the pure-Python
+# class from ``_pydifflib`` so the same test suite covers both implementations
+# whenever the accelerator is built.
+_PySequenceMatcher = _pydifflib.SequenceMatcher
+_has_c_accelerator = difflib.SequenceMatcher is not _PySequenceMatcher
+
+
+class _PyImplMixin:
+    """Run a TestCase with ``difflib.SequenceMatcher`` patched to pure Python."""
+
+    def setUp(self):
+        super().setUp()
+        self._orig_SequenceMatcher = difflib.SequenceMatcher
+        difflib.SequenceMatcher = _PySequenceMatcher
+
+    def tearDown(self):
+        difflib.SequenceMatcher = self._orig_SequenceMatcher
+        super().tearDown()
+
+
 class TestWithAscii(unittest.TestCase):
     def test_one_insert(self):
         sm = difflib.SequenceMatcher(None, 'b' * 100, 'a' + 'b' * 100)
@@ -201,6 +224,10 @@ class TestSFpatches(unittest.TestCase):
 
     def test_html_diff(self):
         # Check SF patch 914575 for generating HTML differences
+        # Reset the global ``HtmlDiff._default_prefix`` counter so that
+        # generated element IDs are stable when this test runs twice
+        # (e.g. once per implementation; see _PyImplMixin below).
+        difflib.HtmlDiff._default_prefix = 0
         f1a = ((patch914575_from1 + '123\n'*10)*3)
         t1a = (patch914575_to1 + '123\n'*10)*3
         f1b = '456\n'*10 + f1a
@@ -657,5 +684,31 @@ def load_tests(loader, tests, pattern):
     return tests
 
 
+# When the C accelerator is present, generate a parallel ``*_PurePython``
+# class for each TestCase above so the same tests run against the pure-Python
+# implementation as well.  Tests that probe import behaviour (LazyImportTest)
+# or are inherently implementation-specific are skipped.
+def _generate_pure_python_variants():
+    if not _has_c_accelerator:
+        return
+    skip = {"LazyImportTest"}
+    module = sys.modules[__name__]
+    for name in list(vars(module)):
+        cls = getattr(module, name)
+        if (isinstance(cls, type)
+                and issubclass(cls, unittest.TestCase)
+                and cls is not unittest.TestCase
+                and not name.endswith("_PurePython")
+                and name not in skip):
+            new_name = name + "_PurePython"
+            new_cls = type(new_name, (_PyImplMixin, cls), {})
+            setattr(module, new_name, new_cls)
+
+
+_generate_pure_python_variants()
+
+
+
+
 if __name__ == '__main__':
     unittest.main()