From 8ef1fca52ffa648a6daf5ee1982e33f2aff81e59 Mon Sep 17 00:00:00 2001
From: Matthew Roeschke <10647082+mroeschke@users.noreply.github.com>
Date: Fri, 24 Nov 2023 11:12:20 -0800
Subject: [PATCH 1/2] TST/CLN: make equalContents more strict

---
 pandas/_testing/__init__.py                   |  7 --
 pandas/tests/frame/indexing/test_indexing.py  |  2 +-
 .../tests/frame/methods/test_combine_first.py |  2 +-
 pandas/tests/frame/methods/test_reindex.py    |  4 +-
 pandas/tests/frame/test_iteration.py          |  2 +-
 pandas/tests/indexes/datetimes/test_setops.py |  4 +-
 pandas/tests/indexes/interval/test_setops.py  | 30 ++++----
 pandas/tests/indexes/multi/test_setops.py     | 15 ++--
 pandas/tests/indexes/numeric/test_setops.py   |  5 +-
 pandas/tests/indexes/period/test_setops.py    | 10 +--
 pandas/tests/indexes/test_base.py             |  6 +-
 pandas/tests/indexes/test_setops.py           | 69 ++++++++++++-------
 .../tests/indexes/timedeltas/test_setops.py   |  2 +-
 pandas/tests/io/test_sql.py                   |  8 +--
 pandas/tests/series/indexing/test_indexing.py |  2 +-
 pandas/tests/series/test_arithmetic.py        |  6 +-
 pandas/tests/series/test_constructors.py      |  2 +-
 17 files changed, 101 insertions(+), 75 deletions(-)

diff --git a/pandas/_testing/__init__.py b/pandas/_testing/__init__.py
index 832919db442d4..264dafcebe3dc 100644
--- a/pandas/_testing/__init__.py
+++ b/pandas/_testing/__init__.py
@@ -302,13 +302,6 @@ def reset_display_options() -> None:
 # Comparators
 
 
-def equalContents(arr1, arr2) -> bool:
-    """
-    Checks if the set of unique elements of arr1 and arr2 are equivalent.
-    """
-    return frozenset(arr1) == frozenset(arr2)
-
-
 def box_expected(expected, box_cls, transpose: bool = True):
     """
     Helper function to wrap the expected output of a test in a given box_class.
diff --git a/pandas/tests/frame/indexing/test_indexing.py b/pandas/tests/frame/indexing/test_indexing.py
index b2d94ff5ffbd1..135a86cad1395 100644
--- a/pandas/tests/frame/indexing/test_indexing.py
+++ b/pandas/tests/frame/indexing/test_indexing.py
@@ -48,7 +48,7 @@ def test_getitem(self, float_frame):
         # Column access
         for _, series in sl.items():
             assert len(series.index) == 20
-            assert tm.equalContents(series.index, sl.index)
+            tm.assert_index_equal(series.index, sl.index)
 
         for key, _ in float_frame._series.items():
             assert float_frame[key] is not None
diff --git a/pandas/tests/frame/methods/test_combine_first.py b/pandas/tests/frame/methods/test_combine_first.py
index 1779f703dd2b7..0335279b3a123 100644
--- a/pandas/tests/frame/methods/test_combine_first.py
+++ b/pandas/tests/frame/methods/test_combine_first.py
@@ -37,7 +37,7 @@ def test_combine_first(self, float_frame):
         combined = head.combine_first(tail)
         reordered_frame = float_frame.reindex(combined.index)
         tm.assert_frame_equal(combined, reordered_frame)
-        assert tm.equalContents(combined.columns, float_frame.columns)
+        tm.assert_index_equal(combined.columns, float_frame.columns)
         tm.assert_series_equal(combined["A"], reordered_frame["A"])
 
         # same index
diff --git a/pandas/tests/frame/methods/test_reindex.py b/pandas/tests/frame/methods/test_reindex.py
index b57b4f4422888..b6a6334b89fc1 100644
--- a/pandas/tests/frame/methods/test_reindex.py
+++ b/pandas/tests/frame/methods/test_reindex.py
@@ -624,7 +624,7 @@ def test_reindex(self, float_frame, using_copy_on_write):
                     assert np.isnan(val)
 
         for col, series in newFrame.items():
-            assert tm.equalContents(series.index, newFrame.index)
+            tm.assert_index_equal(series.index, newFrame.index)
         emptyFrame = float_frame.reindex(Index([]))
         assert len(emptyFrame.index) == 0
 
@@ -642,7 +642,7 @@ def test_reindex(self, float_frame, using_copy_on_write):
                     assert np.isnan(val)
 
         for col, series in nonContigFrame.items():
-            assert tm.equalContents(series.index, nonContigFrame.index)
+            tm.assert_index_equal(series.index, nonContigFrame.index)
 
         # corner cases
 
diff --git a/pandas/tests/frame/test_iteration.py b/pandas/tests/frame/test_iteration.py
index 7374a8ea6aa77..a1c23ff05f3e1 100644
--- a/pandas/tests/frame/test_iteration.py
+++ b/pandas/tests/frame/test_iteration.py
@@ -40,7 +40,7 @@ def test_items_names(self, float_string_frame):
             assert v.name == k
 
     def test_iter(self, float_frame):
-        assert tm.equalContents(list(float_frame), float_frame.columns)
+        assert list(float_frame) == list(float_frame.columns)
 
     def test_iterrows(self, float_frame, float_string_frame):
         for k, v in float_frame.iterrows():
diff --git a/pandas/tests/indexes/datetimes/test_setops.py b/pandas/tests/indexes/datetimes/test_setops.py
index dde680665a8bc..78c23e47897cf 100644
--- a/pandas/tests/indexes/datetimes/test_setops.py
+++ b/pandas/tests/indexes/datetimes/test_setops.py
@@ -206,13 +206,13 @@ def test_intersection2(self):
         first = tm.makeDateIndex(10)
         second = first[5:]
         intersect = first.intersection(second)
-        assert tm.equalContents(intersect, second)
+        tm.assert_index_equal(intersect, second)
 
         # 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)
+            tm.assert_index_equal(result, second)
 
         third = Index(["a", "b", "c"])
         result = first.intersection(third)
diff --git a/pandas/tests/indexes/interval/test_setops.py b/pandas/tests/indexes/interval/test_setops.py
index 059b0b75f4190..1b0816a9405cb 100644
--- a/pandas/tests/indexes/interval/test_setops.py
+++ b/pandas/tests/indexes/interval/test_setops.py
@@ -25,14 +25,16 @@ def test_union(self, closed, sort):
 
         expected = monotonic_index(0, 13, closed=closed)
         result = index[::-1].union(other, sort=sort)
-        if sort is None:
+        if sort in (None, True):
             tm.assert_index_equal(result, expected)
-        assert tm.equalContents(result, expected)
+        else:
+            tm.assert_index_equal(result.sort_values(), expected)
 
         result = other[::-1].union(index, sort=sort)
-        if sort is None:
+        if sort in (None, True):
             tm.assert_index_equal(result, expected)
-        assert tm.equalContents(result, expected)
+        else:
+            tm.assert_index_equal(result.sort_values(), expected)
 
         tm.assert_index_equal(index.union(index, sort=sort), index)
         tm.assert_index_equal(index.union(index[:1], sort=sort), index)
@@ -65,14 +67,16 @@ def test_intersection(self, closed, sort):
 
         expected = monotonic_index(5, 11, closed=closed)
         result = index[::-1].intersection(other, sort=sort)
-        if sort is None:
+        if sort in (None, True):
             tm.assert_index_equal(result, expected)
-        assert tm.equalContents(result, expected)
+        else:
+            tm.assert_index_equal(result.sort_values(), expected)
 
         result = other[::-1].intersection(index, sort=sort)
-        if sort is None:
+        if sort in (None, True):
             tm.assert_index_equal(result, expected)
-        assert tm.equalContents(result, expected)
+        else:
+            tm.assert_index_equal(result.sort_values(), expected)
 
         tm.assert_index_equal(index.intersection(index, sort=sort), index)
 
@@ -148,16 +152,18 @@ def test_symmetric_difference(self, closed, sort):
         index = monotonic_index(0, 11, closed=closed)
         result = index[1:].symmetric_difference(index[:-1], sort=sort)
         expected = IntervalIndex([index[0], index[-1]])
-        if sort is None:
+        if sort in (None, True):
             tm.assert_index_equal(result, expected)
-        assert tm.equalContents(result, expected)
+        else:
+            tm.assert_index_equal(result.sort_values(), expected)
 
         # GH 19101: empty result, same dtype
         result = index.symmetric_difference(index, sort=sort)
         expected = empty_index(dtype="int64", closed=closed)
-        if sort is None:
+        if sort in (None, True):
             tm.assert_index_equal(result, expected)
-        assert tm.equalContents(result, expected)
+        else:
+            tm.assert_index_equal(result.sort_values(), expected)
 
         # GH 19101: empty result, different dtypes
         other = IntervalIndex.from_arrays(
diff --git a/pandas/tests/indexes/multi/test_setops.py b/pandas/tests/indexes/multi/test_setops.py
index 2b4107acee096..be266f5d8fdce 100644
--- a/pandas/tests/indexes/multi/test_setops.py
+++ b/pandas/tests/indexes/multi/test_setops.py
@@ -243,10 +243,10 @@ def test_union(idx, sort):
 
     the_union = piece1.union(piece2, sort=sort)
 
-    if sort is None:
-        tm.assert_index_equal(the_union, idx.sort_values())
-
-    assert tm.equalContents(the_union, idx)
+    if sort in (None, False):
+        tm.assert_index_equal(the_union.sort_values(), idx.sort_values())
+    else:
+        tm.assert_index_equal(the_union, idx)
 
     # corner case, pass self or empty thing:
     the_union = idx.union(idx, sort=sort)
@@ -258,7 +258,7 @@ def test_union(idx, sort):
     tuples = idx.values
     result = idx[:4].union(tuples[4:], sort=sort)
     if sort is None:
-        tm.equalContents(result, idx)
+        tm.assert_index_equal(result.sort_values(), idx.sort_values())
     else:
         assert result.equals(idx)
 
@@ -284,9 +284,10 @@ def test_intersection(idx, sort):
 
     the_int = piece1.intersection(piece2, sort=sort)
 
-    if sort is None:
+    if sort in (None, True):
         tm.assert_index_equal(the_int, idx[3:5])
-    assert tm.equalContents(the_int, idx[3:5])
+    else:
+        tm.assert_index_equal(the_int.sort_values(), idx[3:5])
 
     # corner case, pass self
     the_int = idx.intersection(idx, sort=sort)
diff --git a/pandas/tests/indexes/numeric/test_setops.py b/pandas/tests/indexes/numeric/test_setops.py
index d3789f2477896..376b51dd98bb1 100644
--- a/pandas/tests/indexes/numeric/test_setops.py
+++ b/pandas/tests/indexes/numeric/test_setops.py
@@ -133,7 +133,10 @@ def test_symmetric_difference(self, sort):
         index2 = Index([2, 3, 4, 1])
         result = index1.symmetric_difference(index2, sort=sort)
         expected = Index([5, 1])
-        assert tm.equalContents(result, expected)
+        if sort is not None:
+            tm.assert_index_equal(result, expected)
+        else:
+            tm.assert_index_equal(result, expected.sort_values())
         assert result.name is None
         if sort is None:
             expected = expected.sort_values()
diff --git a/pandas/tests/indexes/period/test_setops.py b/pandas/tests/indexes/period/test_setops.py
index b9a5940795a5b..2fa7e8cd0d2df 100644
--- a/pandas/tests/indexes/period/test_setops.py
+++ b/pandas/tests/indexes/period/test_setops.py
@@ -142,9 +142,10 @@ def test_union_misc(self, sort):
 
         # not in order
         result = _permute(index[:-5]).union(_permute(index[10:]), sort=sort)
-        if sort is None:
+        if sort is False:
+            tm.assert_index_equal(result.sort_values(), index)
+        else:
             tm.assert_index_equal(result, index)
-        assert tm.equalContents(result, index)
 
         # cast if different frequencies
         index = period_range("1/1/2000", "1/20/2000", freq="D")
@@ -163,9 +164,10 @@ def test_intersection(self, sort):
         left = _permute(index[:-5])
         right = _permute(index[10:])
         result = left.intersection(right, sort=sort)
-        if sort is None:
+        if sort is False:
+            tm.assert_index_equal(result.sort_values(), index[10:-5])
+        else:
             tm.assert_index_equal(result, index[10:-5])
-        assert tm.equalContents(result, index[10:-5])
 
         # cast if different frequencies
         index = period_range("1/1/2000", "1/20/2000", freq="D")
diff --git a/pandas/tests/indexes/test_base.py b/pandas/tests/indexes/test_base.py
index dc624f0271a73..5360f1c6ea6d9 100644
--- a/pandas/tests/indexes/test_base.py
+++ b/pandas/tests/indexes/test_base.py
@@ -492,10 +492,10 @@ def test_union_dt_as_obj(self, simple_index):
         first_cat = index.union(date_index)
         second_cat = index.union(index)
 
-        appended = np.append(index, date_index.astype("O"))
+        appended = Index(np.append(index, date_index.astype("O")))
 
-        assert tm.equalContents(first_cat, appended)
-        assert tm.equalContents(second_cat, index)
+        tm.assert_index_equal(first_cat, appended)
+        tm.assert_index_equal(second_cat, index)
         tm.assert_contains_all(index, first_cat)
         tm.assert_contains_all(index, second_cat)
         tm.assert_contains_all(date_index, first_cat)
diff --git a/pandas/tests/indexes/test_setops.py b/pandas/tests/indexes/test_setops.py
index 1f328c06b483b..dab2475240267 100644
--- a/pandas/tests/indexes/test_setops.py
+++ b/pandas/tests/indexes/test_setops.py
@@ -30,6 +30,13 @@
 )
 
 
+def equal_contents(arr1, arr2) -> bool:
+    """
+    Checks if the set of unique elements of arr1 and arr2 are equivalent.
+    """
+    return frozenset(arr1) == frozenset(arr2)
+
+
 @pytest.fixture(
     params=tm.ALL_REAL_NUMPY_DTYPES
     + [
@@ -215,10 +222,10 @@ def test_intersection_base(self, index):
         if isinstance(index, CategoricalIndex):
             pytest.skip(f"Not relevant for {type(index).__name__}")
 
-        first = index[:5]
-        second = index[:3]
+        first = index[:5].unique()
+        second = index[:3].unique()
         intersect = first.intersection(second)
-        assert tm.equalContents(intersect, second)
+        tm.assert_index_equal(intersect, second)
 
         if isinstance(index.dtype, DatetimeTZDtype):
             # The second.values below will drop tz, so the rest of this test
@@ -229,7 +236,7 @@ def test_intersection_base(self, index):
         cases = [second.to_numpy(), second.to_series(), second.to_list()]
         for case in cases:
             result = first.intersection(case)
-            assert tm.equalContents(result, second)
+            assert equal_contents(result, second)
 
         if isinstance(index, MultiIndex):
             msg = "other must be a MultiIndex or a list of tuples"
@@ -241,12 +248,13 @@ def test_intersection_base(self, index):
     )
     @pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
     def test_union_base(self, index):
+        index = index.unique()
         first = index[3:]
         second = index[:5]
         everything = index
 
         union = first.union(second)
-        assert tm.equalContents(union, everything)
+        tm.assert_index_equal(union.sort_values(), everything.sort_values())
 
         if isinstance(index.dtype, DatetimeTZDtype):
             # The second.values below will drop tz, so the rest of this test
@@ -257,7 +265,7 @@ def test_union_base(self, index):
         cases = [second.to_numpy(), second.to_series(), second.to_list()]
         for case in cases:
             result = first.union(case)
-            assert tm.equalContents(result, everything)
+            assert equal_contents(result, everything)
 
         if isinstance(index, MultiIndex):
             msg = "other must be a MultiIndex or a list of tuples"
@@ -280,13 +288,13 @@ def test_difference_base(self, sort, index):
         else:
             answer = index[4:]
         result = first.difference(second, sort)
-        assert tm.equalContents(result, answer)
+        assert equal_contents(result, answer)
 
         # GH#10149
         cases = [second.to_numpy(), second.to_series(), second.to_list()]
         for case in cases:
             result = first.difference(case, sort)
-            assert tm.equalContents(result, answer)
+            assert equal_contents(result, answer)
 
         if isinstance(index, MultiIndex):
             msg = "other must be a MultiIndex or a list of tuples"
@@ -311,13 +319,13 @@ def test_symmetric_difference(self, index):
         second = index[:-1]
         answer = index[[0, -1]]
         result = first.symmetric_difference(second)
-        assert tm.equalContents(result, answer)
+        tm.assert_index_equal(result.sort_values(), answer.sort_values())
 
         # GH#10149
         cases = [second.to_numpy(), second.to_series(), second.to_list()]
         for case in cases:
             result = first.symmetric_difference(case)
-            assert tm.equalContents(result, answer)
+            assert equal_contents(result, answer)
 
         if isinstance(index, MultiIndex):
             msg = "other must be a MultiIndex or a list of tuples"
@@ -701,9 +709,10 @@ def test_intersection(self, index, sort):
         first = index[:20]
         second = index[:10]
         intersect = first.intersection(second, sort=sort)
-        if sort is None:
-            tm.assert_index_equal(intersect, second.sort_values())
-        assert tm.equalContents(intersect, second)
+        if sort in (None, False):
+            tm.assert_index_equal(intersect.sort_values(), second.sort_values())
+        else:
+            tm.assert_index_equal(intersect, second)
 
         # Corner cases
         inter = first.intersection(first, sort=sort)
@@ -766,9 +775,10 @@ def test_union(self, index, sort):
         everything = index[:20]
 
         union = first.union(second, sort=sort)
-        if sort is None:
-            tm.assert_index_equal(union, everything.sort_values())
-        assert tm.equalContents(union, everything)
+        if sort in (None, False):
+            tm.assert_index_equal(union.sort_values(), everything.sort_values())
+        else:
+            tm.assert_index_equal(union, everything)
 
     @pytest.mark.parametrize("klass", [np.array, Series, list])
     @pytest.mark.parametrize("index", ["string"], indirect=True)
@@ -780,9 +790,10 @@ def test_union_from_iterables(self, index, klass, sort):
 
         case = klass(second.values)
         result = first.union(case, sort=sort)
-        if sort is None:
-            tm.assert_index_equal(result, everything.sort_values())
-        assert tm.equalContents(result, everything)
+        if sort in (None, False):
+            tm.assert_index_equal(result.sort_values(), everything.sort_values())
+        else:
+            tm.assert_index_equal(result, everything)
 
     @pytest.mark.parametrize("index", ["string"], indirect=True)
     def test_union_identity(self, index, sort):
@@ -811,7 +822,11 @@ def test_difference_name_preservation(self, index, second_name, expected, sort):
         second.name = second_name
         result = first.difference(second, sort=sort)
 
-        assert tm.equalContents(result, answer)
+        if sort is True:
+            tm.assert_index_equal(result, answer)
+        else:
+            answer.name = second_name
+            tm.assert_index_equal(result.sort_values(), answer.sort_values())
 
         if expected is None:
             assert result.name is None
@@ -894,7 +909,6 @@ def test_symmetric_difference_mi(self, sort):
         if sort is None:
             expected = expected.sort_values()
         tm.assert_index_equal(result, expected)
-        assert tm.equalContents(result, expected)
 
     @pytest.mark.parametrize(
         "index2,expected",
@@ -916,13 +930,20 @@ def test_symmetric_difference_missing(self, index2, expected, sort):
     def test_symmetric_difference_non_index(self, sort):
         index1 = Index([1, 2, 3, 4], name="index1")
         index2 = np.array([2, 3, 4, 5])
-        expected = Index([1, 5])
+        expected = Index([1, 5], name="index1")
         result = index1.symmetric_difference(index2, sort=sort)
-        assert tm.equalContents(result, expected)
+        if sort in (None, True):
+            tm.assert_index_equal(result, expected)
+        else:
+            tm.assert_index_equal(result.sort_values(), expected)
         assert result.name == "index1"
 
         result = index1.symmetric_difference(index2, result_name="new_name", sort=sort)
-        assert tm.equalContents(result, expected)
+        expected.name = "new_name"
+        if sort in (None, True):
+            tm.assert_index_equal(result, expected)
+        else:
+            tm.assert_index_equal(result.sort_values(), expected)
         assert result.name == "new_name"
 
     def test_union_ea_dtypes(self, any_numeric_ea_and_arrow_dtype):
diff --git a/pandas/tests/indexes/timedeltas/test_setops.py b/pandas/tests/indexes/timedeltas/test_setops.py
index 727b4eee00566..fce10d9176d74 100644
--- a/pandas/tests/indexes/timedeltas/test_setops.py
+++ b/pandas/tests/indexes/timedeltas/test_setops.py
@@ -115,7 +115,7 @@ def test_intersection_equal(self, sort):
         intersect = first.intersection(second, sort=sort)
         if sort is None:
             tm.assert_index_equal(intersect, second.sort_values())
-        assert tm.equalContents(intersect, second)
+        tm.assert_index_equal(intersect, second)
 
         # Corner cases
         inter = first.intersection(first, sort=sort)
diff --git a/pandas/tests/io/test_sql.py b/pandas/tests/io/test_sql.py
index 144210166d1a6..a15e85d42cd9b 100644
--- a/pandas/tests/io/test_sql.py
+++ b/pandas/tests/io/test_sql.py
@@ -375,7 +375,7 @@ def check_iris_frame(frame: DataFrame):
     pytype = frame.dtypes.iloc[0].type
     row = frame.iloc[0]
     assert issubclass(pytype, np.floating)
-    tm.equalContents(row.values, [5.1, 3.5, 1.4, 0.2, "Iris-setosa"])
+    tm.assert_series_equal(row, Series([5.1, 3.5, 1.4, 0.2, "Iris-setosa"]))
     assert frame.shape in ((150, 5), (8, 5))
 
 
@@ -1734,7 +1734,7 @@ def test_api_execute_sql(conn, request):
         iris_results = pandas_sql.execute("SELECT * FROM iris")
         row = iris_results.fetchone()
         iris_results.close()
-    tm.equalContents(row, [5.1, 3.5, 1.4, 0.2, "Iris-setosa"])
+    assert list(row) == [5.1, 3.5, 1.4, 0.2, "Iris-setosa"]
 
 
 @pytest.mark.parametrize("conn", all_connectable_types)
@@ -2710,7 +2710,7 @@ def test_execute_sql(conn, request):
             iris_results = pandasSQL.execute("SELECT * FROM iris")
             row = iris_results.fetchone()
             iris_results.close()
-    tm.equalContents(row, [5.1, 3.5, 1.4, 0.2, "Iris-setosa"])
+    assert list(row) == [5.1, 3.5, 1.4, 0.2, "Iris-setosa"]
 
 
 @pytest.mark.parametrize("conn", sqlalchemy_connectable_iris)
@@ -2726,7 +2726,7 @@ def test_sqlalchemy_read_table_columns(conn, request):
     iris_frame = sql.read_sql_table(
         "iris", con=conn, columns=["SepalLength", "SepalLength"]
     )
-    tm.equalContents(iris_frame.columns.values, ["SepalLength", "SepalLength"])
+    tm.assert_index_equal(iris_frame.columns, Index(["SepalLength", "SepalLength"]))
 
 
 @pytest.mark.parametrize("conn", sqlalchemy_connectable_iris)
diff --git a/pandas/tests/series/indexing/test_indexing.py b/pandas/tests/series/indexing/test_indexing.py
index b108ec24732ac..0c788b371a03a 100644
--- a/pandas/tests/series/indexing/test_indexing.py
+++ b/pandas/tests/series/indexing/test_indexing.py
@@ -252,7 +252,7 @@ def test_slice(string_series, object_series, using_copy_on_write, warn_copy_on_w
     assert string_series[numSlice.index[0]] == numSlice[numSlice.index[0]]
 
     assert numSlice.index[1] == string_series.index[11]
-    assert tm.equalContents(numSliceEnd, np.array(string_series)[-10:])
+    tm.assert_numpy_array_equal(np.array(numSliceEnd), np.array(string_series)[-10:])
 
     # Test return view.
     sl = string_series[10:20]
diff --git a/pandas/tests/series/test_arithmetic.py b/pandas/tests/series/test_arithmetic.py
index e7233f005e427..6471cd71f0860 100644
--- a/pandas/tests/series/test_arithmetic.py
+++ b/pandas/tests/series/test_arithmetic.py
@@ -662,9 +662,9 @@ def test_comparison_operators_with_nas(self, comparison_op):
 
     def test_ne(self):
         ts = Series([3, 4, 5, 6, 7], [3, 4, 5, 6, 7], dtype=float)
-        expected = [True, True, False, True, True]
-        assert tm.equalContents(ts.index != 5, expected)
-        assert tm.equalContents(~(ts.index == 5), expected)
+        expected = np.array([True, True, False, True, True])
+        tm.assert_numpy_array_equal(ts.index != 5, expected)
+        tm.assert_numpy_array_equal(~(ts.index == 5), expected)
 
     @pytest.mark.parametrize(
         "left, right",
diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py
index 65726eb8fcbb8..84c612c43da29 100644
--- a/pandas/tests/series/test_constructors.py
+++ b/pandas/tests/series/test_constructors.py
@@ -160,7 +160,7 @@ def test_constructor(self, datetime_series, using_infer_string):
         derived = Series(datetime_series)
         assert derived.index._is_all_dates
 
-        assert tm.equalContents(derived.index, datetime_series.index)
+        tm.assert_index_equal(derived.index, datetime_series.index)
         # Ensure new index is not created
         assert id(datetime_series.index) == id(derived.index)
 

From 31552fb19421020a5f0f737635483e808f00bef1 Mon Sep 17 00:00:00 2001
From: Matthew Roeschke <10647082+mroeschke@users.noreply.github.com>
Date: Fri, 24 Nov 2023 13:48:46 -0800
Subject: [PATCH 2/2] Follow up

---
 pandas/_testing/__init__.py                    |  1 -
 pandas/tests/indexes/base_class/test_setops.py | 13 ++++++++++---
 pandas/tests/io/test_sql.py                    |  6 ++++--
 3 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/pandas/_testing/__init__.py b/pandas/_testing/__init__.py
index 264dafcebe3dc..51de242522074 100644
--- a/pandas/_testing/__init__.py
+++ b/pandas/_testing/__init__.py
@@ -1124,7 +1124,6 @@ def shares_memory(left, right) -> bool:
     "EMPTY_STRING_PATTERN",
     "ENDIAN",
     "ensure_clean",
-    "equalContents",
     "external_error_raised",
     "FLOAT_EA_DTYPES",
     "FLOAT_NUMPY_DTYPES",
diff --git a/pandas/tests/indexes/base_class/test_setops.py b/pandas/tests/indexes/base_class/test_setops.py
index 488f79eea0d11..e538ad512d691 100644
--- a/pandas/tests/indexes/base_class/test_setops.py
+++ b/pandas/tests/indexes/base_class/test_setops.py
@@ -12,6 +12,13 @@
 from pandas.core.algorithms import safe_sort
 
 
+def equal_contents(arr1, arr2) -> bool:
+    """
+    Checks if the set of unique elements of arr1 and arr2 are equivalent.
+    """
+    return frozenset(arr1) == frozenset(arr2)
+
+
 class TestIndexSetOps:
     @pytest.mark.parametrize(
         "method", ["union", "intersection", "difference", "symmetric_difference"]
@@ -71,7 +78,7 @@ def test_union_different_type_base(self, klass):
 
         result = first.union(klass(second.values))
 
-        assert tm.equalContents(result, index)
+        assert equal_contents(result, index)
 
     def test_union_sort_other_incomparable(self):
         # https://github.com/pandas-dev/pandas/issues/24959
@@ -119,7 +126,7 @@ def test_intersection_different_type_base(self, klass, sort):
         second = index[:3]
 
         result = first.intersection(klass(second.values), sort=sort)
-        assert tm.equalContents(result, second)
+        assert equal_contents(result, second)
 
     def test_intersection_nosort(self):
         result = Index(["c", "b", "a"]).intersection(["b", "a"])
@@ -244,7 +251,7 @@ def test_union_name_preservation(
             tm.assert_index_equal(union, expected)
         else:
             expected = Index(vals, name=expected_name)
-            tm.equalContents(union, expected)
+            tm.assert_index_equal(union.sort_values(), expected.sort_values())
 
     @pytest.mark.parametrize(
         "diff_type, expected",
diff --git a/pandas/tests/io/test_sql.py b/pandas/tests/io/test_sql.py
index a15e85d42cd9b..45d0a839b9e1a 100644
--- a/pandas/tests/io/test_sql.py
+++ b/pandas/tests/io/test_sql.py
@@ -375,7 +375,9 @@ def check_iris_frame(frame: DataFrame):
     pytype = frame.dtypes.iloc[0].type
     row = frame.iloc[0]
     assert issubclass(pytype, np.floating)
-    tm.assert_series_equal(row, Series([5.1, 3.5, 1.4, 0.2, "Iris-setosa"]))
+    tm.assert_series_equal(
+        row, Series([5.1, 3.5, 1.4, 0.2, "Iris-setosa"], index=frame.columns, name=0)
+    )
     assert frame.shape in ((150, 5), (8, 5))
 
 
@@ -2726,7 +2728,7 @@ def test_sqlalchemy_read_table_columns(conn, request):
     iris_frame = sql.read_sql_table(
         "iris", con=conn, columns=["SepalLength", "SepalLength"]
     )
-    tm.assert_index_equal(iris_frame.columns, Index(["SepalLength", "SepalLength"]))
+    tm.assert_index_equal(iris_frame.columns, Index(["SepalLength", "SepalLength__1"]))
 
 
 @pytest.mark.parametrize("conn", sqlalchemy_connectable_iris)