Add files using upload-large-folder tool

mantis_evalkit/lib/python3.10/site-packages/pandas/tests/construction/test_extract_array.py

@@ -0,0 +1,18 @@
+from pandas import Index
+import pandas._testing as tm
+from pandas.core.construction import extract_array
+
+
+def test_extract_array_rangeindex():
+    ri = Index(range(5))
+
+    expected = ri._values
+    res = extract_array(ri, extract_numpy=True, extract_range=True)
+    tm.assert_numpy_array_equal(res, expected)
+    res = extract_array(ri, extract_numpy=False, extract_range=True)
+    tm.assert_numpy_array_equal(res, expected)
+
+    res = extract_array(ri, extract_numpy=True, extract_range=False)
+    tm.assert_index_equal(res, ri)
+    res = extract_array(ri, extract_numpy=False, extract_range=False)
+    tm.assert_index_equal(res, ri)

mantis_evalkit/lib/python3.10/site-packages/pandas/tests/dtypes/cast/test_can_hold_element.py

@@ -0,0 +1,79 @@
+import numpy as np
+
+from pandas.core.dtypes.cast import can_hold_element
+
+
+def test_can_hold_element_range(any_int_numpy_dtype):
+    # GH#44261
+    dtype = np.dtype(any_int_numpy_dtype)
+    arr = np.array([], dtype=dtype)
+
+    rng = range(2, 127)
+    assert can_hold_element(arr, rng)
+
+    # negatives -> can't be held by uint dtypes
+    rng = range(-2, 127)
+    if dtype.kind == "i":
+        assert can_hold_element(arr, rng)
+    else:
+        assert not can_hold_element(arr, rng)
+
+    rng = range(2, 255)
+    if dtype == "int8":
+        assert not can_hold_element(arr, rng)
+    else:
+        assert can_hold_element(arr, rng)
+
+    rng = range(-255, 65537)
+    if dtype.kind == "u":
+        assert not can_hold_element(arr, rng)
+    elif dtype.itemsize < 4:
+        assert not can_hold_element(arr, rng)
+    else:
+        assert can_hold_element(arr, rng)
+
+    # empty
+    rng = range(-(10**10), -(10**10))
+    assert len(rng) == 0
+    # assert can_hold_element(arr, rng)
+
+    rng = range(10**10, 10**10)
+    assert len(rng) == 0
+    assert can_hold_element(arr, rng)
+
+
+def test_can_hold_element_int_values_float_ndarray():
+    arr = np.array([], dtype=np.int64)
+
+    element = np.array([1.0, 2.0])
+    assert can_hold_element(arr, element)
+
+    assert not can_hold_element(arr, element + 0.5)
+
+    # integer but not losslessly castable to int64
+    element = np.array([3, 2**65], dtype=np.float64)
+    assert not can_hold_element(arr, element)
+
+
+def test_can_hold_element_int8_int():
+    arr = np.array([], dtype=np.int8)
+
+    element = 2
+    assert can_hold_element(arr, element)
+    assert can_hold_element(arr, np.int8(element))
+    assert can_hold_element(arr, np.uint8(element))
+    assert can_hold_element(arr, np.int16(element))
+    assert can_hold_element(arr, np.uint16(element))
+    assert can_hold_element(arr, np.int32(element))
+    assert can_hold_element(arr, np.uint32(element))
+    assert can_hold_element(arr, np.int64(element))
+    assert can_hold_element(arr, np.uint64(element))
+
+    element = 2**9
+    assert not can_hold_element(arr, element)
+    assert not can_hold_element(arr, np.int16(element))
+    assert not can_hold_element(arr, np.uint16(element))
+    assert not can_hold_element(arr, np.int32(element))
+    assert not can_hold_element(arr, np.uint32(element))
+    assert not can_hold_element(arr, np.int64(element))
+    assert not can_hold_element(arr, np.uint64(element))

mantis_evalkit/lib/python3.10/site-packages/pandas/tests/dtypes/cast/test_construct_from_scalar.py

@@ -0,0 +1,55 @@
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.cast import construct_1d_arraylike_from_scalar
+from pandas.core.dtypes.dtypes import CategoricalDtype
+
+from pandas import (
+    Categorical,
+    Timedelta,
+)
+import pandas._testing as tm
+
+
+def test_cast_1d_array_like_from_scalar_categorical():
+    # see gh-19565
+    #
+    # Categorical result from scalar did not maintain
+    # categories and ordering of the passed dtype.
+    cats = ["a", "b", "c"]
+    cat_type = CategoricalDtype(categories=cats, ordered=False)
+    expected = Categorical(["a", "a"], categories=cats)
+
+    result = construct_1d_arraylike_from_scalar("a", len(expected), cat_type)
+    tm.assert_categorical_equal(result, expected)
+
+
+def test_cast_1d_array_like_from_timestamp(fixed_now_ts):
+    # check we dont lose nanoseconds
+    ts = fixed_now_ts + Timedelta(1)
+    res = construct_1d_arraylike_from_scalar(ts, 2, np.dtype("M8[ns]"))
+    assert res[0] == ts
+
+
+def test_cast_1d_array_like_from_timedelta():
+    # check we dont lose nanoseconds
+    td = Timedelta(1)
+    res = construct_1d_arraylike_from_scalar(td, 2, np.dtype("m8[ns]"))
+    assert res[0] == td
+
+
+def test_cast_1d_array_like_mismatched_datetimelike():
+    td = np.timedelta64("NaT", "ns")
+    dt = np.datetime64("NaT", "ns")
+
+    with pytest.raises(TypeError, match="Cannot cast"):
+        construct_1d_arraylike_from_scalar(td, 2, dt.dtype)
+
+    with pytest.raises(TypeError, match="Cannot cast"):
+        construct_1d_arraylike_from_scalar(np.timedelta64(4, "ns"), 2, dt.dtype)
+
+    with pytest.raises(TypeError, match="Cannot cast"):
+        construct_1d_arraylike_from_scalar(dt, 2, td.dtype)
+
+    with pytest.raises(TypeError, match="Cannot cast"):
+        construct_1d_arraylike_from_scalar(np.datetime64(4, "ns"), 2, td.dtype)

mantis_evalkit/lib/python3.10/site-packages/pandas/tests/dtypes/cast/test_construct_ndarray.py

@@ -0,0 +1,36 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.core.construction import sanitize_array
+
+
+@pytest.mark.parametrize(
+    "values, dtype, expected",
+    [
+        ([1, 2, 3], None, np.array([1, 2, 3], dtype=np.int64)),
+        (np.array([1, 2, 3]), None, np.array([1, 2, 3])),
+        (["1", "2", None], None, np.array(["1", "2", None])),
+        (["1", "2", None], np.dtype("str"), np.array(["1", "2", None])),
+        ([1, 2, None], np.dtype("str"), np.array(["1", "2", None])),
+    ],
+)
+def test_construct_1d_ndarray_preserving_na(
+    values, dtype, expected, using_infer_string
+):
+    result = sanitize_array(values, index=None, dtype=dtype)
+    if using_infer_string and expected.dtype == object and dtype is None:
+        tm.assert_extension_array_equal(result, pd.array(expected))
+    else:
+        tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("dtype", ["m8[ns]", "M8[ns]"])
+def test_construct_1d_ndarray_preserving_na_datetimelike(dtype):
+    arr = np.arange(5, dtype=np.int64).view(dtype)
+    expected = np.array(list(arr), dtype=object)
+    assert all(isinstance(x, type(arr[0])) for x in expected)
+
+    result = sanitize_array(arr, index=None, dtype=np.dtype(object))
+    tm.assert_numpy_array_equal(result, expected)

mantis_evalkit/lib/python3.10/site-packages/pandas/tests/dtypes/cast/test_construct_object_arr.py

@@ -0,0 +1,20 @@
+import pytest
+
+from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike
+
+
+@pytest.mark.parametrize("datum1", [1, 2.0, "3", (4, 5), [6, 7], None])
+@pytest.mark.parametrize("datum2", [8, 9.0, "10", (11, 12), [13, 14], None])
+def test_cast_1d_array(datum1, datum2):
+    data = [datum1, datum2]
+    result = construct_1d_object_array_from_listlike(data)
+
+    # Direct comparison fails: https://github.com/numpy/numpy/issues/10218
+    assert result.dtype == "object"
+    assert list(result) == data
+
+
+@pytest.mark.parametrize("val", [1, 2.0, None])
+def test_cast_1d_array_invalid_scalar(val):
+    with pytest.raises(TypeError, match="has no len()"):
+        construct_1d_object_array_from_listlike(val)

mantis_evalkit/lib/python3.10/site-packages/pandas/tests/dtypes/cast/test_dict_compat.py

@@ -0,0 +1,14 @@
+import numpy as np
+
+from pandas.core.dtypes.cast import dict_compat
+
+from pandas import Timestamp
+
+
+def test_dict_compat():
+    data_datetime64 = {np.datetime64("1990-03-15"): 1, np.datetime64("2015-03-15"): 2}
+    data_unchanged = {1: 2, 3: 4, 5: 6}
+    expected = {Timestamp("1990-3-15"): 1, Timestamp("2015-03-15"): 2}
+    assert dict_compat(data_datetime64) == expected
+    assert dict_compat(expected) == expected
+    assert dict_compat(data_unchanged) == data_unchanged

mantis_evalkit/lib/python3.10/site-packages/pandas/tests/dtypes/cast/test_downcast.py

@@ -0,0 +1,97 @@
+import decimal
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.cast import maybe_downcast_to_dtype
+
+from pandas import (
+    Series,
+    Timedelta,
+)
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+    "arr,dtype,expected",
+    [
+        (
+            np.array([8.5, 8.6, 8.7, 8.8, 8.9999999999995]),
+            "infer",
+            np.array([8.5, 8.6, 8.7, 8.8, 8.9999999999995]),
+        ),
+        (
+            np.array([8.0, 8.0, 8.0, 8.0, 8.9999999999995]),
+            "infer",
+            np.array([8, 8, 8, 8, 9], dtype=np.int64),
+        ),
+        (
+            np.array([8.0, 8.0, 8.0, 8.0, 9.0000000000005]),
+            "infer",
+            np.array([8, 8, 8, 8, 9], dtype=np.int64),
+        ),
+        (
+            # This is a judgement call, but we do _not_ downcast Decimal
+            #  objects
+            np.array([decimal.Decimal(0.0)]),
+            "int64",
+            np.array([decimal.Decimal(0.0)]),
+        ),
+        (
+            # GH#45837
+            np.array([Timedelta(days=1), Timedelta(days=2)], dtype=object),
+            "infer",
+            np.array([1, 2], dtype="m8[D]").astype("m8[ns]"),
+        ),
+        # TODO: similar for dt64, dt64tz, Period, Interval?
+    ],
+)
+def test_downcast(arr, expected, dtype):
+    result = maybe_downcast_to_dtype(arr, dtype)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+def test_downcast_booleans():
+    # see gh-16875: coercing of booleans.
+    ser = Series([True, True, False])
+    result = maybe_downcast_to_dtype(ser, np.dtype(np.float64))
+
+    expected = ser.values
+    tm.assert_numpy_array_equal(result, expected)
+
+
+def test_downcast_conversion_no_nan(any_real_numpy_dtype):
+    dtype = any_real_numpy_dtype
+    expected = np.array([1, 2])
+    arr = np.array([1.0, 2.0], dtype=dtype)
+
+    result = maybe_downcast_to_dtype(arr, "infer")
+    tm.assert_almost_equal(result, expected, check_dtype=False)
+
+
+def test_downcast_conversion_nan(float_numpy_dtype):
+    dtype = float_numpy_dtype
+    data = [1.0, 2.0, np.nan]
+
+    expected = np.array(data, dtype=dtype)
+    arr = np.array(data, dtype=dtype)
+
+    result = maybe_downcast_to_dtype(arr, "infer")
+    tm.assert_almost_equal(result, expected)
+
+
+def test_downcast_conversion_empty(any_real_numpy_dtype):
+    dtype = any_real_numpy_dtype
+    arr = np.array([], dtype=dtype)
+    result = maybe_downcast_to_dtype(arr, np.dtype("int64"))
+    tm.assert_numpy_array_equal(result, np.array([], dtype=np.int64))
+
+
+@pytest.mark.parametrize("klass", [np.datetime64, np.timedelta64])
+def test_datetime_likes_nan(klass):
+    dtype = klass.__name__ + "[ns]"
+    arr = np.array([1, 2, np.nan])
+
+    exp = np.array([1, 2, klass("NaT")], dtype)
+    res = maybe_downcast_to_dtype(arr, dtype)
+    tm.assert_numpy_array_equal(res, exp)

mantis_evalkit/lib/python3.10/site-packages/pandas/tests/dtypes/cast/test_find_common_type.py

@@ -0,0 +1,175 @@
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.cast import find_common_type
+from pandas.core.dtypes.common import pandas_dtype
+from pandas.core.dtypes.dtypes import (
+    CategoricalDtype,
+    DatetimeTZDtype,
+    IntervalDtype,
+    PeriodDtype,
+)
+
+from pandas import (
+    Categorical,
+    Index,
+)
+
+
+@pytest.mark.parametrize(
+    "source_dtypes,expected_common_dtype",
+    [
+        ((np.int64,), np.int64),
+        ((np.uint64,), np.uint64),
+        ((np.float32,), np.float32),
+        ((object,), object),
+        # Into ints.
+        ((np.int16, np.int64), np.int64),
+        ((np.int32, np.uint32), np.int64),
+        ((np.uint16, np.uint64), np.uint64),
+        # Into floats.
+        ((np.float16, np.float32), np.float32),
+        ((np.float16, np.int16), np.float32),
+        ((np.float32, np.int16), np.float32),
+        ((np.uint64, np.int64), np.float64),
+        ((np.int16, np.float64), np.float64),
+        ((np.float16, np.int64), np.float64),
+        # Into others.
+        ((np.complex128, np.int32), np.complex128),
+        ((object, np.float32), object),
+        ((object, np.int16), object),
+        # Bool with int.
+        ((np.dtype("bool"), np.int64), object),
+        ((np.dtype("bool"), np.int32), object),
+        ((np.dtype("bool"), np.int16), object),
+        ((np.dtype("bool"), np.int8), object),
+        ((np.dtype("bool"), np.uint64), object),
+        ((np.dtype("bool"), np.uint32), object),
+        ((np.dtype("bool"), np.uint16), object),
+        ((np.dtype("bool"), np.uint8), object),
+        # Bool with float.
+        ((np.dtype("bool"), np.float64), object),
+        ((np.dtype("bool"), np.float32), object),
+        (
+            (np.dtype("datetime64[ns]"), np.dtype("datetime64[ns]")),
+            np.dtype("datetime64[ns]"),
+        ),
+        (
+            (np.dtype("timedelta64[ns]"), np.dtype("timedelta64[ns]")),
+            np.dtype("timedelta64[ns]"),
+        ),
+        (
+            (np.dtype("datetime64[ns]"), np.dtype("datetime64[ms]")),
+            np.dtype("datetime64[ns]"),
+        ),
+        (
+            (np.dtype("timedelta64[ms]"), np.dtype("timedelta64[ns]")),
+            np.dtype("timedelta64[ns]"),
+        ),
+        ((np.dtype("datetime64[ns]"), np.dtype("timedelta64[ns]")), object),
+        ((np.dtype("datetime64[ns]"), np.int64), object),
+    ],
+)
+def test_numpy_dtypes(source_dtypes, expected_common_dtype):
+    source_dtypes = [pandas_dtype(x) for x in source_dtypes]
+    assert find_common_type(source_dtypes) == expected_common_dtype
+
+
+def test_raises_empty_input():
+    with pytest.raises(ValueError, match="no types given"):
+        find_common_type([])
+
+
+@pytest.mark.parametrize(
+    "dtypes,exp_type",
+    [
+        ([CategoricalDtype()], "category"),
+        ([object, CategoricalDtype()], object),
+        ([CategoricalDtype(), CategoricalDtype()], "category"),
+    ],
+)
+def test_categorical_dtype(dtypes, exp_type):
+    assert find_common_type(dtypes) == exp_type
+
+
+def test_datetimetz_dtype_match():
+    dtype = DatetimeTZDtype(unit="ns", tz="US/Eastern")
+    assert find_common_type([dtype, dtype]) == "datetime64[ns, US/Eastern]"
+
+
+@pytest.mark.parametrize(
+    "dtype2",
+    [
+        DatetimeTZDtype(unit="ns", tz="Asia/Tokyo"),
+        np.dtype("datetime64[ns]"),
+        object,
+        np.int64,
+    ],
+)
+def test_datetimetz_dtype_mismatch(dtype2):
+    dtype = DatetimeTZDtype(unit="ns", tz="US/Eastern")
+    assert find_common_type([dtype, dtype2]) == object
+    assert find_common_type([dtype2, dtype]) == object
+
+
+def test_period_dtype_match():
+    dtype = PeriodDtype(freq="D")
+    assert find_common_type([dtype, dtype]) == "period[D]"
+
+
+@pytest.mark.parametrize(
+    "dtype2",
+    [
+        DatetimeTZDtype(unit="ns", tz="Asia/Tokyo"),
+        PeriodDtype(freq="2D"),
+        PeriodDtype(freq="h"),
+        np.dtype("datetime64[ns]"),
+        object,
+        np.int64,
+    ],
+)
+def test_period_dtype_mismatch(dtype2):
+    dtype = PeriodDtype(freq="D")
+    assert find_common_type([dtype, dtype2]) == object
+    assert find_common_type([dtype2, dtype]) == object
+
+
+interval_dtypes = [
+    IntervalDtype(np.int64, "right"),
+    IntervalDtype(np.float64, "right"),
+    IntervalDtype(np.uint64, "right"),
+    IntervalDtype(DatetimeTZDtype(unit="ns", tz="US/Eastern"), "right"),
+    IntervalDtype("M8[ns]", "right"),
+    IntervalDtype("m8[ns]", "right"),
+]
+
+
+@pytest.mark.parametrize("left", interval_dtypes)
+@pytest.mark.parametrize("right", interval_dtypes)
+def test_interval_dtype(left, right):
+    result = find_common_type([left, right])
+
+    if left is right:
+        assert result is left
+
+    elif left.subtype.kind in ["i", "u", "f"]:
+        # i.e. numeric
+        if right.subtype.kind in ["i", "u", "f"]:
+            # both numeric -> common numeric subtype
+            expected = IntervalDtype(np.float64, "right")
+            assert result == expected
+        else:
+            assert result == object
+
+    else:
+        assert result == object
+
+
+@pytest.mark.parametrize("dtype", interval_dtypes)
+def test_interval_dtype_with_categorical(dtype):
+    obj = Index([], dtype=dtype)
+
+    cat = Categorical([], categories=obj)
+
+    result = find_common_type([dtype, cat.dtype])
+    assert result == dtype

mantis_evalkit/lib/python3.10/site-packages/pandas/tests/dtypes/cast/test_infer_datetimelike.py

@@ -0,0 +1,28 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    NaT,
+    Series,
+    Timestamp,
+)
+
+
+@pytest.mark.parametrize(
+    "data,exp_size",
+    [
+        # see gh-16362.
+        ([[NaT, "a", "b", 0], [NaT, "b", "c", 1]], 8),
+        ([[NaT, "a", 0], [NaT, "b", 1]], 6),
+    ],
+)
+def test_maybe_infer_to_datetimelike_df_construct(data, exp_size):
+    result = DataFrame(np.array(data))
+    assert result.size == exp_size
+
+
+def test_maybe_infer_to_datetimelike_ser_construct():
+    # see gh-19671.
+    result = Series(["M1701", Timestamp("20130101")])
+    assert result.dtype.kind == "O"

mantis_evalkit/lib/python3.10/site-packages/pandas/tests/dtypes/cast/test_infer_dtype.py

@@ -0,0 +1,216 @@
+from datetime import (
+    date,
+    datetime,
+    timedelta,
+)
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.cast import (
+    infer_dtype_from,
+    infer_dtype_from_array,
+    infer_dtype_from_scalar,
+)
+from pandas.core.dtypes.common import is_dtype_equal
+
+from pandas import (
+    Categorical,
+    Interval,
+    Period,
+    Series,
+    Timedelta,
+    Timestamp,
+    date_range,
+)
+
+
+def test_infer_dtype_from_int_scalar(any_int_numpy_dtype):
+    # Test that infer_dtype_from_scalar is
+    # returning correct dtype for int and float.
+    data = np.dtype(any_int_numpy_dtype).type(12)
+    dtype, val = infer_dtype_from_scalar(data)
+    assert dtype == type(data)
+
+
+def test_infer_dtype_from_float_scalar(float_numpy_dtype):
+    float_numpy_dtype = np.dtype(float_numpy_dtype).type
+    data = float_numpy_dtype(12)
+
+    dtype, val = infer_dtype_from_scalar(data)
+    assert dtype == float_numpy_dtype
+
+
+@pytest.mark.parametrize(
+    "data,exp_dtype", [(12, np.int64), (np.float64(12), np.float64)]
+)
+def test_infer_dtype_from_python_scalar(data, exp_dtype):
+    dtype, val = infer_dtype_from_scalar(data)
+    assert dtype == exp_dtype
+
+
+@pytest.mark.parametrize("bool_val", [True, False])
+def test_infer_dtype_from_boolean(bool_val):
+    dtype, val = infer_dtype_from_scalar(bool_val)
+    assert dtype == np.bool_
+
+
+def test_infer_dtype_from_complex(complex_dtype):
+    data = np.dtype(complex_dtype).type(1)
+    dtype, val = infer_dtype_from_scalar(data)
+    assert dtype == np.complex128
+
+
+def test_infer_dtype_from_datetime():
+    dt64 = np.datetime64(1, "ns")
+    dtype, val = infer_dtype_from_scalar(dt64)
+    assert dtype == "M8[ns]"
+
+    ts = Timestamp(1)
+    dtype, val = infer_dtype_from_scalar(ts)
+    assert dtype == "M8[ns]"
+
+    dt = datetime(2000, 1, 1, 0, 0)
+    dtype, val = infer_dtype_from_scalar(dt)
+    assert dtype == "M8[us]"
+
+
+def test_infer_dtype_from_timedelta():
+    td64 = np.timedelta64(1, "ns")
+    dtype, val = infer_dtype_from_scalar(td64)
+    assert dtype == "m8[ns]"
+
+    pytd = timedelta(1)
+    dtype, val = infer_dtype_from_scalar(pytd)
+    assert dtype == "m8[us]"
+
+    td = Timedelta(1)
+    dtype, val = infer_dtype_from_scalar(td)
+    assert dtype == "m8[ns]"
+
+
+@pytest.mark.parametrize("freq", ["M", "D"])
+def test_infer_dtype_from_period(freq):
+    p = Period("2011-01-01", freq=freq)
+    dtype, val = infer_dtype_from_scalar(p)
+
+    exp_dtype = f"period[{freq}]"
+
+    assert dtype == exp_dtype
+    assert val == p
+
+
+def test_infer_dtype_misc():
+    dt = date(2000, 1, 1)
+    dtype, val = infer_dtype_from_scalar(dt)
+    assert dtype == np.object_
+
+    ts = Timestamp(1, tz="US/Eastern")
+    dtype, val = infer_dtype_from_scalar(ts)
+    assert dtype == "datetime64[ns, US/Eastern]"
+
+
+@pytest.mark.parametrize("tz", ["UTC", "US/Eastern", "Asia/Tokyo"])
+def test_infer_from_scalar_tz(tz):
+    dt = Timestamp(1, tz=tz)
+    dtype, val = infer_dtype_from_scalar(dt)
+
+    exp_dtype = f"datetime64[ns, {tz}]"
+
+    assert dtype == exp_dtype
+    assert val == dt
+
+
+@pytest.mark.parametrize(
+    "left, right, subtype",
+    [
+        (0, 1, "int64"),
+        (0.0, 1.0, "float64"),
+        (Timestamp(0), Timestamp(1), "datetime64[ns]"),
+        (Timestamp(0, tz="UTC"), Timestamp(1, tz="UTC"), "datetime64[ns, UTC]"),
+        (Timedelta(0), Timedelta(1), "timedelta64[ns]"),
+    ],
+)
+def test_infer_from_interval(left, right, subtype, closed):
+    # GH 30337
+    interval = Interval(left, right, closed)
+    result_dtype, result_value = infer_dtype_from_scalar(interval)
+    expected_dtype = f"interval[{subtype}, {closed}]"
+    assert result_dtype == expected_dtype
+    assert result_value == interval
+
+
+def test_infer_dtype_from_scalar_errors():
+    msg = "invalid ndarray passed to infer_dtype_from_scalar"
+
+    with pytest.raises(ValueError, match=msg):
+        infer_dtype_from_scalar(np.array([1]))
+
+
+@pytest.mark.parametrize(
+    "value, expected",
+    [
+        ("foo", np.object_),
+        (b"foo", np.object_),
+        (1, np.int64),
+        (1.5, np.float64),
+        (np.datetime64("2016-01-01"), np.dtype("M8[s]")),
+        (Timestamp("20160101"), np.dtype("M8[s]")),
+        (Timestamp("20160101", tz="UTC"), "datetime64[s, UTC]"),
+    ],
+)
+def test_infer_dtype_from_scalar(value, expected, using_infer_string):
+    dtype, _ = infer_dtype_from_scalar(value)
+    if using_infer_string and value == "foo":
+        expected = "string"
+    assert is_dtype_equal(dtype, expected)
+
+    with pytest.raises(TypeError, match="must be list-like"):
+        infer_dtype_from_array(value)
+
+
+@pytest.mark.parametrize(
+    "arr, expected",
+    [
+        ([1], np.dtype(int)),
+        (np.array([1], dtype=np.int64), np.int64),
+        ([np.nan, 1, ""], np.object_),
+        (np.array([[1.0, 2.0]]), np.float64),
+        (Categorical(list("aabc")), "category"),
+        (Categorical([1, 2, 3]), "category"),
+        (date_range("20160101", periods=3), np.dtype("=M8[ns]")),
+        (
+            date_range("20160101", periods=3, tz="US/Eastern"),
+            "datetime64[ns, US/Eastern]",
+        ),
+        (Series([1.0, 2, 3]), np.float64),
+        (Series(list("abc")), np.object_),
+        (
+            Series(date_range("20160101", periods=3, tz="US/Eastern")),
+            "datetime64[ns, US/Eastern]",
+        ),
+    ],
+)
+def test_infer_dtype_from_array(arr, expected, using_infer_string):
+    dtype, _ = infer_dtype_from_array(arr)
+    if (
+        using_infer_string
+        and isinstance(arr, Series)
+        and arr.tolist() == ["a", "b", "c"]
+    ):
+        expected = "string"
+    assert is_dtype_equal(dtype, expected)
+
+
+@pytest.mark.parametrize("cls", [np.datetime64, np.timedelta64])
+def test_infer_dtype_from_scalar_zerodim_datetimelike(cls):
+    # ndarray.item() can incorrectly return int instead of td64/dt64
+    val = cls(1234, "ns")
+    arr = np.array(val)
+
+    dtype, res = infer_dtype_from_scalar(arr)
+    assert dtype.type is cls
+    assert isinstance(res, cls)
+
+    dtype, res = infer_dtype_from(arr)
+    assert dtype.type is cls

mantis_evalkit/lib/python3.10/site-packages/pandas/tests/dtypes/cast/test_maybe_box_native.py

@@ -0,0 +1,40 @@
+from datetime import datetime
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.cast import maybe_box_native
+
+from pandas import (
+    Interval,
+    Period,
+    Timedelta,
+    Timestamp,
+)
+
+
+@pytest.mark.parametrize(
+    "obj,expected_dtype",
+    [
+        (b"\x00\x10", bytes),
+        (int(4), int),
+        (np.uint(4), int),
+        (np.int32(-4), int),
+        (np.uint8(4), int),
+        (float(454.98), float),
+        (np.float16(0.4), float),
+        (np.float64(1.4), float),
+        (np.bool_(False), bool),
+        (datetime(2005, 2, 25), datetime),
+        (np.datetime64("2005-02-25"), Timestamp),
+        (Timestamp("2005-02-25"), Timestamp),
+        (np.timedelta64(1, "D"), Timedelta),
+        (Timedelta(1, "D"), Timedelta),
+        (Interval(0, 1), Interval),
+        (Period("4Q2005"), Period),
+    ],
+)
+def test_maybe_box_native(obj, expected_dtype):
+    boxed_obj = maybe_box_native(obj)
+    result_dtype = type(boxed_obj)
+    assert result_dtype is expected_dtype

mantis_evalkit/lib/python3.10/site-packages/pandas/tests/dtypes/cast/test_promote.py

@@ -0,0 +1,530 @@
+"""
+These test the method maybe_promote from core/dtypes/cast.py
+"""
+
+import datetime
+from decimal import Decimal
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import NaT
+
+from pandas.core.dtypes.cast import maybe_promote
+from pandas.core.dtypes.common import is_scalar
+from pandas.core.dtypes.dtypes import DatetimeTZDtype
+from pandas.core.dtypes.missing import isna
+
+import pandas as pd
+
+
+def _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar=None):
+    """
+    Auxiliary function to unify testing of scalar/array promotion.
+
+    Parameters
+    ----------
+    dtype : dtype
+        The value to pass on as the first argument to maybe_promote.
+    fill_value : scalar
+        The value to pass on as the second argument to maybe_promote as
+        a scalar.
+    expected_dtype : dtype
+        The expected dtype returned by maybe_promote (by design this is the
+        same regardless of whether fill_value was passed as a scalar or in an
+        array!).
+    exp_val_for_scalar : scalar
+        The expected value for the (potentially upcast) fill_value returned by
+        maybe_promote.
+    """
+    assert is_scalar(fill_value)
+
+    # here, we pass on fill_value as a scalar directly; the expected value
+    # returned from maybe_promote is fill_value, potentially upcast to the
+    # returned dtype.
+    result_dtype, result_fill_value = maybe_promote(dtype, fill_value)
+    expected_fill_value = exp_val_for_scalar
+
+    assert result_dtype == expected_dtype
+    _assert_match(result_fill_value, expected_fill_value)
+
+
+def _assert_match(result_fill_value, expected_fill_value):
+    # GH#23982/25425 require the same type in addition to equality/NA-ness
+    res_type = type(result_fill_value)
+    ex_type = type(expected_fill_value)
+
+    if hasattr(result_fill_value, "dtype"):
+        # Compare types in a way that is robust to platform-specific
+        #  idiosyncrasies where e.g. sometimes we get "ulonglong" as an alias
+        #  for "uint64" or "intc" as an alias for "int32"
+        assert result_fill_value.dtype.kind == expected_fill_value.dtype.kind
+        assert result_fill_value.dtype.itemsize == expected_fill_value.dtype.itemsize
+    else:
+        # On some builds, type comparison fails, e.g. np.int32 != np.int32
+        assert res_type == ex_type or res_type.__name__ == ex_type.__name__
+
+    match_value = result_fill_value == expected_fill_value
+    if match_value is pd.NA:
+        match_value = False
+
+    # Note: type check above ensures that we have the _same_ NA value
+    # for missing values, None == None (which is checked
+    # through match_value above), but np.nan != np.nan and pd.NaT != pd.NaT
+    match_missing = isna(result_fill_value) and isna(expected_fill_value)
+
+    assert match_value or match_missing
+
+
+@pytest.mark.parametrize(
+    "dtype, fill_value, expected_dtype",
+    [
+        # size 8
+        ("int8", 1, "int8"),
+        ("int8", np.iinfo("int8").max + 1, "int16"),
+        ("int8", np.iinfo("int16").max + 1, "int32"),
+        ("int8", np.iinfo("int32").max + 1, "int64"),
+        ("int8", np.iinfo("int64").max + 1, "object"),
+        ("int8", -1, "int8"),
+        ("int8", np.iinfo("int8").min - 1, "int16"),
+        ("int8", np.iinfo("int16").min - 1, "int32"),
+        ("int8", np.iinfo("int32").min - 1, "int64"),
+        ("int8", np.iinfo("int64").min - 1, "object"),
+        # keep signed-ness as long as possible
+        ("uint8", 1, "uint8"),
+        ("uint8", np.iinfo("int8").max + 1, "uint8"),
+        ("uint8", np.iinfo("uint8").max + 1, "uint16"),
+        ("uint8", np.iinfo("int16").max + 1, "uint16"),
+        ("uint8", np.iinfo("uint16").max + 1, "uint32"),
+        ("uint8", np.iinfo("int32").max + 1, "uint32"),
+        ("uint8", np.iinfo("uint32").max + 1, "uint64"),
+        ("uint8", np.iinfo("int64").max + 1, "uint64"),
+        ("uint8", np.iinfo("uint64").max + 1, "object"),
+        # max of uint8 cannot be contained in int8
+        ("uint8", -1, "int16"),
+        ("uint8", np.iinfo("int8").min - 1, "int16"),
+        ("uint8", np.iinfo("int16").min - 1, "int32"),
+        ("uint8", np.iinfo("int32").min - 1, "int64"),
+        ("uint8", np.iinfo("int64").min - 1, "object"),
+        # size 16
+        ("int16", 1, "int16"),
+        ("int16", np.iinfo("int8").max + 1, "int16"),
+        ("int16", np.iinfo("int16").max + 1, "int32"),
+        ("int16", np.iinfo("int32").max + 1, "int64"),
+        ("int16", np.iinfo("int64").max + 1, "object"),
+        ("int16", -1, "int16"),
+        ("int16", np.iinfo("int8").min - 1, "int16"),
+        ("int16", np.iinfo("int16").min - 1, "int32"),
+        ("int16", np.iinfo("int32").min - 1, "int64"),
+        ("int16", np.iinfo("int64").min - 1, "object"),
+        ("uint16", 1, "uint16"),
+        ("uint16", np.iinfo("int8").max + 1, "uint16"),
+        ("uint16", np.iinfo("uint8").max + 1, "uint16"),
+        ("uint16", np.iinfo("int16").max + 1, "uint16"),
+        ("uint16", np.iinfo("uint16").max + 1, "uint32"),
+        ("uint16", np.iinfo("int32").max + 1, "uint32"),
+        ("uint16", np.iinfo("uint32").max + 1, "uint64"),
+        ("uint16", np.iinfo("int64").max + 1, "uint64"),
+        ("uint16", np.iinfo("uint64").max + 1, "object"),
+        ("uint16", -1, "int32"),
+        ("uint16", np.iinfo("int8").min - 1, "int32"),
+        ("uint16", np.iinfo("int16").min - 1, "int32"),
+        ("uint16", np.iinfo("int32").min - 1, "int64"),
+        ("uint16", np.iinfo("int64").min - 1, "object"),
+        # size 32
+        ("int32", 1, "int32"),
+        ("int32", np.iinfo("int8").max + 1, "int32"),
+        ("int32", np.iinfo("int16").max + 1, "int32"),
+        ("int32", np.iinfo("int32").max + 1, "int64"),
+        ("int32", np.iinfo("int64").max + 1, "object"),
+        ("int32", -1, "int32"),
+        ("int32", np.iinfo("int8").min - 1, "int32"),
+        ("int32", np.iinfo("int16").min - 1, "int32"),
+        ("int32", np.iinfo("int32").min - 1, "int64"),
+        ("int32", np.iinfo("int64").min - 1, "object"),
+        ("uint32", 1, "uint32"),
+        ("uint32", np.iinfo("int8").max + 1, "uint32"),
+        ("uint32", np.iinfo("uint8").max + 1, "uint32"),
+        ("uint32", np.iinfo("int16").max + 1, "uint32"),
+        ("uint32", np.iinfo("uint16").max + 1, "uint32"),
+        ("uint32", np.iinfo("int32").max + 1, "uint32"),
+        ("uint32", np.iinfo("uint32").max + 1, "uint64"),
+        ("uint32", np.iinfo("int64").max + 1, "uint64"),
+        ("uint32", np.iinfo("uint64").max + 1, "object"),
+        ("uint32", -1, "int64"),
+        ("uint32", np.iinfo("int8").min - 1, "int64"),
+        ("uint32", np.iinfo("int16").min - 1, "int64"),
+        ("uint32", np.iinfo("int32").min - 1, "int64"),
+        ("uint32", np.iinfo("int64").min - 1, "object"),
+        # size 64
+        ("int64", 1, "int64"),
+        ("int64", np.iinfo("int8").max + 1, "int64"),
+        ("int64", np.iinfo("int16").max + 1, "int64"),
+        ("int64", np.iinfo("int32").max + 1, "int64"),
+        ("int64", np.iinfo("int64").max + 1, "object"),
+        ("int64", -1, "int64"),
+        ("int64", np.iinfo("int8").min - 1, "int64"),
+        ("int64", np.iinfo("int16").min - 1, "int64"),
+        ("int64", np.iinfo("int32").min - 1, "int64"),
+        ("int64", np.iinfo("int64").min - 1, "object"),
+        ("uint64", 1, "uint64"),
+        ("uint64", np.iinfo("int8").max + 1, "uint64"),
+        ("uint64", np.iinfo("uint8").max + 1, "uint64"),
+        ("uint64", np.iinfo("int16").max + 1, "uint64"),
+        ("uint64", np.iinfo("uint16").max + 1, "uint64"),
+        ("uint64", np.iinfo("int32").max + 1, "uint64"),
+        ("uint64", np.iinfo("uint32").max + 1, "uint64"),
+        ("uint64", np.iinfo("int64").max + 1, "uint64"),
+        ("uint64", np.iinfo("uint64").max + 1, "object"),
+        ("uint64", -1, "object"),
+        ("uint64", np.iinfo("int8").min - 1, "object"),
+        ("uint64", np.iinfo("int16").min - 1, "object"),
+        ("uint64", np.iinfo("int32").min - 1, "object"),
+        ("uint64", np.iinfo("int64").min - 1, "object"),
+    ],
+)
+def test_maybe_promote_int_with_int(dtype, fill_value, expected_dtype):
+    dtype = np.dtype(dtype)
+    expected_dtype = np.dtype(expected_dtype)
+
+    # output is not a generic int, but corresponds to expected_dtype
+    exp_val_for_scalar = np.array([fill_value], dtype=expected_dtype)[0]
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_int_with_float(any_int_numpy_dtype, float_numpy_dtype):
+    dtype = np.dtype(any_int_numpy_dtype)
+    fill_dtype = np.dtype(float_numpy_dtype)
+
+    # create array of given dtype; casts "1" to correct dtype
+    fill_value = np.array([1], dtype=fill_dtype)[0]
+
+    # filling int with float always upcasts to float64
+    expected_dtype = np.float64
+    # fill_value can be different float type
+    exp_val_for_scalar = np.float64(fill_value)
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_float_with_int(float_numpy_dtype, any_int_numpy_dtype):
+    dtype = np.dtype(float_numpy_dtype)
+    fill_dtype = np.dtype(any_int_numpy_dtype)
+
+    # create array of given dtype; casts "1" to correct dtype
+    fill_value = np.array([1], dtype=fill_dtype)[0]
+
+    # filling float with int always keeps float dtype
+    # because: np.finfo('float32').max > np.iinfo('uint64').max
+    expected_dtype = dtype
+    # output is not a generic float, but corresponds to expected_dtype
+    exp_val_for_scalar = np.array([fill_value], dtype=expected_dtype)[0]
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+@pytest.mark.parametrize(
+    "dtype, fill_value, expected_dtype",
+    [
+        # float filled with float
+        ("float32", 1, "float32"),
+        ("float32", float(np.finfo("float32").max) * 1.1, "float64"),
+        ("float64", 1, "float64"),
+        ("float64", float(np.finfo("float32").max) * 1.1, "float64"),
+        # complex filled with float
+        ("complex64", 1, "complex64"),
+        ("complex64", float(np.finfo("float32").max) * 1.1, "complex128"),
+        ("complex128", 1, "complex128"),
+        ("complex128", float(np.finfo("float32").max) * 1.1, "complex128"),
+        # float filled with complex
+        ("float32", 1 + 1j, "complex64"),
+        ("float32", float(np.finfo("float32").max) * (1.1 + 1j), "complex128"),
+        ("float64", 1 + 1j, "complex128"),
+        ("float64", float(np.finfo("float32").max) * (1.1 + 1j), "complex128"),
+        # complex filled with complex
+        ("complex64", 1 + 1j, "complex64"),
+        ("complex64", float(np.finfo("float32").max) * (1.1 + 1j), "complex128"),
+        ("complex128", 1 + 1j, "complex128"),
+        ("complex128", float(np.finfo("float32").max) * (1.1 + 1j), "complex128"),
+    ],
+)
+def test_maybe_promote_float_with_float(dtype, fill_value, expected_dtype):
+    dtype = np.dtype(dtype)
+    expected_dtype = np.dtype(expected_dtype)
+
+    # output is not a generic float, but corresponds to expected_dtype
+    exp_val_for_scalar = np.array([fill_value], dtype=expected_dtype)[0]
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_bool_with_any(any_numpy_dtype):
+    dtype = np.dtype(bool)
+    fill_dtype = np.dtype(any_numpy_dtype)
+
+    # create array of given dtype; casts "1" to correct dtype
+    fill_value = np.array([1], dtype=fill_dtype)[0]
+
+    # filling bool with anything but bool casts to object
+    expected_dtype = np.dtype(object) if fill_dtype != bool else fill_dtype
+    exp_val_for_scalar = fill_value
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_any_with_bool(any_numpy_dtype):
+    dtype = np.dtype(any_numpy_dtype)
+    fill_value = True
+
+    # filling anything but bool with bool casts to object
+    expected_dtype = np.dtype(object) if dtype != bool else dtype
+    # output is not a generic bool, but corresponds to expected_dtype
+    exp_val_for_scalar = np.array([fill_value], dtype=expected_dtype)[0]
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_bytes_with_any(bytes_dtype, any_numpy_dtype):
+    dtype = np.dtype(bytes_dtype)
+    fill_dtype = np.dtype(any_numpy_dtype)
+
+    # create array of given dtype; casts "1" to correct dtype
+    fill_value = np.array([1], dtype=fill_dtype)[0]
+
+    # we never use bytes dtype internally, always promote to object
+    expected_dtype = np.dtype(np.object_)
+    exp_val_for_scalar = fill_value
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_any_with_bytes(any_numpy_dtype):
+    dtype = np.dtype(any_numpy_dtype)
+
+    # create array of given dtype
+    fill_value = b"abc"
+
+    # we never use bytes dtype internally, always promote to object
+    expected_dtype = np.dtype(np.object_)
+    # output is not a generic bytes, but corresponds to expected_dtype
+    exp_val_for_scalar = np.array([fill_value], dtype=expected_dtype)[0]
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_datetime64_with_any(datetime64_dtype, any_numpy_dtype):
+    dtype = np.dtype(datetime64_dtype)
+    fill_dtype = np.dtype(any_numpy_dtype)
+
+    # create array of given dtype; casts "1" to correct dtype
+    fill_value = np.array([1], dtype=fill_dtype)[0]
+
+    # filling datetime with anything but datetime casts to object
+    if fill_dtype.kind == "M":
+        expected_dtype = dtype
+        # for datetime dtypes, scalar values get cast to to_datetime64
+        exp_val_for_scalar = pd.Timestamp(fill_value).to_datetime64()
+    else:
+        expected_dtype = np.dtype(object)
+        exp_val_for_scalar = fill_value
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+@pytest.mark.parametrize(
+    "fill_value",
+    [
+        pd.Timestamp("now"),
+        np.datetime64("now"),
+        datetime.datetime.now(),
+        datetime.date.today(),
+    ],
+    ids=["pd.Timestamp", "np.datetime64", "datetime.datetime", "datetime.date"],
+)
+def test_maybe_promote_any_with_datetime64(any_numpy_dtype, fill_value):
+    dtype = np.dtype(any_numpy_dtype)
+
+    # filling datetime with anything but datetime casts to object
+    if dtype.kind == "M":
+        expected_dtype = dtype
+        # for datetime dtypes, scalar values get cast to pd.Timestamp.value
+        exp_val_for_scalar = pd.Timestamp(fill_value).to_datetime64()
+    else:
+        expected_dtype = np.dtype(object)
+        exp_val_for_scalar = fill_value
+
+    if type(fill_value) is datetime.date and dtype.kind == "M":
+        # Casting date to dt64 is deprecated, in 2.0 enforced to cast to object
+        expected_dtype = np.dtype(object)
+        exp_val_for_scalar = fill_value
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+@pytest.mark.parametrize(
+    "fill_value",
+    [
+        pd.Timestamp(2023, 1, 1),
+        np.datetime64("2023-01-01"),
+        datetime.datetime(2023, 1, 1),
+        datetime.date(2023, 1, 1),
+    ],
+    ids=["pd.Timestamp", "np.datetime64", "datetime.datetime", "datetime.date"],
+)
+def test_maybe_promote_any_numpy_dtype_with_datetimetz(
+    any_numpy_dtype, tz_aware_fixture, fill_value
+):
+    dtype = np.dtype(any_numpy_dtype)
+    fill_dtype = DatetimeTZDtype(tz=tz_aware_fixture)
+
+    fill_value = pd.Series([fill_value], dtype=fill_dtype)[0]
+
+    # filling any numpy dtype with datetimetz casts to object
+    expected_dtype = np.dtype(object)
+    exp_val_for_scalar = fill_value
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_timedelta64_with_any(timedelta64_dtype, any_numpy_dtype):
+    dtype = np.dtype(timedelta64_dtype)
+    fill_dtype = np.dtype(any_numpy_dtype)
+
+    # create array of given dtype; casts "1" to correct dtype
+    fill_value = np.array([1], dtype=fill_dtype)[0]
+
+    # filling timedelta with anything but timedelta casts to object
+    if fill_dtype.kind == "m":
+        expected_dtype = dtype
+        # for timedelta dtypes, scalar values get cast to pd.Timedelta.value
+        exp_val_for_scalar = pd.Timedelta(fill_value).to_timedelta64()
+    else:
+        expected_dtype = np.dtype(object)
+        exp_val_for_scalar = fill_value
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+@pytest.mark.parametrize(
+    "fill_value",
+    [pd.Timedelta(days=1), np.timedelta64(24, "h"), datetime.timedelta(1)],
+    ids=["pd.Timedelta", "np.timedelta64", "datetime.timedelta"],
+)
+def test_maybe_promote_any_with_timedelta64(any_numpy_dtype, fill_value):
+    dtype = np.dtype(any_numpy_dtype)
+
+    # filling anything but timedelta with timedelta casts to object
+    if dtype.kind == "m":
+        expected_dtype = dtype
+        # for timedelta dtypes, scalar values get cast to pd.Timedelta.value
+        exp_val_for_scalar = pd.Timedelta(fill_value).to_timedelta64()
+    else:
+        expected_dtype = np.dtype(object)
+        exp_val_for_scalar = fill_value
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_string_with_any(string_dtype, any_numpy_dtype):
+    dtype = np.dtype(string_dtype)
+    fill_dtype = np.dtype(any_numpy_dtype)
+
+    # create array of given dtype; casts "1" to correct dtype
+    fill_value = np.array([1], dtype=fill_dtype)[0]
+
+    # filling string with anything casts to object
+    expected_dtype = np.dtype(object)
+    exp_val_for_scalar = fill_value
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_any_with_string(any_numpy_dtype):
+    dtype = np.dtype(any_numpy_dtype)
+
+    # create array of given dtype
+    fill_value = "abc"
+
+    # filling anything with a string casts to object
+    expected_dtype = np.dtype(object)
+    exp_val_for_scalar = fill_value
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_object_with_any(object_dtype, any_numpy_dtype):
+    dtype = np.dtype(object_dtype)
+    fill_dtype = np.dtype(any_numpy_dtype)
+
+    # create array of given dtype; casts "1" to correct dtype
+    fill_value = np.array([1], dtype=fill_dtype)[0]
+
+    # filling object with anything stays object
+    expected_dtype = np.dtype(object)
+    exp_val_for_scalar = fill_value
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_any_with_object(any_numpy_dtype):
+    dtype = np.dtype(any_numpy_dtype)
+
+    # create array of object dtype from a scalar value (i.e. passing
+    # dtypes.common.is_scalar), which can however not be cast to int/float etc.
+    fill_value = pd.DateOffset(1)
+
+    # filling object with anything stays object
+    expected_dtype = np.dtype(object)
+    exp_val_for_scalar = fill_value
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)
+
+
+def test_maybe_promote_any_numpy_dtype_with_na(any_numpy_dtype, nulls_fixture):
+    fill_value = nulls_fixture
+    dtype = np.dtype(any_numpy_dtype)
+
+    if isinstance(fill_value, Decimal):
+        # Subject to change, but ATM (When Decimal(NAN) is being added to nulls_fixture)
+        #  this is the existing behavior in maybe_promote,
+        #  hinges on is_valid_na_for_dtype
+        if dtype.kind in "iufc":
+            if dtype.kind in "iu":
+                expected_dtype = np.dtype(np.float64)
+            else:
+                expected_dtype = dtype
+            exp_val_for_scalar = np.nan
+        else:
+            expected_dtype = np.dtype(object)
+            exp_val_for_scalar = fill_value
+    elif dtype.kind in "iu" and fill_value is not NaT:
+        # integer + other missing value (np.nan / None) casts to float
+        expected_dtype = np.float64
+        exp_val_for_scalar = np.nan
+    elif dtype == object and fill_value is NaT:
+        # inserting into object does not cast the value
+        # but *does* cast None to np.nan
+        expected_dtype = np.dtype(object)
+        exp_val_for_scalar = fill_value
+    elif dtype.kind in "mM":
+        # datetime / timedelta cast all missing values to dtyped-NaT
+        expected_dtype = dtype
+        exp_val_for_scalar = dtype.type("NaT", "ns")
+    elif fill_value is NaT:
+        # NaT upcasts everything that's not datetime/timedelta to object
+        expected_dtype = np.dtype(object)
+        exp_val_for_scalar = NaT
+    elif dtype.kind in "fc":
+        # float / complex + missing value (!= NaT) stays the same
+        expected_dtype = dtype
+        exp_val_for_scalar = np.nan
+    else:
+        # all other cases cast to object, and use np.nan as missing value
+        expected_dtype = np.dtype(object)
+        if fill_value is pd.NA:
+            exp_val_for_scalar = pd.NA
+        else:
+            exp_val_for_scalar = np.nan
+
+    _check_promote(dtype, fill_value, expected_dtype, exp_val_for_scalar)

mantis_evalkit/lib/python3.10/site-packages/pandas/tests/dtypes/test_common.py

@@ -0,0 +1,801 @@
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+from pandas.core.dtypes.astype import astype_array
+import pandas.core.dtypes.common as com
+from pandas.core.dtypes.dtypes import (
+    CategoricalDtype,
+    CategoricalDtypeType,
+    DatetimeTZDtype,
+    ExtensionDtype,
+    IntervalDtype,
+    PeriodDtype,
+)
+from pandas.core.dtypes.missing import isna
+
+import pandas as pd
+import pandas._testing as tm
+from pandas.api.types import pandas_dtype
+from pandas.arrays import SparseArray
+
+
+# EA & Actual Dtypes
+def to_ea_dtypes(dtypes):
+    """convert list of string dtypes to EA dtype"""
+    return [getattr(pd, dt + "Dtype") for dt in dtypes]
+
+
+def to_numpy_dtypes(dtypes):
+    """convert list of string dtypes to numpy dtype"""
+    return [getattr(np, dt) for dt in dtypes if isinstance(dt, str)]
+
+
+class TestNumpyEADtype:
+    # Passing invalid dtype, both as a string or object, must raise TypeError
+    # Per issue GH15520
+    @pytest.mark.parametrize("box", [pd.Timestamp, "pd.Timestamp", list])
+    def test_invalid_dtype_error(self, box):
+        with pytest.raises(TypeError, match="not understood"):
+            com.pandas_dtype(box)
+
+    @pytest.mark.parametrize(
+        "dtype",
+        [
+            object,
+            "float64",
+            np.object_,
+            np.dtype("object"),
+            "O",
+            np.float64,
+            float,
+            np.dtype("float64"),
+            "object_",
+        ],
+    )
+    def test_pandas_dtype_valid(self, dtype):
+        assert com.pandas_dtype(dtype) == dtype
+
+    @pytest.mark.parametrize(
+        "dtype", ["M8[ns]", "m8[ns]", "object", "float64", "int64"]
+    )
+    def test_numpy_dtype(self, dtype):
+        assert com.pandas_dtype(dtype) == np.dtype(dtype)
+
+    def test_numpy_string_dtype(self):
+        # do not parse freq-like string as period dtype
+        assert com.pandas_dtype("U") == np.dtype("U")
+        assert com.pandas_dtype("S") == np.dtype("S")
+
+    @pytest.mark.parametrize(
+        "dtype",
+        [
+            "datetime64[ns, US/Eastern]",
+            "datetime64[ns, Asia/Tokyo]",
+            "datetime64[ns, UTC]",
+            # GH#33885 check that the M8 alias is understood
+            "M8[ns, US/Eastern]",
+            "M8[ns, Asia/Tokyo]",
+            "M8[ns, UTC]",
+        ],
+    )
+    def test_datetimetz_dtype(self, dtype):
+        assert com.pandas_dtype(dtype) == DatetimeTZDtype.construct_from_string(dtype)
+        assert com.pandas_dtype(dtype) == dtype
+
+    def test_categorical_dtype(self):
+        assert com.pandas_dtype("category") == CategoricalDtype()
+
+    @pytest.mark.parametrize(
+        "dtype",
+        [
+            "period[D]",
+            "period[3M]",
+            "period[us]",
+            "Period[D]",
+            "Period[3M]",
+            "Period[us]",
+        ],
+    )
+    def test_period_dtype(self, dtype):
+        assert com.pandas_dtype(dtype) is not PeriodDtype(dtype)
+        assert com.pandas_dtype(dtype) == PeriodDtype(dtype)
+        assert com.pandas_dtype(dtype) == dtype
+
+
+dtypes = {
+    "datetime_tz": com.pandas_dtype("datetime64[ns, US/Eastern]"),
+    "datetime": com.pandas_dtype("datetime64[ns]"),
+    "timedelta": com.pandas_dtype("timedelta64[ns]"),
+    "period": PeriodDtype("D"),
+    "integer": np.dtype(np.int64),
+    "float": np.dtype(np.float64),
+    "object": np.dtype(object),
+    "category": com.pandas_dtype("category"),
+    "string": pd.StringDtype(),
+}
+
+
+@pytest.mark.parametrize("name1,dtype1", list(dtypes.items()), ids=lambda x: str(x))
+@pytest.mark.parametrize("name2,dtype2", list(dtypes.items()), ids=lambda x: str(x))
+def test_dtype_equal(name1, dtype1, name2, dtype2):
+    # match equal to self, but not equal to other
+    assert com.is_dtype_equal(dtype1, dtype1)
+    if name1 != name2:
+        assert not com.is_dtype_equal(dtype1, dtype2)
+
+
+@pytest.mark.parametrize("name,dtype", list(dtypes.items()), ids=lambda x: str(x))
+def test_pyarrow_string_import_error(name, dtype):
+    # GH-44276
+    assert not com.is_dtype_equal(dtype, "string[pyarrow]")
+
+
+@pytest.mark.parametrize(
+    "dtype1,dtype2",
+    [
+        (np.int8, np.int64),
+        (np.int16, np.int64),
+        (np.int32, np.int64),
+        (np.float32, np.float64),
+        (PeriodDtype("D"), PeriodDtype("2D")),  # PeriodType
+        (
+            com.pandas_dtype("datetime64[ns, US/Eastern]"),
+            com.pandas_dtype("datetime64[ns, CET]"),
+        ),  # Datetime
+        (None, None),  # gh-15941: no exception should be raised.
+    ],
+)
+def test_dtype_equal_strict(dtype1, dtype2):
+    assert not com.is_dtype_equal(dtype1, dtype2)
+
+
+def get_is_dtype_funcs():
+    """
+    Get all functions in pandas.core.dtypes.common that
+    begin with 'is_' and end with 'dtype'
+
+    """
+    fnames = [f for f in dir(com) if (f.startswith("is_") and f.endswith("dtype"))]
+    fnames.remove("is_string_or_object_np_dtype")  # fastpath requires np.dtype obj
+    return [getattr(com, fname) for fname in fnames]
+
+
+@pytest.mark.filterwarnings(
+    "ignore:is_categorical_dtype is deprecated:DeprecationWarning"
+)
+@pytest.mark.parametrize("func", get_is_dtype_funcs(), ids=lambda x: x.__name__)
+def test_get_dtype_error_catch(func):
+    # see gh-15941
+    #
+    # No exception should be raised.
+
+    msg = f"{func.__name__} is deprecated"
+    warn = None
+    if (
+        func is com.is_int64_dtype
+        or func is com.is_interval_dtype
+        or func is com.is_datetime64tz_dtype
+        or func is com.is_categorical_dtype
+        or func is com.is_period_dtype
+    ):
+        warn = DeprecationWarning
+
+    with tm.assert_produces_warning(warn, match=msg):
+        assert not func(None)
+
+
+def test_is_object():
+    assert com.is_object_dtype(object)
+    assert com.is_object_dtype(np.array([], dtype=object))
+
+    assert not com.is_object_dtype(int)
+    assert not com.is_object_dtype(np.array([], dtype=int))
+    assert not com.is_object_dtype([1, 2, 3])
+
+
+@pytest.mark.parametrize(
+    "check_scipy", [False, pytest.param(True, marks=td.skip_if_no("scipy"))]
+)
+def test_is_sparse(check_scipy):
+    msg = "is_sparse is deprecated"
+    with tm.assert_produces_warning(DeprecationWarning, match=msg):
+        assert com.is_sparse(SparseArray([1, 2, 3]))
+
+        assert not com.is_sparse(np.array([1, 2, 3]))
+
+        if check_scipy:
+            import scipy.sparse
+
+            assert not com.is_sparse(scipy.sparse.bsr_matrix([1, 2, 3]))
+
+
+def test_is_scipy_sparse():
+    sp_sparse = pytest.importorskip("scipy.sparse")
+
+    assert com.is_scipy_sparse(sp_sparse.bsr_matrix([1, 2, 3]))
+
+    assert not com.is_scipy_sparse(SparseArray([1, 2, 3]))
+
+
+def test_is_datetime64_dtype():
+    assert not com.is_datetime64_dtype(object)
+    assert not com.is_datetime64_dtype([1, 2, 3])
+    assert not com.is_datetime64_dtype(np.array([], dtype=int))
+
+    assert com.is_datetime64_dtype(np.datetime64)
+    assert com.is_datetime64_dtype(np.array([], dtype=np.datetime64))
+
+
+def test_is_datetime64tz_dtype():
+    msg = "is_datetime64tz_dtype is deprecated"
+    with tm.assert_produces_warning(DeprecationWarning, match=msg):
+        assert not com.is_datetime64tz_dtype(object)
+        assert not com.is_datetime64tz_dtype([1, 2, 3])
+        assert not com.is_datetime64tz_dtype(pd.DatetimeIndex([1, 2, 3]))
+        assert com.is_datetime64tz_dtype(pd.DatetimeIndex(["2000"], tz="US/Eastern"))
+
+
+def test_custom_ea_kind_M_not_datetime64tz():
+    # GH 34986
+    class NotTZDtype(ExtensionDtype):
+        @property
+        def kind(self) -> str:
+            return "M"
+
+    not_tz_dtype = NotTZDtype()
+    msg = "is_datetime64tz_dtype is deprecated"
+    with tm.assert_produces_warning(DeprecationWarning, match=msg):
+        assert not com.is_datetime64tz_dtype(not_tz_dtype)
+        assert not com.needs_i8_conversion(not_tz_dtype)
+
+
+def test_is_timedelta64_dtype():
+    assert not com.is_timedelta64_dtype(object)
+    assert not com.is_timedelta64_dtype(None)
+    assert not com.is_timedelta64_dtype([1, 2, 3])
+    assert not com.is_timedelta64_dtype(np.array([], dtype=np.datetime64))
+    assert not com.is_timedelta64_dtype("0 days")
+    assert not com.is_timedelta64_dtype("0 days 00:00:00")
+    assert not com.is_timedelta64_dtype(["0 days 00:00:00"])
+    assert not com.is_timedelta64_dtype("NO DATE")
+
+    assert com.is_timedelta64_dtype(np.timedelta64)
+    assert com.is_timedelta64_dtype(pd.Series([], dtype="timedelta64[ns]"))
+    assert com.is_timedelta64_dtype(pd.to_timedelta(["0 days", "1 days"]))
+
+
+def test_is_period_dtype():
+    msg = "is_period_dtype is deprecated"
+    with tm.assert_produces_warning(DeprecationWarning, match=msg):
+        assert not com.is_period_dtype(object)
+        assert not com.is_period_dtype([1, 2, 3])
+        assert not com.is_period_dtype(pd.Period("2017-01-01"))
+
+        assert com.is_period_dtype(PeriodDtype(freq="D"))
+        assert com.is_period_dtype(pd.PeriodIndex([], freq="Y"))
+
+
+def test_is_interval_dtype():
+    msg = "is_interval_dtype is deprecated"
+    with tm.assert_produces_warning(DeprecationWarning, match=msg):
+        assert not com.is_interval_dtype(object)
+        assert not com.is_interval_dtype([1, 2, 3])
+
+        assert com.is_interval_dtype(IntervalDtype())
+
+        interval = pd.Interval(1, 2, closed="right")
+        assert not com.is_interval_dtype(interval)
+        assert com.is_interval_dtype(pd.IntervalIndex([interval]))
+
+
+def test_is_categorical_dtype():
+    msg = "is_categorical_dtype is deprecated"
+    with tm.assert_produces_warning(DeprecationWarning, match=msg):
+        assert not com.is_categorical_dtype(object)
+        assert not com.is_categorical_dtype([1, 2, 3])
+
+        assert com.is_categorical_dtype(CategoricalDtype())
+        assert com.is_categorical_dtype(pd.Categorical([1, 2, 3]))
+        assert com.is_categorical_dtype(pd.CategoricalIndex([1, 2, 3]))
+
+
+@pytest.mark.parametrize(
+    "dtype, expected",
+    [
+        (int, False),
+        (pd.Series([1, 2]), False),
+        (str, True),
+        (object, True),
+        (np.array(["a", "b"]), True),
+        (pd.StringDtype(), True),
+        (pd.Index([], dtype="O"), True),
+    ],
+)
+def test_is_string_dtype(dtype, expected):
+    # GH#54661
+
+    result = com.is_string_dtype(dtype)
+    assert result is expected
+
+
+@pytest.mark.parametrize(
+    "data",
+    [[(0, 1), (1, 1)], pd.Categorical([1, 2, 3]), np.array([1, 2], dtype=object)],
+)
+def test_is_string_dtype_arraylike_with_object_elements_not_strings(data):
+    # GH 15585
+    assert not com.is_string_dtype(pd.Series(data))
+
+
+def test_is_string_dtype_nullable(nullable_string_dtype):
+    assert com.is_string_dtype(pd.array(["a", "b"], dtype=nullable_string_dtype))
+
+
+integer_dtypes: list = []
+
+
+@pytest.mark.parametrize(
+    "dtype",
+    integer_dtypes
+    + [pd.Series([1, 2])]
+    + tm.ALL_INT_NUMPY_DTYPES
+    + to_numpy_dtypes(tm.ALL_INT_NUMPY_DTYPES)
+    + tm.ALL_INT_EA_DTYPES
+    + to_ea_dtypes(tm.ALL_INT_EA_DTYPES),
+)
+def test_is_integer_dtype(dtype):
+    assert com.is_integer_dtype(dtype)
+
+
+@pytest.mark.parametrize(
+    "dtype",
+    [
+        str,
+        float,
+        np.datetime64,
+        np.timedelta64,
+        pd.Index([1, 2.0]),
+        np.array(["a", "b"]),
+        np.array([], dtype=np.timedelta64),
+    ],
+)
+def test_is_not_integer_dtype(dtype):
+    assert not com.is_integer_dtype(dtype)
+
+
+signed_integer_dtypes: list = []
+
+
+@pytest.mark.parametrize(
+    "dtype",
+    signed_integer_dtypes
+    + [pd.Series([1, 2])]
+    + tm.SIGNED_INT_NUMPY_DTYPES
+    + to_numpy_dtypes(tm.SIGNED_INT_NUMPY_DTYPES)
+    + tm.SIGNED_INT_EA_DTYPES
+    + to_ea_dtypes(tm.SIGNED_INT_EA_DTYPES),
+)
+def test_is_signed_integer_dtype(dtype):
+    assert com.is_integer_dtype(dtype)
+
+
+@pytest.mark.parametrize(
+    "dtype",
+    [
+        str,
+        float,
+        np.datetime64,
+        np.timedelta64,
+        pd.Index([1, 2.0]),
+        np.array(["a", "b"]),
+        np.array([], dtype=np.timedelta64),
+    ]
+    + tm.UNSIGNED_INT_NUMPY_DTYPES
+    + to_numpy_dtypes(tm.UNSIGNED_INT_NUMPY_DTYPES)
+    + tm.UNSIGNED_INT_EA_DTYPES
+    + to_ea_dtypes(tm.UNSIGNED_INT_EA_DTYPES),
+)
+def test_is_not_signed_integer_dtype(dtype):
+    assert not com.is_signed_integer_dtype(dtype)
+
+
+unsigned_integer_dtypes: list = []
+
+
+@pytest.mark.parametrize(
+    "dtype",
+    unsigned_integer_dtypes
+    + [pd.Series([1, 2], dtype=np.uint32)]
+    + tm.UNSIGNED_INT_NUMPY_DTYPES
+    + to_numpy_dtypes(tm.UNSIGNED_INT_NUMPY_DTYPES)
+    + tm.UNSIGNED_INT_EA_DTYPES
+    + to_ea_dtypes(tm.UNSIGNED_INT_EA_DTYPES),
+)
+def test_is_unsigned_integer_dtype(dtype):
+    assert com.is_unsigned_integer_dtype(dtype)
+
+
+@pytest.mark.parametrize(
+    "dtype",
+    [
+        str,
+        float,
+        np.datetime64,
+        np.timedelta64,
+        pd.Index([1, 2.0]),
+        np.array(["a", "b"]),
+        np.array([], dtype=np.timedelta64),
+    ]
+    + tm.SIGNED_INT_NUMPY_DTYPES
+    + to_numpy_dtypes(tm.SIGNED_INT_NUMPY_DTYPES)
+    + tm.SIGNED_INT_EA_DTYPES
+    + to_ea_dtypes(tm.SIGNED_INT_EA_DTYPES),
+)
+def test_is_not_unsigned_integer_dtype(dtype):
+    assert not com.is_unsigned_integer_dtype(dtype)
+
+
+@pytest.mark.parametrize(
+    "dtype", [np.int64, np.array([1, 2], dtype=np.int64), "Int64", pd.Int64Dtype]
+)
+def test_is_int64_dtype(dtype):
+    msg = "is_int64_dtype is deprecated"
+    with tm.assert_produces_warning(DeprecationWarning, match=msg):
+        assert com.is_int64_dtype(dtype)
+
+
+def test_type_comparison_with_numeric_ea_dtype(any_numeric_ea_dtype):
+    # GH#43038
+    assert pandas_dtype(any_numeric_ea_dtype) == any_numeric_ea_dtype
+
+
+def test_type_comparison_with_real_numpy_dtype(any_real_numpy_dtype):
+    # GH#43038
+    assert pandas_dtype(any_real_numpy_dtype) == any_real_numpy_dtype
+
+
+def test_type_comparison_with_signed_int_ea_dtype_and_signed_int_numpy_dtype(
+    any_signed_int_ea_dtype, any_signed_int_numpy_dtype
+):
+    # GH#43038
+    assert not pandas_dtype(any_signed_int_ea_dtype) == any_signed_int_numpy_dtype
+
+
+@pytest.mark.parametrize(
+    "dtype",
+    [
+        str,
+        float,
+        np.int32,
+        np.uint64,
+        pd.Index([1, 2.0]),
+        np.array(["a", "b"]),
+        np.array([1, 2], dtype=np.uint32),
+        "int8",
+        "Int8",
+        pd.Int8Dtype,
+    ],
+)
+def test_is_not_int64_dtype(dtype):
+    msg = "is_int64_dtype is deprecated"
+    with tm.assert_produces_warning(DeprecationWarning, match=msg):
+        assert not com.is_int64_dtype(dtype)
+
+
+def test_is_datetime64_any_dtype():
+    assert not com.is_datetime64_any_dtype(int)
+    assert not com.is_datetime64_any_dtype(str)
+    assert not com.is_datetime64_any_dtype(np.array([1, 2]))
+    assert not com.is_datetime64_any_dtype(np.array(["a", "b"]))
+
+    assert com.is_datetime64_any_dtype(np.datetime64)
+    assert com.is_datetime64_any_dtype(np.array([], dtype=np.datetime64))
+    assert com.is_datetime64_any_dtype(DatetimeTZDtype("ns", "US/Eastern"))
+    assert com.is_datetime64_any_dtype(
+        pd.DatetimeIndex([1, 2, 3], dtype="datetime64[ns]")
+    )
+
+
+def test_is_datetime64_ns_dtype():
+    assert not com.is_datetime64_ns_dtype(int)
+    assert not com.is_datetime64_ns_dtype(str)
+    assert not com.is_datetime64_ns_dtype(np.datetime64)
+    assert not com.is_datetime64_ns_dtype(np.array([1, 2]))
+    assert not com.is_datetime64_ns_dtype(np.array(["a", "b"]))
+    assert not com.is_datetime64_ns_dtype(np.array([], dtype=np.datetime64))
+
+    # This datetime array has the wrong unit (ps instead of ns)
+    assert not com.is_datetime64_ns_dtype(np.array([], dtype="datetime64[ps]"))
+
+    assert com.is_datetime64_ns_dtype(DatetimeTZDtype("ns", "US/Eastern"))
+    assert com.is_datetime64_ns_dtype(
+        pd.DatetimeIndex([1, 2, 3], dtype=np.dtype("datetime64[ns]"))
+    )
+
+    # non-nano dt64tz
+    assert not com.is_datetime64_ns_dtype(DatetimeTZDtype("us", "US/Eastern"))
+
+
+def test_is_timedelta64_ns_dtype():
+    assert not com.is_timedelta64_ns_dtype(np.dtype("m8[ps]"))
+    assert not com.is_timedelta64_ns_dtype(np.array([1, 2], dtype=np.timedelta64))
+
+    assert com.is_timedelta64_ns_dtype(np.dtype("m8[ns]"))
+    assert com.is_timedelta64_ns_dtype(np.array([1, 2], dtype="m8[ns]"))
+
+
+def test_is_numeric_v_string_like():
+    assert not com.is_numeric_v_string_like(np.array([1]), 1)
+    assert not com.is_numeric_v_string_like(np.array([1]), np.array([2]))
+    assert not com.is_numeric_v_string_like(np.array(["foo"]), np.array(["foo"]))
+
+    assert com.is_numeric_v_string_like(np.array([1]), "foo")
+    assert com.is_numeric_v_string_like(np.array([1, 2]), np.array(["foo"]))
+    assert com.is_numeric_v_string_like(np.array(["foo"]), np.array([1, 2]))
+
+
+def test_needs_i8_conversion():
+    assert not com.needs_i8_conversion(str)
+    assert not com.needs_i8_conversion(np.int64)
+    assert not com.needs_i8_conversion(pd.Series([1, 2]))
+    assert not com.needs_i8_conversion(np.array(["a", "b"]))
+
+    assert not com.needs_i8_conversion(np.datetime64)
+    assert com.needs_i8_conversion(np.dtype(np.datetime64))
+    assert not com.needs_i8_conversion(pd.Series([], dtype="timedelta64[ns]"))
+    assert com.needs_i8_conversion(pd.Series([], dtype="timedelta64[ns]").dtype)
+    assert not com.needs_i8_conversion(pd.DatetimeIndex(["2000"], tz="US/Eastern"))
+    assert com.needs_i8_conversion(pd.DatetimeIndex(["2000"], tz="US/Eastern").dtype)
+
+
+def test_is_numeric_dtype():
+    assert not com.is_numeric_dtype(str)
+    assert not com.is_numeric_dtype(np.datetime64)
+    assert not com.is_numeric_dtype(np.timedelta64)
+    assert not com.is_numeric_dtype(np.array(["a", "b"]))
+    assert not com.is_numeric_dtype(np.array([], dtype=np.timedelta64))
+
+    assert com.is_numeric_dtype(int)
+    assert com.is_numeric_dtype(float)
+    assert com.is_numeric_dtype(np.uint64)
+    assert com.is_numeric_dtype(pd.Series([1, 2]))
+    assert com.is_numeric_dtype(pd.Index([1, 2.0]))
+
+    class MyNumericDType(ExtensionDtype):
+        @property
+        def type(self):
+            return str
+
+        @property
+        def name(self):
+            raise NotImplementedError
+
+        @classmethod
+        def construct_array_type(cls):
+            raise NotImplementedError
+
+        def _is_numeric(self) -> bool:
+            return True
+
+    assert com.is_numeric_dtype(MyNumericDType())
+
+
+def test_is_any_real_numeric_dtype():
+    assert not com.is_any_real_numeric_dtype(str)
+    assert not com.is_any_real_numeric_dtype(bool)
+    assert not com.is_any_real_numeric_dtype(complex)
+    assert not com.is_any_real_numeric_dtype(object)
+    assert not com.is_any_real_numeric_dtype(np.datetime64)
+    assert not com.is_any_real_numeric_dtype(np.array(["a", "b", complex(1, 2)]))
+    assert not com.is_any_real_numeric_dtype(pd.DataFrame([complex(1, 2), True]))
+
+    assert com.is_any_real_numeric_dtype(int)
+    assert com.is_any_real_numeric_dtype(float)
+    assert com.is_any_real_numeric_dtype(np.array([1, 2.5]))
+
+
+def test_is_float_dtype():
+    assert not com.is_float_dtype(str)
+    assert not com.is_float_dtype(int)
+    assert not com.is_float_dtype(pd.Series([1, 2]))
+    assert not com.is_float_dtype(np.array(["a", "b"]))
+
+    assert com.is_float_dtype(float)
+    assert com.is_float_dtype(pd.Index([1, 2.0]))
+
+
+def test_is_bool_dtype():
+    assert not com.is_bool_dtype(int)
+    assert not com.is_bool_dtype(str)
+    assert not com.is_bool_dtype(pd.Series([1, 2]))
+    assert not com.is_bool_dtype(pd.Series(["a", "b"], dtype="category"))
+    assert not com.is_bool_dtype(np.array(["a", "b"]))
+    assert not com.is_bool_dtype(pd.Index(["a", "b"]))
+    assert not com.is_bool_dtype("Int64")
+
+    assert com.is_bool_dtype(bool)
+    assert com.is_bool_dtype(np.bool_)
+    assert com.is_bool_dtype(pd.Series([True, False], dtype="category"))
+    assert com.is_bool_dtype(np.array([True, False]))
+    assert com.is_bool_dtype(pd.Index([True, False]))
+
+    assert com.is_bool_dtype(pd.BooleanDtype())
+    assert com.is_bool_dtype(pd.array([True, False, None], dtype="boolean"))
+    assert com.is_bool_dtype("boolean")
+
+
+def test_is_bool_dtype_numpy_error():
+    # GH39010
+    assert not com.is_bool_dtype("0 - Name")
+
+
+@pytest.mark.parametrize(
+    "check_scipy", [False, pytest.param(True, marks=td.skip_if_no("scipy"))]
+)
+def test_is_extension_array_dtype(check_scipy):
+    assert not com.is_extension_array_dtype([1, 2, 3])
+    assert not com.is_extension_array_dtype(np.array([1, 2, 3]))
+    assert not com.is_extension_array_dtype(pd.DatetimeIndex([1, 2, 3]))
+
+    cat = pd.Categorical([1, 2, 3])
+    assert com.is_extension_array_dtype(cat)
+    assert com.is_extension_array_dtype(pd.Series(cat))
+    assert com.is_extension_array_dtype(SparseArray([1, 2, 3]))
+    assert com.is_extension_array_dtype(pd.DatetimeIndex(["2000"], tz="US/Eastern"))
+
+    dtype = DatetimeTZDtype("ns", tz="US/Eastern")
+    s = pd.Series([], dtype=dtype)
+    assert com.is_extension_array_dtype(s)
+
+    if check_scipy:
+        import scipy.sparse
+
+        assert not com.is_extension_array_dtype(scipy.sparse.bsr_matrix([1, 2, 3]))
+
+
+def test_is_complex_dtype():
+    assert not com.is_complex_dtype(int)
+    assert not com.is_complex_dtype(str)
+    assert not com.is_complex_dtype(pd.Series([1, 2]))
+    assert not com.is_complex_dtype(np.array(["a", "b"]))
+
+    assert com.is_complex_dtype(np.complex128)
+    assert com.is_complex_dtype(complex)
+    assert com.is_complex_dtype(np.array([1 + 1j, 5]))
+
+
+@pytest.mark.parametrize(
+    "input_param,result",
+    [
+        (int, np.dtype(int)),
+        ("int32", np.dtype("int32")),
+        (float, np.dtype(float)),
+        ("float64", np.dtype("float64")),
+        (np.dtype("float64"), np.dtype("float64")),
+        (str, np.dtype(str)),
+        (pd.Series([1, 2], dtype=np.dtype("int16")), np.dtype("int16")),
+        (pd.Series(["a", "b"], dtype=object), np.dtype(object)),
+        (pd.Index([1, 2]), np.dtype("int64")),
+        (pd.Index(["a", "b"], dtype=object), np.dtype(object)),
+        ("category", "category"),
+        (pd.Categorical(["a", "b"]).dtype, CategoricalDtype(["a", "b"])),
+        (pd.Categorical(["a", "b"]), CategoricalDtype(["a", "b"])),
+        (pd.CategoricalIndex(["a", "b"]).dtype, CategoricalDtype(["a", "b"])),
+        (pd.CategoricalIndex(["a", "b"]), CategoricalDtype(["a", "b"])),
+        (CategoricalDtype(), CategoricalDtype()),
+        (pd.DatetimeIndex([1, 2]), np.dtype("=M8[ns]")),
+        (pd.DatetimeIndex([1, 2]).dtype, np.dtype("=M8[ns]")),
+        ("<M8[ns]", np.dtype("<M8[ns]")),
+        ("datetime64[ns, Europe/London]", DatetimeTZDtype("ns", "Europe/London")),
+        (PeriodDtype(freq="D"), PeriodDtype(freq="D")),
+        ("period[D]", PeriodDtype(freq="D")),
+        (IntervalDtype(), IntervalDtype()),
+    ],
+)
+def test_get_dtype(input_param, result):
+    assert com._get_dtype(input_param) == result
+
+
+@pytest.mark.parametrize(
+    "input_param,expected_error_message",
+    [
+        (None, "Cannot deduce dtype from null object"),
+        (1, "data type not understood"),
+        (1.2, "data type not understood"),
+        # numpy dev changed from double-quotes to single quotes
+        ("random string", "data type [\"']random string[\"'] not understood"),
+        (pd.DataFrame([1, 2]), "data type not understood"),
+    ],
+)
+def test_get_dtype_fails(input_param, expected_error_message):
+    # python objects
+    # 2020-02-02 npdev changed error message
+    expected_error_message += f"|Cannot interpret '{input_param}' as a data type"
+    with pytest.raises(TypeError, match=expected_error_message):
+        com._get_dtype(input_param)
+
+
+@pytest.mark.parametrize(
+    "input_param,result",
+    [
+        (int, np.dtype(int).type),
+        ("int32", np.int32),
+        (float, np.dtype(float).type),
+        ("float64", np.float64),
+        (np.dtype("float64"), np.float64),
+        (str, np.dtype(str).type),
+        (pd.Series([1, 2], dtype=np.dtype("int16")), np.int16),
+        (pd.Series(["a", "b"], dtype=object), np.object_),
+        (pd.Index([1, 2], dtype="int64"), np.int64),
+        (pd.Index(["a", "b"], dtype=object), np.object_),
+        ("category", CategoricalDtypeType),
+        (pd.Categorical(["a", "b"]).dtype, CategoricalDtypeType),
+        (pd.Categorical(["a", "b"]), CategoricalDtypeType),
+        (pd.CategoricalIndex(["a", "b"]).dtype, CategoricalDtypeType),
+        (pd.CategoricalIndex(["a", "b"]), CategoricalDtypeType),
+        (pd.DatetimeIndex([1, 2]), np.datetime64),
+        (pd.DatetimeIndex([1, 2]).dtype, np.datetime64),
+        ("<M8[ns]", np.datetime64),
+        (pd.DatetimeIndex(["2000"], tz="Europe/London"), pd.Timestamp),
+        (pd.DatetimeIndex(["2000"], tz="Europe/London").dtype, pd.Timestamp),
+        ("datetime64[ns, Europe/London]", pd.Timestamp),
+        (PeriodDtype(freq="D"), pd.Period),
+        ("period[D]", pd.Period),
+        (IntervalDtype(), pd.Interval),
+        (None, type(None)),
+        (1, type(None)),
+        (1.2, type(None)),
+        (pd.DataFrame([1, 2]), type(None)),  # composite dtype
+    ],
+)
+def test__is_dtype_type(input_param, result):
+    assert com._is_dtype_type(input_param, lambda tipo: tipo == result)
+
+
+def test_astype_nansafe_copy_false(any_int_numpy_dtype):
+    # GH#34457 use astype, not view
+    arr = np.array([1, 2, 3], dtype=any_int_numpy_dtype)
+
+    dtype = np.dtype("float64")
+    result = astype_array(arr, dtype, copy=False)
+
+    expected = np.array([1.0, 2.0, 3.0], dtype=dtype)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("from_type", [np.datetime64, np.timedelta64])
+def test_astype_object_preserves_datetime_na(from_type):
+    arr = np.array([from_type("NaT", "ns")])
+    result = astype_array(arr, dtype=np.dtype("object"))
+
+    assert isna(result)[0]
+
+
+def test_validate_allhashable():
+    assert com.validate_all_hashable(1, "a") is None
+
+    with pytest.raises(TypeError, match="All elements must be hashable"):
+        com.validate_all_hashable([])
+
+    with pytest.raises(TypeError, match="list must be a hashable type"):
+        com.validate_all_hashable([], error_name="list")
+
+
+def test_pandas_dtype_numpy_warning():
+    # GH#51523
+    with tm.assert_produces_warning(
+        DeprecationWarning,
+        check_stacklevel=False,
+        match="Converting `np.integer` or `np.signedinteger` to a dtype is deprecated",
+    ):
+        pandas_dtype(np.integer)
+
+
+def test_pandas_dtype_ea_not_instance():
+    # GH 31356 GH 54592
+    with tm.assert_produces_warning(UserWarning):
+        assert pandas_dtype(CategoricalDtype) == CategoricalDtype()

mantis_evalkit/lib/python3.10/site-packages/pandas/tests/dtypes/test_concat.py

@@ -0,0 +1,51 @@
+import pytest
+
+import pandas.core.dtypes.concat as _concat
+
+import pandas as pd
+from pandas import Series
+import pandas._testing as tm
+
+
+def test_concat_mismatched_categoricals_with_empty():
+    # concat_compat behavior on series._values should match pd.concat on series
+    ser1 = Series(["a", "b", "c"], dtype="category")
+    ser2 = Series([], dtype="category")
+
+    msg = "The behavior of array concatenation with empty entries is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = _concat.concat_compat([ser1._values, ser2._values])
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        expected = pd.concat([ser1, ser2])._values
+    tm.assert_categorical_equal(result, expected)
+
+
+@pytest.mark.parametrize("copy", [True, False])
+def test_concat_single_dataframe_tz_aware(copy):
+    # https://github.com/pandas-dev/pandas/issues/25257
+    df = pd.DataFrame(
+        {"timestamp": [pd.Timestamp("2020-04-08 09:00:00.709949+0000", tz="UTC")]}
+    )
+    expected = df.copy()
+    result = pd.concat([df], copy=copy)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_concat_periodarray_2d():
+    pi = pd.period_range("2016-01-01", periods=36, freq="D")
+    arr = pi._data.reshape(6, 6)
+
+    result = _concat.concat_compat([arr[:2], arr[2:]], axis=0)
+    tm.assert_period_array_equal(result, arr)
+
+    result = _concat.concat_compat([arr[:, :2], arr[:, 2:]], axis=1)
+    tm.assert_period_array_equal(result, arr)
+
+    msg = (
+        "all the input array dimensions.* for the concatenation axis must match exactly"
+    )
+    with pytest.raises(ValueError, match=msg):
+        _concat.concat_compat([arr[:, :2], arr[:, 2:]], axis=0)
+
+    with pytest.raises(ValueError, match=msg):
+        _concat.concat_compat([arr[:2], arr[2:]], axis=1)

mantis_evalkit/lib/python3.10/site-packages/pandas/tests/dtypes/test_dtypes.py

@@ -0,0 +1,1234 @@
+import re
+import weakref
+
+import numpy as np
+import pytest
+import pytz
+
+from pandas._libs.tslibs.dtypes import NpyDatetimeUnit
+
+from pandas.core.dtypes.base import _registry as registry
+from pandas.core.dtypes.common import (
+    is_bool_dtype,
+    is_categorical_dtype,
+    is_datetime64_any_dtype,
+    is_datetime64_dtype,
+    is_datetime64_ns_dtype,
+    is_datetime64tz_dtype,
+    is_dtype_equal,
+    is_interval_dtype,
+    is_period_dtype,
+    is_string_dtype,
+)
+from pandas.core.dtypes.dtypes import (
+    CategoricalDtype,
+    DatetimeTZDtype,
+    IntervalDtype,
+    PeriodDtype,
+)
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    CategoricalIndex,
+    DatetimeIndex,
+    IntervalIndex,
+    Series,
+    SparseDtype,
+    date_range,
+)
+import pandas._testing as tm
+from pandas.core.arrays.sparse import SparseArray
+
+
+class Base:
+    def test_hash(self, dtype):
+        hash(dtype)
+
+    def test_equality_invalid(self, dtype):
+        assert not dtype == "foo"
+        assert not is_dtype_equal(dtype, np.int64)
+
+    def test_numpy_informed(self, dtype):
+        # npdev 2020-02-02 changed from "data type not understood" to
+        #  "Cannot interpret 'foo' as a data type"
+        msg = "|".join(
+            ["data type not understood", "Cannot interpret '.*' as a data type"]
+        )
+        with pytest.raises(TypeError, match=msg):
+            np.dtype(dtype)
+
+        assert not dtype == np.str_
+        assert not np.str_ == dtype
+
+    def test_pickle(self, dtype):
+        # make sure our cache is NOT pickled
+
+        # clear the cache
+        type(dtype).reset_cache()
+        assert not len(dtype._cache_dtypes)
+
+        # force back to the cache
+        result = tm.round_trip_pickle(dtype)
+        if not isinstance(dtype, PeriodDtype):
+            # Because PeriodDtype has a cython class as a base class,
+            #  it has different pickle semantics, and its cache is re-populated
+            #  on un-pickling.
+            assert not len(dtype._cache_dtypes)
+        assert result == dtype
+
+
+class TestCategoricalDtype(Base):
+    @pytest.fixture
+    def dtype(self):
+        """
+        Class level fixture of dtype for TestCategoricalDtype
+        """
+        return CategoricalDtype()
+
+    def test_hash_vs_equality(self, dtype):
+        dtype2 = CategoricalDtype()
+        assert dtype == dtype2
+        assert dtype2 == dtype
+        assert hash(dtype) == hash(dtype2)
+
+    def test_equality(self, dtype):
+        assert dtype == "category"
+        assert is_dtype_equal(dtype, "category")
+        assert "category" == dtype
+        assert is_dtype_equal("category", dtype)
+
+        assert dtype == CategoricalDtype()
+        assert is_dtype_equal(dtype, CategoricalDtype())
+        assert CategoricalDtype() == dtype
+        assert is_dtype_equal(CategoricalDtype(), dtype)
+
+        assert dtype != "foo"
+        assert not is_dtype_equal(dtype, "foo")
+        assert "foo" != dtype
+        assert not is_dtype_equal("foo", dtype)
+
+    def test_construction_from_string(self, dtype):
+        result = CategoricalDtype.construct_from_string("category")
+        assert is_dtype_equal(dtype, result)
+        msg = "Cannot construct a 'CategoricalDtype' from 'foo'"
+        with pytest.raises(TypeError, match=msg):
+            CategoricalDtype.construct_from_string("foo")
+
+    def test_constructor_invalid(self):
+        msg = "Parameter 'categories' must be list-like"
+        with pytest.raises(TypeError, match=msg):
+            CategoricalDtype("category")
+
+    dtype1 = CategoricalDtype(["a", "b"], ordered=True)
+    dtype2 = CategoricalDtype(["x", "y"], ordered=False)
+    c = Categorical([0, 1], dtype=dtype1)
+
+    @pytest.mark.parametrize(
+        "values, categories, ordered, dtype, expected",
+        [
+            [None, None, None, None, CategoricalDtype()],
+            [None, ["a", "b"], True, None, dtype1],
+            [c, None, None, dtype2, dtype2],
+            [c, ["x", "y"], False, None, dtype2],
+        ],
+    )
+    def test_from_values_or_dtype(self, values, categories, ordered, dtype, expected):
+        result = CategoricalDtype._from_values_or_dtype(
+            values, categories, ordered, dtype
+        )
+        assert result == expected
+
+    @pytest.mark.parametrize(
+        "values, categories, ordered, dtype",
+        [
+            [None, ["a", "b"], True, dtype2],
+            [None, ["a", "b"], None, dtype2],
+            [None, None, True, dtype2],
+        ],
+    )
+    def test_from_values_or_dtype_raises(self, values, categories, ordered, dtype):
+        msg = "Cannot specify `categories` or `ordered` together with `dtype`."
+        with pytest.raises(ValueError, match=msg):
+            CategoricalDtype._from_values_or_dtype(values, categories, ordered, dtype)
+
+    def test_from_values_or_dtype_invalid_dtype(self):
+        msg = "Cannot not construct CategoricalDtype from <class 'object'>"
+        with pytest.raises(ValueError, match=msg):
+            CategoricalDtype._from_values_or_dtype(None, None, None, object)
+
+    def test_is_dtype(self, dtype):
+        assert CategoricalDtype.is_dtype(dtype)
+        assert CategoricalDtype.is_dtype("category")
+        assert CategoricalDtype.is_dtype(CategoricalDtype())
+        assert not CategoricalDtype.is_dtype("foo")
+        assert not CategoricalDtype.is_dtype(np.float64)
+
+    def test_basic(self, dtype):
+        msg = "is_categorical_dtype is deprecated"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            assert is_categorical_dtype(dtype)
+
+            factor = Categorical(["a", "b", "b", "a", "a", "c", "c", "c"])
+
+            s = Series(factor, name="A")
+
+            # dtypes
+            assert is_categorical_dtype(s.dtype)
+            assert is_categorical_dtype(s)
+            assert not is_categorical_dtype(np.dtype("float64"))
+
+    def test_tuple_categories(self):
+        categories = [(1, "a"), (2, "b"), (3, "c")]
+        result = CategoricalDtype(categories)
+        assert all(result.categories == categories)
+
+    @pytest.mark.parametrize(
+        "categories, expected",
+        [
+            ([True, False], True),
+            ([True, False, None], True),
+            ([True, False, "a", "b'"], False),
+            ([0, 1], False),
+        ],
+    )
+    def test_is_boolean(self, categories, expected):
+        cat = Categorical(categories)
+        assert cat.dtype._is_boolean is expected
+        assert is_bool_dtype(cat) is expected
+        assert is_bool_dtype(cat.dtype) is expected
+
+    def test_dtype_specific_categorical_dtype(self):
+        expected = "datetime64[ns]"
+        dti = DatetimeIndex([], dtype=expected)
+        result = str(Categorical(dti).categories.dtype)
+        assert result == expected
+
+    def test_not_string(self):
+        # though CategoricalDtype has object kind, it cannot be string
+        assert not is_string_dtype(CategoricalDtype())
+
+    def test_repr_range_categories(self):
+        rng = pd.Index(range(3))
+        dtype = CategoricalDtype(categories=rng, ordered=False)
+        result = repr(dtype)
+
+        expected = (
+            "CategoricalDtype(categories=range(0, 3), ordered=False, "
+            "categories_dtype=int64)"
+        )
+        assert result == expected
+
+    def test_update_dtype(self):
+        # GH 27338
+        result = CategoricalDtype(["a"]).update_dtype(Categorical(["b"], ordered=True))
+        expected = CategoricalDtype(["b"], ordered=True)
+        assert result == expected
+
+    def test_repr(self):
+        cat = Categorical(pd.Index([1, 2, 3], dtype="int32"))
+        result = cat.dtype.__repr__()
+        expected = (
+            "CategoricalDtype(categories=[1, 2, 3], ordered=False, "
+            "categories_dtype=int32)"
+        )
+        assert result == expected
+
+
+class TestDatetimeTZDtype(Base):
+    @pytest.fixture
+    def dtype(self):
+        """
+        Class level fixture of dtype for TestDatetimeTZDtype
+        """
+        return DatetimeTZDtype("ns", "US/Eastern")
+
+    def test_alias_to_unit_raises(self):
+        # 23990
+        with pytest.raises(ValueError, match="Passing a dtype alias"):
+            DatetimeTZDtype("datetime64[ns, US/Central]")
+
+    def test_alias_to_unit_bad_alias_raises(self):
+        # 23990
+        with pytest.raises(TypeError, match=""):
+            DatetimeTZDtype("this is a bad string")
+
+        with pytest.raises(TypeError, match=""):
+            DatetimeTZDtype("datetime64[ns, US/NotATZ]")
+
+    def test_hash_vs_equality(self, dtype):
+        # make sure that we satisfy is semantics
+        dtype2 = DatetimeTZDtype("ns", "US/Eastern")
+        dtype3 = DatetimeTZDtype(dtype2)
+        assert dtype == dtype2
+        assert dtype2 == dtype
+        assert dtype3 == dtype
+        assert hash(dtype) == hash(dtype2)
+        assert hash(dtype) == hash(dtype3)
+
+        dtype4 = DatetimeTZDtype("ns", "US/Central")
+        assert dtype2 != dtype4
+        assert hash(dtype2) != hash(dtype4)
+
+    def test_construction_non_nanosecond(self):
+        res = DatetimeTZDtype("ms", "US/Eastern")
+        assert res.unit == "ms"
+        assert res._creso == NpyDatetimeUnit.NPY_FR_ms.value
+        assert res.str == "|M8[ms]"
+        assert str(res) == "datetime64[ms, US/Eastern]"
+        assert res.base == np.dtype("M8[ms]")
+
+    def test_day_not_supported(self):
+        msg = "DatetimeTZDtype only supports s, ms, us, ns units"
+        with pytest.raises(ValueError, match=msg):
+            DatetimeTZDtype("D", "US/Eastern")
+
+    def test_subclass(self):
+        a = DatetimeTZDtype.construct_from_string("datetime64[ns, US/Eastern]")
+        b = DatetimeTZDtype.construct_from_string("datetime64[ns, CET]")
+
+        assert issubclass(type(a), type(a))
+        assert issubclass(type(a), type(b))
+
+    def test_compat(self, dtype):
+        msg = "is_datetime64tz_dtype is deprecated"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            assert is_datetime64tz_dtype(dtype)
+            assert is_datetime64tz_dtype("datetime64[ns, US/Eastern]")
+        assert is_datetime64_any_dtype(dtype)
+        assert is_datetime64_any_dtype("datetime64[ns, US/Eastern]")
+        assert is_datetime64_ns_dtype(dtype)
+        assert is_datetime64_ns_dtype("datetime64[ns, US/Eastern]")
+        assert not is_datetime64_dtype(dtype)
+        assert not is_datetime64_dtype("datetime64[ns, US/Eastern]")
+
+    def test_construction_from_string(self, dtype):
+        result = DatetimeTZDtype.construct_from_string("datetime64[ns, US/Eastern]")
+        assert is_dtype_equal(dtype, result)
+
+    @pytest.mark.parametrize(
+        "string",
+        [
+            "foo",
+            "datetime64[ns, notatz]",
+            # non-nano unit
+            "datetime64[ps, UTC]",
+            # dateutil str that returns None from gettz
+            "datetime64[ns, dateutil/invalid]",
+        ],
+    )
+    def test_construct_from_string_invalid_raises(self, string):
+        msg = f"Cannot construct a 'DatetimeTZDtype' from '{string}'"
+        with pytest.raises(TypeError, match=re.escape(msg)):
+            DatetimeTZDtype.construct_from_string(string)
+
+    def test_construct_from_string_wrong_type_raises(self):
+        msg = "'construct_from_string' expects a string, got <class 'list'>"
+        with pytest.raises(TypeError, match=msg):
+            DatetimeTZDtype.construct_from_string(["datetime64[ns, notatz]"])
+
+    def test_is_dtype(self, dtype):
+        assert not DatetimeTZDtype.is_dtype(None)
+        assert DatetimeTZDtype.is_dtype(dtype)
+        assert DatetimeTZDtype.is_dtype("datetime64[ns, US/Eastern]")
+        assert DatetimeTZDtype.is_dtype("M8[ns, US/Eastern]")
+        assert not DatetimeTZDtype.is_dtype("foo")
+        assert DatetimeTZDtype.is_dtype(DatetimeTZDtype("ns", "US/Pacific"))
+        assert not DatetimeTZDtype.is_dtype(np.float64)
+
+    def test_equality(self, dtype):
+        assert is_dtype_equal(dtype, "datetime64[ns, US/Eastern]")
+        assert is_dtype_equal(dtype, "M8[ns, US/Eastern]")
+        assert is_dtype_equal(dtype, DatetimeTZDtype("ns", "US/Eastern"))
+        assert not is_dtype_equal(dtype, "foo")
+        assert not is_dtype_equal(dtype, DatetimeTZDtype("ns", "CET"))
+        assert not is_dtype_equal(
+            DatetimeTZDtype("ns", "US/Eastern"), DatetimeTZDtype("ns", "US/Pacific")
+        )
+
+        # numpy compat
+        assert is_dtype_equal(np.dtype("M8[ns]"), "datetime64[ns]")
+
+        assert dtype == "M8[ns, US/Eastern]"
+
+    def test_basic(self, dtype):
+        msg = "is_datetime64tz_dtype is deprecated"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            assert is_datetime64tz_dtype(dtype)
+
+        dr = date_range("20130101", periods=3, tz="US/Eastern")
+        s = Series(dr, name="A")
+
+        # dtypes
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            assert is_datetime64tz_dtype(s.dtype)
+            assert is_datetime64tz_dtype(s)
+            assert not is_datetime64tz_dtype(np.dtype("float64"))
+            assert not is_datetime64tz_dtype(1.0)
+
+    def test_dst(self):
+        dr1 = date_range("2013-01-01", periods=3, tz="US/Eastern")
+        s1 = Series(dr1, name="A")
+        assert isinstance(s1.dtype, DatetimeTZDtype)
+
+        dr2 = date_range("2013-08-01", periods=3, tz="US/Eastern")
+        s2 = Series(dr2, name="A")
+        assert isinstance(s2.dtype, DatetimeTZDtype)
+        assert s1.dtype == s2.dtype
+
+    @pytest.mark.parametrize("tz", ["UTC", "US/Eastern"])
+    @pytest.mark.parametrize("constructor", ["M8", "datetime64"])
+    def test_parser(self, tz, constructor):
+        # pr #11245
+        dtz_str = f"{constructor}[ns, {tz}]"
+        result = DatetimeTZDtype.construct_from_string(dtz_str)
+        expected = DatetimeTZDtype("ns", tz)
+        assert result == expected
+
+    def test_empty(self):
+        with pytest.raises(TypeError, match="A 'tz' is required."):
+            DatetimeTZDtype()
+
+    def test_tz_standardize(self):
+        # GH 24713
+        tz = pytz.timezone("US/Eastern")
+        dr = date_range("2013-01-01", periods=3, tz="US/Eastern")
+        dtype = DatetimeTZDtype("ns", dr.tz)
+        assert dtype.tz == tz
+        dtype = DatetimeTZDtype("ns", dr[0].tz)
+        assert dtype.tz == tz
+
+
+class TestPeriodDtype(Base):
+    @pytest.fixture
+    def dtype(self):
+        """
+        Class level fixture of dtype for TestPeriodDtype
+        """
+        return PeriodDtype("D")
+
+    def test_hash_vs_equality(self, dtype):
+        # make sure that we satisfy is semantics
+        dtype2 = PeriodDtype("D")
+        dtype3 = PeriodDtype(dtype2)
+        assert dtype == dtype2
+        assert dtype2 == dtype
+        assert dtype3 == dtype
+        assert dtype is not dtype2
+        assert dtype2 is not dtype
+        assert dtype3 is not dtype
+        assert hash(dtype) == hash(dtype2)
+        assert hash(dtype) == hash(dtype3)
+
+    def test_construction(self):
+        with pytest.raises(ValueError, match="Invalid frequency: xx"):
+            PeriodDtype("xx")
+
+        for s in ["period[D]", "Period[D]", "D"]:
+            dt = PeriodDtype(s)
+            assert dt.freq == pd.tseries.offsets.Day()
+
+        for s in ["period[3D]", "Period[3D]", "3D"]:
+            dt = PeriodDtype(s)
+            assert dt.freq == pd.tseries.offsets.Day(3)
+
+        for s in [
+            "period[26h]",
+            "Period[26h]",
+            "26h",
+            "period[1D2h]",
+            "Period[1D2h]",
+            "1D2h",
+        ]:
+            dt = PeriodDtype(s)
+            assert dt.freq == pd.tseries.offsets.Hour(26)
+
+    def test_cannot_use_custom_businessday(self):
+        # GH#52534
+        msg = "C is not supported as period frequency"
+        msg1 = "<CustomBusinessDay> is not supported as period frequency"
+        msg2 = r"PeriodDtype\[B\] is deprecated"
+        with pytest.raises(ValueError, match=msg):
+            PeriodDtype("C")
+        with pytest.raises(ValueError, match=msg1):
+            with tm.assert_produces_warning(FutureWarning, match=msg2):
+                PeriodDtype(pd.offsets.CustomBusinessDay())
+
+    def test_subclass(self):
+        a = PeriodDtype("period[D]")
+        b = PeriodDtype("period[3D]")
+
+        assert issubclass(type(a), type(a))
+        assert issubclass(type(a), type(b))
+
+    def test_identity(self):
+        assert PeriodDtype("period[D]") == PeriodDtype("period[D]")
+        assert PeriodDtype("period[D]") is not PeriodDtype("period[D]")
+
+        assert PeriodDtype("period[3D]") == PeriodDtype("period[3D]")
+        assert PeriodDtype("period[3D]") is not PeriodDtype("period[3D]")
+
+        assert PeriodDtype("period[1s1us]") == PeriodDtype("period[1000001us]")
+        assert PeriodDtype("period[1s1us]") is not PeriodDtype("period[1000001us]")
+
+    def test_compat(self, dtype):
+        assert not is_datetime64_ns_dtype(dtype)
+        assert not is_datetime64_ns_dtype("period[D]")
+        assert not is_datetime64_dtype(dtype)
+        assert not is_datetime64_dtype("period[D]")
+
+    def test_construction_from_string(self, dtype):
+        result = PeriodDtype("period[D]")
+        assert is_dtype_equal(dtype, result)
+        result = PeriodDtype.construct_from_string("period[D]")
+        assert is_dtype_equal(dtype, result)
+
+        with pytest.raises(TypeError, match="list"):
+            PeriodDtype.construct_from_string([1, 2, 3])
+
+    @pytest.mark.parametrize(
+        "string",
+        [
+            "foo",
+            "period[foo]",
+            "foo[D]",
+            "datetime64[ns]",
+            "datetime64[ns, US/Eastern]",
+        ],
+    )
+    def test_construct_dtype_from_string_invalid_raises(self, string):
+        msg = f"Cannot construct a 'PeriodDtype' from '{string}'"
+        with pytest.raises(TypeError, match=re.escape(msg)):
+            PeriodDtype.construct_from_string(string)
+
+    def test_is_dtype(self, dtype):
+        assert PeriodDtype.is_dtype(dtype)
+        assert PeriodDtype.is_dtype("period[D]")
+        assert PeriodDtype.is_dtype("period[3D]")
+        assert PeriodDtype.is_dtype(PeriodDtype("3D"))
+        assert PeriodDtype.is_dtype("period[us]")
+        assert PeriodDtype.is_dtype("period[s]")
+        assert PeriodDtype.is_dtype(PeriodDtype("us"))
+        assert PeriodDtype.is_dtype(PeriodDtype("s"))
+
+        assert not PeriodDtype.is_dtype("D")
+        assert not PeriodDtype.is_dtype("3D")
+        assert not PeriodDtype.is_dtype("U")
+        assert not PeriodDtype.is_dtype("s")
+        assert not PeriodDtype.is_dtype("foo")
+        assert not PeriodDtype.is_dtype(np.object_)
+        assert not PeriodDtype.is_dtype(np.int64)
+        assert not PeriodDtype.is_dtype(np.float64)
+
+    def test_equality(self, dtype):
+        assert is_dtype_equal(dtype, "period[D]")
+        assert is_dtype_equal(dtype, PeriodDtype("D"))
+        assert is_dtype_equal(dtype, PeriodDtype("D"))
+        assert is_dtype_equal(PeriodDtype("D"), PeriodDtype("D"))
+
+        assert not is_dtype_equal(dtype, "D")
+        assert not is_dtype_equal(PeriodDtype("D"), PeriodDtype("2D"))
+
+    def test_basic(self, dtype):
+        msg = "is_period_dtype is deprecated"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            assert is_period_dtype(dtype)
+
+            pidx = pd.period_range("2013-01-01 09:00", periods=5, freq="h")
+
+            assert is_period_dtype(pidx.dtype)
+            assert is_period_dtype(pidx)
+
+            s = Series(pidx, name="A")
+
+            assert is_period_dtype(s.dtype)
+            assert is_period_dtype(s)
+
+            assert not is_period_dtype(np.dtype("float64"))
+            assert not is_period_dtype(1.0)
+
+    def test_freq_argument_required(self):
+        # GH#27388
+        msg = "missing 1 required positional argument: 'freq'"
+        with pytest.raises(TypeError, match=msg):
+            PeriodDtype()
+
+        msg = "PeriodDtype argument should be string or BaseOffset, got NoneType"
+        with pytest.raises(TypeError, match=msg):
+            # GH#51790
+            PeriodDtype(None)
+
+    def test_not_string(self):
+        # though PeriodDtype has object kind, it cannot be string
+        assert not is_string_dtype(PeriodDtype("D"))
+
+    def test_perioddtype_caching_dateoffset_normalize(self):
+        # GH 24121
+        per_d = PeriodDtype(pd.offsets.YearEnd(normalize=True))
+        assert per_d.freq.normalize
+
+        per_d2 = PeriodDtype(pd.offsets.YearEnd(normalize=False))
+        assert not per_d2.freq.normalize
+
+    def test_dont_keep_ref_after_del(self):
+        # GH 54184
+        dtype = PeriodDtype("D")
+        ref = weakref.ref(dtype)
+        del dtype
+        assert ref() is None
+
+
+class TestIntervalDtype(Base):
+    @pytest.fixture
+    def dtype(self):
+        """
+        Class level fixture of dtype for TestIntervalDtype
+        """
+        return IntervalDtype("int64", "right")
+
+    def test_hash_vs_equality(self, dtype):
+        # make sure that we satisfy is semantics
+        dtype2 = IntervalDtype("int64", "right")
+        dtype3 = IntervalDtype(dtype2)
+        assert dtype == dtype2
+        assert dtype2 == dtype
+        assert dtype3 == dtype
+        assert dtype is not dtype2
+        assert dtype2 is not dtype3
+        assert dtype3 is not dtype
+        assert hash(dtype) == hash(dtype2)
+        assert hash(dtype) == hash(dtype3)
+
+        dtype1 = IntervalDtype("interval")
+        dtype2 = IntervalDtype(dtype1)
+        dtype3 = IntervalDtype("interval")
+        assert dtype2 == dtype1
+        assert dtype2 == dtype2
+        assert dtype2 == dtype3
+        assert dtype2 is not dtype1
+        assert dtype2 is dtype2
+        assert dtype2 is not dtype3
+        assert hash(dtype2) == hash(dtype1)
+        assert hash(dtype2) == hash(dtype2)
+        assert hash(dtype2) == hash(dtype3)
+
+    @pytest.mark.parametrize(
+        "subtype", ["interval[int64]", "Interval[int64]", "int64", np.dtype("int64")]
+    )
+    def test_construction(self, subtype):
+        i = IntervalDtype(subtype, closed="right")
+        assert i.subtype == np.dtype("int64")
+        msg = "is_interval_dtype is deprecated"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            assert is_interval_dtype(i)
+
+    @pytest.mark.parametrize(
+        "subtype", ["interval[int64]", "Interval[int64]", "int64", np.dtype("int64")]
+    )
+    def test_construction_allows_closed_none(self, subtype):
+        # GH#38394
+        dtype = IntervalDtype(subtype)
+
+        assert dtype.closed is None
+
+    def test_closed_mismatch(self):
+        msg = "'closed' keyword does not match value specified in dtype string"
+        with pytest.raises(ValueError, match=msg):
+            IntervalDtype("interval[int64, left]", "right")
+
+    @pytest.mark.parametrize("subtype", [None, "interval", "Interval"])
+    def test_construction_generic(self, subtype):
+        # generic
+        i = IntervalDtype(subtype)
+        assert i.subtype is None
+        msg = "is_interval_dtype is deprecated"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            assert is_interval_dtype(i)
+
+    @pytest.mark.parametrize(
+        "subtype",
+        [
+            CategoricalDtype(list("abc"), False),
+            CategoricalDtype(list("wxyz"), True),
+            object,
+            str,
+            "<U10",
+            "interval[category]",
+            "interval[object]",
+        ],
+    )
+    def test_construction_not_supported(self, subtype):
+        # GH 19016
+        msg = (
+            "category, object, and string subtypes are not supported "
+            "for IntervalDtype"
+        )
+        with pytest.raises(TypeError, match=msg):
+            IntervalDtype(subtype)
+
+    @pytest.mark.parametrize("subtype", ["xx", "IntervalA", "Interval[foo]"])
+    def test_construction_errors(self, subtype):
+        msg = "could not construct IntervalDtype"
+        with pytest.raises(TypeError, match=msg):
+            IntervalDtype(subtype)
+
+    def test_closed_must_match(self):
+        # GH#37933
+        dtype = IntervalDtype(np.float64, "left")
+
+        msg = "dtype.closed and 'closed' do not match"
+        with pytest.raises(ValueError, match=msg):
+            IntervalDtype(dtype, closed="both")
+
+    def test_closed_invalid(self):
+        with pytest.raises(ValueError, match="closed must be one of"):
+            IntervalDtype(np.float64, "foo")
+
+    def test_construction_from_string(self, dtype):
+        result = IntervalDtype("interval[int64, right]")
+        assert is_dtype_equal(dtype, result)
+        result = IntervalDtype.construct_from_string("interval[int64, right]")
+        assert is_dtype_equal(dtype, result)
+
+    @pytest.mark.parametrize("string", [0, 3.14, ("a", "b"), None])
+    def test_construction_from_string_errors(self, string):
+        # these are invalid entirely
+        msg = f"'construct_from_string' expects a string, got {type(string)}"
+
+        with pytest.raises(TypeError, match=re.escape(msg)):
+            IntervalDtype.construct_from_string(string)
+
+    @pytest.mark.parametrize("string", ["foo", "foo[int64]", "IntervalA"])
+    def test_construction_from_string_error_subtype(self, string):
+        # this is an invalid subtype
+        msg = (
+            "Incorrectly formatted string passed to constructor. "
+            r"Valid formats include Interval or Interval\[dtype\] "
+            "where dtype is numeric, datetime, or timedelta"
+        )
+
+        with pytest.raises(TypeError, match=msg):
+            IntervalDtype.construct_from_string(string)
+
+    def test_subclass(self):
+        a = IntervalDtype("interval[int64, right]")
+        b = IntervalDtype("interval[int64, right]")
+
+        assert issubclass(type(a), type(a))
+        assert issubclass(type(a), type(b))
+
+    def test_is_dtype(self, dtype):
+        assert IntervalDtype.is_dtype(dtype)
+        assert IntervalDtype.is_dtype("interval")
+        assert IntervalDtype.is_dtype(IntervalDtype("float64"))
+        assert IntervalDtype.is_dtype(IntervalDtype("int64"))
+        assert IntervalDtype.is_dtype(IntervalDtype(np.int64))
+        assert IntervalDtype.is_dtype(IntervalDtype("float64", "left"))
+        assert IntervalDtype.is_dtype(IntervalDtype("int64", "right"))
+        assert IntervalDtype.is_dtype(IntervalDtype(np.int64, "both"))
+
+        assert not IntervalDtype.is_dtype("D")
+        assert not IntervalDtype.is_dtype("3D")
+        assert not IntervalDtype.is_dtype("us")
+        assert not IntervalDtype.is_dtype("S")
+        assert not IntervalDtype.is_dtype("foo")
+        assert not IntervalDtype.is_dtype("IntervalA")
+        assert not IntervalDtype.is_dtype(np.object_)
+        assert not IntervalDtype.is_dtype(np.int64)
+        assert not IntervalDtype.is_dtype(np.float64)
+
+    def test_equality(self, dtype):
+        assert is_dtype_equal(dtype, "interval[int64, right]")
+        assert is_dtype_equal(dtype, IntervalDtype("int64", "right"))
+        assert is_dtype_equal(
+            IntervalDtype("int64", "right"), IntervalDtype("int64", "right")
+        )
+
+        assert not is_dtype_equal(dtype, "interval[int64]")
+        assert not is_dtype_equal(dtype, IntervalDtype("int64"))
+        assert not is_dtype_equal(
+            IntervalDtype("int64", "right"), IntervalDtype("int64")
+        )
+
+        assert not is_dtype_equal(dtype, "int64")
+        assert not is_dtype_equal(
+            IntervalDtype("int64", "neither"), IntervalDtype("float64", "right")
+        )
+        assert not is_dtype_equal(
+            IntervalDtype("int64", "both"), IntervalDtype("int64", "left")
+        )
+
+        # invalid subtype comparisons do not raise when directly compared
+        dtype1 = IntervalDtype("float64", "left")
+        dtype2 = IntervalDtype("datetime64[ns, US/Eastern]", "left")
+        assert dtype1 != dtype2
+        assert dtype2 != dtype1
+
+    @pytest.mark.parametrize(
+        "subtype",
+        [
+            None,
+            "interval",
+            "Interval",
+            "int64",
+            "uint64",
+            "float64",
+            "complex128",
+            "datetime64",
+            "timedelta64",
+            PeriodDtype("Q"),
+        ],
+    )
+    def test_equality_generic(self, subtype):
+        # GH 18980
+        closed = "right" if subtype is not None else None
+        dtype = IntervalDtype(subtype, closed=closed)
+        assert is_dtype_equal(dtype, "interval")
+        assert is_dtype_equal(dtype, IntervalDtype())
+
+    @pytest.mark.parametrize(
+        "subtype",
+        [
+            "int64",
+            "uint64",
+            "float64",
+            "complex128",
+            "datetime64",
+            "timedelta64",
+            PeriodDtype("Q"),
+        ],
+    )
+    def test_name_repr(self, subtype):
+        # GH 18980
+        closed = "right" if subtype is not None else None
+        dtype = IntervalDtype(subtype, closed=closed)
+        expected = f"interval[{subtype}, {closed}]"
+        assert str(dtype) == expected
+        assert dtype.name == "interval"
+
+    @pytest.mark.parametrize("subtype", [None, "interval", "Interval"])
+    def test_name_repr_generic(self, subtype):
+        # GH 18980
+        dtype = IntervalDtype(subtype)
+        assert str(dtype) == "interval"
+        assert dtype.name == "interval"
+
+    def test_basic(self, dtype):
+        msg = "is_interval_dtype is deprecated"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            assert is_interval_dtype(dtype)
+
+            ii = IntervalIndex.from_breaks(range(3))
+
+            assert is_interval_dtype(ii.dtype)
+            assert is_interval_dtype(ii)
+
+            s = Series(ii, name="A")
+
+            assert is_interval_dtype(s.dtype)
+            assert is_interval_dtype(s)
+
+    def test_basic_dtype(self):
+        msg = "is_interval_dtype is deprecated"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            assert is_interval_dtype("interval[int64, both]")
+            assert is_interval_dtype(IntervalIndex.from_tuples([(0, 1)]))
+            assert is_interval_dtype(IntervalIndex.from_breaks(np.arange(4)))
+            assert is_interval_dtype(
+                IntervalIndex.from_breaks(date_range("20130101", periods=3))
+            )
+            assert not is_interval_dtype("U")
+            assert not is_interval_dtype("S")
+            assert not is_interval_dtype("foo")
+            assert not is_interval_dtype(np.object_)
+            assert not is_interval_dtype(np.int64)
+            assert not is_interval_dtype(np.float64)
+
+    def test_caching(self):
+        # GH 54184: Caching not shown to improve performance
+        IntervalDtype.reset_cache()
+        dtype = IntervalDtype("int64", "right")
+        assert len(IntervalDtype._cache_dtypes) == 0
+
+        IntervalDtype("interval")
+        assert len(IntervalDtype._cache_dtypes) == 0
+
+        IntervalDtype.reset_cache()
+        tm.round_trip_pickle(dtype)
+        assert len(IntervalDtype._cache_dtypes) == 0
+
+    def test_not_string(self):
+        # GH30568: though IntervalDtype has object kind, it cannot be string
+        assert not is_string_dtype(IntervalDtype())
+
+    def test_unpickling_without_closed(self):
+        # GH#38394
+        dtype = IntervalDtype("interval")
+
+        assert dtype._closed is None
+
+        tm.round_trip_pickle(dtype)
+
+    def test_dont_keep_ref_after_del(self):
+        # GH 54184
+        dtype = IntervalDtype("int64", "right")
+        ref = weakref.ref(dtype)
+        del dtype
+        assert ref() is None
+
+
+class TestCategoricalDtypeParametrized:
+    @pytest.mark.parametrize(
+        "categories",
+        [
+            list("abcd"),
+            np.arange(1000),
+            ["a", "b", 10, 2, 1.3, True],
+            [True, False],
+            date_range("2017", periods=4),
+        ],
+    )
+    def test_basic(self, categories, ordered):
+        c1 = CategoricalDtype(categories, ordered=ordered)
+        tm.assert_index_equal(c1.categories, pd.Index(categories))
+        assert c1.ordered is ordered
+
+    def test_order_matters(self):
+        categories = ["a", "b"]
+        c1 = CategoricalDtype(categories, ordered=True)
+        c2 = CategoricalDtype(categories, ordered=False)
+        c3 = CategoricalDtype(categories, ordered=None)
+        assert c1 is not c2
+        assert c1 is not c3
+
+    @pytest.mark.parametrize("ordered", [False, None])
+    def test_unordered_same(self, ordered):
+        c1 = CategoricalDtype(["a", "b"], ordered=ordered)
+        c2 = CategoricalDtype(["b", "a"], ordered=ordered)
+        assert hash(c1) == hash(c2)
+
+    def test_categories(self):
+        result = CategoricalDtype(["a", "b", "c"])
+        tm.assert_index_equal(result.categories, pd.Index(["a", "b", "c"]))
+        assert result.ordered is False
+
+    def test_equal_but_different(self):
+        c1 = CategoricalDtype([1, 2, 3])
+        c2 = CategoricalDtype([1.0, 2.0, 3.0])
+        assert c1 is not c2
+        assert c1 != c2
+
+    def test_equal_but_different_mixed_dtypes(self):
+        c1 = CategoricalDtype([1, 2, "3"])
+        c2 = CategoricalDtype(["3", 1, 2])
+        assert c1 is not c2
+        assert c1 == c2
+
+    def test_equal_empty_ordered(self):
+        c1 = CategoricalDtype([], ordered=True)
+        c2 = CategoricalDtype([], ordered=True)
+        assert c1 is not c2
+        assert c1 == c2
+
+    def test_equal_empty_unordered(self):
+        c1 = CategoricalDtype([])
+        c2 = CategoricalDtype([])
+        assert c1 is not c2
+        assert c1 == c2
+
+    @pytest.mark.parametrize("v1, v2", [([1, 2, 3], [1, 2, 3]), ([1, 2, 3], [3, 2, 1])])
+    def test_order_hashes_different(self, v1, v2):
+        c1 = CategoricalDtype(v1, ordered=False)
+        c2 = CategoricalDtype(v2, ordered=True)
+        c3 = CategoricalDtype(v1, ordered=None)
+        assert c1 is not c2
+        assert c1 is not c3
+
+    def test_nan_invalid(self):
+        msg = "Categorical categories cannot be null"
+        with pytest.raises(ValueError, match=msg):
+            CategoricalDtype([1, 2, np.nan])
+
+    def test_non_unique_invalid(self):
+        msg = "Categorical categories must be unique"
+        with pytest.raises(ValueError, match=msg):
+            CategoricalDtype([1, 2, 1])
+
+    def test_same_categories_different_order(self):
+        c1 = CategoricalDtype(["a", "b"], ordered=True)
+        c2 = CategoricalDtype(["b", "a"], ordered=True)
+        assert c1 is not c2
+
+    @pytest.mark.parametrize("ordered1", [True, False, None])
+    @pytest.mark.parametrize("ordered2", [True, False, None])
+    def test_categorical_equality(self, ordered1, ordered2):
+        # same categories, same order
+        # any combination of None/False are equal
+        # True/True is the only combination with True that are equal
+        c1 = CategoricalDtype(list("abc"), ordered1)
+        c2 = CategoricalDtype(list("abc"), ordered2)
+        result = c1 == c2
+        expected = bool(ordered1) is bool(ordered2)
+        assert result is expected
+
+        # same categories, different order
+        # any combination of None/False are equal (order doesn't matter)
+        # any combination with True are not equal (different order of cats)
+        c1 = CategoricalDtype(list("abc"), ordered1)
+        c2 = CategoricalDtype(list("cab"), ordered2)
+        result = c1 == c2
+        expected = (bool(ordered1) is False) and (bool(ordered2) is False)
+        assert result is expected
+
+        # different categories
+        c2 = CategoricalDtype([1, 2, 3], ordered2)
+        assert c1 != c2
+
+        # none categories
+        c1 = CategoricalDtype(list("abc"), ordered1)
+        c2 = CategoricalDtype(None, ordered2)
+        c3 = CategoricalDtype(None, ordered1)
+        assert c1 != c2
+        assert c2 != c1
+        assert c2 == c3
+
+    def test_categorical_dtype_equality_requires_categories(self):
+        # CategoricalDtype with categories=None is *not* equal to
+        #  any fully-initialized CategoricalDtype
+        first = CategoricalDtype(["a", "b"])
+        second = CategoricalDtype()
+        third = CategoricalDtype(ordered=True)
+
+        assert second == second
+        assert third == third
+
+        assert first != second
+        assert second != first
+        assert first != third
+        assert third != first
+        assert second == third
+        assert third == second
+
+    @pytest.mark.parametrize("categories", [list("abc"), None])
+    @pytest.mark.parametrize("other", ["category", "not a category"])
+    def test_categorical_equality_strings(self, categories, ordered, other):
+        c1 = CategoricalDtype(categories, ordered)
+        result = c1 == other
+        expected = other == "category"
+        assert result is expected
+
+    def test_invalid_raises(self):
+        with pytest.raises(TypeError, match="ordered"):
+            CategoricalDtype(["a", "b"], ordered="foo")
+
+        with pytest.raises(TypeError, match="'categories' must be list-like"):
+            CategoricalDtype("category")
+
+    def test_mixed(self):
+        a = CategoricalDtype(["a", "b", 1, 2])
+        b = CategoricalDtype(["a", "b", "1", "2"])
+        assert hash(a) != hash(b)
+
+    def test_from_categorical_dtype_identity(self):
+        c1 = Categorical([1, 2], categories=[1, 2, 3], ordered=True)
+        # Identity test for no changes
+        c2 = CategoricalDtype._from_categorical_dtype(c1)
+        assert c2 is c1
+
+    def test_from_categorical_dtype_categories(self):
+        c1 = Categorical([1, 2], categories=[1, 2, 3], ordered=True)
+        # override categories
+        result = CategoricalDtype._from_categorical_dtype(c1, categories=[2, 3])
+        assert result == CategoricalDtype([2, 3], ordered=True)
+
+    def test_from_categorical_dtype_ordered(self):
+        c1 = Categorical([1, 2], categories=[1, 2, 3], ordered=True)
+        # override ordered
+        result = CategoricalDtype._from_categorical_dtype(c1, ordered=False)
+        assert result == CategoricalDtype([1, 2, 3], ordered=False)
+
+    def test_from_categorical_dtype_both(self):
+        c1 = Categorical([1, 2], categories=[1, 2, 3], ordered=True)
+        # override ordered
+        result = CategoricalDtype._from_categorical_dtype(
+            c1, categories=[1, 2], ordered=False
+        )
+        assert result == CategoricalDtype([1, 2], ordered=False)
+
+    def test_str_vs_repr(self, ordered, using_infer_string):
+        c1 = CategoricalDtype(["a", "b"], ordered=ordered)
+        assert str(c1) == "category"
+        # Py2 will have unicode prefixes
+        dtype = "string" if using_infer_string else "object"
+        pat = (
+            r"CategoricalDtype\(categories=\[.*\], ordered={ordered}, "
+            rf"categories_dtype={dtype}\)"
+        )
+        assert re.match(pat.format(ordered=ordered), repr(c1))
+
+    def test_categorical_categories(self):
+        # GH17884
+        c1 = CategoricalDtype(Categorical(["a", "b"]))
+        tm.assert_index_equal(c1.categories, pd.Index(["a", "b"]))
+        c1 = CategoricalDtype(CategoricalIndex(["a", "b"]))
+        tm.assert_index_equal(c1.categories, pd.Index(["a", "b"]))
+
+    @pytest.mark.parametrize(
+        "new_categories", [list("abc"), list("cba"), list("wxyz"), None]
+    )
+    @pytest.mark.parametrize("new_ordered", [True, False, None])
+    def test_update_dtype(self, ordered, new_categories, new_ordered):
+        original_categories = list("abc")
+        dtype = CategoricalDtype(original_categories, ordered)
+        new_dtype = CategoricalDtype(new_categories, new_ordered)
+
+        result = dtype.update_dtype(new_dtype)
+        expected_categories = pd.Index(new_categories or original_categories)
+        expected_ordered = new_ordered if new_ordered is not None else dtype.ordered
+
+        tm.assert_index_equal(result.categories, expected_categories)
+        assert result.ordered is expected_ordered
+
+    def test_update_dtype_string(self, ordered):
+        dtype = CategoricalDtype(list("abc"), ordered)
+        expected_categories = dtype.categories
+        expected_ordered = dtype.ordered
+        result = dtype.update_dtype("category")
+        tm.assert_index_equal(result.categories, expected_categories)
+        assert result.ordered is expected_ordered
+
+    @pytest.mark.parametrize("bad_dtype", ["foo", object, np.int64, PeriodDtype("Q")])
+    def test_update_dtype_errors(self, bad_dtype):
+        dtype = CategoricalDtype(list("abc"), False)
+        msg = "a CategoricalDtype must be passed to perform an update, "
+        with pytest.raises(ValueError, match=msg):
+            dtype.update_dtype(bad_dtype)
+
+
+@pytest.mark.parametrize(
+    "dtype", [CategoricalDtype, IntervalDtype, DatetimeTZDtype, PeriodDtype]
+)
+def test_registry(dtype):
+    assert dtype in registry.dtypes
+
+
+@pytest.mark.parametrize(
+    "dtype, expected",
+    [
+        ("int64", None),
+        ("interval", IntervalDtype()),
+        ("interval[int64, neither]", IntervalDtype()),
+        ("interval[datetime64[ns], left]", IntervalDtype("datetime64[ns]", "left")),
+        ("period[D]", PeriodDtype("D")),
+        ("category", CategoricalDtype()),
+        ("datetime64[ns, US/Eastern]", DatetimeTZDtype("ns", "US/Eastern")),
+    ],
+)
+def test_registry_find(dtype, expected):
+    assert registry.find(dtype) == expected
+
+
+@pytest.mark.parametrize(
+    "dtype, expected",
+    [
+        (str, False),
+        (int, False),
+        (bool, True),
+        (np.bool_, True),
+        (np.array(["a", "b"]), False),
+        (Series([1, 2]), False),
+        (np.array([True, False]), True),
+        (Series([True, False]), True),
+        (SparseArray([True, False]), True),
+        (SparseDtype(bool), True),
+    ],
+)
+def test_is_bool_dtype(dtype, expected):
+    result = is_bool_dtype(dtype)
+    assert result is expected
+
+
+def test_is_bool_dtype_sparse():
+    result = is_bool_dtype(Series(SparseArray([True, False])))
+    assert result is True
+
+
+@pytest.mark.parametrize(
+    "check",
+    [
+        is_categorical_dtype,
+        is_datetime64tz_dtype,
+        is_period_dtype,
+        is_datetime64_ns_dtype,
+        is_datetime64_dtype,
+        is_interval_dtype,
+        is_datetime64_any_dtype,
+        is_string_dtype,
+        is_bool_dtype,
+    ],
+)
+def test_is_dtype_no_warning(check):
+    data = pd.DataFrame({"A": [1, 2]})
+
+    warn = None
+    msg = f"{check.__name__} is deprecated"
+    if (
+        check is is_categorical_dtype
+        or check is is_interval_dtype
+        or check is is_datetime64tz_dtype
+        or check is is_period_dtype
+    ):
+        warn = DeprecationWarning
+
+    with tm.assert_produces_warning(warn, match=msg):
+        check(data)
+
+    with tm.assert_produces_warning(warn, match=msg):
+        check(data["A"])
+
+
+def test_period_dtype_compare_to_string():
+    # https://github.com/pandas-dev/pandas/issues/37265
+    dtype = PeriodDtype(freq="M")
+    assert (dtype == "period[M]") is True
+    assert (dtype != "period[M]") is False
+
+
+def test_compare_complex_dtypes():
+    # GH 28050
+    df = pd.DataFrame(np.arange(5).astype(np.complex128))
+    msg = "'<' not supported between instances of 'complex' and 'complex'"
+
+    with pytest.raises(TypeError, match=msg):
+        df < df.astype(object)
+
+    with pytest.raises(TypeError, match=msg):
+        df.lt(df.astype(object))
+
+
+def test_cast_string_to_complex():
+    # GH 4895
+    expected = pd.DataFrame(["1.0+5j", "1.5-3j"], dtype=complex)
+    result = pd.DataFrame(["1.0+5j", "1.5-3j"]).astype(complex)
+    tm.assert_frame_equal(result, expected)
+
+
+def test_categorical_complex():
+    result = Categorical([1, 2 + 2j])
+    expected = Categorical([1.0 + 0.0j, 2.0 + 2.0j])
+    tm.assert_categorical_equal(result, expected)
+    result = Categorical([1, 2, 2 + 2j])
+    expected = Categorical([1.0 + 0.0j, 2.0 + 0.0j, 2.0 + 2.0j])
+    tm.assert_categorical_equal(result, expected)
+
+
+def test_multi_column_dtype_assignment():
+    # GH #27583
+    df = pd.DataFrame({"a": [0.0], "b": 0.0})
+    expected = pd.DataFrame({"a": [0], "b": 0})
+
+    df[["a", "b"]] = 0
+    tm.assert_frame_equal(df, expected)
+
+    df["b"] = 0
+    tm.assert_frame_equal(df, expected)

mantis_evalkit/lib/python3.10/site-packages/pandas/tests/dtypes/test_generic.py

@@ -0,0 +1,130 @@
+import re
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes import generic as gt
+
+import pandas as pd
+import pandas._testing as tm
+
+
+class TestABCClasses:
+    tuples = [[1, 2, 2], ["red", "blue", "red"]]
+    multi_index = pd.MultiIndex.from_arrays(tuples, names=("number", "color"))
+    datetime_index = pd.to_datetime(["2000/1/1", "2010/1/1"])
+    timedelta_index = pd.to_timedelta(np.arange(5), unit="s")
+    period_index = pd.period_range("2000/1/1", "2010/1/1/", freq="M")
+    categorical = pd.Categorical([1, 2, 3], categories=[2, 3, 1])
+    categorical_df = pd.DataFrame({"values": [1, 2, 3]}, index=categorical)
+    df = pd.DataFrame({"names": ["a", "b", "c"]}, index=multi_index)
+    sparse_array = pd.arrays.SparseArray(np.random.default_rng(2).standard_normal(10))
+
+    datetime_array = pd.core.arrays.DatetimeArray._from_sequence(datetime_index)
+    timedelta_array = pd.core.arrays.TimedeltaArray._from_sequence(timedelta_index)
+
+    abc_pairs = [
+        ("ABCMultiIndex", multi_index),
+        ("ABCDatetimeIndex", datetime_index),
+        ("ABCRangeIndex", pd.RangeIndex(3)),
+        ("ABCTimedeltaIndex", timedelta_index),
+        ("ABCIntervalIndex", pd.interval_range(start=0, end=3)),
+        (
+            "ABCPeriodArray",
+            pd.arrays.PeriodArray([2000, 2001, 2002], dtype="period[D]"),
+        ),
+        ("ABCNumpyExtensionArray", pd.arrays.NumpyExtensionArray(np.array([0, 1, 2]))),
+        ("ABCPeriodIndex", period_index),
+        ("ABCCategoricalIndex", categorical_df.index),
+        ("ABCSeries", pd.Series([1, 2, 3])),
+        ("ABCDataFrame", df),
+        ("ABCCategorical", categorical),
+        ("ABCDatetimeArray", datetime_array),
+        ("ABCTimedeltaArray", timedelta_array),
+    ]
+
+    @pytest.mark.parametrize("abctype1, inst", abc_pairs)
+    @pytest.mark.parametrize("abctype2, _", abc_pairs)
+    def test_abc_pairs_instance_check(self, abctype1, abctype2, inst, _):
+        # GH 38588, 46719
+        if abctype1 == abctype2:
+            assert isinstance(inst, getattr(gt, abctype2))
+            assert not isinstance(type(inst), getattr(gt, abctype2))
+        else:
+            assert not isinstance(inst, getattr(gt, abctype2))
+
+    @pytest.mark.parametrize("abctype1, inst", abc_pairs)
+    @pytest.mark.parametrize("abctype2, _", abc_pairs)
+    def test_abc_pairs_subclass_check(self, abctype1, abctype2, inst, _):
+        # GH 38588, 46719
+        if abctype1 == abctype2:
+            assert issubclass(type(inst), getattr(gt, abctype2))
+
+            with pytest.raises(
+                TypeError, match=re.escape("issubclass() arg 1 must be a class")
+            ):
+                issubclass(inst, getattr(gt, abctype2))
+        else:
+            assert not issubclass(type(inst), getattr(gt, abctype2))
+
+    abc_subclasses = {
+        "ABCIndex": [
+            abctype
+            for abctype, _ in abc_pairs
+            if "Index" in abctype and abctype != "ABCIndex"
+        ],
+        "ABCNDFrame": ["ABCSeries", "ABCDataFrame"],
+        "ABCExtensionArray": [
+            "ABCCategorical",
+            "ABCDatetimeArray",
+            "ABCPeriodArray",
+            "ABCTimedeltaArray",
+        ],
+    }
+
+    @pytest.mark.parametrize("parent, subs", abc_subclasses.items())
+    @pytest.mark.parametrize("abctype, inst", abc_pairs)
+    def test_abc_hierarchy(self, parent, subs, abctype, inst):
+        # GH 38588
+        if abctype in subs:
+            assert isinstance(inst, getattr(gt, parent))
+        else:
+            assert not isinstance(inst, getattr(gt, parent))
+
+    @pytest.mark.parametrize("abctype", [e for e in gt.__dict__ if e.startswith("ABC")])
+    def test_abc_coverage(self, abctype):
+        # GH 38588
+        assert (
+            abctype in (e for e, _ in self.abc_pairs) or abctype in self.abc_subclasses
+        )
+
+
+def test_setattr_warnings():
+    # GH7175 - GOTCHA: You can't use dot notation to add a column...
+    d = {
+        "one": pd.Series([1.0, 2.0, 3.0], index=["a", "b", "c"]),
+        "two": pd.Series([1.0, 2.0, 3.0, 4.0], index=["a", "b", "c", "d"]),
+    }
+    df = pd.DataFrame(d)
+
+    with tm.assert_produces_warning(None):
+        #  successfully add new column
+        #  this should not raise a warning
+        df["three"] = df.two + 1
+        assert df.three.sum() > df.two.sum()
+
+    with tm.assert_produces_warning(None):
+        #  successfully modify column in place
+        #  this should not raise a warning
+        df.one += 1
+        assert df.one.iloc[0] == 2
+
+    with tm.assert_produces_warning(None):
+        #  successfully add an attribute to a series
+        #  this should not raise a warning
+        df.two.not_an_index = [1, 2]
+
+    with tm.assert_produces_warning(UserWarning):
+        #  warn when setting column to nonexistent name
+        df.four = df.two + 2
+        assert df.four.sum() > df.two.sum()

mantis_evalkit/lib/python3.10/site-packages/pandas/tests/dtypes/test_inference.py

@@ -0,0 +1,2047 @@
+"""
+These the test the public routines exposed in types/common.py
+related to inference and not otherwise tested in types/test_common.py
+
+"""
+import collections
+from collections import namedtuple
+from collections.abc import Iterator
+from datetime import (
+    date,
+    datetime,
+    time,
+    timedelta,
+)
+from decimal import Decimal
+from fractions import Fraction
+from io import StringIO
+import itertools
+from numbers import Number
+import re
+import sys
+from typing import (
+    Generic,
+    TypeVar,
+)
+
+import numpy as np
+import pytest
+import pytz
+
+from pandas._libs import (
+    lib,
+    missing as libmissing,
+    ops as libops,
+)
+from pandas.compat.numpy import np_version_gt2
+
+from pandas.core.dtypes import inference
+from pandas.core.dtypes.cast import find_result_type
+from pandas.core.dtypes.common import (
+    ensure_int32,
+    is_bool,
+    is_complex,
+    is_datetime64_any_dtype,
+    is_datetime64_dtype,
+    is_datetime64_ns_dtype,
+    is_datetime64tz_dtype,
+    is_float,
+    is_integer,
+    is_number,
+    is_scalar,
+    is_scipy_sparse,
+    is_timedelta64_dtype,
+    is_timedelta64_ns_dtype,
+)
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    DataFrame,
+    DateOffset,
+    DatetimeIndex,
+    Index,
+    Interval,
+    Period,
+    PeriodIndex,
+    Series,
+    Timedelta,
+    TimedeltaIndex,
+    Timestamp,
+)
+import pandas._testing as tm
+from pandas.core.arrays import (
+    BooleanArray,
+    FloatingArray,
+    IntegerArray,
+)
+
+
+@pytest.fixture(params=[True, False], ids=str)
+def coerce(request):
+    return request.param
+
+
+class MockNumpyLikeArray:
+    """
+    A class which is numpy-like (e.g. Pint's Quantity) but not actually numpy
+
+    The key is that it is not actually a numpy array so
+    ``util.is_array(mock_numpy_like_array_instance)`` returns ``False``. Other
+    important properties are that the class defines a :meth:`__iter__` method
+    (so that ``isinstance(abc.Iterable)`` returns ``True``) and has a
+    :meth:`ndim` property, as pandas special-cases 0-dimensional arrays in some
+    cases.
+
+    We expect pandas to behave with respect to such duck arrays exactly as
+    with real numpy arrays. In particular, a 0-dimensional duck array is *NOT*
+    a scalar (`is_scalar(np.array(1)) == False`), but it is not list-like either.
+    """
+
+    def __init__(self, values) -> None:
+        self._values = values
+
+    def __iter__(self) -> Iterator:
+        iter_values = iter(self._values)
+
+        def it_outer():
+            yield from iter_values
+
+        return it_outer()
+
+    def __len__(self) -> int:
+        return len(self._values)
+
+    def __array__(self, dtype=None, copy=None):
+        return np.asarray(self._values, dtype=dtype)
+
+    @property
+    def ndim(self):
+        return self._values.ndim
+
+    @property
+    def dtype(self):
+        return self._values.dtype
+
+    @property
+    def size(self):
+        return self._values.size
+
+    @property
+    def shape(self):
+        return self._values.shape
+
+
+# collect all objects to be tested for list-like-ness; use tuples of objects,
+# whether they are list-like or not (special casing for sets), and their ID
+ll_params = [
+    ([1], True, "list"),
+    ([], True, "list-empty"),
+    ((1,), True, "tuple"),
+    ((), True, "tuple-empty"),
+    ({"a": 1}, True, "dict"),
+    ({}, True, "dict-empty"),
+    ({"a", 1}, "set", "set"),
+    (set(), "set", "set-empty"),
+    (frozenset({"a", 1}), "set", "frozenset"),
+    (frozenset(), "set", "frozenset-empty"),
+    (iter([1, 2]), True, "iterator"),
+    (iter([]), True, "iterator-empty"),
+    ((x for x in [1, 2]), True, "generator"),
+    ((_ for _ in []), True, "generator-empty"),
+    (Series([1]), True, "Series"),
+    (Series([], dtype=object), True, "Series-empty"),
+    # Series.str will still raise a TypeError if iterated
+    (Series(["a"]).str, True, "StringMethods"),
+    (Series([], dtype="O").str, True, "StringMethods-empty"),
+    (Index([1]), True, "Index"),
+    (Index([]), True, "Index-empty"),
+    (DataFrame([[1]]), True, "DataFrame"),
+    (DataFrame(), True, "DataFrame-empty"),
+    (np.ndarray((2,) * 1), True, "ndarray-1d"),
+    (np.array([]), True, "ndarray-1d-empty"),
+    (np.ndarray((2,) * 2), True, "ndarray-2d"),
+    (np.array([[]]), True, "ndarray-2d-empty"),
+    (np.ndarray((2,) * 3), True, "ndarray-3d"),
+    (np.array([[[]]]), True, "ndarray-3d-empty"),
+    (np.ndarray((2,) * 4), True, "ndarray-4d"),
+    (np.array([[[[]]]]), True, "ndarray-4d-empty"),
+    (np.array(2), False, "ndarray-0d"),
+    (MockNumpyLikeArray(np.ndarray((2,) * 1)), True, "duck-ndarray-1d"),
+    (MockNumpyLikeArray(np.array([])), True, "duck-ndarray-1d-empty"),
+    (MockNumpyLikeArray(np.ndarray((2,) * 2)), True, "duck-ndarray-2d"),
+    (MockNumpyLikeArray(np.array([[]])), True, "duck-ndarray-2d-empty"),
+    (MockNumpyLikeArray(np.ndarray((2,) * 3)), True, "duck-ndarray-3d"),
+    (MockNumpyLikeArray(np.array([[[]]])), True, "duck-ndarray-3d-empty"),
+    (MockNumpyLikeArray(np.ndarray((2,) * 4)), True, "duck-ndarray-4d"),
+    (MockNumpyLikeArray(np.array([[[[]]]])), True, "duck-ndarray-4d-empty"),
+    (MockNumpyLikeArray(np.array(2)), False, "duck-ndarray-0d"),
+    (1, False, "int"),
+    (b"123", False, "bytes"),
+    (b"", False, "bytes-empty"),
+    ("123", False, "string"),
+    ("", False, "string-empty"),
+    (str, False, "string-type"),
+    (object(), False, "object"),
+    (np.nan, False, "NaN"),
+    (None, False, "None"),
+]
+objs, expected, ids = zip(*ll_params)
+
+
+@pytest.fixture(params=zip(objs, expected), ids=ids)
+def maybe_list_like(request):
+    return request.param
+
+
+def test_is_list_like(maybe_list_like):
+    obj, expected = maybe_list_like
+    expected = True if expected == "set" else expected
+    assert inference.is_list_like(obj) == expected
+
+
+def test_is_list_like_disallow_sets(maybe_list_like):
+    obj, expected = maybe_list_like
+    expected = False if expected == "set" else expected
+    assert inference.is_list_like(obj, allow_sets=False) == expected
+
+
+def test_is_list_like_recursion():
+    # GH 33721
+    # interpreter would crash with SIGABRT
+    def list_like():
+        inference.is_list_like([])
+        list_like()
+
+    rec_limit = sys.getrecursionlimit()
+    try:
+        # Limit to avoid stack overflow on Windows CI
+        sys.setrecursionlimit(100)
+        with tm.external_error_raised(RecursionError):
+            list_like()
+    finally:
+        sys.setrecursionlimit(rec_limit)
+
+
+def test_is_list_like_iter_is_none():
+    # GH 43373
+    # is_list_like was yielding false positives with __iter__ == None
+    class NotListLike:
+        def __getitem__(self, item):
+            return self
+
+        __iter__ = None
+
+    assert not inference.is_list_like(NotListLike())
+
+
+def test_is_list_like_generic():
+    # GH 49649
+    # is_list_like was yielding false positives for Generic classes in python 3.11
+    T = TypeVar("T")
+
+    class MyDataFrame(DataFrame, Generic[T]):
+        ...
+
+    tstc = MyDataFrame[int]
+    tst = MyDataFrame[int]({"x": [1, 2, 3]})
+
+    assert not inference.is_list_like(tstc)
+    assert isinstance(tst, DataFrame)
+    assert inference.is_list_like(tst)
+
+
+def test_is_sequence():
+    is_seq = inference.is_sequence
+    assert is_seq((1, 2))
+    assert is_seq([1, 2])
+    assert not is_seq("abcd")
+    assert not is_seq(np.int64)
+
+    class A:
+        def __getitem__(self, item):
+            return 1
+
+    assert not is_seq(A())
+
+
+def test_is_array_like():
+    assert inference.is_array_like(Series([], dtype=object))
+    assert inference.is_array_like(Series([1, 2]))
+    assert inference.is_array_like(np.array(["a", "b"]))
+    assert inference.is_array_like(Index(["2016-01-01"]))
+    assert inference.is_array_like(np.array([2, 3]))
+    assert inference.is_array_like(MockNumpyLikeArray(np.array([2, 3])))
+
+    class DtypeList(list):
+        dtype = "special"
+
+    assert inference.is_array_like(DtypeList())
+
+    assert not inference.is_array_like([1, 2, 3])
+    assert not inference.is_array_like(())
+    assert not inference.is_array_like("foo")
+    assert not inference.is_array_like(123)
+
+
+@pytest.mark.parametrize(
+    "inner",
+    [
+        [],
+        [1],
+        (1,),
+        (1, 2),
+        {"a": 1},
+        {1, "a"},
+        Series([1]),
+        Series([], dtype=object),
+        Series(["a"]).str,
+        (x for x in range(5)),
+    ],
+)
+@pytest.mark.parametrize("outer", [list, Series, np.array, tuple])
+def test_is_nested_list_like_passes(inner, outer):
+    result = outer([inner for _ in range(5)])
+    assert inference.is_list_like(result)
+
+
+@pytest.mark.parametrize(
+    "obj",
+    [
+        "abc",
+        [],
+        [1],
+        (1,),
+        ["a"],
+        "a",
+        {"a"},
+        [1, 2, 3],
+        Series([1]),
+        DataFrame({"A": [1]}),
+        ([1, 2] for _ in range(5)),
+    ],
+)
+def test_is_nested_list_like_fails(obj):
+    assert not inference.is_nested_list_like(obj)
+
+
+@pytest.mark.parametrize("ll", [{}, {"A": 1}, Series([1]), collections.defaultdict()])
+def test_is_dict_like_passes(ll):
+    assert inference.is_dict_like(ll)
+
+
+@pytest.mark.parametrize(
+    "ll",
+    [
+        "1",
+        1,
+        [1, 2],
+        (1, 2),
+        range(2),
+        Index([1]),
+        dict,
+        collections.defaultdict,
+        Series,
+    ],
+)
+def test_is_dict_like_fails(ll):
+    assert not inference.is_dict_like(ll)
+
+
+@pytest.mark.parametrize("has_keys", [True, False])
+@pytest.mark.parametrize("has_getitem", [True, False])
+@pytest.mark.parametrize("has_contains", [True, False])
+def test_is_dict_like_duck_type(has_keys, has_getitem, has_contains):
+    class DictLike:
+        def __init__(self, d) -> None:
+            self.d = d
+
+        if has_keys:
+
+            def keys(self):
+                return self.d.keys()
+
+        if has_getitem:
+
+            def __getitem__(self, key):
+                return self.d.__getitem__(key)
+
+        if has_contains:
+
+            def __contains__(self, key) -> bool:
+                return self.d.__contains__(key)
+
+    d = DictLike({1: 2})
+    result = inference.is_dict_like(d)
+    expected = has_keys and has_getitem and has_contains
+
+    assert result is expected
+
+
+def test_is_file_like():
+    class MockFile:
+        pass
+
+    is_file = inference.is_file_like
+
+    data = StringIO("data")
+    assert is_file(data)
+
+    # No read / write attributes
+    # No iterator attributes
+    m = MockFile()
+    assert not is_file(m)
+
+    MockFile.write = lambda self: 0
+
+    # Write attribute but not an iterator
+    m = MockFile()
+    assert not is_file(m)
+
+    # gh-16530: Valid iterator just means we have the
+    # __iter__ attribute for our purposes.
+    MockFile.__iter__ = lambda self: self
+
+    # Valid write-only file
+    m = MockFile()
+    assert is_file(m)
+
+    del MockFile.write
+    MockFile.read = lambda self: 0
+
+    # Valid read-only file
+    m = MockFile()
+    assert is_file(m)
+
+    # Iterator but no read / write attributes
+    data = [1, 2, 3]
+    assert not is_file(data)
+
+
+test_tuple = collections.namedtuple("test_tuple", ["a", "b", "c"])
+
+
+@pytest.mark.parametrize("ll", [test_tuple(1, 2, 3)])
+def test_is_names_tuple_passes(ll):
+    assert inference.is_named_tuple(ll)
+
+
+@pytest.mark.parametrize("ll", [(1, 2, 3), "a", Series({"pi": 3.14})])
+def test_is_names_tuple_fails(ll):
+    assert not inference.is_named_tuple(ll)
+
+
+def test_is_hashable():
+    # all new-style classes are hashable by default
+    class HashableClass:
+        pass
+
+    class UnhashableClass1:
+        __hash__ = None
+
+    class UnhashableClass2:
+        def __hash__(self):
+            raise TypeError("Not hashable")
+
+    hashable = (1, 3.14, np.float64(3.14), "a", (), (1,), HashableClass())
+    not_hashable = ([], UnhashableClass1())
+    abc_hashable_not_really_hashable = (([],), UnhashableClass2())
+
+    for i in hashable:
+        assert inference.is_hashable(i)
+    for i in not_hashable:
+        assert not inference.is_hashable(i)
+    for i in abc_hashable_not_really_hashable:
+        assert not inference.is_hashable(i)
+
+    # numpy.array is no longer collections.abc.Hashable as of
+    # https://github.com/numpy/numpy/pull/5326, just test
+    # is_hashable()
+    assert not inference.is_hashable(np.array([]))
+
+
+@pytest.mark.parametrize("ll", [re.compile("ad")])
+def test_is_re_passes(ll):
+    assert inference.is_re(ll)
+
+
+@pytest.mark.parametrize("ll", ["x", 2, 3, object()])
+def test_is_re_fails(ll):
+    assert not inference.is_re(ll)
+
+
+@pytest.mark.parametrize(
+    "ll", [r"a", "x", r"asdf", re.compile("adsf"), r"\u2233\s*", re.compile(r"")]
+)
+def test_is_recompilable_passes(ll):
+    assert inference.is_re_compilable(ll)
+
+
+@pytest.mark.parametrize("ll", [1, [], object()])
+def test_is_recompilable_fails(ll):
+    assert not inference.is_re_compilable(ll)
+
+
+class TestInference:
+    @pytest.mark.parametrize(
+        "arr",
+        [
+            np.array(list("abc"), dtype="S1"),
+            np.array(list("abc"), dtype="S1").astype(object),
+            [b"a", np.nan, b"c"],
+        ],
+    )
+    def test_infer_dtype_bytes(self, arr):
+        result = lib.infer_dtype(arr, skipna=True)
+        assert result == "bytes"
+
+    @pytest.mark.parametrize(
+        "value, expected",
+        [
+            (float("inf"), True),
+            (np.inf, True),
+            (-np.inf, False),
+            (1, False),
+            ("a", False),
+        ],
+    )
+    def test_isposinf_scalar(self, value, expected):
+        # GH 11352
+        result = libmissing.isposinf_scalar(value)
+        assert result is expected
+
+    @pytest.mark.parametrize(
+        "value, expected",
+        [
+            (float("-inf"), True),
+            (-np.inf, True),
+            (np.inf, False),
+            (1, False),
+            ("a", False),
+        ],
+    )
+    def test_isneginf_scalar(self, value, expected):
+        result = libmissing.isneginf_scalar(value)
+        assert result is expected
+
+    @pytest.mark.parametrize(
+        "convert_to_masked_nullable, exp",
+        [
+            (
+                True,
+                BooleanArray(
+                    np.array([True, False], dtype="bool"), np.array([False, True])
+                ),
+            ),
+            (False, np.array([True, np.nan], dtype="object")),
+        ],
+    )
+    def test_maybe_convert_nullable_boolean(self, convert_to_masked_nullable, exp):
+        # GH 40687
+        arr = np.array([True, np.nan], dtype=object)
+        result = libops.maybe_convert_bool(
+            arr, set(), convert_to_masked_nullable=convert_to_masked_nullable
+        )
+        if convert_to_masked_nullable:
+            tm.assert_extension_array_equal(BooleanArray(*result), exp)
+        else:
+            result = result[0]
+            tm.assert_numpy_array_equal(result, exp)
+
+    @pytest.mark.parametrize("convert_to_masked_nullable", [True, False])
+    @pytest.mark.parametrize("coerce_numeric", [True, False])
+    @pytest.mark.parametrize(
+        "infinity", ["inf", "inF", "iNf", "Inf", "iNF", "InF", "INf", "INF"]
+    )
+    @pytest.mark.parametrize("prefix", ["", "-", "+"])
+    def test_maybe_convert_numeric_infinities(
+        self, coerce_numeric, infinity, prefix, convert_to_masked_nullable
+    ):
+        # see gh-13274
+        result, _ = lib.maybe_convert_numeric(
+            np.array([prefix + infinity], dtype=object),
+            na_values={"", "NULL", "nan"},
+            coerce_numeric=coerce_numeric,
+            convert_to_masked_nullable=convert_to_masked_nullable,
+        )
+        expected = np.array([np.inf if prefix in ["", "+"] else -np.inf])
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize("convert_to_masked_nullable", [True, False])
+    def test_maybe_convert_numeric_infinities_raises(self, convert_to_masked_nullable):
+        msg = "Unable to parse string"
+        with pytest.raises(ValueError, match=msg):
+            lib.maybe_convert_numeric(
+                np.array(["foo_inf"], dtype=object),
+                na_values={"", "NULL", "nan"},
+                coerce_numeric=False,
+                convert_to_masked_nullable=convert_to_masked_nullable,
+            )
+
+    @pytest.mark.parametrize("convert_to_masked_nullable", [True, False])
+    def test_maybe_convert_numeric_post_floatify_nan(
+        self, coerce, convert_to_masked_nullable
+    ):
+        # see gh-13314
+        data = np.array(["1.200", "-999.000", "4.500"], dtype=object)
+        expected = np.array([1.2, np.nan, 4.5], dtype=np.float64)
+        nan_values = {-999, -999.0}
+
+        out = lib.maybe_convert_numeric(
+            data,
+            nan_values,
+            coerce,
+            convert_to_masked_nullable=convert_to_masked_nullable,
+        )
+        if convert_to_masked_nullable:
+            expected = FloatingArray(expected, np.isnan(expected))
+            tm.assert_extension_array_equal(expected, FloatingArray(*out))
+        else:
+            out = out[0]
+            tm.assert_numpy_array_equal(out, expected)
+
+    def test_convert_infs(self):
+        arr = np.array(["inf", "inf", "inf"], dtype="O")
+        result, _ = lib.maybe_convert_numeric(arr, set(), False)
+        assert result.dtype == np.float64
+
+        arr = np.array(["-inf", "-inf", "-inf"], dtype="O")
+        result, _ = lib.maybe_convert_numeric(arr, set(), False)
+        assert result.dtype == np.float64
+
+    def test_scientific_no_exponent(self):
+        # See PR 12215
+        arr = np.array(["42E", "2E", "99e", "6e"], dtype="O")
+        result, _ = lib.maybe_convert_numeric(arr, set(), False, True)
+        assert np.all(np.isnan(result))
+
+    def test_convert_non_hashable(self):
+        # GH13324
+        # make sure that we are handing non-hashables
+        arr = np.array([[10.0, 2], 1.0, "apple"], dtype=object)
+        result, _ = lib.maybe_convert_numeric(arr, set(), False, True)
+        tm.assert_numpy_array_equal(result, np.array([np.nan, 1.0, np.nan]))
+
+    def test_convert_numeric_uint64(self):
+        arr = np.array([2**63], dtype=object)
+        exp = np.array([2**63], dtype=np.uint64)
+        tm.assert_numpy_array_equal(lib.maybe_convert_numeric(arr, set())[0], exp)
+
+        arr = np.array([str(2**63)], dtype=object)
+        exp = np.array([2**63], dtype=np.uint64)
+        tm.assert_numpy_array_equal(lib.maybe_convert_numeric(arr, set())[0], exp)
+
+        arr = np.array([np.uint64(2**63)], dtype=object)
+        exp = np.array([2**63], dtype=np.uint64)
+        tm.assert_numpy_array_equal(lib.maybe_convert_numeric(arr, set())[0], exp)
+
+    @pytest.mark.parametrize(
+        "arr",
+        [
+            np.array([2**63, np.nan], dtype=object),
+            np.array([str(2**63), np.nan], dtype=object),
+            np.array([np.nan, 2**63], dtype=object),
+            np.array([np.nan, str(2**63)], dtype=object),
+        ],
+    )
+    def test_convert_numeric_uint64_nan(self, coerce, arr):
+        expected = arr.astype(float) if coerce else arr.copy()
+        result, _ = lib.maybe_convert_numeric(arr, set(), coerce_numeric=coerce)
+        tm.assert_almost_equal(result, expected)
+
+    @pytest.mark.parametrize("convert_to_masked_nullable", [True, False])
+    def test_convert_numeric_uint64_nan_values(
+        self, coerce, convert_to_masked_nullable
+    ):
+        arr = np.array([2**63, 2**63 + 1], dtype=object)
+        na_values = {2**63}
+
+        expected = (
+            np.array([np.nan, 2**63 + 1], dtype=float) if coerce else arr.copy()
+        )
+        result = lib.maybe_convert_numeric(
+            arr,
+            na_values,
+            coerce_numeric=coerce,
+            convert_to_masked_nullable=convert_to_masked_nullable,
+        )
+        if convert_to_masked_nullable and coerce:
+            expected = IntegerArray(
+                np.array([0, 2**63 + 1], dtype="u8"),
+                np.array([True, False], dtype="bool"),
+            )
+            result = IntegerArray(*result)
+        else:
+            result = result[0]  # discard mask
+        tm.assert_almost_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "case",
+        [
+            np.array([2**63, -1], dtype=object),
+            np.array([str(2**63), -1], dtype=object),
+            np.array([str(2**63), str(-1)], dtype=object),
+            np.array([-1, 2**63], dtype=object),
+            np.array([-1, str(2**63)], dtype=object),
+            np.array([str(-1), str(2**63)], dtype=object),
+        ],
+    )
+    @pytest.mark.parametrize("convert_to_masked_nullable", [True, False])
+    def test_convert_numeric_int64_uint64(
+        self, case, coerce, convert_to_masked_nullable
+    ):
+        expected = case.astype(float) if coerce else case.copy()
+        result, _ = lib.maybe_convert_numeric(
+            case,
+            set(),
+            coerce_numeric=coerce,
+            convert_to_masked_nullable=convert_to_masked_nullable,
+        )
+
+        tm.assert_almost_equal(result, expected)
+
+    @pytest.mark.parametrize("convert_to_masked_nullable", [True, False])
+    def test_convert_numeric_string_uint64(self, convert_to_masked_nullable):
+        # GH32394
+        result = lib.maybe_convert_numeric(
+            np.array(["uint64"], dtype=object),
+            set(),
+            coerce_numeric=True,
+            convert_to_masked_nullable=convert_to_masked_nullable,
+        )
+        if convert_to_masked_nullable:
+            result = FloatingArray(*result)
+        else:
+            result = result[0]
+        assert np.isnan(result)
+
+    @pytest.mark.parametrize("value", [-(2**63) - 1, 2**64])
+    def test_convert_int_overflow(self, value):
+        # see gh-18584
+        arr = np.array([value], dtype=object)
+        result = lib.maybe_convert_objects(arr)
+        tm.assert_numpy_array_equal(arr, result)
+
+    @pytest.mark.parametrize("val", [None, np.nan, float("nan")])
+    @pytest.mark.parametrize("dtype", ["M8[ns]", "m8[ns]"])
+    def test_maybe_convert_objects_nat_inference(self, val, dtype):
+        dtype = np.dtype(dtype)
+        vals = np.array([pd.NaT, val], dtype=object)
+        result = lib.maybe_convert_objects(
+            vals,
+            convert_non_numeric=True,
+            dtype_if_all_nat=dtype,
+        )
+        assert result.dtype == dtype
+        assert np.isnat(result).all()
+
+        result = lib.maybe_convert_objects(
+            vals[::-1],
+            convert_non_numeric=True,
+            dtype_if_all_nat=dtype,
+        )
+        assert result.dtype == dtype
+        assert np.isnat(result).all()
+
+    @pytest.mark.parametrize(
+        "value, expected_dtype",
+        [
+            # see gh-4471
+            ([2**63], np.uint64),
+            # NumPy bug: can't compare uint64 to int64, as that
+            # results in both casting to float64, so we should
+            # make sure that this function is robust against it
+            ([np.uint64(2**63)], np.uint64),
+            ([2, -1], np.int64),
+            ([2**63, -1], object),
+            # GH#47294
+            ([np.uint8(1)], np.uint8),
+            ([np.uint16(1)], np.uint16),
+            ([np.uint32(1)], np.uint32),
+            ([np.uint64(1)], np.uint64),
+            ([np.uint8(2), np.uint16(1)], np.uint16),
+            ([np.uint32(2), np.uint16(1)], np.uint32),
+            ([np.uint32(2), -1], object),
+            ([np.uint32(2), 1], np.uint64),
+            ([np.uint32(2), np.int32(1)], object),
+        ],
+    )
+    def test_maybe_convert_objects_uint(self, value, expected_dtype):
+        arr = np.array(value, dtype=object)
+        exp = np.array(value, dtype=expected_dtype)
+        tm.assert_numpy_array_equal(lib.maybe_convert_objects(arr), exp)
+
+    def test_maybe_convert_objects_datetime(self):
+        # GH27438
+        arr = np.array(
+            [np.datetime64("2000-01-01"), np.timedelta64(1, "s")], dtype=object
+        )
+        exp = arr.copy()
+        out = lib.maybe_convert_objects(arr, convert_non_numeric=True)
+        tm.assert_numpy_array_equal(out, exp)
+
+        arr = np.array([pd.NaT, np.timedelta64(1, "s")], dtype=object)
+        exp = np.array([np.timedelta64("NaT"), np.timedelta64(1, "s")], dtype="m8[ns]")
+        out = lib.maybe_convert_objects(arr, convert_non_numeric=True)
+        tm.assert_numpy_array_equal(out, exp)
+
+        # with convert_non_numeric=True, the nan is a valid NA value for td64
+        arr = np.array([np.timedelta64(1, "s"), np.nan], dtype=object)
+        exp = exp[::-1]
+        out = lib.maybe_convert_objects(arr, convert_non_numeric=True)
+        tm.assert_numpy_array_equal(out, exp)
+
+    def test_maybe_convert_objects_dtype_if_all_nat(self):
+        arr = np.array([pd.NaT, pd.NaT], dtype=object)
+        out = lib.maybe_convert_objects(arr, convert_non_numeric=True)
+        # no dtype_if_all_nat passed -> we dont guess
+        tm.assert_numpy_array_equal(out, arr)
+
+        out = lib.maybe_convert_objects(
+            arr,
+            convert_non_numeric=True,
+            dtype_if_all_nat=np.dtype("timedelta64[ns]"),
+        )
+        exp = np.array(["NaT", "NaT"], dtype="timedelta64[ns]")
+        tm.assert_numpy_array_equal(out, exp)
+
+        out = lib.maybe_convert_objects(
+            arr,
+            convert_non_numeric=True,
+            dtype_if_all_nat=np.dtype("datetime64[ns]"),
+        )
+        exp = np.array(["NaT", "NaT"], dtype="datetime64[ns]")
+        tm.assert_numpy_array_equal(out, exp)
+
+    def test_maybe_convert_objects_dtype_if_all_nat_invalid(self):
+        # we accept datetime64[ns], timedelta64[ns], and EADtype
+        arr = np.array([pd.NaT, pd.NaT], dtype=object)
+
+        with pytest.raises(ValueError, match="int64"):
+            lib.maybe_convert_objects(
+                arr,
+                convert_non_numeric=True,
+                dtype_if_all_nat=np.dtype("int64"),
+            )
+
+    @pytest.mark.parametrize("dtype", ["datetime64[ns]", "timedelta64[ns]"])
+    def test_maybe_convert_objects_datetime_overflow_safe(self, dtype):
+        stamp = datetime(2363, 10, 4)  # Enterprise-D launch date
+        if dtype == "timedelta64[ns]":
+            stamp = stamp - datetime(1970, 1, 1)
+        arr = np.array([stamp], dtype=object)
+
+        out = lib.maybe_convert_objects(arr, convert_non_numeric=True)
+        # no OutOfBoundsDatetime/OutOfBoundsTimedeltas
+        tm.assert_numpy_array_equal(out, arr)
+
+    def test_maybe_convert_objects_mixed_datetimes(self):
+        ts = Timestamp("now")
+        vals = [ts, ts.to_pydatetime(), ts.to_datetime64(), pd.NaT, np.nan, None]
+
+        for data in itertools.permutations(vals):
+            data = np.array(list(data), dtype=object)
+            expected = DatetimeIndex(data)._data._ndarray
+            result = lib.maybe_convert_objects(data, convert_non_numeric=True)
+            tm.assert_numpy_array_equal(result, expected)
+
+    def test_maybe_convert_objects_timedelta64_nat(self):
+        obj = np.timedelta64("NaT", "ns")
+        arr = np.array([obj], dtype=object)
+        assert arr[0] is obj
+
+        result = lib.maybe_convert_objects(arr, convert_non_numeric=True)
+
+        expected = np.array([obj], dtype="m8[ns]")
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "exp",
+        [
+            IntegerArray(np.array([2, 0], dtype="i8"), np.array([False, True])),
+            IntegerArray(np.array([2, 0], dtype="int64"), np.array([False, True])),
+        ],
+    )
+    def test_maybe_convert_objects_nullable_integer(self, exp):
+        # GH27335
+        arr = np.array([2, np.nan], dtype=object)
+        result = lib.maybe_convert_objects(arr, convert_to_nullable_dtype=True)
+
+        tm.assert_extension_array_equal(result, exp)
+
+    @pytest.mark.parametrize(
+        "dtype, val", [("int64", 1), ("uint64", np.iinfo(np.int64).max + 1)]
+    )
+    def test_maybe_convert_objects_nullable_none(self, dtype, val):
+        # GH#50043
+        arr = np.array([val, None, 3], dtype="object")
+        result = lib.maybe_convert_objects(arr, convert_to_nullable_dtype=True)
+        expected = IntegerArray(
+            np.array([val, 0, 3], dtype=dtype), np.array([False, True, False])
+        )
+        tm.assert_extension_array_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "convert_to_masked_nullable, exp",
+        [
+            (True, IntegerArray(np.array([2, 0], dtype="i8"), np.array([False, True]))),
+            (False, np.array([2, np.nan], dtype="float64")),
+        ],
+    )
+    def test_maybe_convert_numeric_nullable_integer(
+        self, convert_to_masked_nullable, exp
+    ):
+        # GH 40687
+        arr = np.array([2, np.nan], dtype=object)
+        result = lib.maybe_convert_numeric(
+            arr, set(), convert_to_masked_nullable=convert_to_masked_nullable
+        )
+        if convert_to_masked_nullable:
+            result = IntegerArray(*result)
+            tm.assert_extension_array_equal(result, exp)
+        else:
+            result = result[0]
+            tm.assert_numpy_array_equal(result, exp)
+
+    @pytest.mark.parametrize(
+        "convert_to_masked_nullable, exp",
+        [
+            (
+                True,
+                FloatingArray(
+                    np.array([2.0, 0.0], dtype="float64"), np.array([False, True])
+                ),
+            ),
+            (False, np.array([2.0, np.nan], dtype="float64")),
+        ],
+    )
+    def test_maybe_convert_numeric_floating_array(
+        self, convert_to_masked_nullable, exp
+    ):
+        # GH 40687
+        arr = np.array([2.0, np.nan], dtype=object)
+        result = lib.maybe_convert_numeric(
+            arr, set(), convert_to_masked_nullable=convert_to_masked_nullable
+        )
+        if convert_to_masked_nullable:
+            tm.assert_extension_array_equal(FloatingArray(*result), exp)
+        else:
+            result = result[0]
+            tm.assert_numpy_array_equal(result, exp)
+
+    def test_maybe_convert_objects_bool_nan(self):
+        # GH32146
+        ind = Index([True, False, np.nan], dtype=object)
+        exp = np.array([True, False, np.nan], dtype=object)
+        out = lib.maybe_convert_objects(ind.values, safe=1)
+        tm.assert_numpy_array_equal(out, exp)
+
+    def test_maybe_convert_objects_nullable_boolean(self):
+        # GH50047
+        arr = np.array([True, False], dtype=object)
+        exp = np.array([True, False])
+        out = lib.maybe_convert_objects(arr, convert_to_nullable_dtype=True)
+        tm.assert_numpy_array_equal(out, exp)
+
+        arr = np.array([True, False, pd.NaT], dtype=object)
+        exp = np.array([True, False, pd.NaT], dtype=object)
+        out = lib.maybe_convert_objects(arr, convert_to_nullable_dtype=True)
+        tm.assert_numpy_array_equal(out, exp)
+
+    @pytest.mark.parametrize("val", [None, np.nan])
+    def test_maybe_convert_objects_nullable_boolean_na(self, val):
+        # GH50047
+        arr = np.array([True, False, val], dtype=object)
+        exp = BooleanArray(
+            np.array([True, False, False]), np.array([False, False, True])
+        )
+        out = lib.maybe_convert_objects(arr, convert_to_nullable_dtype=True)
+        tm.assert_extension_array_equal(out, exp)
+
+    @pytest.mark.parametrize(
+        "data0",
+        [
+            True,
+            1,
+            1.0,
+            1.0 + 1.0j,
+            np.int8(1),
+            np.int16(1),
+            np.int32(1),
+            np.int64(1),
+            np.float16(1),
+            np.float32(1),
+            np.float64(1),
+            np.complex64(1),
+            np.complex128(1),
+        ],
+    )
+    @pytest.mark.parametrize(
+        "data1",
+        [
+            True,
+            1,
+            1.0,
+            1.0 + 1.0j,
+            np.int8(1),
+            np.int16(1),
+            np.int32(1),
+            np.int64(1),
+            np.float16(1),
+            np.float32(1),
+            np.float64(1),
+            np.complex64(1),
+            np.complex128(1),
+        ],
+    )
+    def test_maybe_convert_objects_itemsize(self, data0, data1):
+        # GH 40908
+        data = [data0, data1]
+        arr = np.array(data, dtype="object")
+
+        common_kind = np.result_type(type(data0), type(data1)).kind
+        kind0 = "python" if not hasattr(data0, "dtype") else data0.dtype.kind
+        kind1 = "python" if not hasattr(data1, "dtype") else data1.dtype.kind
+        if kind0 != "python" and kind1 != "python":
+            kind = common_kind
+            itemsize = max(data0.dtype.itemsize, data1.dtype.itemsize)
+        elif is_bool(data0) or is_bool(data1):
+            kind = "bool" if (is_bool(data0) and is_bool(data1)) else "object"
+            itemsize = ""
+        elif is_complex(data0) or is_complex(data1):
+            kind = common_kind
+            itemsize = 16
+        else:
+            kind = common_kind
+            itemsize = 8
+
+        expected = np.array(data, dtype=f"{kind}{itemsize}")
+        result = lib.maybe_convert_objects(arr)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_mixed_dtypes_remain_object_array(self):
+        # GH14956
+        arr = np.array([datetime(2015, 1, 1, tzinfo=pytz.utc), 1], dtype=object)
+        result = lib.maybe_convert_objects(arr, convert_non_numeric=True)
+        tm.assert_numpy_array_equal(result, arr)
+
+    @pytest.mark.parametrize(
+        "idx",
+        [
+            pd.IntervalIndex.from_breaks(range(5), closed="both"),
+            pd.period_range("2016-01-01", periods=3, freq="D"),
+        ],
+    )
+    def test_maybe_convert_objects_ea(self, idx):
+        result = lib.maybe_convert_objects(
+            np.array(idx, dtype=object),
+            convert_non_numeric=True,
+        )
+        tm.assert_extension_array_equal(result, idx._data)
+
+
+class TestTypeInference:
+    # Dummy class used for testing with Python objects
+    class Dummy:
+        pass
+
+    def test_inferred_dtype_fixture(self, any_skipna_inferred_dtype):
+        # see pandas/conftest.py
+        inferred_dtype, values = any_skipna_inferred_dtype
+
+        # make sure the inferred dtype of the fixture is as requested
+        assert inferred_dtype == lib.infer_dtype(values, skipna=True)
+
+    @pytest.mark.parametrize("skipna", [True, False])
+    def test_length_zero(self, skipna):
+        result = lib.infer_dtype(np.array([], dtype="i4"), skipna=skipna)
+        assert result == "integer"
+
+        result = lib.infer_dtype([], skipna=skipna)
+        assert result == "empty"
+
+        # GH 18004
+        arr = np.array([np.array([], dtype=object), np.array([], dtype=object)])
+        result = lib.infer_dtype(arr, skipna=skipna)
+        assert result == "empty"
+
+    def test_integers(self):
+        arr = np.array([1, 2, 3, np.int64(4), np.int32(5)], dtype="O")
+        result = lib.infer_dtype(arr, skipna=True)
+        assert result == "integer"
+
+        arr = np.array([1, 2, 3, np.int64(4), np.int32(5), "foo"], dtype="O")
+        result = lib.infer_dtype(arr, skipna=True)
+        assert result == "mixed-integer"
+
+        arr = np.array([1, 2, 3, 4, 5], dtype="i4")
+        result = lib.infer_dtype(arr, skipna=True)
+        assert result == "integer"
+
+    @pytest.mark.parametrize(
+        "arr, skipna",
+        [
+            (np.array([1, 2, np.nan, np.nan, 3], dtype="O"), False),
+            (np.array([1, 2, np.nan, np.nan, 3], dtype="O"), True),
+            (np.array([1, 2, 3, np.int64(4), np.int32(5), np.nan], dtype="O"), False),
+            (np.array([1, 2, 3, np.int64(4), np.int32(5), np.nan], dtype="O"), True),
+        ],
+    )
+    def test_integer_na(self, arr, skipna):
+        # GH 27392
+        result = lib.infer_dtype(arr, skipna=skipna)
+        expected = "integer" if skipna else "integer-na"
+        assert result == expected
+
+    def test_infer_dtype_skipna_default(self):
+        # infer_dtype `skipna` default deprecated in GH#24050,
+        #  changed to True in GH#29876
+        arr = np.array([1, 2, 3, np.nan], dtype=object)
+
+        result = lib.infer_dtype(arr)
+        assert result == "integer"
+
+    def test_bools(self):
+        arr = np.array([True, False, True, True, True], dtype="O")
+        result = lib.infer_dtype(arr, skipna=True)
+        assert result == "boolean"
+
+        arr = np.array([np.bool_(True), np.bool_(False)], dtype="O")
+        result = lib.infer_dtype(arr, skipna=True)
+        assert result == "boolean"
+
+        arr = np.array([True, False, True, "foo"], dtype="O")
+        result = lib.infer_dtype(arr, skipna=True)
+        assert result == "mixed"
+
+        arr = np.array([True, False, True], dtype=bool)
+        result = lib.infer_dtype(arr, skipna=True)
+        assert result == "boolean"
+
+        arr = np.array([True, np.nan, False], dtype="O")
+        result = lib.infer_dtype(arr, skipna=True)
+        assert result == "boolean"
+
+        result = lib.infer_dtype(arr, skipna=False)
+        assert result == "mixed"
+
+    def test_floats(self):
+        arr = np.array([1.0, 2.0, 3.0, np.float64(4), np.float32(5)], dtype="O")
+        result = lib.infer_dtype(arr, skipna=True)
+        assert result == "floating"
+
+        arr = np.array([1, 2, 3, np.float64(4), np.float32(5), "foo"], dtype="O")
+        result = lib.infer_dtype(arr, skipna=True)
+        assert result == "mixed-integer"
+
+        arr = np.array([1, 2, 3, 4, 5], dtype="f4")
+        result = lib.infer_dtype(arr, skipna=True)
+        assert result == "floating"
+
+        arr = np.array([1, 2, 3, 4, 5], dtype="f8")
+        result = lib.infer_dtype(arr, skipna=True)
+        assert result == "floating"
+
+    def test_decimals(self):
+        # GH15690
+        arr = np.array([Decimal(1), Decimal(2), Decimal(3)])
+        result = lib.infer_dtype(arr, skipna=True)
+        assert result == "decimal"
+
+        arr = np.array([1.0, 2.0, Decimal(3)])
+        result = lib.infer_dtype(arr, skipna=True)
+        assert result == "mixed"
+
+        result = lib.infer_dtype(arr[::-1], skipna=True)
+        assert result == "mixed"
+
+        arr = np.array([Decimal(1), Decimal("NaN"), Decimal(3)])
+        result = lib.infer_dtype(arr, skipna=True)
+        assert result == "decimal"
+
+        arr = np.array([Decimal(1), np.nan, Decimal(3)], dtype="O")
+        result = lib.infer_dtype(arr, skipna=True)
+        assert result == "decimal"
+
+    # complex is compatible with nan, so skipna has no effect
+    @pytest.mark.parametrize("skipna", [True, False])
+    def test_complex(self, skipna):
+        # gets cast to complex on array construction
+        arr = np.array([1.0, 2.0, 1 + 1j])
+        result = lib.infer_dtype(arr, skipna=skipna)
+        assert result == "complex"
+
+        arr = np.array([1.0, 2.0, 1 + 1j], dtype="O")
+        result = lib.infer_dtype(arr, skipna=skipna)
+        assert result == "mixed"
+
+        result = lib.infer_dtype(arr[::-1], skipna=skipna)
+        assert result == "mixed"
+
+        # gets cast to complex on array construction
+        arr = np.array([1, np.nan, 1 + 1j])
+        result = lib.infer_dtype(arr, skipna=skipna)
+        assert result == "complex"
+
+        arr = np.array([1.0, np.nan, 1 + 1j], dtype="O")
+        result = lib.infer_dtype(arr, skipna=skipna)
+        assert result == "mixed"
+
+        # complex with nans stays complex
+        arr = np.array([1 + 1j, np.nan, 3 + 3j], dtype="O")
+        result = lib.infer_dtype(arr, skipna=skipna)
+        assert result == "complex"
+
+        # test smaller complex dtype; will pass through _try_infer_map fastpath
+        arr = np.array([1 + 1j, np.nan, 3 + 3j], dtype=np.complex64)
+        result = lib.infer_dtype(arr, skipna=skipna)
+        assert result == "complex"
+
+    def test_string(self):
+        pass
+
+    def test_unicode(self):
+        arr = ["a", np.nan, "c"]
+        result = lib.infer_dtype(arr, skipna=False)
+        # This currently returns "mixed", but it's not clear that's optimal.
+        # This could also return "string" or "mixed-string"
+        assert result == "mixed"
+
+        # even though we use skipna, we are only skipping those NAs that are
+        #  considered matching by is_string_array
+        arr = ["a", np.nan, "c"]
+        result = lib.infer_dtype(arr, skipna=True)
+        assert result == "string"
+
+        arr = ["a", pd.NA, "c"]
+        result = lib.infer_dtype(arr, skipna=True)
+        assert result == "string"
+
+        arr = ["a", pd.NaT, "c"]
+        result = lib.infer_dtype(arr, skipna=True)
+        assert result == "mixed"
+
+        arr = ["a", "c"]
+        result = lib.infer_dtype(arr, skipna=False)
+        assert result == "string"
+
+    @pytest.mark.parametrize(
+        "dtype, missing, skipna, expected",
+        [
+            (float, np.nan, False, "floating"),
+            (float, np.nan, True, "floating"),
+            (object, np.nan, False, "floating"),
+            (object, np.nan, True, "empty"),
+            (object, None, False, "mixed"),
+            (object, None, True, "empty"),
+        ],
+    )
+    @pytest.mark.parametrize("box", [Series, np.array])
+    def test_object_empty(self, box, missing, dtype, skipna, expected):
+        # GH 23421
+        arr = box([missing, missing], dtype=dtype)
+
+        result = lib.infer_dtype(arr, skipna=skipna)
+        assert result == expected
+
+    def test_datetime(self):
+        dates = [datetime(2012, 1, x) for x in range(1, 20)]
+        index = Index(dates)
+        assert index.inferred_type == "datetime64"
+
+    def test_infer_dtype_datetime64(self):
+        arr = np.array(
+            [np.datetime64("2011-01-01"), np.datetime64("2011-01-01")], dtype=object
+        )
+        assert lib.infer_dtype(arr, skipna=True) == "datetime64"
+
+    @pytest.mark.parametrize("na_value", [pd.NaT, np.nan])
+    def test_infer_dtype_datetime64_with_na(self, na_value):
+        # starts with nan
+        arr = np.array([na_value, np.datetime64("2011-01-02")])
+        assert lib.infer_dtype(arr, skipna=True) == "datetime64"
+
+        arr = np.array([na_value, np.datetime64("2011-01-02"), na_value])
+        assert lib.infer_dtype(arr, skipna=True) == "datetime64"
+
+    @pytest.mark.parametrize(
+        "arr",
+        [
+            np.array(
+                [np.timedelta64("nat"), np.datetime64("2011-01-02")], dtype=object
+            ),
+            np.array(
+                [np.datetime64("2011-01-02"), np.timedelta64("nat")], dtype=object
+            ),
+            np.array([np.datetime64("2011-01-01"), Timestamp("2011-01-02")]),
+            np.array([Timestamp("2011-01-02"), np.datetime64("2011-01-01")]),
+            np.array([np.nan, Timestamp("2011-01-02"), 1.1]),
+            np.array([np.nan, "2011-01-01", Timestamp("2011-01-02")], dtype=object),
+            np.array([np.datetime64("nat"), np.timedelta64(1, "D")], dtype=object),
+            np.array([np.timedelta64(1, "D"), np.datetime64("nat")], dtype=object),
+        ],
+    )
+    def test_infer_datetimelike_dtype_mixed(self, arr):
+        assert lib.infer_dtype(arr, skipna=False) == "mixed"
+
+    def test_infer_dtype_mixed_integer(self):
+        arr = np.array([np.nan, Timestamp("2011-01-02"), 1])
+        assert lib.infer_dtype(arr, skipna=True) == "mixed-integer"
+
+    @pytest.mark.parametrize(
+        "arr",
+        [
+            np.array([Timestamp("2011-01-01"), Timestamp("2011-01-02")]),
+            np.array([datetime(2011, 1, 1), datetime(2012, 2, 1)]),
+            np.array([datetime(2011, 1, 1), Timestamp("2011-01-02")]),
+        ],
+    )
+    def test_infer_dtype_datetime(self, arr):
+        assert lib.infer_dtype(arr, skipna=True) == "datetime"
+
+    @pytest.mark.parametrize("na_value", [pd.NaT, np.nan])
+    @pytest.mark.parametrize(
+        "time_stamp", [Timestamp("2011-01-01"), datetime(2011, 1, 1)]
+    )
+    def test_infer_dtype_datetime_with_na(self, na_value, time_stamp):
+        # starts with nan
+        arr = np.array([na_value, time_stamp])
+        assert lib.infer_dtype(arr, skipna=True) == "datetime"
+
+        arr = np.array([na_value, time_stamp, na_value])
+        assert lib.infer_dtype(arr, skipna=True) == "datetime"
+
+    @pytest.mark.parametrize(
+        "arr",
+        [
+            np.array([Timedelta("1 days"), Timedelta("2 days")]),
+            np.array([np.timedelta64(1, "D"), np.timedelta64(2, "D")], dtype=object),
+            np.array([timedelta(1), timedelta(2)]),
+        ],
+    )
+    def test_infer_dtype_timedelta(self, arr):
+        assert lib.infer_dtype(arr, skipna=True) == "timedelta"
+
+    @pytest.mark.parametrize("na_value", [pd.NaT, np.nan])
+    @pytest.mark.parametrize(
+        "delta", [Timedelta("1 days"), np.timedelta64(1, "D"), timedelta(1)]
+    )
+    def test_infer_dtype_timedelta_with_na(self, na_value, delta):
+        # starts with nan
+        arr = np.array([na_value, delta])
+        assert lib.infer_dtype(arr, skipna=True) == "timedelta"
+
+        arr = np.array([na_value, delta, na_value])
+        assert lib.infer_dtype(arr, skipna=True) == "timedelta"
+
+    def test_infer_dtype_period(self):
+        # GH 13664
+        arr = np.array([Period("2011-01", freq="D"), Period("2011-02", freq="D")])
+        assert lib.infer_dtype(arr, skipna=True) == "period"
+
+        # non-homogeneous freqs -> mixed
+        arr = np.array([Period("2011-01", freq="D"), Period("2011-02", freq="M")])
+        assert lib.infer_dtype(arr, skipna=True) == "mixed"
+
+    @pytest.mark.parametrize("klass", [pd.array, Series, Index])
+    @pytest.mark.parametrize("skipna", [True, False])
+    def test_infer_dtype_period_array(self, klass, skipna):
+        # https://github.com/pandas-dev/pandas/issues/23553
+        values = klass(
+            [
+                Period("2011-01-01", freq="D"),
+                Period("2011-01-02", freq="D"),
+                pd.NaT,
+            ]
+        )
+        assert lib.infer_dtype(values, skipna=skipna) == "period"
+
+        # periods but mixed freq
+        values = klass(
+            [
+                Period("2011-01-01", freq="D"),
+                Period("2011-01-02", freq="M"),
+                pd.NaT,
+            ]
+        )
+        # with pd.array this becomes NumpyExtensionArray which ends up
+        #  as "unknown-array"
+        exp = "unknown-array" if klass is pd.array else "mixed"
+        assert lib.infer_dtype(values, skipna=skipna) == exp
+
+    def test_infer_dtype_period_mixed(self):
+        arr = np.array(
+            [Period("2011-01", freq="M"), np.datetime64("nat")], dtype=object
+        )
+        assert lib.infer_dtype(arr, skipna=False) == "mixed"
+
+        arr = np.array(
+            [np.datetime64("nat"), Period("2011-01", freq="M")], dtype=object
+        )
+        assert lib.infer_dtype(arr, skipna=False) == "mixed"
+
+    @pytest.mark.parametrize("na_value", [pd.NaT, np.nan])
+    def test_infer_dtype_period_with_na(self, na_value):
+        # starts with nan
+        arr = np.array([na_value, Period("2011-01", freq="D")])
+        assert lib.infer_dtype(arr, skipna=True) == "period"
+
+        arr = np.array([na_value, Period("2011-01", freq="D"), na_value])
+        assert lib.infer_dtype(arr, skipna=True) == "period"
+
+    def test_infer_dtype_all_nan_nat_like(self):
+        arr = np.array([np.nan, np.nan])
+        assert lib.infer_dtype(arr, skipna=True) == "floating"
+
+        # nan and None mix are result in mixed
+        arr = np.array([np.nan, np.nan, None])
+        assert lib.infer_dtype(arr, skipna=True) == "empty"
+        assert lib.infer_dtype(arr, skipna=False) == "mixed"
+
+        arr = np.array([None, np.nan, np.nan])
+        assert lib.infer_dtype(arr, skipna=True) == "empty"
+        assert lib.infer_dtype(arr, skipna=False) == "mixed"
+
+        # pd.NaT
+        arr = np.array([pd.NaT])
+        assert lib.infer_dtype(arr, skipna=False) == "datetime"
+
+        arr = np.array([pd.NaT, np.nan])
+        assert lib.infer_dtype(arr, skipna=False) == "datetime"
+
+        arr = np.array([np.nan, pd.NaT])
+        assert lib.infer_dtype(arr, skipna=False) == "datetime"
+
+        arr = np.array([np.nan, pd.NaT, np.nan])
+        assert lib.infer_dtype(arr, skipna=False) == "datetime"
+
+        arr = np.array([None, pd.NaT, None])
+        assert lib.infer_dtype(arr, skipna=False) == "datetime"
+
+        # np.datetime64(nat)
+        arr = np.array([np.datetime64("nat")])
+        assert lib.infer_dtype(arr, skipna=False) == "datetime64"
+
+        for n in [np.nan, pd.NaT, None]:
+            arr = np.array([n, np.datetime64("nat"), n])
+            assert lib.infer_dtype(arr, skipna=False) == "datetime64"
+
+            arr = np.array([pd.NaT, n, np.datetime64("nat"), n])
+            assert lib.infer_dtype(arr, skipna=False) == "datetime64"
+
+        arr = np.array([np.timedelta64("nat")], dtype=object)
+        assert lib.infer_dtype(arr, skipna=False) == "timedelta"
+
+        for n in [np.nan, pd.NaT, None]:
+            arr = np.array([n, np.timedelta64("nat"), n])
+            assert lib.infer_dtype(arr, skipna=False) == "timedelta"
+
+            arr = np.array([pd.NaT, n, np.timedelta64("nat"), n])
+            assert lib.infer_dtype(arr, skipna=False) == "timedelta"
+
+        # datetime / timedelta mixed
+        arr = np.array([pd.NaT, np.datetime64("nat"), np.timedelta64("nat"), np.nan])
+        assert lib.infer_dtype(arr, skipna=False) == "mixed"
+
+        arr = np.array([np.timedelta64("nat"), np.datetime64("nat")], dtype=object)
+        assert lib.infer_dtype(arr, skipna=False) == "mixed"
+
+    def test_is_datetimelike_array_all_nan_nat_like(self):
+        arr = np.array([np.nan, pd.NaT, np.datetime64("nat")])
+        assert lib.is_datetime_array(arr)
+        assert lib.is_datetime64_array(arr)
+        assert not lib.is_timedelta_or_timedelta64_array(arr)
+
+        arr = np.array([np.nan, pd.NaT, np.timedelta64("nat")])
+        assert not lib.is_datetime_array(arr)
+        assert not lib.is_datetime64_array(arr)
+        assert lib.is_timedelta_or_timedelta64_array(arr)
+
+        arr = np.array([np.nan, pd.NaT, np.datetime64("nat"), np.timedelta64("nat")])
+        assert not lib.is_datetime_array(arr)
+        assert not lib.is_datetime64_array(arr)
+        assert not lib.is_timedelta_or_timedelta64_array(arr)
+
+        arr = np.array([np.nan, pd.NaT])
+        assert lib.is_datetime_array(arr)
+        assert lib.is_datetime64_array(arr)
+        assert lib.is_timedelta_or_timedelta64_array(arr)
+
+        arr = np.array([np.nan, np.nan], dtype=object)
+        assert not lib.is_datetime_array(arr)
+        assert not lib.is_datetime64_array(arr)
+        assert not lib.is_timedelta_or_timedelta64_array(arr)
+
+        assert lib.is_datetime_with_singletz_array(
+            np.array(
+                [
+                    Timestamp("20130101", tz="US/Eastern"),
+                    Timestamp("20130102", tz="US/Eastern"),
+                ],
+                dtype=object,
+            )
+        )
+        assert not lib.is_datetime_with_singletz_array(
+            np.array(
+                [
+                    Timestamp("20130101", tz="US/Eastern"),
+                    Timestamp("20130102", tz="CET"),
+                ],
+                dtype=object,
+            )
+        )
+
+    @pytest.mark.parametrize(
+        "func",
+        [
+            "is_datetime_array",
+            "is_datetime64_array",
+            "is_bool_array",
+            "is_timedelta_or_timedelta64_array",
+            "is_date_array",
+            "is_time_array",
+            "is_interval_array",
+        ],
+    )
+    def test_other_dtypes_for_array(self, func):
+        func = getattr(lib, func)
+        arr = np.array(["foo", "bar"])
+        assert not func(arr)
+        assert not func(arr.reshape(2, 1))
+
+        arr = np.array([1, 2])
+        assert not func(arr)
+        assert not func(arr.reshape(2, 1))
+
+    def test_date(self):
+        dates = [date(2012, 1, day) for day in range(1, 20)]
+        index = Index(dates)
+        assert index.inferred_type == "date"
+
+        dates = [date(2012, 1, day) for day in range(1, 20)] + [np.nan]
+        result = lib.infer_dtype(dates, skipna=False)
+        assert result == "mixed"
+
+        result = lib.infer_dtype(dates, skipna=True)
+        assert result == "date"
+
+    @pytest.mark.parametrize(
+        "values",
+        [
+            [date(2020, 1, 1), Timestamp("2020-01-01")],
+            [Timestamp("2020-01-01"), date(2020, 1, 1)],
+            [date(2020, 1, 1), pd.NaT],
+            [pd.NaT, date(2020, 1, 1)],
+        ],
+    )
+    @pytest.mark.parametrize("skipna", [True, False])
+    def test_infer_dtype_date_order_invariant(self, values, skipna):
+        # https://github.com/pandas-dev/pandas/issues/33741
+        result = lib.infer_dtype(values, skipna=skipna)
+        assert result == "date"
+
+    def test_is_numeric_array(self):
+        assert lib.is_float_array(np.array([1, 2.0]))
+        assert lib.is_float_array(np.array([1, 2.0, np.nan]))
+        assert not lib.is_float_array(np.array([1, 2]))
+
+        assert lib.is_integer_array(np.array([1, 2]))
+        assert not lib.is_integer_array(np.array([1, 2.0]))
+
+    def test_is_string_array(self):
+        # We should only be accepting pd.NA, np.nan,
+        # other floating point nans e.g. float('nan')]
+        # when skipna is True.
+        assert lib.is_string_array(np.array(["foo", "bar"]))
+        assert not lib.is_string_array(
+            np.array(["foo", "bar", pd.NA], dtype=object), skipna=False
+        )
+        assert lib.is_string_array(
+            np.array(["foo", "bar", pd.NA], dtype=object), skipna=True
+        )
+        # we allow NaN/None in the StringArray constructor, so its allowed here
+        assert lib.is_string_array(
+            np.array(["foo", "bar", None], dtype=object), skipna=True
+        )
+        assert lib.is_string_array(
+            np.array(["foo", "bar", np.nan], dtype=object), skipna=True
+        )
+        # But not e.g. datetimelike or Decimal NAs
+        assert not lib.is_string_array(
+            np.array(["foo", "bar", pd.NaT], dtype=object), skipna=True
+        )
+        assert not lib.is_string_array(
+            np.array(["foo", "bar", np.datetime64("NaT")], dtype=object), skipna=True
+        )
+        assert not lib.is_string_array(
+            np.array(["foo", "bar", Decimal("NaN")], dtype=object), skipna=True
+        )
+
+        assert not lib.is_string_array(
+            np.array(["foo", "bar", None], dtype=object), skipna=False
+        )
+        assert not lib.is_string_array(
+            np.array(["foo", "bar", np.nan], dtype=object), skipna=False
+        )
+        assert not lib.is_string_array(np.array([1, 2]))
+
+    def test_to_object_array_tuples(self):
+        r = (5, 6)
+        values = [r]
+        lib.to_object_array_tuples(values)
+
+        # make sure record array works
+        record = namedtuple("record", "x y")
+        r = record(5, 6)
+        values = [r]
+        lib.to_object_array_tuples(values)
+
+    def test_object(self):
+        # GH 7431
+        # cannot infer more than this as only a single element
+        arr = np.array([None], dtype="O")
+        result = lib.infer_dtype(arr, skipna=False)
+        assert result == "mixed"
+        result = lib.infer_dtype(arr, skipna=True)
+        assert result == "empty"
+
+    def test_to_object_array_width(self):
+        # see gh-13320
+        rows = [[1, 2, 3], [4, 5, 6]]
+
+        expected = np.array(rows, dtype=object)
+        out = lib.to_object_array(rows)
+        tm.assert_numpy_array_equal(out, expected)
+
+        expected = np.array(rows, dtype=object)
+        out = lib.to_object_array(rows, min_width=1)
+        tm.assert_numpy_array_equal(out, expected)
+
+        expected = np.array(
+            [[1, 2, 3, None, None], [4, 5, 6, None, None]], dtype=object
+        )
+        out = lib.to_object_array(rows, min_width=5)
+        tm.assert_numpy_array_equal(out, expected)
+
+    def test_is_period(self):
+        # GH#55264
+        msg = "is_period is deprecated and will be removed in a future version"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            assert lib.is_period(Period("2011-01", freq="M"))
+            assert not lib.is_period(PeriodIndex(["2011-01"], freq="M"))
+            assert not lib.is_period(Timestamp("2011-01"))
+            assert not lib.is_period(1)
+            assert not lib.is_period(np.nan)
+
+    def test_is_interval(self):
+        # GH#55264
+        msg = "is_interval is deprecated and will be removed in a future version"
+        item = Interval(1, 2)
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            assert lib.is_interval(item)
+            assert not lib.is_interval(pd.IntervalIndex([item]))
+            assert not lib.is_interval(pd.IntervalIndex([item])._engine)
+
+    def test_categorical(self):
+        # GH 8974
+        arr = Categorical(list("abc"))
+        result = lib.infer_dtype(arr, skipna=True)
+        assert result == "categorical"
+
+        result = lib.infer_dtype(Series(arr), skipna=True)
+        assert result == "categorical"
+
+        arr = Categorical(list("abc"), categories=["cegfab"], ordered=True)
+        result = lib.infer_dtype(arr, skipna=True)
+        assert result == "categorical"
+
+        result = lib.infer_dtype(Series(arr), skipna=True)
+        assert result == "categorical"
+
+    @pytest.mark.parametrize("asobject", [True, False])
+    def test_interval(self, asobject):
+        idx = pd.IntervalIndex.from_breaks(range(5), closed="both")
+        if asobject:
+            idx = idx.astype(object)
+
+        inferred = lib.infer_dtype(idx, skipna=False)
+        assert inferred == "interval"
+
+        inferred = lib.infer_dtype(idx._data, skipna=False)
+        assert inferred == "interval"
+
+        inferred = lib.infer_dtype(Series(idx, dtype=idx.dtype), skipna=False)
+        assert inferred == "interval"
+
+    @pytest.mark.parametrize("value", [Timestamp(0), Timedelta(0), 0, 0.0])
+    def test_interval_mismatched_closed(self, value):
+        first = Interval(value, value, closed="left")
+        second = Interval(value, value, closed="right")
+
+        # if closed match, we should infer "interval"
+        arr = np.array([first, first], dtype=object)
+        assert lib.infer_dtype(arr, skipna=False) == "interval"
+
+        # if closed dont match, we should _not_ get "interval"
+        arr2 = np.array([first, second], dtype=object)
+        assert lib.infer_dtype(arr2, skipna=False) == "mixed"
+
+    def test_interval_mismatched_subtype(self):
+        first = Interval(0, 1, closed="left")
+        second = Interval(Timestamp(0), Timestamp(1), closed="left")
+        third = Interval(Timedelta(0), Timedelta(1), closed="left")
+
+        arr = np.array([first, second])
+        assert lib.infer_dtype(arr, skipna=False) == "mixed"
+
+        arr = np.array([second, third])
+        assert lib.infer_dtype(arr, skipna=False) == "mixed"
+
+        arr = np.array([first, third])
+        assert lib.infer_dtype(arr, skipna=False) == "mixed"
+
+        # float vs int subdtype are compatible
+        flt_interval = Interval(1.5, 2.5, closed="left")
+        arr = np.array([first, flt_interval], dtype=object)
+        assert lib.infer_dtype(arr, skipna=False) == "interval"
+
+    @pytest.mark.parametrize("klass", [pd.array, Series])
+    @pytest.mark.parametrize("skipna", [True, False])
+    @pytest.mark.parametrize("data", [["a", "b", "c"], ["a", "b", pd.NA]])
+    def test_string_dtype(self, data, skipna, klass, nullable_string_dtype):
+        # StringArray
+        val = klass(data, dtype=nullable_string_dtype)
+        inferred = lib.infer_dtype(val, skipna=skipna)
+        assert inferred == "string"
+
+    @pytest.mark.parametrize("klass", [pd.array, Series])
+    @pytest.mark.parametrize("skipna", [True, False])
+    @pytest.mark.parametrize("data", [[True, False, True], [True, False, pd.NA]])
+    def test_boolean_dtype(self, data, skipna, klass):
+        # BooleanArray
+        val = klass(data, dtype="boolean")
+        inferred = lib.infer_dtype(val, skipna=skipna)
+        assert inferred == "boolean"
+
+
+class TestNumberScalar:
+    def test_is_number(self):
+        assert is_number(True)
+        assert is_number(1)
+        assert is_number(1.1)
+        assert is_number(1 + 3j)
+        assert is_number(np.int64(1))
+        assert is_number(np.float64(1.1))
+        assert is_number(np.complex128(1 + 3j))
+        assert is_number(np.nan)
+
+        assert not is_number(None)
+        assert not is_number("x")
+        assert not is_number(datetime(2011, 1, 1))
+        assert not is_number(np.datetime64("2011-01-01"))
+        assert not is_number(Timestamp("2011-01-01"))
+        assert not is_number(Timestamp("2011-01-01", tz="US/Eastern"))
+        assert not is_number(timedelta(1000))
+        assert not is_number(Timedelta("1 days"))
+
+        # questionable
+        assert not is_number(np.bool_(False))
+        assert is_number(np.timedelta64(1, "D"))
+
+    def test_is_bool(self):
+        assert is_bool(True)
+        assert is_bool(False)
+        assert is_bool(np.bool_(False))
+
+        assert not is_bool(1)
+        assert not is_bool(1.1)
+        assert not is_bool(1 + 3j)
+        assert not is_bool(np.int64(1))
+        assert not is_bool(np.float64(1.1))
+        assert not is_bool(np.complex128(1 + 3j))
+        assert not is_bool(np.nan)
+        assert not is_bool(None)
+        assert not is_bool("x")
+        assert not is_bool(datetime(2011, 1, 1))
+        assert not is_bool(np.datetime64("2011-01-01"))
+        assert not is_bool(Timestamp("2011-01-01"))
+        assert not is_bool(Timestamp("2011-01-01", tz="US/Eastern"))
+        assert not is_bool(timedelta(1000))
+        assert not is_bool(np.timedelta64(1, "D"))
+        assert not is_bool(Timedelta("1 days"))
+
+    def test_is_integer(self):
+        assert is_integer(1)
+        assert is_integer(np.int64(1))
+
+        assert not is_integer(True)
+        assert not is_integer(1.1)
+        assert not is_integer(1 + 3j)
+        assert not is_integer(False)
+        assert not is_integer(np.bool_(False))
+        assert not is_integer(np.float64(1.1))
+        assert not is_integer(np.complex128(1 + 3j))
+        assert not is_integer(np.nan)
+        assert not is_integer(None)
+        assert not is_integer("x")
+        assert not is_integer(datetime(2011, 1, 1))
+        assert not is_integer(np.datetime64("2011-01-01"))
+        assert not is_integer(Timestamp("2011-01-01"))
+        assert not is_integer(Timestamp("2011-01-01", tz="US/Eastern"))
+        assert not is_integer(timedelta(1000))
+        assert not is_integer(Timedelta("1 days"))
+        assert not is_integer(np.timedelta64(1, "D"))
+
+    def test_is_float(self):
+        assert is_float(1.1)
+        assert is_float(np.float64(1.1))
+        assert is_float(np.nan)
+
+        assert not is_float(True)
+        assert not is_float(1)
+        assert not is_float(1 + 3j)
+        assert not is_float(False)
+        assert not is_float(np.bool_(False))
+        assert not is_float(np.int64(1))
+        assert not is_float(np.complex128(1 + 3j))
+        assert not is_float(None)
+        assert not is_float("x")
+        assert not is_float(datetime(2011, 1, 1))
+        assert not is_float(np.datetime64("2011-01-01"))
+        assert not is_float(Timestamp("2011-01-01"))
+        assert not is_float(Timestamp("2011-01-01", tz="US/Eastern"))
+        assert not is_float(timedelta(1000))
+        assert not is_float(np.timedelta64(1, "D"))
+        assert not is_float(Timedelta("1 days"))
+
+    def test_is_datetime_dtypes(self):
+        ts = pd.date_range("20130101", periods=3)
+        tsa = pd.date_range("20130101", periods=3, tz="US/Eastern")
+
+        msg = "is_datetime64tz_dtype is deprecated"
+
+        assert is_datetime64_dtype("datetime64")
+        assert is_datetime64_dtype("datetime64[ns]")
+        assert is_datetime64_dtype(ts)
+        assert not is_datetime64_dtype(tsa)
+
+        assert not is_datetime64_ns_dtype("datetime64")
+        assert is_datetime64_ns_dtype("datetime64[ns]")
+        assert is_datetime64_ns_dtype(ts)
+        assert is_datetime64_ns_dtype(tsa)
+
+        assert is_datetime64_any_dtype("datetime64")
+        assert is_datetime64_any_dtype("datetime64[ns]")
+        assert is_datetime64_any_dtype(ts)
+        assert is_datetime64_any_dtype(tsa)
+
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            assert not is_datetime64tz_dtype("datetime64")
+            assert not is_datetime64tz_dtype("datetime64[ns]")
+            assert not is_datetime64tz_dtype(ts)
+            assert is_datetime64tz_dtype(tsa)
+
+    @pytest.mark.parametrize("tz", ["US/Eastern", "UTC"])
+    def test_is_datetime_dtypes_with_tz(self, tz):
+        dtype = f"datetime64[ns, {tz}]"
+        assert not is_datetime64_dtype(dtype)
+
+        msg = "is_datetime64tz_dtype is deprecated"
+        with tm.assert_produces_warning(DeprecationWarning, match=msg):
+            assert is_datetime64tz_dtype(dtype)
+        assert is_datetime64_ns_dtype(dtype)
+        assert is_datetime64_any_dtype(dtype)
+
+    def test_is_timedelta(self):
+        assert is_timedelta64_dtype("timedelta64")
+        assert is_timedelta64_dtype("timedelta64[ns]")
+        assert not is_timedelta64_ns_dtype("timedelta64")
+        assert is_timedelta64_ns_dtype("timedelta64[ns]")
+
+        tdi = TimedeltaIndex([1e14, 2e14], dtype="timedelta64[ns]")
+        assert is_timedelta64_dtype(tdi)
+        assert is_timedelta64_ns_dtype(tdi)
+        assert is_timedelta64_ns_dtype(tdi.astype("timedelta64[ns]"))
+
+        assert not is_timedelta64_ns_dtype(Index([], dtype=np.float64))
+        assert not is_timedelta64_ns_dtype(Index([], dtype=np.int64))
+
+
+class TestIsScalar:
+    def test_is_scalar_builtin_scalars(self):
+        assert is_scalar(None)
+        assert is_scalar(True)
+        assert is_scalar(False)
+        assert is_scalar(Fraction())
+        assert is_scalar(0.0)
+        assert is_scalar(1)
+        assert is_scalar(complex(2))
+        assert is_scalar(float("NaN"))
+        assert is_scalar(np.nan)
+        assert is_scalar("foobar")
+        assert is_scalar(b"foobar")
+        assert is_scalar(datetime(2014, 1, 1))
+        assert is_scalar(date(2014, 1, 1))
+        assert is_scalar(time(12, 0))
+        assert is_scalar(timedelta(hours=1))
+        assert is_scalar(pd.NaT)
+        assert is_scalar(pd.NA)
+
+    def test_is_scalar_builtin_nonscalars(self):
+        assert not is_scalar({})
+        assert not is_scalar([])
+        assert not is_scalar([1])
+        assert not is_scalar(())
+        assert not is_scalar((1,))
+        assert not is_scalar(slice(None))
+        assert not is_scalar(Ellipsis)
+
+    def test_is_scalar_numpy_array_scalars(self):
+        assert is_scalar(np.int64(1))
+        assert is_scalar(np.float64(1.0))
+        assert is_scalar(np.int32(1))
+        assert is_scalar(np.complex64(2))
+        assert is_scalar(np.object_("foobar"))
+        assert is_scalar(np.str_("foobar"))
+        assert is_scalar(np.bytes_(b"foobar"))
+        assert is_scalar(np.datetime64("2014-01-01"))
+        assert is_scalar(np.timedelta64(1, "h"))
+
+    @pytest.mark.parametrize(
+        "zerodim",
+        [
+            np.array(1),
+            np.array("foobar"),
+            np.array(np.datetime64("2014-01-01")),
+            np.array(np.timedelta64(1, "h")),
+            np.array(np.datetime64("NaT")),
+        ],
+    )
+    def test_is_scalar_numpy_zerodim_arrays(self, zerodim):
+        assert not is_scalar(zerodim)
+        assert is_scalar(lib.item_from_zerodim(zerodim))
+
+    @pytest.mark.parametrize("arr", [np.array([]), np.array([[]])])
+    def test_is_scalar_numpy_arrays(self, arr):
+        assert not is_scalar(arr)
+        assert not is_scalar(MockNumpyLikeArray(arr))
+
+    def test_is_scalar_pandas_scalars(self):
+        assert is_scalar(Timestamp("2014-01-01"))
+        assert is_scalar(Timedelta(hours=1))
+        assert is_scalar(Period("2014-01-01"))
+        assert is_scalar(Interval(left=0, right=1))
+        assert is_scalar(DateOffset(days=1))
+        assert is_scalar(pd.offsets.Minute(3))
+
+    def test_is_scalar_pandas_containers(self):
+        assert not is_scalar(Series(dtype=object))
+        assert not is_scalar(Series([1]))
+        assert not is_scalar(DataFrame())
+        assert not is_scalar(DataFrame([[1]]))
+        assert not is_scalar(Index([]))
+        assert not is_scalar(Index([1]))
+        assert not is_scalar(Categorical([]))
+        assert not is_scalar(DatetimeIndex([])._data)
+        assert not is_scalar(TimedeltaIndex([])._data)
+        assert not is_scalar(DatetimeIndex([])._data.to_period("D"))
+        assert not is_scalar(pd.array([1, 2, 3]))
+
+    def test_is_scalar_number(self):
+        # Number() is not recognied by PyNumber_Check, so by extension
+        #  is not recognized by is_scalar, but instances of non-abstract
+        #  subclasses are.
+
+        class Numeric(Number):
+            def __init__(self, value) -> None:
+                self.value = value
+
+            def __int__(self) -> int:
+                return self.value
+
+        num = Numeric(1)
+        assert is_scalar(num)
+
+
+@pytest.mark.parametrize("unit", ["ms", "us", "ns"])
+def test_datetimeindex_from_empty_datetime64_array(unit):
+    idx = DatetimeIndex(np.array([], dtype=f"datetime64[{unit}]"))
+    assert len(idx) == 0
+
+
+def test_nan_to_nat_conversions():
+    df = DataFrame(
+        {"A": np.asarray(range(10), dtype="float64"), "B": Timestamp("20010101")}
+    )
+    df.iloc[3:6, :] = np.nan
+    result = df.loc[4, "B"]
+    assert result is pd.NaT
+
+    s = df["B"].copy()
+    s[8:9] = np.nan
+    assert s[8] is pd.NaT
+
+
+@pytest.mark.filterwarnings("ignore::PendingDeprecationWarning")
+def test_is_scipy_sparse(spmatrix):
+    pytest.importorskip("scipy")
+    assert is_scipy_sparse(spmatrix([[0, 1]]))
+    assert not is_scipy_sparse(np.array([1]))
+
+
+def test_ensure_int32():
+    values = np.arange(10, dtype=np.int32)
+    result = ensure_int32(values)
+    assert result.dtype == np.int32
+
+    values = np.arange(10, dtype=np.int64)
+    result = ensure_int32(values)
+    assert result.dtype == np.int32
+
+
+@pytest.mark.parametrize(
+    "right,result",
+    [
+        (0, np.uint8),
+        (-1, np.int16),
+        (300, np.uint16),
+        # For floats, we just upcast directly to float64 instead of trying to
+        # find a smaller floating dtype
+        (300.0, np.uint16),  # for integer floats, we convert them to ints
+        (300.1, np.float64),
+        (np.int16(300), np.int16 if np_version_gt2 else np.uint16),
+    ],
+)
+def test_find_result_type_uint_int(right, result):
+    left_dtype = np.dtype("uint8")
+    assert find_result_type(left_dtype, right) == result
+
+
+@pytest.mark.parametrize(
+    "right,result",
+    [
+        (0, np.int8),
+        (-1, np.int8),
+        (300, np.int16),
+        # For floats, we just upcast directly to float64 instead of trying to
+        # find a smaller floating dtype
+        (300.0, np.int16),  # for integer floats, we convert them to ints
+        (300.1, np.float64),
+        (np.int16(300), np.int16),
+    ],
+)
+def test_find_result_type_int_int(right, result):
+    left_dtype = np.dtype("int8")
+    assert find_result_type(left_dtype, right) == result
+
+
+@pytest.mark.parametrize(
+    "right,result",
+    [
+        (300.0, np.float64),
+        (np.float32(300), np.float32),
+    ],
+)
+def test_find_result_type_floats(right, result):
+    left_dtype = np.dtype("float16")
+    assert find_result_type(left_dtype, right) == result

mantis_evalkit/lib/python3.10/site-packages/pandas/tests/dtypes/test_missing.py

@@ -0,0 +1,923 @@
+from contextlib import nullcontext
+from datetime import datetime
+from decimal import Decimal
+
+import numpy as np
+import pytest
+
+from pandas._config import config as cf
+
+from pandas._libs import missing as libmissing
+from pandas._libs.tslibs import iNaT
+from pandas.compat.numpy import np_version_gte1p25
+
+from pandas.core.dtypes.common import (
+    is_float,
+    is_scalar,
+    pandas_dtype,
+)
+from pandas.core.dtypes.dtypes import (
+    CategoricalDtype,
+    DatetimeTZDtype,
+    IntervalDtype,
+    PeriodDtype,
+)
+from pandas.core.dtypes.missing import (
+    array_equivalent,
+    is_valid_na_for_dtype,
+    isna,
+    isnull,
+    na_value_for_dtype,
+    notna,
+    notnull,
+)
+
+import pandas as pd
+from pandas import (
+    DatetimeIndex,
+    Index,
+    NaT,
+    Series,
+    TimedeltaIndex,
+    date_range,
+    period_range,
+)
+import pandas._testing as tm
+
+fix_now = pd.Timestamp("2021-01-01")
+fix_utcnow = pd.Timestamp("2021-01-01", tz="UTC")
+
+
+@pytest.mark.parametrize("notna_f", [notna, notnull])
+def test_notna_notnull(notna_f):
+    assert notna_f(1.0)
+    assert not notna_f(None)
+    assert not notna_f(np.nan)
+
+    msg = "use_inf_as_na option is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        with cf.option_context("mode.use_inf_as_na", False):
+            assert notna_f(np.inf)
+            assert notna_f(-np.inf)
+
+            arr = np.array([1.5, np.inf, 3.5, -np.inf])
+            result = notna_f(arr)
+            assert result.all()
+
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        with cf.option_context("mode.use_inf_as_na", True):
+            assert not notna_f(np.inf)
+            assert not notna_f(-np.inf)
+
+            arr = np.array([1.5, np.inf, 3.5, -np.inf])
+            result = notna_f(arr)
+            assert result.sum() == 2
+
+
+@pytest.mark.parametrize("null_func", [notna, notnull, isna, isnull])
+@pytest.mark.parametrize(
+    "ser",
+    [
+        Series(
+            [str(i) for i in range(5)],
+            index=Index([str(i) for i in range(5)], dtype=object),
+            dtype=object,
+        ),
+        Series(range(5), date_range("2020-01-01", periods=5)),
+        Series(range(5), period_range("2020-01-01", periods=5)),
+    ],
+)
+def test_null_check_is_series(null_func, ser):
+    msg = "use_inf_as_na option is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        with cf.option_context("mode.use_inf_as_na", False):
+            assert isinstance(null_func(ser), Series)
+
+
+class TestIsNA:
+    def test_0d_array(self):
+        assert isna(np.array(np.nan))
+        assert not isna(np.array(0.0))
+        assert not isna(np.array(0))
+        # test object dtype
+        assert isna(np.array(np.nan, dtype=object))
+        assert not isna(np.array(0.0, dtype=object))
+        assert not isna(np.array(0, dtype=object))
+
+    @pytest.mark.parametrize("shape", [(4, 0), (4,)])
+    def test_empty_object(self, shape):
+        arr = np.empty(shape=shape, dtype=object)
+        result = isna(arr)
+        expected = np.ones(shape=shape, dtype=bool)
+        tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize("isna_f", [isna, isnull])
+    def test_isna_isnull(self, isna_f):
+        assert not isna_f(1.0)
+        assert isna_f(None)
+        assert isna_f(np.nan)
+        assert float("nan")
+        assert not isna_f(np.inf)
+        assert not isna_f(-np.inf)
+
+        # type
+        assert not isna_f(type(Series(dtype=object)))
+        assert not isna_f(type(Series(dtype=np.float64)))
+        assert not isna_f(type(pd.DataFrame()))
+
+    @pytest.mark.parametrize("isna_f", [isna, isnull])
+    @pytest.mark.parametrize(
+        "data",
+        [
+            np.arange(4, dtype=float),
+            [0.0, 1.0, 0.0, 1.0],
+            Series(list("abcd"), dtype=object),
+            date_range("2020-01-01", periods=4),
+        ],
+    )
+    @pytest.mark.parametrize(
+        "index",
+        [
+            date_range("2020-01-01", periods=4),
+            range(4),
+            period_range("2020-01-01", periods=4),
+        ],
+    )
+    def test_isna_isnull_frame(self, isna_f, data, index):
+        # frame
+        df = pd.DataFrame(data, index=index)
+        result = isna_f(df)
+        expected = df.apply(isna_f)
+        tm.assert_frame_equal(result, expected)
+
+    def test_isna_lists(self):
+        result = isna([[False]])
+        exp = np.array([[False]])
+        tm.assert_numpy_array_equal(result, exp)
+
+        result = isna([[1], [2]])
+        exp = np.array([[False], [False]])
+        tm.assert_numpy_array_equal(result, exp)
+
+        # list of strings / unicode
+        result = isna(["foo", "bar"])
+        exp = np.array([False, False])
+        tm.assert_numpy_array_equal(result, exp)
+
+        result = isna(["foo", "bar"])
+        exp = np.array([False, False])
+        tm.assert_numpy_array_equal(result, exp)
+
+        # GH20675
+        result = isna([np.nan, "world"])
+        exp = np.array([True, False])
+        tm.assert_numpy_array_equal(result, exp)
+
+    def test_isna_nat(self):
+        result = isna([NaT])
+        exp = np.array([True])
+        tm.assert_numpy_array_equal(result, exp)
+
+        result = isna(np.array([NaT], dtype=object))
+        exp = np.array([True])
+        tm.assert_numpy_array_equal(result, exp)
+
+    def test_isna_numpy_nat(self):
+        arr = np.array(
+            [
+                NaT,
+                np.datetime64("NaT"),
+                np.timedelta64("NaT"),
+                np.datetime64("NaT", "s"),
+            ]
+        )
+        result = isna(arr)
+        expected = np.array([True] * 4)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_isna_datetime(self):
+        assert not isna(datetime.now())
+        assert notna(datetime.now())
+
+        idx = date_range("1/1/1990", periods=20)
+        exp = np.ones(len(idx), dtype=bool)
+        tm.assert_numpy_array_equal(notna(idx), exp)
+
+        idx = np.asarray(idx)
+        idx[0] = iNaT
+        idx = DatetimeIndex(idx)
+        mask = isna(idx)
+        assert mask[0]
+        exp = np.array([True] + [False] * (len(idx) - 1), dtype=bool)
+        tm.assert_numpy_array_equal(mask, exp)
+
+        # GH 9129
+        pidx = idx.to_period(freq="M")
+        mask = isna(pidx)
+        assert mask[0]
+        exp = np.array([True] + [False] * (len(idx) - 1), dtype=bool)
+        tm.assert_numpy_array_equal(mask, exp)
+
+        mask = isna(pidx[1:])
+        exp = np.zeros(len(mask), dtype=bool)
+        tm.assert_numpy_array_equal(mask, exp)
+
+    def test_isna_old_datetimelike(self):
+        # isna_old should work for dt64tz, td64, and period, not just tznaive
+        dti = date_range("2016-01-01", periods=3)
+        dta = dti._data
+        dta[-1] = NaT
+        expected = np.array([False, False, True], dtype=bool)
+
+        objs = [dta, dta.tz_localize("US/Eastern"), dta - dta, dta.to_period("D")]
+
+        for obj in objs:
+            msg = "use_inf_as_na option is deprecated"
+            with tm.assert_produces_warning(FutureWarning, match=msg):
+                with cf.option_context("mode.use_inf_as_na", True):
+                    result = isna(obj)
+
+            tm.assert_numpy_array_equal(result, expected)
+
+    @pytest.mark.parametrize(
+        "value, expected",
+        [
+            (np.complex128(np.nan), True),
+            (np.float64(1), False),
+            (np.array([1, 1 + 0j, np.nan, 3]), np.array([False, False, True, False])),
+            (
+                np.array([1, 1 + 0j, np.nan, 3], dtype=object),
+                np.array([False, False, True, False]),
+            ),
+            (
+                np.array([1, 1 + 0j, np.nan, 3]).astype(object),
+                np.array([False, False, True, False]),
+            ),
+        ],
+    )
+    def test_complex(self, value, expected):
+        result = isna(value)
+        if is_scalar(result):
+            assert result is expected
+        else:
+            tm.assert_numpy_array_equal(result, expected)
+
+    def test_datetime_other_units(self):
+        idx = DatetimeIndex(["2011-01-01", "NaT", "2011-01-02"])
+        exp = np.array([False, True, False])
+        tm.assert_numpy_array_equal(isna(idx), exp)
+        tm.assert_numpy_array_equal(notna(idx), ~exp)
+        tm.assert_numpy_array_equal(isna(idx.values), exp)
+        tm.assert_numpy_array_equal(notna(idx.values), ~exp)
+
+    @pytest.mark.parametrize(
+        "dtype",
+        [
+            "datetime64[D]",
+            "datetime64[h]",
+            "datetime64[m]",
+            "datetime64[s]",
+            "datetime64[ms]",
+            "datetime64[us]",
+            "datetime64[ns]",
+        ],
+    )
+    def test_datetime_other_units_astype(self, dtype):
+        idx = DatetimeIndex(["2011-01-01", "NaT", "2011-01-02"])
+        values = idx.values.astype(dtype)
+
+        exp = np.array([False, True, False])
+        tm.assert_numpy_array_equal(isna(values), exp)
+        tm.assert_numpy_array_equal(notna(values), ~exp)
+
+        exp = Series([False, True, False])
+        s = Series(values)
+        tm.assert_series_equal(isna(s), exp)
+        tm.assert_series_equal(notna(s), ~exp)
+        s = Series(values, dtype=object)
+        tm.assert_series_equal(isna(s), exp)
+        tm.assert_series_equal(notna(s), ~exp)
+
+    def test_timedelta_other_units(self):
+        idx = TimedeltaIndex(["1 days", "NaT", "2 days"])
+        exp = np.array([False, True, False])
+        tm.assert_numpy_array_equal(isna(idx), exp)
+        tm.assert_numpy_array_equal(notna(idx), ~exp)
+        tm.assert_numpy_array_equal(isna(idx.values), exp)
+        tm.assert_numpy_array_equal(notna(idx.values), ~exp)
+
+    @pytest.mark.parametrize(
+        "dtype",
+        [
+            "timedelta64[D]",
+            "timedelta64[h]",
+            "timedelta64[m]",
+            "timedelta64[s]",
+            "timedelta64[ms]",
+            "timedelta64[us]",
+            "timedelta64[ns]",
+        ],
+    )
+    def test_timedelta_other_units_dtype(self, dtype):
+        idx = TimedeltaIndex(["1 days", "NaT", "2 days"])
+        values = idx.values.astype(dtype)
+
+        exp = np.array([False, True, False])
+        tm.assert_numpy_array_equal(isna(values), exp)
+        tm.assert_numpy_array_equal(notna(values), ~exp)
+
+        exp = Series([False, True, False])
+        s = Series(values)
+        tm.assert_series_equal(isna(s), exp)
+        tm.assert_series_equal(notna(s), ~exp)
+        s = Series(values, dtype=object)
+        tm.assert_series_equal(isna(s), exp)
+        tm.assert_series_equal(notna(s), ~exp)
+
+    def test_period(self):
+        idx = pd.PeriodIndex(["2011-01", "NaT", "2012-01"], freq="M")
+        exp = np.array([False, True, False])
+        tm.assert_numpy_array_equal(isna(idx), exp)
+        tm.assert_numpy_array_equal(notna(idx), ~exp)
+
+        exp = Series([False, True, False])
+        s = Series(idx)
+        tm.assert_series_equal(isna(s), exp)
+        tm.assert_series_equal(notna(s), ~exp)
+        s = Series(idx, dtype=object)
+        tm.assert_series_equal(isna(s), exp)
+        tm.assert_series_equal(notna(s), ~exp)
+
+    def test_decimal(self):
+        # scalars GH#23530
+        a = Decimal(1.0)
+        assert isna(a) is False
+        assert notna(a) is True
+
+        b = Decimal("NaN")
+        assert isna(b) is True
+        assert notna(b) is False
+
+        # array
+        arr = np.array([a, b])
+        expected = np.array([False, True])
+        result = isna(arr)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = notna(arr)
+        tm.assert_numpy_array_equal(result, ~expected)
+
+        # series
+        ser = Series(arr)
+        expected = Series(expected)
+        result = isna(ser)
+        tm.assert_series_equal(result, expected)
+
+        result = notna(ser)
+        tm.assert_series_equal(result, ~expected)
+
+        # index
+        idx = Index(arr)
+        expected = np.array([False, True])
+        result = isna(idx)
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = notna(idx)
+        tm.assert_numpy_array_equal(result, ~expected)
+
+
+@pytest.mark.parametrize("dtype_equal", [True, False])
+def test_array_equivalent(dtype_equal):
+    assert array_equivalent(
+        np.array([np.nan, np.nan]), np.array([np.nan, np.nan]), dtype_equal=dtype_equal
+    )
+    assert array_equivalent(
+        np.array([np.nan, 1, np.nan]),
+        np.array([np.nan, 1, np.nan]),
+        dtype_equal=dtype_equal,
+    )
+    assert array_equivalent(
+        np.array([np.nan, None], dtype="object"),
+        np.array([np.nan, None], dtype="object"),
+        dtype_equal=dtype_equal,
+    )
+    # Check the handling of nested arrays in array_equivalent_object
+    assert array_equivalent(
+        np.array([np.array([np.nan, None], dtype="object"), None], dtype="object"),
+        np.array([np.array([np.nan, None], dtype="object"), None], dtype="object"),
+        dtype_equal=dtype_equal,
+    )
+    assert array_equivalent(
+        np.array([np.nan, 1 + 1j], dtype="complex"),
+        np.array([np.nan, 1 + 1j], dtype="complex"),
+        dtype_equal=dtype_equal,
+    )
+    assert not array_equivalent(
+        np.array([np.nan, 1 + 1j], dtype="complex"),
+        np.array([np.nan, 1 + 2j], dtype="complex"),
+        dtype_equal=dtype_equal,
+    )
+    assert not array_equivalent(
+        np.array([np.nan, 1, np.nan]),
+        np.array([np.nan, 2, np.nan]),
+        dtype_equal=dtype_equal,
+    )
+    assert not array_equivalent(
+        np.array(["a", "b", "c", "d"]), np.array(["e", "e"]), dtype_equal=dtype_equal
+    )
+    assert array_equivalent(
+        Index([0, np.nan]), Index([0, np.nan]), dtype_equal=dtype_equal
+    )
+    assert not array_equivalent(
+        Index([0, np.nan]), Index([1, np.nan]), dtype_equal=dtype_equal
+    )
+
+
+@pytest.mark.parametrize("dtype_equal", [True, False])
+def test_array_equivalent_tdi(dtype_equal):
+    assert array_equivalent(
+        TimedeltaIndex([0, np.nan]),
+        TimedeltaIndex([0, np.nan]),
+        dtype_equal=dtype_equal,
+    )
+    assert not array_equivalent(
+        TimedeltaIndex([0, np.nan]),
+        TimedeltaIndex([1, np.nan]),
+        dtype_equal=dtype_equal,
+    )
+
+
+@pytest.mark.parametrize("dtype_equal", [True, False])
+def test_array_equivalent_dti(dtype_equal):
+    assert array_equivalent(
+        DatetimeIndex([0, np.nan]), DatetimeIndex([0, np.nan]), dtype_equal=dtype_equal
+    )
+    assert not array_equivalent(
+        DatetimeIndex([0, np.nan]), DatetimeIndex([1, np.nan]), dtype_equal=dtype_equal
+    )
+
+    dti1 = DatetimeIndex([0, np.nan], tz="US/Eastern")
+    dti2 = DatetimeIndex([0, np.nan], tz="CET")
+    dti3 = DatetimeIndex([1, np.nan], tz="US/Eastern")
+
+    assert array_equivalent(
+        dti1,
+        dti1,
+        dtype_equal=dtype_equal,
+    )
+    assert not array_equivalent(
+        dti1,
+        dti3,
+        dtype_equal=dtype_equal,
+    )
+    # The rest are not dtype_equal
+    assert not array_equivalent(DatetimeIndex([0, np.nan]), dti1)
+    assert array_equivalent(
+        dti2,
+        dti1,
+    )
+
+    assert not array_equivalent(DatetimeIndex([0, np.nan]), TimedeltaIndex([0, np.nan]))
+
+
+@pytest.mark.parametrize(
+    "val", [1, 1.1, 1 + 1j, True, "abc", [1, 2], (1, 2), {1, 2}, {"a": 1}, None]
+)
+def test_array_equivalent_series(val):
+    arr = np.array([1, 2])
+    msg = "elementwise comparison failed"
+    cm = (
+        # stacklevel is chosen to make sense when called from .equals
+        tm.assert_produces_warning(FutureWarning, match=msg, check_stacklevel=False)
+        if isinstance(val, str) and not np_version_gte1p25
+        else nullcontext()
+    )
+    with cm:
+        assert not array_equivalent(Series([arr, arr]), Series([arr, val]))
+
+
+def test_array_equivalent_array_mismatched_shape():
+    # to trigger the motivating bug, the first N elements of the arrays need
+    #  to match
+    first = np.array([1, 2, 3])
+    second = np.array([1, 2])
+
+    left = Series([first, "a"], dtype=object)
+    right = Series([second, "a"], dtype=object)
+    assert not array_equivalent(left, right)
+
+
+def test_array_equivalent_array_mismatched_dtype():
+    # same shape, different dtype can still be equivalent
+    first = np.array([1, 2], dtype=np.float64)
+    second = np.array([1, 2])
+
+    left = Series([first, "a"], dtype=object)
+    right = Series([second, "a"], dtype=object)
+    assert array_equivalent(left, right)
+
+
+def test_array_equivalent_different_dtype_but_equal():
+    # Unclear if this is exposed anywhere in the public-facing API
+    assert array_equivalent(np.array([1, 2]), np.array([1.0, 2.0]))
+
+
+@pytest.mark.parametrize(
+    "lvalue, rvalue",
+    [
+        # There are 3 variants for each of lvalue and rvalue. We include all
+        #  three for the tz-naive `now` and exclude the datetim64 variant
+        #  for utcnow because it drops tzinfo.
+        (fix_now, fix_utcnow),
+        (fix_now.to_datetime64(), fix_utcnow),
+        (fix_now.to_pydatetime(), fix_utcnow),
+        (fix_now, fix_utcnow),
+        (fix_now.to_datetime64(), fix_utcnow.to_pydatetime()),
+        (fix_now.to_pydatetime(), fix_utcnow.to_pydatetime()),
+    ],
+)
+def test_array_equivalent_tzawareness(lvalue, rvalue):
+    # we shouldn't raise if comparing tzaware and tznaive datetimes
+    left = np.array([lvalue], dtype=object)
+    right = np.array([rvalue], dtype=object)
+
+    assert not array_equivalent(left, right, strict_nan=True)
+    assert not array_equivalent(left, right, strict_nan=False)
+
+
+def test_array_equivalent_compat():
+    # see gh-13388
+    m = np.array([(1, 2), (3, 4)], dtype=[("a", int), ("b", float)])
+    n = np.array([(1, 2), (3, 4)], dtype=[("a", int), ("b", float)])
+    assert array_equivalent(m, n, strict_nan=True)
+    assert array_equivalent(m, n, strict_nan=False)
+
+    m = np.array([(1, 2), (3, 4)], dtype=[("a", int), ("b", float)])
+    n = np.array([(1, 2), (4, 3)], dtype=[("a", int), ("b", float)])
+    assert not array_equivalent(m, n, strict_nan=True)
+    assert not array_equivalent(m, n, strict_nan=False)
+
+    m = np.array([(1, 2), (3, 4)], dtype=[("a", int), ("b", float)])
+    n = np.array([(1, 2), (3, 4)], dtype=[("b", int), ("a", float)])
+    assert not array_equivalent(m, n, strict_nan=True)
+    assert not array_equivalent(m, n, strict_nan=False)
+
+
+@pytest.mark.parametrize("dtype", ["O", "S", "U"])
+def test_array_equivalent_str(dtype):
+    assert array_equivalent(
+        np.array(["A", "B"], dtype=dtype), np.array(["A", "B"], dtype=dtype)
+    )
+    assert not array_equivalent(
+        np.array(["A", "B"], dtype=dtype), np.array(["A", "X"], dtype=dtype)
+    )
+
+
+@pytest.mark.parametrize("strict_nan", [True, False])
+def test_array_equivalent_nested(strict_nan):
+    # reached in groupby aggregations, make sure we use np.any when checking
+    #  if the comparison is truthy
+    left = np.array([np.array([50, 70, 90]), np.array([20, 30])], dtype=object)
+    right = np.array([np.array([50, 70, 90]), np.array([20, 30])], dtype=object)
+
+    assert array_equivalent(left, right, strict_nan=strict_nan)
+    assert not array_equivalent(left, right[::-1], strict_nan=strict_nan)
+
+    left = np.empty(2, dtype=object)
+    left[:] = [np.array([50, 70, 90]), np.array([20, 30, 40])]
+    right = np.empty(2, dtype=object)
+    right[:] = [np.array([50, 70, 90]), np.array([20, 30, 40])]
+    assert array_equivalent(left, right, strict_nan=strict_nan)
+    assert not array_equivalent(left, right[::-1], strict_nan=strict_nan)
+
+    left = np.array([np.array([50, 50, 50]), np.array([40, 40])], dtype=object)
+    right = np.array([50, 40])
+    assert not array_equivalent(left, right, strict_nan=strict_nan)
+
+
+@pytest.mark.filterwarnings("ignore:elementwise comparison failed:DeprecationWarning")
+@pytest.mark.parametrize("strict_nan", [True, False])
+def test_array_equivalent_nested2(strict_nan):
+    # more than one level of nesting
+    left = np.array(
+        [
+            np.array([np.array([50, 70]), np.array([90])], dtype=object),
+            np.array([np.array([20, 30])], dtype=object),
+        ],
+        dtype=object,
+    )
+    right = np.array(
+        [
+            np.array([np.array([50, 70]), np.array([90])], dtype=object),
+            np.array([np.array([20, 30])], dtype=object),
+        ],
+        dtype=object,
+    )
+    assert array_equivalent(left, right, strict_nan=strict_nan)
+    assert not array_equivalent(left, right[::-1], strict_nan=strict_nan)
+
+    left = np.array([np.array([np.array([50, 50, 50])], dtype=object)], dtype=object)
+    right = np.array([50])
+    assert not array_equivalent(left, right, strict_nan=strict_nan)
+
+
+@pytest.mark.parametrize("strict_nan", [True, False])
+def test_array_equivalent_nested_list(strict_nan):
+    left = np.array([[50, 70, 90], [20, 30]], dtype=object)
+    right = np.array([[50, 70, 90], [20, 30]], dtype=object)
+
+    assert array_equivalent(left, right, strict_nan=strict_nan)
+    assert not array_equivalent(left, right[::-1], strict_nan=strict_nan)
+
+    left = np.array([[50, 50, 50], [40, 40]], dtype=object)
+    right = np.array([50, 40])
+    assert not array_equivalent(left, right, strict_nan=strict_nan)
+
+
+@pytest.mark.filterwarnings("ignore:elementwise comparison failed:DeprecationWarning")
+@pytest.mark.xfail(reason="failing")
+@pytest.mark.parametrize("strict_nan", [True, False])
+def test_array_equivalent_nested_mixed_list(strict_nan):
+    # mixed arrays / lists in left and right
+    # https://github.com/pandas-dev/pandas/issues/50360
+    left = np.array([np.array([1, 2, 3]), np.array([4, 5])], dtype=object)
+    right = np.array([[1, 2, 3], [4, 5]], dtype=object)
+
+    assert array_equivalent(left, right, strict_nan=strict_nan)
+    assert not array_equivalent(left, right[::-1], strict_nan=strict_nan)
+
+    # multiple levels of nesting
+    left = np.array(
+        [
+            np.array([np.array([1, 2, 3]), np.array([4, 5])], dtype=object),
+            np.array([np.array([6]), np.array([7, 8]), np.array([9])], dtype=object),
+        ],
+        dtype=object,
+    )
+    right = np.array([[[1, 2, 3], [4, 5]], [[6], [7, 8], [9]]], dtype=object)
+    assert array_equivalent(left, right, strict_nan=strict_nan)
+    assert not array_equivalent(left, right[::-1], strict_nan=strict_nan)
+
+    # same-length lists
+    subarr = np.empty(2, dtype=object)
+    subarr[:] = [
+        np.array([None, "b"], dtype=object),
+        np.array(["c", "d"], dtype=object),
+    ]
+    left = np.array([subarr, None], dtype=object)
+    right = np.array([[[None, "b"], ["c", "d"]], None], dtype=object)
+    assert array_equivalent(left, right, strict_nan=strict_nan)
+    assert not array_equivalent(left, right[::-1], strict_nan=strict_nan)
+
+
+@pytest.mark.xfail(reason="failing")
+@pytest.mark.parametrize("strict_nan", [True, False])
+def test_array_equivalent_nested_dicts(strict_nan):
+    left = np.array([{"f1": 1, "f2": np.array(["a", "b"], dtype=object)}], dtype=object)
+    right = np.array(
+        [{"f1": 1, "f2": np.array(["a", "b"], dtype=object)}], dtype=object
+    )
+    assert array_equivalent(left, right, strict_nan=strict_nan)
+    assert not array_equivalent(left, right[::-1], strict_nan=strict_nan)
+
+    right2 = np.array([{"f1": 1, "f2": ["a", "b"]}], dtype=object)
+    assert array_equivalent(left, right2, strict_nan=strict_nan)
+    assert not array_equivalent(left, right2[::-1], strict_nan=strict_nan)
+
+
+def test_array_equivalent_index_with_tuples():
+    # GH#48446
+    idx1 = Index(np.array([(pd.NA, 4), (1, 1)], dtype="object"))
+    idx2 = Index(np.array([(1, 1), (pd.NA, 4)], dtype="object"))
+    assert not array_equivalent(idx1, idx2)
+    assert not idx1.equals(idx2)
+    assert not array_equivalent(idx2, idx1)
+    assert not idx2.equals(idx1)
+
+    idx1 = Index(np.array([(4, pd.NA), (1, 1)], dtype="object"))
+    idx2 = Index(np.array([(1, 1), (4, pd.NA)], dtype="object"))
+    assert not array_equivalent(idx1, idx2)
+    assert not idx1.equals(idx2)
+    assert not array_equivalent(idx2, idx1)
+    assert not idx2.equals(idx1)
+
+
+@pytest.mark.parametrize(
+    "dtype, na_value",
+    [
+        # Datetime-like
+        (np.dtype("M8[ns]"), np.datetime64("NaT", "ns")),
+        (np.dtype("m8[ns]"), np.timedelta64("NaT", "ns")),
+        (DatetimeTZDtype.construct_from_string("datetime64[ns, US/Eastern]"), NaT),
+        (PeriodDtype("M"), NaT),
+        # Integer
+        ("u1", 0),
+        ("u2", 0),
+        ("u4", 0),
+        ("u8", 0),
+        ("i1", 0),
+        ("i2", 0),
+        ("i4", 0),
+        ("i8", 0),
+        # Bool
+        ("bool", False),
+        # Float
+        ("f2", np.nan),
+        ("f4", np.nan),
+        ("f8", np.nan),
+        # Object
+        ("O", np.nan),
+        # Interval
+        (IntervalDtype(), np.nan),
+    ],
+)
+def test_na_value_for_dtype(dtype, na_value):
+    result = na_value_for_dtype(pandas_dtype(dtype))
+    # identify check doesn't work for datetime64/timedelta64("NaT") bc they
+    #  are not singletons
+    assert result is na_value or (
+        isna(result) and isna(na_value) and type(result) is type(na_value)
+    )
+
+
+class TestNAObj:
+    def _check_behavior(self, arr, expected):
+        result = libmissing.isnaobj(arr)
+        tm.assert_numpy_array_equal(result, expected)
+        result = libmissing.isnaobj(arr, inf_as_na=True)
+        tm.assert_numpy_array_equal(result, expected)
+
+        arr = np.atleast_2d(arr)
+        expected = np.atleast_2d(expected)
+
+        result = libmissing.isnaobj(arr)
+        tm.assert_numpy_array_equal(result, expected)
+        result = libmissing.isnaobj(arr, inf_as_na=True)
+        tm.assert_numpy_array_equal(result, expected)
+
+        # Test fortran order
+        arr = arr.copy(order="F")
+        result = libmissing.isnaobj(arr)
+        tm.assert_numpy_array_equal(result, expected)
+        result = libmissing.isnaobj(arr, inf_as_na=True)
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_basic(self):
+        arr = np.array([1, None, "foo", -5.1, NaT, np.nan])
+        expected = np.array([False, True, False, False, True, True])
+
+        self._check_behavior(arr, expected)
+
+    def test_non_obj_dtype(self):
+        arr = np.array([1, 3, np.nan, 5], dtype=float)
+        expected = np.array([False, False, True, False])
+
+        self._check_behavior(arr, expected)
+
+    def test_empty_arr(self):
+        arr = np.array([])
+        expected = np.array([], dtype=bool)
+
+        self._check_behavior(arr, expected)
+
+    def test_empty_str_inp(self):
+        arr = np.array([""])  # empty but not na
+        expected = np.array([False])
+
+        self._check_behavior(arr, expected)
+
+    def test_empty_like(self):
+        # see gh-13717: no segfaults!
+        arr = np.empty_like([None])
+        expected = np.array([True])
+
+        self._check_behavior(arr, expected)
+
+
+m8_units = ["as", "ps", "ns", "us", "ms", "s", "m", "h", "D", "W", "M", "Y"]
+
+na_vals = (
+    [
+        None,
+        NaT,
+        float("NaN"),
+        complex("NaN"),
+        np.nan,
+        np.float64("NaN"),
+        np.float32("NaN"),
+        np.complex64(np.nan),
+        np.complex128(np.nan),
+        np.datetime64("NaT"),
+        np.timedelta64("NaT"),
+    ]
+    + [np.datetime64("NaT", unit) for unit in m8_units]
+    + [np.timedelta64("NaT", unit) for unit in m8_units]
+)
+
+inf_vals = [
+    float("inf"),
+    float("-inf"),
+    complex("inf"),
+    complex("-inf"),
+    np.inf,
+    -np.inf,
+]
+
+int_na_vals = [
+    # Values that match iNaT, which we treat as null in specific cases
+    np.int64(NaT._value),
+    int(NaT._value),
+]
+
+sometimes_na_vals = [Decimal("NaN")]
+
+never_na_vals = [
+    # float/complex values that when viewed as int64 match iNaT
+    -0.0,
+    np.float64("-0.0"),
+    -0j,
+    np.complex64(-0j),
+]
+
+
+class TestLibMissing:
+    @pytest.mark.parametrize("func", [libmissing.checknull, isna])
+    @pytest.mark.parametrize(
+        "value", na_vals + sometimes_na_vals  # type: ignore[operator]
+    )
+    def test_checknull_na_vals(self, func, value):
+        assert func(value)
+
+    @pytest.mark.parametrize("func", [libmissing.checknull, isna])
+    @pytest.mark.parametrize("value", inf_vals)
+    def test_checknull_inf_vals(self, func, value):
+        assert not func(value)
+
+    @pytest.mark.parametrize("func", [libmissing.checknull, isna])
+    @pytest.mark.parametrize("value", int_na_vals)
+    def test_checknull_intna_vals(self, func, value):
+        assert not func(value)
+
+    @pytest.mark.parametrize("func", [libmissing.checknull, isna])
+    @pytest.mark.parametrize("value", never_na_vals)
+    def test_checknull_never_na_vals(self, func, value):
+        assert not func(value)
+
+    @pytest.mark.parametrize(
+        "value", na_vals + sometimes_na_vals  # type: ignore[operator]
+    )
+    def test_checknull_old_na_vals(self, value):
+        assert libmissing.checknull(value, inf_as_na=True)
+
+    @pytest.mark.parametrize("value", inf_vals)
+    def test_checknull_old_inf_vals(self, value):
+        assert libmissing.checknull(value, inf_as_na=True)
+
+    @pytest.mark.parametrize("value", int_na_vals)
+    def test_checknull_old_intna_vals(self, value):
+        assert not libmissing.checknull(value, inf_as_na=True)
+
+    @pytest.mark.parametrize("value", int_na_vals)
+    def test_checknull_old_never_na_vals(self, value):
+        assert not libmissing.checknull(value, inf_as_na=True)
+
+    def test_is_matching_na(self, nulls_fixture, nulls_fixture2):
+        left = nulls_fixture
+        right = nulls_fixture2
+
+        assert libmissing.is_matching_na(left, left)
+
+        if left is right:
+            assert libmissing.is_matching_na(left, right)
+        elif is_float(left) and is_float(right):
+            # np.nan vs float("NaN") we consider as matching
+            assert libmissing.is_matching_na(left, right)
+        elif type(left) is type(right):
+            # e.g. both Decimal("NaN")
+            assert libmissing.is_matching_na(left, right)
+        else:
+            assert not libmissing.is_matching_na(left, right)
+
+    def test_is_matching_na_nan_matches_none(self):
+        assert not libmissing.is_matching_na(None, np.nan)
+        assert not libmissing.is_matching_na(np.nan, None)
+
+        assert libmissing.is_matching_na(None, np.nan, nan_matches_none=True)
+        assert libmissing.is_matching_na(np.nan, None, nan_matches_none=True)
+
+
+class TestIsValidNAForDtype:
+    def test_is_valid_na_for_dtype_interval(self):
+        dtype = IntervalDtype("int64", "left")
+        assert not is_valid_na_for_dtype(NaT, dtype)
+
+        dtype = IntervalDtype("datetime64[ns]", "both")
+        assert not is_valid_na_for_dtype(NaT, dtype)
+
+    def test_is_valid_na_for_dtype_categorical(self):
+        dtype = CategoricalDtype(categories=[0, 1, 2])
+        assert is_valid_na_for_dtype(np.nan, dtype)
+
+        assert not is_valid_na_for_dtype(NaT, dtype)
+        assert not is_valid_na_for_dtype(np.datetime64("NaT", "ns"), dtype)
+        assert not is_valid_na_for_dtype(np.timedelta64("NaT", "ns"), dtype)