TST/REF: collect index tests (#39485)

Author: jbrockmendel

pandas/tests/indexes/common.py

@@ -5,7 +5,6 @@
 import pytest
 
 from pandas._libs import iNaT
-from pandas.errors import InvalidIndexError
 
 from pandas.core.dtypes.common import is_datetime64tz_dtype
 from pandas.core.dtypes.dtypes import CategoricalDtype
@@ -202,25 +201,6 @@ def test_reindex_base(self):
         with pytest.raises(ValueError, match="Invalid fill method"):
             idx.get_indexer(idx, method="invalid")
 
-    def test_get_indexer_consistency(self, index):
-        # See GH 16819
-        if isinstance(index, IntervalIndex):
-            # requires index.is_non_overlapping
-            return
-
-        if index.is_unique:
-            indexer = index.get_indexer(index[0:2])
-            assert isinstance(indexer, np.ndarray)
-            assert indexer.dtype == np.intp
-        else:
-            e = "Reindexing only valid with uniquely valued Index objects"
-            with pytest.raises(InvalidIndexError, match=e):
-                index.get_indexer(index[0:2])
-
-        indexer, _ = index.get_indexer_non_unique(index[0:2])
-        assert isinstance(indexer, np.ndarray)
-        assert indexer.dtype == np.intp
-
     def test_ndarray_compat_properties(self):
         idx = self.create_index()
         assert idx.T.equals(idx)

pandas/tests/indexes/datetimelike_/test_indexing.py

@@ -0,0 +1,43 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import DatetimeIndex, Index
+import pandas._testing as tm
+
+dtlike_dtypes = [
+    np.dtype("timedelta64[ns]"),
+    np.dtype("datetime64[ns]"),
+    pd.DatetimeTZDtype("ns", "Asia/Tokyo"),
+    pd.PeriodDtype("ns"),
+]
+
+
+@pytest.mark.parametrize("ldtype", dtlike_dtypes)
+@pytest.mark.parametrize("rdtype", dtlike_dtypes)
+def test_get_indexer_non_unique_wrong_dtype(ldtype, rdtype):
+
+    vals = np.tile(3600 * 10 ** 9 * np.arange(3), 2)
+
+    def construct(dtype):
+        if dtype is dtlike_dtypes[-1]:
+            # PeriodArray will try to cast ints to strings
+            return DatetimeIndex(vals).astype(dtype)
+        return Index(vals, dtype=dtype)
+
+    left = construct(ldtype)
+    right = construct(rdtype)
+
+    result = left.get_indexer_non_unique(right)
+
+    if ldtype is rdtype:
+        ex1 = np.array([0, 3, 1, 4, 2, 5] * 2, dtype=np.intp)
+        ex2 = np.array([], dtype=np.intp)
+        tm.assert_numpy_array_equal(result[0], ex1)
+        tm.assert_numpy_array_equal(result[1], ex2)
+
+    else:
+        no_matches = np.array([-1] * 6, dtype=np.intp)
+        missing = np.arange(6, dtype=np.intp)
+        tm.assert_numpy_array_equal(result[0], no_matches)
+        tm.assert_numpy_array_equal(result[1], missing)

pandas/tests/indexes/numeric/test_indexing.py

@@ -1,7 +1,7 @@
 import numpy as np
 import pytest
 
-from pandas import Float64Index, Index, Int64Index, Series, UInt64Index
+from pandas import Float64Index, Index, Int64Index, RangeIndex, Series, UInt64Index
 import pandas._testing as tm
 
 
@@ -13,6 +13,54 @@ def index_large():
 
 
 class TestGetLoc:
+    @pytest.mark.parametrize("method", [None, "pad", "backfill", "nearest"])
+    def test_get_loc(self, method):
+        index = Index([0, 1, 2])
+        assert index.get_loc(1, method=method) == 1
+
+        if method:
+            assert index.get_loc(1, method=method, tolerance=0) == 1
+
+    @pytest.mark.parametrize("method", [None, "pad", "backfill", "nearest"])
+    def test_get_loc_raises_bad_label(self, method):
+        index = Index([0, 1, 2])
+        if method:
+            msg = "not supported between"
+        else:
+            msg = "invalid key"
+
+        with pytest.raises(TypeError, match=msg):
+            index.get_loc([1, 2], method=method)
+
+    @pytest.mark.parametrize(
+        "method,loc", [("pad", 1), ("backfill", 2), ("nearest", 1)]
+    )
+    def test_get_loc_tolerance(self, method, loc):
+        index = Index([0, 1, 2])
+        assert index.get_loc(1.1, method) == loc
+        assert index.get_loc(1.1, method, tolerance=1) == loc
+
+    @pytest.mark.parametrize("method", ["pad", "backfill", "nearest"])
+    def test_get_loc_outside_tolerance_raises(self, method):
+        index = Index([0, 1, 2])
+        with pytest.raises(KeyError, match="1.1"):
+            index.get_loc(1.1, method, tolerance=0.05)
+
+    def test_get_loc_bad_tolerance_raises(self):
+        index = Index([0, 1, 2])
+        with pytest.raises(ValueError, match="must be numeric"):
+            index.get_loc(1.1, "nearest", tolerance="invalid")
+
+    def test_get_loc_tolerance_no_method_raises(self):
+        index = Index([0, 1, 2])
+        with pytest.raises(ValueError, match="tolerance .* valid if"):
+            index.get_loc(1.1, tolerance=1)
+
+    def test_get_loc_raises_missized_tolerance(self):
+        index = Index([0, 1, 2])
+        with pytest.raises(ValueError, match="tolerance size must match"):
+            index.get_loc(1.1, "nearest", tolerance=[1, 1])
+
     def test_get_loc_float64(self):
         idx = Float64Index([0.0, 1.0, 2.0])
         for method in [None, "pad", "backfill", "nearest"]:
@@ -82,6 +130,131 @@ def test_get_loc_missing_nan(self):
 
 
 class TestGetIndexer:
+    def test_get_indexer(self):
+        index1 = Index([1, 2, 3, 4, 5])
+        index2 = Index([2, 4, 6])
+
+        r1 = index1.get_indexer(index2)
+        e1 = np.array([1, 3, -1], dtype=np.intp)
+        tm.assert_almost_equal(r1, e1)
+
+    @pytest.mark.parametrize("reverse", [True, False])
+    @pytest.mark.parametrize(
+        "expected,method",
+        [
+            (np.array([-1, 0, 0, 1, 1], dtype=np.intp), "pad"),
+            (np.array([-1, 0, 0, 1, 1], dtype=np.intp), "ffill"),
+            (np.array([0, 0, 1, 1, 2], dtype=np.intp), "backfill"),
+            (np.array([0, 0, 1, 1, 2], dtype=np.intp), "bfill"),
+        ],
+    )
+    def test_get_indexer_methods(self, reverse, expected, method):
+        index1 = Index([1, 2, 3, 4, 5])
+        index2 = Index([2, 4, 6])
+
+        if reverse:
+            index1 = index1[::-1]
+            expected = expected[::-1]
+
+        result = index2.get_indexer(index1, method=method)
+        tm.assert_almost_equal(result, expected)
+
+    def test_get_indexer_invalid(self):
+        # GH10411
+        index = Index(np.arange(10))
+
+        with pytest.raises(ValueError, match="tolerance argument"):
+            index.get_indexer([1, 0], tolerance=1)
+
+        with pytest.raises(ValueError, match="limit argument"):
+            index.get_indexer([1, 0], limit=1)
+
+    @pytest.mark.parametrize(
+        "method, tolerance, indexer, expected",
+        [
+            ("pad", None, [0, 5, 9], [0, 5, 9]),
+            ("backfill", None, [0, 5, 9], [0, 5, 9]),
+            ("nearest", None, [0, 5, 9], [0, 5, 9]),
+            ("pad", 0, [0, 5, 9], [0, 5, 9]),
+            ("backfill", 0, [0, 5, 9], [0, 5, 9]),
+            ("nearest", 0, [0, 5, 9], [0, 5, 9]),
+            ("pad", None, [0.2, 1.8, 8.5], [0, 1, 8]),
+            ("backfill", None, [0.2, 1.8, 8.5], [1, 2, 9]),
+            ("nearest", None, [0.2, 1.8, 8.5], [0, 2, 9]),
+            ("pad", 1, [0.2, 1.8, 8.5], [0, 1, 8]),
+            ("backfill", 1, [0.2, 1.8, 8.5], [1, 2, 9]),
+            ("nearest", 1, [0.2, 1.8, 8.5], [0, 2, 9]),
+            ("pad", 0.2, [0.2, 1.8, 8.5], [0, -1, -1]),
+            ("backfill", 0.2, [0.2, 1.8, 8.5], [-1, 2, -1]),
+            ("nearest", 0.2, [0.2, 1.8, 8.5], [0, 2, -1]),
+        ],
+    )
+    def test_get_indexer_nearest(self, method, tolerance, indexer, expected):
+        index = Index(np.arange(10))
+
+        actual = index.get_indexer(indexer, method=method, tolerance=tolerance)
+        tm.assert_numpy_array_equal(actual, np.array(expected, dtype=np.intp))
+
+    @pytest.mark.parametrize("listtype", [list, tuple, Series, np.array])
+    @pytest.mark.parametrize(
+        "tolerance, expected",
+        list(
+            zip(
+                [[0.3, 0.3, 0.1], [0.2, 0.1, 0.1], [0.1, 0.5, 0.5]],
+                [[0, 2, -1], [0, -1, -1], [-1, 2, 9]],
+            )
+        ),
+    )
+    def test_get_indexer_nearest_listlike_tolerance(
+        self, tolerance, expected, listtype
+    ):
+        index = Index(np.arange(10))
+
+        actual = index.get_indexer(
+            [0.2, 1.8, 8.5], method="nearest", tolerance=listtype(tolerance)
+        )
+        tm.assert_numpy_array_equal(actual, np.array(expected, dtype=np.intp))
+
+    def test_get_indexer_nearest_error(self):
+        index = Index(np.arange(10))
+        with pytest.raises(ValueError, match="limit argument"):
+            index.get_indexer([1, 0], method="nearest", limit=1)
+
+        with pytest.raises(ValueError, match="tolerance size must match"):
+            index.get_indexer([1, 0], method="nearest", tolerance=[1, 2, 3])
+
+    @pytest.mark.parametrize(
+        "method,expected",
+        [("pad", [8, 7, 0]), ("backfill", [9, 8, 1]), ("nearest", [9, 7, 0])],
+    )
+    def test_get_indexer_nearest_decreasing(self, method, expected):
+        index = Index(np.arange(10))[::-1]
+
+        actual = index.get_indexer([0, 5, 9], method=method)
+        tm.assert_numpy_array_equal(actual, np.array([9, 4, 0], dtype=np.intp))
+
+        actual = index.get_indexer([0.2, 1.8, 8.5], method=method)
+        tm.assert_numpy_array_equal(actual, np.array(expected, dtype=np.intp))
+
+    @pytest.mark.parametrize(
+        "idx_class", [Int64Index, RangeIndex, Float64Index, UInt64Index]
+    )
+    @pytest.mark.parametrize("method", ["get_indexer", "get_indexer_non_unique"])
+    def test_get_indexer_numeric_index_boolean_target(self, method, idx_class):
+        # GH 16877
+
+        numeric_index = idx_class(RangeIndex(4))
+        other = Index([True, False, True])
+
+        result = getattr(numeric_index, method)(other)
+        expected = np.array([-1, -1, -1], dtype=np.intp)
+        if method == "get_indexer":
+            tm.assert_numpy_array_equal(result, expected)
+        else:
+            missing = np.arange(3, dtype=np.intp)
+            tm.assert_numpy_array_equal(result[0], expected)
+            tm.assert_numpy_array_equal(result[1], missing)
+
     @pytest.mark.parametrize("method", ["pad", "backfill", "nearest"])
     def test_get_indexer_with_method_numeric_vs_bool(self, method):
         left = Index([1, 2, 3])
@@ -274,6 +447,62 @@ def test_contains_float64_not_nans(self):
         assert 1.0 in index
 
 
+class TestSliceLocs:
+    @pytest.mark.parametrize("dtype", [int, float])
+    def test_slice_locs(self, dtype):
+        index = Index(np.array([0, 1, 2, 5, 6, 7, 9, 10], dtype=dtype))
+        n = len(index)
+
+        assert index.slice_locs(start=2) == (2, n)
+        assert index.slice_locs(start=3) == (3, n)
+        assert index.slice_locs(3, 8) == (3, 6)
+        assert index.slice_locs(5, 10) == (3, n)
+        assert index.slice_locs(end=8) == (0, 6)
+        assert index.slice_locs(end=9) == (0, 7)
+
+        # reversed
+        index2 = index[::-1]
+        assert index2.slice_locs(8, 2) == (2, 6)
+        assert index2.slice_locs(7, 3) == (2, 5)
+
+    @pytest.mark.parametrize("dtype", [int, float])
+    def test_slice_locs_float_locs(self, dtype):
+        index = Index(np.array([0, 1, 2, 5, 6, 7, 9, 10], dtype=dtype))
+        n = len(index)
+        assert index.slice_locs(5.0, 10.0) == (3, n)
+        assert index.slice_locs(4.5, 10.5) == (3, 8)
+
+        index2 = index[::-1]
+        assert index2.slice_locs(8.5, 1.5) == (2, 6)
+        assert index2.slice_locs(10.5, -1) == (0, n)
+
+    @pytest.mark.parametrize("dtype", [int, float])
+    def test_slice_locs_dup_numeric(self, dtype):
+        index = Index(np.array([10, 12, 12, 14], dtype=dtype))
+        assert index.slice_locs(12, 12) == (1, 3)
+        assert index.slice_locs(11, 13) == (1, 3)
+
+        index2 = index[::-1]
+        assert index2.slice_locs(12, 12) == (1, 3)
+        assert index2.slice_locs(13, 11) == (1, 3)
+
+    def test_slice_locs_na(self):
+        index = Index([np.nan, 1, 2])
+        assert index.slice_locs(1) == (1, 3)
+        assert index.slice_locs(np.nan) == (0, 3)
+
+        index = Index([0, np.nan, np.nan, 1, 2])
+        assert index.slice_locs(np.nan) == (1, 5)
+
+    def test_slice_locs_na_raises(self):
+        index = Index([np.nan, 1, 2])
+        with pytest.raises(KeyError, match=""):
+            index.slice_locs(start=1.5)
+
+        with pytest.raises(KeyError, match=""):
+            index.slice_locs(end=1.5)
+
+
 class TestGetSliceBounds:
     @pytest.mark.parametrize("kind", ["getitem", "loc", None])
     @pytest.mark.parametrize("side, expected", [("left", 4), ("right", 5)])

pandas/tests/indexes/numeric/test_setops.py

@@ -110,6 +110,24 @@ def test_intersection_monotonic(self, index2, keeps_name, sort):
             expected = expected.sort_values()
         tm.assert_index_equal(result, expected)
 
+    def test_symmetric_difference(self, sort):
+        # smoke
+        index1 = Index([5, 2, 3, 4], name="index1")
+        index2 = Index([2, 3, 4, 1])
+        result = index1.symmetric_difference(index2, sort=sort)
+        expected = Index([5, 1])
+        assert tm.equalContents(result, expected)
+        assert result.name is None
+        if sort is None:
+            expected = expected.sort_values()
+        tm.assert_index_equal(result, expected)
+
+        # __xor__ syntax
+        with tm.assert_produces_warning(FutureWarning):
+            expected = index1 ^ index2
+        assert tm.equalContents(result, expected)
+        assert result.name is None
+
 
 class TestSetOpsSort:
     @pytest.mark.parametrize("slice_", [slice(None), slice(0)])