TST: add sortable/orderable fixtures, use in sort-dependent tests (#54072)

Add index_sortable, index_flat_sortable, index_with_missing_sortable,
and index_or_series_obj_orderable fixtures that exclude the
mixed-int-string Index via params filtering. Use these in tests that
require sorting/ordering so test bodies stay clean with no try/except
that could swallow bugs.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: jbrockmendel

pandas/conftest.py

@@ -746,6 +746,14 @@ def index(request):
     return indices_dict[request.param].copy(deep=False)
 
 
+@pytest.fixture(params=[key for key in indices_dict if key != "mixed-int-string"])
+def index_sortable(request):
+    """
+    index fixture, but excluding types that are not orderable.
+    """
+    return indices_dict[request.param].copy(deep=False)
+
+
 @pytest.fixture(
     params=[
         key for key, value in indices_dict.items() if not isinstance(value, MultiIndex)
@@ -759,6 +767,20 @@ def index_flat(request):
     return indices_dict[key].copy(deep=False)
 
 
+@pytest.fixture(
+    params=[
+        key
+        for key, value in indices_dict.items()
+        if not isinstance(value, MultiIndex) and key != "mixed-int-string"
+    ]
+)
+def index_flat_sortable(request):
+    """
+    index_flat fixture, but excluding types that are not orderable.
+    """
+    return indices_dict[request.param].copy(deep=False)
+
+
 @pytest.fixture(
     params=[
         key
@@ -793,6 +815,28 @@ def index_with_missing(request):
         return type(ind)(vals, copy=False)
 
 
+@pytest.fixture(
+    params=[
+        key
+        for key, value in indices_dict.items()
+        if not (
+            key.startswith(("int", "uint", "float"))
+            or key in ["range", "empty", "repeats", "bool-dtype", "mixed-int-string"]
+        )
+        and not isinstance(value, MultiIndex)
+    ]
+)
+def index_with_missing_sortable(request):
+    """
+    index_with_missing fixture, but excluding types that are not orderable.
+    """
+    ind = indices_dict[request.param]
+    vals = ind.values.copy()
+    vals[0] = None
+    vals[-1] = None
+    return type(ind)(vals, copy=False)
+
+
 # ----------------------------------------------------------------
 # Series'
 # ----------------------------------------------------------------
@@ -871,6 +915,21 @@ def index_or_series_obj(request):
     return _index_or_series_objs[request.param].copy(deep=False)
 
 
+_index_or_series_objs_orderable = {
+    key: value
+    for key, value in _index_or_series_objs.items()
+    if "mixed-int-string" not in key
+}
+
+
+@pytest.fixture(params=_index_or_series_objs_orderable.keys())
+def index_or_series_obj_orderable(request):
+    """
+    index_or_series_obj fixture, but excluding types that are not orderable.
+    """
+    return _index_or_series_objs_orderable[request.param].copy(deep=False)
+
+
 _typ_objects_series = {
     f"{dtype.__name__}-series": Series(dtype) for dtype in tm.PYTHON_DATA_TYPES
 }

pandas/tests/base/test_misc.py

@@ -139,10 +139,10 @@ def test_memory_usage_components_narrow_series(any_real_numpy_dtype):
     assert total_usage == non_index_usage + index_usage
 
 
-def test_searchsorted(request, index_or_series_obj):
+def test_searchsorted(request, index_or_series_obj_orderable):
     # numpy.searchsorted calls obj.searchsorted under the hood.
     # See gh-12238
-    obj = index_or_series_obj
+    obj = index_or_series_obj_orderable
 
     if isinstance(obj, pd.MultiIndex):
         # See gh-14833
@@ -156,11 +156,6 @@ def test_searchsorted(request, index_or_series_obj):
         #  comparison semantics https://github.com/numpy/numpy/issues/15981
         mark = pytest.mark.xfail(reason="complex objects are not comparable")
         request.applymarker(mark)
-    elif isinstance(obj, Index) and obj.inferred_type == "mixed-integer":
-        # mixed int/str types are not orderable in Python 3
-        with pytest.raises(TypeError, match="not supported between"):
-            max(obj)
-        return
 
     max_obj = max(obj, default=0)
     index = np.searchsorted(obj, max_obj)

pandas/tests/base/test_value_counts.py

@@ -18,7 +18,6 @@
     array,
 )
 import pandas._testing as tm
-from pandas.core.indexes.api import safe_sort_index
 from pandas.tests.base.common import allow_na_ops
 
 
@@ -54,8 +53,8 @@ def test_value_counts(index_or_series_obj):
 
 @pytest.mark.parametrize("null_obj", [np.nan, None])
 @pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
-def test_value_counts_null(null_obj, index_or_series_obj):
-    orig = index_or_series_obj
+def test_value_counts_null(null_obj, index_or_series_obj_orderable):
+    orig = index_or_series_obj_orderable
 
     if not allow_na_ops(orig):
         pytest.skip("type doesn't allow for NA operations")
@@ -98,14 +97,8 @@ def test_value_counts_null(null_obj, index_or_series_obj):
     expected[null_obj] = 3
 
     result = obj.value_counts(dropna=False)
-    if expected.index.inferred_type == "mixed-integer":
-        # mixed int/str types are not orderable; use safe_sort_index
-        sorted_idx = safe_sort_index(expected.index)
-        expected = expected.reindex(sorted_idx)
-        result = result.reindex(sorted_idx)
-    else:
-        expected = expected.sort_index()
-        result = result.sort_index()
+    expected = expected.sort_index()
+    result = result.sort_index()
     tm.assert_series_equal(result, expected)
 
 

pandas/tests/indexes/multi/test_setops.py

@@ -15,7 +15,6 @@
     is_float_dtype,
     is_unsigned_integer_dtype,
 )
-from pandas.core.indexes.api import safe_sort_index
 
 
 @pytest.mark.parametrize("case", [0.5, "xxx"])
@@ -626,24 +625,18 @@ def test_union_with_duplicates_keep_ea_dtype(dupe_val, any_numeric_ea_dtype):
 
 
 @pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
-def test_union_duplicates(index, request):
+def test_union_duplicates(index_sortable, request):
     # GH#38977
+    index = index_sortable
     if index.empty or isinstance(index, (IntervalIndex, CategoricalIndex)):
         pytest.skip(f"No duplicates in an empty {type(index).__name__}")
 
     values = index.unique().values.tolist()
     mi1 = MultiIndex.from_arrays([values, [1] * len(values)])
     mi2 = MultiIndex.from_arrays([[values[0], *values], [1] * (len(values) + 1)])
-
-    # mi2.union(mi1): mi1 (other) has no duplicates, so MultiIndex._union takes
-    # the sort path, which emits RuntimeWarning for unorderable types
-    warn = RuntimeWarning if index.inferred_type == "mixed-integer" else None
-    warn_msg = "The values in the array are unorderable"
-
-    with tm.assert_produces_warning(warn, match=warn_msg):
-        result = mi2.union(mi1)
-    expected = safe_sort_index(mi2)
-    tm.assert_index_equal(safe_sort_index(result), expected)
+    result = mi2.union(mi1)
+    expected = mi2.sort_values()
+    tm.assert_index_equal(result, expected)
 
     if (
         is_unsigned_integer_dtype(mi2.levels[0])
@@ -664,7 +657,7 @@ def test_union_duplicates(index, request):
         )
 
     result = mi1.union(mi2)
-    tm.assert_index_equal(safe_sort_index(result), expected)
+    tm.assert_index_equal(result, expected)
 
 
 def test_union_keep_dtype_precision(any_real_numeric_dtype):

pandas/tests/indexes/test_common.py

@@ -436,27 +436,18 @@ def test_hasnans_isnans(self, index_flat):
 
 @pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
 @pytest.mark.parametrize("na_position", [None, "middle"])
-def test_sort_values_invalid_na_position(index_with_missing, na_position):
-    if index_with_missing.inferred_type == "mixed-integer":
-        # mixed int/str types are not orderable; TypeError before ValueError
-        with pytest.raises(TypeError, match="not supported between"):
-            index_with_missing.sort_values(na_position=na_position)
-        return
+def test_sort_values_invalid_na_position(index_with_missing_sortable, na_position):
     with pytest.raises(ValueError, match=f"invalid na_position: {na_position}"):
-        index_with_missing.sort_values(na_position=na_position)
+        index_with_missing_sortable.sort_values(na_position=na_position)
 
 
 @pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
 @pytest.mark.parametrize("na_position", ["first", "last"])
-def test_sort_values_with_missing(index_with_missing, na_position):
+def test_sort_values_with_missing(index_with_missing_sortable, na_position):
     # GH 35584. Test that sort_values works with missing values,
     # sort non-missing and place missing according to na_position
 
-    if index_with_missing.inferred_type == "mixed-integer":
-        # mixed int/str types are not orderable in Python 3
-        with pytest.raises(TypeError, match="not supported between"):
-            index_with_missing.sort_values(na_position=na_position)
-        return
+    index_with_missing = index_with_missing_sortable
 
     missing_count = np.sum(index_with_missing.isna())
     not_na_vals = index_with_missing[index_with_missing.notna()].values

pandas/tests/indexes/test_numpy_compat.py

@@ -151,22 +151,18 @@ def test_numpy_ufuncs_other(index, func):
 
 
 @pytest.mark.parametrize("func", [np.maximum, np.minimum])
-def test_numpy_ufuncs_reductions(index, func):
+def test_numpy_ufuncs_reductions(index_sortable, func):
     # TODO: overlap with tests.series.test_ufunc.test_reductions
+    index = index_sortable
     if len(index) == 0:
         pytest.skip("Test doesn't make sense for empty index.")
 
     if isinstance(index, CategoricalIndex) and index.dtype.ordered is False:
         with pytest.raises(TypeError, match="is not ordered for"):
             func.reduce(index)
         return
-    elif index.inferred_type == "mixed-integer":
-        # mixed int/str types are not orderable in Python 3
-        with pytest.raises(TypeError, match="not supported between"):
-            func.reduce(index)
-        return
-    else:
-        result = func.reduce(index)
+
+    result = func.reduce(index)
 
     if func is np.maximum:
         expected = index.max(skipna=False)

pandas/tests/indexes/test_old_base.py

@@ -355,27 +355,17 @@ def test_memory_usage_doesnt_trigger_engine(self, index):
             assert res_without_engine > 0
             assert res_with_engine > 0
 
-    def test_argsort(self, index):
+    def test_argsort(self, index_sortable):
+        index = index_sortable
         if isinstance(index, CategoricalIndex):
             pytest.skip(f"{type(self).__name__} separately tested")
 
-        if index.inferred_type == "mixed-integer":
-            # mixed int/str types are not orderable in Python 3
-            with pytest.raises(TypeError, match="not supported between"):
-                index.argsort()
-            return
-
         result = index.argsort()
         expected = np.array(index).argsort()
         tm.assert_numpy_array_equal(result, expected)
 
-    def test_numpy_argsort(self, index):
-        if index.inferred_type == "mixed-integer":
-            # mixed int/str types are not orderable in Python 3
-            with pytest.raises(TypeError, match="not supported between"):
-                np.argsort(index)
-            return
-
+    def test_numpy_argsort(self, index_sortable):
+        index = index_sortable
         result = np.argsort(index)
         expected = index.argsort()
         tm.assert_numpy_array_equal(result, expected)