Index: trunk/test/unit/org/openstreetmap/josm/tools/AlphanumComparatorTest.java
===================================================================
--- trunk/test/unit/org/openstreetmap/josm/tools/AlphanumComparatorTest.java	(revision 18981)
+++ trunk/test/unit/org/openstreetmap/josm/tools/AlphanumComparatorTest.java	(revision 18983)
@@ -2,9 +2,15 @@
 package org.openstreetmap.josm.tools;
 
+import static org.junit.jupiter.api.Assertions.assertAll;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
+import java.text.Collator;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.function.BiFunction;
+import java.util.stream.Stream;
 
+import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
 
@@ -13,4 +19,8 @@
  */
 class AlphanumComparatorTest {
+    @AfterEach
+    void teardown() {
+        AlphanumComparator.useFastASCIISort = true;
+    }
 
     /**
@@ -33,3 +43,75 @@
         assertEquals(Arrays.asList("a5", "a100", "a00999", "b1", "b20"), lst);
     }
+
+    private static Stream<String[]> testNonRegression23471Arguments() {
+        List<String> testStrings = Arrays.asList(
+                "AMEN",
+                "Ameriabank",
+                "America First Credit Union",
+                "BAC Credomatic",
+                "BADR Banque",
+                "BAI",
+                "Banca Popolare di Cividale",
+                "Banca Popolare di Sondrio",
+                "Banca Sella",
+                "Banca Transilvania",
+                "Bancaribe",
+                "BancaStato",
+                "Banco Agrario",
+                "Banco AV Villas",
+                "Banco Azteca",
+                "Banco Bicentenario",
+                "Banco BISA",
+                "Banco BMG",
+                "Banco BPI (Portugal)",
+                "Banco BPM",
+                "Banco Caja Social",
+                "Banco Ciudad",
+                "Banco Continental (Paraguay)",
+                "Banco di Sardegna"
+        );
+        List<String> testChars = new ArrayList<>(AlphanumComparator.ASCII_SORT_ORDER.length());
+        for (char c : AlphanumComparator.ASCII_SORT_ORDER.toCharArray()) {
+            testChars.add(Character.toString(c));
+        }
+        BiFunction<List<String>, String, List<String>> subList = (list, string) -> list.subList(list.indexOf(string), list.size());
+        return Stream.concat(
+                testStrings.stream().flatMap(first -> subList.apply(testStrings, first).stream().map(second -> new String[]{first, second})),
+                testChars.stream().flatMap(first -> subList.apply(testChars, first).stream().map(second -> new String[]{first, second}))
+        );
+    }
+
+    /**
+     * Non-regression test for #23471
+     * This ensures that the comparison contract holds.
+     * There are ~5300 combinations run in <1s (as of 2024-02-14).
+     */
+    @Test
+    void testNonRegression23471() {
+        assertAll(testNonRegression23471Arguments().map(strings -> () -> testNonRegression23471(strings[0], strings[1])));
+    }
+
+    private static void testNonRegression23471(String first, String second) {
+        AlphanumComparator.useFastASCIISort = true;
+        final AlphanumComparator instance = AlphanumComparator.getInstance();
+        assertEquals(-instance.compare(first, second), instance.compare(second, first));
+        // Ensure that the fast sort is equivalent to the slow sort
+        AlphanumComparator.useFastASCIISort = false;
+        final int slowFirstSecond = instance.compare(first, second);
+        final int slowSecondFirst = instance.compare(second, first);
+        AlphanumComparator.useFastASCIISort = true;
+        final int fastFirstSecond = instance.compare(first, second);
+        final int fastSecondFirst = instance.compare(second, first);
+        assertEquals(slowFirstSecond, fastFirstSecond);
+        assertEquals(slowSecondFirst, fastSecondFirst);
+
+        final Collator collator = Collator.getInstance();
+        collator.setStrength(Collator.SECONDARY);
+        // Check against the collator instance
+        assertEquals(Utils.clamp(collator.compare(first, second), -1, 1),
+                Utils.clamp(instance.compare(first, second), -1, 1));
+        assertEquals(Utils.clamp(collator.compare(second, first), -1, 1),
+                Utils.clamp(instance.compare(second, first), -1, 1));
+    }
+
 }