first commit

.venv/Lib/site-packages/pandas/tests/util/conftest.py

@@ -0,0 +1,26 @@
+import pytest
+
+
+@pytest.fixture(params=[True, False])
+def check_dtype(request):
+    return request.param
+
+
+@pytest.fixture(params=[True, False])
+def check_exact(request):
+    return request.param
+
+
+@pytest.fixture(params=[True, False])
+def check_index_type(request):
+    return request.param
+
+
+@pytest.fixture(params=[0.5e-3, 0.5e-5])
+def rtol(request):
+    return request.param
+
+
+@pytest.fixture(params=[True, False])
+def check_categorical(request):
+    return request.param

.venv/Lib/site-packages/pandas/tests/util/test_assert_almost_equal.py

@@ -0,0 +1,460 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Index,
+    Series,
+    Timestamp,
+)
+import pandas._testing as tm
+
+
+def _assert_almost_equal_both(a, b, **kwargs):
+    """
+    Check that two objects are approximately equal.
+
+    This check is performed commutatively.
+
+    Parameters
+    ----------
+    a : object
+        The first object to compare.
+    b : object
+        The second object to compare.
+    **kwargs
+        The arguments passed to `tm.assert_almost_equal`.
+    """
+    tm.assert_almost_equal(a, b, **kwargs)
+    tm.assert_almost_equal(b, a, **kwargs)
+
+
+def _assert_not_almost_equal(a, b, **kwargs):
+    """
+    Check that two objects are not approximately equal.
+
+    Parameters
+    ----------
+    a : object
+        The first object to compare.
+    b : object
+        The second object to compare.
+    **kwargs
+        The arguments passed to `tm.assert_almost_equal`.
+    """
+    try:
+        tm.assert_almost_equal(a, b, **kwargs)
+        msg = f"{a} and {b} were approximately equal when they shouldn't have been"
+        pytest.fail(msg=msg)
+    except AssertionError:
+        pass
+
+
+def _assert_not_almost_equal_both(a, b, **kwargs):
+    """
+    Check that two objects are not approximately equal.
+
+    This check is performed commutatively.
+
+    Parameters
+    ----------
+    a : object
+        The first object to compare.
+    b : object
+        The second object to compare.
+    **kwargs
+        The arguments passed to `tm.assert_almost_equal`.
+    """
+    _assert_not_almost_equal(a, b, **kwargs)
+    _assert_not_almost_equal(b, a, **kwargs)
+
+
+@pytest.mark.parametrize(
+    "a,b,check_less_precise",
+    [(1.1, 1.1, False), (1.1, 1.100001, True), (1.1, 1.1001, 2)],
+)
+def test_assert_almost_equal_deprecated(a, b, check_less_precise):
+    # GH#30562
+    with tm.assert_produces_warning(FutureWarning):
+        _assert_almost_equal_both(a, b, check_less_precise=check_less_precise)
+
+
+@pytest.mark.parametrize(
+    "a,b",
+    [
+        (1.1, 1.1),
+        (1.1, 1.100001),
+        (np.int16(1), 1.000001),
+        (np.float64(1.1), 1.1),
+        (np.uint32(5), 5),
+    ],
+)
+def test_assert_almost_equal_numbers(a, b):
+    _assert_almost_equal_both(a, b)
+
+
+@pytest.mark.parametrize(
+    "a,b",
+    [
+        (1.1, 1),
+        (1.1, True),
+        (1, 2),
+        (1.0001, np.int16(1)),
+        # The following two examples are not "almost equal" due to tol.
+        (0.1, 0.1001),
+        (0.0011, 0.0012),
+    ],
+)
+def test_assert_not_almost_equal_numbers(a, b):
+    _assert_not_almost_equal_both(a, b)
+
+
+@pytest.mark.parametrize(
+    "a,b",
+    [
+        (1.1, 1.1),
+        (1.1, 1.100001),
+        (1.1, 1.1001),
+        (0.000001, 0.000005),
+        (1000.0, 1000.0005),
+        # Testing this example, as per #13357
+        (0.000011, 0.000012),
+    ],
+)
+def test_assert_almost_equal_numbers_atol(a, b):
+    # Equivalent to the deprecated check_less_precise=True
+    _assert_almost_equal_both(a, b, rtol=0.5e-3, atol=0.5e-3)
+
+
+@pytest.mark.parametrize("a,b", [(1.1, 1.11), (0.1, 0.101), (0.000011, 0.001012)])
+def test_assert_not_almost_equal_numbers_atol(a, b):
+    _assert_not_almost_equal_both(a, b, atol=1e-3)
+
+
+@pytest.mark.parametrize(
+    "a,b",
+    [
+        (1.1, 1.1),
+        (1.1, 1.100001),
+        (1.1, 1.1001),
+        (1000.0, 1000.0005),
+        (1.1, 1.11),
+        (0.1, 0.101),
+    ],
+)
+def test_assert_almost_equal_numbers_rtol(a, b):
+    _assert_almost_equal_both(a, b, rtol=0.05)
+
+
+@pytest.mark.parametrize("a,b", [(0.000011, 0.000012), (0.000001, 0.000005)])
+def test_assert_not_almost_equal_numbers_rtol(a, b):
+    _assert_not_almost_equal_both(a, b, rtol=0.05)
+
+
+@pytest.mark.parametrize(
+    "a,b,rtol",
+    [
+        (1.00001, 1.00005, 0.001),
+        (-0.908356 + 0.2j, -0.908358 + 0.2j, 1e-3),
+        (0.1 + 1.009j, 0.1 + 1.006j, 0.1),
+        (0.1001 + 2.0j, 0.1 + 2.001j, 0.01),
+    ],
+)
+def test_assert_almost_equal_complex_numbers(a, b, rtol):
+    _assert_almost_equal_both(a, b, rtol=rtol)
+    _assert_almost_equal_both(np.complex64(a), np.complex64(b), rtol=rtol)
+    _assert_almost_equal_both(np.complex128(a), np.complex128(b), rtol=rtol)
+
+
+@pytest.mark.parametrize(
+    "a,b,rtol",
+    [
+        (0.58310768, 0.58330768, 1e-7),
+        (-0.908 + 0.2j, -0.978 + 0.2j, 0.001),
+        (0.1 + 1j, 0.1 + 2j, 0.01),
+        (-0.132 + 1.001j, -0.132 + 1.005j, 1e-5),
+        (0.58310768j, 0.58330768j, 1e-9),
+    ],
+)
+def test_assert_not_almost_equal_complex_numbers(a, b, rtol):
+    _assert_not_almost_equal_both(a, b, rtol=rtol)
+    _assert_not_almost_equal_both(np.complex64(a), np.complex64(b), rtol=rtol)
+    _assert_not_almost_equal_both(np.complex128(a), np.complex128(b), rtol=rtol)
+
+
+@pytest.mark.parametrize("a,b", [(0, 0), (0, 0.0), (0, np.float64(0)), (0.00000001, 0)])
+def test_assert_almost_equal_numbers_with_zeros(a, b):
+    _assert_almost_equal_both(a, b)
+
+
+@pytest.mark.parametrize("a,b", [(0.001, 0), (1, 0)])
+def test_assert_not_almost_equal_numbers_with_zeros(a, b):
+    _assert_not_almost_equal_both(a, b)
+
+
+@pytest.mark.parametrize("a,b", [(1, "abc"), (1, [1]), (1, object())])
+def test_assert_not_almost_equal_numbers_with_mixed(a, b):
+    _assert_not_almost_equal_both(a, b)
+
+
+@pytest.mark.parametrize(
+    "left_dtype", ["M8[ns]", "m8[ns]", "float64", "int64", "object"]
+)
+@pytest.mark.parametrize(
+    "right_dtype", ["M8[ns]", "m8[ns]", "float64", "int64", "object"]
+)
+def test_assert_almost_equal_edge_case_ndarrays(left_dtype, right_dtype):
+    # Empty compare.
+    _assert_almost_equal_both(
+        np.array([], dtype=left_dtype),
+        np.array([], dtype=right_dtype),
+        check_dtype=False,
+    )
+
+
+def test_assert_almost_equal_dicts():
+    _assert_almost_equal_both({"a": 1, "b": 2}, {"a": 1, "b": 2})
+
+
+@pytest.mark.parametrize(
+    "a,b",
+    [
+        ({"a": 1, "b": 2}, {"a": 1, "b": 3}),
+        ({"a": 1, "b": 2}, {"a": 1, "b": 2, "c": 3}),
+        ({"a": 1}, 1),
+        ({"a": 1}, "abc"),
+        ({"a": 1}, [1]),
+    ],
+)
+def test_assert_not_almost_equal_dicts(a, b):
+    _assert_not_almost_equal_both(a, b)
+
+
+@pytest.mark.parametrize("val", [1, 2])
+def test_assert_almost_equal_dict_like_object(val):
+    dict_val = 1
+    real_dict = {"a": val}
+
+    class DictLikeObj:
+        def keys(self):
+            return ("a",)
+
+        def __getitem__(self, item):
+            if item == "a":
+                return dict_val
+
+    func = (
+        _assert_almost_equal_both if val == dict_val else _assert_not_almost_equal_both
+    )
+    func(real_dict, DictLikeObj(), check_dtype=False)
+
+
+def test_assert_almost_equal_strings():
+    _assert_almost_equal_both("abc", "abc")
+
+
+@pytest.mark.parametrize(
+    "a,b", [("abc", "abcd"), ("abc", "abd"), ("abc", 1), ("abc", [1])]
+)
+def test_assert_not_almost_equal_strings(a, b):
+    _assert_not_almost_equal_both(a, b)
+
+
+@pytest.mark.parametrize(
+    "a,b", [([1, 2, 3], [1, 2, 3]), (np.array([1, 2, 3]), np.array([1, 2, 3]))]
+)
+def test_assert_almost_equal_iterables(a, b):
+    _assert_almost_equal_both(a, b)
+
+
+@pytest.mark.parametrize(
+    "a,b",
+    [
+        # Class is different.
+        (np.array([1, 2, 3]), [1, 2, 3]),
+        # Dtype is different.
+        (np.array([1, 2, 3]), np.array([1.0, 2.0, 3.0])),
+        # Can't compare generators.
+        (iter([1, 2, 3]), [1, 2, 3]),
+        ([1, 2, 3], [1, 2, 4]),
+        ([1, 2, 3], [1, 2, 3, 4]),
+        ([1, 2, 3], 1),
+    ],
+)
+def test_assert_not_almost_equal_iterables(a, b):
+    _assert_not_almost_equal(a, b)
+
+
+def test_assert_almost_equal_null():
+    _assert_almost_equal_both(None, None)
+
+
+@pytest.mark.parametrize("a,b", [(None, np.NaN), (None, 0), (np.NaN, 0)])
+def test_assert_not_almost_equal_null(a, b):
+    _assert_not_almost_equal(a, b)
+
+
+@pytest.mark.parametrize(
+    "a,b",
+    [
+        (np.inf, np.inf),
+        (np.inf, float("inf")),
+        (np.array([np.inf, np.nan, -np.inf]), np.array([np.inf, np.nan, -np.inf])),
+        (
+            np.array([np.inf, None, -np.inf], dtype=np.object_),
+            np.array([np.inf, np.nan, -np.inf], dtype=np.object_),
+        ),
+    ],
+)
+def test_assert_almost_equal_inf(a, b):
+    _assert_almost_equal_both(a, b)
+
+
+def test_assert_not_almost_equal_inf():
+    _assert_not_almost_equal_both(np.inf, 0)
+
+
+@pytest.mark.parametrize(
+    "a,b",
+    [
+        (Index([1.0, 1.1]), Index([1.0, 1.100001])),
+        (Series([1.0, 1.1]), Series([1.0, 1.100001])),
+        (np.array([1.1, 2.000001]), np.array([1.1, 2.0])),
+        (DataFrame({"a": [1.0, 1.1]}), DataFrame({"a": [1.0, 1.100001]})),
+    ],
+)
+def test_assert_almost_equal_pandas(a, b):
+    _assert_almost_equal_both(a, b)
+
+
+def test_assert_almost_equal_object():
+    a = [Timestamp("2011-01-01"), Timestamp("2011-01-01")]
+    b = [Timestamp("2011-01-01"), Timestamp("2011-01-01")]
+    _assert_almost_equal_both(a, b)
+
+
+def test_assert_almost_equal_value_mismatch():
+    msg = "expected 2\\.00000 but got 1\\.00000, with rtol=1e-05, atol=1e-08"
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_almost_equal(1, 2)
+
+
+@pytest.mark.parametrize(
+    "a,b,klass1,klass2",
+    [(np.array([1]), 1, "ndarray", "int"), (1, np.array([1]), "int", "ndarray")],
+)
+def test_assert_almost_equal_class_mismatch(a, b, klass1, klass2):
+
+    msg = f"""numpy array are different
+
+numpy array classes are different
+\\[left\\]:  {klass1}
+\\[right\\]: {klass2}"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_almost_equal(a, b)
+
+
+def test_assert_almost_equal_value_mismatch1():
+    msg = """numpy array are different
+
+numpy array values are different \\(66\\.66667 %\\)
+\\[left\\]:  \\[nan, 2\\.0, 3\\.0\\]
+\\[right\\]: \\[1\\.0, nan, 3\\.0\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_almost_equal(np.array([np.nan, 2, 3]), np.array([1, np.nan, 3]))
+
+
+def test_assert_almost_equal_value_mismatch2():
+    msg = """numpy array are different
+
+numpy array values are different \\(50\\.0 %\\)
+\\[left\\]:  \\[1, 2\\]
+\\[right\\]: \\[1, 3\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_almost_equal(np.array([1, 2]), np.array([1, 3]))
+
+
+def test_assert_almost_equal_value_mismatch3():
+    msg = """numpy array are different
+
+numpy array values are different \\(16\\.66667 %\\)
+\\[left\\]:  \\[\\[1, 2\\], \\[3, 4\\], \\[5, 6\\]\\]
+\\[right\\]: \\[\\[1, 3\\], \\[3, 4\\], \\[5, 6\\]\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_almost_equal(
+            np.array([[1, 2], [3, 4], [5, 6]]), np.array([[1, 3], [3, 4], [5, 6]])
+        )
+
+
+def test_assert_almost_equal_value_mismatch4():
+    msg = """numpy array are different
+
+numpy array values are different \\(25\\.0 %\\)
+\\[left\\]:  \\[\\[1, 2\\], \\[3, 4\\]\\]
+\\[right\\]: \\[\\[1, 3\\], \\[3, 4\\]\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_almost_equal(np.array([[1, 2], [3, 4]]), np.array([[1, 3], [3, 4]]))
+
+
+def test_assert_almost_equal_shape_mismatch_override():
+    msg = """Index are different
+
+Index shapes are different
+\\[left\\]:  \\(2L*,\\)
+\\[right\\]: \\(3L*,\\)"""
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_almost_equal(np.array([1, 2]), np.array([3, 4, 5]), obj="Index")
+
+
+def test_assert_almost_equal_unicode():
+    # see gh-20503
+    msg = """numpy array are different
+
+numpy array values are different \\(33\\.33333 %\\)
+\\[left\\]:  \\[á, à, ä\\]
+\\[right\\]: \\[á, à, å\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_almost_equal(np.array(["á", "à", "ä"]), np.array(["á", "à", "å"]))
+
+
+def test_assert_almost_equal_timestamp():
+    a = np.array([Timestamp("2011-01-01"), Timestamp("2011-01-01")])
+    b = np.array([Timestamp("2011-01-01"), Timestamp("2011-01-02")])
+
+    msg = """numpy array are different
+
+numpy array values are different \\(50\\.0 %\\)
+\\[left\\]:  \\[2011-01-01 00:00:00, 2011-01-01 00:00:00\\]
+\\[right\\]: \\[2011-01-01 00:00:00, 2011-01-02 00:00:00\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_almost_equal(a, b)
+
+
+def test_assert_almost_equal_iterable_length_mismatch():
+    msg = """Iterable are different
+
+Iterable length are different
+\\[left\\]:  2
+\\[right\\]: 3"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_almost_equal([1, 2], [3, 4, 5])
+
+
+def test_assert_almost_equal_iterable_values_mismatch():
+    msg = """Iterable are different
+
+Iterable values are different \\(50\\.0 %\\)
+\\[left\\]:  \\[1, 2\\]
+\\[right\\]: \\[1, 3\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_almost_equal([1, 2], [1, 3])

.venv/Lib/site-packages/pandas/tests/util/test_assert_attr_equal.py

@@ -0,0 +1,33 @@
+from types import SimpleNamespace
+
+import pytest
+
+from pandas.core.dtypes.common import is_float
+
+import pandas._testing as tm
+
+
+def test_assert_attr_equal(nulls_fixture):
+    obj = SimpleNamespace()
+    obj.na_value = nulls_fixture
+    assert tm.assert_attr_equal("na_value", obj, obj)
+
+
+def test_assert_attr_equal_different_nulls(nulls_fixture, nulls_fixture2):
+    obj = SimpleNamespace()
+    obj.na_value = nulls_fixture
+
+    obj2 = SimpleNamespace()
+    obj2.na_value = nulls_fixture2
+
+    if nulls_fixture is nulls_fixture2:
+        assert tm.assert_attr_equal("na_value", obj, obj2)
+    elif is_float(nulls_fixture) and is_float(nulls_fixture2):
+        # we consider float("nan") and np.float64("nan") to be equivalent
+        assert tm.assert_attr_equal("na_value", obj, obj2)
+    elif type(nulls_fixture) is type(nulls_fixture2):
+        # e.g. Decimal("NaN")
+        assert tm.assert_attr_equal("na_value", obj, obj2)
+    else:
+        with pytest.raises(AssertionError, match='"na_value" are different'):
+            tm.assert_attr_equal("na_value", obj, obj2)

.venv/Lib/site-packages/pandas/tests/util/test_assert_categorical_equal.py

@@ -0,0 +1,90 @@
+import pytest
+
+from pandas import Categorical
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+    "c",
+    [Categorical([1, 2, 3, 4]), Categorical([1, 2, 3, 4], categories=[1, 2, 3, 4, 5])],
+)
+def test_categorical_equal(c):
+    tm.assert_categorical_equal(c, c)
+
+
+@pytest.mark.parametrize("check_category_order", [True, False])
+def test_categorical_equal_order_mismatch(check_category_order):
+    c1 = Categorical([1, 2, 3, 4], categories=[1, 2, 3, 4])
+    c2 = Categorical([1, 2, 3, 4], categories=[4, 3, 2, 1])
+    kwargs = {"check_category_order": check_category_order}
+
+    if check_category_order:
+        msg = """Categorical\\.categories are different
+
+Categorical\\.categories values are different \\(100\\.0 %\\)
+\\[left\\]:  Int64Index\\(\\[1, 2, 3, 4\\], dtype='int64'\\)
+\\[right\\]: Int64Index\\(\\[4, 3, 2, 1\\], dtype='int64'\\)"""
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_categorical_equal(c1, c2, **kwargs)
+    else:
+        tm.assert_categorical_equal(c1, c2, **kwargs)
+
+
+def test_categorical_equal_categories_mismatch():
+    msg = """Categorical\\.categories are different
+
+Categorical\\.categories values are different \\(25\\.0 %\\)
+\\[left\\]:  Int64Index\\(\\[1, 2, 3, 4\\], dtype='int64'\\)
+\\[right\\]: Int64Index\\(\\[1, 2, 3, 5\\], dtype='int64'\\)"""
+
+    c1 = Categorical([1, 2, 3, 4])
+    c2 = Categorical([1, 2, 3, 5])
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_categorical_equal(c1, c2)
+
+
+def test_categorical_equal_codes_mismatch():
+    categories = [1, 2, 3, 4]
+    msg = """Categorical\\.codes are different
+
+Categorical\\.codes values are different \\(50\\.0 %\\)
+\\[left\\]:  \\[0, 1, 3, 2\\]
+\\[right\\]: \\[0, 1, 2, 3\\]"""
+
+    c1 = Categorical([1, 2, 4, 3], categories=categories)
+    c2 = Categorical([1, 2, 3, 4], categories=categories)
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_categorical_equal(c1, c2)
+
+
+def test_categorical_equal_ordered_mismatch():
+    data = [1, 2, 3, 4]
+    msg = """Categorical are different
+
+Attribute "ordered" are different
+\\[left\\]:  False
+\\[right\\]: True"""
+
+    c1 = Categorical(data, ordered=False)
+    c2 = Categorical(data, ordered=True)
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_categorical_equal(c1, c2)
+
+
+@pytest.mark.parametrize("obj", ["index", "foo", "pandas"])
+def test_categorical_equal_object_override(obj):
+    data = [1, 2, 3, 4]
+    msg = f"""{obj} are different
+
+Attribute "ordered" are different
+\\[left\\]:  False
+\\[right\\]: True"""
+
+    c1 = Categorical(data, ordered=False)
+    c2 = Categorical(data, ordered=True)
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_categorical_equal(c1, c2, obj=obj)

.venv/Lib/site-packages/pandas/tests/util/test_assert_extension_array_equal.py

@@ -0,0 +1,113 @@
+import numpy as np
+import pytest
+
+from pandas import array
+import pandas._testing as tm
+from pandas.core.arrays.sparse import SparseArray
+
+
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        {},  # Default is check_exact=False
+        {"check_exact": False},
+        {"check_exact": True},
+    ],
+)
+def test_assert_extension_array_equal_not_exact(kwargs):
+    # see gh-23709
+    arr1 = SparseArray([-0.17387645482451206, 0.3414148016424936])
+    arr2 = SparseArray([-0.17387645482451206, 0.3414148016424937])
+
+    if kwargs.get("check_exact", False):
+        msg = """\
+ExtensionArray are different
+
+ExtensionArray values are different \\(50\\.0 %\\)
+\\[left\\]:  \\[-0\\.17387645482.*, 0\\.341414801642.*\\]
+\\[right\\]: \\[-0\\.17387645482.*, 0\\.341414801642.*\\]"""
+
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_extension_array_equal(arr1, arr2, **kwargs)
+    else:
+        tm.assert_extension_array_equal(arr1, arr2, **kwargs)
+
+
+@pytest.mark.parametrize("decimals", range(10))
+def test_assert_extension_array_equal_less_precise(decimals):
+    rtol = 0.5 * 10**-decimals
+    arr1 = SparseArray([0.5, 0.123456])
+    arr2 = SparseArray([0.5, 0.123457])
+
+    if decimals >= 5:
+        msg = """\
+ExtensionArray are different
+
+ExtensionArray values are different \\(50\\.0 %\\)
+\\[left\\]:  \\[0\\.5, 0\\.123456\\]
+\\[right\\]: \\[0\\.5, 0\\.123457\\]"""
+
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_extension_array_equal(arr1, arr2, rtol=rtol)
+    else:
+        tm.assert_extension_array_equal(arr1, arr2, rtol=rtol)
+
+
+def test_assert_extension_array_equal_dtype_mismatch(check_dtype):
+    end = 5
+    kwargs = {"check_dtype": check_dtype}
+
+    arr1 = SparseArray(np.arange(end, dtype="int64"))
+    arr2 = SparseArray(np.arange(end, dtype="int32"))
+
+    if check_dtype:
+        msg = """\
+ExtensionArray are different
+
+Attribute "dtype" are different
+\\[left\\]:  Sparse\\[int64, 0\\]
+\\[right\\]: Sparse\\[int32, 0\\]"""
+
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_extension_array_equal(arr1, arr2, **kwargs)
+    else:
+        tm.assert_extension_array_equal(arr1, arr2, **kwargs)
+
+
+def test_assert_extension_array_equal_missing_values():
+    arr1 = SparseArray([np.nan, 1, 2, np.nan])
+    arr2 = SparseArray([np.nan, 1, 2, 3])
+
+    msg = """\
+ExtensionArray NA mask are different
+
+ExtensionArray NA mask values are different \\(25\\.0 %\\)
+\\[left\\]:  \\[True, False, False, True\\]
+\\[right\\]: \\[True, False, False, False\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_extension_array_equal(arr1, arr2)
+
+
+@pytest.mark.parametrize("side", ["left", "right"])
+def test_assert_extension_array_equal_non_extension_array(side):
+    numpy_array = np.arange(5)
+    extension_array = SparseArray(numpy_array)
+
+    msg = f"{side} is not an ExtensionArray"
+    args = (
+        (numpy_array, extension_array)
+        if side == "left"
+        else (extension_array, numpy_array)
+    )
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_extension_array_equal(*args)
+
+
+@pytest.mark.parametrize("right_dtype", ["Int32", "int64"])
+def test_assert_extension_array_equal_ignore_dtype_mismatch(right_dtype):
+    # https://github.com/pandas-dev/pandas/issues/35715
+    left = array([1, 2, 3], dtype="Int64")
+    right = array([1, 2, 3], dtype=right_dtype)
+    tm.assert_extension_array_equal(left, right, check_dtype=False)

.venv/Lib/site-packages/pandas/tests/util/test_assert_frame_equal.py

@@ -0,0 +1,344 @@
+import pytest
+
+import pandas as pd
+from pandas import DataFrame
+import pandas._testing as tm
+
+
+@pytest.fixture(params=[True, False])
+def by_blocks_fixture(request):
+    return request.param
+
+
+@pytest.fixture(params=["DataFrame", "Series"])
+def obj_fixture(request):
+    return request.param
+
+
+def _assert_frame_equal_both(a, b, **kwargs):
+    """
+    Check that two DataFrame equal.
+
+    This check is performed commutatively.
+
+    Parameters
+    ----------
+    a : DataFrame
+        The first DataFrame to compare.
+    b : DataFrame
+        The second DataFrame to compare.
+    kwargs : dict
+        The arguments passed to `tm.assert_frame_equal`.
+    """
+    tm.assert_frame_equal(a, b, **kwargs)
+    tm.assert_frame_equal(b, a, **kwargs)
+
+
+def _assert_not_frame_equal(a, b, **kwargs):
+    """
+    Check that two DataFrame are not equal.
+
+    Parameters
+    ----------
+    a : DataFrame
+        The first DataFrame to compare.
+    b : DataFrame
+        The second DataFrame to compare.
+    kwargs : dict
+        The arguments passed to `tm.assert_frame_equal`.
+    """
+    msg = "The two DataFrames were equal when they shouldn't have been"
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_frame_equal(a, b, **kwargs)
+
+
+def _assert_not_frame_equal_both(a, b, **kwargs):
+    """
+    Check that two DataFrame are not equal.
+
+    This check is performed commutatively.
+
+    Parameters
+    ----------
+    a : DataFrame
+        The first DataFrame to compare.
+    b : DataFrame
+        The second DataFrame to compare.
+    kwargs : dict
+        The arguments passed to `tm.assert_frame_equal`.
+    """
+    _assert_not_frame_equal(a, b, **kwargs)
+    _assert_not_frame_equal(b, a, **kwargs)
+
+
+@pytest.mark.parametrize("check_like", [True, False])
+def test_frame_equal_row_order_mismatch(check_like, obj_fixture):
+    df1 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}, index=["a", "b", "c"])
+    df2 = DataFrame({"A": [3, 2, 1], "B": [6, 5, 4]}, index=["c", "b", "a"])
+
+    if not check_like:  # Do not ignore row-column orderings.
+        msg = f"{obj_fixture}.index are different"
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_frame_equal(df1, df2, check_like=check_like, obj=obj_fixture)
+    else:
+        _assert_frame_equal_both(df1, df2, check_like=check_like, obj=obj_fixture)
+
+
+@pytest.mark.parametrize(
+    "df1,df2",
+    [
+        (DataFrame({"A": [1, 2, 3]}), DataFrame({"A": [1, 2, 3, 4]})),
+        (DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}), DataFrame({"A": [1, 2, 3]})),
+    ],
+)
+def test_frame_equal_shape_mismatch(df1, df2, obj_fixture):
+    msg = f"{obj_fixture} are different"
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_frame_equal(df1, df2, obj=obj_fixture)
+
+
+@pytest.mark.parametrize(
+    "df1,df2,msg",
+    [
+        # Index
+        (
+            DataFrame.from_records({"a": [1, 2], "c": ["l1", "l2"]}, index=["a"]),
+            DataFrame.from_records({"a": [1.0, 2.0], "c": ["l1", "l2"]}, index=["a"]),
+            "DataFrame\\.index are different",
+        ),
+        # MultiIndex
+        (
+            DataFrame.from_records(
+                {"a": [1, 2], "b": [2.1, 1.5], "c": ["l1", "l2"]}, index=["a", "b"]
+            ),
+            DataFrame.from_records(
+                {"a": [1.0, 2.0], "b": [2.1, 1.5], "c": ["l1", "l2"]}, index=["a", "b"]
+            ),
+            "MultiIndex level \\[0\\] are different",
+        ),
+    ],
+)
+def test_frame_equal_index_dtype_mismatch(df1, df2, msg, check_index_type):
+    kwargs = {"check_index_type": check_index_type}
+
+    if check_index_type:
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_frame_equal(df1, df2, **kwargs)
+    else:
+        tm.assert_frame_equal(df1, df2, **kwargs)
+
+
+def test_empty_dtypes(check_dtype):
+    columns = ["col1", "col2"]
+    df1 = DataFrame(columns=columns)
+    df2 = DataFrame(columns=columns)
+
+    kwargs = {"check_dtype": check_dtype}
+    df1["col1"] = df1["col1"].astype("int64")
+
+    if check_dtype:
+        msg = r"Attributes of DataFrame\..* are different"
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_frame_equal(df1, df2, **kwargs)
+    else:
+        tm.assert_frame_equal(df1, df2, **kwargs)
+
+
+@pytest.mark.parametrize("check_like", [True, False])
+def test_frame_equal_index_mismatch(check_like, obj_fixture):
+    msg = f"""{obj_fixture}\\.index are different
+
+{obj_fixture}\\.index values are different \\(33\\.33333 %\\)
+\\[left\\]:  Index\\(\\['a', 'b', 'c'\\], dtype='object'\\)
+\\[right\\]: Index\\(\\['a', 'b', 'd'\\], dtype='object'\\)"""
+
+    df1 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}, index=["a", "b", "c"])
+    df2 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}, index=["a", "b", "d"])
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_frame_equal(df1, df2, check_like=check_like, obj=obj_fixture)
+
+
+@pytest.mark.parametrize("check_like", [True, False])
+def test_frame_equal_columns_mismatch(check_like, obj_fixture):
+    msg = f"""{obj_fixture}\\.columns are different
+
+{obj_fixture}\\.columns values are different \\(50\\.0 %\\)
+\\[left\\]:  Index\\(\\['A', 'B'\\], dtype='object'\\)
+\\[right\\]: Index\\(\\['A', 'b'\\], dtype='object'\\)"""
+
+    df1 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}, index=["a", "b", "c"])
+    df2 = DataFrame({"A": [1, 2, 3], "b": [4, 5, 6]}, index=["a", "b", "c"])
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_frame_equal(df1, df2, check_like=check_like, obj=obj_fixture)
+
+
+def test_frame_equal_block_mismatch(by_blocks_fixture, obj_fixture):
+    obj = obj_fixture
+    msg = f"""{obj}\\.iloc\\[:, 1\\] \\(column name="B"\\) are different
+
+{obj}\\.iloc\\[:, 1\\] \\(column name="B"\\) values are different \\(33\\.33333 %\\)
+\\[index\\]: \\[0, 1, 2\\]
+\\[left\\]:  \\[4, 5, 6\\]
+\\[right\\]: \\[4, 5, 7\\]"""
+
+    df1 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+    df2 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 7]})
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_frame_equal(df1, df2, by_blocks=by_blocks_fixture, obj=obj_fixture)
+
+
+@pytest.mark.parametrize(
+    "df1,df2,msg",
+    [
+        (
+            DataFrame({"A": ["á", "à", "ä"], "E": ["é", "è", "ë"]}),
+            DataFrame({"A": ["á", "à", "ä"], "E": ["é", "è", "e̊"]}),
+            """{obj}\\.iloc\\[:, 1\\] \\(column name="E"\\) are different
+
+{obj}\\.iloc\\[:, 1\\] \\(column name="E"\\) values are different \\(33\\.33333 %\\)
+\\[index\\]: \\[0, 1, 2\\]
+\\[left\\]:  \\[é, è, ë\\]
+\\[right\\]: \\[é, è, e̊\\]""",
+        ),
+        (
+            DataFrame({"A": ["á", "à", "ä"], "E": ["é", "è", "ë"]}),
+            DataFrame({"A": ["a", "a", "a"], "E": ["e", "e", "e"]}),
+            """{obj}\\.iloc\\[:, 0\\] \\(column name="A"\\) are different
+
+{obj}\\.iloc\\[:, 0\\] \\(column name="A"\\) values are different \\(100\\.0 %\\)
+\\[index\\]: \\[0, 1, 2\\]
+\\[left\\]:  \\[á, à, ä\\]
+\\[right\\]: \\[a, a, a\\]""",
+        ),
+    ],
+)
+def test_frame_equal_unicode(df1, df2, msg, by_blocks_fixture, obj_fixture):
+    # see gh-20503
+    #
+    # Test ensures that `tm.assert_frame_equals` raises the right exception
+    # when comparing DataFrames containing differing unicode objects.
+    msg = msg.format(obj=obj_fixture)
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_frame_equal(df1, df2, by_blocks=by_blocks_fixture, obj=obj_fixture)
+
+
+def test_assert_frame_equal_extension_dtype_mismatch():
+    # https://github.com/pandas-dev/pandas/issues/32747
+    left = DataFrame({"a": [1, 2, 3]}, dtype="Int64")
+    right = left.astype(int)
+
+    msg = (
+        "Attributes of DataFrame\\.iloc\\[:, 0\\] "
+        '\\(column name="a"\\) are different\n\n'
+        'Attribute "dtype" are different\n'
+        "\\[left\\]:  Int64\n"
+        "\\[right\\]: int[32|64]"
+    )
+
+    tm.assert_frame_equal(left, right, check_dtype=False)
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_frame_equal(left, right, check_dtype=True)
+
+
+def test_assert_frame_equal_interval_dtype_mismatch():
+    # https://github.com/pandas-dev/pandas/issues/32747
+    left = DataFrame({"a": [pd.Interval(0, 1)]}, dtype="interval")
+    right = left.astype(object)
+
+    msg = (
+        "Attributes of DataFrame\\.iloc\\[:, 0\\] "
+        '\\(column name="a"\\) are different\n\n'
+        'Attribute "dtype" are different\n'
+        "\\[left\\]:  interval\\[int64, right\\]\n"
+        "\\[right\\]: object"
+    )
+
+    tm.assert_frame_equal(left, right, check_dtype=False)
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_frame_equal(left, right, check_dtype=True)
+
+
+@pytest.mark.parametrize("right_dtype", ["Int32", "int64"])
+def test_assert_frame_equal_ignore_extension_dtype_mismatch(right_dtype):
+    # https://github.com/pandas-dev/pandas/issues/35715
+    left = DataFrame({"a": [1, 2, 3]}, dtype="Int64")
+    right = DataFrame({"a": [1, 2, 3]}, dtype=right_dtype)
+    tm.assert_frame_equal(left, right, check_dtype=False)
+
+
+@pytest.mark.parametrize(
+    "dtype",
+    [
+        ("timedelta64[ns]"),
+        ("datetime64[ns, UTC]"),
+        ("Period[D]"),
+    ],
+)
+def test_assert_frame_equal_datetime_like_dtype_mismatch(dtype):
+    df1 = DataFrame({"a": []}, dtype=dtype)
+    df2 = DataFrame({"a": []})
+    tm.assert_frame_equal(df1, df2, check_dtype=False)
+
+
+def test_allows_duplicate_labels():
+    left = DataFrame()
+    right = DataFrame().set_flags(allows_duplicate_labels=False)
+    tm.assert_frame_equal(left, left)
+    tm.assert_frame_equal(right, right)
+    tm.assert_frame_equal(left, right, check_flags=False)
+    tm.assert_frame_equal(right, left, check_flags=False)
+
+    with pytest.raises(AssertionError, match="<Flags"):
+        tm.assert_frame_equal(left, right)
+
+    with pytest.raises(AssertionError, match="<Flags"):
+        tm.assert_frame_equal(left, right)
+
+
+def test_assert_frame_equal_columns_mixed_dtype():
+    # GH#39168
+    df = DataFrame([[0, 1, 2]], columns=["foo", "bar", 42], index=[1, "test", 2])
+    tm.assert_frame_equal(df, df, check_like=True)
+
+
+def test_frame_equal_extension_dtype(frame_or_series, any_numeric_ea_dtype):
+    # GH#39410
+    obj = frame_or_series([1, 2], dtype=any_numeric_ea_dtype)
+    tm.assert_equal(obj, obj, check_exact=True)
+
+
+@pytest.mark.parametrize("indexer", [(0, 1), (1, 0)])
+def test_frame_equal_mixed_dtypes(frame_or_series, any_numeric_ea_dtype, indexer):
+    dtypes = (any_numeric_ea_dtype, "int64")
+    obj1 = frame_or_series([1, 2], dtype=dtypes[indexer[0]])
+    obj2 = frame_or_series([1, 2], dtype=dtypes[indexer[1]])
+    msg = r'(Series|DataFrame.iloc\[:, 0\] \(column name="0"\) classes) are different'
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_equal(obj1, obj2, check_exact=True, check_dtype=False)
+
+
+def test_assert_frame_equal_check_like_different_indexes():
+    # GH#39739
+    df1 = DataFrame(index=pd.Index([], dtype="object"))
+    df2 = DataFrame(index=pd.RangeIndex(start=0, stop=0, step=1))
+    with pytest.raises(AssertionError, match="DataFrame.index are different"):
+        tm.assert_frame_equal(df1, df2, check_like=True)
+
+
+def test_assert_frame_equal_checking_allow_dups_flag():
+    # GH#45554
+    left = DataFrame([[1, 2], [3, 4]])
+    left.flags.allows_duplicate_labels = False
+
+    right = DataFrame([[1, 2], [3, 4]])
+    right.flags.allows_duplicate_labels = True
+    tm.assert_frame_equal(left, right, check_flags=False)
+
+    with pytest.raises(AssertionError, match="allows_duplicate_labels"):
+        tm.assert_frame_equal(left, right, check_flags=True)

.venv/Lib/site-packages/pandas/tests/util/test_assert_index_equal.py

@@ -0,0 +1,244 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    Categorical,
+    CategoricalIndex,
+    Index,
+    MultiIndex,
+    NaT,
+    RangeIndex,
+)
+import pandas._testing as tm
+
+
+def test_index_equal_levels_mismatch():
+    msg = """Index are different
+
+Index levels are different
+\\[left\\]:  1, Int64Index\\(\\[1, 2, 3\\], dtype='int64'\\)
+\\[right\\]: 2, MultiIndex\\(\\[\\('A', 1\\),
+            \\('A', 2\\),
+            \\('B', 3\\),
+            \\('B', 4\\)\\],
+           \\)"""
+
+    idx1 = Index([1, 2, 3])
+    idx2 = MultiIndex.from_tuples([("A", 1), ("A", 2), ("B", 3), ("B", 4)])
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_index_equal(idx1, idx2, exact=False)
+
+
+def test_index_equal_values_mismatch(check_exact):
+    msg = """MultiIndex level \\[1\\] are different
+
+MultiIndex level \\[1\\] values are different \\(25\\.0 %\\)
+\\[left\\]:  Int64Index\\(\\[2, 2, 3, 4\\], dtype='int64'\\)
+\\[right\\]: Int64Index\\(\\[1, 2, 3, 4\\], dtype='int64'\\)"""
+
+    idx1 = MultiIndex.from_tuples([("A", 2), ("A", 2), ("B", 3), ("B", 4)])
+    idx2 = MultiIndex.from_tuples([("A", 1), ("A", 2), ("B", 3), ("B", 4)])
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_index_equal(idx1, idx2, check_exact=check_exact)
+
+
+def test_index_equal_length_mismatch(check_exact):
+    msg = """Index are different
+
+Index length are different
+\\[left\\]:  3, Int64Index\\(\\[1, 2, 3\\], dtype='int64'\\)
+\\[right\\]: 4, Int64Index\\(\\[1, 2, 3, 4\\], dtype='int64'\\)"""
+
+    idx1 = Index([1, 2, 3])
+    idx2 = Index([1, 2, 3, 4])
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_index_equal(idx1, idx2, check_exact=check_exact)
+
+
+@pytest.mark.parametrize("exact", [False, "equiv"])
+def test_index_equal_class(exact):
+    idx1 = Index([0, 1, 2])
+    idx2 = RangeIndex(3)
+
+    tm.assert_index_equal(idx1, idx2, exact=exact)
+
+
+@pytest.mark.parametrize(
+    "idx_values, msg_str",
+    [
+        [[1, 2, 3.0], "Float64Index\\(\\[1\\.0, 2\\.0, 3\\.0\\], dtype='float64'\\)"],
+        [range(3), "RangeIndex\\(start=0, stop=3, step=1\\)"],
+    ],
+)
+def test_index_equal_class_mismatch(check_exact, idx_values, msg_str):
+    msg = f"""Index are different
+
+Index classes are different
+\\[left\\]:  Int64Index\\(\\[1, 2, 3\\], dtype='int64'\\)
+\\[right\\]: {msg_str}"""
+
+    idx1 = Index([1, 2, 3])
+    idx2 = Index(idx_values)
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_index_equal(idx1, idx2, exact=True, check_exact=check_exact)
+
+
+def test_index_equal_values_close(check_exact):
+    idx1 = Index([1, 2, 3.0])
+    idx2 = Index([1, 2, 3.0000000001])
+
+    if check_exact:
+        msg = """Index are different
+
+Index values are different \\(33\\.33333 %\\)
+\\[left\\]:  Float64Index\\(\\[1.0, 2.0, 3.0], dtype='float64'\\)
+\\[right\\]: Float64Index\\(\\[1.0, 2.0, 3.0000000001\\], dtype='float64'\\)"""
+
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_index_equal(idx1, idx2, check_exact=check_exact)
+    else:
+        tm.assert_index_equal(idx1, idx2, check_exact=check_exact)
+
+
+def test_index_equal_values_less_close(check_exact, rtol):
+    idx1 = Index([1, 2, 3.0])
+    idx2 = Index([1, 2, 3.0001])
+    kwargs = {"check_exact": check_exact, "rtol": rtol}
+
+    if check_exact or rtol < 0.5e-3:
+        msg = """Index are different
+
+Index values are different \\(33\\.33333 %\\)
+\\[left\\]:  Float64Index\\(\\[1.0, 2.0, 3.0], dtype='float64'\\)
+\\[right\\]: Float64Index\\(\\[1.0, 2.0, 3.0001\\], dtype='float64'\\)"""
+
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_index_equal(idx1, idx2, **kwargs)
+    else:
+        tm.assert_index_equal(idx1, idx2, **kwargs)
+
+
+def test_index_equal_values_too_far(check_exact, rtol):
+    idx1 = Index([1, 2, 3])
+    idx2 = Index([1, 2, 4])
+    kwargs = {"check_exact": check_exact, "rtol": rtol}
+
+    msg = """Index are different
+
+Index values are different \\(33\\.33333 %\\)
+\\[left\\]:  Int64Index\\(\\[1, 2, 3\\], dtype='int64'\\)
+\\[right\\]: Int64Index\\(\\[1, 2, 4\\], dtype='int64'\\)"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_index_equal(idx1, idx2, **kwargs)
+
+
+@pytest.mark.parametrize("check_order", [True, False])
+def test_index_equal_value_oder_mismatch(check_exact, rtol, check_order):
+    idx1 = Index([1, 2, 3])
+    idx2 = Index([3, 2, 1])
+
+    msg = """Index are different
+
+Index values are different \\(66\\.66667 %\\)
+\\[left\\]:  Int64Index\\(\\[1, 2, 3\\], dtype='int64'\\)
+\\[right\\]: Int64Index\\(\\[3, 2, 1\\], dtype='int64'\\)"""
+
+    if check_order:
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_index_equal(
+                idx1, idx2, check_exact=check_exact, rtol=rtol, check_order=True
+            )
+    else:
+        tm.assert_index_equal(
+            idx1, idx2, check_exact=check_exact, rtol=rtol, check_order=False
+        )
+
+
+def test_index_equal_level_values_mismatch(check_exact, rtol):
+    idx1 = MultiIndex.from_tuples([("A", 2), ("A", 2), ("B", 3), ("B", 4)])
+    idx2 = MultiIndex.from_tuples([("A", 1), ("A", 2), ("B", 3), ("B", 4)])
+    kwargs = {"check_exact": check_exact, "rtol": rtol}
+
+    msg = """MultiIndex level \\[1\\] are different
+
+MultiIndex level \\[1\\] values are different \\(25\\.0 %\\)
+\\[left\\]:  Int64Index\\(\\[2, 2, 3, 4\\], dtype='int64'\\)
+\\[right\\]: Int64Index\\(\\[1, 2, 3, 4\\], dtype='int64'\\)"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_index_equal(idx1, idx2, **kwargs)
+
+
+@pytest.mark.parametrize(
+    "name1,name2",
+    [(None, "x"), ("x", "x"), (np.nan, np.nan), (NaT, NaT), (np.nan, NaT)],
+)
+def test_index_equal_names(name1, name2):
+
+    idx1 = Index([1, 2, 3], name=name1)
+    idx2 = Index([1, 2, 3], name=name2)
+
+    if name1 == name2 or name1 is name2:
+        tm.assert_index_equal(idx1, idx2)
+    else:
+        name1 = "'x'" if name1 == "x" else name1
+        name2 = "'x'" if name2 == "x" else name2
+        msg = f"""Index are different
+
+Attribute "names" are different
+\\[left\\]:  \\[{name1}\\]
+\\[right\\]: \\[{name2}\\]"""
+
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_index_equal(idx1, idx2)
+
+
+def test_index_equal_category_mismatch(check_categorical):
+    msg = """Index are different
+
+Attribute "dtype" are different
+\\[left\\]:  CategoricalDtype\\(categories=\\['a', 'b'\\], ordered=False\\)
+\\[right\\]: CategoricalDtype\\(categories=\\['a', 'b', 'c'\\], \
+ordered=False\\)"""
+
+    idx1 = Index(Categorical(["a", "b"]))
+    idx2 = Index(Categorical(["a", "b"], categories=["a", "b", "c"]))
+
+    if check_categorical:
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_index_equal(idx1, idx2, check_categorical=check_categorical)
+    else:
+        tm.assert_index_equal(idx1, idx2, check_categorical=check_categorical)
+
+
+@pytest.mark.parametrize("exact", [False, True])
+def test_index_equal_range_categories(check_categorical, exact):
+    # GH41263
+    msg = """\
+Index are different
+
+Index classes are different
+\\[left\\]:  RangeIndex\\(start=0, stop=10, step=1\\)
+\\[right\\]: Int64Index\\(\\[0, 1, 2, 3, 4, 5, 6, 7, 8, 9\\], dtype='int64'\\)"""
+
+    rcat = CategoricalIndex(RangeIndex(10))
+    icat = CategoricalIndex(list(range(10)))
+
+    if check_categorical and exact:
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_index_equal(rcat, icat, check_categorical=True, exact=True)
+    else:
+        tm.assert_index_equal(
+            rcat, icat, check_categorical=check_categorical, exact=exact
+        )
+
+
+def test_assert_index_equal_mixed_dtype():
+    # GH#39168
+    idx = Index(["foo", "bar", 42])
+    tm.assert_index_equal(idx, idx, check_order=False)

.venv/Lib/site-packages/pandas/tests/util/test_assert_interval_array_equal.py

@@ -0,0 +1,81 @@
+import pytest
+
+from pandas import interval_range
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        {"start": 0, "periods": 4},
+        {"start": 1, "periods": 5},
+        {"start": 5, "end": 10, "closed": "left"},
+    ],
+)
+def test_interval_array_equal(kwargs):
+    arr = interval_range(**kwargs).values
+    tm.assert_interval_array_equal(arr, arr)
+
+
+def test_interval_array_equal_closed_mismatch():
+    kwargs = {"start": 0, "periods": 5}
+    arr1 = interval_range(closed="left", **kwargs).values
+    arr2 = interval_range(closed="right", **kwargs).values
+
+    msg = """\
+IntervalArray are different
+
+Attribute "closed" are different
+\\[left\\]:  left
+\\[right\\]: right"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_interval_array_equal(arr1, arr2)
+
+
+def test_interval_array_equal_periods_mismatch():
+    kwargs = {"start": 0}
+    arr1 = interval_range(periods=5, **kwargs).values
+    arr2 = interval_range(periods=6, **kwargs).values
+
+    msg = """\
+IntervalArray.left are different
+
+IntervalArray.left shapes are different
+\\[left\\]:  \\(5,\\)
+\\[right\\]: \\(6,\\)"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_interval_array_equal(arr1, arr2)
+
+
+def test_interval_array_equal_end_mismatch():
+    kwargs = {"start": 0, "periods": 5}
+    arr1 = interval_range(end=10, **kwargs).values
+    arr2 = interval_range(end=20, **kwargs).values
+
+    msg = """\
+IntervalArray.left are different
+
+IntervalArray.left values are different \\(80.0 %\\)
+\\[left\\]:  \\[0, 2, 4, 6, 8\\]
+\\[right\\]: \\[0, 4, 8, 12, 16\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_interval_array_equal(arr1, arr2)
+
+
+def test_interval_array_equal_start_mismatch():
+    kwargs = {"periods": 4}
+    arr1 = interval_range(start=0, **kwargs).values
+    arr2 = interval_range(start=1, **kwargs).values
+
+    msg = """\
+IntervalArray.left are different
+
+IntervalArray.left values are different \\(100.0 %\\)
+\\[left\\]:  \\[0, 1, 2, 3\\]
+\\[right\\]: \\[1, 2, 3, 4\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_interval_array_equal(arr1, arr2)

.venv/Lib/site-packages/pandas/tests/util/test_assert_numpy_array_equal.py

@@ -0,0 +1,223 @@
+import copy
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import Timestamp
+import pandas._testing as tm
+
+
+def test_assert_numpy_array_equal_shape_mismatch():
+    msg = """numpy array are different
+
+numpy array shapes are different
+\\[left\\]:  \\(2L*,\\)
+\\[right\\]: \\(3L*,\\)"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_numpy_array_equal(np.array([1, 2]), np.array([3, 4, 5]))
+
+
+def test_assert_numpy_array_equal_bad_type():
+    expected = "Expected type"
+
+    with pytest.raises(AssertionError, match=expected):
+        tm.assert_numpy_array_equal(1, 2)
+
+
+@pytest.mark.parametrize(
+    "a,b,klass1,klass2",
+    [(np.array([1]), 1, "ndarray", "int"), (1, np.array([1]), "int", "ndarray")],
+)
+def test_assert_numpy_array_equal_class_mismatch(a, b, klass1, klass2):
+    msg = f"""numpy array are different
+
+numpy array classes are different
+\\[left\\]:  {klass1}
+\\[right\\]: {klass2}"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_numpy_array_equal(a, b)
+
+
+def test_assert_numpy_array_equal_value_mismatch1():
+    msg = """numpy array are different
+
+numpy array values are different \\(66\\.66667 %\\)
+\\[left\\]:  \\[nan, 2\\.0, 3\\.0\\]
+\\[right\\]: \\[1\\.0, nan, 3\\.0\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_numpy_array_equal(np.array([np.nan, 2, 3]), np.array([1, np.nan, 3]))
+
+
+def test_assert_numpy_array_equal_value_mismatch2():
+    msg = """numpy array are different
+
+numpy array values are different \\(50\\.0 %\\)
+\\[left\\]:  \\[1, 2\\]
+\\[right\\]: \\[1, 3\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_numpy_array_equal(np.array([1, 2]), np.array([1, 3]))
+
+
+def test_assert_numpy_array_equal_value_mismatch3():
+    msg = """numpy array are different
+
+numpy array values are different \\(16\\.66667 %\\)
+\\[left\\]:  \\[\\[1, 2\\], \\[3, 4\\], \\[5, 6\\]\\]
+\\[right\\]: \\[\\[1, 3\\], \\[3, 4\\], \\[5, 6\\]\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_numpy_array_equal(
+            np.array([[1, 2], [3, 4], [5, 6]]), np.array([[1, 3], [3, 4], [5, 6]])
+        )
+
+
+def test_assert_numpy_array_equal_value_mismatch4():
+    msg = """numpy array are different
+
+numpy array values are different \\(50\\.0 %\\)
+\\[left\\]:  \\[1\\.1, 2\\.000001\\]
+\\[right\\]: \\[1\\.1, 2.0\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_numpy_array_equal(np.array([1.1, 2.000001]), np.array([1.1, 2.0]))
+
+
+def test_assert_numpy_array_equal_value_mismatch5():
+    msg = """numpy array are different
+
+numpy array values are different \\(16\\.66667 %\\)
+\\[left\\]:  \\[\\[1, 2\\], \\[3, 4\\], \\[5, 6\\]\\]
+\\[right\\]: \\[\\[1, 3\\], \\[3, 4\\], \\[5, 6\\]\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_numpy_array_equal(
+            np.array([[1, 2], [3, 4], [5, 6]]), np.array([[1, 3], [3, 4], [5, 6]])
+        )
+
+
+def test_assert_numpy_array_equal_value_mismatch6():
+    msg = """numpy array are different
+
+numpy array values are different \\(25\\.0 %\\)
+\\[left\\]:  \\[\\[1, 2\\], \\[3, 4\\]\\]
+\\[right\\]: \\[\\[1, 3\\], \\[3, 4\\]\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_numpy_array_equal(
+            np.array([[1, 2], [3, 4]]), np.array([[1, 3], [3, 4]])
+        )
+
+
+def test_assert_numpy_array_equal_shape_mismatch_override():
+    msg = """Index are different
+
+Index shapes are different
+\\[left\\]:  \\(2L*,\\)
+\\[right\\]: \\(3L*,\\)"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_numpy_array_equal(np.array([1, 2]), np.array([3, 4, 5]), obj="Index")
+
+
+def test_numpy_array_equal_unicode():
+    # see gh-20503
+    #
+    # Test ensures that `tm.assert_numpy_array_equals` raises the right
+    # exception when comparing np.arrays containing differing unicode objects.
+    msg = """numpy array are different
+
+numpy array values are different \\(33\\.33333 %\\)
+\\[left\\]:  \\[á, à, ä\\]
+\\[right\\]: \\[á, à, å\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_numpy_array_equal(
+            np.array(["á", "à", "ä"]), np.array(["á", "à", "å"])
+        )
+
+
+def test_numpy_array_equal_object():
+    a = np.array([Timestamp("2011-01-01"), Timestamp("2011-01-01")])
+    b = np.array([Timestamp("2011-01-01"), Timestamp("2011-01-02")])
+
+    msg = """numpy array are different
+
+numpy array values are different \\(50\\.0 %\\)
+\\[left\\]:  \\[2011-01-01 00:00:00, 2011-01-01 00:00:00\\]
+\\[right\\]: \\[2011-01-01 00:00:00, 2011-01-02 00:00:00\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_numpy_array_equal(a, b)
+
+
+@pytest.mark.parametrize("other_type", ["same", "copy"])
+@pytest.mark.parametrize("check_same", ["same", "copy"])
+def test_numpy_array_equal_copy_flag(other_type, check_same):
+    a = np.array([1, 2, 3])
+    msg = None
+
+    if other_type == "same":
+        other = a.view()
+    else:
+        other = a.copy()
+
+    if check_same != other_type:
+        msg = (
+            r"array\(\[1, 2, 3\]\) is not array\(\[1, 2, 3\]\)"
+            if check_same == "same"
+            else r"array\(\[1, 2, 3\]\) is array\(\[1, 2, 3\]\)"
+        )
+
+    if msg is not None:
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_numpy_array_equal(a, other, check_same=check_same)
+    else:
+        tm.assert_numpy_array_equal(a, other, check_same=check_same)
+
+
+def test_numpy_array_equal_contains_na():
+    # https://github.com/pandas-dev/pandas/issues/31881
+    a = np.array([True, False])
+    b = np.array([True, pd.NA], dtype=object)
+
+    msg = """numpy array are different
+
+numpy array values are different \\(50.0 %\\)
+\\[left\\]:  \\[True, False\\]
+\\[right\\]: \\[True, <NA>\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_numpy_array_equal(a, b)
+
+
+def test_numpy_array_equal_identical_na(nulls_fixture):
+    a = np.array([nulls_fixture], dtype=object)
+
+    tm.assert_numpy_array_equal(a, a)
+
+    # matching but not the identical object
+    if hasattr(nulls_fixture, "copy"):
+        other = nulls_fixture.copy()
+    else:
+        other = copy.copy(nulls_fixture)
+    b = np.array([other], dtype=object)
+    tm.assert_numpy_array_equal(a, b)
+
+
+def test_numpy_array_equal_different_na():
+    a = np.array([np.nan], dtype=object)
+    b = np.array([pd.NA], dtype=object)
+
+    msg = """numpy array are different
+
+numpy array values are different \\(100.0 %\\)
+\\[left\\]:  \\[nan\\]
+\\[right\\]: \\[<NA>\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_numpy_array_equal(a, b)

.venv/Lib/site-packages/pandas/tests/util/test_assert_produces_warning.py

@@ -0,0 +1,204 @@
+""""
+Test module for testing ``pandas._testing.assert_produces_warning``.
+"""
+import warnings
+
+import pytest
+
+from pandas.errors import (
+    DtypeWarning,
+    PerformanceWarning,
+)
+
+import pandas._testing as tm
+
+
+@pytest.fixture(
+    params=[
+        RuntimeWarning,
+        ResourceWarning,
+        UserWarning,
+        FutureWarning,
+        DeprecationWarning,
+        PerformanceWarning,
+        DtypeWarning,
+    ],
+)
+def category(request):
+    """
+    Return unique warning.
+
+    Useful for testing behavior of tm.assert_produces_warning with various categories.
+    """
+    return request.param
+
+
+@pytest.fixture(
+    params=[
+        (RuntimeWarning, UserWarning),
+        (UserWarning, FutureWarning),
+        (FutureWarning, RuntimeWarning),
+        (DeprecationWarning, PerformanceWarning),
+        (PerformanceWarning, FutureWarning),
+        (DtypeWarning, DeprecationWarning),
+        (ResourceWarning, DeprecationWarning),
+        (FutureWarning, DeprecationWarning),
+    ],
+    ids=lambda x: type(x).__name__,
+)
+def pair_different_warnings(request):
+    """
+    Return pair or different warnings.
+
+    Useful for testing how several different warnings are handled
+    in tm.assert_produces_warning.
+    """
+    return request.param
+
+
+def f():
+    warnings.warn("f1", FutureWarning)
+    warnings.warn("f2", RuntimeWarning)
+
+
+@pytest.mark.filterwarnings("ignore:f1:FutureWarning")
+def test_assert_produces_warning_honors_filter():
+    # Raise by default.
+    msg = r"Caused unexpected warning\(s\)"
+    with pytest.raises(AssertionError, match=msg):
+        with tm.assert_produces_warning(RuntimeWarning):
+            f()
+
+    with tm.assert_produces_warning(RuntimeWarning, raise_on_extra_warnings=False):
+        f()
+
+
+@pytest.mark.parametrize(
+    "message, match",
+    [
+        ("", None),
+        ("", ""),
+        ("Warning message", r".*"),
+        ("Warning message", "War"),
+        ("Warning message", r"[Ww]arning"),
+        ("Warning message", "age"),
+        ("Warning message", r"age$"),
+        ("Message 12-234 with numbers", r"\d{2}-\d{3}"),
+        ("Message 12-234 with numbers", r"^Mes.*\d{2}-\d{3}"),
+        ("Message 12-234 with numbers", r"\d{2}-\d{3}\s\S+"),
+        ("Message, which we do not match", None),
+    ],
+)
+def test_catch_warning_category_and_match(category, message, match):
+    with tm.assert_produces_warning(category, match=match):
+        warnings.warn(message, category)
+
+
+def test_fail_to_match_runtime_warning():
+    category = RuntimeWarning
+    match = "Did not see this warning"
+    unmatched = (
+        r"Did not see warning 'RuntimeWarning' matching 'Did not see this warning'. "
+        r"The emitted warning messages are "
+        r"\[RuntimeWarning\('This is not a match.'\), "
+        r"RuntimeWarning\('Another unmatched warning.'\)\]"
+    )
+    with pytest.raises(AssertionError, match=unmatched):
+        with tm.assert_produces_warning(category, match=match):
+            warnings.warn("This is not a match.", category)
+            warnings.warn("Another unmatched warning.", category)
+
+
+def test_fail_to_match_future_warning():
+    category = FutureWarning
+    match = "Warning"
+    unmatched = (
+        r"Did not see warning 'FutureWarning' matching 'Warning'. "
+        r"The emitted warning messages are "
+        r"\[FutureWarning\('This is not a match.'\), "
+        r"FutureWarning\('Another unmatched warning.'\)\]"
+    )
+    with pytest.raises(AssertionError, match=unmatched):
+        with tm.assert_produces_warning(category, match=match):
+            warnings.warn("This is not a match.", category)
+            warnings.warn("Another unmatched warning.", category)
+
+
+def test_fail_to_match_resource_warning():
+    category = ResourceWarning
+    match = r"\d+"
+    unmatched = (
+        r"Did not see warning 'ResourceWarning' matching '\\d\+'. "
+        r"The emitted warning messages are "
+        r"\[ResourceWarning\('This is not a match.'\), "
+        r"ResourceWarning\('Another unmatched warning.'\)\]"
+    )
+    with pytest.raises(AssertionError, match=unmatched):
+        with tm.assert_produces_warning(category, match=match):
+            warnings.warn("This is not a match.", category)
+            warnings.warn("Another unmatched warning.", category)
+
+
+def test_fail_to_catch_actual_warning(pair_different_warnings):
+    expected_category, actual_category = pair_different_warnings
+    match = "Did not see expected warning of class"
+    with pytest.raises(AssertionError, match=match):
+        with tm.assert_produces_warning(expected_category):
+            warnings.warn("warning message", actual_category)
+
+
+def test_ignore_extra_warning(pair_different_warnings):
+    expected_category, extra_category = pair_different_warnings
+    with tm.assert_produces_warning(expected_category, raise_on_extra_warnings=False):
+        warnings.warn("Expected warning", expected_category)
+        warnings.warn("Unexpected warning OK", extra_category)
+
+
+def test_raise_on_extra_warning(pair_different_warnings):
+    expected_category, extra_category = pair_different_warnings
+    match = r"Caused unexpected warning\(s\)"
+    with pytest.raises(AssertionError, match=match):
+        with tm.assert_produces_warning(expected_category):
+            warnings.warn("Expected warning", expected_category)
+            warnings.warn("Unexpected warning NOT OK", extra_category)
+
+
+def test_same_category_different_messages_first_match():
+    category = UserWarning
+    with tm.assert_produces_warning(category, match=r"^Match this"):
+        warnings.warn("Match this", category)
+        warnings.warn("Do not match that", category)
+        warnings.warn("Do not match that either", category)
+
+
+def test_same_category_different_messages_last_match():
+    category = DeprecationWarning
+    with tm.assert_produces_warning(category, match=r"^Match this"):
+        warnings.warn("Do not match that", category)
+        warnings.warn("Do not match that either", category)
+        warnings.warn("Match this", category)
+
+
+def test_right_category_wrong_match_raises(pair_different_warnings):
+    target_category, other_category = pair_different_warnings
+    with pytest.raises(AssertionError, match="Did not see warning.*matching"):
+        with tm.assert_produces_warning(target_category, match=r"^Match this"):
+            warnings.warn("Do not match it", target_category)
+            warnings.warn("Match this", other_category)
+
+
+@pytest.mark.parametrize("false_or_none", [False, None])
+class TestFalseOrNoneExpectedWarning:
+    def test_raise_on_warning(self, false_or_none):
+        msg = r"Caused unexpected warning\(s\)"
+        with pytest.raises(AssertionError, match=msg):
+            with tm.assert_produces_warning(false_or_none):
+                f()
+
+    def test_no_raise_without_warning(self, false_or_none):
+        with tm.assert_produces_warning(false_or_none):
+            pass
+
+    def test_no_raise_with_false_raise_on_extra(self, false_or_none):
+        with tm.assert_produces_warning(false_or_none, raise_on_extra_warnings=False):
+            f()

.venv/Lib/site-packages/pandas/tests/util/test_assert_series_equal.py

@@ -0,0 +1,353 @@
+import pytest
+
+from pandas.core.dtypes.common import is_extension_array_dtype
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+
+
+def _assert_series_equal_both(a, b, **kwargs):
+    """
+    Check that two Series equal.
+
+    This check is performed commutatively.
+
+    Parameters
+    ----------
+    a : Series
+        The first Series to compare.
+    b : Series
+        The second Series to compare.
+    kwargs : dict
+        The arguments passed to `tm.assert_series_equal`.
+    """
+    tm.assert_series_equal(a, b, **kwargs)
+    tm.assert_series_equal(b, a, **kwargs)
+
+
+def _assert_not_series_equal(a, b, **kwargs):
+    """
+    Check that two Series are not equal.
+
+    Parameters
+    ----------
+    a : Series
+        The first Series to compare.
+    b : Series
+        The second Series to compare.
+    kwargs : dict
+        The arguments passed to `tm.assert_series_equal`.
+    """
+    try:
+        tm.assert_series_equal(a, b, **kwargs)
+        msg = "The two Series were equal when they shouldn't have been"
+
+        pytest.fail(msg=msg)
+    except AssertionError:
+        pass
+
+
+def _assert_not_series_equal_both(a, b, **kwargs):
+    """
+    Check that two Series are not equal.
+
+    This check is performed commutatively.
+
+    Parameters
+    ----------
+    a : Series
+        The first Series to compare.
+    b : Series
+        The second Series to compare.
+    kwargs : dict
+        The arguments passed to `tm.assert_series_equal`.
+    """
+    _assert_not_series_equal(a, b, **kwargs)
+    _assert_not_series_equal(b, a, **kwargs)
+
+
+@pytest.mark.parametrize("data", [range(3), list("abc"), list("áàä")])
+def test_series_equal(data):
+    _assert_series_equal_both(Series(data), Series(data))
+
+
+@pytest.mark.parametrize(
+    "data1,data2",
+    [
+        (range(3), range(1, 4)),
+        (list("abc"), list("xyz")),
+        (list("áàä"), list("éèë")),
+        (list("áàä"), list(b"aaa")),
+        (range(3), range(4)),
+    ],
+)
+def test_series_not_equal_value_mismatch(data1, data2):
+    _assert_not_series_equal_both(Series(data1), Series(data2))
+
+
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        {"dtype": "float64"},  # dtype mismatch
+        {"index": [1, 2, 4]},  # index mismatch
+        {"name": "foo"},  # name mismatch
+    ],
+)
+def test_series_not_equal_metadata_mismatch(kwargs):
+    data = range(3)
+    s1 = Series(data)
+
+    s2 = Series(data, **kwargs)
+    _assert_not_series_equal_both(s1, s2)
+
+
+@pytest.mark.parametrize("data1,data2", [(0.12345, 0.12346), (0.1235, 0.1236)])
+@pytest.mark.parametrize("dtype", ["float32", "float64", "Float32"])
+@pytest.mark.parametrize("decimals", [0, 1, 2, 3, 5, 10])
+def test_less_precise(data1, data2, dtype, decimals):
+    rtol = 10**-decimals
+    s1 = Series([data1], dtype=dtype)
+    s2 = Series([data2], dtype=dtype)
+
+    if (decimals == 5 or decimals == 10) or (
+        decimals >= 3 and abs(data1 - data2) >= 0.0005
+    ):
+        if is_extension_array_dtype(dtype):
+            msg = "ExtensionArray are different"
+        else:
+            msg = "Series values are different"
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_series_equal(s1, s2, rtol=rtol)
+    else:
+        _assert_series_equal_both(s1, s2, rtol=rtol)
+
+
+@pytest.mark.parametrize(
+    "s1,s2,msg",
+    [
+        # Index
+        (
+            Series(["l1", "l2"], index=[1, 2]),
+            Series(["l1", "l2"], index=[1.0, 2.0]),
+            "Series\\.index are different",
+        ),
+        # MultiIndex
+        (
+            DataFrame.from_records(
+                {"a": [1, 2], "b": [2.1, 1.5], "c": ["l1", "l2"]}, index=["a", "b"]
+            ).c,
+            DataFrame.from_records(
+                {"a": [1.0, 2.0], "b": [2.1, 1.5], "c": ["l1", "l2"]}, index=["a", "b"]
+            ).c,
+            "MultiIndex level \\[0\\] are different",
+        ),
+    ],
+)
+def test_series_equal_index_dtype(s1, s2, msg, check_index_type):
+    kwargs = {"check_index_type": check_index_type}
+
+    if check_index_type:
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_series_equal(s1, s2, **kwargs)
+    else:
+        tm.assert_series_equal(s1, s2, **kwargs)
+
+
+def test_series_equal_length_mismatch(rtol):
+    msg = """Series are different
+
+Series length are different
+\\[left\\]:  3, RangeIndex\\(start=0, stop=3, step=1\\)
+\\[right\\]: 4, RangeIndex\\(start=0, stop=4, step=1\\)"""
+
+    s1 = Series([1, 2, 3])
+    s2 = Series([1, 2, 3, 4])
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_series_equal(s1, s2, rtol=rtol)
+
+
+def test_series_equal_numeric_values_mismatch(rtol):
+    msg = """Series are different
+
+Series values are different \\(33\\.33333 %\\)
+\\[index\\]: \\[0, 1, 2\\]
+\\[left\\]:  \\[1, 2, 3\\]
+\\[right\\]: \\[1, 2, 4\\]"""
+
+    s1 = Series([1, 2, 3])
+    s2 = Series([1, 2, 4])
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_series_equal(s1, s2, rtol=rtol)
+
+
+def test_series_equal_categorical_values_mismatch(rtol):
+    msg = """Series are different
+
+Series values are different \\(66\\.66667 %\\)
+\\[index\\]: \\[0, 1, 2\\]
+\\[left\\]:  \\['a', 'b', 'c'\\]
+Categories \\(3, object\\): \\['a', 'b', 'c'\\]
+\\[right\\]: \\['a', 'c', 'b'\\]
+Categories \\(3, object\\): \\['a', 'b', 'c'\\]"""
+
+    s1 = Series(Categorical(["a", "b", "c"]))
+    s2 = Series(Categorical(["a", "c", "b"]))
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_series_equal(s1, s2, rtol=rtol)
+
+
+def test_series_equal_datetime_values_mismatch(rtol):
+    msg = """numpy array are different
+
+numpy array values are different \\(100.0 %\\)
+\\[index\\]: \\[0, 1, 2\\]
+\\[left\\]:  \\[1514764800000000000, 1514851200000000000, 1514937600000000000\\]
+\\[right\\]: \\[1549065600000000000, 1549152000000000000, 1549238400000000000\\]"""
+
+    s1 = Series(pd.date_range("2018-01-01", periods=3, freq="D"))
+    s2 = Series(pd.date_range("2019-02-02", periods=3, freq="D"))
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_series_equal(s1, s2, rtol=rtol)
+
+
+def test_series_equal_categorical_mismatch(check_categorical):
+    msg = """Attributes of Series are different
+
+Attribute "dtype" are different
+\\[left\\]:  CategoricalDtype\\(categories=\\['a', 'b'\\], ordered=False\\)
+\\[right\\]: CategoricalDtype\\(categories=\\['a', 'b', 'c'\\], \
+ordered=False\\)"""
+
+    s1 = Series(Categorical(["a", "b"]))
+    s2 = Series(Categorical(["a", "b"], categories=list("abc")))
+
+    if check_categorical:
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_series_equal(s1, s2, check_categorical=check_categorical)
+    else:
+        _assert_series_equal_both(s1, s2, check_categorical=check_categorical)
+
+
+def test_assert_series_equal_extension_dtype_mismatch():
+    # https://github.com/pandas-dev/pandas/issues/32747
+    left = Series(pd.array([1, 2, 3], dtype="Int64"))
+    right = left.astype(int)
+
+    msg = """Attributes of Series are different
+
+Attribute "dtype" are different
+\\[left\\]:  Int64
+\\[right\\]: int[32|64]"""
+
+    tm.assert_series_equal(left, right, check_dtype=False)
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_series_equal(left, right, check_dtype=True)
+
+
+def test_assert_series_equal_interval_dtype_mismatch():
+    # https://github.com/pandas-dev/pandas/issues/32747
+    left = Series([pd.Interval(0, 1)], dtype="interval")
+    right = left.astype(object)
+
+    msg = """Attributes of Series are different
+
+Attribute "dtype" are different
+\\[left\\]:  interval\\[int64, right\\]
+\\[right\\]: object"""
+
+    tm.assert_series_equal(left, right, check_dtype=False)
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_series_equal(left, right, check_dtype=True)
+
+
+def test_series_equal_series_type():
+    class MySeries(Series):
+        pass
+
+    s1 = Series([1, 2])
+    s2 = Series([1, 2])
+    s3 = MySeries([1, 2])
+
+    tm.assert_series_equal(s1, s2, check_series_type=False)
+    tm.assert_series_equal(s1, s2, check_series_type=True)
+
+    tm.assert_series_equal(s1, s3, check_series_type=False)
+    tm.assert_series_equal(s3, s1, check_series_type=False)
+
+    with pytest.raises(AssertionError, match="Series classes are different"):
+        tm.assert_series_equal(s1, s3, check_series_type=True)
+
+    with pytest.raises(AssertionError, match="Series classes are different"):
+        tm.assert_series_equal(s3, s1, check_series_type=True)
+
+
+def test_series_equal_exact_for_nonnumeric():
+    # https://github.com/pandas-dev/pandas/issues/35446
+    s1 = Series(["a", "b"])
+    s2 = Series(["a", "b"])
+    s3 = Series(["b", "a"])
+
+    tm.assert_series_equal(s1, s2, check_exact=True)
+    tm.assert_series_equal(s2, s1, check_exact=True)
+
+    msg = """Series are different
+
+Series values are different \\(100\\.0 %\\)
+\\[index\\]: \\[0, 1\\]
+\\[left\\]:  \\[a, b\\]
+\\[right\\]: \\[b, a\\]"""
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_series_equal(s1, s3, check_exact=True)
+
+    msg = """Series are different
+
+Series values are different \\(100\\.0 %\\)
+\\[index\\]: \\[0, 1\\]
+\\[left\\]:  \\[b, a\\]
+\\[right\\]: \\[a, b\\]"""
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_series_equal(s3, s1, check_exact=True)
+
+
+@pytest.mark.parametrize("right_dtype", ["Int32", "int64"])
+def test_assert_series_equal_ignore_extension_dtype_mismatch(right_dtype):
+    # https://github.com/pandas-dev/pandas/issues/35715
+    left = Series([1, 2, 3], dtype="Int64")
+    right = Series([1, 2, 3], dtype=right_dtype)
+    tm.assert_series_equal(left, right, check_dtype=False)
+
+
+def test_allows_duplicate_labels():
+    left = Series([1])
+    right = Series([1]).set_flags(allows_duplicate_labels=False)
+    tm.assert_series_equal(left, left)
+    tm.assert_series_equal(right, right)
+    tm.assert_series_equal(left, right, check_flags=False)
+    tm.assert_series_equal(right, left, check_flags=False)
+
+    with pytest.raises(AssertionError, match="<Flags"):
+        tm.assert_series_equal(left, right)
+
+    with pytest.raises(AssertionError, match="<Flags"):
+        tm.assert_series_equal(left, right)
+
+
+def test_assert_series_equal_identical_na(nulls_fixture):
+    ser = Series([nulls_fixture])
+
+    tm.assert_series_equal(ser, ser.copy())
+
+    # while we're here do Index too
+    idx = pd.Index(ser)
+    tm.assert_index_equal(idx, idx.copy(deep=True))

.venv/Lib/site-packages/pandas/tests/util/test_deprecate.py

@@ -0,0 +1,64 @@
+from textwrap import dedent
+
+import pytest
+
+from pandas.util._decorators import deprecate
+
+import pandas._testing as tm
+
+
+def new_func():
+    """
+    This is the summary. The deprecate directive goes next.
+
+    This is the extended summary. The deprecate directive goes before this.
+    """
+    return "new_func called"
+
+
+def new_func_no_docstring():
+    return "new_func_no_docstring called"
+
+
+def new_func_wrong_docstring():
+    """Summary should be in the next line."""
+    return "new_func_wrong_docstring called"
+
+
+def new_func_with_deprecation():
+    """
+    This is the summary. The deprecate directive goes next.
+
+    .. deprecated:: 1.0
+        Use new_func instead.
+
+    This is the extended summary. The deprecate directive goes before this.
+    """
+    pass
+
+
+def test_deprecate_ok():
+    depr_func = deprecate("depr_func", new_func, "1.0", msg="Use new_func instead.")
+
+    with tm.assert_produces_warning(FutureWarning):
+        result = depr_func()
+
+    assert result == "new_func called"
+    assert depr_func.__doc__ == dedent(new_func_with_deprecation.__doc__)
+
+
+def test_deprecate_no_docstring():
+    depr_func = deprecate(
+        "depr_func", new_func_no_docstring, "1.0", msg="Use new_func instead."
+    )
+    with tm.assert_produces_warning(FutureWarning):
+        result = depr_func()
+    assert result == "new_func_no_docstring called"
+
+
+def test_deprecate_wrong_docstring():
+    msg = "deprecate needs a correctly formatted docstring"
+    with pytest.raises(AssertionError, match=msg):
+        deprecate(
+            "depr_func", new_func_wrong_docstring, "1.0", msg="Use new_func instead."
+        )

.venv/Lib/site-packages/pandas/tests/util/test_deprecate_kwarg.py

@@ -0,0 +1,90 @@
+import pytest
+
+from pandas.util._decorators import deprecate_kwarg
+
+import pandas._testing as tm
+
+
+@deprecate_kwarg("old", "new")
+def _f1(new=False):
+    return new
+
+
+_f2_mappings = {"yes": True, "no": False}
+
+
+@deprecate_kwarg("old", "new", _f2_mappings)
+def _f2(new=False):
+    return new
+
+
+def _f3_mapping(x):
+    return x + 1
+
+
+@deprecate_kwarg("old", "new", _f3_mapping)
+def _f3(new=0):
+    return new
+
+
+@pytest.mark.parametrize("key,klass", [("old", FutureWarning), ("new", None)])
+def test_deprecate_kwarg(key, klass):
+    x = 78
+
+    with tm.assert_produces_warning(klass):
+        assert _f1(**{key: x}) == x
+
+
+@pytest.mark.parametrize("key", list(_f2_mappings.keys()))
+def test_dict_deprecate_kwarg(key):
+    with tm.assert_produces_warning(FutureWarning):
+        assert _f2(old=key) == _f2_mappings[key]
+
+
+@pytest.mark.parametrize("key", ["bogus", 12345, -1.23])
+def test_missing_deprecate_kwarg(key):
+    with tm.assert_produces_warning(FutureWarning):
+        assert _f2(old=key) == key
+
+
+@pytest.mark.parametrize("x", [1, -1.4, 0])
+def test_callable_deprecate_kwarg(x):
+    with tm.assert_produces_warning(FutureWarning):
+        assert _f3(old=x) == _f3_mapping(x)
+
+
+def test_callable_deprecate_kwarg_fail():
+    msg = "((can only|cannot) concatenate)|(must be str)|(Can't convert)"
+
+    with pytest.raises(TypeError, match=msg):
+        _f3(old="hello")
+
+
+def test_bad_deprecate_kwarg():
+    msg = "mapping from old to new argument values must be dict or callable!"
+
+    with pytest.raises(TypeError, match=msg):
+
+        @deprecate_kwarg("old", "new", 0)
+        def f4(new=None):
+            return new
+
+
+@deprecate_kwarg("old", None)
+def _f4(old=True, unchanged=True):
+    return old, unchanged
+
+
+@pytest.mark.parametrize("key", ["old", "unchanged"])
+def test_deprecate_keyword(key):
+    x = 9
+
+    if key == "old":
+        klass = FutureWarning
+        expected = (x, True)
+    else:
+        klass = None
+        expected = (True, x)
+
+    with tm.assert_produces_warning(klass):
+        assert _f4(**{key: x}) == expected

.venv/Lib/site-packages/pandas/tests/util/test_deprecate_nonkeyword_arguments.py

@@ -0,0 +1,116 @@
+"""
+Tests for the `deprecate_nonkeyword_arguments` decorator
+"""
+
+import warnings
+
+from pandas.util._decorators import deprecate_nonkeyword_arguments
+
+import pandas._testing as tm
+
+
+@deprecate_nonkeyword_arguments(version="1.1", allowed_args=["a", "b"])
+def f(a, b=0, c=0, d=0):
+    return a + b + c + d
+
+
+def test_one_argument():
+    with tm.assert_produces_warning(None):
+        assert f(19) == 19
+
+
+def test_one_and_one_arguments():
+    with tm.assert_produces_warning(None):
+        assert f(19, d=6) == 25
+
+
+def test_two_arguments():
+    with tm.assert_produces_warning(None):
+        assert f(1, 5) == 6
+
+
+def test_two_and_two_arguments():
+    with tm.assert_produces_warning(None):
+        assert f(1, 3, c=3, d=5) == 12
+
+
+def test_three_arguments():
+    with tm.assert_produces_warning(FutureWarning):
+        assert f(6, 3, 3) == 12
+
+
+def test_four_arguments():
+    with tm.assert_produces_warning(FutureWarning):
+        assert f(1, 2, 3, 4) == 10
+
+
+@deprecate_nonkeyword_arguments(version="1.1")
+def g(a, b=0, c=0, d=0):
+    with tm.assert_produces_warning(None):
+        return a + b + c + d
+
+
+def test_one_and_three_arguments_default_allowed_args():
+    with tm.assert_produces_warning(None):
+        assert g(1, b=3, c=3, d=5) == 12
+
+
+def test_three_arguments_default_allowed_args():
+    with tm.assert_produces_warning(FutureWarning):
+        assert g(6, 3, 3) == 12
+
+
+def test_three_positional_argument_with_warning_message_analysis():
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        assert g(6, 3, 3) == 12
+        assert len(w) == 1
+        for actual_warning in w:
+            assert actual_warning.category == FutureWarning
+            assert str(actual_warning.message) == (
+                "Starting with pandas version 1.1 all arguments of g "
+                "except for the argument 'a' will be keyword-only."
+            )
+
+
+@deprecate_nonkeyword_arguments(version="1.1")
+def h(a=0, b=0, c=0, d=0):
+    return a + b + c + d
+
+
+def test_all_keyword_arguments():
+    with tm.assert_produces_warning(None):
+        assert h(a=1, b=2) == 3
+
+
+def test_one_positional_argument():
+    with tm.assert_produces_warning(FutureWarning):
+        assert h(23) == 23
+
+
+def test_one_positional_argument_with_warning_message_analysis():
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        assert h(19) == 19
+        assert len(w) == 1
+        for actual_warning in w:
+            assert actual_warning.category == FutureWarning
+            assert str(actual_warning.message) == (
+                "Starting with pandas version 1.1 all arguments "
+                "of h will be keyword-only."
+            )
+
+
+class Foo:
+    @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "bar"])
+    def baz(self, bar=None, foobar=None):
+        ...
+
+
+def test_class():
+    msg = (
+        r"In a future version of pandas all arguments of Foo\.baz "
+        r"except for the argument \'bar\' will be keyword-only"
+    )
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        Foo().baz("qux", "quox")

.venv/Lib/site-packages/pandas/tests/util/test_doc.py

@@ -0,0 +1,90 @@
+from textwrap import dedent
+
+from pandas.util._decorators import doc
+
+
+@doc(method="cumsum", operation="sum")
+def cumsum(whatever):
+    """
+    This is the {method} method.
+
+    It computes the cumulative {operation}.
+    """
+
+
+@doc(
+    cumsum,
+    dedent(
+        """
+        Examples
+        --------
+
+        >>> cumavg([1, 2, 3])
+        2
+        """
+    ),
+    method="cumavg",
+    operation="average",
+)
+def cumavg(whatever):
+    pass
+
+
+@doc(cumsum, method="cummax", operation="maximum")
+def cummax(whatever):
+    pass
+
+
+@doc(cummax, method="cummin", operation="minimum")
+def cummin(whatever):
+    pass
+
+
+def test_docstring_formatting():
+    docstr = dedent(
+        """
+        This is the cumsum method.
+
+        It computes the cumulative sum.
+        """
+    )
+    assert cumsum.__doc__ == docstr
+
+
+def test_docstring_appending():
+    docstr = dedent(
+        """
+        This is the cumavg method.
+
+        It computes the cumulative average.
+
+        Examples
+        --------
+
+        >>> cumavg([1, 2, 3])
+        2
+        """
+    )
+    assert cumavg.__doc__ == docstr
+
+
+def test_doc_template_from_func():
+    docstr = dedent(
+        """
+        This is the cummax method.
+
+        It computes the cumulative maximum.
+        """
+    )
+    assert cummax.__doc__ == docstr
+
+
+def test_inherit_doc_template():
+    docstr = dedent(
+        """
+        This is the cummin method.
+
+        It computes the cumulative minimum.
+        """
+    )
+    assert cummin.__doc__ == docstr

.venv/Lib/site-packages/pandas/tests/util/test_hashing.py

@@ -0,0 +1,392 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    Series,
+)
+import pandas._testing as tm
+from pandas.core.util.hashing import hash_tuples
+from pandas.util import (
+    hash_array,
+    hash_pandas_object,
+)
+
+
+@pytest.fixture(
+    params=[
+        Series([1, 2, 3] * 3, dtype="int32"),
+        Series([None, 2.5, 3.5] * 3, dtype="float32"),
+        Series(["a", "b", "c"] * 3, dtype="category"),
+        Series(["d", "e", "f"] * 3),
+        Series([True, False, True] * 3),
+        Series(pd.date_range("20130101", periods=9)),
+        Series(pd.date_range("20130101", periods=9, tz="US/Eastern")),
+        Series(pd.timedelta_range("2000", periods=9)),
+    ]
+)
+def series(request):
+    return request.param
+
+
+@pytest.fixture(params=[True, False])
+def index(request):
+    return request.param
+
+
+def test_consistency():
+    # Check that our hash doesn't change because of a mistake
+    # in the actual code; this is the ground truth.
+    result = hash_pandas_object(Index(["foo", "bar", "baz"]))
+    expected = Series(
+        np.array(
+            [3600424527151052760, 1374399572096150070, 477881037637427054],
+            dtype="uint64",
+        ),
+        index=["foo", "bar", "baz"],
+    )
+    tm.assert_series_equal(result, expected)
+
+
+def test_hash_array(series):
+    arr = series.values
+    tm.assert_numpy_array_equal(hash_array(arr), hash_array(arr))
+
+
+@pytest.mark.parametrize("dtype", ["U", object])
+def test_hash_array_mixed(dtype):
+    result1 = hash_array(np.array(["3", "4", "All"]))
+    result2 = hash_array(np.array([3, 4, "All"], dtype=dtype))
+
+    tm.assert_numpy_array_equal(result1, result2)
+
+
+@pytest.mark.parametrize("val", [5, "foo", pd.Timestamp("20130101")])
+def test_hash_array_errors(val):
+    msg = "must pass a ndarray-like"
+    with pytest.raises(TypeError, match=msg):
+        hash_array(val)
+
+
+def test_hash_tuples():
+    tuples = [(1, "one"), (1, "two"), (2, "one")]
+    result = hash_tuples(tuples)
+
+    expected = hash_pandas_object(MultiIndex.from_tuples(tuples)).values
+    tm.assert_numpy_array_equal(result, expected)
+
+    # We only need to support MultiIndex and list-of-tuples
+    msg = "|".join(["object is not iterable", "zip argument #1 must support iteration"])
+    with pytest.raises(TypeError, match=msg):
+        hash_tuples(tuples[0])
+
+
+@pytest.mark.parametrize("val", [5, "foo", pd.Timestamp("20130101")])
+def test_hash_tuples_err(val):
+    msg = "must be convertible to a list-of-tuples"
+    with pytest.raises(TypeError, match=msg):
+        hash_tuples(val)
+
+
+def test_multiindex_unique():
+    mi = MultiIndex.from_tuples([(118, 472), (236, 118), (51, 204), (102, 51)])
+    assert mi.is_unique is True
+
+    result = hash_pandas_object(mi)
+    assert result.is_unique is True
+
+
+def test_multiindex_objects():
+    mi = MultiIndex(
+        levels=[["b", "d", "a"], [1, 2, 3]],
+        codes=[[0, 1, 0, 2], [2, 0, 0, 1]],
+        names=["col1", "col2"],
+    )
+    recons = mi._sort_levels_monotonic()
+
+    # These are equal.
+    assert mi.equals(recons)
+    assert Index(mi.values).equals(Index(recons.values))
+
+
+@pytest.mark.parametrize(
+    "obj",
+    [
+        Series([1, 2, 3]),
+        Series([1.0, 1.5, 3.2]),
+        Series([1.0, 1.5, np.nan]),
+        Series([1.0, 1.5, 3.2], index=[1.5, 1.1, 3.3]),
+        Series(["a", "b", "c"]),
+        Series(["a", np.nan, "c"]),
+        Series(["a", None, "c"]),
+        Series([True, False, True]),
+        Series(dtype=object),
+        DataFrame({"x": ["a", "b", "c"], "y": [1, 2, 3]}),
+        DataFrame(),
+        tm.makeMissingDataframe(),
+        tm.makeMixedDataFrame(),
+        tm.makeTimeDataFrame(),
+        tm.makeTimeSeries(),
+        Series(tm.makePeriodIndex()),
+        Series(pd.date_range("20130101", periods=3, tz="US/Eastern")),
+    ],
+)
+def test_hash_pandas_object(obj, index):
+    a = hash_pandas_object(obj, index=index)
+    b = hash_pandas_object(obj, index=index)
+    tm.assert_series_equal(a, b)
+
+
+@pytest.mark.parametrize(
+    "obj",
+    [
+        Series([1, 2, 3]),
+        Series([1.0, 1.5, 3.2]),
+        Series([1.0, 1.5, np.nan]),
+        Series([1.0, 1.5, 3.2], index=[1.5, 1.1, 3.3]),
+        Series(["a", "b", "c"]),
+        Series(["a", np.nan, "c"]),
+        Series(["a", None, "c"]),
+        Series([True, False, True]),
+        DataFrame({"x": ["a", "b", "c"], "y": [1, 2, 3]}),
+        tm.makeMissingDataframe(),
+        tm.makeMixedDataFrame(),
+        tm.makeTimeDataFrame(),
+        tm.makeTimeSeries(),
+        Series(tm.makePeriodIndex()),
+        Series(pd.date_range("20130101", periods=3, tz="US/Eastern")),
+    ],
+)
+def test_hash_pandas_object_diff_index_non_empty(obj):
+    a = hash_pandas_object(obj, index=True)
+    b = hash_pandas_object(obj, index=False)
+    assert not (a == b).all()
+
+
+@pytest.mark.parametrize(
+    "obj",
+    [
+        Index([1, 2, 3]),
+        Index([True, False, True]),
+        tm.makeTimedeltaIndex(),
+        tm.makePeriodIndex(),
+        MultiIndex.from_product(
+            [range(5), ["foo", "bar", "baz"], pd.date_range("20130101", periods=2)]
+        ),
+        MultiIndex.from_product([pd.CategoricalIndex(list("aabc")), range(3)]),
+    ],
+)
+def test_hash_pandas_index(obj, index):
+    a = hash_pandas_object(obj, index=index)
+    b = hash_pandas_object(obj, index=index)
+    tm.assert_series_equal(a, b)
+
+
+def test_hash_pandas_series(series, index):
+    a = hash_pandas_object(series, index=index)
+    b = hash_pandas_object(series, index=index)
+    tm.assert_series_equal(a, b)
+
+
+def test_hash_pandas_series_diff_index(series):
+    a = hash_pandas_object(series, index=True)
+    b = hash_pandas_object(series, index=False)
+    assert not (a == b).all()
+
+
+@pytest.mark.parametrize(
+    "obj", [Series([], dtype="float64"), Series([], dtype="object"), Index([])]
+)
+def test_hash_pandas_empty_object(obj, index):
+    # These are by-definition the same with
+    # or without the index as the data is empty.
+    a = hash_pandas_object(obj, index=index)
+    b = hash_pandas_object(obj, index=index)
+    tm.assert_series_equal(a, b)
+
+
+@pytest.mark.parametrize(
+    "s1",
+    [
+        Series(["a", "b", "c", "d"]),
+        Series([1000, 2000, 3000, 4000]),
+        Series(pd.date_range(0, periods=4)),
+    ],
+)
+@pytest.mark.parametrize("categorize", [True, False])
+def test_categorical_consistency(s1, categorize):
+    # see gh-15143
+    #
+    # Check that categoricals hash consistent with their values,
+    # not codes. This should work for categoricals of any dtype.
+    s2 = s1.astype("category").cat.set_categories(s1)
+    s3 = s2.cat.set_categories(list(reversed(s1)))
+
+    # These should all hash identically.
+    h1 = hash_pandas_object(s1, categorize=categorize)
+    h2 = hash_pandas_object(s2, categorize=categorize)
+    h3 = hash_pandas_object(s3, categorize=categorize)
+
+    tm.assert_series_equal(h1, h2)
+    tm.assert_series_equal(h1, h3)
+
+
+def test_categorical_with_nan_consistency():
+    c = pd.Categorical.from_codes(
+        [-1, 0, 1, 2, 3, 4], categories=pd.date_range("2012-01-01", periods=5, name="B")
+    )
+    expected = hash_array(c, categorize=False)
+
+    c = pd.Categorical.from_codes([-1, 0], categories=[pd.Timestamp("2012-01-01")])
+    result = hash_array(c, categorize=False)
+
+    assert result[0] in expected
+    assert result[1] in expected
+
+
+def test_pandas_errors():
+    msg = "Unexpected type for hashing"
+    with pytest.raises(TypeError, match=msg):
+        hash_pandas_object(pd.Timestamp("20130101"))
+
+
+def test_hash_keys():
+    # Using different hash keys, should have
+    # different hashes for the same data.
+    #
+    # This only matters for object dtypes.
+    obj = Series(list("abc"))
+
+    a = hash_pandas_object(obj, hash_key="9876543210123456")
+    b = hash_pandas_object(obj, hash_key="9876543210123465")
+
+    assert (a != b).all()
+
+
+def test_df_hash_keys():
+    # DataFrame version of the test_hash_keys.
+    # https://github.com/pandas-dev/pandas/issues/41404
+    obj = DataFrame({"x": np.arange(3), "y": list("abc")})
+
+    a = hash_pandas_object(obj, hash_key="9876543210123456")
+    b = hash_pandas_object(obj, hash_key="9876543210123465")
+
+    assert (a != b).all()
+
+
+def test_df_encoding():
+    # Check that DataFrame recognizes optional encoding.
+    # https://github.com/pandas-dev/pandas/issues/41404
+    # https://github.com/pandas-dev/pandas/pull/42049
+    obj = DataFrame({"x": np.arange(3), "y": list("a+c")})
+
+    a = hash_pandas_object(obj, encoding="utf8")
+    b = hash_pandas_object(obj, encoding="utf7")
+
+    # Note that the "+" is encoded as "+-" in utf-7.
+    assert a[0] == b[0]
+    assert a[1] != b[1]
+    assert a[2] == b[2]
+
+
+def test_invalid_key():
+    # This only matters for object dtypes.
+    msg = "key should be a 16-byte string encoded"
+
+    with pytest.raises(ValueError, match=msg):
+        hash_pandas_object(Series(list("abc")), hash_key="foo")
+
+
+def test_already_encoded(index):
+    # If already encoded, then ok.
+    obj = Series(list("abc")).str.encode("utf8")
+    a = hash_pandas_object(obj, index=index)
+    b = hash_pandas_object(obj, index=index)
+    tm.assert_series_equal(a, b)
+
+
+def test_alternate_encoding(index):
+    obj = Series(list("abc"))
+    a = hash_pandas_object(obj, index=index)
+    b = hash_pandas_object(obj, index=index)
+    tm.assert_series_equal(a, b)
+
+
+@pytest.mark.parametrize("l_exp", range(8))
+@pytest.mark.parametrize("l_add", [0, 1])
+def test_same_len_hash_collisions(l_exp, l_add):
+    length = 2 ** (l_exp + 8) + l_add
+    s = tm.rands_array(length, 2)
+
+    result = hash_array(s, "utf8")
+    assert not result[0] == result[1]
+
+
+def test_hash_collisions():
+    # Hash collisions are bad.
+    #
+    # https://github.com/pandas-dev/pandas/issues/14711#issuecomment-264885726
+    hashes = [
+        "Ingrid-9Z9fKIZmkO7i7Cn51Li34pJm44fgX6DYGBNj3VPlOH50m7HnBlPxfIwFMrcNJNMP6PSgLmwWnInciMWrCSAlLEvt7JkJl4IxiMrVbXSa8ZQoVaq5xoQPjltuJEfwdNlO6jo8qRRHvD8sBEBMQASrRa6TsdaPTPCBo3nwIBpE7YzzmyH0vMBhjQZLx1aCT7faSEx7PgFxQhHdKFWROcysamgy9iVj8DO2Fmwg1NNl93rIAqC3mdqfrCxrzfvIY8aJdzin2cHVzy3QUJxZgHvtUtOLxoqnUHsYbNTeq0xcLXpTZEZCxD4PGubIuCNf32c33M7HFsnjWSEjE2yVdWKhmSVodyF8hFYVmhYnMCztQnJrt3O8ZvVRXd5IKwlLexiSp4h888w7SzAIcKgc3g5XQJf6MlSMftDXm9lIsE1mJNiJEv6uY6pgvC3fUPhatlR5JPpVAHNSbSEE73MBzJrhCAbOLXQumyOXigZuPoME7QgJcBalliQol7YZ9",  # noqa: E501
+        "Tim-b9MddTxOWW2AT1Py6vtVbZwGAmYCjbp89p8mxsiFoVX4FyDOF3wFiAkyQTUgwg9sVqVYOZo09Dh1AzhFHbgij52ylF0SEwgzjzHH8TGY8Lypart4p4onnDoDvVMBa0kdthVGKl6K0BDVGzyOXPXKpmnMF1H6rJzqHJ0HywfwS4XYpVwlAkoeNsiicHkJUFdUAhG229INzvIAiJuAHeJDUoyO4DCBqtoZ5TDend6TK7Y914yHlfH3g1WZu5LksKv68VQHJriWFYusW5e6ZZ6dKaMjTwEGuRgdT66iU5nqWTHRH8WSzpXoCFwGcTOwyuqPSe0fTe21DVtJn1FKj9F9nEnR9xOvJUO7E0piCIF4Ad9yAIDY4DBimpsTfKXCu1vdHpKYerzbndfuFe5AhfMduLYZJi5iAw8qKSwR5h86ttXV0Mc0QmXz8dsRvDgxjXSmupPxBggdlqUlC828hXiTPD7am0yETBV0F3bEtvPiNJfremszcV8NcqAoARMe",  # noqa: E501
+    ]
+
+    # These should be different.
+    result1 = hash_array(np.asarray(hashes[0:1], dtype=object), "utf8")
+    expected1 = np.array([14963968704024874985], dtype=np.uint64)
+    tm.assert_numpy_array_equal(result1, expected1)
+
+    result2 = hash_array(np.asarray(hashes[1:2], dtype=object), "utf8")
+    expected2 = np.array([16428432627716348016], dtype=np.uint64)
+    tm.assert_numpy_array_equal(result2, expected2)
+
+    result = hash_array(np.asarray(hashes, dtype=object), "utf8")
+    tm.assert_numpy_array_equal(result, np.concatenate([expected1, expected2], axis=0))
+
+
+@pytest.mark.parametrize(
+    "data, result_data",
+    [
+        [[tuple("1"), tuple("2")], [10345501319357378243, 8331063931016360761]],
+        [[(1,), (2,)], [9408946347443669104, 3278256261030523334]],
+    ],
+)
+def test_hash_with_tuple(data, result_data):
+    # GH#28969 array containing a tuple raises on call to arr.astype(str)
+    #  apparently a numpy bug github.com/numpy/numpy/issues/9441
+
+    df = DataFrame({"data": data})
+    result = hash_pandas_object(df)
+    expected = Series(result_data, dtype=np.uint64)
+    tm.assert_series_equal(result, expected)
+
+
+def test_hashable_tuple_args():
+    # require that the elements of such tuples are themselves hashable
+
+    df3 = DataFrame(
+        {
+            "data": [
+                (
+                    1,
+                    [],
+                ),
+                (
+                    2,
+                    {},
+                ),
+            ]
+        }
+    )
+    with pytest.raises(TypeError, match="unhashable type: 'list'"):
+        hash_pandas_object(df3)
+
+
+def test_hash_object_none_key():
+    # https://github.com/pandas-dev/pandas/issues/30887
+    result = pd.util.hash_pandas_object(Series(["a", "b"]), hash_key=None)
+    expected = Series([4578374827886788867, 17338122309987883691], dtype="uint64")
+    tm.assert_series_equal(result, expected)

.venv/Lib/site-packages/pandas/tests/util/test_numba.py

@@ -0,0 +1,12 @@
+import pytest
+
+import pandas.util._test_decorators as td
+
+from pandas import option_context
+
+
+@td.skip_if_installed("numba")
+def test_numba_not_installed_option_context():
+    with pytest.raises(ImportError, match="Missing optional"):
+        with option_context("compute.use_numba", True):
+            pass

.venv/Lib/site-packages/pandas/tests/util/test_safe_import.py

@@ -0,0 +1,39 @@
+import sys
+import types
+
+import pytest
+
+import pandas.util._test_decorators as td
+
+
+@pytest.mark.parametrize("name", ["foo", "hello123"])
+def test_safe_import_non_existent(name):
+    assert not td.safe_import(name)
+
+
+def test_safe_import_exists():
+    assert td.safe_import("pandas")
+
+
+@pytest.mark.parametrize("min_version,valid", [("0.0.0", True), ("99.99.99", False)])
+def test_safe_import_versions(min_version, valid):
+    result = td.safe_import("pandas", min_version=min_version)
+    result = result if valid else not result
+    assert result
+
+
+@pytest.mark.parametrize(
+    "min_version,valid", [(None, False), ("1.0", True), ("2.0", False)]
+)
+def test_safe_import_dummy(monkeypatch, min_version, valid):
+    mod_name = "hello123"
+
+    mod = types.ModuleType(mod_name)
+    mod.__version__ = "1.5"
+
+    if min_version is not None:
+        monkeypatch.setitem(sys.modules, mod_name, mod)
+
+    result = td.safe_import(mod_name, min_version=min_version)
+    result = result if valid else not result
+    assert result

.venv/Lib/site-packages/pandas/tests/util/test_shares_memory.py

@@ -0,0 +1,13 @@
+import pandas as pd
+import pandas._testing as tm
+
+
+def test_shares_memory_interval():
+    obj = pd.interval_range(1, 5)
+
+    assert tm.shares_memory(obj, obj)
+    assert tm.shares_memory(obj, obj._data)
+    assert tm.shares_memory(obj, obj[::-1])
+    assert tm.shares_memory(obj, obj[:2])
+
+    assert not tm.shares_memory(obj, obj._data.copy())

.venv/Lib/site-packages/pandas/tests/util/test_show_versions.py

@@ -0,0 +1,101 @@
+import json
+import os
+import re
+
+import pytest
+
+from pandas.util._print_versions import (
+    _get_dependency_info,
+    _get_sys_info,
+)
+
+import pandas as pd
+
+
+@pytest.mark.filterwarnings(
+    # openpyxl
+    "ignore:defusedxml.lxml is no longer supported:DeprecationWarning"
+)
+@pytest.mark.filterwarnings(
+    # html5lib
+    "ignore:Using or importing the ABCs from:DeprecationWarning"
+)
+@pytest.mark.filterwarnings(
+    # fastparquet
+    "ignore:pandas.core.index is deprecated:FutureWarning"
+)
+@pytest.mark.filterwarnings(
+    # pandas_datareader
+    "ignore:pandas.util.testing is deprecated:FutureWarning"
+)
+@pytest.mark.filterwarnings(
+    # https://github.com/pandas-dev/pandas/issues/35252
+    "ignore:Distutils:UserWarning"
+)
+def test_show_versions(tmpdir):
+    # GH39701
+    as_json = os.path.join(tmpdir, "test_output.json")
+
+    pd.show_versions(as_json=as_json)
+
+    with open(as_json) as fd:
+        # check if file output is valid JSON, will raise an exception if not
+        result = json.load(fd)
+
+    # Basic check that each version element is found in output
+    expected = {
+        "system": _get_sys_info(),
+        "dependencies": _get_dependency_info(),
+    }
+
+    assert result == expected
+
+
+def test_show_versions_console_json(capsys):
+    # GH39701
+    pd.show_versions(as_json=True)
+    stdout = capsys.readouterr().out
+
+    # check valid json is printed to the console if as_json is True
+    result = json.loads(stdout)
+
+    # Basic check that each version element is found in output
+    expected = {
+        "system": _get_sys_info(),
+        "dependencies": _get_dependency_info(),
+    }
+
+    assert result == expected
+
+
+def test_show_versions_console(capsys):
+    # gh-32041
+    # gh-32041
+    pd.show_versions(as_json=False)
+    result = capsys.readouterr().out
+
+    # check header
+    assert "INSTALLED VERSIONS" in result
+
+    # check full commit hash
+    assert re.search(r"commit\s*:\s[0-9a-f]{40}\n", result)
+
+    # check required dependency
+    # 2020-12-09 npdev has "dirty" in the tag
+    assert re.search(r"numpy\s*:\s([0-9\.\+a-g\_]|dev)+(dirty)?\n", result)
+
+    # check optional dependency
+    assert re.search(r"pyarrow\s*:\s([0-9\.]+|None)\n", result)
+
+
+def test_json_output_match(capsys, tmpdir):
+    # GH39701
+    pd.show_versions(as_json=True)
+    result_console = capsys.readouterr().out
+
+    out_path = os.path.join(tmpdir, "test_json.json")
+    pd.show_versions(as_json=out_path)
+    with open(out_path) as out_fd:
+        result_file = out_fd.read()
+
+    assert result_console == result_file

.venv/Lib/site-packages/pandas/tests/util/test_util.py

@@ -0,0 +1,83 @@
+import os
+
+import pytest
+
+import pandas.compat as compat
+
+import pandas._testing as tm
+
+
+def test_rands():
+    r = tm.rands(10)
+    assert len(r) == 10
+
+
+def test_rands_array_1d():
+    arr = tm.rands_array(5, size=10)
+    assert arr.shape == (10,)
+    assert len(arr[0]) == 5
+
+
+def test_rands_array_2d():
+    arr = tm.rands_array(7, size=(10, 10))
+    assert arr.shape == (10, 10)
+    assert len(arr[1, 1]) == 7
+
+
+def test_numpy_err_state_is_default():
+    expected = {"over": "warn", "divide": "warn", "invalid": "warn", "under": "ignore"}
+    import numpy as np
+
+    # The error state should be unchanged after that import.
+    assert np.geterr() == expected
+
+
+def test_convert_rows_list_to_csv_str():
+    rows_list = ["aaa", "bbb", "ccc"]
+    ret = tm.convert_rows_list_to_csv_str(rows_list)
+
+    if compat.is_platform_windows():
+        expected = "aaa\r\nbbb\r\nccc\r\n"
+    else:
+        expected = "aaa\nbbb\nccc\n"
+
+    assert ret == expected
+
+
+def test_create_temp_directory():
+    with tm.ensure_clean_dir() as path:
+        assert os.path.exists(path)
+        assert os.path.isdir(path)
+    assert not os.path.exists(path)
+
+
+@pytest.mark.parametrize("strict_data_files", [True, False])
+def test_datapath_missing(datapath):
+    with pytest.raises(ValueError, match="Could not find file"):
+        datapath("not_a_file")
+
+
+def test_datapath(datapath):
+    args = ("io", "data", "csv", "iris.csv")
+
+    result = datapath(*args)
+    expected = os.path.join(os.path.dirname(os.path.dirname(__file__)), *args)
+
+    assert result == expected
+
+
+def test_rng_context():
+    import numpy as np
+
+    expected0 = 1.764052345967664
+    expected1 = 1.6243453636632417
+
+    with tm.RNGContext(0):
+        with tm.RNGContext(1):
+            assert np.random.randn() == expected1
+        assert np.random.randn() == expected0
+
+
+def test_external_error_raised():
+    with tm.external_error_raised(TypeError):
+        raise TypeError("Should not check this error message, so it will pass")

.venv/Lib/site-packages/pandas/tests/util/test_validate_args.py

@@ -0,0 +1,67 @@
+import pytest
+
+from pandas.util._validators import validate_args
+
+_fname = "func"
+
+
+def test_bad_min_fname_arg_count():
+    msg = "'max_fname_arg_count' must be non-negative"
+
+    with pytest.raises(ValueError, match=msg):
+        validate_args(_fname, (None,), -1, "foo")
+
+
+def test_bad_arg_length_max_value_single():
+    args = (None, None)
+    compat_args = ("foo",)
+
+    min_fname_arg_count = 0
+    max_length = len(compat_args) + min_fname_arg_count
+    actual_length = len(args) + min_fname_arg_count
+    msg = (
+        rf"{_fname}\(\) takes at most {max_length} "
+        rf"argument \({actual_length} given\)"
+    )
+
+    with pytest.raises(TypeError, match=msg):
+        validate_args(_fname, args, min_fname_arg_count, compat_args)
+
+
+def test_bad_arg_length_max_value_multiple():
+    args = (None, None)
+    compat_args = {"foo": None}
+
+    min_fname_arg_count = 2
+    max_length = len(compat_args) + min_fname_arg_count
+    actual_length = len(args) + min_fname_arg_count
+    msg = (
+        rf"{_fname}\(\) takes at most {max_length} "
+        rf"arguments \({actual_length} given\)"
+    )
+
+    with pytest.raises(TypeError, match=msg):
+        validate_args(_fname, args, min_fname_arg_count, compat_args)
+
+
+@pytest.mark.parametrize("i", range(1, 3))
+def test_not_all_defaults(i):
+    bad_arg = "foo"
+    msg = (
+        f"the '{bad_arg}' parameter is not supported "
+        rf"in the pandas implementation of {_fname}\(\)"
+    )
+
+    compat_args = {"foo": 2, "bar": -1, "baz": 3}
+    arg_vals = (1, -1, 3)
+
+    with pytest.raises(ValueError, match=msg):
+        validate_args(_fname, arg_vals[:i], 2, compat_args)
+
+
+def test_validation():
+    # No exceptions should be raised.
+    validate_args(_fname, (None,), 2, {"out": None})
+
+    compat_args = {"axis": 1, "out": None}
+    validate_args(_fname, (1, None), 2, compat_args)

.venv/Lib/site-packages/pandas/tests/util/test_validate_args_and_kwargs.py

@@ -0,0 +1,81 @@
+import pytest
+
+from pandas.util._validators import validate_args_and_kwargs
+
+_fname = "func"
+
+
+def test_invalid_total_length_max_length_one():
+    compat_args = ("foo",)
+    kwargs = {"foo": "FOO"}
+    args = ("FoO", "BaZ")
+
+    min_fname_arg_count = 0
+    max_length = len(compat_args) + min_fname_arg_count
+    actual_length = len(kwargs) + len(args) + min_fname_arg_count
+
+    msg = (
+        rf"{_fname}\(\) takes at most {max_length} "
+        rf"argument \({actual_length} given\)"
+    )
+
+    with pytest.raises(TypeError, match=msg):
+        validate_args_and_kwargs(_fname, args, kwargs, min_fname_arg_count, compat_args)
+
+
+def test_invalid_total_length_max_length_multiple():
+    compat_args = ("foo", "bar", "baz")
+    kwargs = {"foo": "FOO", "bar": "BAR"}
+    args = ("FoO", "BaZ")
+
+    min_fname_arg_count = 2
+    max_length = len(compat_args) + min_fname_arg_count
+    actual_length = len(kwargs) + len(args) + min_fname_arg_count
+
+    msg = (
+        rf"{_fname}\(\) takes at most {max_length} "
+        rf"arguments \({actual_length} given\)"
+    )
+
+    with pytest.raises(TypeError, match=msg):
+        validate_args_and_kwargs(_fname, args, kwargs, min_fname_arg_count, compat_args)
+
+
+@pytest.mark.parametrize("args,kwargs", [((), {"foo": -5, "bar": 2}), ((-5, 2), {})])
+def test_missing_args_or_kwargs(args, kwargs):
+    bad_arg = "bar"
+    min_fname_arg_count = 2
+
+    compat_args = {"foo": -5, bad_arg: 1}
+
+    msg = (
+        rf"the '{bad_arg}' parameter is not supported "
+        rf"in the pandas implementation of {_fname}\(\)"
+    )
+
+    with pytest.raises(ValueError, match=msg):
+        validate_args_and_kwargs(_fname, args, kwargs, min_fname_arg_count, compat_args)
+
+
+def test_duplicate_argument():
+    min_fname_arg_count = 2
+
+    compat_args = {"foo": None, "bar": None, "baz": None}
+    kwargs = {"foo": None, "bar": None}
+    args = (None,)  # duplicate value for "foo"
+
+    msg = rf"{_fname}\(\) got multiple values for keyword argument 'foo'"
+
+    with pytest.raises(TypeError, match=msg):
+        validate_args_and_kwargs(_fname, args, kwargs, min_fname_arg_count, compat_args)
+
+
+def test_validation():
+    # No exceptions should be raised.
+    compat_args = {"foo": 1, "bar": None, "baz": -2}
+    kwargs = {"baz": -2}
+
+    args = (1, None)
+    min_fname_arg_count = 2
+
+    validate_args_and_kwargs(_fname, args, kwargs, min_fname_arg_count, compat_args)

.venv/Lib/site-packages/pandas/tests/util/test_validate_inclusive.py

@@ -0,0 +1,40 @@
+import numpy as np
+import pytest
+
+from pandas.util._validators import validate_inclusive
+
+import pandas as pd
+
+
+@pytest.mark.parametrize(
+    "invalid_inclusive",
+    (
+        "ccc",
+        2,
+        object(),
+        None,
+        np.nan,
+        pd.NA,
+        pd.DataFrame(),
+    ),
+)
+def test_invalid_inclusive(invalid_inclusive):
+    with pytest.raises(
+        ValueError,
+        match="Inclusive has to be either 'both', 'neither', 'left' or 'right'",
+    ):
+        validate_inclusive(invalid_inclusive)
+
+
+@pytest.mark.parametrize(
+    "valid_inclusive, expected_tuple",
+    (
+        ("left", (True, False)),
+        ("right", (False, True)),
+        ("both", (True, True)),
+        ("neither", (False, False)),
+    ),
+)
+def test_valid_inclusive(valid_inclusive, expected_tuple):
+    resultant_tuple = validate_inclusive(valid_inclusive)
+    assert expected_tuple == resultant_tuple

.venv/Lib/site-packages/pandas/tests/util/test_validate_kwargs.py

@@ -0,0 +1,66 @@
+import pytest
+
+from pandas.util._validators import (
+    validate_bool_kwarg,
+    validate_kwargs,
+)
+
+_fname = "func"
+
+
+def test_bad_kwarg():
+    good_arg = "f"
+    bad_arg = good_arg + "o"
+
+    compat_args = {good_arg: "foo", bad_arg + "o": "bar"}
+    kwargs = {good_arg: "foo", bad_arg: "bar"}
+
+    msg = rf"{_fname}\(\) got an unexpected keyword argument '{bad_arg}'"
+
+    with pytest.raises(TypeError, match=msg):
+        validate_kwargs(_fname, kwargs, compat_args)
+
+
+@pytest.mark.parametrize("i", range(1, 3))
+def test_not_all_none(i):
+    bad_arg = "foo"
+    msg = (
+        rf"the '{bad_arg}' parameter is not supported "
+        rf"in the pandas implementation of {_fname}\(\)"
+    )
+
+    compat_args = {"foo": 1, "bar": "s", "baz": None}
+
+    kwarg_keys = ("foo", "bar", "baz")
+    kwarg_vals = (2, "s", None)
+
+    kwargs = dict(zip(kwarg_keys[:i], kwarg_vals[:i]))
+
+    with pytest.raises(ValueError, match=msg):
+        validate_kwargs(_fname, kwargs, compat_args)
+
+
+def test_validation():
+    # No exceptions should be raised.
+    compat_args = {"f": None, "b": 1, "ba": "s"}
+
+    kwargs = {"f": None, "b": 1}
+    validate_kwargs(_fname, kwargs, compat_args)
+
+
+@pytest.mark.parametrize("name", ["inplace", "copy"])
+@pytest.mark.parametrize("value", [1, "True", [1, 2, 3], 5.0])
+def test_validate_bool_kwarg_fail(name, value):
+    msg = (
+        f'For argument "{name}" expected type bool, '
+        f"received type {type(value).__name__}"
+    )
+
+    with pytest.raises(ValueError, match=msg):
+        validate_bool_kwarg(value, name)
+
+
+@pytest.mark.parametrize("name", ["inplace", "copy"])
+@pytest.mark.parametrize("value", [True, False, None])
+def test_validate_bool_kwarg(name, value):
+    assert validate_bool_kwarg(value, name) == value