test_bytes: Add SIMD-specific test cases for bytes.hex()

Add targeted tests for corner cases relevant to SIMD optimization:

- test_hex_simd_boundaries: Test lengths around the 16-byte SIMD
  threshold (14, 15, 16, 17, 31, 32, 33, 64, 65 bytes)

- test_hex_nibble_boundaries: Test the 9/10 nibble value boundary
  where digits become letters, verifying the signed comparison
  optimization works correctly

- test_hex_simd_separator: Test SIMD separator insertion path
  (triggered when sep >= 8 and len >= 16) with various group
  sizes and both positive/negative bytes_per_sep

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

Author: gpshead

Lib/test/test_bytes.py

@@ -584,6 +584,87 @@ def test_hex_separator_six_bytes(self):
         self.assertEqual(six_bytes.hex(':', -6), '0306090c0f12')
         self.assertEqual(six_bytes.hex(' ', -95), '0306090c0f12')
 
+    def test_hex_simd_boundaries(self):
+        # Test lengths around the SIMD threshold (16 bytes).
+        # SIMD processes 16 bytes at a time; smaller inputs use scalar code.
+        for length in (14, 15, 16, 17, 31, 32, 33, 64, 65):
+            data = self.type2test(bytes(range(length)))
+            expected = ''.join(f'{b:02x}' for b in range(length))
+            with self.subTest(length=length):
+                self.assertEqual(data.hex(), expected)
+
+    def test_hex_nibble_boundaries(self):
+        # Test the nibble value boundary at 9/10 (where '9' becomes 'a').
+        # SIMD uses signed comparison for efficiency; verify correctness
+        # at this boundary for various nibble combinations.
+        boundary_bytes = self.type2test(bytes([
+            0x09,  # both nibbles: 0, 9
+            0x0a,  # both nibbles: 0, 10
+            0x90,  # both nibbles: 9, 0
+            0x99,  # both nibbles: 9, 9 (max all-digit)
+            0x9a,  # both nibbles: 9, 10
+            0xa0,  # both nibbles: 10, 0
+            0xa9,  # both nibbles: 10, 9
+            0xaa,  # both nibbles: 10, 10 (min all-letter)
+            0x00,  # min value
+            0xff,  # max value
+        ]))
+        self.assertEqual(boundary_bytes.hex(), '090a90999aa0a9aa00ff')
+
+        # Repeat with 16+ bytes to exercise SIMD path
+        simd_boundary = self.type2test(boundary_bytes * 2)
+        self.assertEqual(simd_boundary.hex(), '090a90999aa0a9aa00ff' * 2)
+
+    def test_hex_simd_separator(self):
+        # Test SIMD path for separator insertion (sep >= 8 bytes, len >= 16).
+        # SIMD hexlifies then shuffles in-place to insert separators.
+
+        # 32 bytes exercises SIMD; test various separator group sizes
+        data = self.type2test(bytes(range(32)))
+
+        # bytes_per_sep=8: 4 groups of 8 bytes, 3 separators
+        self.assertEqual(
+            data.hex('-', 8),
+            '0001020304050607-08090a0b0c0d0e0f-'
+            '1011121314151617-18191a1b1c1d1e1f'
+        )
+        # bytes_per_sep=9: groups of 9 from start, 5 byte remainder at end
+        self.assertEqual(
+            data.hex('.', 9),
+            '0001020304.05060708090a0b0c0d.'
+            '0e0f10111213141516.1718191a1b1c1d1e1f'
+        )
+        # bytes_per_sep=16: 2 groups of 16 bytes
+        self.assertEqual(
+            data.hex(' ', 16),
+            '000102030405060708090a0b0c0d0e0f '
+            '101112131415161718191a1b1c1d1e1f'
+        )
+        # Negative bytes_per_sep: groups from end, remainder at start
+        self.assertEqual(
+            data.hex('|', -8),
+            '0001020304050607|08090a0b0c0d0e0f|'
+            '1011121314151617|18191a1b1c1d1e1f'
+        )
+        self.assertEqual(
+            data.hex('_', -9),
+            '000102030405060708_090a0b0c0d0e0f1011_'
+            '12131415161718191a_1b1c1d1e1f'
+        )
+
+        # 20 bytes: SIMD (16) + 4 byte scalar remainder
+        data20 = self.type2test(bytes(range(20)))
+        # Positive: groups from start, remainder at end
+        self.assertEqual(
+            data20.hex('#', 8),
+            '00010203#0405060708090a0b#0c0d0e0f10111213'
+        )
+        # Negative: groups from end, remainder at start
+        self.assertEqual(
+            data20.hex('@', -8),
+            '0001020304050607@08090a0b0c0d0e0f@10111213'
+        )
+
     def test_join(self):
         self.assertEqual(self.type2test(b"").join([]), b"")
         self.assertEqual(self.type2test(b"").join([b""]), b"")