From 2160e9be55dd901e7fa0c4720e76b97d5711b8d2 Mon Sep 17 00:00:00 2001
From: Brock <jbrockmendel@gmail.com>
Date: Thu, 24 Dec 2020 14:00:58 -0800
Subject: [PATCH 1/2] REF: make pd._testing a directory

---
 pandas/{_testing.py => _testing/__init__.py}  | 1405 +----------------
 pandas/_testing/asserters.py                  | 1382 ++++++++++++++++
 .../tests/series/apply/test_series_apply.py   |    4 +-
 3 files changed, 1418 insertions(+), 1373 deletions(-)
 rename pandas/{_testing.py => _testing/__init__.py} (52%)
 create mode 100644 pandas/_testing/asserters.py

diff --git a/pandas/_testing.py b/pandas/_testing/__init__.py
similarity index 52%
rename from pandas/_testing.py
rename to pandas/_testing/__init__.py
index f96645b3805f0..0891d733e0d0e 100644
--- a/pandas/_testing.py
+++ b/pandas/_testing/__init__.py
@@ -26,7 +26,6 @@
 import zipfile
 
 import numpy as np
-from numpy.random import rand, randn
 
 from pandas._config.localization import (  # noqa:F401
     can_set_locale,
@@ -34,26 +33,16 @@
     set_locale,
 )
 
-from pandas._libs.lib import no_default
-import pandas._libs.testing as _testing
 from pandas._typing import Dtype, FilePathOrBuffer, FrameOrSeries
 from pandas.compat import get_lzma_file, import_lzma
 
 from pandas.core.dtypes.common import (
-    is_bool,
-    is_categorical_dtype,
     is_datetime64_dtype,
     is_datetime64tz_dtype,
-    is_extension_array_dtype,
-    is_interval_dtype,
-    is_number,
-    is_numeric_dtype,
     is_period_dtype,
     is_sequence,
     is_timedelta64_dtype,
-    needs_i8_conversion,
 )
-from pandas.core.dtypes.missing import array_equivalent
 
 import pandas as pd
 from pandas import (
@@ -68,19 +57,33 @@
     Series,
     bdate_range,
 )
-from pandas.core.algorithms import take_1d
-from pandas.core.arrays import (
-    DatetimeArray,
-    ExtensionArray,
-    IntervalArray,
-    PeriodArray,
-    TimedeltaArray,
-    period_array,
-)
-from pandas.core.arrays.datetimelike import DatetimeLikeArrayMixin
+from pandas.core.arrays import DatetimeArray, PeriodArray, TimedeltaArray, period_array
 
 from pandas.io.common import urlopen
-from pandas.io.formats.printing import pprint_thing
+
+from .asserters import (  # noqa:F401
+    assert_almost_equal,
+    assert_attr_equal,
+    assert_categorical_equal,
+    assert_class_equal,
+    assert_contains_all,
+    assert_copy,
+    assert_datetime_array_equal,
+    assert_dict_equal,
+    assert_equal,
+    assert_extension_array_equal,
+    assert_frame_equal,
+    assert_index_equal,
+    assert_interval_array_equal,
+    assert_is_sorted,
+    assert_is_valid_plot_return_object,
+    assert_numpy_array_equal,
+    assert_period_array_equal,
+    assert_series_equal,
+    assert_sp_array_equal,
+    assert_timedelta_array_equal,
+    raise_assert_detail,
+)
 
 lzma = import_lzma()
 
@@ -335,192 +338,8 @@ def write_to_compressed(compression, path, data, dest="test"):
         getattr(f, method)(*args)
 
 
-def _get_tol_from_less_precise(check_less_precise: Union[bool, int]) -> float:
-    """
-    Return the tolerance equivalent to the deprecated `check_less_precise`
-    parameter.
-
-    Parameters
-    ----------
-    check_less_precise : bool or int
-
-    Returns
-    -------
-    float
-        Tolerance to be used as relative/absolute tolerance.
-
-    Examples
-    --------
-    >>> # Using check_less_precise as a bool:
-    >>> _get_tol_from_less_precise(False)
-    0.5e-5
-    >>> _get_tol_from_less_precise(True)
-    0.5e-3
-    >>> # Using check_less_precise as an int representing the decimal
-    >>> # tolerance intended:
-    >>> _get_tol_from_less_precise(2)
-    0.5e-2
-    >>> _get_tol_from_less_precise(8)
-    0.5e-8
-
-    """
-    if isinstance(check_less_precise, bool):
-        if check_less_precise:
-            # 3-digit tolerance
-            return 0.5e-3
-        else:
-            # 5-digit tolerance
-            return 0.5e-5
-    else:
-        # Equivalent to setting checking_less_precise=<decimals>
-        return 0.5 * 10 ** -check_less_precise
-
-
-def assert_almost_equal(
-    left,
-    right,
-    check_dtype: Union[bool, str] = "equiv",
-    check_less_precise: Union[bool, int] = no_default,
-    rtol: float = 1.0e-5,
-    atol: float = 1.0e-8,
-    **kwargs,
-):
-    """
-    Check that the left and right objects are approximately equal.
-
-    By approximately equal, we refer to objects that are numbers or that
-    contain numbers which may be equivalent to specific levels of precision.
-
-    Parameters
-    ----------
-    left : object
-    right : object
-    check_dtype : bool or {'equiv'}, default 'equiv'
-        Check dtype if both a and b are the same type. If 'equiv' is passed in,
-        then `RangeIndex` and `Int64Index` are also considered equivalent
-        when doing type checking.
-    check_less_precise : bool or int, default False
-        Specify comparison precision. 5 digits (False) or 3 digits (True)
-        after decimal points are compared. If int, then specify the number
-        of digits to compare.
-
-        When comparing two numbers, if the first number has magnitude less
-        than 1e-5, we compare the two numbers directly and check whether
-        they are equivalent within the specified precision. Otherwise, we
-        compare the **ratio** of the second number to the first number and
-        check whether it is equivalent to 1 within the specified precision.
-
-        .. deprecated:: 1.1.0
-           Use `rtol` and `atol` instead to define relative/absolute
-           tolerance, respectively. Similar to :func:`math.isclose`.
-    rtol : float, default 1e-5
-        Relative tolerance.
-
-        .. versionadded:: 1.1.0
-    atol : float, default 1e-8
-        Absolute tolerance.
-
-        .. versionadded:: 1.1.0
-    """
-    if check_less_precise is not no_default:
-        warnings.warn(
-            "The 'check_less_precise' keyword in testing.assert_*_equal "
-            "is deprecated and will be removed in a future version. "
-            "You can stop passing 'check_less_precise' to silence this warning.",
-            FutureWarning,
-            stacklevel=2,
-        )
-        rtol = atol = _get_tol_from_less_precise(check_less_precise)
-
-    if isinstance(left, pd.Index):
-        assert_index_equal(
-            left,
-            right,
-            check_exact=False,
-            exact=check_dtype,
-            rtol=rtol,
-            atol=atol,
-            **kwargs,
-        )
-
-    elif isinstance(left, pd.Series):
-        assert_series_equal(
-            left,
-            right,
-            check_exact=False,
-            check_dtype=check_dtype,
-            rtol=rtol,
-            atol=atol,
-            **kwargs,
-        )
-
-    elif isinstance(left, pd.DataFrame):
-        assert_frame_equal(
-            left,
-            right,
-            check_exact=False,
-            check_dtype=check_dtype,
-            rtol=rtol,
-            atol=atol,
-            **kwargs,
-        )
-
-    else:
-        # Other sequences.
-        if check_dtype:
-            if is_number(left) and is_number(right):
-                # Do not compare numeric classes, like np.float64 and float.
-                pass
-            elif is_bool(left) and is_bool(right):
-                # Do not compare bool classes, like np.bool_ and bool.
-                pass
-            else:
-                if isinstance(left, np.ndarray) or isinstance(right, np.ndarray):
-                    obj = "numpy array"
-                else:
-                    obj = "Input"
-                assert_class_equal(left, right, obj=obj)
-        _testing.assert_almost_equal(
-            left, right, check_dtype=check_dtype, rtol=rtol, atol=atol, **kwargs
-        )
-
-
-def _check_isinstance(left, right, cls):
-    """
-    Helper method for our assert_* methods that ensures that
-    the two objects being compared have the right type before
-    proceeding with the comparison.
-
-    Parameters
-    ----------
-    left : The first object being compared.
-    right : The second object being compared.
-    cls : The class type to check against.
-
-    Raises
-    ------
-    AssertionError : Either `left` or `right` is not an instance of `cls`.
-    """
-    cls_name = cls.__name__
-
-    if not isinstance(left, cls):
-        raise AssertionError(
-            f"{cls_name} Expected type {cls}, found {type(left)} instead"
-        )
-    if not isinstance(right, cls):
-        raise AssertionError(
-            f"{cls_name} Expected type {cls}, found {type(right)} instead"
-        )
-
-
-def assert_dict_equal(left, right, compare_keys: bool = True):
-
-    _check_isinstance(left, right, dict)
-    _testing.assert_dict_equal(left, right, compare_keys=compare_keys)
-
-
 def randbool(size=(), p: float = 0.5):
-    return rand(*size) <= p
+    return np.random.rand(*size) <= p
 
 
 RANDS_CHARS = np.array(list(string.ascii_letters + string.digits), dtype=(np.str_, 1))
@@ -687,1092 +506,6 @@ def equalContents(arr1, arr2) -> bool:
     return frozenset(arr1) == frozenset(arr2)
 
 
-def assert_index_equal(
-    left: Index,
-    right: Index,
-    exact: Union[bool, str] = "equiv",
-    check_names: bool = True,
-    check_less_precise: Union[bool, int] = no_default,
-    check_exact: bool = True,
-    check_categorical: bool = True,
-    check_order: bool = True,
-    rtol: float = 1.0e-5,
-    atol: float = 1.0e-8,
-    obj: str = "Index",
-) -> None:
-    """
-    Check that left and right Index are equal.
-
-    Parameters
-    ----------
-    left : Index
-    right : Index
-    exact : bool or {'equiv'}, default 'equiv'
-        Whether to check the Index class, dtype and inferred_type
-        are identical. If 'equiv', then RangeIndex can be substituted for
-        Int64Index as well.
-    check_names : bool, default True
-        Whether to check the names attribute.
-    check_less_precise : bool or int, default False
-        Specify comparison precision. Only used when check_exact is False.
-        5 digits (False) or 3 digits (True) after decimal points are compared.
-        If int, then specify the digits to compare.
-
-        .. deprecated:: 1.1.0
-           Use `rtol` and `atol` instead to define relative/absolute
-           tolerance, respectively. Similar to :func:`math.isclose`.
-    check_exact : bool, default True
-        Whether to compare number exactly.
-    check_categorical : bool, default True
-        Whether to compare internal Categorical exactly.
-    check_order : bool, default True
-        Whether to compare the order of index entries as well as their values.
-        If True, both indexes must contain the same elements, in the same order.
-        If False, both indexes must contain the same elements, but in any order.
-
-        .. versionadded:: 1.2.0
-    rtol : float, default 1e-5
-        Relative tolerance. Only used when check_exact is False.
-
-        .. versionadded:: 1.1.0
-    atol : float, default 1e-8
-        Absolute tolerance. Only used when check_exact is False.
-
-        .. versionadded:: 1.1.0
-    obj : str, default 'Index'
-        Specify object name being compared, internally used to show appropriate
-        assertion message.
-
-    Examples
-    --------
-    >>> from pandas.testing import assert_index_equal
-    >>> a = pd.Index([1, 2, 3])
-    >>> b = pd.Index([1, 2, 3])
-    >>> assert_index_equal(a, b)
-    """
-    __tracebackhide__ = True
-
-    def _check_types(left, right, obj="Index"):
-        if exact:
-            assert_class_equal(left, right, exact=exact, obj=obj)
-
-            # Skip exact dtype checking when `check_categorical` is False
-            if check_categorical:
-                assert_attr_equal("dtype", left, right, obj=obj)
-
-            # allow string-like to have different inferred_types
-            if left.inferred_type in ("string"):
-                assert right.inferred_type in ("string")
-            else:
-                assert_attr_equal("inferred_type", left, right, obj=obj)
-
-    def _get_ilevel_values(index, level):
-        # accept level number only
-        unique = index.levels[level]
-        level_codes = index.codes[level]
-        filled = take_1d(unique._values, level_codes, fill_value=unique._na_value)
-        return unique._shallow_copy(filled, name=index.names[level])
-
-    if check_less_precise is not no_default:
-        warnings.warn(
-            "The 'check_less_precise' keyword in testing.assert_*_equal "
-            "is deprecated and will be removed in a future version. "
-            "You can stop passing 'check_less_precise' to silence this warning.",
-            FutureWarning,
-            stacklevel=2,
-        )
-        rtol = atol = _get_tol_from_less_precise(check_less_precise)
-
-    # instance validation
-    _check_isinstance(left, right, Index)
-
-    # class / dtype comparison
-    _check_types(left, right, obj=obj)
-
-    # level comparison
-    if left.nlevels != right.nlevels:
-        msg1 = f"{obj} levels are different"
-        msg2 = f"{left.nlevels}, {left}"
-        msg3 = f"{right.nlevels}, {right}"
-        raise_assert_detail(obj, msg1, msg2, msg3)
-
-    # length comparison
-    if len(left) != len(right):
-        msg1 = f"{obj} length are different"
-        msg2 = f"{len(left)}, {left}"
-        msg3 = f"{len(right)}, {right}"
-        raise_assert_detail(obj, msg1, msg2, msg3)
-
-    # If order doesn't matter then sort the index entries
-    if not check_order:
-        left = left.sort_values()
-        right = right.sort_values()
-
-    # MultiIndex special comparison for little-friendly error messages
-    if left.nlevels > 1:
-        left = cast(MultiIndex, left)
-        right = cast(MultiIndex, right)
-
-        for level in range(left.nlevels):
-            # cannot use get_level_values here because it can change dtype
-            llevel = _get_ilevel_values(left, level)
-            rlevel = _get_ilevel_values(right, level)
-
-            lobj = f"MultiIndex level [{level}]"
-            assert_index_equal(
-                llevel,
-                rlevel,
-                exact=exact,
-                check_names=check_names,
-                check_exact=check_exact,
-                rtol=rtol,
-                atol=atol,
-                obj=lobj,
-            )
-            # get_level_values may change dtype
-            _check_types(left.levels[level], right.levels[level], obj=obj)
-
-    # skip exact index checking when `check_categorical` is False
-    if check_exact and check_categorical:
-        if not left.equals(right):
-            diff = (
-                np.sum((left._values != right._values).astype(int)) * 100.0 / len(left)
-            )
-            msg = f"{obj} values are different ({np.round(diff, 5)} %)"
-            raise_assert_detail(obj, msg, left, right)
-    else:
-        _testing.assert_almost_equal(
-            left.values,
-            right.values,
-            rtol=rtol,
-            atol=atol,
-            check_dtype=exact,
-            obj=obj,
-            lobj=left,
-            robj=right,
-        )
-
-    # metadata comparison
-    if check_names:
-        assert_attr_equal("names", left, right, obj=obj)
-    if isinstance(left, pd.PeriodIndex) or isinstance(right, pd.PeriodIndex):
-        assert_attr_equal("freq", left, right, obj=obj)
-    if isinstance(left, pd.IntervalIndex) or isinstance(right, pd.IntervalIndex):
-        assert_interval_array_equal(left._values, right._values)
-
-    if check_categorical:
-        if is_categorical_dtype(left.dtype) or is_categorical_dtype(right.dtype):
-            assert_categorical_equal(left._values, right._values, obj=f"{obj} category")
-
-
-def assert_class_equal(left, right, exact: Union[bool, str] = True, obj="Input"):
-    """
-    Checks classes are equal.
-    """
-    __tracebackhide__ = True
-
-    def repr_class(x):
-        if isinstance(x, Index):
-            # return Index as it is to include values in the error message
-            return x
-
-        return type(x).__name__
-
-    if exact == "equiv":
-        if type(left) != type(right):
-            # allow equivalence of Int64Index/RangeIndex
-            types = {type(left).__name__, type(right).__name__}
-            if len(types - {"Int64Index", "RangeIndex"}):
-                msg = f"{obj} classes are not equivalent"
-                raise_assert_detail(obj, msg, repr_class(left), repr_class(right))
-    elif exact:
-        if type(left) != type(right):
-            msg = f"{obj} classes are different"
-            raise_assert_detail(obj, msg, repr_class(left), repr_class(right))
-
-
-def assert_attr_equal(attr: str, left, right, obj: str = "Attributes"):
-    """
-    Check attributes are equal. Both objects must have attribute.
-
-    Parameters
-    ----------
-    attr : str
-        Attribute name being compared.
-    left : object
-    right : object
-    obj : str, default 'Attributes'
-        Specify object name being compared, internally used to show appropriate
-        assertion message
-    """
-    __tracebackhide__ = True
-
-    left_attr = getattr(left, attr)
-    right_attr = getattr(right, attr)
-
-    if left_attr is right_attr:
-        return True
-    elif (
-        is_number(left_attr)
-        and np.isnan(left_attr)
-        and is_number(right_attr)
-        and np.isnan(right_attr)
-    ):
-        # np.nan
-        return True
-
-    try:
-        result = left_attr == right_attr
-    except TypeError:
-        # datetimetz on rhs may raise TypeError
-        result = False
-    if not isinstance(result, bool):
-        result = result.all()
-
-    if result:
-        return True
-    else:
-        msg = f'Attribute "{attr}" are different'
-        raise_assert_detail(obj, msg, left_attr, right_attr)
-
-
-def assert_is_valid_plot_return_object(objs):
-    import matplotlib.pyplot as plt
-
-    if isinstance(objs, (pd.Series, np.ndarray)):
-        for el in objs.ravel():
-            msg = (
-                "one of 'objs' is not a matplotlib Axes instance, "
-                f"type encountered {repr(type(el).__name__)}"
-            )
-            assert isinstance(el, (plt.Axes, dict)), msg
-    else:
-        msg = (
-            "objs is neither an ndarray of Artist instances nor a single "
-            "ArtistArtist instance, tuple, or dict, 'objs' is a "
-            f"{repr(type(objs).__name__)}"
-        )
-        assert isinstance(objs, (plt.Artist, tuple, dict)), msg
-
-
-def assert_is_sorted(seq):
-    """Assert that the sequence is sorted."""
-    if isinstance(seq, (Index, Series)):
-        seq = seq.values
-    # sorting does not change precisions
-    assert_numpy_array_equal(seq, np.sort(np.array(seq)))
-
-
-def assert_categorical_equal(
-    left, right, check_dtype=True, check_category_order=True, obj="Categorical"
-):
-    """
-    Test that Categoricals are equivalent.
-
-    Parameters
-    ----------
-    left : Categorical
-    right : Categorical
-    check_dtype : bool, default True
-        Check that integer dtype of the codes are the same
-    check_category_order : bool, default True
-        Whether the order of the categories should be compared, which
-        implies identical integer codes.  If False, only the resulting
-        values are compared.  The ordered attribute is
-        checked regardless.
-    obj : str, default 'Categorical'
-        Specify object name being compared, internally used to show appropriate
-        assertion message
-    """
-    _check_isinstance(left, right, Categorical)
-
-    if check_category_order:
-        assert_index_equal(left.categories, right.categories, obj=f"{obj}.categories")
-        assert_numpy_array_equal(
-            left.codes, right.codes, check_dtype=check_dtype, obj=f"{obj}.codes"
-        )
-    else:
-        try:
-            lc = left.categories.sort_values()
-            rc = right.categories.sort_values()
-        except TypeError:
-            # e.g. '<' not supported between instances of 'int' and 'str'
-            lc, rc = left.categories, right.categories
-        assert_index_equal(lc, rc, obj=f"{obj}.categories")
-        assert_index_equal(
-            left.categories.take(left.codes),
-            right.categories.take(right.codes),
-            obj=f"{obj}.values",
-        )
-
-    assert_attr_equal("ordered", left, right, obj=obj)
-
-
-def assert_interval_array_equal(left, right, exact="equiv", obj="IntervalArray"):
-    """
-    Test that two IntervalArrays are equivalent.
-
-    Parameters
-    ----------
-    left, right : IntervalArray
-        The IntervalArrays to compare.
-    exact : bool or {'equiv'}, default 'equiv'
-        Whether to check the Index class, dtype and inferred_type
-        are identical. If 'equiv', then RangeIndex can be substituted for
-        Int64Index as well.
-    obj : str, default 'IntervalArray'
-        Specify object name being compared, internally used to show appropriate
-        assertion message
-    """
-    _check_isinstance(left, right, IntervalArray)
-
-    kwargs = {}
-    if left._left.dtype.kind in ["m", "M"]:
-        # We have a DatetimeArray or TimedeltaArray
-        kwargs["check_freq"] = False
-
-    assert_equal(left._left, right._left, obj=f"{obj}.left", **kwargs)
-    assert_equal(left._right, right._right, obj=f"{obj}.left", **kwargs)
-
-    assert_attr_equal("closed", left, right, obj=obj)
-
-
-def assert_period_array_equal(left, right, obj="PeriodArray"):
-    _check_isinstance(left, right, PeriodArray)
-
-    assert_numpy_array_equal(left._data, right._data, obj=f"{obj}._data")
-    assert_attr_equal("freq", left, right, obj=obj)
-
-
-def assert_datetime_array_equal(left, right, obj="DatetimeArray", check_freq=True):
-    __tracebackhide__ = True
-    _check_isinstance(left, right, DatetimeArray)
-
-    assert_numpy_array_equal(left._data, right._data, obj=f"{obj}._data")
-    if check_freq:
-        assert_attr_equal("freq", left, right, obj=obj)
-    assert_attr_equal("tz", left, right, obj=obj)
-
-
-def assert_timedelta_array_equal(left, right, obj="TimedeltaArray", check_freq=True):
-    __tracebackhide__ = True
-    _check_isinstance(left, right, TimedeltaArray)
-    assert_numpy_array_equal(left._data, right._data, obj=f"{obj}._data")
-    if check_freq:
-        assert_attr_equal("freq", left, right, obj=obj)
-
-
-def raise_assert_detail(obj, message, left, right, diff=None, index_values=None):
-    __tracebackhide__ = True
-
-    msg = f"""{obj} are different
-
-{message}"""
-
-    if isinstance(index_values, np.ndarray):
-        msg += f"\n[index]: {pprint_thing(index_values)}"
-
-    if isinstance(left, np.ndarray):
-        left = pprint_thing(left)
-    elif is_categorical_dtype(left):
-        left = repr(left)
-
-    if isinstance(right, np.ndarray):
-        right = pprint_thing(right)
-    elif is_categorical_dtype(right):
-        right = repr(right)
-
-    msg += f"""
-[left]:  {left}
-[right]: {right}"""
-
-    if diff is not None:
-        msg += f"\n[diff]: {diff}"
-
-    raise AssertionError(msg)
-
-
-def assert_numpy_array_equal(
-    left,
-    right,
-    strict_nan=False,
-    check_dtype=True,
-    err_msg=None,
-    check_same=None,
-    obj="numpy array",
-    index_values=None,
-):
-    """
-    Check that 'np.ndarray' is equivalent.
-
-    Parameters
-    ----------
-    left, right : numpy.ndarray or iterable
-        The two arrays to be compared.
-    strict_nan : bool, default False
-        If True, consider NaN and None to be different.
-    check_dtype : bool, default True
-        Check dtype if both a and b are np.ndarray.
-    err_msg : str, default None
-        If provided, used as assertion message.
-    check_same : None|'copy'|'same', default None
-        Ensure left and right refer/do not refer to the same memory area.
-    obj : str, default 'numpy array'
-        Specify object name being compared, internally used to show appropriate
-        assertion message.
-    index_values : numpy.ndarray, default None
-        optional index (shared by both left and right), used in output.
-    """
-    __tracebackhide__ = True
-
-    # instance validation
-    # Show a detailed error message when classes are different
-    assert_class_equal(left, right, obj=obj)
-    # both classes must be an np.ndarray
-    _check_isinstance(left, right, np.ndarray)
-
-    def _get_base(obj):
-        return obj.base if getattr(obj, "base", None) is not None else obj
-
-    left_base = _get_base(left)
-    right_base = _get_base(right)
-
-    if check_same == "same":
-        if left_base is not right_base:
-            raise AssertionError(f"{repr(left_base)} is not {repr(right_base)}")
-    elif check_same == "copy":
-        if left_base is right_base:
-            raise AssertionError(f"{repr(left_base)} is {repr(right_base)}")
-
-    def _raise(left, right, err_msg):
-        if err_msg is None:
-            if left.shape != right.shape:
-                raise_assert_detail(
-                    obj, f"{obj} shapes are different", left.shape, right.shape
-                )
-
-            diff = 0
-            for left_arr, right_arr in zip(left, right):
-                # count up differences
-                if not array_equivalent(left_arr, right_arr, strict_nan=strict_nan):
-                    diff += 1
-
-            diff = diff * 100.0 / left.size
-            msg = f"{obj} values are different ({np.round(diff, 5)} %)"
-            raise_assert_detail(obj, msg, left, right, index_values=index_values)
-
-        raise AssertionError(err_msg)
-
-    # compare shape and values
-    if not array_equivalent(left, right, strict_nan=strict_nan):
-        _raise(left, right, err_msg)
-
-    if check_dtype:
-        if isinstance(left, np.ndarray) and isinstance(right, np.ndarray):
-            assert_attr_equal("dtype", left, right, obj=obj)
-
-
-def assert_extension_array_equal(
-    left,
-    right,
-    check_dtype=True,
-    index_values=None,
-    check_less_precise=no_default,
-    check_exact=False,
-    rtol: float = 1.0e-5,
-    atol: float = 1.0e-8,
-):
-    """
-    Check that left and right ExtensionArrays are equal.
-
-    Parameters
-    ----------
-    left, right : ExtensionArray
-        The two arrays to compare.
-    check_dtype : bool, default True
-        Whether to check if the ExtensionArray dtypes are identical.
-    index_values : numpy.ndarray, default None
-        Optional index (shared by both left and right), used in output.
-    check_less_precise : bool or int, default False
-        Specify comparison precision. Only used when check_exact is False.
-        5 digits (False) or 3 digits (True) after decimal points are compared.
-        If int, then specify the digits to compare.
-
-        .. deprecated:: 1.1.0
-           Use `rtol` and `atol` instead to define relative/absolute
-           tolerance, respectively. Similar to :func:`math.isclose`.
-    check_exact : bool, default False
-        Whether to compare number exactly.
-    rtol : float, default 1e-5
-        Relative tolerance. Only used when check_exact is False.
-
-        .. versionadded:: 1.1.0
-    atol : float, default 1e-8
-        Absolute tolerance. Only used when check_exact is False.
-
-        .. versionadded:: 1.1.0
-
-    Notes
-    -----
-    Missing values are checked separately from valid values.
-    A mask of missing values is computed for each and checked to match.
-    The remaining all-valid values are cast to object dtype and checked.
-
-    Examples
-    --------
-    >>> from pandas.testing import assert_extension_array_equal
-    >>> a = pd.Series([1, 2, 3, 4])
-    >>> b, c = a.array, a.array
-    >>> assert_extension_array_equal(b, c)
-    """
-    if check_less_precise is not no_default:
-        warnings.warn(
-            "The 'check_less_precise' keyword in testing.assert_*_equal "
-            "is deprecated and will be removed in a future version. "
-            "You can stop passing 'check_less_precise' to silence this warning.",
-            FutureWarning,
-            stacklevel=2,
-        )
-        rtol = atol = _get_tol_from_less_precise(check_less_precise)
-
-    assert isinstance(left, ExtensionArray), "left is not an ExtensionArray"
-    assert isinstance(right, ExtensionArray), "right is not an ExtensionArray"
-    if check_dtype:
-        assert_attr_equal("dtype", left, right, obj="ExtensionArray")
-
-    if (
-        isinstance(left, DatetimeLikeArrayMixin)
-        and isinstance(right, DatetimeLikeArrayMixin)
-        and type(right) == type(left)
-    ):
-        # Avoid slow object-dtype comparisons
-        # np.asarray for case where we have a np.MaskedArray
-        assert_numpy_array_equal(
-            np.asarray(left.asi8), np.asarray(right.asi8), index_values=index_values
-        )
-        return
-
-    left_na = np.asarray(left.isna())
-    right_na = np.asarray(right.isna())
-    assert_numpy_array_equal(
-        left_na, right_na, obj="ExtensionArray NA mask", index_values=index_values
-    )
-
-    left_valid = np.asarray(left[~left_na].astype(object))
-    right_valid = np.asarray(right[~right_na].astype(object))
-    if check_exact:
-        assert_numpy_array_equal(
-            left_valid, right_valid, obj="ExtensionArray", index_values=index_values
-        )
-    else:
-        _testing.assert_almost_equal(
-            left_valid,
-            right_valid,
-            check_dtype=check_dtype,
-            rtol=rtol,
-            atol=atol,
-            obj="ExtensionArray",
-            index_values=index_values,
-        )
-
-
-# This could be refactored to use the NDFrame.equals method
-def assert_series_equal(
-    left,
-    right,
-    check_dtype=True,
-    check_index_type="equiv",
-    check_series_type=True,
-    check_less_precise=no_default,
-    check_names=True,
-    check_exact=False,
-    check_datetimelike_compat=False,
-    check_categorical=True,
-    check_category_order=True,
-    check_freq=True,
-    check_flags=True,
-    rtol=1.0e-5,
-    atol=1.0e-8,
-    obj="Series",
-    *,
-    check_index=True,
-):
-    """
-    Check that left and right Series are equal.
-
-    Parameters
-    ----------
-    left : Series
-    right : Series
-    check_dtype : bool, default True
-        Whether to check the Series dtype is identical.
-    check_index_type : bool or {'equiv'}, default 'equiv'
-        Whether to check the Index class, dtype and inferred_type
-        are identical.
-    check_series_type : bool, default True
-         Whether to check the Series class is identical.
-    check_less_precise : bool or int, default False
-        Specify comparison precision. Only used when check_exact is False.
-        5 digits (False) or 3 digits (True) after decimal points are compared.
-        If int, then specify the digits to compare.
-
-        When comparing two numbers, if the first number has magnitude less
-        than 1e-5, we compare the two numbers directly and check whether
-        they are equivalent within the specified precision. Otherwise, we
-        compare the **ratio** of the second number to the first number and
-        check whether it is equivalent to 1 within the specified precision.
-
-        .. deprecated:: 1.1.0
-           Use `rtol` and `atol` instead to define relative/absolute
-           tolerance, respectively. Similar to :func:`math.isclose`.
-    check_names : bool, default True
-        Whether to check the Series and Index names attribute.
-    check_exact : bool, default False
-        Whether to compare number exactly.
-    check_datetimelike_compat : bool, default False
-        Compare datetime-like which is comparable ignoring dtype.
-    check_categorical : bool, default True
-        Whether to compare internal Categorical exactly.
-    check_category_order : bool, default True
-        Whether to compare category order of internal Categoricals.
-
-        .. versionadded:: 1.0.2
-    check_freq : bool, default True
-        Whether to check the `freq` attribute on a DatetimeIndex or TimedeltaIndex.
-    check_flags : bool, default True
-        Whether to check the `flags` attribute.
-
-        .. versionadded:: 1.2.0
-
-    rtol : float, default 1e-5
-        Relative tolerance. Only used when check_exact is False.
-
-        .. versionadded:: 1.1.0
-    atol : float, default 1e-8
-        Absolute tolerance. Only used when check_exact is False.
-
-        .. versionadded:: 1.1.0
-    obj : str, default 'Series'
-        Specify object name being compared, internally used to show appropriate
-        assertion message.
-    check_index : bool, default True
-        Whether to check index equivalence. If False, then compare only values.
-
-        .. versionadded:: 1.3.0
-
-    Examples
-    --------
-    >>> from pandas.testing import assert_series_equal
-    >>> a = pd.Series([1, 2, 3, 4])
-    >>> b = pd.Series([1, 2, 3, 4])
-    >>> assert_series_equal(a, b)
-    """
-    __tracebackhide__ = True
-
-    if check_less_precise is not no_default:
-        warnings.warn(
-            "The 'check_less_precise' keyword in testing.assert_*_equal "
-            "is deprecated and will be removed in a future version. "
-            "You can stop passing 'check_less_precise' to silence this warning.",
-            FutureWarning,
-            stacklevel=2,
-        )
-        rtol = atol = _get_tol_from_less_precise(check_less_precise)
-
-    # instance validation
-    _check_isinstance(left, right, Series)
-
-    if check_series_type:
-        assert_class_equal(left, right, obj=obj)
-
-    # length comparison
-    if len(left) != len(right):
-        msg1 = f"{len(left)}, {left.index}"
-        msg2 = f"{len(right)}, {right.index}"
-        raise_assert_detail(obj, "Series length are different", msg1, msg2)
-
-    if check_flags:
-        assert left.flags == right.flags, f"{repr(left.flags)} != {repr(right.flags)}"
-
-    if check_index:
-        # GH #38183
-        assert_index_equal(
-            left.index,
-            right.index,
-            exact=check_index_type,
-            check_names=check_names,
-            check_exact=check_exact,
-            check_categorical=check_categorical,
-            rtol=rtol,
-            atol=atol,
-            obj=f"{obj}.index",
-        )
-
-    if check_freq and isinstance(left.index, (pd.DatetimeIndex, pd.TimedeltaIndex)):
-        lidx = left.index
-        ridx = right.index
-        assert lidx.freq == ridx.freq, (lidx.freq, ridx.freq)
-
-    if check_dtype:
-        # We want to skip exact dtype checking when `check_categorical`
-        # is False. We'll still raise if only one is a `Categorical`,
-        # regardless of `check_categorical`
-        if (
-            is_categorical_dtype(left.dtype)
-            and is_categorical_dtype(right.dtype)
-            and not check_categorical
-        ):
-            pass
-        else:
-            assert_attr_equal("dtype", left, right, obj=f"Attributes of {obj}")
-
-    if check_exact and is_numeric_dtype(left.dtype) and is_numeric_dtype(right.dtype):
-        # Only check exact if dtype is numeric
-        assert_numpy_array_equal(
-            left._values,
-            right._values,
-            check_dtype=check_dtype,
-            obj=str(obj),
-            index_values=np.asarray(left.index),
-        )
-    elif check_datetimelike_compat and (
-        needs_i8_conversion(left.dtype) or needs_i8_conversion(right.dtype)
-    ):
-        # we want to check only if we have compat dtypes
-        # e.g. integer and M|m are NOT compat, but we can simply check
-        # the values in that case
-
-        # datetimelike may have different objects (e.g. datetime.datetime
-        # vs Timestamp) but will compare equal
-        if not Index(left._values).equals(Index(right._values)):
-            msg = (
-                f"[datetimelike_compat=True] {left._values} "
-                f"is not equal to {right._values}."
-            )
-            raise AssertionError(msg)
-    elif is_interval_dtype(left.dtype) and is_interval_dtype(right.dtype):
-        assert_interval_array_equal(left.array, right.array)
-    elif is_categorical_dtype(left.dtype) or is_categorical_dtype(right.dtype):
-        _testing.assert_almost_equal(
-            left._values,
-            right._values,
-            rtol=rtol,
-            atol=atol,
-            check_dtype=check_dtype,
-            obj=str(obj),
-            index_values=np.asarray(left.index),
-        )
-    elif is_extension_array_dtype(left.dtype) and is_extension_array_dtype(right.dtype):
-        assert_extension_array_equal(
-            left._values,
-            right._values,
-            check_dtype=check_dtype,
-            index_values=np.asarray(left.index),
-        )
-    elif is_extension_array_dtype_and_needs_i8_conversion(
-        left.dtype, right.dtype
-    ) or is_extension_array_dtype_and_needs_i8_conversion(right.dtype, left.dtype):
-        assert_extension_array_equal(
-            left._values,
-            right._values,
-            check_dtype=check_dtype,
-            index_values=np.asarray(left.index),
-        )
-    elif needs_i8_conversion(left.dtype) and needs_i8_conversion(right.dtype):
-        # DatetimeArray or TimedeltaArray
-        assert_extension_array_equal(
-            left._values,
-            right._values,
-            check_dtype=check_dtype,
-            index_values=np.asarray(left.index),
-        )
-    else:
-        _testing.assert_almost_equal(
-            left._values,
-            right._values,
-            rtol=rtol,
-            atol=atol,
-            check_dtype=check_dtype,
-            obj=str(obj),
-            index_values=np.asarray(left.index),
-        )
-
-    # metadata comparison
-    if check_names:
-        assert_attr_equal("name", left, right, obj=obj)
-
-    if check_categorical:
-        if is_categorical_dtype(left.dtype) or is_categorical_dtype(right.dtype):
-            assert_categorical_equal(
-                left._values,
-                right._values,
-                obj=f"{obj} category",
-                check_category_order=check_category_order,
-            )
-
-
-# This could be refactored to use the NDFrame.equals method
-def assert_frame_equal(
-    left,
-    right,
-    check_dtype=True,
-    check_index_type="equiv",
-    check_column_type="equiv",
-    check_frame_type=True,
-    check_less_precise=no_default,
-    check_names=True,
-    by_blocks=False,
-    check_exact=False,
-    check_datetimelike_compat=False,
-    check_categorical=True,
-    check_like=False,
-    check_freq=True,
-    check_flags=True,
-    rtol=1.0e-5,
-    atol=1.0e-8,
-    obj="DataFrame",
-):
-    """
-    Check that left and right DataFrame are equal.
-
-    This function is intended to compare two DataFrames and output any
-    differences. Is is mostly intended for use in unit tests.
-    Additional parameters allow varying the strictness of the
-    equality checks performed.
-
-    Parameters
-    ----------
-    left : DataFrame
-        First DataFrame to compare.
-    right : DataFrame
-        Second DataFrame to compare.
-    check_dtype : bool, default True
-        Whether to check the DataFrame dtype is identical.
-    check_index_type : bool or {'equiv'}, default 'equiv'
-        Whether to check the Index class, dtype and inferred_type
-        are identical.
-    check_column_type : bool or {'equiv'}, default 'equiv'
-        Whether to check the columns class, dtype and inferred_type
-        are identical. Is passed as the ``exact`` argument of
-        :func:`assert_index_equal`.
-    check_frame_type : bool, default True
-        Whether to check the DataFrame class is identical.
-    check_less_precise : bool or int, default False
-        Specify comparison precision. Only used when check_exact is False.
-        5 digits (False) or 3 digits (True) after decimal points are compared.
-        If int, then specify the digits to compare.
-
-        When comparing two numbers, if the first number has magnitude less
-        than 1e-5, we compare the two numbers directly and check whether
-        they are equivalent within the specified precision. Otherwise, we
-        compare the **ratio** of the second number to the first number and
-        check whether it is equivalent to 1 within the specified precision.
-
-        .. deprecated:: 1.1.0
-           Use `rtol` and `atol` instead to define relative/absolute
-           tolerance, respectively. Similar to :func:`math.isclose`.
-    check_names : bool, default True
-        Whether to check that the `names` attribute for both the `index`
-        and `column` attributes of the DataFrame is identical.
-    by_blocks : bool, default False
-        Specify how to compare internal data. If False, compare by columns.
-        If True, compare by blocks.
-    check_exact : bool, default False
-        Whether to compare number exactly.
-    check_datetimelike_compat : bool, default False
-        Compare datetime-like which is comparable ignoring dtype.
-    check_categorical : bool, default True
-        Whether to compare internal Categorical exactly.
-    check_like : bool, default False
-        If True, ignore the order of index & columns.
-        Note: index labels must match their respective rows
-        (same as in columns) - same labels must be with the same data.
-    check_freq : bool, default True
-        Whether to check the `freq` attribute on a DatetimeIndex or TimedeltaIndex.
-    check_flags : bool, default True
-        Whether to check the `flags` attribute.
-    rtol : float, default 1e-5
-        Relative tolerance. Only used when check_exact is False.
-
-        .. versionadded:: 1.1.0
-    atol : float, default 1e-8
-        Absolute tolerance. Only used when check_exact is False.
-
-        .. versionadded:: 1.1.0
-    obj : str, default 'DataFrame'
-        Specify object name being compared, internally used to show appropriate
-        assertion message.
-
-    See Also
-    --------
-    assert_series_equal : Equivalent method for asserting Series equality.
-    DataFrame.equals : Check DataFrame equality.
-
-    Examples
-    --------
-    This example shows comparing two DataFrames that are equal
-    but with columns of differing dtypes.
-
-    >>> from pandas._testing import assert_frame_equal
-    >>> df1 = pd.DataFrame({'a': [1, 2], 'b': [3, 4]})
-    >>> df2 = pd.DataFrame({'a': [1, 2], 'b': [3.0, 4.0]})
-
-    df1 equals itself.
-
-    >>> assert_frame_equal(df1, df1)
-
-    df1 differs from df2 as column 'b' is of a different type.
-
-    >>> assert_frame_equal(df1, df2)
-    Traceback (most recent call last):
-    ...
-    AssertionError: Attributes of DataFrame.iloc[:, 1] (column name="b") are different
-
-    Attribute "dtype" are different
-    [left]:  int64
-    [right]: float64
-
-    Ignore differing dtypes in columns with check_dtype.
-
-    >>> assert_frame_equal(df1, df2, check_dtype=False)
-    """
-    __tracebackhide__ = True
-
-    if check_less_precise is not no_default:
-        warnings.warn(
-            "The 'check_less_precise' keyword in testing.assert_*_equal "
-            "is deprecated and will be removed in a future version. "
-            "You can stop passing 'check_less_precise' to silence this warning.",
-            FutureWarning,
-            stacklevel=2,
-        )
-        rtol = atol = _get_tol_from_less_precise(check_less_precise)
-
-    # instance validation
-    _check_isinstance(left, right, DataFrame)
-
-    if check_frame_type:
-        assert isinstance(left, type(right))
-        # assert_class_equal(left, right, obj=obj)
-
-    # shape comparison
-    if left.shape != right.shape:
-        raise_assert_detail(
-            obj, f"{obj} shape mismatch", f"{repr(left.shape)}", f"{repr(right.shape)}"
-        )
-
-    if check_flags:
-        assert left.flags == right.flags, f"{repr(left.flags)} != {repr(right.flags)}"
-
-    # index comparison
-    assert_index_equal(
-        left.index,
-        right.index,
-        exact=check_index_type,
-        check_names=check_names,
-        check_exact=check_exact,
-        check_categorical=check_categorical,
-        check_order=not check_like,
-        rtol=rtol,
-        atol=atol,
-        obj=f"{obj}.index",
-    )
-
-    # column comparison
-    assert_index_equal(
-        left.columns,
-        right.columns,
-        exact=check_column_type,
-        check_names=check_names,
-        check_exact=check_exact,
-        check_categorical=check_categorical,
-        check_order=not check_like,
-        rtol=rtol,
-        atol=atol,
-        obj=f"{obj}.columns",
-    )
-
-    if check_like:
-        left, right = left.reindex_like(right), right
-
-    # compare by blocks
-    if by_blocks:
-        rblocks = right._to_dict_of_blocks()
-        lblocks = left._to_dict_of_blocks()
-        for dtype in list(set(list(lblocks.keys()) + list(rblocks.keys()))):
-            assert dtype in lblocks
-            assert dtype in rblocks
-            assert_frame_equal(
-                lblocks[dtype], rblocks[dtype], check_dtype=check_dtype, obj=obj
-            )
-
-    # compare by columns
-    else:
-        for i, col in enumerate(left.columns):
-            assert col in right
-            lcol = left.iloc[:, i]
-            rcol = right.iloc[:, i]
-            # GH #38183
-            # use check_index=False, because we do not want to run
-            # assert_index_equal for each column,
-            # as we already checked it for the whole dataframe before.
-            assert_series_equal(
-                lcol,
-                rcol,
-                check_dtype=check_dtype,
-                check_index_type=check_index_type,
-                check_exact=check_exact,
-                check_names=check_names,
-                check_datetimelike_compat=check_datetimelike_compat,
-                check_categorical=check_categorical,
-                check_freq=check_freq,
-                obj=f'{obj}.iloc[:, {i}] (column name="{col}")',
-                rtol=rtol,
-                atol=atol,
-                check_index=False,
-            )
-
-
-def assert_equal(left, right, **kwargs):
-    """
-    Wrapper for tm.assert_*_equal to dispatch to the appropriate test function.
-
-    Parameters
-    ----------
-    left, right : Index, Series, DataFrame, ExtensionArray, or np.ndarray
-        The two items to be compared.
-    **kwargs
-        All keyword arguments are passed through to the underlying assert method.
-    """
-    __tracebackhide__ = True
-
-    if isinstance(left, pd.Index):
-        assert_index_equal(left, right, **kwargs)
-        if isinstance(left, (pd.DatetimeIndex, pd.TimedeltaIndex)):
-            assert left.freq == right.freq, (left.freq, right.freq)
-    elif isinstance(left, pd.Series):
-        assert_series_equal(left, right, **kwargs)
-    elif isinstance(left, pd.DataFrame):
-        assert_frame_equal(left, right, **kwargs)
-    elif isinstance(left, IntervalArray):
-        assert_interval_array_equal(left, right, **kwargs)
-    elif isinstance(left, PeriodArray):
-        assert_period_array_equal(left, right, **kwargs)
-    elif isinstance(left, DatetimeArray):
-        assert_datetime_array_equal(left, right, **kwargs)
-    elif isinstance(left, TimedeltaArray):
-        assert_timedelta_array_equal(left, right, **kwargs)
-    elif isinstance(left, ExtensionArray):
-        assert_extension_array_equal(left, right, **kwargs)
-    elif isinstance(left, np.ndarray):
-        assert_numpy_array_equal(left, right, **kwargs)
-    elif isinstance(left, str):
-        assert kwargs == {}
-        assert left == right
-    else:
-        raise NotImplementedError(type(left))
-
-
 def box_expected(expected, box_cls, transpose=True):
     """
     Helper function to wrap the expected output of a test in a given box_class.
@@ -1829,84 +562,10 @@ def to_array(obj):
         return np.array(obj)
 
 
-# -----------------------------------------------------------------------------
-# Sparse
-
-
-def assert_sp_array_equal(left, right):
-    """
-    Check that the left and right SparseArray are equal.
-
-    Parameters
-    ----------
-    left : SparseArray
-    right : SparseArray
-    """
-    _check_isinstance(left, right, pd.arrays.SparseArray)
-
-    assert_numpy_array_equal(left.sp_values, right.sp_values)
-
-    # SparseIndex comparison
-    assert isinstance(left.sp_index, pd._libs.sparse.SparseIndex)
-    assert isinstance(right.sp_index, pd._libs.sparse.SparseIndex)
-
-    left_index = left.sp_index
-    right_index = right.sp_index
-
-    if not left_index.equals(right_index):
-        raise_assert_detail(
-            "SparseArray.index", "index are not equal", left_index, right_index
-        )
-    else:
-        # Just ensure a
-        pass
-
-    assert_attr_equal("fill_value", left, right)
-    assert_attr_equal("dtype", left, right)
-    assert_numpy_array_equal(left.to_dense(), right.to_dense())
-
-
 # -----------------------------------------------------------------------------
 # Others
 
 
-def assert_contains_all(iterable, dic):
-    for k in iterable:
-        assert k in dic, f"Did not contain item: {repr(k)}"
-
-
-def assert_copy(iter1, iter2, **eql_kwargs):
-    """
-    iter1, iter2: iterables that produce elements
-    comparable with assert_almost_equal
-
-    Checks that the elements are equal, but not
-    the same object. (Does not check that items
-    in sequences are also not the same object)
-    """
-    for elem1, elem2 in zip(iter1, iter2):
-        assert_almost_equal(elem1, elem2, **eql_kwargs)
-        msg = (
-            f"Expected object {repr(type(elem1))} and object {repr(type(elem2))} to be "
-            "different objects, but they were the same object."
-        )
-        assert elem1 is not elem2, msg
-
-
-def is_extension_array_dtype_and_needs_i8_conversion(left_dtype, right_dtype) -> bool:
-    """
-    Checks that we have the combination of an ExtensionArraydtype and
-    a dtype that should be converted to int64
-
-    Returns
-    -------
-    bool
-
-    Related to issue #37609
-    """
-    return is_extension_array_dtype(left_dtype) and needs_i8_conversion(right_dtype)
-
-
 def getCols(k):
     return string.ascii_uppercase[:k]
 
@@ -2090,12 +749,12 @@ def all_timeseries_index_generator(k=10):
 # make series
 def makeFloatSeries(name=None):
     index = makeStringIndex(_N)
-    return Series(randn(_N), index=index, name=name)
+    return Series(np.random.randn(_N), index=index, name=name)
 
 
 def makeStringSeries(name=None):
     index = makeStringIndex(_N)
-    return Series(randn(_N), index=index, name=name)
+    return Series(np.random.randn(_N), index=index, name=name)
 
 
 def makeObjectSeries(name=None):
@@ -2107,19 +766,21 @@ def makeObjectSeries(name=None):
 
 def getSeriesData():
     index = makeStringIndex(_N)
-    return {c: Series(randn(_N), index=index) for c in getCols(_K)}
+    return {c: Series(np.random.randn(_N), index=index) for c in getCols(_K)}
 
 
 def makeTimeSeries(nper=None, freq="B", name=None):
     if nper is None:
         nper = _N
-    return Series(randn(nper), index=makeDateIndex(nper, freq=freq), name=name)
+    return Series(
+        np.random.randn(nper), index=makeDateIndex(nper, freq=freq), name=name
+    )
 
 
 def makePeriodSeries(nper=None, name=None):
     if nper is None:
         nper = _N
-    return Series(randn(nper), index=makePeriodIndex(nper), name=name)
+    return Series(np.random.randn(nper), index=makePeriodIndex(nper), name=name)
 
 
 def getTimeSeriesData(nper=None, freq="B"):
diff --git a/pandas/_testing/asserters.py b/pandas/_testing/asserters.py
new file mode 100644
index 0000000000000..ba4410bd95940
--- /dev/null
+++ b/pandas/_testing/asserters.py
@@ -0,0 +1,1382 @@
+from typing import Union, cast
+import warnings
+
+import numpy as np
+
+from pandas._libs.lib import no_default
+import pandas._libs.testing as _testing
+
+from pandas.core.dtypes.common import (
+    is_bool,
+    is_categorical_dtype,
+    is_extension_array_dtype,
+    is_interval_dtype,
+    is_number,
+    is_numeric_dtype,
+    needs_i8_conversion,
+)
+from pandas.core.dtypes.missing import array_equivalent
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    DataFrame,
+    DatetimeIndex,
+    Index,
+    IntervalIndex,
+    MultiIndex,
+    PeriodIndex,
+    Series,
+    TimedeltaIndex,
+)
+from pandas.core.algorithms import take_1d
+from pandas.core.arrays import (
+    DatetimeArray,
+    ExtensionArray,
+    IntervalArray,
+    PeriodArray,
+    TimedeltaArray,
+)
+from pandas.core.arrays.datetimelike import DatetimeLikeArrayMixin
+
+from pandas.io.formats.printing import pprint_thing
+
+
+def assert_almost_equal(
+    left,
+    right,
+    check_dtype: Union[bool, str] = "equiv",
+    check_less_precise: Union[bool, int] = no_default,
+    rtol: float = 1.0e-5,
+    atol: float = 1.0e-8,
+    **kwargs,
+):
+    """
+    Check that the left and right objects are approximately equal.
+
+    By approximately equal, we refer to objects that are numbers or that
+    contain numbers which may be equivalent to specific levels of precision.
+
+    Parameters
+    ----------
+    left : object
+    right : object
+    check_dtype : bool or {'equiv'}, default 'equiv'
+        Check dtype if both a and b are the same type. If 'equiv' is passed in,
+        then `RangeIndex` and `Int64Index` are also considered equivalent
+        when doing type checking.
+    check_less_precise : bool or int, default False
+        Specify comparison precision. 5 digits (False) or 3 digits (True)
+        after decimal points are compared. If int, then specify the number
+        of digits to compare.
+
+        When comparing two numbers, if the first number has magnitude less
+        than 1e-5, we compare the two numbers directly and check whether
+        they are equivalent within the specified precision. Otherwise, we
+        compare the **ratio** of the second number to the first number and
+        check whether it is equivalent to 1 within the specified precision.
+
+        .. deprecated:: 1.1.0
+           Use `rtol` and `atol` instead to define relative/absolute
+           tolerance, respectively. Similar to :func:`math.isclose`.
+    rtol : float, default 1e-5
+        Relative tolerance.
+
+        .. versionadded:: 1.1.0
+    atol : float, default 1e-8
+        Absolute tolerance.
+
+        .. versionadded:: 1.1.0
+    """
+    if check_less_precise is not no_default:
+        warnings.warn(
+            "The 'check_less_precise' keyword in testing.assert_*_equal "
+            "is deprecated and will be removed in a future version. "
+            "You can stop passing 'check_less_precise' to silence this warning.",
+            FutureWarning,
+            stacklevel=2,
+        )
+        rtol = atol = _get_tol_from_less_precise(check_less_precise)
+
+    if isinstance(left, Index):
+        assert_index_equal(
+            left,
+            right,
+            check_exact=False,
+            exact=check_dtype,
+            rtol=rtol,
+            atol=atol,
+            **kwargs,
+        )
+
+    elif isinstance(left, Series):
+        assert_series_equal(
+            left,
+            right,
+            check_exact=False,
+            check_dtype=check_dtype,
+            rtol=rtol,
+            atol=atol,
+            **kwargs,
+        )
+
+    elif isinstance(left, DataFrame):
+        assert_frame_equal(
+            left,
+            right,
+            check_exact=False,
+            check_dtype=check_dtype,
+            rtol=rtol,
+            atol=atol,
+            **kwargs,
+        )
+
+    else:
+        # Other sequences.
+        if check_dtype:
+            if is_number(left) and is_number(right):
+                # Do not compare numeric classes, like np.float64 and float.
+                pass
+            elif is_bool(left) and is_bool(right):
+                # Do not compare bool classes, like np.bool_ and bool.
+                pass
+            else:
+                if isinstance(left, np.ndarray) or isinstance(right, np.ndarray):
+                    obj = "numpy array"
+                else:
+                    obj = "Input"
+                assert_class_equal(left, right, obj=obj)
+        _testing.assert_almost_equal(
+            left, right, check_dtype=check_dtype, rtol=rtol, atol=atol, **kwargs
+        )
+
+
+def _get_tol_from_less_precise(check_less_precise: Union[bool, int]) -> float:
+    """
+    Return the tolerance equivalent to the deprecated `check_less_precise`
+    parameter.
+
+    Parameters
+    ----------
+    check_less_precise : bool or int
+
+    Returns
+    -------
+    float
+        Tolerance to be used as relative/absolute tolerance.
+
+    Examples
+    --------
+    >>> # Using check_less_precise as a bool:
+    >>> _get_tol_from_less_precise(False)
+    0.5e-5
+    >>> _get_tol_from_less_precise(True)
+    0.5e-3
+    >>> # Using check_less_precise as an int representing the decimal
+    >>> # tolerance intended:
+    >>> _get_tol_from_less_precise(2)
+    0.5e-2
+    >>> _get_tol_from_less_precise(8)
+    0.5e-8
+
+    """
+    if isinstance(check_less_precise, bool):
+        if check_less_precise:
+            # 3-digit tolerance
+            return 0.5e-3
+        else:
+            # 5-digit tolerance
+            return 0.5e-5
+    else:
+        # Equivalent to setting checking_less_precise=<decimals>
+        return 0.5 * 10 ** -check_less_precise
+
+
+def _check_isinstance(left, right, cls):
+    """
+    Helper method for our assert_* methods that ensures that
+    the two objects being compared have the right type before
+    proceeding with the comparison.
+
+    Parameters
+    ----------
+    left : The first object being compared.
+    right : The second object being compared.
+    cls : The class type to check against.
+
+    Raises
+    ------
+    AssertionError : Either `left` or `right` is not an instance of `cls`.
+    """
+    cls_name = cls.__name__
+
+    if not isinstance(left, cls):
+        raise AssertionError(
+            f"{cls_name} Expected type {cls}, found {type(left)} instead"
+        )
+    if not isinstance(right, cls):
+        raise AssertionError(
+            f"{cls_name} Expected type {cls}, found {type(right)} instead"
+        )
+
+
+def assert_dict_equal(left, right, compare_keys: bool = True):
+
+    _check_isinstance(left, right, dict)
+    _testing.assert_dict_equal(left, right, compare_keys=compare_keys)
+
+
+def assert_index_equal(
+    left: Index,
+    right: Index,
+    exact: Union[bool, str] = "equiv",
+    check_names: bool = True,
+    check_less_precise: Union[bool, int] = no_default,
+    check_exact: bool = True,
+    check_categorical: bool = True,
+    check_order: bool = True,
+    rtol: float = 1.0e-5,
+    atol: float = 1.0e-8,
+    obj: str = "Index",
+) -> None:
+    """
+    Check that left and right Index are equal.
+
+    Parameters
+    ----------
+    left : Index
+    right : Index
+    exact : bool or {'equiv'}, default 'equiv'
+        Whether to check the Index class, dtype and inferred_type
+        are identical. If 'equiv', then RangeIndex can be substituted for
+        Int64Index as well.
+    check_names : bool, default True
+        Whether to check the names attribute.
+    check_less_precise : bool or int, default False
+        Specify comparison precision. Only used when check_exact is False.
+        5 digits (False) or 3 digits (True) after decimal points are compared.
+        If int, then specify the digits to compare.
+
+        .. deprecated:: 1.1.0
+           Use `rtol` and `atol` instead to define relative/absolute
+           tolerance, respectively. Similar to :func:`math.isclose`.
+    check_exact : bool, default True
+        Whether to compare number exactly.
+    check_categorical : bool, default True
+        Whether to compare internal Categorical exactly.
+    check_order : bool, default True
+        Whether to compare the order of index entries as well as their values.
+        If True, both indexes must contain the same elements, in the same order.
+        If False, both indexes must contain the same elements, but in any order.
+
+        .. versionadded:: 1.2.0
+    rtol : float, default 1e-5
+        Relative tolerance. Only used when check_exact is False.
+
+        .. versionadded:: 1.1.0
+    atol : float, default 1e-8
+        Absolute tolerance. Only used when check_exact is False.
+
+        .. versionadded:: 1.1.0
+    obj : str, default 'Index'
+        Specify object name being compared, internally used to show appropriate
+        assertion message.
+
+    Examples
+    --------
+    >>> from pandas.testing import assert_index_equal
+    >>> a = pd.Index([1, 2, 3])
+    >>> b = pd.Index([1, 2, 3])
+    >>> assert_index_equal(a, b)
+    """
+    __tracebackhide__ = True
+
+    def _check_types(left, right, obj="Index"):
+        if exact:
+            assert_class_equal(left, right, exact=exact, obj=obj)
+
+            # Skip exact dtype checking when `check_categorical` is False
+            if check_categorical:
+                assert_attr_equal("dtype", left, right, obj=obj)
+
+            # allow string-like to have different inferred_types
+            if left.inferred_type in ("string"):
+                assert right.inferred_type in ("string")
+            else:
+                assert_attr_equal("inferred_type", left, right, obj=obj)
+
+    def _get_ilevel_values(index, level):
+        # accept level number only
+        unique = index.levels[level]
+        level_codes = index.codes[level]
+        filled = take_1d(unique._values, level_codes, fill_value=unique._na_value)
+        return unique._shallow_copy(filled, name=index.names[level])
+
+    if check_less_precise is not no_default:
+        warnings.warn(
+            "The 'check_less_precise' keyword in testing.assert_*_equal "
+            "is deprecated and will be removed in a future version. "
+            "You can stop passing 'check_less_precise' to silence this warning.",
+            FutureWarning,
+            stacklevel=2,
+        )
+        rtol = atol = _get_tol_from_less_precise(check_less_precise)
+
+    # instance validation
+    _check_isinstance(left, right, Index)
+
+    # class / dtype comparison
+    _check_types(left, right, obj=obj)
+
+    # level comparison
+    if left.nlevels != right.nlevels:
+        msg1 = f"{obj} levels are different"
+        msg2 = f"{left.nlevels}, {left}"
+        msg3 = f"{right.nlevels}, {right}"
+        raise_assert_detail(obj, msg1, msg2, msg3)
+
+    # length comparison
+    if len(left) != len(right):
+        msg1 = f"{obj} length are different"
+        msg2 = f"{len(left)}, {left}"
+        msg3 = f"{len(right)}, {right}"
+        raise_assert_detail(obj, msg1, msg2, msg3)
+
+    # If order doesn't matter then sort the index entries
+    if not check_order:
+        left = left.sort_values()
+        right = right.sort_values()
+
+    # MultiIndex special comparison for little-friendly error messages
+    if left.nlevels > 1:
+        left = cast(MultiIndex, left)
+        right = cast(MultiIndex, right)
+
+        for level in range(left.nlevels):
+            # cannot use get_level_values here because it can change dtype
+            llevel = _get_ilevel_values(left, level)
+            rlevel = _get_ilevel_values(right, level)
+
+            lobj = f"MultiIndex level [{level}]"
+            assert_index_equal(
+                llevel,
+                rlevel,
+                exact=exact,
+                check_names=check_names,
+                check_exact=check_exact,
+                rtol=rtol,
+                atol=atol,
+                obj=lobj,
+            )
+            # get_level_values may change dtype
+            _check_types(left.levels[level], right.levels[level], obj=obj)
+
+    # skip exact index checking when `check_categorical` is False
+    if check_exact and check_categorical:
+        if not left.equals(right):
+            diff = (
+                np.sum((left._values != right._values).astype(int)) * 100.0 / len(left)
+            )
+            msg = f"{obj} values are different ({np.round(diff, 5)} %)"
+            raise_assert_detail(obj, msg, left, right)
+    else:
+        _testing.assert_almost_equal(
+            left.values,
+            right.values,
+            rtol=rtol,
+            atol=atol,
+            check_dtype=exact,
+            obj=obj,
+            lobj=left,
+            robj=right,
+        )
+
+    # metadata comparison
+    if check_names:
+        assert_attr_equal("names", left, right, obj=obj)
+    if isinstance(left, PeriodIndex) or isinstance(right, PeriodIndex):
+        assert_attr_equal("freq", left, right, obj=obj)
+    if isinstance(left, IntervalIndex) or isinstance(right, IntervalIndex):
+        assert_interval_array_equal(left._values, right._values)
+
+    if check_categorical:
+        if is_categorical_dtype(left.dtype) or is_categorical_dtype(right.dtype):
+            assert_categorical_equal(left._values, right._values, obj=f"{obj} category")
+
+
+def assert_class_equal(left, right, exact: Union[bool, str] = True, obj="Input"):
+    """
+    Checks classes are equal.
+    """
+    __tracebackhide__ = True
+
+    def repr_class(x):
+        if isinstance(x, Index):
+            # return Index as it is to include values in the error message
+            return x
+
+        return type(x).__name__
+
+    if exact == "equiv":
+        if type(left) != type(right):
+            # allow equivalence of Int64Index/RangeIndex
+            types = {type(left).__name__, type(right).__name__}
+            if len(types - {"Int64Index", "RangeIndex"}):
+                msg = f"{obj} classes are not equivalent"
+                raise_assert_detail(obj, msg, repr_class(left), repr_class(right))
+    elif exact:
+        if type(left) != type(right):
+            msg = f"{obj} classes are different"
+            raise_assert_detail(obj, msg, repr_class(left), repr_class(right))
+
+
+def assert_attr_equal(attr: str, left, right, obj: str = "Attributes"):
+    """
+    Check attributes are equal. Both objects must have attribute.
+
+    Parameters
+    ----------
+    attr : str
+        Attribute name being compared.
+    left : object
+    right : object
+    obj : str, default 'Attributes'
+        Specify object name being compared, internally used to show appropriate
+        assertion message
+    """
+    __tracebackhide__ = True
+
+    left_attr = getattr(left, attr)
+    right_attr = getattr(right, attr)
+
+    if left_attr is right_attr:
+        return True
+    elif (
+        is_number(left_attr)
+        and np.isnan(left_attr)
+        and is_number(right_attr)
+        and np.isnan(right_attr)
+    ):
+        # np.nan
+        return True
+
+    try:
+        result = left_attr == right_attr
+    except TypeError:
+        # datetimetz on rhs may raise TypeError
+        result = False
+    if not isinstance(result, bool):
+        result = result.all()
+
+    if result:
+        return True
+    else:
+        msg = f'Attribute "{attr}" are different'
+        raise_assert_detail(obj, msg, left_attr, right_attr)
+
+
+def assert_is_valid_plot_return_object(objs):
+    import matplotlib.pyplot as plt
+
+    if isinstance(objs, (Series, np.ndarray)):
+        for el in objs.ravel():
+            msg = (
+                "one of 'objs' is not a matplotlib Axes instance, "
+                f"type encountered {repr(type(el).__name__)}"
+            )
+            assert isinstance(el, (plt.Axes, dict)), msg
+    else:
+        msg = (
+            "objs is neither an ndarray of Artist instances nor a single "
+            "ArtistArtist instance, tuple, or dict, 'objs' is a "
+            f"{repr(type(objs).__name__)}"
+        )
+        assert isinstance(objs, (plt.Artist, tuple, dict)), msg
+
+
+def assert_is_sorted(seq):
+    """Assert that the sequence is sorted."""
+    if isinstance(seq, (Index, Series)):
+        seq = seq.values
+    # sorting does not change precisions
+    assert_numpy_array_equal(seq, np.sort(np.array(seq)))
+
+
+def assert_categorical_equal(
+    left, right, check_dtype=True, check_category_order=True, obj="Categorical"
+):
+    """
+    Test that Categoricals are equivalent.
+
+    Parameters
+    ----------
+    left : Categorical
+    right : Categorical
+    check_dtype : bool, default True
+        Check that integer dtype of the codes are the same
+    check_category_order : bool, default True
+        Whether the order of the categories should be compared, which
+        implies identical integer codes.  If False, only the resulting
+        values are compared.  The ordered attribute is
+        checked regardless.
+    obj : str, default 'Categorical'
+        Specify object name being compared, internally used to show appropriate
+        assertion message
+    """
+    _check_isinstance(left, right, Categorical)
+
+    if check_category_order:
+        assert_index_equal(left.categories, right.categories, obj=f"{obj}.categories")
+        assert_numpy_array_equal(
+            left.codes, right.codes, check_dtype=check_dtype, obj=f"{obj}.codes"
+        )
+    else:
+        try:
+            lc = left.categories.sort_values()
+            rc = right.categories.sort_values()
+        except TypeError:
+            # e.g. '<' not supported between instances of 'int' and 'str'
+            lc, rc = left.categories, right.categories
+        assert_index_equal(lc, rc, obj=f"{obj}.categories")
+        assert_index_equal(
+            left.categories.take(left.codes),
+            right.categories.take(right.codes),
+            obj=f"{obj}.values",
+        )
+
+    assert_attr_equal("ordered", left, right, obj=obj)
+
+
+def assert_interval_array_equal(left, right, exact="equiv", obj="IntervalArray"):
+    """
+    Test that two IntervalArrays are equivalent.
+
+    Parameters
+    ----------
+    left, right : IntervalArray
+        The IntervalArrays to compare.
+    exact : bool or {'equiv'}, default 'equiv'
+        Whether to check the Index class, dtype and inferred_type
+        are identical. If 'equiv', then RangeIndex can be substituted for
+        Int64Index as well.
+    obj : str, default 'IntervalArray'
+        Specify object name being compared, internally used to show appropriate
+        assertion message
+    """
+    _check_isinstance(left, right, IntervalArray)
+
+    kwargs = {}
+    if left._left.dtype.kind in ["m", "M"]:
+        # We have a DatetimeArray or TimedeltaArray
+        kwargs["check_freq"] = False
+
+    assert_equal(left._left, right._left, obj=f"{obj}.left", **kwargs)
+    assert_equal(left._right, right._right, obj=f"{obj}.left", **kwargs)
+
+    assert_attr_equal("closed", left, right, obj=obj)
+
+
+def assert_period_array_equal(left, right, obj="PeriodArray"):
+    _check_isinstance(left, right, PeriodArray)
+
+    assert_numpy_array_equal(left._data, right._data, obj=f"{obj}._data")
+    assert_attr_equal("freq", left, right, obj=obj)
+
+
+def assert_datetime_array_equal(left, right, obj="DatetimeArray", check_freq=True):
+    __tracebackhide__ = True
+    _check_isinstance(left, right, DatetimeArray)
+
+    assert_numpy_array_equal(left._data, right._data, obj=f"{obj}._data")
+    if check_freq:
+        assert_attr_equal("freq", left, right, obj=obj)
+    assert_attr_equal("tz", left, right, obj=obj)
+
+
+def assert_timedelta_array_equal(left, right, obj="TimedeltaArray", check_freq=True):
+    __tracebackhide__ = True
+    _check_isinstance(left, right, TimedeltaArray)
+    assert_numpy_array_equal(left._data, right._data, obj=f"{obj}._data")
+    if check_freq:
+        assert_attr_equal("freq", left, right, obj=obj)
+
+
+def raise_assert_detail(obj, message, left, right, diff=None, index_values=None):
+    __tracebackhide__ = True
+
+    msg = f"""{obj} are different
+
+{message}"""
+
+    if isinstance(index_values, np.ndarray):
+        msg += f"\n[index]: {pprint_thing(index_values)}"
+
+    if isinstance(left, np.ndarray):
+        left = pprint_thing(left)
+    elif is_categorical_dtype(left):
+        left = repr(left)
+
+    if isinstance(right, np.ndarray):
+        right = pprint_thing(right)
+    elif is_categorical_dtype(right):
+        right = repr(right)
+
+    msg += f"""
+[left]:  {left}
+[right]: {right}"""
+
+    if diff is not None:
+        msg += f"\n[diff]: {diff}"
+
+    raise AssertionError(msg)
+
+
+def assert_numpy_array_equal(
+    left,
+    right,
+    strict_nan=False,
+    check_dtype=True,
+    err_msg=None,
+    check_same=None,
+    obj="numpy array",
+    index_values=None,
+):
+    """
+    Check that 'np.ndarray' is equivalent.
+
+    Parameters
+    ----------
+    left, right : numpy.ndarray or iterable
+        The two arrays to be compared.
+    strict_nan : bool, default False
+        If True, consider NaN and None to be different.
+    check_dtype : bool, default True
+        Check dtype if both a and b are np.ndarray.
+    err_msg : str, default None
+        If provided, used as assertion message.
+    check_same : None|'copy'|'same', default None
+        Ensure left and right refer/do not refer to the same memory area.
+    obj : str, default 'numpy array'
+        Specify object name being compared, internally used to show appropriate
+        assertion message.
+    index_values : numpy.ndarray, default None
+        optional index (shared by both left and right), used in output.
+    """
+    __tracebackhide__ = True
+
+    # instance validation
+    # Show a detailed error message when classes are different
+    assert_class_equal(left, right, obj=obj)
+    # both classes must be an np.ndarray
+    _check_isinstance(left, right, np.ndarray)
+
+    def _get_base(obj):
+        return obj.base if getattr(obj, "base", None) is not None else obj
+
+    left_base = _get_base(left)
+    right_base = _get_base(right)
+
+    if check_same == "same":
+        if left_base is not right_base:
+            raise AssertionError(f"{repr(left_base)} is not {repr(right_base)}")
+    elif check_same == "copy":
+        if left_base is right_base:
+            raise AssertionError(f"{repr(left_base)} is {repr(right_base)}")
+
+    def _raise(left, right, err_msg):
+        if err_msg is None:
+            if left.shape != right.shape:
+                raise_assert_detail(
+                    obj, f"{obj} shapes are different", left.shape, right.shape
+                )
+
+            diff = 0
+            for left_arr, right_arr in zip(left, right):
+                # count up differences
+                if not array_equivalent(left_arr, right_arr, strict_nan=strict_nan):
+                    diff += 1
+
+            diff = diff * 100.0 / left.size
+            msg = f"{obj} values are different ({np.round(diff, 5)} %)"
+            raise_assert_detail(obj, msg, left, right, index_values=index_values)
+
+        raise AssertionError(err_msg)
+
+    # compare shape and values
+    if not array_equivalent(left, right, strict_nan=strict_nan):
+        _raise(left, right, err_msg)
+
+    if check_dtype:
+        if isinstance(left, np.ndarray) and isinstance(right, np.ndarray):
+            assert_attr_equal("dtype", left, right, obj=obj)
+
+
+def assert_extension_array_equal(
+    left,
+    right,
+    check_dtype=True,
+    index_values=None,
+    check_less_precise=no_default,
+    check_exact=False,
+    rtol: float = 1.0e-5,
+    atol: float = 1.0e-8,
+):
+    """
+    Check that left and right ExtensionArrays are equal.
+
+    Parameters
+    ----------
+    left, right : ExtensionArray
+        The two arrays to compare.
+    check_dtype : bool, default True
+        Whether to check if the ExtensionArray dtypes are identical.
+    index_values : numpy.ndarray, default None
+        Optional index (shared by both left and right), used in output.
+    check_less_precise : bool or int, default False
+        Specify comparison precision. Only used when check_exact is False.
+        5 digits (False) or 3 digits (True) after decimal points are compared.
+        If int, then specify the digits to compare.
+
+        .. deprecated:: 1.1.0
+           Use `rtol` and `atol` instead to define relative/absolute
+           tolerance, respectively. Similar to :func:`math.isclose`.
+    check_exact : bool, default False
+        Whether to compare number exactly.
+    rtol : float, default 1e-5
+        Relative tolerance. Only used when check_exact is False.
+
+        .. versionadded:: 1.1.0
+    atol : float, default 1e-8
+        Absolute tolerance. Only used when check_exact is False.
+
+        .. versionadded:: 1.1.0
+
+    Notes
+    -----
+    Missing values are checked separately from valid values.
+    A mask of missing values is computed for each and checked to match.
+    The remaining all-valid values are cast to object dtype and checked.
+
+    Examples
+    --------
+    >>> from pandas.testing import assert_extension_array_equal
+    >>> a = pd.Series([1, 2, 3, 4])
+    >>> b, c = a.array, a.array
+    >>> assert_extension_array_equal(b, c)
+    """
+    if check_less_precise is not no_default:
+        warnings.warn(
+            "The 'check_less_precise' keyword in testing.assert_*_equal "
+            "is deprecated and will be removed in a future version. "
+            "You can stop passing 'check_less_precise' to silence this warning.",
+            FutureWarning,
+            stacklevel=2,
+        )
+        rtol = atol = _get_tol_from_less_precise(check_less_precise)
+
+    assert isinstance(left, ExtensionArray), "left is not an ExtensionArray"
+    assert isinstance(right, ExtensionArray), "right is not an ExtensionArray"
+    if check_dtype:
+        assert_attr_equal("dtype", left, right, obj="ExtensionArray")
+
+    if (
+        isinstance(left, DatetimeLikeArrayMixin)
+        and isinstance(right, DatetimeLikeArrayMixin)
+        and type(right) == type(left)
+    ):
+        # Avoid slow object-dtype comparisons
+        # np.asarray for case where we have a np.MaskedArray
+        assert_numpy_array_equal(
+            np.asarray(left.asi8), np.asarray(right.asi8), index_values=index_values
+        )
+        return
+
+    left_na = np.asarray(left.isna())
+    right_na = np.asarray(right.isna())
+    assert_numpy_array_equal(
+        left_na, right_na, obj="ExtensionArray NA mask", index_values=index_values
+    )
+
+    left_valid = np.asarray(left[~left_na].astype(object))
+    right_valid = np.asarray(right[~right_na].astype(object))
+    if check_exact:
+        assert_numpy_array_equal(
+            left_valid, right_valid, obj="ExtensionArray", index_values=index_values
+        )
+    else:
+        _testing.assert_almost_equal(
+            left_valid,
+            right_valid,
+            check_dtype=check_dtype,
+            rtol=rtol,
+            atol=atol,
+            obj="ExtensionArray",
+            index_values=index_values,
+        )
+
+
+# This could be refactored to use the NDFrame.equals method
+def assert_series_equal(
+    left,
+    right,
+    check_dtype=True,
+    check_index_type="equiv",
+    check_series_type=True,
+    check_less_precise=no_default,
+    check_names=True,
+    check_exact=False,
+    check_datetimelike_compat=False,
+    check_categorical=True,
+    check_category_order=True,
+    check_freq=True,
+    check_flags=True,
+    rtol=1.0e-5,
+    atol=1.0e-8,
+    obj="Series",
+    *,
+    check_index=True,
+):
+    """
+    Check that left and right Series are equal.
+
+    Parameters
+    ----------
+    left : Series
+    right : Series
+    check_dtype : bool, default True
+        Whether to check the Series dtype is identical.
+    check_index_type : bool or {'equiv'}, default 'equiv'
+        Whether to check the Index class, dtype and inferred_type
+        are identical.
+    check_series_type : bool, default True
+         Whether to check the Series class is identical.
+    check_less_precise : bool or int, default False
+        Specify comparison precision. Only used when check_exact is False.
+        5 digits (False) or 3 digits (True) after decimal points are compared.
+        If int, then specify the digits to compare.
+
+        When comparing two numbers, if the first number has magnitude less
+        than 1e-5, we compare the two numbers directly and check whether
+        they are equivalent within the specified precision. Otherwise, we
+        compare the **ratio** of the second number to the first number and
+        check whether it is equivalent to 1 within the specified precision.
+
+        .. deprecated:: 1.1.0
+           Use `rtol` and `atol` instead to define relative/absolute
+           tolerance, respectively. Similar to :func:`math.isclose`.
+    check_names : bool, default True
+        Whether to check the Series and Index names attribute.
+    check_exact : bool, default False
+        Whether to compare number exactly.
+    check_datetimelike_compat : bool, default False
+        Compare datetime-like which is comparable ignoring dtype.
+    check_categorical : bool, default True
+        Whether to compare internal Categorical exactly.
+    check_category_order : bool, default True
+        Whether to compare category order of internal Categoricals.
+
+        .. versionadded:: 1.0.2
+    check_freq : bool, default True
+        Whether to check the `freq` attribute on a DatetimeIndex or TimedeltaIndex.
+    check_flags : bool, default True
+        Whether to check the `flags` attribute.
+
+        .. versionadded:: 1.2.0
+
+    rtol : float, default 1e-5
+        Relative tolerance. Only used when check_exact is False.
+
+        .. versionadded:: 1.1.0
+    atol : float, default 1e-8
+        Absolute tolerance. Only used when check_exact is False.
+
+        .. versionadded:: 1.1.0
+    obj : str, default 'Series'
+        Specify object name being compared, internally used to show appropriate
+        assertion message.
+    check_index : bool, default True
+        Whether to check index equivalence. If False, then compare only values.
+
+        .. versionadded:: 1.3.0
+
+    Examples
+    --------
+    >>> from pandas.testing import assert_series_equal
+    >>> a = pd.Series([1, 2, 3, 4])
+    >>> b = pd.Series([1, 2, 3, 4])
+    >>> assert_series_equal(a, b)
+    """
+    __tracebackhide__ = True
+
+    if check_less_precise is not no_default:
+        warnings.warn(
+            "The 'check_less_precise' keyword in testing.assert_*_equal "
+            "is deprecated and will be removed in a future version. "
+            "You can stop passing 'check_less_precise' to silence this warning.",
+            FutureWarning,
+            stacklevel=2,
+        )
+        rtol = atol = _get_tol_from_less_precise(check_less_precise)
+
+    # instance validation
+    _check_isinstance(left, right, Series)
+
+    if check_series_type:
+        assert_class_equal(left, right, obj=obj)
+
+    # length comparison
+    if len(left) != len(right):
+        msg1 = f"{len(left)}, {left.index}"
+        msg2 = f"{len(right)}, {right.index}"
+        raise_assert_detail(obj, "Series length are different", msg1, msg2)
+
+    if check_flags:
+        assert left.flags == right.flags, f"{repr(left.flags)} != {repr(right.flags)}"
+
+    if check_index:
+        # GH #38183
+        assert_index_equal(
+            left.index,
+            right.index,
+            exact=check_index_type,
+            check_names=check_names,
+            check_exact=check_exact,
+            check_categorical=check_categorical,
+            rtol=rtol,
+            atol=atol,
+            obj=f"{obj}.index",
+        )
+
+    if check_freq and isinstance(left.index, (DatetimeIndex, TimedeltaIndex)):
+        lidx = left.index
+        ridx = right.index
+        assert lidx.freq == ridx.freq, (lidx.freq, ridx.freq)
+
+    if check_dtype:
+        # We want to skip exact dtype checking when `check_categorical`
+        # is False. We'll still raise if only one is a `Categorical`,
+        # regardless of `check_categorical`
+        if (
+            is_categorical_dtype(left.dtype)
+            and is_categorical_dtype(right.dtype)
+            and not check_categorical
+        ):
+            pass
+        else:
+            assert_attr_equal("dtype", left, right, obj=f"Attributes of {obj}")
+
+    if check_exact and is_numeric_dtype(left.dtype) and is_numeric_dtype(right.dtype):
+        # Only check exact if dtype is numeric
+        assert_numpy_array_equal(
+            left._values,
+            right._values,
+            check_dtype=check_dtype,
+            obj=str(obj),
+            index_values=np.asarray(left.index),
+        )
+    elif check_datetimelike_compat and (
+        needs_i8_conversion(left.dtype) or needs_i8_conversion(right.dtype)
+    ):
+        # we want to check only if we have compat dtypes
+        # e.g. integer and M|m are NOT compat, but we can simply check
+        # the values in that case
+
+        # datetimelike may have different objects (e.g. datetime.datetime
+        # vs Timestamp) but will compare equal
+        if not Index(left._values).equals(Index(right._values)):
+            msg = (
+                f"[datetimelike_compat=True] {left._values} "
+                f"is not equal to {right._values}."
+            )
+            raise AssertionError(msg)
+    elif is_interval_dtype(left.dtype) and is_interval_dtype(right.dtype):
+        assert_interval_array_equal(left.array, right.array)
+    elif is_categorical_dtype(left.dtype) or is_categorical_dtype(right.dtype):
+        _testing.assert_almost_equal(
+            left._values,
+            right._values,
+            rtol=rtol,
+            atol=atol,
+            check_dtype=check_dtype,
+            obj=str(obj),
+            index_values=np.asarray(left.index),
+        )
+    elif is_extension_array_dtype(left.dtype) and is_extension_array_dtype(right.dtype):
+        assert_extension_array_equal(
+            left._values,
+            right._values,
+            check_dtype=check_dtype,
+            index_values=np.asarray(left.index),
+        )
+    elif is_extension_array_dtype_and_needs_i8_conversion(
+        left.dtype, right.dtype
+    ) or is_extension_array_dtype_and_needs_i8_conversion(right.dtype, left.dtype):
+        assert_extension_array_equal(
+            left._values,
+            right._values,
+            check_dtype=check_dtype,
+            index_values=np.asarray(left.index),
+        )
+    elif needs_i8_conversion(left.dtype) and needs_i8_conversion(right.dtype):
+        # DatetimeArray or TimedeltaArray
+        assert_extension_array_equal(
+            left._values,
+            right._values,
+            check_dtype=check_dtype,
+            index_values=np.asarray(left.index),
+        )
+    else:
+        _testing.assert_almost_equal(
+            left._values,
+            right._values,
+            rtol=rtol,
+            atol=atol,
+            check_dtype=check_dtype,
+            obj=str(obj),
+            index_values=np.asarray(left.index),
+        )
+
+    # metadata comparison
+    if check_names:
+        assert_attr_equal("name", left, right, obj=obj)
+
+    if check_categorical:
+        if is_categorical_dtype(left.dtype) or is_categorical_dtype(right.dtype):
+            assert_categorical_equal(
+                left._values,
+                right._values,
+                obj=f"{obj} category",
+                check_category_order=check_category_order,
+            )
+
+
+# This could be refactored to use the NDFrame.equals method
+def assert_frame_equal(
+    left,
+    right,
+    check_dtype=True,
+    check_index_type="equiv",
+    check_column_type="equiv",
+    check_frame_type=True,
+    check_less_precise=no_default,
+    check_names=True,
+    by_blocks=False,
+    check_exact=False,
+    check_datetimelike_compat=False,
+    check_categorical=True,
+    check_like=False,
+    check_freq=True,
+    check_flags=True,
+    rtol=1.0e-5,
+    atol=1.0e-8,
+    obj="DataFrame",
+):
+    """
+    Check that left and right DataFrame are equal.
+
+    This function is intended to compare two DataFrames and output any
+    differences. Is is mostly intended for use in unit tests.
+    Additional parameters allow varying the strictness of the
+    equality checks performed.
+
+    Parameters
+    ----------
+    left : DataFrame
+        First DataFrame to compare.
+    right : DataFrame
+        Second DataFrame to compare.
+    check_dtype : bool, default True
+        Whether to check the DataFrame dtype is identical.
+    check_index_type : bool or {'equiv'}, default 'equiv'
+        Whether to check the Index class, dtype and inferred_type
+        are identical.
+    check_column_type : bool or {'equiv'}, default 'equiv'
+        Whether to check the columns class, dtype and inferred_type
+        are identical. Is passed as the ``exact`` argument of
+        :func:`assert_index_equal`.
+    check_frame_type : bool, default True
+        Whether to check the DataFrame class is identical.
+    check_less_precise : bool or int, default False
+        Specify comparison precision. Only used when check_exact is False.
+        5 digits (False) or 3 digits (True) after decimal points are compared.
+        If int, then specify the digits to compare.
+
+        When comparing two numbers, if the first number has magnitude less
+        than 1e-5, we compare the two numbers directly and check whether
+        they are equivalent within the specified precision. Otherwise, we
+        compare the **ratio** of the second number to the first number and
+        check whether it is equivalent to 1 within the specified precision.
+
+        .. deprecated:: 1.1.0
+           Use `rtol` and `atol` instead to define relative/absolute
+           tolerance, respectively. Similar to :func:`math.isclose`.
+    check_names : bool, default True
+        Whether to check that the `names` attribute for both the `index`
+        and `column` attributes of the DataFrame is identical.
+    by_blocks : bool, default False
+        Specify how to compare internal data. If False, compare by columns.
+        If True, compare by blocks.
+    check_exact : bool, default False
+        Whether to compare number exactly.
+    check_datetimelike_compat : bool, default False
+        Compare datetime-like which is comparable ignoring dtype.
+    check_categorical : bool, default True
+        Whether to compare internal Categorical exactly.
+    check_like : bool, default False
+        If True, ignore the order of index & columns.
+        Note: index labels must match their respective rows
+        (same as in columns) - same labels must be with the same data.
+    check_freq : bool, default True
+        Whether to check the `freq` attribute on a DatetimeIndex or TimedeltaIndex.
+    check_flags : bool, default True
+        Whether to check the `flags` attribute.
+    rtol : float, default 1e-5
+        Relative tolerance. Only used when check_exact is False.
+
+        .. versionadded:: 1.1.0
+    atol : float, default 1e-8
+        Absolute tolerance. Only used when check_exact is False.
+
+        .. versionadded:: 1.1.0
+    obj : str, default 'DataFrame'
+        Specify object name being compared, internally used to show appropriate
+        assertion message.
+
+    See Also
+    --------
+    assert_series_equal : Equivalent method for asserting Series equality.
+    DataFrame.equals : Check DataFrame equality.
+
+    Examples
+    --------
+    This example shows comparing two DataFrames that are equal
+    but with columns of differing dtypes.
+
+    >>> from pandas._testing import assert_frame_equal
+    >>> df1 = pd.DataFrame({'a': [1, 2], 'b': [3, 4]})
+    >>> df2 = pd.DataFrame({'a': [1, 2], 'b': [3.0, 4.0]})
+
+    df1 equals itself.
+
+    >>> assert_frame_equal(df1, df1)
+
+    df1 differs from df2 as column 'b' is of a different type.
+
+    >>> assert_frame_equal(df1, df2)
+    Traceback (most recent call last):
+    ...
+    AssertionError: Attributes of DataFrame.iloc[:, 1] (column name="b") are different
+
+    Attribute "dtype" are different
+    [left]:  int64
+    [right]: float64
+
+    Ignore differing dtypes in columns with check_dtype.
+
+    >>> assert_frame_equal(df1, df2, check_dtype=False)
+    """
+    __tracebackhide__ = True
+
+    if check_less_precise is not no_default:
+        warnings.warn(
+            "The 'check_less_precise' keyword in testing.assert_*_equal "
+            "is deprecated and will be removed in a future version. "
+            "You can stop passing 'check_less_precise' to silence this warning.",
+            FutureWarning,
+            stacklevel=2,
+        )
+        rtol = atol = _get_tol_from_less_precise(check_less_precise)
+
+    # instance validation
+    _check_isinstance(left, right, DataFrame)
+
+    if check_frame_type:
+        assert isinstance(left, type(right))
+        # assert_class_equal(left, right, obj=obj)
+
+    # shape comparison
+    if left.shape != right.shape:
+        raise_assert_detail(
+            obj, f"{obj} shape mismatch", f"{repr(left.shape)}", f"{repr(right.shape)}"
+        )
+
+    if check_flags:
+        assert left.flags == right.flags, f"{repr(left.flags)} != {repr(right.flags)}"
+
+    # index comparison
+    assert_index_equal(
+        left.index,
+        right.index,
+        exact=check_index_type,
+        check_names=check_names,
+        check_exact=check_exact,
+        check_categorical=check_categorical,
+        check_order=not check_like,
+        rtol=rtol,
+        atol=atol,
+        obj=f"{obj}.index",
+    )
+
+    # column comparison
+    assert_index_equal(
+        left.columns,
+        right.columns,
+        exact=check_column_type,
+        check_names=check_names,
+        check_exact=check_exact,
+        check_categorical=check_categorical,
+        check_order=not check_like,
+        rtol=rtol,
+        atol=atol,
+        obj=f"{obj}.columns",
+    )
+
+    if check_like:
+        left, right = left.reindex_like(right), right
+
+    # compare by blocks
+    if by_blocks:
+        rblocks = right._to_dict_of_blocks()
+        lblocks = left._to_dict_of_blocks()
+        for dtype in list(set(list(lblocks.keys()) + list(rblocks.keys()))):
+            assert dtype in lblocks
+            assert dtype in rblocks
+            assert_frame_equal(
+                lblocks[dtype], rblocks[dtype], check_dtype=check_dtype, obj=obj
+            )
+
+    # compare by columns
+    else:
+        for i, col in enumerate(left.columns):
+            assert col in right
+            lcol = left.iloc[:, i]
+            rcol = right.iloc[:, i]
+            # GH #38183
+            # use check_index=False, because we do not want to run
+            # assert_index_equal for each column,
+            # as we already checked it for the whole dataframe before.
+            assert_series_equal(
+                lcol,
+                rcol,
+                check_dtype=check_dtype,
+                check_index_type=check_index_type,
+                check_exact=check_exact,
+                check_names=check_names,
+                check_datetimelike_compat=check_datetimelike_compat,
+                check_categorical=check_categorical,
+                check_freq=check_freq,
+                obj=f'{obj}.iloc[:, {i}] (column name="{col}")',
+                rtol=rtol,
+                atol=atol,
+                check_index=False,
+            )
+
+
+def assert_equal(left, right, **kwargs):
+    """
+    Wrapper for tm.assert_*_equal to dispatch to the appropriate test function.
+
+    Parameters
+    ----------
+    left, right : Index, Series, DataFrame, ExtensionArray, or np.ndarray
+        The two items to be compared.
+    **kwargs
+        All keyword arguments are passed through to the underlying assert method.
+    """
+    __tracebackhide__ = True
+
+    if isinstance(left, Index):
+        assert_index_equal(left, right, **kwargs)
+        if isinstance(left, (DatetimeIndex, TimedeltaIndex)):
+            assert left.freq == right.freq, (left.freq, right.freq)
+    elif isinstance(left, Series):
+        assert_series_equal(left, right, **kwargs)
+    elif isinstance(left, DataFrame):
+        assert_frame_equal(left, right, **kwargs)
+    elif isinstance(left, IntervalArray):
+        assert_interval_array_equal(left, right, **kwargs)
+    elif isinstance(left, PeriodArray):
+        assert_period_array_equal(left, right, **kwargs)
+    elif isinstance(left, DatetimeArray):
+        assert_datetime_array_equal(left, right, **kwargs)
+    elif isinstance(left, TimedeltaArray):
+        assert_timedelta_array_equal(left, right, **kwargs)
+    elif isinstance(left, ExtensionArray):
+        assert_extension_array_equal(left, right, **kwargs)
+    elif isinstance(left, np.ndarray):
+        assert_numpy_array_equal(left, right, **kwargs)
+    elif isinstance(left, str):
+        assert kwargs == {}
+        assert left == right
+    else:
+        raise NotImplementedError(type(left))
+
+
+def assert_sp_array_equal(left, right):
+    """
+    Check that the left and right SparseArray are equal.
+
+    Parameters
+    ----------
+    left : SparseArray
+    right : SparseArray
+    """
+    _check_isinstance(left, right, pd.arrays.SparseArray)
+
+    assert_numpy_array_equal(left.sp_values, right.sp_values)
+
+    # SparseIndex comparison
+    assert isinstance(left.sp_index, pd._libs.sparse.SparseIndex)
+    assert isinstance(right.sp_index, pd._libs.sparse.SparseIndex)
+
+    left_index = left.sp_index
+    right_index = right.sp_index
+
+    if not left_index.equals(right_index):
+        raise_assert_detail(
+            "SparseArray.index", "index are not equal", left_index, right_index
+        )
+    else:
+        # Just ensure a
+        pass
+
+    assert_attr_equal("fill_value", left, right)
+    assert_attr_equal("dtype", left, right)
+    assert_numpy_array_equal(left.to_dense(), right.to_dense())
+
+
+def assert_contains_all(iterable, dic):
+    for k in iterable:
+        assert k in dic, f"Did not contain item: {repr(k)}"
+
+
+def assert_copy(iter1, iter2, **eql_kwargs):
+    """
+    iter1, iter2: iterables that produce elements
+    comparable with assert_almost_equal
+
+    Checks that the elements are equal, but not
+    the same object. (Does not check that items
+    in sequences are also not the same object)
+    """
+    for elem1, elem2 in zip(iter1, iter2):
+        assert_almost_equal(elem1, elem2, **eql_kwargs)
+        msg = (
+            f"Expected object {repr(type(elem1))} and object {repr(type(elem2))} to be "
+            "different objects, but they were the same object."
+        )
+        assert elem1 is not elem2, msg
+
+
+def is_extension_array_dtype_and_needs_i8_conversion(left_dtype, right_dtype) -> bool:
+    """
+    Checks that we have the combination of an ExtensionArraydtype and
+    a dtype that should be converted to int64
+
+    Returns
+    -------
+    bool
+
+    Related to issue #37609
+    """
+    return is_extension_array_dtype(left_dtype) and needs_i8_conversion(right_dtype)
diff --git a/pandas/tests/series/apply/test_series_apply.py b/pandas/tests/series/apply/test_series_apply.py
index 93431a5c75091..02121772bf1c7 100644
--- a/pandas/tests/series/apply/test_series_apply.py
+++ b/pandas/tests/series/apply/test_series_apply.py
@@ -4,6 +4,8 @@
 import numpy as np
 import pytest
 
+from pandas.core.dtypes.common import is_number
+
 import pandas as pd
 from pandas import DataFrame, Index, MultiIndex, Series, isna, timedelta_range
 import pandas._testing as tm
@@ -400,7 +402,7 @@ def test_agg_cython_table(self, series, func, expected):
         # test reducing functions in
         # pandas.core.base.SelectionMixin._cython_table
         result = series.agg(func)
-        if tm.is_number(expected):
+        if is_number(expected):
             assert np.isclose(result, expected, equal_nan=True)
         else:
             assert result == expected

From 71dc8b032528c99ba23712323569614d55d06240 Mon Sep 17 00:00:00 2001
From: Brock <jbrockmendel@gmail.com>
Date: Thu, 24 Dec 2020 19:39:02 -0800
Subject: [PATCH 2/2] implement _testing/contexts.py

---
 pandas/_testing/__init__.py                   | 262 +-----------------
 pandas/_testing/contexts.py                   | 249 +++++++++++++++++
 pandas/tests/internals/test_internals.py      |  14 +-
 .../series/methods/test_combine_first.py      |   2 +-
 pandas/tests/series/test_repr.py              |   6 +-
 5 files changed, 273 insertions(+), 260 deletions(-)
 create mode 100644 pandas/_testing/contexts.py

diff --git a/pandas/_testing/__init__.py b/pandas/_testing/__init__.py
index 0891d733e0d0e..3b3b1e6c14a8f 100644
--- a/pandas/_testing/__init__.py
+++ b/pandas/_testing/__init__.py
@@ -7,9 +7,7 @@
 import operator
 import os
 import re
-from shutil import rmtree
 import string
-import tempfile
 from typing import (
     Any,
     Callable,
@@ -57,11 +55,7 @@
     Series,
     bdate_range,
 )
-from pandas.core.arrays import DatetimeArray, PeriodArray, TimedeltaArray, period_array
-
-from pandas.io.common import urlopen
-
-from .asserters import (  # noqa:F401
+from pandas._testing.asserters import (  # noqa:F401
     assert_almost_equal,
     assert_attr_equal,
     assert_categorical_equal,
@@ -84,6 +78,18 @@
     assert_timedelta_array_equal,
     raise_assert_detail,
 )
+from pandas._testing.contexts import (  # noqa:F401
+    decompress_file,
+    ensure_clean,
+    ensure_clean_dir,
+    ensure_safe_environment_variables,
+    set_timezone,
+    use_numexpr,
+    with_csv_dialect,
+)
+from pandas.core.arrays import DatetimeArray, PeriodArray, TimedeltaArray, period_array
+
+from pandas.io.common import urlopen
 
 lzma = import_lzma()
 
@@ -247,55 +253,6 @@ def round_trip_localpath(writer, reader, path: Optional[str] = None):
     return obj
 
 
-@contextmanager
-def decompress_file(path, compression):
-    """
-    Open a compressed file and return a file object.
-
-    Parameters
-    ----------
-    path : str
-        The path where the file is read from.
-
-    compression : {'gzip', 'bz2', 'zip', 'xz', None}
-        Name of the decompression to use
-
-    Returns
-    -------
-    file object
-    """
-    if compression is None:
-        f = open(path, "rb")
-    elif compression == "gzip":
-        # pandas\_testing.py:243: error: Incompatible types in assignment
-        # (expression has type "IO[Any]", variable has type "BinaryIO")
-        f = gzip.open(path, "rb")  # type: ignore[assignment]
-    elif compression == "bz2":
-        # pandas\_testing.py:245: error: Incompatible types in assignment
-        # (expression has type "BZ2File", variable has type "BinaryIO")
-        f = bz2.BZ2File(path, "rb")  # type: ignore[assignment]
-    elif compression == "xz":
-        f = get_lzma_file(lzma)(path, "rb")
-    elif compression == "zip":
-        zip_file = zipfile.ZipFile(path)
-        zip_names = zip_file.namelist()
-        if len(zip_names) == 1:
-            # pandas\_testing.py:252: error: Incompatible types in assignment
-            # (expression has type "IO[bytes]", variable has type "BinaryIO")
-            f = zip_file.open(zip_names.pop())  # type: ignore[assignment]
-        else:
-            raise ValueError(f"ZIP file {path} error. Only one file per ZIP.")
-    else:
-        raise ValueError(f"Unrecognized compression type: {compression}")
-
-    try:
-        yield f
-    finally:
-        f.close()
-        if compression == "zip":
-            zip_file.close()
-
-
 def write_to_compressed(compression, path, data, dest="test"):
     """
     Write data to a compressed file.
@@ -393,108 +350,6 @@ def close(fignum=None):
         _close(fignum)
 
 
-# -----------------------------------------------------------------------------
-# contextmanager to ensure the file cleanup
-
-
-@contextmanager
-def ensure_clean(filename=None, return_filelike=False, **kwargs):
-    """
-    Gets a temporary path and agrees to remove on close.
-
-    Parameters
-    ----------
-    filename : str (optional)
-        if None, creates a temporary file which is then removed when out of
-        scope. if passed, creates temporary file with filename as ending.
-    return_filelike : bool (default False)
-        if True, returns a file-like which is *always* cleaned. Necessary for
-        savefig and other functions which want to append extensions.
-    **kwargs
-        Additional keywords passed in for creating a temporary file.
-        :meth:`tempFile.TemporaryFile` is used when `return_filelike` is ``True``.
-        :meth:`tempfile.mkstemp` is used when `return_filelike` is ``False``.
-        Note that the `filename` parameter will be passed in as the `suffix`
-        argument to either function.
-
-    See Also
-    --------
-    tempfile.TemporaryFile
-    tempfile.mkstemp
-    """
-    filename = filename or ""
-    fd = None
-
-    kwargs["suffix"] = filename
-
-    if return_filelike:
-        f = tempfile.TemporaryFile(**kwargs)
-
-        try:
-            yield f
-        finally:
-            f.close()
-    else:
-        # Don't generate tempfile if using a path with directory specified.
-        if len(os.path.dirname(filename)):
-            raise ValueError("Can't pass a qualified name to ensure_clean()")
-
-        try:
-            fd, filename = tempfile.mkstemp(**kwargs)
-        except UnicodeEncodeError:
-            import pytest
-
-            pytest.skip("no unicode file names on this system")
-
-        try:
-            yield filename
-        finally:
-            try:
-                os.close(fd)
-            except OSError:
-                print(f"Couldn't close file descriptor: {fd} (file: {filename})")
-            try:
-                if os.path.exists(filename):
-                    os.remove(filename)
-            except OSError as e:
-                print(f"Exception on removing file: {e}")
-
-
-@contextmanager
-def ensure_clean_dir():
-    """
-    Get a temporary directory path and agrees to remove on close.
-
-    Yields
-    ------
-    Temporary directory path
-    """
-    directory_name = tempfile.mkdtemp(suffix="")
-    try:
-        yield directory_name
-    finally:
-        try:
-            rmtree(directory_name)
-        except OSError:
-            pass
-
-
-@contextmanager
-def ensure_safe_environment_variables():
-    """
-    Get a context manager to safely set environment variables
-
-    All changes will be undone on close, hence environment variables set
-    within this contextmanager will neither persist nor change global state.
-    """
-    saved_environ = dict(os.environ)
-    try:
-        yield
-    finally:
-        os.environ.clear()
-        os.environ.update(saved_environ)
-
-
 # -----------------------------------------------------------------------------
 # Comparators
 
@@ -1522,54 +1377,6 @@ def __exit__(self, exc_type, exc_value, traceback):
         np.random.set_state(self.start_state)
 
 
-@contextmanager
-def with_csv_dialect(name, **kwargs):
-    """
-    Context manager to temporarily register a CSV dialect for parsing CSV.
-
-    Parameters
-    ----------
-    name : str
-        The name of the dialect.
-    kwargs : mapping
-        The parameters for the dialect.
-
-    Raises
-    ------
-    ValueError : the name of the dialect conflicts with a builtin one.
-
-    See Also
-    --------
-    csv : Python's CSV library.
-    """
-    import csv
-
-    _BUILTIN_DIALECTS = {"excel", "excel-tab", "unix"}
-
-    if name in _BUILTIN_DIALECTS:
-        raise ValueError("Cannot override builtin dialect.")
-
-    csv.register_dialect(name, **kwargs)
-    yield
-    csv.unregister_dialect(name)
-
-
-@contextmanager
-def use_numexpr(use, min_elements=None):
-    from pandas.core.computation import expressions as expr
-
-    if min_elements is None:
-        min_elements = expr._MIN_ELEMENTS
-
-    olduse = expr.USE_NUMEXPR
-    oldmin = expr._MIN_ELEMENTS
-    expr.set_use_numexpr(use)
-    expr._MIN_ELEMENTS = min_elements
-    yield
-    expr._MIN_ELEMENTS = oldmin
-    expr.set_use_numexpr(olduse)
-
-
 def test_parallel(num_threads=2, kwargs_list=None):
     """
     Decorator to run the same function multiple times in parallel.
@@ -1649,49 +1456,6 @@ def _constructor(self):
         return SubclassedCategorical
 
 
-@contextmanager
-def set_timezone(tz: str):
-    """
-    Context manager for temporarily setting a timezone.
-
-    Parameters
-    ----------
-    tz : str
-        A string representing a valid timezone.
-
-    Examples
-    --------
-    >>> from datetime import datetime
-    >>> from dateutil.tz import tzlocal
-    >>> tzlocal().tzname(datetime.now())
-    'IST'
-
-    >>> with set_timezone('US/Eastern'):
-    ...     tzlocal().tzname(datetime.now())
-    ...
-    'EDT'
-    """
-    import os
-    import time
-
-    def setTZ(tz):
-        if tz is None:
-            try:
-                del os.environ["TZ"]
-            except KeyError:
-                pass
-        else:
-            os.environ["TZ"] = tz
-            time.tzset()
-
-    orig_tz = os.environ.get("TZ")
-    setTZ(tz)
-    try:
-        yield
-    finally:
-        setTZ(orig_tz)
-
-
 def _make_skipna_wrapper(alternative, skipna_alternative=None):
     """
     Create a function for calling on an array.
diff --git a/pandas/_testing/contexts.py b/pandas/_testing/contexts.py
new file mode 100644
index 0000000000000..ac03cc77a321f
--- /dev/null
+++ b/pandas/_testing/contexts.py
@@ -0,0 +1,249 @@
+import bz2
+from contextlib import contextmanager
+import gzip
+import os
+from shutil import rmtree
+import tempfile
+import zipfile
+
+from pandas.compat import get_lzma_file, import_lzma
+
+lzma = import_lzma()
+
+
+@contextmanager
+def decompress_file(path, compression):
+    """
+    Open a compressed file and return a file object.
+
+    Parameters
+    ----------
+    path : str
+        The path where the file is read from.
+
+    compression : {'gzip', 'bz2', 'zip', 'xz', None}
+        Name of the decompression to use
+
+    Returns
+    -------
+    file object
+    """
+    if compression is None:
+        f = open(path, "rb")
+    elif compression == "gzip":
+        # pandas\_testing.py:243: error: Incompatible types in assignment
+        # (expression has type "IO[Any]", variable has type "BinaryIO")
+        f = gzip.open(path, "rb")  # type: ignore[assignment]
+    elif compression == "bz2":
+        # pandas\_testing.py:245: error: Incompatible types in assignment
+        # (expression has type "BZ2File", variable has type "BinaryIO")
+        f = bz2.BZ2File(path, "rb")  # type: ignore[assignment]
+    elif compression == "xz":
+        f = get_lzma_file(lzma)(path, "rb")
+    elif compression == "zip":
+        zip_file = zipfile.ZipFile(path)
+        zip_names = zip_file.namelist()
+        if len(zip_names) == 1:
+            # pandas\_testing.py:252: error: Incompatible types in assignment
+            # (expression has type "IO[bytes]", variable has type "BinaryIO")
+            f = zip_file.open(zip_names.pop())  # type: ignore[assignment]
+        else:
+            raise ValueError(f"ZIP file {path} error. Only one file per ZIP.")
+    else:
+        raise ValueError(f"Unrecognized compression type: {compression}")
+
+    try:
+        yield f
+    finally:
+        f.close()
+        if compression == "zip":
+            zip_file.close()
+
+
+@contextmanager
+def set_timezone(tz: str):
+    """
+    Context manager for temporarily setting a timezone.
+
+    Parameters
+    ----------
+    tz : str
+        A string representing a valid timezone.
+
+    Examples
+    --------
+    >>> from datetime import datetime
+    >>> from dateutil.tz import tzlocal
+    >>> tzlocal().tzname(datetime.now())
+    'IST'
+
+    >>> with set_timezone('US/Eastern'):
+    ...     tzlocal().tzname(datetime.now())
+    ...
+    'EDT'
+    """
+    import os
+    import time
+
+    def setTZ(tz):
+        if tz is None:
+            try:
+                del os.environ["TZ"]
+            except KeyError:
+                pass
+        else:
+            os.environ["TZ"] = tz
+            time.tzset()
+
+    orig_tz = os.environ.get("TZ")
+    setTZ(tz)
+    try:
+        yield
+    finally:
+        setTZ(orig_tz)
+
+
+@contextmanager
+def ensure_clean(filename=None, return_filelike=False, **kwargs):
+    """
+    Gets a temporary path and agrees to remove on close.
+
+    Parameters
+    ----------
+    filename : str (optional)
+        if None, creates a temporary file which is then removed when out of
+        scope. if passed, creates temporary file with filename as ending.
+    return_filelike : bool (default False)
+        if True, returns a file-like which is *always* cleaned. Necessary for
+        savefig and other functions which want to append extensions.
+    **kwargs
+        Additional keywords passed in for creating a temporary file.
+        :meth:`tempFile.TemporaryFile` is used when `return_filelike` is ``True``.
+        :meth:`tempfile.mkstemp` is used when `return_filelike` is ``False``.
+        Note that the `filename` parameter will be passed in as the `suffix`
+        argument to either function.
+
+    See Also
+    --------
+    tempfile.TemporaryFile
+    tempfile.mkstemp
+    """
+    filename = filename or ""
+    fd = None
+
+    kwargs["suffix"] = filename
+
+    if return_filelike:
+        f = tempfile.TemporaryFile(**kwargs)
+
+        try:
+            yield f
+        finally:
+            f.close()
+    else:
+        # Don't generate tempfile if using a path with directory specified.
+        if len(os.path.dirname(filename)):
+            raise ValueError("Can't pass a qualified name to ensure_clean()")
+
+        try:
+            fd, filename = tempfile.mkstemp(**kwargs)
+        except UnicodeEncodeError:
+            import pytest
+
+            pytest.skip("no unicode file names on this system")
+
+        try:
+            yield filename
+        finally:
+            try:
+                os.close(fd)
+            except OSError:
+                print(f"Couldn't close file descriptor: {fd} (file: {filename})")
+            try:
+                if os.path.exists(filename):
+                    os.remove(filename)
+            except OSError as e:
+                print(f"Exception on removing file: {e}")
+
+
+@contextmanager
+def ensure_clean_dir():
+    """
+    Get a temporary directory path and agrees to remove on close.
+
+    Yields
+    ------
+    Temporary directory path
+    """
+    directory_name = tempfile.mkdtemp(suffix="")
+    try:
+        yield directory_name
+    finally:
+        try:
+            rmtree(directory_name)
+        except OSError:
+            pass
+
+
+@contextmanager
+def ensure_safe_environment_variables():
+    """
+    Get a context manager to safely set environment variables
+
+    All changes will be undone on close, hence environment variables set
+    within this contextmanager will neither persist nor change global state.
+    """
+    saved_environ = dict(os.environ)
+    try:
+        yield
+    finally:
+        os.environ.clear()
+        os.environ.update(saved_environ)
+
+
+@contextmanager
+def with_csv_dialect(name, **kwargs):
+    """
+    Context manager to temporarily register a CSV dialect for parsing CSV.
+
+    Parameters
+    ----------
+    name : str
+        The name of the dialect.
+    kwargs : mapping
+        The parameters for the dialect.
+
+    Raises
+    ------
+    ValueError : the name of the dialect conflicts with a builtin one.
+
+    See Also
+    --------
+    csv : Python's CSV library.
+    """
+    import csv
+
+    _BUILTIN_DIALECTS = {"excel", "excel-tab", "unix"}
+
+    if name in _BUILTIN_DIALECTS:
+        raise ValueError("Cannot override builtin dialect.")
+
+    csv.register_dialect(name, **kwargs)
+    yield
+    csv.unregister_dialect(name)
+
+
+@contextmanager
+def use_numexpr(use, min_elements=None):
+    from pandas.core.computation import expressions as expr
+
+    if min_elements is None:
+        min_elements = expr._MIN_ELEMENTS
+
+    olduse = expr.USE_NUMEXPR
+    oldmin = expr._MIN_ELEMENTS
+    expr.set_use_numexpr(use)
+    expr._MIN_ELEMENTS = min_elements
+    yield
+    expr._MIN_ELEMENTS = oldmin
+    expr.set_use_numexpr(olduse)
diff --git a/pandas/tests/internals/test_internals.py b/pandas/tests/internals/test_internals.py
index 9b032da1f20ea..3c949ad694abd 100644
--- a/pandas/tests/internals/test_internals.py
+++ b/pandas/tests/internals/test_internals.py
@@ -377,11 +377,11 @@ def test_set_change_dtype(self, mgr):
         idx = mgr2.items.get_loc("baz")
         assert mgr2.iget(idx).dtype == np.object_
 
-        mgr2.insert(len(mgr2.items), "quux", tm.randn(N).astype(int))
+        mgr2.insert(len(mgr2.items), "quux", np.random.randn(N).astype(int))
         idx = mgr2.items.get_loc("quux")
         assert mgr2.iget(idx).dtype == np.int_
 
-        mgr2.iset(mgr2.items.get_loc("quux"), tm.randn(N))
+        mgr2.iset(mgr2.items.get_loc("quux"), np.random.randn(N))
         assert mgr2.iget(idx).dtype == np.float_
 
     def test_copy(self, mgr):
@@ -615,11 +615,11 @@ def test_interleave_dtype(self, mgr_string, dtype):
         assert mgr.as_array().dtype == "object"
 
     def test_consolidate_ordering_issues(self, mgr):
-        mgr.iset(mgr.items.get_loc("f"), tm.randn(N))
-        mgr.iset(mgr.items.get_loc("d"), tm.randn(N))
-        mgr.iset(mgr.items.get_loc("b"), tm.randn(N))
-        mgr.iset(mgr.items.get_loc("g"), tm.randn(N))
-        mgr.iset(mgr.items.get_loc("h"), tm.randn(N))
+        mgr.iset(mgr.items.get_loc("f"), np.random.randn(N))
+        mgr.iset(mgr.items.get_loc("d"), np.random.randn(N))
+        mgr.iset(mgr.items.get_loc("b"), np.random.randn(N))
+        mgr.iset(mgr.items.get_loc("g"), np.random.randn(N))
+        mgr.iset(mgr.items.get_loc("h"), np.random.randn(N))
 
         # we have datetime/tz blocks in mgr
         cons = mgr.consolidate()
diff --git a/pandas/tests/series/methods/test_combine_first.py b/pandas/tests/series/methods/test_combine_first.py
index 2a02406f50750..94aa6b8d84cad 100644
--- a/pandas/tests/series/methods/test_combine_first.py
+++ b/pandas/tests/series/methods/test_combine_first.py
@@ -46,7 +46,7 @@ def test_combine_first(self):
 
         # mixed types
         index = tm.makeStringIndex(20)
-        floats = Series(tm.randn(20), index=index)
+        floats = Series(np.random.randn(20), index=index)
         strings = Series(tm.makeStringIndex(10), index=index[::2])
 
         combined = strings.combine_first(floats)
diff --git a/pandas/tests/series/test_repr.py b/pandas/tests/series/test_repr.py
index 75e7f8a17eda3..30907d3b4ac46 100644
--- a/pandas/tests/series/test_repr.py
+++ b/pandas/tests/series/test_repr.py
@@ -71,8 +71,8 @@ def test_repr(self, datetime_series, string_series, object_series):
         str(string_series.astype(int))
         str(object_series)
 
-        str(Series(tm.randn(1000), index=np.arange(1000)))
-        str(Series(tm.randn(1000), index=np.arange(1000, 0, step=-1)))
+        str(Series(np.random.randn(1000), index=np.arange(1000)))
+        str(Series(np.random.randn(1000), index=np.arange(1000, 0, step=-1)))
 
         # empty
         str(Series(dtype=object))
@@ -104,7 +104,7 @@ def test_repr(self, datetime_series, string_series, object_series):
             repr(string_series)
 
         biggie = Series(
-            tm.randn(1000), index=np.arange(1000), name=("foo", "bar", "baz")
+            np.random.randn(1000), index=np.arange(1000), name=("foo", "bar", "baz")
         )
         repr(biggie)