TST: fixturize indexing intervalindex tests

pandas/conftest.py

@@ -1565,6 +1565,14 @@ def indexer_si(request):
     return request.param
 
 
+@pytest.fixture(params=[tm.setitem, tm.loc])
+def indexer_sl(request):
+    """
+    Parametrize over __setitem__, loc.__setitem__
+    """
+    return request.param
+
+
 @pytest.fixture
 def using_array_manager(request):
     """

pandas/tests/indexing/interval/test_interval.py

@@ -7,87 +7,83 @@
 
 
 class TestIntervalIndex:
-    def setup_method(self, method):
-        self.s = Series(np.arange(5), IntervalIndex.from_breaks(np.arange(6)))
+    @pytest.fixture
+    def series_with_interval_index(self):
+        return Series(np.arange(5), IntervalIndex.from_breaks(np.arange(6)))
 
-    def test_getitem_with_scalar(self):
+    def test_getitem_with_scalar(self, series_with_interval_index, indexer_sl):
 
-        s = self.s
+        ser = series_with_interval_index.copy()
 
-        expected = s.iloc[:3]
-        tm.assert_series_equal(expected, s[:3])
-        tm.assert_series_equal(expected, s[:2.5])
-        tm.assert_series_equal(expected, s[0.1:2.5])
+        expected = ser.iloc[:3]
+        tm.assert_series_equal(expected, indexer_sl(ser)[:3])
+        tm.assert_series_equal(expected, indexer_sl(ser)[:2.5])
+        tm.assert_series_equal(expected, indexer_sl(ser)[0.1:2.5])
+        if indexer_sl is tm.loc:
+            tm.assert_series_equal(expected, ser.loc[-1:3])
 
-        expected = s.iloc[1:4]
-        tm.assert_series_equal(expected, s[[1.5, 2.5, 3.5]])
-        tm.assert_series_equal(expected, s[[2, 3, 4]])
-        tm.assert_series_equal(expected, s[[1.5, 3, 4]])
+        expected = ser.iloc[1:4]
+        tm.assert_series_equal(expected, indexer_sl(ser)[[1.5, 2.5, 3.5]])
+        tm.assert_series_equal(expected, indexer_sl(ser)[[2, 3, 4]])
+        tm.assert_series_equal(expected, indexer_sl(ser)[[1.5, 3, 4]])
 
-        expected = s.iloc[2:5]
-        tm.assert_series_equal(expected, s[s >= 2])
+        expected = ser.iloc[2:5]
+        tm.assert_series_equal(expected, indexer_sl(ser)[ser >= 2])
 
     @pytest.mark.parametrize("direction", ["increasing", "decreasing"])
-    def test_nonoverlapping_monotonic(self, direction, closed):
+    def test_nonoverlapping_monotonic(self, direction, closed, indexer_sl):
         tpls = [(0, 1), (2, 3), (4, 5)]
         if direction == "decreasing":
             tpls = tpls[::-1]
 
         idx = IntervalIndex.from_tuples(tpls, closed=closed)
-        s = Series(list("abc"), idx)
+        ser = Series(list("abc"), idx)
 
-        for key, expected in zip(idx.left, s):
+        for key, expected in zip(idx.left, ser):
             if idx.closed_left:
-                assert s[key] == expected
-                assert s.loc[key] == expected
+                assert indexer_sl(ser)[key] == expected
             else:
                 with pytest.raises(KeyError, match=str(key)):
-                    s[key]
-                with pytest.raises(KeyError, match=str(key)):
-                    s.loc[key]
+                    indexer_sl(ser)[key]
 
-        for key, expected in zip(idx.right, s):
+        for key, expected in zip(idx.right, ser):
             if idx.closed_right:
-                assert s[key] == expected
-                assert s.loc[key] == expected
+                assert indexer_sl(ser)[key] == expected
             else:
                 with pytest.raises(KeyError, match=str(key)):
-                    s[key]
-                with pytest.raises(KeyError, match=str(key)):
-                    s.loc[key]
+                    indexer_sl(ser)[key]
 
-        for key, expected in zip(idx.mid, s):
-            assert s[key] == expected
-            assert s.loc[key] == expected
+        for key, expected in zip(idx.mid, ser):
+            assert indexer_sl(ser)[key] == expected
 
-    def test_non_matching(self):
-        s = self.s
+    def test_non_matching(self, series_with_interval_index, indexer_sl):
+        ser = series_with_interval_index.copy()
 
         # this is a departure from our current
         # indexing scheme, but simpler
         with pytest.raises(KeyError, match=r"^\[-1\]$"):
-            s.loc[[-1, 3, 4, 5]]
+            indexer_sl(ser)[[-1, 3, 4, 5]]
 
         with pytest.raises(KeyError, match=r"^\[-1\]$"):
-            s.loc[[-1, 3]]
+            indexer_sl(ser)[[-1, 3]]
 
     @pytest.mark.arm_slow
     def test_large_series(self):
-        s = Series(
+        ser = Series(
             np.arange(1000000), index=IntervalIndex.from_breaks(np.arange(1000001))
         )
 
-        result1 = s.loc[:80000]
-        result2 = s.loc[0:80000]
-        result3 = s.loc[0:80000:1]
+        result1 = ser.loc[:80000]
+        result2 = ser.loc[0:80000]
+        result3 = ser.loc[0:80000:1]
         tm.assert_series_equal(result1, result2)
         tm.assert_series_equal(result1, result3)
 
     def test_loc_getitem_frame(self):
         # CategoricalIndex with IntervalIndex categories
         df = DataFrame({"A": range(10)})
-        s = pd.cut(df.A, 5)
-        df["B"] = s
+        ser = pd.cut(df.A, 5)
+        df["B"] = ser
         df = df.set_index("B")
 
         result = df.loc[4]