TST/REF: collect Index setop, indexing tests

pandas/tests/indexes/common.py

@@ -363,6 +363,7 @@ def test_numpy_argsort(self, index):
         # cannot be changed at the moment due to
         # backwards compatibility concerns
         if isinstance(type(index), (CategoricalIndex, RangeIndex)):
+            # TODO: why type(index)?
             msg = "the 'axis' parameter is not supported"
             with pytest.raises(ValueError, match=msg):
                 np.argsort(index, axis=1)
@@ -375,49 +376,6 @@ def test_numpy_argsort(self, index):
             with pytest.raises(ValueError, match=msg):
                 np.argsort(index, order=("a", "b"))
 
-    def test_take(self, index):
-        indexer = [4, 3, 0, 2]
-        if len(index) < 5:
-            # not enough elements; ignore
-            return
-
-        result = index.take(indexer)
-        expected = index[indexer]
-        assert result.equals(expected)
-
-        if not isinstance(index, (DatetimeIndex, PeriodIndex, TimedeltaIndex)):
-            # GH 10791
-            msg = r"'(.*Index)' object has no attribute 'freq'"
-            with pytest.raises(AttributeError, match=msg):
-                index.freq
-
-    def test_take_invalid_kwargs(self):
-        idx = self.create_index()
-        indices = [1, 2]
-
-        msg = r"take\(\) got an unexpected keyword argument 'foo'"
-        with pytest.raises(TypeError, match=msg):
-            idx.take(indices, foo=2)
-
-        msg = "the 'out' parameter is not supported"
-        with pytest.raises(ValueError, match=msg):
-            idx.take(indices, out=indices)
-
-        msg = "the 'mode' parameter is not supported"
-        with pytest.raises(ValueError, match=msg):
-            idx.take(indices, mode="clip")
-
-    def test_take_minus1_without_fill(self, index):
-        # -1 does not get treated as NA unless allow_fill=True is passed
-        if len(index) == 0:
-            # Test is not applicable
-            return
-
-        result = index.take([0, 0, -1])
-
-        expected = index.take([0, 0, len(index) - 1])
-        tm.assert_index_equal(result, expected)
-
     def test_repeat(self):
         rep = 2
         i = self.create_index()
@@ -456,117 +414,6 @@ def test_where(self, klass):
         result = i.where(klass(cond))
         tm.assert_index_equal(result, expected)
 
-    @pytest.mark.parametrize("case", [0.5, "xxx"])
-    @pytest.mark.parametrize(
-        "method", ["intersection", "union", "difference", "symmetric_difference"]
-    )
-    def test_set_ops_error_cases(self, case, method, index):
-        # non-iterable input
-        msg = "Input must be Index or array-like"
-        with pytest.raises(TypeError, match=msg):
-            getattr(index, method)(case)
-
-    def test_intersection_base(self, index):
-        if isinstance(index, CategoricalIndex):
-            return
-
-        first = index[:5]
-        second = index[:3]
-        intersect = first.intersection(second)
-        assert tm.equalContents(intersect, second)
-
-        if is_datetime64tz_dtype(index.dtype):
-            # The second.values below will drop tz, so the rest of this test
-            #  is not applicable.
-            return
-
-        # GH 10149
-        cases = [klass(second.values) for klass in [np.array, Series, list]]
-        for case in cases:
-            result = first.intersection(case)
-            assert tm.equalContents(result, second)
-
-        if isinstance(index, MultiIndex):
-            msg = "other must be a MultiIndex or a list of tuples"
-            with pytest.raises(TypeError, match=msg):
-                first.intersection([1, 2, 3])
-
-    def test_union_base(self, index):
-        first = index[3:]
-        second = index[:5]
-        everything = index
-        union = first.union(second)
-        assert tm.equalContents(union, everything)
-
-        if is_datetime64tz_dtype(index.dtype):
-            # The second.values below will drop tz, so the rest of this test
-            #  is not applicable.
-            return
-
-        # GH 10149
-        cases = [klass(second.values) for klass in [np.array, Series, list]]
-        for case in cases:
-            if not isinstance(index, CategoricalIndex):
-                result = first.union(case)
-                assert tm.equalContents(result, everything), (
-                    result,
-                    everything,
-                    type(case),
-                )
-
-        if isinstance(index, MultiIndex):
-            msg = "other must be a MultiIndex or a list of tuples"
-            with pytest.raises(TypeError, match=msg):
-                first.union([1, 2, 3])
-
-    def test_difference_base(self, sort, index):
-        first = index[2:]
-        second = index[:4]
-        if isinstance(index, CategoricalIndex) or index.is_boolean():
-            answer = []
-        else:
-            answer = index[4:]
-        result = first.difference(second, sort)
-        assert tm.equalContents(result, answer)
-
-        # GH 10149
-        cases = [klass(second.values) for klass in [np.array, Series, list]]
-        for case in cases:
-            if isinstance(index, (DatetimeIndex, TimedeltaIndex)):
-                assert type(result) == type(answer)
-                tm.assert_numpy_array_equal(
-                    result.sort_values().asi8, answer.sort_values().asi8
-                )
-            else:
-                result = first.difference(case, sort)
-                assert tm.equalContents(result, answer)
-
-        if isinstance(index, MultiIndex):
-            msg = "other must be a MultiIndex or a list of tuples"
-            with pytest.raises(TypeError, match=msg):
-                first.difference([1, 2, 3], sort)
-
-    def test_symmetric_difference(self, index):
-        if isinstance(index, CategoricalIndex):
-            return
-
-        first = index[1:]
-        second = index[:-1]
-        answer = index[[0, -1]]
-        result = first.symmetric_difference(second)
-        assert tm.equalContents(result, answer)
-
-        # GH 10149
-        cases = [klass(second.values) for klass in [np.array, Series, list]]
-        for case in cases:
-            result = first.symmetric_difference(case)
-            assert tm.equalContents(result, answer)
-
-        if isinstance(index, MultiIndex):
-            msg = "other must be a MultiIndex or a list of tuples"
-            with pytest.raises(TypeError, match=msg):
-                first.symmetric_difference([1, 2, 3])
-
     def test_insert_base(self, index):
         result = index[1:4]
 
@@ -601,7 +448,8 @@ def test_delete_base(self, index):
 
     def test_equals(self, index):
         if isinstance(index, IntervalIndex):
-            # IntervalIndex tested separately
+            # IntervalIndex tested separately, the index.equals(index.astype(object))
+            #  fails for IntervalIndex
             return
 
         assert index.equals(index)

pandas/tests/indexes/numeric/test_indexing.py

@@ -1,7 +1,7 @@
 import numpy as np
 import pytest
 
-from pandas import Float64Index, Int64Index, Series, UInt64Index
+from pandas import Float64Index, Index, Int64Index, Series, UInt64Index
 import pandas._testing as tm
 
 
@@ -241,3 +241,20 @@ def test_contains_float64_nans(self):
     def test_contains_float64_not_nans(self):
         index = Float64Index([1.0, 2.0, np.nan])
         assert 1.0 in index
+
+
+class TestGetSliceBounds:
+    @pytest.mark.parametrize("kind", ["getitem", "loc", None])
+    @pytest.mark.parametrize("side, expected", [("left", 4), ("right", 5)])
+    def test_get_slice_bounds_within(self, kind, side, expected):
+        index = Index(range(6))
+        result = index.get_slice_bound(4, kind=kind, side=side)
+        assert result == expected
+
+    @pytest.mark.parametrize("kind", ["getitem", "loc", None])
+    @pytest.mark.parametrize("side", ["left", "right"])
+    @pytest.mark.parametrize("bound, expected", [(-1, 0), (10, 6)])
+    def test_get_slice_bounds_outside(self, kind, side, expected, bound):
+        index = Index(range(6))
+        result = index.get_slice_bound(bound, kind=kind, side=side)
+        assert result == expected

pandas/tests/indexes/test_base.py

@@ -1082,27 +1082,6 @@ def test_symmetric_difference_non_index(self, sort):
         assert tm.equalContents(result, expected)
         assert result.name == "new_name"
 
-    def test_difference_type(self, index, sort):
-        # GH 20040
-        # If taking difference of a set and itself, it
-        # needs to preserve the type of the index
-        if not index.is_unique:
-            return
-        result = index.difference(index, sort=sort)
-        expected = index.drop(index)
-        tm.assert_index_equal(result, expected)
-
-    def test_intersection_difference(self, index, sort):
-        # GH 20040
-        # Test that the intersection of an index with an
-        # empty index produces the same index as the difference
-        # of an index with itself.  Test for all types
-        if not index.is_unique:
-            return
-        inter = index.intersection(index.drop(index))
-        diff = index.difference(index, sort=sort)
-        tm.assert_index_equal(inter, diff)
-
     def test_is_mixed_deprecated(self):
         # GH#32922
         index = self.create_index()

pandas/tests/indexes/test_common.py

@@ -71,139 +71,6 @@ def test_getitem_error(self, index, itm):
         with pytest.raises(IndexError):
             index[itm]
 
-    @pytest.mark.parametrize(
-        "fname, sname, expected_name",
-        [
-            ("A", "A", "A"),
-            ("A", "B", None),
-            ("A", None, None),
-            (None, "B", None),
-            (None, None, None),
-        ],
-    )
-    def test_corner_union(self, index, fname, sname, expected_name):
-        # GH 9943 9862
-        # Test unions with various name combinations
-        # Do not test MultiIndex or repeats
-
-        if isinstance(index, MultiIndex) or not index.is_unique:
-            pytest.skip("Not for MultiIndex or repeated indices")
-
-        # Test copy.union(copy)
-        first = index.copy().set_names(fname)
-        second = index.copy().set_names(sname)
-        union = first.union(second)
-        expected = index.copy().set_names(expected_name)
-        tm.assert_index_equal(union, expected)
-
-        # Test copy.union(empty)
-        first = index.copy().set_names(fname)
-        second = index.drop(index).set_names(sname)
-        union = first.union(second)
-        expected = index.copy().set_names(expected_name)
-        tm.assert_index_equal(union, expected)
-
-        # Test empty.union(copy)
-        first = index.drop(index).set_names(fname)
-        second = index.copy().set_names(sname)
-        union = first.union(second)
-        expected = index.copy().set_names(expected_name)
-        tm.assert_index_equal(union, expected)
-
-        # Test empty.union(empty)
-        first = index.drop(index).set_names(fname)
-        second = index.drop(index).set_names(sname)
-        union = first.union(second)
-        expected = index.drop(index).set_names(expected_name)
-        tm.assert_index_equal(union, expected)
-
-    @pytest.mark.parametrize(
-        "fname, sname, expected_name",
-        [
-            ("A", "A", "A"),
-            ("A", "B", None),
-            ("A", None, None),
-            (None, "B", None),
-            (None, None, None),
-        ],
-    )
-    def test_union_unequal(self, index, fname, sname, expected_name):
-        if isinstance(index, MultiIndex) or not index.is_unique:
-            pytest.skip("Not for MultiIndex or repeated indices")
-
-        # test copy.union(subset) - need sort for unicode and string
-        first = index.copy().set_names(fname)
-        second = index[1:].set_names(sname)
-        union = first.union(second).sort_values()
-        expected = index.set_names(expected_name).sort_values()
-        tm.assert_index_equal(union, expected)
-
-    @pytest.mark.parametrize(
-        "fname, sname, expected_name",
-        [
-            ("A", "A", "A"),
-            ("A", "B", None),
-            ("A", None, None),
-            (None, "B", None),
-            (None, None, None),
-        ],
-    )
-    def test_corner_intersect(self, index, fname, sname, expected_name):
-        # GH35847
-        # Test intersections with various name combinations
-
-        if isinstance(index, MultiIndex) or not index.is_unique:
-            pytest.skip("Not for MultiIndex or repeated indices")
-
-        # Test copy.intersection(copy)
-        first = index.copy().set_names(fname)
-        second = index.copy().set_names(sname)
-        intersect = first.intersection(second)
-        expected = index.copy().set_names(expected_name)
-        tm.assert_index_equal(intersect, expected)
-
-        # Test copy.intersection(empty)
-        first = index.copy().set_names(fname)
-        second = index.drop(index).set_names(sname)
-        intersect = first.intersection(second)
-        expected = index.drop(index).set_names(expected_name)
-        tm.assert_index_equal(intersect, expected)
-
-        # Test empty.intersection(copy)
-        first = index.drop(index).set_names(fname)
-        second = index.copy().set_names(sname)
-        intersect = first.intersection(second)
-        expected = index.drop(index).set_names(expected_name)
-        tm.assert_index_equal(intersect, expected)
-
-        # Test empty.intersection(empty)
-        first = index.drop(index).set_names(fname)
-        second = index.drop(index).set_names(sname)
-        intersect = first.intersection(second)
-        expected = index.drop(index).set_names(expected_name)
-        tm.assert_index_equal(intersect, expected)
-
-    @pytest.mark.parametrize(
-        "fname, sname, expected_name",
-        [
-            ("A", "A", "A"),
-            ("A", "B", None),
-            ("A", None, None),
-            (None, "B", None),
-            (None, None, None),
-        ],
-    )
-    def test_intersect_unequal(self, index, fname, sname, expected_name):
-        if isinstance(index, MultiIndex) or not index.is_unique:
-            pytest.skip("Not for MultiIndex or repeated indices")
-
-        # test copy.intersection(subset) - need sort for unicode and string
-        first = index.copy().set_names(fname)
-        second = index[1:].set_names(sname)
-        intersect = first.intersection(second).sort_values()
-        expected = index[1:].set_names(expected_name).sort_values()
-        tm.assert_index_equal(intersect, expected)
-
     def test_to_flat_index(self, index):
         # 22866
         if isinstance(index, MultiIndex):
@@ -329,13 +196,6 @@ def test_get_unique_index(self, index):
                 result = i._get_unique_index(dropna=dropna)
                 tm.assert_index_equal(result, expected)
 
-    def test_mutability(self, index):
-        if not len(index):
-            pytest.skip("Skip check for empty Index")
-        msg = "Index does not support mutable operations"
-        with pytest.raises(TypeError, match=msg):
-            index[0] = index[0]
-
     def test_view(self, index):
         assert index.view().name == index.name