TST/CLN: Use fixtures instead of setup_method in tests/indexing

pandas/tests/indexing/common.py

@@ -1,190 +1,40 @@
 """ common utilities """
-import itertools
+from __future__ import annotations
 
-import numpy as np
-
-from pandas import (
-    DataFrame,
-    MultiIndex,
-    Series,
-    date_range,
-)
-import pandas._testing as tm
-from pandas.core.api import (
-    Float64Index,
-    UInt64Index,
+from typing import (
+    Any,
+    Literal,
 )
 
 
-def _mklbl(prefix, n):
+def _mklbl(prefix: str, n: int):
     return [f"{prefix}{i}" for i in range(n)]
 
 
-def _axify(obj, key, axis):
-    # create a tuple accessor
-    axes = [slice(None)] * obj.ndim
-    axes[axis] = key
-    return tuple(axes)
-
-
-class Base:
-    """indexing comprehensive base class"""
-
-    _kinds = {"series", "frame"}
-    _typs = {
-        "ints",
-        "uints",
-        "labels",
-        "mixed",
-        "ts",
-        "floats",
-        "empty",
-        "ts_rev",
-        "multi",
-    }
-
-    def setup_method(self):
-
-        self.series_ints = Series(np.random.rand(4), index=np.arange(0, 8, 2))
-        self.frame_ints = DataFrame(
-            np.random.randn(4, 4), index=np.arange(0, 8, 2), columns=np.arange(0, 12, 3)
-        )
-
-        self.series_uints = Series(
-            np.random.rand(4), index=UInt64Index(np.arange(0, 8, 2))
-        )
-        self.frame_uints = DataFrame(
-            np.random.randn(4, 4),
-            index=UInt64Index(range(0, 8, 2)),
-            columns=UInt64Index(range(0, 12, 3)),
-        )
-
-        self.series_floats = Series(
-            np.random.rand(4), index=Float64Index(range(0, 8, 2))
-        )
-        self.frame_floats = DataFrame(
-            np.random.randn(4, 4),
-            index=Float64Index(range(0, 8, 2)),
-            columns=Float64Index(range(0, 12, 3)),
-        )
-
-        m_idces = [
-            MultiIndex.from_product([[1, 2], [3, 4]]),
-            MultiIndex.from_product([[5, 6], [7, 8]]),
-            MultiIndex.from_product([[9, 10], [11, 12]]),
-        ]
-
-        self.series_multi = Series(np.random.rand(4), index=m_idces[0])
-        self.frame_multi = DataFrame(
-            np.random.randn(4, 4), index=m_idces[0], columns=m_idces[1]
-        )
-
-        self.series_labels = Series(np.random.randn(4), index=list("abcd"))
-        self.frame_labels = DataFrame(
-            np.random.randn(4, 4), index=list("abcd"), columns=list("ABCD")
-        )
-
-        self.series_mixed = Series(np.random.randn(4), index=[2, 4, "null", 8])
-        self.frame_mixed = DataFrame(np.random.randn(4, 4), index=[2, 4, "null", 8])
-
-        self.series_ts = Series(
-            np.random.randn(4), index=date_range("20130101", periods=4)
-        )
-        self.frame_ts = DataFrame(
-            np.random.randn(4, 4), index=date_range("20130101", periods=4)
-        )
-
-        dates_rev = date_range("20130101", periods=4).sort_values(ascending=False)
-        self.series_ts_rev = Series(np.random.randn(4), index=dates_rev)
-        self.frame_ts_rev = DataFrame(np.random.randn(4, 4), index=dates_rev)
-
-        self.frame_empty = DataFrame()
-        self.series_empty = Series(dtype=object)
-
-        # form agglomerates
-        for kind in self._kinds:
-            d = {}
-            for typ in self._typs:
-                d[typ] = getattr(self, f"{kind}_{typ}")
-
-            setattr(self, kind, d)
-
-    def generate_indices(self, f, values=False):
-        """
-        generate the indices
-        if values is True , use the axis values
-        is False, use the range
-        """
-        axes = f.axes
-        if values:
-            axes = (list(range(len(ax))) for ax in axes)
-
-        return itertools.product(*axes)
-
-    def get_value(self, name, f, i, values=False):
-        """return the value for the location i"""
-        # check against values
-        if values:
-            return f.values[i]
-
-        elif name == "iat":
-            return f.iloc[i]
-        else:
-            assert name == "at"
-            return f.loc[i]
-
-    def check_values(self, f, func, values=False):
-
-        if f is None:
-            return
-        axes = f.axes
-        indices = itertools.product(*axes)
-
-        for i in indices:
-            result = getattr(f, func)[i]
-
-            # check against values
-            if values:
-                expected = f.values[i]
-            else:
-                expected = f
-                for a in reversed(i):
-                    expected = expected.__getitem__(a)
-
-            tm.assert_almost_equal(result, expected)
-
-    def check_result(self, method, key, typs=None, axes=None, fails=None):
-        def _eq(axis, obj, key):
-            """compare equal for these 2 keys"""
-            axified = _axify(obj, key, axis)
+def check_indexing_smoketest_or_raises(
+    obj,
+    method: Literal["iloc", "loc"],
+    key: Any,
+    axes: Literal[0, 1] | None = None,
+    fails=None,
+) -> None:
+    if axes is None:
+        axes_list = [0, 1]
+    else:
+        assert axes in [0, 1]
+        axes_list = [axes]
+
+    for ax in axes_list:
+        if ax < obj.ndim:
+            # create a tuple accessor
+            new_axes = [slice(None)] * obj.ndim
+            new_axes[ax] = key
+            axified = tuple(new_axes)
             try:
                 getattr(obj, method).__getitem__(axified)
-
             except (IndexError, TypeError, KeyError) as detail:
-
                 # if we are in fails, the ok, otherwise raise it
                 if fails is not None:
                     if isinstance(detail, fails):
                         return
                 raise
-
-        if typs is None:
-            typs = self._typs
-
-        if axes is None:
-            axes = [0, 1]
-        else:
-            assert axes in [0, 1]
-            axes = [axes]
-
-        # check
-        for kind in self._kinds:
-
-            d = getattr(self, kind)
-            for ax in axes:
-                for typ in typs:
-                    assert typ in self._typs
-
-                    obj = d[typ]
-                    if ax < obj.ndim:
-                        _eq(axis=ax, obj=obj, key=key)

pandas/tests/indexing/conftest.py

@@ -0,0 +1,107 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    MultiIndex,
+    Series,
+    date_range,
+)
+from pandas.core.api import (
+    Float64Index,
+    UInt64Index,
+)
+
+
+@pytest.fixture
+def series_ints():
+    return Series(np.random.rand(4), index=np.arange(0, 8, 2))
+
+
+@pytest.fixture
+def frame_ints():
+    return DataFrame(
+        np.random.randn(4, 4), index=np.arange(0, 8, 2), columns=np.arange(0, 12, 3)
+    )
+
+
+@pytest.fixture
+def series_uints():
+    return Series(np.random.rand(4), index=UInt64Index(np.arange(0, 8, 2)))
+
+
+@pytest.fixture
+def frame_uints():
+    return DataFrame(
+        np.random.randn(4, 4),
+        index=UInt64Index(range(0, 8, 2)),
+        columns=UInt64Index(range(0, 12, 3)),
+    )
+
+
+@pytest.fixture
+def series_labels():
+    return Series(np.random.randn(4), index=list("abcd"))
+
+
+@pytest.fixture
+def frame_labels():
+    return DataFrame(np.random.randn(4, 4), index=list("abcd"), columns=list("ABCD"))
+
+
+@pytest.fixture
+def series_ts():
+    return Series(np.random.randn(4), index=date_range("20130101", periods=4))
+
+
+@pytest.fixture
+def frame_ts():
+    return DataFrame(np.random.randn(4, 4), index=date_range("20130101", periods=4))
+
+
+@pytest.fixture
+def series_floats():
+    return Series(np.random.rand(4), index=Float64Index(range(0, 8, 2)))
+
+
+@pytest.fixture
+def frame_floats():
+    return DataFrame(
+        np.random.randn(4, 4),
+        index=Float64Index(range(0, 8, 2)),
+        columns=Float64Index(range(0, 12, 3)),
+    )
+
+
+@pytest.fixture
+def series_mixed():
+    return Series(np.random.randn(4), index=[2, 4, "null", 8])
+
+
+@pytest.fixture
+def frame_mixed():
+    return DataFrame(np.random.randn(4, 4), index=[2, 4, "null", 8])
+
+
+@pytest.fixture
+def frame_empty():
+    return DataFrame()
+
+
+@pytest.fixture
+def series_empty():
+    return Series(dtype=object)
+
+
+@pytest.fixture
+def frame_multi():
+    return DataFrame(
+        np.random.randn(4, 4),
+        index=MultiIndex.from_product([[1, 2], [3, 4]]),
+        columns=MultiIndex.from_product([[5, 6], [7, 8]]),
+    )
+
+
+@pytest.fixture
+def series_multi():
+    return Series(np.random.rand(4), index=MultiIndex.from_product([[1, 2], [3, 4]]))

pandas/tests/indexing/test_iloc.py

@@ -32,7 +32,7 @@
 )
 import pandas._testing as tm
 from pandas.api.types import is_scalar
-from pandas.tests.indexing.common import Base
+from pandas.tests.indexing.common import check_indexing_smoketest_or_raises
 
 # We pass through the error message from numpy
 _slice_iloc_msg = re.escape(
@@ -41,13 +41,19 @@
 )
 
 
-class TestiLoc(Base):
+class TestiLoc:
     @pytest.mark.parametrize("key", [2, -1, [0, 1, 2]])
-    def test_iloc_getitem_int_and_list_int(self, key):
-        self.check_result(
+    @pytest.mark.parametrize("kind", ["series", "frame"])
+    @pytest.mark.parametrize(
+        "col",
+        ["labels", "mixed", "ts", "floats", "empty"],
+    )
+    def test_iloc_getitem_int_and_list_int(self, key, kind, col, request):
+        obj = request.getfixturevalue(f"{kind}_{col}")
+        check_indexing_smoketest_or_raises(
+            obj,
             "iloc",
             key,
-            typs=["labels", "mixed", "ts", "floats", "empty"],
             fails=IndexError,
         )