diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/__init__.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f583e91d783209745040bec38dd08c6207dc1de7
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/__init__.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/common.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/common.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cdecda7b095a473b45263691b570c509b7c6d621
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/common.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/test_constructors.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/test_constructors.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..41804870c2e238ac5cd19efbdf966bebe0836296
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/test_constructors.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/test_conversion.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/test_conversion.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cc25e60746887d73c338867de2469cd6516e0708
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/test_conversion.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/test_fillna.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/test_fillna.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..902e9c7d4a375c568d275d1a778572d448a8f8fd
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/test_fillna.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/test_misc.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/test_misc.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bc38a1443bba991606d45867b5ad7b812115f33d
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/test_misc.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/test_transpose.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/test_transpose.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f2ed920c20768ebf80768718073f499000880df6
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/test_transpose.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/test_unique.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/test_unique.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..53643f22c08d5604f20ee2b3062e5334059129fe
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/test_unique.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/test_value_counts.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/test_value_counts.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a21bd7a2bf4560d25e5137b5595f53d591b6954a
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/__pycache__/test_value_counts.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/common.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/common.py
new file mode 100644
index 0000000000000000000000000000000000000000..ad0b394105742ca5de92a03a3da2c569c38da469
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/common.py
@@ -0,0 +1,9 @@
+from typing import Any
+
+from pandas import Index
+
+
+def allow_na_ops(obj: Any) -> bool:
+    """Whether to skip test cases including NaN"""
+    is_bool_index = isinstance(obj, Index) and obj.inferred_type == "boolean"
+    return not is_bool_index and obj._can_hold_na
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/test_conversion.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/test_conversion.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe0f1f1454a55018ad5167d958c73dd6a3bc7018
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/test_conversion.py
@@ -0,0 +1,562 @@
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.dtypes import DatetimeTZDtype
+
+import pandas as pd
+from pandas import (
+    CategoricalIndex,
+    Series,
+    Timedelta,
+    Timestamp,
+    date_range,
+)
+import pandas._testing as tm
+from pandas.core.arrays import (
+    DatetimeArray,
+    IntervalArray,
+    NumpyExtensionArray,
+    PeriodArray,
+    SparseArray,
+    TimedeltaArray,
+)
+from pandas.core.arrays.string_arrow import ArrowStringArrayNumpySemantics
+
+
+class TestToIterable:
+    # test that we convert an iterable to python types
+
+    dtypes = [
+        ("int8", int),
+        ("int16", int),
+        ("int32", int),
+        ("int64", int),
+        ("uint8", int),
+        ("uint16", int),
+        ("uint32", int),
+        ("uint64", int),
+        ("float16", float),
+        ("float32", float),
+        ("float64", float),
+        ("datetime64[ns]", Timestamp),
+        ("datetime64[ns, US/Eastern]", Timestamp),
+        ("timedelta64[ns]", Timedelta),
+    ]
+
+    @pytest.mark.parametrize("dtype, rdtype", dtypes)
+    @pytest.mark.parametrize(
+        "method",
+        [
+            lambda x: x.tolist(),
+            lambda x: x.to_list(),
+            lambda x: list(x),
+            lambda x: list(x.__iter__()),
+        ],
+        ids=["tolist", "to_list", "list", "iter"],
+    )
+    def test_iterable(self, index_or_series, method, dtype, rdtype):
+        # gh-10904
+        # gh-13258
+        # coerce iteration to underlying python / pandas types
+        typ = index_or_series
+        if dtype == "float16" and issubclass(typ, pd.Index):
+            with pytest.raises(NotImplementedError, match="float16 indexes are not "):
+                typ([1], dtype=dtype)
+            return
+        s = typ([1], dtype=dtype)
+        result = method(s)[0]
+        assert isinstance(result, rdtype)
+
+    @pytest.mark.parametrize(
+        "dtype, rdtype, obj",
+        [
+            ("object", object, "a"),
+            ("object", int, 1),
+            ("category", object, "a"),
+            ("category", int, 1),
+        ],
+    )
+    @pytest.mark.parametrize(
+        "method",
+        [
+            lambda x: x.tolist(),
+            lambda x: x.to_list(),
+            lambda x: list(x),
+            lambda x: list(x.__iter__()),
+        ],
+        ids=["tolist", "to_list", "list", "iter"],
+    )
+    def test_iterable_object_and_category(
+        self, index_or_series, method, dtype, rdtype, obj
+    ):
+        # gh-10904
+        # gh-13258
+        # coerce iteration to underlying python / pandas types
+        typ = index_or_series
+        s = typ([obj], dtype=dtype)
+        result = method(s)[0]
+        assert isinstance(result, rdtype)
+
+    @pytest.mark.parametrize("dtype, rdtype", dtypes)
+    def test_iterable_items(self, dtype, rdtype):
+        # gh-13258
+        # test if items yields the correct boxed scalars
+        # this only applies to series
+        s = Series([1], dtype=dtype)
+        _, result = next(iter(s.items()))
+        assert isinstance(result, rdtype)
+
+        _, result = next(iter(s.items()))
+        assert isinstance(result, rdtype)
+
+    @pytest.mark.parametrize(
+        "dtype, rdtype", dtypes + [("object", int), ("category", int)]
+    )
+    def test_iterable_map(self, index_or_series, dtype, rdtype):
+        # gh-13236
+        # coerce iteration to underlying python / pandas types
+        typ = index_or_series
+        if dtype == "float16" and issubclass(typ, pd.Index):
+            with pytest.raises(NotImplementedError, match="float16 indexes are not "):
+                typ([1], dtype=dtype)
+            return
+        s = typ([1], dtype=dtype)
+        result = s.map(type)[0]
+        if not isinstance(rdtype, tuple):
+            rdtype = (rdtype,)
+        assert result in rdtype
+
+    @pytest.mark.parametrize(
+        "method",
+        [
+            lambda x: x.tolist(),
+            lambda x: x.to_list(),
+            lambda x: list(x),
+            lambda x: list(x.__iter__()),
+        ],
+        ids=["tolist", "to_list", "list", "iter"],
+    )
+    def test_categorial_datetimelike(self, method):
+        i = CategoricalIndex([Timestamp("1999-12-31"), Timestamp("2000-12-31")])
+
+        result = method(i)[0]
+        assert isinstance(result, Timestamp)
+
+    def test_iter_box_dt64(self, unit):
+        vals = [Timestamp("2011-01-01"), Timestamp("2011-01-02")]
+        ser = Series(vals).dt.as_unit(unit)
+        assert ser.dtype == f"datetime64[{unit}]"
+        for res, exp in zip(ser, vals):
+            assert isinstance(res, Timestamp)
+            assert res.tz is None
+            assert res == exp
+            assert res.unit == unit
+
+    def test_iter_box_dt64tz(self, unit):
+        vals = [
+            Timestamp("2011-01-01", tz="US/Eastern"),
+            Timestamp("2011-01-02", tz="US/Eastern"),
+        ]
+        ser = Series(vals).dt.as_unit(unit)
+
+        assert ser.dtype == f"datetime64[{unit}, US/Eastern]"
+        for res, exp in zip(ser, vals):
+            assert isinstance(res, Timestamp)
+            assert res.tz == exp.tz
+            assert res == exp
+            assert res.unit == unit
+
+    def test_iter_box_timedelta64(self, unit):
+        # timedelta
+        vals = [Timedelta("1 days"), Timedelta("2 days")]
+        ser = Series(vals).dt.as_unit(unit)
+        assert ser.dtype == f"timedelta64[{unit}]"
+        for res, exp in zip(ser, vals):
+            assert isinstance(res, Timedelta)
+            assert res == exp
+            assert res.unit == unit
+
+    def test_iter_box_period(self):
+        # period
+        vals = [pd.Period("2011-01-01", freq="M"), pd.Period("2011-01-02", freq="M")]
+        s = Series(vals)
+        assert s.dtype == "Period[M]"
+        for res, exp in zip(s, vals):
+            assert isinstance(res, pd.Period)
+            assert res.freq == "ME"
+            assert res == exp
+
+
+@pytest.mark.parametrize(
+    "arr, expected_type, dtype",
+    [
+        (np.array([0, 1], dtype=np.int64), np.ndarray, "int64"),
+        (np.array(["a", "b"]), np.ndarray, "object"),
+        (pd.Categorical(["a", "b"]), pd.Categorical, "category"),
+        (
+            pd.DatetimeIndex(["2017", "2018"], tz="US/Central"),
+            DatetimeArray,
+            "datetime64[ns, US/Central]",
+        ),
+        (
+            pd.PeriodIndex([2018, 2019], freq="Y"),
+            PeriodArray,
+            pd.core.dtypes.dtypes.PeriodDtype("Y-DEC"),
+        ),
+        (pd.IntervalIndex.from_breaks([0, 1, 2]), IntervalArray, "interval"),
+        (
+            pd.DatetimeIndex(["2017", "2018"]),
+            DatetimeArray,
+            "datetime64[ns]",
+        ),
+        (
+            pd.TimedeltaIndex([10**10]),
+            TimedeltaArray,
+            "m8[ns]",
+        ),
+    ],
+)
+def test_values_consistent(arr, expected_type, dtype, using_infer_string):
+    if using_infer_string and dtype == "object":
+        expected_type = ArrowStringArrayNumpySemantics
+    l_values = Series(arr)._values
+    r_values = pd.Index(arr)._values
+    assert type(l_values) is expected_type
+    assert type(l_values) is type(r_values)
+
+    tm.assert_equal(l_values, r_values)
+
+
+@pytest.mark.parametrize("arr", [np.array([1, 2, 3])])
+def test_numpy_array(arr):
+    ser = Series(arr)
+    result = ser.array
+    expected = NumpyExtensionArray(arr)
+    tm.assert_extension_array_equal(result, expected)
+
+
+def test_numpy_array_all_dtypes(any_numpy_dtype):
+    ser = Series(dtype=any_numpy_dtype)
+    result = ser.array
+    if np.dtype(any_numpy_dtype).kind == "M":
+        assert isinstance(result, DatetimeArray)
+    elif np.dtype(any_numpy_dtype).kind == "m":
+        assert isinstance(result, TimedeltaArray)
+    else:
+        assert isinstance(result, NumpyExtensionArray)
+
+
+@pytest.mark.parametrize(
+    "arr, attr",
+    [
+        (pd.Categorical(["a", "b"]), "_codes"),
+        (PeriodArray._from_sequence(["2000", "2001"], dtype="period[D]"), "_ndarray"),
+        (pd.array([0, np.nan], dtype="Int64"), "_data"),
+        (IntervalArray.from_breaks([0, 1]), "_left"),
+        (SparseArray([0, 1]), "_sparse_values"),
+        (
+            DatetimeArray._from_sequence(np.array([1, 2], dtype="datetime64[ns]")),
+            "_ndarray",
+        ),
+        # tz-aware Datetime
+        (
+            DatetimeArray._from_sequence(
+                np.array(
+                    ["2000-01-01T12:00:00", "2000-01-02T12:00:00"], dtype="M8[ns]"
+                ),
+                dtype=DatetimeTZDtype(tz="US/Central"),
+            ),
+            "_ndarray",
+        ),
+    ],
+)
+def test_array(arr, attr, index_or_series, request):
+    box = index_or_series
+
+    result = box(arr, copy=False).array
+
+    if attr:
+        arr = getattr(arr, attr)
+        result = getattr(result, attr)
+
+    assert result is arr
+
+
+def test_array_multiindex_raises():
+    idx = pd.MultiIndex.from_product([["A"], ["a", "b"]])
+    msg = "MultiIndex has no single backing array"
+    with pytest.raises(ValueError, match=msg):
+        idx.array
+
+
+@pytest.mark.parametrize(
+    "arr, expected",
+    [
+        (np.array([1, 2], dtype=np.int64), np.array([1, 2], dtype=np.int64)),
+        (pd.Categorical(["a", "b"]), np.array(["a", "b"], dtype=object)),
+        (
+            pd.core.arrays.period_array(["2000", "2001"], freq="D"),
+            np.array([pd.Period("2000", freq="D"), pd.Period("2001", freq="D")]),
+        ),
+        (pd.array([0, np.nan], dtype="Int64"), np.array([0, np.nan])),
+        (
+            IntervalArray.from_breaks([0, 1, 2]),
+            np.array([pd.Interval(0, 1), pd.Interval(1, 2)], dtype=object),
+        ),
+        (SparseArray([0, 1]), np.array([0, 1], dtype=np.int64)),
+        # tz-naive datetime
+        (
+            DatetimeArray._from_sequence(np.array(["2000", "2001"], dtype="M8[ns]")),
+            np.array(["2000", "2001"], dtype="M8[ns]"),
+        ),
+        # tz-aware stays tz`-aware
+        (
+            DatetimeArray._from_sequence(
+                np.array(["2000-01-01T06:00:00", "2000-01-02T06:00:00"], dtype="M8[ns]")
+            )
+            .tz_localize("UTC")
+            .tz_convert("US/Central"),
+            np.array(
+                [
+                    Timestamp("2000-01-01", tz="US/Central"),
+                    Timestamp("2000-01-02", tz="US/Central"),
+                ]
+            ),
+        ),
+        # Timedelta
+        (
+            TimedeltaArray._from_sequence(
+                np.array([0, 3600000000000], dtype="i8").view("m8[ns]")
+            ),
+            np.array([0, 3600000000000], dtype="m8[ns]"),
+        ),
+        # GH#26406 tz is preserved in Categorical[dt64tz]
+        (
+            pd.Categorical(date_range("2016-01-01", periods=2, tz="US/Pacific")),
+            np.array(
+                [
+                    Timestamp("2016-01-01", tz="US/Pacific"),
+                    Timestamp("2016-01-02", tz="US/Pacific"),
+                ]
+            ),
+        ),
+    ],
+)
+def test_to_numpy(arr, expected, index_or_series_or_array, request):
+    box = index_or_series_or_array
+
+    with tm.assert_produces_warning(None):
+        thing = box(arr)
+
+    result = thing.to_numpy()
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = np.asarray(thing)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("as_series", [True, False])
+@pytest.mark.parametrize(
+    "arr", [np.array([1, 2, 3], dtype="int64"), np.array(["a", "b", "c"], dtype=object)]
+)
+def test_to_numpy_copy(arr, as_series, using_infer_string):
+    obj = pd.Index(arr, copy=False)
+    if as_series:
+        obj = Series(obj.values, copy=False)
+
+    # no copy by default
+    result = obj.to_numpy()
+    if using_infer_string and arr.dtype == object:
+        assert np.shares_memory(arr, result) is False
+    else:
+        assert np.shares_memory(arr, result) is True
+
+    result = obj.to_numpy(copy=False)
+    if using_infer_string and arr.dtype == object:
+        assert np.shares_memory(arr, result) is False
+    else:
+        assert np.shares_memory(arr, result) is True
+
+    # copy=True
+    result = obj.to_numpy(copy=True)
+    assert np.shares_memory(arr, result) is False
+
+
+@pytest.mark.parametrize("as_series", [True, False])
+def test_to_numpy_dtype(as_series, unit):
+    tz = "US/Eastern"
+    obj = pd.DatetimeIndex(["2000", "2001"], tz=tz)
+    if as_series:
+        obj = Series(obj)
+
+    # preserve tz by default
+    result = obj.to_numpy()
+    expected = np.array(
+        [Timestamp("2000", tz=tz), Timestamp("2001", tz=tz)], dtype=object
+    )
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = obj.to_numpy(dtype="object")
+    tm.assert_numpy_array_equal(result, expected)
+
+    result = obj.to_numpy(dtype="M8[ns]")
+    expected = np.array(["2000-01-01T05", "2001-01-01T05"], dtype="M8[ns]")
+    tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "values, dtype, na_value, expected",
+    [
+        ([1, 2, None], "float64", 0, [1.0, 2.0, 0.0]),
+        (
+            [Timestamp("2000"), Timestamp("2000"), pd.NaT],
+            None,
+            Timestamp("2000"),
+            [np.datetime64("2000-01-01T00:00:00.000000000")] * 3,
+        ),
+    ],
+)
+def test_to_numpy_na_value_numpy_dtype(
+    index_or_series, values, dtype, na_value, expected
+):
+    obj = index_or_series(values)
+    result = obj.to_numpy(dtype=dtype, na_value=na_value)
+    expected = np.array(expected)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "data, multiindex, dtype, na_value, expected",
+    [
+        (
+            [1, 2, None, 4],
+            [(0, "a"), (0, "b"), (1, "b"), (1, "c")],
+            float,
+            None,
+            [1.0, 2.0, np.nan, 4.0],
+        ),
+        (
+            [1, 2, None, 4],
+            [(0, "a"), (0, "b"), (1, "b"), (1, "c")],
+            float,
+            np.nan,
+            [1.0, 2.0, np.nan, 4.0],
+        ),
+        (
+            [1.0, 2.0, np.nan, 4.0],
+            [("a", 0), ("a", 1), ("a", 2), ("b", 0)],
+            int,
+            0,
+            [1, 2, 0, 4],
+        ),
+        (
+            [Timestamp("2000"), Timestamp("2000"), pd.NaT],
+            [(0, Timestamp("2021")), (0, Timestamp("2022")), (1, Timestamp("2000"))],
+            None,
+            Timestamp("2000"),
+            [np.datetime64("2000-01-01T00:00:00.000000000")] * 3,
+        ),
+    ],
+)
+def test_to_numpy_multiindex_series_na_value(
+    data, multiindex, dtype, na_value, expected
+):
+    index = pd.MultiIndex.from_tuples(multiindex)
+    series = Series(data, index=index)
+    result = series.to_numpy(dtype=dtype, na_value=na_value)
+    expected = np.array(expected)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+def test_to_numpy_kwargs_raises():
+    # numpy
+    s = Series([1, 2, 3])
+    msg = r"to_numpy\(\) got an unexpected keyword argument 'foo'"
+    with pytest.raises(TypeError, match=msg):
+        s.to_numpy(foo=True)
+
+    # extension
+    s = Series([1, 2, 3], dtype="Int64")
+    with pytest.raises(TypeError, match=msg):
+        s.to_numpy(foo=True)
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        {"a": [1, 2, 3], "b": [1, 2, None]},
+        {"a": np.array([1, 2, 3]), "b": np.array([1, 2, np.nan])},
+        {"a": pd.array([1, 2, 3]), "b": pd.array([1, 2, None])},
+    ],
+)
+@pytest.mark.parametrize("dtype, na_value", [(float, np.nan), (object, None)])
+def test_to_numpy_dataframe_na_value(data, dtype, na_value):
+    # https://github.com/pandas-dev/pandas/issues/33820
+    df = pd.DataFrame(data)
+    result = df.to_numpy(dtype=dtype, na_value=na_value)
+    expected = np.array([[1, 1], [2, 2], [3, na_value]], dtype=dtype)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+@pytest.mark.parametrize(
+    "data, expected",
+    [
+        (
+            {"a": pd.array([1, 2, None])},
+            np.array([[1.0], [2.0], [np.nan]], dtype=float),
+        ),
+        (
+            {"a": [1, 2, 3], "b": [1, 2, 3]},
+            np.array([[1, 1], [2, 2], [3, 3]], dtype=float),
+        ),
+    ],
+)
+def test_to_numpy_dataframe_single_block(data, expected):
+    # https://github.com/pandas-dev/pandas/issues/33820
+    df = pd.DataFrame(data)
+    result = df.to_numpy(dtype=float, na_value=np.nan)
+    tm.assert_numpy_array_equal(result, expected)
+
+
+def test_to_numpy_dataframe_single_block_no_mutate():
+    # https://github.com/pandas-dev/pandas/issues/33820
+    result = pd.DataFrame(np.array([1.0, 2.0, np.nan]))
+    expected = pd.DataFrame(np.array([1.0, 2.0, np.nan]))
+    result.to_numpy(na_value=0.0)
+    tm.assert_frame_equal(result, expected)
+
+
+class TestAsArray:
+    @pytest.mark.parametrize("tz", [None, "US/Central"])
+    def test_asarray_object_dt64(self, tz):
+        ser = Series(date_range("2000", periods=2, tz=tz))
+
+        with tm.assert_produces_warning(None):
+            # Future behavior (for tzaware case) with no warning
+            result = np.asarray(ser, dtype=object)
+
+        expected = np.array(
+            [Timestamp("2000-01-01", tz=tz), Timestamp("2000-01-02", tz=tz)]
+        )
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_asarray_tz_naive(self):
+        # This shouldn't produce a warning.
+        ser = Series(date_range("2000", periods=2))
+        expected = np.array(["2000-01-01", "2000-01-02"], dtype="M8[ns]")
+        result = np.asarray(ser)
+
+        tm.assert_numpy_array_equal(result, expected)
+
+    def test_asarray_tz_aware(self):
+        tz = "US/Central"
+        ser = Series(date_range("2000", periods=2, tz=tz))
+        expected = np.array(["2000-01-01T06", "2000-01-02T06"], dtype="M8[ns]")
+        result = np.asarray(ser, dtype="datetime64[ns]")
+
+        tm.assert_numpy_array_equal(result, expected)
+
+        # Old behavior with no warning
+        result = np.asarray(ser, dtype="M8[ns]")
+
+        tm.assert_numpy_array_equal(result, expected)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/test_fillna.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/test_fillna.py
new file mode 100644
index 0000000000000000000000000000000000000000..7300d3013305a7ca08312ae85cc42ae8950acf23
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/test_fillna.py
@@ -0,0 +1,60 @@
+"""
+Though Index.fillna and Series.fillna has separate impl,
+test here to confirm these works as the same
+"""
+
+import numpy as np
+import pytest
+
+from pandas import MultiIndex
+import pandas._testing as tm
+from pandas.tests.base.common import allow_na_ops
+
+
+def test_fillna(index_or_series_obj):
+    # GH 11343
+    obj = index_or_series_obj
+
+    if isinstance(obj, MultiIndex):
+        msg = "isna is not defined for MultiIndex"
+        with pytest.raises(NotImplementedError, match=msg):
+            obj.fillna(0)
+        return
+
+    # values will not be changed
+    fill_value = obj.values[0] if len(obj) > 0 else 0
+    result = obj.fillna(fill_value)
+
+    tm.assert_equal(obj, result)
+
+    # check shallow_copied
+    assert obj is not result
+
+
+@pytest.mark.parametrize("null_obj", [np.nan, None])
+def test_fillna_null(null_obj, index_or_series_obj):
+    # GH 11343
+    obj = index_or_series_obj
+    klass = type(obj)
+
+    if not allow_na_ops(obj):
+        pytest.skip(f"{klass} doesn't allow for NA operations")
+    elif len(obj) < 1:
+        pytest.skip("Test doesn't make sense on empty data")
+    elif isinstance(obj, MultiIndex):
+        pytest.skip(f"MultiIndex can't hold '{null_obj}'")
+
+    values = obj._values
+    fill_value = values[0]
+    expected = values.copy()
+    values[0:2] = null_obj
+    expected[0:2] = fill_value
+
+    expected = klass(expected)
+    obj = klass(values)
+
+    result = obj.fillna(fill_value)
+    tm.assert_equal(result, expected)
+
+    # check shallow_copied
+    assert obj is not result
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/test_misc.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/test_misc.py
new file mode 100644
index 0000000000000000000000000000000000000000..65e234e799353844bab2a63df582adfa5842d2cd
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/base/test_misc.py
@@ -0,0 +1,191 @@
+import sys
+
+import numpy as np
+import pytest
+
+from pandas._config import using_pyarrow_string_dtype
+
+from pandas.compat import PYPY
+
+from pandas.core.dtypes.common import (
+    is_dtype_equal,
+    is_object_dtype,
+)
+
+import pandas as pd
+from pandas import (
+    Index,
+    Series,
+)
+import pandas._testing as tm
+
+
+def test_isnull_notnull_docstrings():
+    # GH#41855 make sure its clear these are aliases
+    doc = pd.DataFrame.notnull.__doc__
+    assert doc.startswith("\nDataFrame.notnull is an alias for DataFrame.notna.\n")
+    doc = pd.DataFrame.isnull.__doc__
+    assert doc.startswith("\nDataFrame.isnull is an alias for DataFrame.isna.\n")
+
+    doc = Series.notnull.__doc__
+    assert doc.startswith("\nSeries.notnull is an alias for Series.notna.\n")
+    doc = Series.isnull.__doc__
+    assert doc.startswith("\nSeries.isnull is an alias for Series.isna.\n")
+
+
+@pytest.mark.parametrize(
+    "op_name, op",
+    [
+        ("add", "+"),
+        ("sub", "-"),
+        ("mul", "*"),
+        ("mod", "%"),
+        ("pow", "**"),
+        ("truediv", "/"),
+        ("floordiv", "//"),
+    ],
+)
+def test_binary_ops_docstring(frame_or_series, op_name, op):
+    # not using the all_arithmetic_functions fixture with _get_opstr
+    # as _get_opstr is used internally in the dynamic implementation of the docstring
+    klass = frame_or_series
+
+    operand1 = klass.__name__.lower()
+    operand2 = "other"
+    expected_str = " ".join([operand1, op, operand2])
+    assert expected_str in getattr(klass, op_name).__doc__
+
+    # reverse version of the binary ops
+    expected_str = " ".join([operand2, op, operand1])
+    assert expected_str in getattr(klass, "r" + op_name).__doc__
+
+
+def test_ndarray_compat_properties(index_or_series_obj):
+    obj = index_or_series_obj
+
+    # Check that we work.
+    for p in ["shape", "dtype", "T", "nbytes"]:
+        assert getattr(obj, p, None) is not None
+
+    # deprecated properties
+    for p in ["strides", "itemsize", "base", "data"]:
+        assert not hasattr(obj, p)
+
+    msg = "can only convert an array of size 1 to a Python scalar"
+    with pytest.raises(ValueError, match=msg):
+        obj.item()  # len > 1
+
+    assert obj.ndim == 1
+    assert obj.size == len(obj)
+
+    assert Index([1]).item() == 1
+    assert Series([1]).item() == 1
+
+
+@pytest.mark.skipif(
+    PYPY or using_pyarrow_string_dtype(),
+    reason="not relevant for PyPy doesn't work properly for arrow strings",
+)
+def test_memory_usage(index_or_series_memory_obj):
+    obj = index_or_series_memory_obj
+    # Clear index caches so that len(obj) == 0 report 0 memory usage
+    if isinstance(obj, Series):
+        is_ser = True
+        obj.index._engine.clear_mapping()
+    else:
+        is_ser = False
+        obj._engine.clear_mapping()
+
+    res = obj.memory_usage()
+    res_deep = obj.memory_usage(deep=True)
+
+    is_object = is_object_dtype(obj) or (is_ser and is_object_dtype(obj.index))
+    is_categorical = isinstance(obj.dtype, pd.CategoricalDtype) or (
+        is_ser and isinstance(obj.index.dtype, pd.CategoricalDtype)
+    )
+    is_object_string = is_dtype_equal(obj, "string[python]") or (
+        is_ser and is_dtype_equal(obj.index.dtype, "string[python]")
+    )
+
+    if len(obj) == 0:
+        expected = 0
+        assert res_deep == res == expected
+    elif is_object or is_categorical or is_object_string:
+        # only deep will pick them up
+        assert res_deep > res
+    else:
+        assert res == res_deep
+
+    # sys.getsizeof will call the .memory_usage with
+    # deep=True, and add on some GC overhead
+    diff = res_deep - sys.getsizeof(obj)
+    assert abs(diff) < 100
+
+
+def test_memory_usage_components_series(series_with_simple_index):
+    series = series_with_simple_index
+    total_usage = series.memory_usage(index=True)
+    non_index_usage = series.memory_usage(index=False)
+    index_usage = series.index.memory_usage()
+    assert total_usage == non_index_usage + index_usage
+
+
+@pytest.mark.parametrize("dtype", tm.NARROW_NP_DTYPES)
+def test_memory_usage_components_narrow_series(dtype):
+    series = Series(range(5), dtype=dtype, index=[f"i-{i}" for i in range(5)], name="a")
+    total_usage = series.memory_usage(index=True)
+    non_index_usage = series.memory_usage(index=False)
+    index_usage = series.index.memory_usage()
+    assert total_usage == non_index_usage + index_usage
+
+
+def test_searchsorted(request, index_or_series_obj):
+    # numpy.searchsorted calls obj.searchsorted under the hood.
+    # See gh-12238
+    obj = index_or_series_obj
+
+    if isinstance(obj, pd.MultiIndex):
+        # See gh-14833
+        request.applymarker(
+            pytest.mark.xfail(
+                reason="np.searchsorted doesn't work on pd.MultiIndex: GH 14833"
+            )
+        )
+    elif obj.dtype.kind == "c" and isinstance(obj, Index):
+        # TODO: Should Series cases also raise? Looks like they use numpy
+        #  comparison semantics https://github.com/numpy/numpy/issues/15981
+        mark = pytest.mark.xfail(reason="complex objects are not comparable")
+        request.applymarker(mark)
+
+    max_obj = max(obj, default=0)
+    index = np.searchsorted(obj, max_obj)
+    assert 0 <= index <= len(obj)
+
+    index = np.searchsorted(obj, max_obj, sorter=range(len(obj)))
+    assert 0 <= index <= len(obj)
+
+
+def test_access_by_position(index_flat):
+    index = index_flat
+
+    if len(index) == 0:
+        pytest.skip("Test doesn't make sense on empty data")
+
+    series = Series(index)
+    assert index[0] == series.iloc[0]
+    assert index[5] == series.iloc[5]
+    assert index[-1] == series.iloc[-1]
+
+    size = len(index)
+    assert index[-1] == index[size - 1]
+
+    msg = f"index {size} is out of bounds for axis 0 with size {size}"
+    if is_dtype_equal(index.dtype, "string[pyarrow]") or is_dtype_equal(
+        index.dtype, "string[pyarrow_numpy]"
+    ):
+        msg = "index out of bounds"
+    with pytest.raises(IndexError, match=msg):
+        index[size]
+    msg = "single positional indexer is out-of-bounds"
+    with pytest.raises(IndexError, match=msg):
+        series.iloc[size]
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__init__.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/__init__.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..23af3628cdf1aa15829843c6faf0acbae637be0a
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/__init__.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_astype.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_astype.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eab5a74973cab41d364b8f98d878a086a372f726
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_astype.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_chained_assignment_deprecation.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_chained_assignment_deprecation.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1835af76a30ec19ba07253b22bfab23f04d707ee
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_chained_assignment_deprecation.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_constructors.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_constructors.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c133f2a514c4874ba21b4cf412dd9859540b1269
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_constructors.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_core_functionalities.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_core_functionalities.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..05b9a026f2631330fea4c809590ff2c8dbe38eeb
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_core_functionalities.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_indexing.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_indexing.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fd2e37f04fcfb4524391f2f3ff2b5c94c65532ce
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_indexing.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_internals.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_internals.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..880b16e3b2f5a78c6323ee906f492e42182291d1
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_internals.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_interp_fillna.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_interp_fillna.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9d52c8bbfebd8c562b18939b5a4c05bb3494b86a
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_interp_fillna.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_methods.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_methods.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ac86473ccc0d4edf54ebc21ec490aa6defeb56e8
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_methods.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_setitem.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_setitem.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eae5f41cc93d25373a7295bffe63ffe1f6aa8a02
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/test_setitem.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/util.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/util.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c9401f5f26aa07ef1ffbe2db1bfd0e3d3707087e
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/__pycache__/util.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_array.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_array.py
new file mode 100644
index 0000000000000000000000000000000000000000..9a3f83e0293f539cd2a68e9eb515cd817d7eb48b
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_array.py
@@ -0,0 +1,190 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Series,
+    date_range,
+)
+import pandas._testing as tm
+from pandas.tests.copy_view.util import get_array
+
+# -----------------------------------------------------------------------------
+# Copy/view behaviour for accessing underlying array of Series/DataFrame
+
+
+@pytest.mark.parametrize(
+    "method",
+    [lambda ser: ser.values, lambda ser: np.asarray(ser)],
+    ids=["values", "asarray"],
+)
+def test_series_values(using_copy_on_write, method):
+    ser = Series([1, 2, 3], name="name")
+    ser_orig = ser.copy()
+
+    arr = method(ser)
+
+    if using_copy_on_write:
+        # .values still gives a view but is read-only
+        assert np.shares_memory(arr, get_array(ser, "name"))
+        assert arr.flags.writeable is False
+
+        # mutating series through arr therefore doesn't work
+        with pytest.raises(ValueError, match="read-only"):
+            arr[0] = 0
+        tm.assert_series_equal(ser, ser_orig)
+
+        # mutating the series itself still works
+        ser.iloc[0] = 0
+        assert ser.values[0] == 0
+    else:
+        assert arr.flags.writeable is True
+        arr[0] = 0
+        assert ser.iloc[0] == 0
+
+
+@pytest.mark.parametrize(
+    "method",
+    [lambda df: df.values, lambda df: np.asarray(df)],
+    ids=["values", "asarray"],
+)
+def test_dataframe_values(using_copy_on_write, using_array_manager, method):
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+    df_orig = df.copy()
+
+    arr = method(df)
+
+    if using_copy_on_write:
+        # .values still gives a view but is read-only
+        assert np.shares_memory(arr, get_array(df, "a"))
+        assert arr.flags.writeable is False
+
+        # mutating series through arr therefore doesn't work
+        with pytest.raises(ValueError, match="read-only"):
+            arr[0, 0] = 0
+        tm.assert_frame_equal(df, df_orig)
+
+        # mutating the series itself still works
+        df.iloc[0, 0] = 0
+        assert df.values[0, 0] == 0
+    else:
+        assert arr.flags.writeable is True
+        arr[0, 0] = 0
+        if not using_array_manager:
+            assert df.iloc[0, 0] == 0
+        else:
+            tm.assert_frame_equal(df, df_orig)
+
+
+def test_series_to_numpy(using_copy_on_write):
+    ser = Series([1, 2, 3], name="name")
+    ser_orig = ser.copy()
+
+    # default: copy=False, no dtype or NAs
+    arr = ser.to_numpy()
+    if using_copy_on_write:
+        # to_numpy still gives a view but is read-only
+        assert np.shares_memory(arr, get_array(ser, "name"))
+        assert arr.flags.writeable is False
+
+        # mutating series through arr therefore doesn't work
+        with pytest.raises(ValueError, match="read-only"):
+            arr[0] = 0
+        tm.assert_series_equal(ser, ser_orig)
+
+        # mutating the series itself still works
+        ser.iloc[0] = 0
+        assert ser.values[0] == 0
+    else:
+        assert arr.flags.writeable is True
+        arr[0] = 0
+        assert ser.iloc[0] == 0
+
+    # specify copy=False gives a writeable array
+    ser = Series([1, 2, 3], name="name")
+    arr = ser.to_numpy(copy=True)
+    assert not np.shares_memory(arr, get_array(ser, "name"))
+    assert arr.flags.writeable is True
+
+    # specifying a dtype that already causes a copy also gives a writeable array
+    ser = Series([1, 2, 3], name="name")
+    arr = ser.to_numpy(dtype="float64")
+    assert not np.shares_memory(arr, get_array(ser, "name"))
+    assert arr.flags.writeable is True
+
+
+@pytest.mark.parametrize("order", ["F", "C"])
+def test_ravel_read_only(using_copy_on_write, order):
+    ser = Series([1, 2, 3])
+    with tm.assert_produces_warning(FutureWarning, match="is deprecated"):
+        arr = ser.ravel(order=order)
+    if using_copy_on_write:
+        assert arr.flags.writeable is False
+    assert np.shares_memory(get_array(ser), arr)
+
+
+def test_series_array_ea_dtypes(using_copy_on_write):
+    ser = Series([1, 2, 3], dtype="Int64")
+    arr = np.asarray(ser, dtype="int64")
+    assert np.shares_memory(arr, get_array(ser))
+    if using_copy_on_write:
+        assert arr.flags.writeable is False
+    else:
+        assert arr.flags.writeable is True
+
+    arr = np.asarray(ser)
+    assert np.shares_memory(arr, get_array(ser))
+    if using_copy_on_write:
+        assert arr.flags.writeable is False
+    else:
+        assert arr.flags.writeable is True
+
+
+def test_dataframe_array_ea_dtypes(using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3]}, dtype="Int64")
+    arr = np.asarray(df, dtype="int64")
+    assert np.shares_memory(arr, get_array(df, "a"))
+    if using_copy_on_write:
+        assert arr.flags.writeable is False
+    else:
+        assert arr.flags.writeable is True
+
+    arr = np.asarray(df)
+    assert np.shares_memory(arr, get_array(df, "a"))
+    if using_copy_on_write:
+        assert arr.flags.writeable is False
+    else:
+        assert arr.flags.writeable is True
+
+
+def test_dataframe_array_string_dtype(using_copy_on_write, using_array_manager):
+    df = DataFrame({"a": ["a", "b"]}, dtype="string")
+    arr = np.asarray(df)
+    if not using_array_manager:
+        assert np.shares_memory(arr, get_array(df, "a"))
+    if using_copy_on_write:
+        assert arr.flags.writeable is False
+    else:
+        assert arr.flags.writeable is True
+
+
+def test_dataframe_multiple_numpy_dtypes():
+    df = DataFrame({"a": [1, 2, 3], "b": 1.5})
+    arr = np.asarray(df)
+    assert not np.shares_memory(arr, get_array(df, "a"))
+    assert arr.flags.writeable is True
+
+
+def test_values_is_ea(using_copy_on_write):
+    df = DataFrame({"a": date_range("2012-01-01", periods=3)})
+    arr = np.asarray(df)
+    if using_copy_on_write:
+        assert arr.flags.writeable is False
+    else:
+        assert arr.flags.writeable is True
+
+
+def test_empty_dataframe():
+    df = DataFrame()
+    arr = np.asarray(df)
+    assert arr.flags.writeable is True
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_astype.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_astype.py
new file mode 100644
index 0000000000000000000000000000000000000000..d462ce3d3187daf1b414d45ffe8193500ac8487c
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_astype.py
@@ -0,0 +1,260 @@
+import pickle
+
+import numpy as np
+import pytest
+
+from pandas.compat.pyarrow import pa_version_under12p0
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Series,
+    Timestamp,
+    date_range,
+)
+import pandas._testing as tm
+from pandas.tests.copy_view.util import get_array
+
+
+def test_astype_single_dtype(using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": 1.5})
+    df_orig = df.copy()
+    df2 = df.astype("float64")
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "c"), get_array(df, "c"))
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "c"), get_array(df, "c"))
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+    # mutating df2 triggers a copy-on-write for that column/block
+    df2.iloc[0, 2] = 5.5
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df2, "c"), get_array(df, "c"))
+    tm.assert_frame_equal(df, df_orig)
+
+    # mutating parent also doesn't update result
+    df2 = df.astype("float64")
+    df.iloc[0, 2] = 5.5
+    tm.assert_frame_equal(df2, df_orig.astype("float64"))
+
+
+@pytest.mark.parametrize("dtype", ["int64", "Int64"])
+@pytest.mark.parametrize("new_dtype", ["int64", "Int64", "int64[pyarrow]"])
+def test_astype_avoids_copy(using_copy_on_write, dtype, new_dtype):
+    if new_dtype == "int64[pyarrow]":
+        pytest.importorskip("pyarrow")
+    df = DataFrame({"a": [1, 2, 3]}, dtype=dtype)
+    df_orig = df.copy()
+    df2 = df.astype(new_dtype)
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+    # mutating df2 triggers a copy-on-write for that column/block
+    df2.iloc[0, 0] = 10
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    tm.assert_frame_equal(df, df_orig)
+
+    # mutating parent also doesn't update result
+    df2 = df.astype(new_dtype)
+    df.iloc[0, 0] = 100
+    tm.assert_frame_equal(df2, df_orig.astype(new_dtype))
+
+
+@pytest.mark.parametrize("dtype", ["float64", "int32", "Int32", "int32[pyarrow]"])
+def test_astype_different_target_dtype(using_copy_on_write, dtype):
+    if dtype == "int32[pyarrow]":
+        pytest.importorskip("pyarrow")
+    df = DataFrame({"a": [1, 2, 3]})
+    df_orig = df.copy()
+    df2 = df.astype(dtype)
+
+    assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    if using_copy_on_write:
+        assert df2._mgr._has_no_reference(0)
+
+    df2.iloc[0, 0] = 5
+    tm.assert_frame_equal(df, df_orig)
+
+    # mutating parent also doesn't update result
+    df2 = df.astype(dtype)
+    df.iloc[0, 0] = 100
+    tm.assert_frame_equal(df2, df_orig.astype(dtype))
+
+
+@td.skip_array_manager_invalid_test
+def test_astype_numpy_to_ea():
+    ser = Series([1, 2, 3])
+    with pd.option_context("mode.copy_on_write", True):
+        result = ser.astype("Int64")
+    assert np.shares_memory(get_array(ser), get_array(result))
+
+
+@pytest.mark.parametrize(
+    "dtype, new_dtype", [("object", "string"), ("string", "object")]
+)
+def test_astype_string_and_object(using_copy_on_write, dtype, new_dtype):
+    df = DataFrame({"a": ["a", "b", "c"]}, dtype=dtype)
+    df_orig = df.copy()
+    df2 = df.astype(new_dtype)
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+    df2.iloc[0, 0] = "x"
+    tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize(
+    "dtype, new_dtype", [("object", "string"), ("string", "object")]
+)
+def test_astype_string_and_object_update_original(
+    using_copy_on_write, dtype, new_dtype
+):
+    df = DataFrame({"a": ["a", "b", "c"]}, dtype=dtype)
+    df2 = df.astype(new_dtype)
+    df_orig = df2.copy()
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+    df.iloc[0, 0] = "x"
+    tm.assert_frame_equal(df2, df_orig)
+
+
+def test_astype_string_copy_on_pickle_roundrip():
+    # https://github.com/pandas-dev/pandas/issues/54654
+    # ensure_string_array may alter array inplace
+    base = Series(np.array([(1, 2), None, 1], dtype="object"))
+    base_copy = pickle.loads(pickle.dumps(base))
+    base_copy.astype(str)
+    tm.assert_series_equal(base, base_copy)
+
+
+def test_astype_dict_dtypes(using_copy_on_write):
+    df = DataFrame(
+        {"a": [1, 2, 3], "b": [4, 5, 6], "c": Series([1.5, 1.5, 1.5], dtype="float64")}
+    )
+    df_orig = df.copy()
+    df2 = df.astype({"a": "float64", "c": "float64"})
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "c"), get_array(df, "c"))
+        assert np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "c"), get_array(df, "c"))
+        assert not np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+    # mutating df2 triggers a copy-on-write for that column/block
+    df2.iloc[0, 2] = 5.5
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df2, "c"), get_array(df, "c"))
+
+    df2.iloc[0, 1] = 10
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_astype_different_datetime_resos(using_copy_on_write):
+    df = DataFrame({"a": date_range("2019-12-31", periods=2, freq="D")})
+    result = df.astype("datetime64[ms]")
+
+    assert not np.shares_memory(get_array(df, "a"), get_array(result, "a"))
+    if using_copy_on_write:
+        assert result._mgr._has_no_reference(0)
+
+
+def test_astype_different_timezones(using_copy_on_write):
+    df = DataFrame(
+        {"a": date_range("2019-12-31", periods=5, freq="D", tz="US/Pacific")}
+    )
+    result = df.astype("datetime64[ns, Europe/Berlin]")
+    if using_copy_on_write:
+        assert not result._mgr._has_no_reference(0)
+        assert np.shares_memory(get_array(df, "a"), get_array(result, "a"))
+
+
+def test_astype_different_timezones_different_reso(using_copy_on_write):
+    df = DataFrame(
+        {"a": date_range("2019-12-31", periods=5, freq="D", tz="US/Pacific")}
+    )
+    result = df.astype("datetime64[ms, Europe/Berlin]")
+    if using_copy_on_write:
+        assert result._mgr._has_no_reference(0)
+        assert not np.shares_memory(get_array(df, "a"), get_array(result, "a"))
+
+
+def test_astype_arrow_timestamp(using_copy_on_write):
+    pytest.importorskip("pyarrow")
+    df = DataFrame(
+        {
+            "a": [
+                Timestamp("2020-01-01 01:01:01.000001"),
+                Timestamp("2020-01-01 01:01:01.000001"),
+            ]
+        },
+        dtype="M8[ns]",
+    )
+    result = df.astype("timestamp[ns][pyarrow]")
+    if using_copy_on_write:
+        assert not result._mgr._has_no_reference(0)
+        if pa_version_under12p0:
+            assert not np.shares_memory(
+                get_array(df, "a"), get_array(result, "a")._pa_array
+            )
+        else:
+            assert np.shares_memory(
+                get_array(df, "a"), get_array(result, "a")._pa_array
+            )
+
+
+def test_convert_dtypes_infer_objects(using_copy_on_write):
+    ser = Series(["a", "b", "c"])
+    ser_orig = ser.copy()
+    result = ser.convert_dtypes(
+        convert_integer=False,
+        convert_boolean=False,
+        convert_floating=False,
+        convert_string=False,
+    )
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(ser), get_array(result))
+    else:
+        assert not np.shares_memory(get_array(ser), get_array(result))
+
+    result.iloc[0] = "x"
+    tm.assert_series_equal(ser, ser_orig)
+
+
+def test_convert_dtypes(using_copy_on_write):
+    df = DataFrame({"a": ["a", "b"], "b": [1, 2], "c": [1.5, 2.5], "d": [True, False]})
+    df_orig = df.copy()
+    df2 = df.convert_dtypes()
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+        assert np.shares_memory(get_array(df2, "d"), get_array(df, "d"))
+        assert np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+        assert np.shares_memory(get_array(df2, "c"), get_array(df, "c"))
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+        assert not np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+        assert not np.shares_memory(get_array(df2, "c"), get_array(df, "c"))
+        assert not np.shares_memory(get_array(df2, "d"), get_array(df, "d"))
+
+    df2.iloc[0, 0] = "x"
+    tm.assert_frame_equal(df, df_orig)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_chained_assignment_deprecation.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_chained_assignment_deprecation.py
new file mode 100644
index 0000000000000000000000000000000000000000..0a37f6b813e55d6072506a5c8168b050aa79ecda
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_chained_assignment_deprecation.py
@@ -0,0 +1,174 @@
+import numpy as np
+import pytest
+
+from pandas.compat import PY311
+from pandas.errors import (
+    ChainedAssignmentError,
+    SettingWithCopyWarning,
+)
+
+from pandas import (
+    DataFrame,
+    option_context,
+)
+import pandas._testing as tm
+
+
+def test_methods_iloc_warn(using_copy_on_write):
+    if not using_copy_on_write:
+        df = DataFrame({"a": [1, 2, 3], "b": 1})
+        with tm.assert_cow_warning(match="A value"):
+            df.iloc[:, 0].replace(1, 5, inplace=True)
+
+        with tm.assert_cow_warning(match="A value"):
+            df.iloc[:, 0].fillna(1, inplace=True)
+
+        with tm.assert_cow_warning(match="A value"):
+            df.iloc[:, 0].interpolate(inplace=True)
+
+        with tm.assert_cow_warning(match="A value"):
+            df.iloc[:, 0].ffill(inplace=True)
+
+        with tm.assert_cow_warning(match="A value"):
+            df.iloc[:, 0].bfill(inplace=True)
+
+
+@pytest.mark.parametrize(
+    "func, args",
+    [
+        ("replace", (4, 5)),
+        ("fillna", (1,)),
+        ("interpolate", ()),
+        ("bfill", ()),
+        ("ffill", ()),
+    ],
+)
+def test_methods_iloc_getitem_item_cache(
+    func, args, using_copy_on_write, warn_copy_on_write
+):
+    # ensure we don't incorrectly raise chained assignment warning because
+    # of the item cache / iloc not setting the item cache
+    df_orig = DataFrame({"a": [1, 2, 3], "b": 1})
+
+    df = df_orig.copy()
+    ser = df.iloc[:, 0]
+    getattr(ser, func)(*args, inplace=True)
+
+    # parent that holds item_cache is dead, so don't increase ref count
+    df = df_orig.copy()
+    ser = df.copy()["a"]
+    getattr(ser, func)(*args, inplace=True)
+
+    df = df_orig.copy()
+    df["a"]  # populate the item_cache
+    ser = df.iloc[:, 0]  # iloc creates a new object
+    getattr(ser, func)(*args, inplace=True)
+
+    df = df_orig.copy()
+    df["a"]  # populate the item_cache
+    ser = df["a"]
+    getattr(ser, func)(*args, inplace=True)
+
+    df = df_orig.copy()
+    df["a"]  # populate the item_cache
+    # TODO(CoW-warn) because of the usage of *args, this doesn't warn on Py3.11+
+    if using_copy_on_write:
+        with tm.raises_chained_assignment_error(not PY311):
+            getattr(df["a"], func)(*args, inplace=True)
+    else:
+        with tm.assert_cow_warning(not PY311, match="A value"):
+            getattr(df["a"], func)(*args, inplace=True)
+
+    df = df_orig.copy()
+    ser = df["a"]  # populate the item_cache and keep ref
+    if using_copy_on_write:
+        with tm.raises_chained_assignment_error(not PY311):
+            getattr(df["a"], func)(*args, inplace=True)
+    else:
+        # ideally also warns on the default mode, but the ser' _cacher
+        # messes up the refcount + even in warning mode this doesn't trigger
+        # the warning of Py3.1+ (see above)
+        with tm.assert_cow_warning(warn_copy_on_write and not PY311, match="A value"):
+            getattr(df["a"], func)(*args, inplace=True)
+
+
+def test_methods_iloc_getitem_item_cache_fillna(
+    using_copy_on_write, warn_copy_on_write
+):
+    # ensure we don't incorrectly raise chained assignment warning because
+    # of the item cache / iloc not setting the item cache
+    df_orig = DataFrame({"a": [1, 2, 3], "b": 1})
+
+    df = df_orig.copy()
+    ser = df.iloc[:, 0]
+    ser.fillna(1, inplace=True)
+
+    # parent that holds item_cache is dead, so don't increase ref count
+    df = df_orig.copy()
+    ser = df.copy()["a"]
+    ser.fillna(1, inplace=True)
+
+    df = df_orig.copy()
+    df["a"]  # populate the item_cache
+    ser = df.iloc[:, 0]  # iloc creates a new object
+    ser.fillna(1, inplace=True)
+
+    df = df_orig.copy()
+    df["a"]  # populate the item_cache
+    ser = df["a"]
+    ser.fillna(1, inplace=True)
+
+    df = df_orig.copy()
+    df["a"]  # populate the item_cache
+    if using_copy_on_write:
+        with tm.raises_chained_assignment_error():
+            df["a"].fillna(1, inplace=True)
+    else:
+        with tm.assert_cow_warning(match="A value"):
+            df["a"].fillna(1, inplace=True)
+
+    df = df_orig.copy()
+    ser = df["a"]  # populate the item_cache and keep ref
+    if using_copy_on_write:
+        with tm.raises_chained_assignment_error():
+            df["a"].fillna(1, inplace=True)
+    else:
+        # TODO(CoW-warn) ideally also warns on the default mode, but the ser' _cacher
+        # messes up the refcount
+        with tm.assert_cow_warning(warn_copy_on_write, match="A value"):
+            df["a"].fillna(1, inplace=True)
+
+
+# TODO(CoW-warn) expand the cases
+@pytest.mark.parametrize(
+    "indexer", [0, [0, 1], slice(0, 2), np.array([True, False, True])]
+)
+def test_series_setitem(indexer, using_copy_on_write, warn_copy_on_write):
+    # ensure we only get a single warning for those typical cases of chained
+    # assignment
+    df = DataFrame({"a": [1, 2, 3], "b": 1})
+
+    # using custom check instead of tm.assert_produces_warning because that doesn't
+    # fail if multiple warnings are raised
+    with pytest.warns() as record:
+        df["a"][indexer] = 0
+    assert len(record) == 1
+    if using_copy_on_write:
+        assert record[0].category == ChainedAssignmentError
+    else:
+        assert record[0].category == FutureWarning
+        assert "ChainedAssignmentError" in record[0].message.args[0]
+
+
+@pytest.mark.filterwarnings("ignore::pandas.errors.SettingWithCopyWarning")
+@pytest.mark.parametrize(
+    "indexer", ["a", ["a", "b"], slice(0, 2), np.array([True, False, True])]
+)
+def test_frame_setitem(indexer, using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3, 4, 5], "b": 1})
+
+    extra_warnings = () if using_copy_on_write else (SettingWithCopyWarning,)
+
+    with option_context("chained_assignment", "warn"):
+        with tm.raises_chained_assignment_error(extra_warnings=extra_warnings):
+            df[0:3][indexer] = 10
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_clip.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_clip.py
new file mode 100644
index 0000000000000000000000000000000000000000..7c87646424e2faf46b740692b007013fef1cfc75
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_clip.py
@@ -0,0 +1,101 @@
+import numpy as np
+
+from pandas import (
+    DataFrame,
+    option_context,
+)
+import pandas._testing as tm
+from pandas.tests.copy_view.util import get_array
+
+
+def test_clip_inplace_reference(using_copy_on_write, warn_copy_on_write):
+    df = DataFrame({"a": [1.5, 2, 3]})
+    df_copy = df.copy()
+    arr_a = get_array(df, "a")
+    view = df[:]
+    if warn_copy_on_write:
+        with tm.assert_cow_warning():
+            df.clip(lower=2, inplace=True)
+    else:
+        df.clip(lower=2, inplace=True)
+
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df, "a"), arr_a)
+        assert df._mgr._has_no_reference(0)
+        assert view._mgr._has_no_reference(0)
+        tm.assert_frame_equal(df_copy, view)
+    else:
+        assert np.shares_memory(get_array(df, "a"), arr_a)
+
+
+def test_clip_inplace_reference_no_op(using_copy_on_write):
+    df = DataFrame({"a": [1.5, 2, 3]})
+    df_copy = df.copy()
+    arr_a = get_array(df, "a")
+    view = df[:]
+    df.clip(lower=0, inplace=True)
+
+    assert np.shares_memory(get_array(df, "a"), arr_a)
+
+    if using_copy_on_write:
+        assert not df._mgr._has_no_reference(0)
+        assert not view._mgr._has_no_reference(0)
+        tm.assert_frame_equal(df_copy, view)
+
+
+def test_clip_inplace(using_copy_on_write):
+    df = DataFrame({"a": [1.5, 2, 3]})
+    arr_a = get_array(df, "a")
+    df.clip(lower=2, inplace=True)
+
+    assert np.shares_memory(get_array(df, "a"), arr_a)
+
+    if using_copy_on_write:
+        assert df._mgr._has_no_reference(0)
+
+
+def test_clip(using_copy_on_write):
+    df = DataFrame({"a": [1.5, 2, 3]})
+    df_orig = df.copy()
+    df2 = df.clip(lower=2)
+
+    assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+    if using_copy_on_write:
+        assert df._mgr._has_no_reference(0)
+    tm.assert_frame_equal(df_orig, df)
+
+
+def test_clip_no_op(using_copy_on_write):
+    df = DataFrame({"a": [1.5, 2, 3]})
+    df2 = df.clip(lower=0)
+
+    if using_copy_on_write:
+        assert not df._mgr._has_no_reference(0)
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+
+def test_clip_chained_inplace(using_copy_on_write):
+    df = DataFrame({"a": [1, 4, 2], "b": 1})
+    df_orig = df.copy()
+    if using_copy_on_write:
+        with tm.raises_chained_assignment_error():
+            df["a"].clip(1, 2, inplace=True)
+        tm.assert_frame_equal(df, df_orig)
+
+        with tm.raises_chained_assignment_error():
+            df[["a"]].clip(1, 2, inplace=True)
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        with tm.assert_produces_warning(FutureWarning, match="inplace method"):
+            df["a"].clip(1, 2, inplace=True)
+
+        with tm.assert_produces_warning(None):
+            with option_context("mode.chained_assignment", None):
+                df[["a"]].clip(1, 2, inplace=True)
+
+        with tm.assert_produces_warning(None):
+            with option_context("mode.chained_assignment", None):
+                df[df["a"] > 1].clip(1, 2, inplace=True)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_constructors.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_constructors.py
new file mode 100644
index 0000000000000000000000000000000000000000..1aa458a62502890f56d9e00af02dd4d7b777a5bb
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_constructors.py
@@ -0,0 +1,382 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    Index,
+    Period,
+    PeriodIndex,
+    Series,
+    Timedelta,
+    TimedeltaIndex,
+    Timestamp,
+)
+import pandas._testing as tm
+from pandas.tests.copy_view.util import get_array
+
+# -----------------------------------------------------------------------------
+# Copy/view behaviour for Series / DataFrame constructors
+
+
+@pytest.mark.parametrize("dtype", [None, "int64"])
+def test_series_from_series(dtype, using_copy_on_write, warn_copy_on_write):
+    # Case: constructing a Series from another Series object follows CoW rules:
+    # a new object is returned and thus mutations are not propagated
+    ser = Series([1, 2, 3], name="name")
+
+    # default is copy=False -> new Series is a shallow copy / view of original
+    result = Series(ser, dtype=dtype)
+
+    # the shallow copy still shares memory
+    assert np.shares_memory(get_array(ser), get_array(result))
+
+    if using_copy_on_write:
+        assert result._mgr.blocks[0].refs.has_reference()
+
+    if using_copy_on_write:
+        # mutating new series copy doesn't mutate original
+        result.iloc[0] = 0
+        assert ser.iloc[0] == 1
+        # mutating triggered a copy-on-write -> no longer shares memory
+        assert not np.shares_memory(get_array(ser), get_array(result))
+    else:
+        # mutating shallow copy does mutate original
+        with tm.assert_cow_warning(warn_copy_on_write):
+            result.iloc[0] = 0
+        assert ser.iloc[0] == 0
+        # and still shares memory
+        assert np.shares_memory(get_array(ser), get_array(result))
+
+    # the same when modifying the parent
+    result = Series(ser, dtype=dtype)
+
+    if using_copy_on_write:
+        # mutating original doesn't mutate new series
+        ser.iloc[0] = 0
+        assert result.iloc[0] == 1
+    else:
+        # mutating original does mutate shallow copy
+        with tm.assert_cow_warning(warn_copy_on_write):
+            ser.iloc[0] = 0
+        assert result.iloc[0] == 0
+
+
+def test_series_from_series_with_reindex(using_copy_on_write, warn_copy_on_write):
+    # Case: constructing a Series from another Series with specifying an index
+    # that potentially requires a reindex of the values
+    ser = Series([1, 2, 3], name="name")
+
+    # passing an index that doesn't actually require a reindex of the values
+    # -> without CoW we get an actual mutating view
+    for index in [
+        ser.index,
+        ser.index.copy(),
+        list(ser.index),
+        ser.index.rename("idx"),
+    ]:
+        result = Series(ser, index=index)
+        assert np.shares_memory(ser.values, result.values)
+        with tm.assert_cow_warning(warn_copy_on_write):
+            result.iloc[0] = 0
+        if using_copy_on_write:
+            assert ser.iloc[0] == 1
+        else:
+            assert ser.iloc[0] == 0
+
+    # ensure that if an actual reindex is needed, we don't have any refs
+    # (mutating the result wouldn't trigger CoW)
+    result = Series(ser, index=[0, 1, 2, 3])
+    assert not np.shares_memory(ser.values, result.values)
+    if using_copy_on_write:
+        assert not result._mgr.blocks[0].refs.has_reference()
+
+
+@pytest.mark.parametrize("fastpath", [False, True])
+@pytest.mark.parametrize("dtype", [None, "int64"])
+@pytest.mark.parametrize("idx", [None, pd.RangeIndex(start=0, stop=3, step=1)])
+@pytest.mark.parametrize(
+    "arr", [np.array([1, 2, 3], dtype="int64"), pd.array([1, 2, 3], dtype="Int64")]
+)
+def test_series_from_array(using_copy_on_write, idx, dtype, fastpath, arr):
+    if idx is None or dtype is not None:
+        fastpath = False
+    msg = "The 'fastpath' keyword in pd.Series is deprecated"
+    with tm.assert_produces_warning(DeprecationWarning, match=msg):
+        ser = Series(arr, dtype=dtype, index=idx, fastpath=fastpath)
+    ser_orig = ser.copy()
+    data = getattr(arr, "_data", arr)
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(ser), data)
+    else:
+        assert np.shares_memory(get_array(ser), data)
+
+    arr[0] = 100
+    if using_copy_on_write:
+        tm.assert_series_equal(ser, ser_orig)
+    else:
+        expected = Series([100, 2, 3], dtype=dtype if dtype is not None else arr.dtype)
+        tm.assert_series_equal(ser, expected)
+
+
+@pytest.mark.parametrize("copy", [True, False, None])
+def test_series_from_array_different_dtype(using_copy_on_write, copy):
+    arr = np.array([1, 2, 3], dtype="int64")
+    ser = Series(arr, dtype="int32", copy=copy)
+    assert not np.shares_memory(get_array(ser), arr)
+
+
+@pytest.mark.parametrize(
+    "idx",
+    [
+        Index([1, 2]),
+        DatetimeIndex([Timestamp("2019-12-31"), Timestamp("2020-12-31")]),
+        PeriodIndex([Period("2019-12-31"), Period("2020-12-31")]),
+        TimedeltaIndex([Timedelta("1 days"), Timedelta("2 days")]),
+    ],
+)
+def test_series_from_index(using_copy_on_write, idx):
+    ser = Series(idx)
+    expected = idx.copy(deep=True)
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(ser), get_array(idx))
+        assert not ser._mgr._has_no_reference(0)
+    else:
+        assert not np.shares_memory(get_array(ser), get_array(idx))
+    ser.iloc[0] = ser.iloc[1]
+    tm.assert_index_equal(idx, expected)
+
+
+def test_series_from_index_different_dtypes(using_copy_on_write):
+    idx = Index([1, 2, 3], dtype="int64")
+    ser = Series(idx, dtype="int32")
+    assert not np.shares_memory(get_array(ser), get_array(idx))
+    if using_copy_on_write:
+        assert ser._mgr._has_no_reference(0)
+
+
+@pytest.mark.filterwarnings("ignore:Setting a value on a view:FutureWarning")
+@pytest.mark.parametrize("fastpath", [False, True])
+@pytest.mark.parametrize("dtype", [None, "int64"])
+@pytest.mark.parametrize("idx", [None, pd.RangeIndex(start=0, stop=3, step=1)])
+def test_series_from_block_manager(using_copy_on_write, idx, dtype, fastpath):
+    ser = Series([1, 2, 3], dtype="int64")
+    ser_orig = ser.copy()
+    msg = "The 'fastpath' keyword in pd.Series is deprecated"
+    with tm.assert_produces_warning(DeprecationWarning, match=msg):
+        ser2 = Series(ser._mgr, dtype=dtype, fastpath=fastpath, index=idx)
+    assert np.shares_memory(get_array(ser), get_array(ser2))
+    if using_copy_on_write:
+        assert not ser2._mgr._has_no_reference(0)
+
+    ser2.iloc[0] = 100
+    if using_copy_on_write:
+        tm.assert_series_equal(ser, ser_orig)
+    else:
+        expected = Series([100, 2, 3])
+        tm.assert_series_equal(ser, expected)
+
+
+def test_series_from_block_manager_different_dtype(using_copy_on_write):
+    ser = Series([1, 2, 3], dtype="int64")
+    msg = "Passing a SingleBlockManager to Series"
+    with tm.assert_produces_warning(DeprecationWarning, match=msg):
+        ser2 = Series(ser._mgr, dtype="int32")
+    assert not np.shares_memory(get_array(ser), get_array(ser2))
+    if using_copy_on_write:
+        assert ser2._mgr._has_no_reference(0)
+
+
+@pytest.mark.parametrize("use_mgr", [True, False])
+@pytest.mark.parametrize("columns", [None, ["a"]])
+def test_dataframe_constructor_mgr_or_df(
+    using_copy_on_write, warn_copy_on_write, columns, use_mgr
+):
+    df = DataFrame({"a": [1, 2, 3]})
+    df_orig = df.copy()
+
+    if use_mgr:
+        data = df._mgr
+        warn = DeprecationWarning
+    else:
+        data = df
+        warn = None
+    msg = "Passing a BlockManager to DataFrame"
+    with tm.assert_produces_warning(warn, match=msg, check_stacklevel=False):
+        new_df = DataFrame(data)
+
+    assert np.shares_memory(get_array(df, "a"), get_array(new_df, "a"))
+    with tm.assert_cow_warning(warn_copy_on_write and not use_mgr):
+        new_df.iloc[0] = 100
+
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df, "a"), get_array(new_df, "a"))
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        assert np.shares_memory(get_array(df, "a"), get_array(new_df, "a"))
+        tm.assert_frame_equal(df, new_df)
+
+
+@pytest.mark.parametrize("dtype", [None, "int64", "Int64"])
+@pytest.mark.parametrize("index", [None, [0, 1, 2]])
+@pytest.mark.parametrize("columns", [None, ["a", "b"], ["a", "b", "c"]])
+def test_dataframe_from_dict_of_series(
+    request, using_copy_on_write, warn_copy_on_write, columns, index, dtype
+):
+    # Case: constructing a DataFrame from Series objects with copy=False
+    # has to do a lazy following CoW rules
+    # (the default for DataFrame(dict) is still to copy to ensure consolidation)
+    s1 = Series([1, 2, 3])
+    s2 = Series([4, 5, 6])
+    s1_orig = s1.copy()
+    expected = DataFrame(
+        {"a": [1, 2, 3], "b": [4, 5, 6]}, index=index, columns=columns, dtype=dtype
+    )
+
+    result = DataFrame(
+        {"a": s1, "b": s2}, index=index, columns=columns, dtype=dtype, copy=False
+    )
+
+    # the shallow copy still shares memory
+    assert np.shares_memory(get_array(result, "a"), get_array(s1))
+
+    # mutating the new dataframe doesn't mutate original
+    with tm.assert_cow_warning(warn_copy_on_write):
+        result.iloc[0, 0] = 10
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "a"), get_array(s1))
+        tm.assert_series_equal(s1, s1_orig)
+    else:
+        assert s1.iloc[0] == 10
+
+    # the same when modifying the parent series
+    s1 = Series([1, 2, 3])
+    s2 = Series([4, 5, 6])
+    result = DataFrame(
+        {"a": s1, "b": s2}, index=index, columns=columns, dtype=dtype, copy=False
+    )
+    with tm.assert_cow_warning(warn_copy_on_write):
+        s1.iloc[0] = 10
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "a"), get_array(s1))
+        tm.assert_frame_equal(result, expected)
+    else:
+        assert result.iloc[0, 0] == 10
+
+
+@pytest.mark.parametrize("dtype", [None, "int64"])
+def test_dataframe_from_dict_of_series_with_reindex(dtype):
+    # Case: constructing a DataFrame from Series objects with copy=False
+    # and passing an index that requires an actual (no-view) reindex -> need
+    # to ensure the result doesn't have refs set up to unnecessarily trigger
+    # a copy on write
+    s1 = Series([1, 2, 3])
+    s2 = Series([4, 5, 6])
+    df = DataFrame({"a": s1, "b": s2}, index=[1, 2, 3], dtype=dtype, copy=False)
+
+    # df should own its memory, so mutating shouldn't trigger a copy
+    arr_before = get_array(df, "a")
+    assert not np.shares_memory(arr_before, get_array(s1))
+    df.iloc[0, 0] = 100
+    arr_after = get_array(df, "a")
+    assert np.shares_memory(arr_before, arr_after)
+
+
+@pytest.mark.parametrize("cons", [Series, Index])
+@pytest.mark.parametrize(
+    "data, dtype", [([1, 2], None), ([1, 2], "int64"), (["a", "b"], None)]
+)
+def test_dataframe_from_series_or_index(
+    using_copy_on_write, warn_copy_on_write, data, dtype, cons
+):
+    obj = cons(data, dtype=dtype)
+    obj_orig = obj.copy()
+    df = DataFrame(obj, dtype=dtype)
+    assert np.shares_memory(get_array(obj), get_array(df, 0))
+    if using_copy_on_write:
+        assert not df._mgr._has_no_reference(0)
+
+    with tm.assert_cow_warning(warn_copy_on_write):
+        df.iloc[0, 0] = data[-1]
+    if using_copy_on_write:
+        tm.assert_equal(obj, obj_orig)
+
+
+@pytest.mark.parametrize("cons", [Series, Index])
+def test_dataframe_from_series_or_index_different_dtype(using_copy_on_write, cons):
+    obj = cons([1, 2], dtype="int64")
+    df = DataFrame(obj, dtype="int32")
+    assert not np.shares_memory(get_array(obj), get_array(df, 0))
+    if using_copy_on_write:
+        assert df._mgr._has_no_reference(0)
+
+
+def test_dataframe_from_series_infer_datetime(using_copy_on_write):
+    ser = Series([Timestamp("2019-12-31"), Timestamp("2020-12-31")], dtype=object)
+    with tm.assert_produces_warning(FutureWarning, match="Dtype inference"):
+        df = DataFrame(ser)
+    assert not np.shares_memory(get_array(ser), get_array(df, 0))
+    if using_copy_on_write:
+        assert df._mgr._has_no_reference(0)
+
+
+@pytest.mark.parametrize("index", [None, [0, 1, 2]])
+def test_dataframe_from_dict_of_series_with_dtype(index):
+    # Variant of above, but now passing a dtype that causes a copy
+    # -> need to ensure the result doesn't have refs set up to unnecessarily
+    # trigger a copy on write
+    s1 = Series([1.0, 2.0, 3.0])
+    s2 = Series([4, 5, 6])
+    df = DataFrame({"a": s1, "b": s2}, index=index, dtype="int64", copy=False)
+
+    # df should own its memory, so mutating shouldn't trigger a copy
+    arr_before = get_array(df, "a")
+    assert not np.shares_memory(arr_before, get_array(s1))
+    df.iloc[0, 0] = 100
+    arr_after = get_array(df, "a")
+    assert np.shares_memory(arr_before, arr_after)
+
+
+@pytest.mark.parametrize("copy", [False, None, True])
+def test_frame_from_numpy_array(using_copy_on_write, copy, using_array_manager):
+    arr = np.array([[1, 2], [3, 4]])
+    df = DataFrame(arr, copy=copy)
+
+    if (
+        using_copy_on_write
+        and copy is not False
+        or copy is True
+        or (using_array_manager and copy is None)
+    ):
+        assert not np.shares_memory(get_array(df, 0), arr)
+    else:
+        assert np.shares_memory(get_array(df, 0), arr)
+
+
+def test_dataframe_from_records_with_dataframe(using_copy_on_write, warn_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3]})
+    df_orig = df.copy()
+    with tm.assert_produces_warning(FutureWarning):
+        df2 = DataFrame.from_records(df)
+    if using_copy_on_write:
+        assert not df._mgr._has_no_reference(0)
+    assert np.shares_memory(get_array(df, "a"), get_array(df2, "a"))
+    with tm.assert_cow_warning(warn_copy_on_write):
+        df2.iloc[0, 0] = 100
+    if using_copy_on_write:
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        tm.assert_frame_equal(df, df2)
+
+
+def test_frame_from_dict_of_index(using_copy_on_write):
+    idx = Index([1, 2, 3])
+    expected = idx.copy(deep=True)
+    df = DataFrame({"a": idx}, copy=False)
+    assert np.shares_memory(get_array(df, "a"), idx._values)
+    if using_copy_on_write:
+        assert not df._mgr._has_no_reference(0)
+
+        df.iloc[0, 0] = 100
+        tm.assert_index_equal(idx, expected)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_core_functionalities.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_core_functionalities.py
new file mode 100644
index 0000000000000000000000000000000000000000..8dc80c5cc0e0eadbe792e114d48593d95df17907
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_core_functionalities.py
@@ -0,0 +1,106 @@
+import numpy as np
+import pytest
+
+from pandas import DataFrame
+import pandas._testing as tm
+from pandas.tests.copy_view.util import get_array
+
+
+def test_assigning_to_same_variable_removes_references(using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3]})
+    df = df.reset_index()
+    if using_copy_on_write:
+        assert df._mgr._has_no_reference(1)
+    arr = get_array(df, "a")
+    df.iloc[0, 1] = 100  # Write into a
+
+    assert np.shares_memory(arr, get_array(df, "a"))
+
+
+def test_setitem_dont_track_unnecessary_references(using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": 1, "c": 1})
+
+    df["b"] = 100
+    arr = get_array(df, "a")
+    # We split the block in setitem, if we are not careful the new blocks will
+    # reference each other triggering a copy
+    df.iloc[0, 0] = 100
+    assert np.shares_memory(arr, get_array(df, "a"))
+
+
+def test_setitem_with_view_copies(using_copy_on_write, warn_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": 1, "c": 1})
+    view = df[:]
+    expected = df.copy()
+
+    df["b"] = 100
+    arr = get_array(df, "a")
+    with tm.assert_cow_warning(warn_copy_on_write):
+        df.iloc[0, 0] = 100  # Check that we correctly track reference
+    if using_copy_on_write:
+        assert not np.shares_memory(arr, get_array(df, "a"))
+        tm.assert_frame_equal(view, expected)
+
+
+def test_setitem_with_view_invalidated_does_not_copy(
+    using_copy_on_write, warn_copy_on_write, request
+):
+    df = DataFrame({"a": [1, 2, 3], "b": 1, "c": 1})
+    view = df[:]
+
+    df["b"] = 100
+    arr = get_array(df, "a")
+    view = None  # noqa: F841
+    # TODO(CoW-warn) false positive? -> block gets split because of `df["b"] = 100`
+    # which introduces additional refs, even when those of `view` go out of scopes
+    with tm.assert_cow_warning(warn_copy_on_write):
+        df.iloc[0, 0] = 100
+    if using_copy_on_write:
+        # Setitem split the block. Since the old block shared data with view
+        # all the new blocks are referencing view and each other. When view
+        # goes out of scope, they don't share data with any other block,
+        # so we should not trigger a copy
+        mark = pytest.mark.xfail(
+            reason="blk.delete does not track references correctly"
+        )
+        request.applymarker(mark)
+        assert np.shares_memory(arr, get_array(df, "a"))
+
+
+def test_out_of_scope(using_copy_on_write):
+    def func():
+        df = DataFrame({"a": [1, 2], "b": 1.5, "c": 1})
+        # create some subset
+        result = df[["a", "b"]]
+        return result
+
+    result = func()
+    if using_copy_on_write:
+        assert not result._mgr.blocks[0].refs.has_reference()
+        assert not result._mgr.blocks[1].refs.has_reference()
+
+
+def test_delete(using_copy_on_write):
+    df = DataFrame(
+        np.random.default_rng(2).standard_normal((4, 3)), columns=["a", "b", "c"]
+    )
+    del df["b"]
+    if using_copy_on_write:
+        assert not df._mgr.blocks[0].refs.has_reference()
+        assert not df._mgr.blocks[1].refs.has_reference()
+
+    df = df[["a"]]
+    if using_copy_on_write:
+        assert not df._mgr.blocks[0].refs.has_reference()
+
+
+def test_delete_reference(using_copy_on_write):
+    df = DataFrame(
+        np.random.default_rng(2).standard_normal((4, 3)), columns=["a", "b", "c"]
+    )
+    x = df[:]
+    del df["b"]
+    if using_copy_on_write:
+        assert df._mgr.blocks[0].refs.has_reference()
+        assert df._mgr.blocks[1].refs.has_reference()
+        assert x._mgr.blocks[0].refs.has_reference()
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_functions.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..56e4b186350f2719978d6ca3803154033c8e08af
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_functions.py
@@ -0,0 +1,396 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Index,
+    Series,
+    concat,
+    merge,
+)
+import pandas._testing as tm
+from pandas.tests.copy_view.util import get_array
+
+
+def test_concat_frames(using_copy_on_write):
+    df = DataFrame({"b": ["a"] * 3})
+    df2 = DataFrame({"a": ["a"] * 3})
+    df_orig = df.copy()
+    result = concat([df, df2], axis=1)
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(result, "b"), get_array(df, "b"))
+        assert np.shares_memory(get_array(result, "a"), get_array(df2, "a"))
+    else:
+        assert not np.shares_memory(get_array(result, "b"), get_array(df, "b"))
+        assert not np.shares_memory(get_array(result, "a"), get_array(df2, "a"))
+
+    result.iloc[0, 0] = "d"
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "b"), get_array(df, "b"))
+        assert np.shares_memory(get_array(result, "a"), get_array(df2, "a"))
+
+    result.iloc[0, 1] = "d"
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "a"), get_array(df2, "a"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_concat_frames_updating_input(using_copy_on_write):
+    df = DataFrame({"b": ["a"] * 3})
+    df2 = DataFrame({"a": ["a"] * 3})
+    result = concat([df, df2], axis=1)
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(result, "b"), get_array(df, "b"))
+        assert np.shares_memory(get_array(result, "a"), get_array(df2, "a"))
+    else:
+        assert not np.shares_memory(get_array(result, "b"), get_array(df, "b"))
+        assert not np.shares_memory(get_array(result, "a"), get_array(df2, "a"))
+
+    expected = result.copy()
+    df.iloc[0, 0] = "d"
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "b"), get_array(df, "b"))
+        assert np.shares_memory(get_array(result, "a"), get_array(df2, "a"))
+
+    df2.iloc[0, 0] = "d"
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "a"), get_array(df2, "a"))
+    tm.assert_frame_equal(result, expected)
+
+
+def test_concat_series(using_copy_on_write):
+    ser = Series([1, 2], name="a")
+    ser2 = Series([3, 4], name="b")
+    ser_orig = ser.copy()
+    ser2_orig = ser2.copy()
+    result = concat([ser, ser2], axis=1)
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(result, "a"), ser.values)
+        assert np.shares_memory(get_array(result, "b"), ser2.values)
+    else:
+        assert not np.shares_memory(get_array(result, "a"), ser.values)
+        assert not np.shares_memory(get_array(result, "b"), ser2.values)
+
+    result.iloc[0, 0] = 100
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "a"), ser.values)
+        assert np.shares_memory(get_array(result, "b"), ser2.values)
+
+    result.iloc[0, 1] = 1000
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "b"), ser2.values)
+    tm.assert_series_equal(ser, ser_orig)
+    tm.assert_series_equal(ser2, ser2_orig)
+
+
+def test_concat_frames_chained(using_copy_on_write):
+    df1 = DataFrame({"a": [1, 2, 3], "b": [0.1, 0.2, 0.3]})
+    df2 = DataFrame({"c": [4, 5, 6]})
+    df3 = DataFrame({"d": [4, 5, 6]})
+    result = concat([concat([df1, df2], axis=1), df3], axis=1)
+    expected = result.copy()
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(result, "a"), get_array(df1, "a"))
+        assert np.shares_memory(get_array(result, "c"), get_array(df2, "c"))
+        assert np.shares_memory(get_array(result, "d"), get_array(df3, "d"))
+    else:
+        assert not np.shares_memory(get_array(result, "a"), get_array(df1, "a"))
+        assert not np.shares_memory(get_array(result, "c"), get_array(df2, "c"))
+        assert not np.shares_memory(get_array(result, "d"), get_array(df3, "d"))
+
+    df1.iloc[0, 0] = 100
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "a"), get_array(df1, "a"))
+
+    tm.assert_frame_equal(result, expected)
+
+
+def test_concat_series_chained(using_copy_on_write):
+    ser1 = Series([1, 2, 3], name="a")
+    ser2 = Series([4, 5, 6], name="c")
+    ser3 = Series([4, 5, 6], name="d")
+    result = concat([concat([ser1, ser2], axis=1), ser3], axis=1)
+    expected = result.copy()
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(result, "a"), get_array(ser1, "a"))
+        assert np.shares_memory(get_array(result, "c"), get_array(ser2, "c"))
+        assert np.shares_memory(get_array(result, "d"), get_array(ser3, "d"))
+    else:
+        assert not np.shares_memory(get_array(result, "a"), get_array(ser1, "a"))
+        assert not np.shares_memory(get_array(result, "c"), get_array(ser2, "c"))
+        assert not np.shares_memory(get_array(result, "d"), get_array(ser3, "d"))
+
+    ser1.iloc[0] = 100
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "a"), get_array(ser1, "a"))
+
+    tm.assert_frame_equal(result, expected)
+
+
+def test_concat_series_updating_input(using_copy_on_write):
+    ser = Series([1, 2], name="a")
+    ser2 = Series([3, 4], name="b")
+    expected = DataFrame({"a": [1, 2], "b": [3, 4]})
+    result = concat([ser, ser2], axis=1)
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(result, "a"), get_array(ser, "a"))
+        assert np.shares_memory(get_array(result, "b"), get_array(ser2, "b"))
+    else:
+        assert not np.shares_memory(get_array(result, "a"), get_array(ser, "a"))
+        assert not np.shares_memory(get_array(result, "b"), get_array(ser2, "b"))
+
+    ser.iloc[0] = 100
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "a"), get_array(ser, "a"))
+        assert np.shares_memory(get_array(result, "b"), get_array(ser2, "b"))
+    tm.assert_frame_equal(result, expected)
+
+    ser2.iloc[0] = 1000
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "b"), get_array(ser2, "b"))
+    tm.assert_frame_equal(result, expected)
+
+
+def test_concat_mixed_series_frame(using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "c": 1})
+    ser = Series([4, 5, 6], name="d")
+    result = concat([df, ser], axis=1)
+    expected = result.copy()
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(result, "a"), get_array(df, "a"))
+        assert np.shares_memory(get_array(result, "c"), get_array(df, "c"))
+        assert np.shares_memory(get_array(result, "d"), get_array(ser, "d"))
+    else:
+        assert not np.shares_memory(get_array(result, "a"), get_array(df, "a"))
+        assert not np.shares_memory(get_array(result, "c"), get_array(df, "c"))
+        assert not np.shares_memory(get_array(result, "d"), get_array(ser, "d"))
+
+    ser.iloc[0] = 100
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "d"), get_array(ser, "d"))
+
+    df.iloc[0, 0] = 100
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "a"), get_array(df, "a"))
+    tm.assert_frame_equal(result, expected)
+
+
+@pytest.mark.parametrize("copy", [True, None, False])
+def test_concat_copy_keyword(using_copy_on_write, copy):
+    df = DataFrame({"a": [1, 2]})
+    df2 = DataFrame({"b": [1.5, 2.5]})
+
+    result = concat([df, df2], axis=1, copy=copy)
+
+    if using_copy_on_write or copy is False:
+        assert np.shares_memory(get_array(df, "a"), get_array(result, "a"))
+        assert np.shares_memory(get_array(df2, "b"), get_array(result, "b"))
+    else:
+        assert not np.shares_memory(get_array(df, "a"), get_array(result, "a"))
+        assert not np.shares_memory(get_array(df2, "b"), get_array(result, "b"))
+
+
+@pytest.mark.parametrize(
+    "func",
+    [
+        lambda df1, df2, **kwargs: df1.merge(df2, **kwargs),
+        lambda df1, df2, **kwargs: merge(df1, df2, **kwargs),
+    ],
+)
+def test_merge_on_key(using_copy_on_write, func):
+    df1 = DataFrame({"key": ["a", "b", "c"], "a": [1, 2, 3]})
+    df2 = DataFrame({"key": ["a", "b", "c"], "b": [4, 5, 6]})
+    df1_orig = df1.copy()
+    df2_orig = df2.copy()
+
+    result = func(df1, df2, on="key")
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(result, "a"), get_array(df1, "a"))
+        assert np.shares_memory(get_array(result, "b"), get_array(df2, "b"))
+        assert np.shares_memory(get_array(result, "key"), get_array(df1, "key"))
+        assert not np.shares_memory(get_array(result, "key"), get_array(df2, "key"))
+    else:
+        assert not np.shares_memory(get_array(result, "a"), get_array(df1, "a"))
+        assert not np.shares_memory(get_array(result, "b"), get_array(df2, "b"))
+
+    result.iloc[0, 1] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "a"), get_array(df1, "a"))
+        assert np.shares_memory(get_array(result, "b"), get_array(df2, "b"))
+
+    result.iloc[0, 2] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "b"), get_array(df2, "b"))
+    tm.assert_frame_equal(df1, df1_orig)
+    tm.assert_frame_equal(df2, df2_orig)
+
+
+def test_merge_on_index(using_copy_on_write):
+    df1 = DataFrame({"a": [1, 2, 3]})
+    df2 = DataFrame({"b": [4, 5, 6]})
+    df1_orig = df1.copy()
+    df2_orig = df2.copy()
+
+    result = merge(df1, df2, left_index=True, right_index=True)
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(result, "a"), get_array(df1, "a"))
+        assert np.shares_memory(get_array(result, "b"), get_array(df2, "b"))
+    else:
+        assert not np.shares_memory(get_array(result, "a"), get_array(df1, "a"))
+        assert not np.shares_memory(get_array(result, "b"), get_array(df2, "b"))
+
+    result.iloc[0, 0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "a"), get_array(df1, "a"))
+        assert np.shares_memory(get_array(result, "b"), get_array(df2, "b"))
+
+    result.iloc[0, 1] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "b"), get_array(df2, "b"))
+    tm.assert_frame_equal(df1, df1_orig)
+    tm.assert_frame_equal(df2, df2_orig)
+
+
+@pytest.mark.parametrize(
+    "func, how",
+    [
+        (lambda df1, df2, **kwargs: merge(df2, df1, on="key", **kwargs), "right"),
+        (lambda df1, df2, **kwargs: merge(df1, df2, on="key", **kwargs), "left"),
+    ],
+)
+def test_merge_on_key_enlarging_one(using_copy_on_write, func, how):
+    df1 = DataFrame({"key": ["a", "b", "c"], "a": [1, 2, 3]})
+    df2 = DataFrame({"key": ["a", "b"], "b": [4, 5]})
+    df1_orig = df1.copy()
+    df2_orig = df2.copy()
+
+    result = func(df1, df2, how=how)
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(result, "a"), get_array(df1, "a"))
+        assert not np.shares_memory(get_array(result, "b"), get_array(df2, "b"))
+        assert df2._mgr._has_no_reference(1)
+        assert df2._mgr._has_no_reference(0)
+        assert np.shares_memory(get_array(result, "key"), get_array(df1, "key")) is (
+            how == "left"
+        )
+        assert not np.shares_memory(get_array(result, "key"), get_array(df2, "key"))
+    else:
+        assert not np.shares_memory(get_array(result, "a"), get_array(df1, "a"))
+        assert not np.shares_memory(get_array(result, "b"), get_array(df2, "b"))
+
+    if how == "left":
+        result.iloc[0, 1] = 0
+    else:
+        result.iloc[0, 2] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "a"), get_array(df1, "a"))
+    tm.assert_frame_equal(df1, df1_orig)
+    tm.assert_frame_equal(df2, df2_orig)
+
+
+@pytest.mark.parametrize("copy", [True, None, False])
+def test_merge_copy_keyword(using_copy_on_write, copy):
+    df = DataFrame({"a": [1, 2]})
+    df2 = DataFrame({"b": [3, 4.5]})
+
+    result = df.merge(df2, copy=copy, left_index=True, right_index=True)
+
+    if using_copy_on_write or copy is False:
+        assert np.shares_memory(get_array(df, "a"), get_array(result, "a"))
+        assert np.shares_memory(get_array(df2, "b"), get_array(result, "b"))
+    else:
+        assert not np.shares_memory(get_array(df, "a"), get_array(result, "a"))
+        assert not np.shares_memory(get_array(df2, "b"), get_array(result, "b"))
+
+
+def test_join_on_key(using_copy_on_write):
+    df_index = Index(["a", "b", "c"], name="key")
+
+    df1 = DataFrame({"a": [1, 2, 3]}, index=df_index.copy(deep=True))
+    df2 = DataFrame({"b": [4, 5, 6]}, index=df_index.copy(deep=True))
+
+    df1_orig = df1.copy()
+    df2_orig = df2.copy()
+
+    result = df1.join(df2, on="key")
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(result, "a"), get_array(df1, "a"))
+        assert np.shares_memory(get_array(result, "b"), get_array(df2, "b"))
+        assert np.shares_memory(get_array(result.index), get_array(df1.index))
+        assert not np.shares_memory(get_array(result.index), get_array(df2.index))
+    else:
+        assert not np.shares_memory(get_array(result, "a"), get_array(df1, "a"))
+        assert not np.shares_memory(get_array(result, "b"), get_array(df2, "b"))
+
+    result.iloc[0, 0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "a"), get_array(df1, "a"))
+        assert np.shares_memory(get_array(result, "b"), get_array(df2, "b"))
+
+    result.iloc[0, 1] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "b"), get_array(df2, "b"))
+
+    tm.assert_frame_equal(df1, df1_orig)
+    tm.assert_frame_equal(df2, df2_orig)
+
+
+def test_join_multiple_dataframes_on_key(using_copy_on_write):
+    df_index = Index(["a", "b", "c"], name="key")
+
+    df1 = DataFrame({"a": [1, 2, 3]}, index=df_index.copy(deep=True))
+    dfs_list = [
+        DataFrame({"b": [4, 5, 6]}, index=df_index.copy(deep=True)),
+        DataFrame({"c": [7, 8, 9]}, index=df_index.copy(deep=True)),
+    ]
+
+    df1_orig = df1.copy()
+    dfs_list_orig = [df.copy() for df in dfs_list]
+
+    result = df1.join(dfs_list)
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(result, "a"), get_array(df1, "a"))
+        assert np.shares_memory(get_array(result, "b"), get_array(dfs_list[0], "b"))
+        assert np.shares_memory(get_array(result, "c"), get_array(dfs_list[1], "c"))
+        assert np.shares_memory(get_array(result.index), get_array(df1.index))
+        assert not np.shares_memory(
+            get_array(result.index), get_array(dfs_list[0].index)
+        )
+        assert not np.shares_memory(
+            get_array(result.index), get_array(dfs_list[1].index)
+        )
+    else:
+        assert not np.shares_memory(get_array(result, "a"), get_array(df1, "a"))
+        assert not np.shares_memory(get_array(result, "b"), get_array(dfs_list[0], "b"))
+        assert not np.shares_memory(get_array(result, "c"), get_array(dfs_list[1], "c"))
+
+    result.iloc[0, 0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "a"), get_array(df1, "a"))
+        assert np.shares_memory(get_array(result, "b"), get_array(dfs_list[0], "b"))
+        assert np.shares_memory(get_array(result, "c"), get_array(dfs_list[1], "c"))
+
+    result.iloc[0, 1] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "b"), get_array(dfs_list[0], "b"))
+        assert np.shares_memory(get_array(result, "c"), get_array(dfs_list[1], "c"))
+
+    result.iloc[0, 2] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "c"), get_array(dfs_list[1], "c"))
+
+    tm.assert_frame_equal(df1, df1_orig)
+    for df, df_orig in zip(dfs_list, dfs_list_orig):
+        tm.assert_frame_equal(df, df_orig)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_indexing.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_indexing.py
new file mode 100644
index 0000000000000000000000000000000000000000..479fa148f994a74eb205e3fa19ba957504744a54
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_indexing.py
@@ -0,0 +1,1266 @@
+import numpy as np
+import pytest
+
+from pandas.errors import SettingWithCopyWarning
+
+from pandas.core.dtypes.common import is_float_dtype
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+from pandas.tests.copy_view.util import get_array
+
+
+@pytest.fixture(params=["numpy", "nullable"])
+def backend(request):
+    if request.param == "numpy":
+
+        def make_dataframe(*args, **kwargs):
+            return DataFrame(*args, **kwargs)
+
+        def make_series(*args, **kwargs):
+            return Series(*args, **kwargs)
+
+    elif request.param == "nullable":
+
+        def make_dataframe(*args, **kwargs):
+            df = DataFrame(*args, **kwargs)
+            df_nullable = df.convert_dtypes()
+            # convert_dtypes will try to cast float to int if there is no loss in
+            # precision -> undo that change
+            for col in df.columns:
+                if is_float_dtype(df[col].dtype) and not is_float_dtype(
+                    df_nullable[col].dtype
+                ):
+                    df_nullable[col] = df_nullable[col].astype("Float64")
+            # copy final result to ensure we start with a fully self-owning DataFrame
+            return df_nullable.copy()
+
+        def make_series(*args, **kwargs):
+            ser = Series(*args, **kwargs)
+            return ser.convert_dtypes().copy()
+
+    return request.param, make_dataframe, make_series
+
+
+# -----------------------------------------------------------------------------
+# Indexing operations taking subset + modifying the subset/parent
+
+
+def test_subset_column_selection(backend, using_copy_on_write):
+    # Case: taking a subset of the columns of a DataFrame
+    # + afterwards modifying the subset
+    _, DataFrame, _ = backend
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+
+    subset = df[["a", "c"]]
+
+    if using_copy_on_write:
+        # the subset shares memory ...
+        assert np.shares_memory(get_array(subset, "a"), get_array(df, "a"))
+        # ... but uses CoW when being modified
+        subset.iloc[0, 0] = 0
+    else:
+        assert not np.shares_memory(get_array(subset, "a"), get_array(df, "a"))
+        # INFO this no longer raise warning since pandas 1.4
+        # with pd.option_context("chained_assignment", "warn"):
+        #     with tm.assert_produces_warning(SettingWithCopyWarning):
+        subset.iloc[0, 0] = 0
+
+    assert not np.shares_memory(get_array(subset, "a"), get_array(df, "a"))
+
+    expected = DataFrame({"a": [0, 2, 3], "c": [0.1, 0.2, 0.3]})
+    tm.assert_frame_equal(subset, expected)
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_subset_column_selection_modify_parent(backend, using_copy_on_write):
+    # Case: taking a subset of the columns of a DataFrame
+    # + afterwards modifying the parent
+    _, DataFrame, _ = backend
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+
+    subset = df[["a", "c"]]
+
+    if using_copy_on_write:
+        # the subset shares memory ...
+        assert np.shares_memory(get_array(subset, "a"), get_array(df, "a"))
+        # ... but parent uses CoW parent when it is modified
+    df.iloc[0, 0] = 0
+
+    assert not np.shares_memory(get_array(subset, "a"), get_array(df, "a"))
+    if using_copy_on_write:
+        # different column/block still shares memory
+        assert np.shares_memory(get_array(subset, "c"), get_array(df, "c"))
+
+    expected = DataFrame({"a": [1, 2, 3], "c": [0.1, 0.2, 0.3]})
+    tm.assert_frame_equal(subset, expected)
+
+
+def test_subset_row_slice(backend, using_copy_on_write, warn_copy_on_write):
+    # Case: taking a subset of the rows of a DataFrame using a slice
+    # + afterwards modifying the subset
+    _, DataFrame, _ = backend
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+
+    subset = df[1:3]
+    subset._mgr._verify_integrity()
+
+    assert np.shares_memory(get_array(subset, "a"), get_array(df, "a"))
+
+    if using_copy_on_write:
+        subset.iloc[0, 0] = 0
+        assert not np.shares_memory(get_array(subset, "a"), get_array(df, "a"))
+
+    else:
+        # INFO this no longer raise warning since pandas 1.4
+        # with pd.option_context("chained_assignment", "warn"):
+        #     with tm.assert_produces_warning(SettingWithCopyWarning):
+        with tm.assert_cow_warning(warn_copy_on_write):
+            subset.iloc[0, 0] = 0
+
+    subset._mgr._verify_integrity()
+
+    expected = DataFrame({"a": [0, 3], "b": [5, 6], "c": [0.2, 0.3]}, index=range(1, 3))
+    tm.assert_frame_equal(subset, expected)
+    if using_copy_on_write:
+        # original parent dataframe is not modified (CoW)
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        # original parent dataframe is actually updated
+        df_orig.iloc[1, 0] = 0
+        tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize(
+    "dtype", ["int64", "float64"], ids=["single-block", "mixed-block"]
+)
+def test_subset_column_slice(
+    backend, using_copy_on_write, warn_copy_on_write, using_array_manager, dtype
+):
+    # Case: taking a subset of the columns of a DataFrame using a slice
+    # + afterwards modifying the subset
+    dtype_backend, DataFrame, _ = backend
+    single_block = (
+        dtype == "int64" and dtype_backend == "numpy"
+    ) and not using_array_manager
+    df = DataFrame(
+        {"a": [1, 2, 3], "b": [4, 5, 6], "c": np.array([7, 8, 9], dtype=dtype)}
+    )
+    df_orig = df.copy()
+
+    subset = df.iloc[:, 1:]
+    subset._mgr._verify_integrity()
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(subset, "b"), get_array(df, "b"))
+
+        subset.iloc[0, 0] = 0
+        assert not np.shares_memory(get_array(subset, "b"), get_array(df, "b"))
+    elif warn_copy_on_write:
+        with tm.assert_cow_warning(single_block):
+            subset.iloc[0, 0] = 0
+    else:
+        # we only get a warning in case of a single block
+        warn = SettingWithCopyWarning if single_block else None
+        with pd.option_context("chained_assignment", "warn"):
+            with tm.assert_produces_warning(warn):
+                subset.iloc[0, 0] = 0
+
+    expected = DataFrame({"b": [0, 5, 6], "c": np.array([7, 8, 9], dtype=dtype)})
+    tm.assert_frame_equal(subset, expected)
+    # original parent dataframe is not modified (also not for BlockManager case,
+    # except for single block)
+    if not using_copy_on_write and (using_array_manager or single_block):
+        df_orig.iloc[0, 1] = 0
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize(
+    "dtype", ["int64", "float64"], ids=["single-block", "mixed-block"]
+)
+@pytest.mark.parametrize(
+    "row_indexer",
+    [slice(1, 2), np.array([False, True, True]), np.array([1, 2])],
+    ids=["slice", "mask", "array"],
+)
+@pytest.mark.parametrize(
+    "column_indexer",
+    [slice("b", "c"), np.array([False, True, True]), ["b", "c"]],
+    ids=["slice", "mask", "array"],
+)
+def test_subset_loc_rows_columns(
+    backend,
+    dtype,
+    row_indexer,
+    column_indexer,
+    using_array_manager,
+    using_copy_on_write,
+    warn_copy_on_write,
+):
+    # Case: taking a subset of the rows+columns of a DataFrame using .loc
+    # + afterwards modifying the subset
+    # Generic test for several combinations of row/column indexers, not all
+    # of those could actually return a view / need CoW (so this test is not
+    # checking memory sharing, only ensuring subsequent mutation doesn't
+    # affect the parent dataframe)
+    dtype_backend, DataFrame, _ = backend
+    df = DataFrame(
+        {"a": [1, 2, 3], "b": [4, 5, 6], "c": np.array([7, 8, 9], dtype=dtype)}
+    )
+    df_orig = df.copy()
+
+    subset = df.loc[row_indexer, column_indexer]
+
+    # a few corner cases _do_ actually modify the parent (with both row and column
+    # slice, and in case of ArrayManager or BlockManager with single block)
+    mutate_parent = (
+        isinstance(row_indexer, slice)
+        and isinstance(column_indexer, slice)
+        and (
+            using_array_manager
+            or (
+                dtype == "int64"
+                and dtype_backend == "numpy"
+                and not using_copy_on_write
+            )
+        )
+    )
+
+    # modifying the subset never modifies the parent
+    with tm.assert_cow_warning(warn_copy_on_write and mutate_parent):
+        subset.iloc[0, 0] = 0
+
+    expected = DataFrame(
+        {"b": [0, 6], "c": np.array([8, 9], dtype=dtype)}, index=range(1, 3)
+    )
+    tm.assert_frame_equal(subset, expected)
+    if mutate_parent:
+        df_orig.iloc[1, 1] = 0
+    tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize(
+    "dtype", ["int64", "float64"], ids=["single-block", "mixed-block"]
+)
+@pytest.mark.parametrize(
+    "row_indexer",
+    [slice(1, 3), np.array([False, True, True]), np.array([1, 2])],
+    ids=["slice", "mask", "array"],
+)
+@pytest.mark.parametrize(
+    "column_indexer",
+    [slice(1, 3), np.array([False, True, True]), [1, 2]],
+    ids=["slice", "mask", "array"],
+)
+def test_subset_iloc_rows_columns(
+    backend,
+    dtype,
+    row_indexer,
+    column_indexer,
+    using_array_manager,
+    using_copy_on_write,
+    warn_copy_on_write,
+):
+    # Case: taking a subset of the rows+columns of a DataFrame using .iloc
+    # + afterwards modifying the subset
+    # Generic test for several combinations of row/column indexers, not all
+    # of those could actually return a view / need CoW (so this test is not
+    # checking memory sharing, only ensuring subsequent mutation doesn't
+    # affect the parent dataframe)
+    dtype_backend, DataFrame, _ = backend
+    df = DataFrame(
+        {"a": [1, 2, 3], "b": [4, 5, 6], "c": np.array([7, 8, 9], dtype=dtype)}
+    )
+    df_orig = df.copy()
+
+    subset = df.iloc[row_indexer, column_indexer]
+
+    # a few corner cases _do_ actually modify the parent (with both row and column
+    # slice, and in case of ArrayManager or BlockManager with single block)
+    mutate_parent = (
+        isinstance(row_indexer, slice)
+        and isinstance(column_indexer, slice)
+        and (
+            using_array_manager
+            or (
+                dtype == "int64"
+                and dtype_backend == "numpy"
+                and not using_copy_on_write
+            )
+        )
+    )
+
+    # modifying the subset never modifies the parent
+    with tm.assert_cow_warning(warn_copy_on_write and mutate_parent):
+        subset.iloc[0, 0] = 0
+
+    expected = DataFrame(
+        {"b": [0, 6], "c": np.array([8, 9], dtype=dtype)}, index=range(1, 3)
+    )
+    tm.assert_frame_equal(subset, expected)
+    if mutate_parent:
+        df_orig.iloc[1, 1] = 0
+    tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize(
+    "indexer",
+    [slice(0, 2), np.array([True, True, False]), np.array([0, 1])],
+    ids=["slice", "mask", "array"],
+)
+def test_subset_set_with_row_indexer(
+    backend, indexer_si, indexer, using_copy_on_write, warn_copy_on_write
+):
+    # Case: setting values with a row indexer on a viewing subset
+    # subset[indexer] = value and subset.iloc[indexer] = value
+    _, DataFrame, _ = backend
+    df = DataFrame({"a": [1, 2, 3, 4], "b": [4, 5, 6, 7], "c": [0.1, 0.2, 0.3, 0.4]})
+    df_orig = df.copy()
+    subset = df[1:4]
+
+    if (
+        indexer_si is tm.setitem
+        and isinstance(indexer, np.ndarray)
+        and indexer.dtype == "int"
+    ):
+        pytest.skip("setitem with labels selects on columns")
+
+    if using_copy_on_write:
+        indexer_si(subset)[indexer] = 0
+    elif warn_copy_on_write:
+        with tm.assert_cow_warning():
+            indexer_si(subset)[indexer] = 0
+    else:
+        # INFO iloc no longer raises warning since pandas 1.4
+        warn = SettingWithCopyWarning if indexer_si is tm.setitem else None
+        with pd.option_context("chained_assignment", "warn"):
+            with tm.assert_produces_warning(warn):
+                indexer_si(subset)[indexer] = 0
+
+    expected = DataFrame(
+        {"a": [0, 0, 4], "b": [0, 0, 7], "c": [0.0, 0.0, 0.4]}, index=range(1, 4)
+    )
+    tm.assert_frame_equal(subset, expected)
+    if using_copy_on_write:
+        # original parent dataframe is not modified (CoW)
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        # original parent dataframe is actually updated
+        df_orig[1:3] = 0
+        tm.assert_frame_equal(df, df_orig)
+
+
+def test_subset_set_with_mask(backend, using_copy_on_write, warn_copy_on_write):
+    # Case: setting values with a mask on a viewing subset: subset[mask] = value
+    _, DataFrame, _ = backend
+    df = DataFrame({"a": [1, 2, 3, 4], "b": [4, 5, 6, 7], "c": [0.1, 0.2, 0.3, 0.4]})
+    df_orig = df.copy()
+    subset = df[1:4]
+
+    mask = subset > 3
+
+    if using_copy_on_write:
+        subset[mask] = 0
+    elif warn_copy_on_write:
+        with tm.assert_cow_warning():
+            subset[mask] = 0
+    else:
+        with pd.option_context("chained_assignment", "warn"):
+            with tm.assert_produces_warning(SettingWithCopyWarning):
+                subset[mask] = 0
+
+    expected = DataFrame(
+        {"a": [2, 3, 0], "b": [0, 0, 0], "c": [0.20, 0.3, 0.4]}, index=range(1, 4)
+    )
+    tm.assert_frame_equal(subset, expected)
+    if using_copy_on_write:
+        # original parent dataframe is not modified (CoW)
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        # original parent dataframe is actually updated
+        df_orig.loc[3, "a"] = 0
+        df_orig.loc[1:3, "b"] = 0
+        tm.assert_frame_equal(df, df_orig)
+
+
+def test_subset_set_column(backend, using_copy_on_write, warn_copy_on_write):
+    # Case: setting a single column on a viewing subset -> subset[col] = value
+    dtype_backend, DataFrame, _ = backend
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+    subset = df[1:3]
+
+    if dtype_backend == "numpy":
+        arr = np.array([10, 11], dtype="int64")
+    else:
+        arr = pd.array([10, 11], dtype="Int64")
+
+    if using_copy_on_write or warn_copy_on_write:
+        subset["a"] = arr
+    else:
+        with pd.option_context("chained_assignment", "warn"):
+            with tm.assert_produces_warning(SettingWithCopyWarning):
+                subset["a"] = arr
+
+    subset._mgr._verify_integrity()
+    expected = DataFrame(
+        {"a": [10, 11], "b": [5, 6], "c": [0.2, 0.3]}, index=range(1, 3)
+    )
+    tm.assert_frame_equal(subset, expected)
+    tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize(
+    "dtype", ["int64", "float64"], ids=["single-block", "mixed-block"]
+)
+def test_subset_set_column_with_loc(
+    backend, using_copy_on_write, warn_copy_on_write, using_array_manager, dtype
+):
+    # Case: setting a single column with loc on a viewing subset
+    # -> subset.loc[:, col] = value
+    _, DataFrame, _ = backend
+    df = DataFrame(
+        {"a": [1, 2, 3], "b": [4, 5, 6], "c": np.array([7, 8, 9], dtype=dtype)}
+    )
+    df_orig = df.copy()
+    subset = df[1:3]
+
+    if using_copy_on_write:
+        subset.loc[:, "a"] = np.array([10, 11], dtype="int64")
+    elif warn_copy_on_write:
+        with tm.assert_cow_warning():
+            subset.loc[:, "a"] = np.array([10, 11], dtype="int64")
+    else:
+        with pd.option_context("chained_assignment", "warn"):
+            with tm.assert_produces_warning(
+                None,
+                raise_on_extra_warnings=not using_array_manager,
+            ):
+                subset.loc[:, "a"] = np.array([10, 11], dtype="int64")
+
+    subset._mgr._verify_integrity()
+    expected = DataFrame(
+        {"a": [10, 11], "b": [5, 6], "c": np.array([8, 9], dtype=dtype)},
+        index=range(1, 3),
+    )
+    tm.assert_frame_equal(subset, expected)
+    if using_copy_on_write:
+        # original parent dataframe is not modified (CoW)
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        # original parent dataframe is actually updated
+        df_orig.loc[1:3, "a"] = np.array([10, 11], dtype="int64")
+        tm.assert_frame_equal(df, df_orig)
+
+
+def test_subset_set_column_with_loc2(
+    backend, using_copy_on_write, warn_copy_on_write, using_array_manager
+):
+    # Case: setting a single column with loc on a viewing subset
+    # -> subset.loc[:, col] = value
+    # separate test for case of DataFrame of a single column -> takes a separate
+    # code path
+    _, DataFrame, _ = backend
+    df = DataFrame({"a": [1, 2, 3]})
+    df_orig = df.copy()
+    subset = df[1:3]
+
+    if using_copy_on_write:
+        subset.loc[:, "a"] = 0
+    elif warn_copy_on_write:
+        with tm.assert_cow_warning():
+            subset.loc[:, "a"] = 0
+    else:
+        with pd.option_context("chained_assignment", "warn"):
+            with tm.assert_produces_warning(
+                None,
+                raise_on_extra_warnings=not using_array_manager,
+            ):
+                subset.loc[:, "a"] = 0
+
+    subset._mgr._verify_integrity()
+    expected = DataFrame({"a": [0, 0]}, index=range(1, 3))
+    tm.assert_frame_equal(subset, expected)
+    if using_copy_on_write:
+        # original parent dataframe is not modified (CoW)
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        # original parent dataframe is actually updated
+        df_orig.loc[1:3, "a"] = 0
+        tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize(
+    "dtype", ["int64", "float64"], ids=["single-block", "mixed-block"]
+)
+def test_subset_set_columns(backend, using_copy_on_write, warn_copy_on_write, dtype):
+    # Case: setting multiple columns on a viewing subset
+    # -> subset[[col1, col2]] = value
+    dtype_backend, DataFrame, _ = backend
+    df = DataFrame(
+        {"a": [1, 2, 3], "b": [4, 5, 6], "c": np.array([7, 8, 9], dtype=dtype)}
+    )
+    df_orig = df.copy()
+    subset = df[1:3]
+
+    if using_copy_on_write or warn_copy_on_write:
+        subset[["a", "c"]] = 0
+    else:
+        with pd.option_context("chained_assignment", "warn"):
+            with tm.assert_produces_warning(SettingWithCopyWarning):
+                subset[["a", "c"]] = 0
+
+    subset._mgr._verify_integrity()
+    if using_copy_on_write:
+        # first and third column should certainly have no references anymore
+        assert all(subset._mgr._has_no_reference(i) for i in [0, 2])
+    expected = DataFrame({"a": [0, 0], "b": [5, 6], "c": [0, 0]}, index=range(1, 3))
+    if dtype_backend == "nullable":
+        # there is not yet a global option, so overriding a column by setting a scalar
+        # defaults to numpy dtype even if original column was nullable
+        expected["a"] = expected["a"].astype("int64")
+        expected["c"] = expected["c"].astype("int64")
+
+    tm.assert_frame_equal(subset, expected)
+    tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize(
+    "indexer",
+    [slice("a", "b"), np.array([True, True, False]), ["a", "b"]],
+    ids=["slice", "mask", "array"],
+)
+def test_subset_set_with_column_indexer(
+    backend, indexer, using_copy_on_write, warn_copy_on_write
+):
+    # Case: setting multiple columns with a column indexer on a viewing subset
+    # -> subset.loc[:, [col1, col2]] = value
+    _, DataFrame, _ = backend
+    df = DataFrame({"a": [1, 2, 3], "b": [0.1, 0.2, 0.3], "c": [4, 5, 6]})
+    df_orig = df.copy()
+    subset = df[1:3]
+
+    if using_copy_on_write:
+        subset.loc[:, indexer] = 0
+    elif warn_copy_on_write:
+        with tm.assert_cow_warning():
+            subset.loc[:, indexer] = 0
+    else:
+        with pd.option_context("chained_assignment", "warn"):
+            # As of 2.0, this setitem attempts (successfully) to set values
+            #  inplace, so the assignment is not chained.
+            subset.loc[:, indexer] = 0
+
+    subset._mgr._verify_integrity()
+    expected = DataFrame({"a": [0, 0], "b": [0.0, 0.0], "c": [5, 6]}, index=range(1, 3))
+    tm.assert_frame_equal(subset, expected)
+    if using_copy_on_write:
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        # pre-2.0, in the mixed case with BlockManager, only column "a"
+        #  would be mutated in the parent frame. this changed with the
+        #  enforcement of GH#45333
+        df_orig.loc[1:2, ["a", "b"]] = 0
+        tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize(
+    "method",
+    [
+        lambda df: df[["a", "b"]][0:2],
+        lambda df: df[0:2][["a", "b"]],
+        lambda df: df[["a", "b"]].iloc[0:2],
+        lambda df: df[["a", "b"]].loc[0:1],
+        lambda df: df[0:2].iloc[:, 0:2],
+        lambda df: df[0:2].loc[:, "a":"b"],  # type: ignore[misc]
+    ],
+    ids=[
+        "row-getitem-slice",
+        "column-getitem",
+        "row-iloc-slice",
+        "row-loc-slice",
+        "column-iloc-slice",
+        "column-loc-slice",
+    ],
+)
+@pytest.mark.parametrize(
+    "dtype", ["int64", "float64"], ids=["single-block", "mixed-block"]
+)
+def test_subset_chained_getitem(
+    request,
+    backend,
+    method,
+    dtype,
+    using_copy_on_write,
+    using_array_manager,
+    warn_copy_on_write,
+):
+    # Case: creating a subset using multiple, chained getitem calls using views
+    # still needs to guarantee proper CoW behaviour
+    _, DataFrame, _ = backend
+    df = DataFrame(
+        {"a": [1, 2, 3], "b": [4, 5, 6], "c": np.array([7, 8, 9], dtype=dtype)}
+    )
+    df_orig = df.copy()
+
+    # when not using CoW, it depends on whether we have a single block or not
+    # and whether we are slicing the columns -> in that case we have a view
+    test_callspec = request.node.callspec.id
+    if not using_array_manager:
+        subset_is_view = test_callspec in (
+            "numpy-single-block-column-iloc-slice",
+            "numpy-single-block-column-loc-slice",
+        )
+    else:
+        # with ArrayManager, it doesn't matter whether we have
+        # single vs mixed block or numpy vs nullable dtypes
+        subset_is_view = test_callspec.endswith(
+            ("column-iloc-slice", "column-loc-slice")
+        )
+
+    # modify subset -> don't modify parent
+    subset = method(df)
+
+    with tm.assert_cow_warning(warn_copy_on_write and subset_is_view):
+        subset.iloc[0, 0] = 0
+    if using_copy_on_write or (not subset_is_view):
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        assert df.iloc[0, 0] == 0
+
+    # modify parent -> don't modify subset
+    subset = method(df)
+    with tm.assert_cow_warning(warn_copy_on_write and subset_is_view):
+        df.iloc[0, 0] = 0
+    expected = DataFrame({"a": [1, 2], "b": [4, 5]})
+    if using_copy_on_write or not subset_is_view:
+        tm.assert_frame_equal(subset, expected)
+    else:
+        assert subset.iloc[0, 0] == 0
+
+
+@pytest.mark.parametrize(
+    "dtype", ["int64", "float64"], ids=["single-block", "mixed-block"]
+)
+def test_subset_chained_getitem_column(
+    backend, dtype, using_copy_on_write, warn_copy_on_write
+):
+    # Case: creating a subset using multiple, chained getitem calls using views
+    # still needs to guarantee proper CoW behaviour
+    dtype_backend, DataFrame, Series = backend
+    df = DataFrame(
+        {"a": [1, 2, 3], "b": [4, 5, 6], "c": np.array([7, 8, 9], dtype=dtype)}
+    )
+    df_orig = df.copy()
+
+    # modify subset -> don't modify parent
+    subset = df[:]["a"][0:2]
+    df._clear_item_cache()
+    with tm.assert_cow_warning(warn_copy_on_write):
+        subset.iloc[0] = 0
+    if using_copy_on_write:
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        assert df.iloc[0, 0] == 0
+
+    # modify parent -> don't modify subset
+    subset = df[:]["a"][0:2]
+    df._clear_item_cache()
+    with tm.assert_cow_warning(warn_copy_on_write):
+        df.iloc[0, 0] = 0
+    expected = Series([1, 2], name="a")
+    if using_copy_on_write:
+        tm.assert_series_equal(subset, expected)
+    else:
+        assert subset.iloc[0] == 0
+
+
+@pytest.mark.parametrize(
+    "method",
+    [
+        lambda s: s["a":"c"]["a":"b"],  # type: ignore[misc]
+        lambda s: s.iloc[0:3].iloc[0:2],
+        lambda s: s.loc["a":"c"].loc["a":"b"],  # type: ignore[misc]
+        lambda s: s.loc["a":"c"]  # type: ignore[misc]
+        .iloc[0:3]
+        .iloc[0:2]
+        .loc["a":"b"]  # type: ignore[misc]
+        .iloc[0:1],
+    ],
+    ids=["getitem", "iloc", "loc", "long-chain"],
+)
+def test_subset_chained_getitem_series(
+    backend, method, using_copy_on_write, warn_copy_on_write
+):
+    # Case: creating a subset using multiple, chained getitem calls using views
+    # still needs to guarantee proper CoW behaviour
+    _, _, Series = backend
+    s = Series([1, 2, 3], index=["a", "b", "c"])
+    s_orig = s.copy()
+
+    # modify subset -> don't modify parent
+    subset = method(s)
+    with tm.assert_cow_warning(warn_copy_on_write):
+        subset.iloc[0] = 0
+    if using_copy_on_write:
+        tm.assert_series_equal(s, s_orig)
+    else:
+        assert s.iloc[0] == 0
+
+    # modify parent -> don't modify subset
+    subset = s.iloc[0:3].iloc[0:2]
+    with tm.assert_cow_warning(warn_copy_on_write):
+        s.iloc[0] = 0
+    expected = Series([1, 2], index=["a", "b"])
+    if using_copy_on_write:
+        tm.assert_series_equal(subset, expected)
+    else:
+        assert subset.iloc[0] == 0
+
+
+def test_subset_chained_single_block_row(
+    using_copy_on_write, using_array_manager, warn_copy_on_write
+):
+    # not parametrizing this for dtype backend, since this explicitly tests single block
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [7, 8, 9]})
+    df_orig = df.copy()
+
+    # modify subset -> don't modify parent
+    subset = df[:].iloc[0].iloc[0:2]
+    with tm.assert_cow_warning(warn_copy_on_write):
+        subset.iloc[0] = 0
+    if using_copy_on_write or using_array_manager:
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        assert df.iloc[0, 0] == 0
+
+    # modify parent -> don't modify subset
+    subset = df[:].iloc[0].iloc[0:2]
+    with tm.assert_cow_warning(warn_copy_on_write):
+        df.iloc[0, 0] = 0
+    expected = Series([1, 4], index=["a", "b"], name=0)
+    if using_copy_on_write or using_array_manager:
+        tm.assert_series_equal(subset, expected)
+    else:
+        assert subset.iloc[0] == 0
+
+
+@pytest.mark.parametrize(
+    "method",
+    [
+        lambda df: df[:],
+        lambda df: df.loc[:, :],
+        lambda df: df.loc[:],
+        lambda df: df.iloc[:, :],
+        lambda df: df.iloc[:],
+    ],
+    ids=["getitem", "loc", "loc-rows", "iloc", "iloc-rows"],
+)
+def test_null_slice(backend, method, using_copy_on_write, warn_copy_on_write):
+    # Case: also all variants of indexing with a null slice (:) should return
+    # new objects to ensure we correctly use CoW for the results
+    dtype_backend, DataFrame, _ = backend
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [7, 8, 9]})
+    df_orig = df.copy()
+
+    df2 = method(df)
+
+    # we always return new objects (shallow copy), regardless of CoW or not
+    assert df2 is not df
+
+    # and those trigger CoW when mutated
+    with tm.assert_cow_warning(warn_copy_on_write):
+        df2.iloc[0, 0] = 0
+    if using_copy_on_write:
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        assert df.iloc[0, 0] == 0
+
+
+@pytest.mark.parametrize(
+    "method",
+    [
+        lambda s: s[:],
+        lambda s: s.loc[:],
+        lambda s: s.iloc[:],
+    ],
+    ids=["getitem", "loc", "iloc"],
+)
+def test_null_slice_series(backend, method, using_copy_on_write, warn_copy_on_write):
+    _, _, Series = backend
+    s = Series([1, 2, 3], index=["a", "b", "c"])
+    s_orig = s.copy()
+
+    s2 = method(s)
+
+    # we always return new objects, regardless of CoW or not
+    assert s2 is not s
+
+    # and those trigger CoW when mutated
+    with tm.assert_cow_warning(warn_copy_on_write):
+        s2.iloc[0] = 0
+    if using_copy_on_write:
+        tm.assert_series_equal(s, s_orig)
+    else:
+        assert s.iloc[0] == 0
+
+
+# TODO add more tests modifying the parent
+
+
+# -----------------------------------------------------------------------------
+# Series -- Indexing operations taking subset + modifying the subset/parent
+
+
+def test_series_getitem_slice(backend, using_copy_on_write, warn_copy_on_write):
+    # Case: taking a slice of a Series + afterwards modifying the subset
+    _, _, Series = backend
+    s = Series([1, 2, 3], index=["a", "b", "c"])
+    s_orig = s.copy()
+
+    subset = s[:]
+    assert np.shares_memory(get_array(subset), get_array(s))
+
+    with tm.assert_cow_warning(warn_copy_on_write):
+        subset.iloc[0] = 0
+
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(subset), get_array(s))
+
+    expected = Series([0, 2, 3], index=["a", "b", "c"])
+    tm.assert_series_equal(subset, expected)
+
+    if using_copy_on_write:
+        # original parent series is not modified (CoW)
+        tm.assert_series_equal(s, s_orig)
+    else:
+        # original parent series is actually updated
+        assert s.iloc[0] == 0
+
+
+def test_series_getitem_ellipsis(using_copy_on_write, warn_copy_on_write):
+    # Case: taking a view of a Series using Ellipsis + afterwards modifying the subset
+    s = Series([1, 2, 3])
+    s_orig = s.copy()
+
+    subset = s[...]
+    assert np.shares_memory(get_array(subset), get_array(s))
+
+    with tm.assert_cow_warning(warn_copy_on_write):
+        subset.iloc[0] = 0
+
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(subset), get_array(s))
+
+    expected = Series([0, 2, 3])
+    tm.assert_series_equal(subset, expected)
+
+    if using_copy_on_write:
+        # original parent series is not modified (CoW)
+        tm.assert_series_equal(s, s_orig)
+    else:
+        # original parent series is actually updated
+        assert s.iloc[0] == 0
+
+
+@pytest.mark.parametrize(
+    "indexer",
+    [slice(0, 2), np.array([True, True, False]), np.array([0, 1])],
+    ids=["slice", "mask", "array"],
+)
+def test_series_subset_set_with_indexer(
+    backend, indexer_si, indexer, using_copy_on_write, warn_copy_on_write
+):
+    # Case: setting values in a viewing Series with an indexer
+    _, _, Series = backend
+    s = Series([1, 2, 3], index=["a", "b", "c"])
+    s_orig = s.copy()
+    subset = s[:]
+
+    warn = None
+    msg = "Series.__setitem__ treating keys as positions is deprecated"
+    if (
+        indexer_si is tm.setitem
+        and isinstance(indexer, np.ndarray)
+        and indexer.dtype.kind == "i"
+    ):
+        warn = FutureWarning
+    if warn_copy_on_write:
+        with tm.assert_cow_warning(raise_on_extra_warnings=warn is not None):
+            indexer_si(subset)[indexer] = 0
+    else:
+        with tm.assert_produces_warning(warn, match=msg):
+            indexer_si(subset)[indexer] = 0
+    expected = Series([0, 0, 3], index=["a", "b", "c"])
+    tm.assert_series_equal(subset, expected)
+
+    if using_copy_on_write:
+        tm.assert_series_equal(s, s_orig)
+    else:
+        tm.assert_series_equal(s, expected)
+
+
+# -----------------------------------------------------------------------------
+# del operator
+
+
+def test_del_frame(backend, using_copy_on_write, warn_copy_on_write):
+    # Case: deleting a column with `del` on a viewing child dataframe should
+    # not modify parent + update the references
+    dtype_backend, DataFrame, _ = backend
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+    df2 = df[:]
+
+    assert np.shares_memory(get_array(df, "a"), get_array(df2, "a"))
+
+    del df2["b"]
+
+    assert np.shares_memory(get_array(df, "a"), get_array(df2, "a"))
+    tm.assert_frame_equal(df, df_orig)
+    tm.assert_frame_equal(df2, df_orig[["a", "c"]])
+    df2._mgr._verify_integrity()
+
+    with tm.assert_cow_warning(warn_copy_on_write and dtype_backend == "numpy"):
+        df.loc[0, "b"] = 200
+    assert np.shares_memory(get_array(df, "a"), get_array(df2, "a"))
+    df_orig = df.copy()
+
+    with tm.assert_cow_warning(warn_copy_on_write):
+        df2.loc[0, "a"] = 100
+    if using_copy_on_write:
+        # modifying child after deleting a column still doesn't update parent
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        assert df.loc[0, "a"] == 100
+
+
+def test_del_series(backend):
+    _, _, Series = backend
+    s = Series([1, 2, 3], index=["a", "b", "c"])
+    s_orig = s.copy()
+    s2 = s[:]
+
+    assert np.shares_memory(get_array(s), get_array(s2))
+
+    del s2["a"]
+
+    assert not np.shares_memory(get_array(s), get_array(s2))
+    tm.assert_series_equal(s, s_orig)
+    tm.assert_series_equal(s2, s_orig[["b", "c"]])
+
+    # modifying s2 doesn't need copy on write (due to `del`, s2 is backed by new array)
+    values = s2.values
+    s2.loc["b"] = 100
+    assert values[0] == 100
+
+
+# -----------------------------------------------------------------------------
+# Accessing column as Series
+
+
+def test_column_as_series(
+    backend, using_copy_on_write, warn_copy_on_write, using_array_manager
+):
+    # Case: selecting a single column now also uses Copy-on-Write
+    dtype_backend, DataFrame, Series = backend
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+
+    s = df["a"]
+
+    assert np.shares_memory(get_array(s, "a"), get_array(df, "a"))
+
+    if using_copy_on_write or using_array_manager:
+        s[0] = 0
+    else:
+        if warn_copy_on_write:
+            with tm.assert_cow_warning():
+                s[0] = 0
+        else:
+            warn = SettingWithCopyWarning if dtype_backend == "numpy" else None
+            with pd.option_context("chained_assignment", "warn"):
+                with tm.assert_produces_warning(warn):
+                    s[0] = 0
+
+    expected = Series([0, 2, 3], name="a")
+    tm.assert_series_equal(s, expected)
+    if using_copy_on_write:
+        # assert not np.shares_memory(s.values, get_array(df, "a"))
+        tm.assert_frame_equal(df, df_orig)
+        # ensure cached series on getitem is not the changed series
+        tm.assert_series_equal(df["a"], df_orig["a"])
+    else:
+        df_orig.iloc[0, 0] = 0
+        tm.assert_frame_equal(df, df_orig)
+
+
+def test_column_as_series_set_with_upcast(
+    backend, using_copy_on_write, using_array_manager, warn_copy_on_write
+):
+    # Case: selecting a single column now also uses Copy-on-Write -> when
+    # setting a value causes an upcast, we don't need to update the parent
+    # DataFrame through the cache mechanism
+    dtype_backend, DataFrame, Series = backend
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+
+    s = df["a"]
+    if dtype_backend == "nullable":
+        with tm.assert_cow_warning(warn_copy_on_write):
+            with pytest.raises(TypeError, match="Invalid value"):
+                s[0] = "foo"
+        expected = Series([1, 2, 3], name="a")
+    elif using_copy_on_write or warn_copy_on_write or using_array_manager:
+        # TODO(CoW-warn) assert the FutureWarning for CoW is also raised
+        with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
+            s[0] = "foo"
+        expected = Series(["foo", 2, 3], dtype=object, name="a")
+    else:
+        with pd.option_context("chained_assignment", "warn"):
+            msg = "|".join(
+                [
+                    "A value is trying to be set on a copy of a slice from a DataFrame",
+                    "Setting an item of incompatible dtype is deprecated",
+                ]
+            )
+            with tm.assert_produces_warning(
+                (SettingWithCopyWarning, FutureWarning), match=msg
+            ):
+                s[0] = "foo"
+        expected = Series(["foo", 2, 3], dtype=object, name="a")
+
+    tm.assert_series_equal(s, expected)
+    if using_copy_on_write:
+        tm.assert_frame_equal(df, df_orig)
+        # ensure cached series on getitem is not the changed series
+        tm.assert_series_equal(df["a"], df_orig["a"])
+    else:
+        df_orig["a"] = expected
+        tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize(
+    "method",
+    [
+        lambda df: df["a"],
+        lambda df: df.loc[:, "a"],
+        lambda df: df.iloc[:, 0],
+    ],
+    ids=["getitem", "loc", "iloc"],
+)
+def test_column_as_series_no_item_cache(
+    request,
+    backend,
+    method,
+    using_copy_on_write,
+    warn_copy_on_write,
+    using_array_manager,
+):
+    # Case: selecting a single column (which now also uses Copy-on-Write to protect
+    # the view) should always give a new object (i.e. not make use of a cache)
+    dtype_backend, DataFrame, _ = backend
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+
+    s1 = method(df)
+    s2 = method(df)
+
+    is_iloc = "iloc" in request.node.name
+    if using_copy_on_write or warn_copy_on_write or is_iloc:
+        assert s1 is not s2
+    else:
+        assert s1 is s2
+
+    if using_copy_on_write or using_array_manager:
+        s1.iloc[0] = 0
+    elif warn_copy_on_write:
+        with tm.assert_cow_warning():
+            s1.iloc[0] = 0
+    else:
+        warn = SettingWithCopyWarning if dtype_backend == "numpy" else None
+        with pd.option_context("chained_assignment", "warn"):
+            with tm.assert_produces_warning(warn):
+                s1.iloc[0] = 0
+
+    if using_copy_on_write:
+        tm.assert_series_equal(s2, df_orig["a"])
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        assert s2.iloc[0] == 0
+
+
+# TODO add tests for other indexing methods on the Series
+
+
+def test_dataframe_add_column_from_series(backend, using_copy_on_write):
+    # Case: adding a new column to a DataFrame from an existing column/series
+    # -> delays copy under CoW
+    _, DataFrame, Series = backend
+    df = DataFrame({"a": [1, 2, 3], "b": [0.1, 0.2, 0.3]})
+
+    s = Series([10, 11, 12])
+    df["new"] = s
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df, "new"), get_array(s))
+    else:
+        assert not np.shares_memory(get_array(df, "new"), get_array(s))
+
+    # editing series -> doesn't modify column in frame
+    s[0] = 0
+    expected = DataFrame({"a": [1, 2, 3], "b": [0.1, 0.2, 0.3], "new": [10, 11, 12]})
+    tm.assert_frame_equal(df, expected)
+
+
+@pytest.mark.parametrize("val", [100, "a"])
+@pytest.mark.parametrize(
+    "indexer_func, indexer",
+    [
+        (tm.loc, (0, "a")),
+        (tm.iloc, (0, 0)),
+        (tm.loc, ([0], "a")),
+        (tm.iloc, ([0], 0)),
+        (tm.loc, (slice(None), "a")),
+        (tm.iloc, (slice(None), 0)),
+    ],
+)
+@pytest.mark.parametrize(
+    "col", [[0.1, 0.2, 0.3], [7, 8, 9]], ids=["mixed-block", "single-block"]
+)
+def test_set_value_copy_only_necessary_column(
+    using_copy_on_write, warn_copy_on_write, indexer_func, indexer, val, col
+):
+    # When setting inplace, only copy column that is modified instead of the whole
+    # block (by splitting the block)
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": col})
+    df_orig = df.copy()
+    view = df[:]
+
+    if val == "a" and not warn_copy_on_write:
+        with tm.assert_produces_warning(
+            FutureWarning, match="Setting an item of incompatible dtype is deprecated"
+        ):
+            indexer_func(df)[indexer] = val
+    if val == "a" and warn_copy_on_write:
+        with tm.assert_produces_warning(
+            FutureWarning, match="incompatible dtype|Setting a value on a view"
+        ):
+            indexer_func(df)[indexer] = val
+    else:
+        with tm.assert_cow_warning(warn_copy_on_write and val == 100):
+            indexer_func(df)[indexer] = val
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df, "b"), get_array(view, "b"))
+        assert not np.shares_memory(get_array(df, "a"), get_array(view, "a"))
+        tm.assert_frame_equal(view, df_orig)
+    else:
+        assert np.shares_memory(get_array(df, "c"), get_array(view, "c"))
+        if val == "a":
+            assert not np.shares_memory(get_array(df, "a"), get_array(view, "a"))
+        else:
+            assert np.shares_memory(get_array(df, "a"), get_array(view, "a"))
+
+
+def test_series_midx_slice(using_copy_on_write, warn_copy_on_write):
+    ser = Series([1, 2, 3], index=pd.MultiIndex.from_arrays([[1, 1, 2], [3, 4, 5]]))
+    ser_orig = ser.copy()
+    result = ser[1]
+    assert np.shares_memory(get_array(ser), get_array(result))
+    with tm.assert_cow_warning(warn_copy_on_write):
+        result.iloc[0] = 100
+    if using_copy_on_write:
+        tm.assert_series_equal(ser, ser_orig)
+    else:
+        expected = Series(
+            [100, 2, 3], index=pd.MultiIndex.from_arrays([[1, 1, 2], [3, 4, 5]])
+        )
+        tm.assert_series_equal(ser, expected)
+
+
+def test_getitem_midx_slice(
+    using_copy_on_write, warn_copy_on_write, using_array_manager
+):
+    df = DataFrame({("a", "x"): [1, 2], ("a", "y"): 1, ("b", "x"): 2})
+    df_orig = df.copy()
+    new_df = df[("a",)]
+
+    if using_copy_on_write:
+        assert not new_df._mgr._has_no_reference(0)
+
+    if not using_array_manager:
+        assert np.shares_memory(get_array(df, ("a", "x")), get_array(new_df, "x"))
+    if using_copy_on_write:
+        new_df.iloc[0, 0] = 100
+        tm.assert_frame_equal(df_orig, df)
+    else:
+        if warn_copy_on_write:
+            with tm.assert_cow_warning():
+                new_df.iloc[0, 0] = 100
+        else:
+            with pd.option_context("chained_assignment", "warn"):
+                with tm.assert_produces_warning(SettingWithCopyWarning):
+                    new_df.iloc[0, 0] = 100
+        assert df.iloc[0, 0] == 100
+
+
+def test_series_midx_tuples_slice(using_copy_on_write, warn_copy_on_write):
+    ser = Series(
+        [1, 2, 3],
+        index=pd.MultiIndex.from_tuples([((1, 2), 3), ((1, 2), 4), ((2, 3), 4)]),
+    )
+    result = ser[(1, 2)]
+    assert np.shares_memory(get_array(ser), get_array(result))
+    with tm.assert_cow_warning(warn_copy_on_write):
+        result.iloc[0] = 100
+    if using_copy_on_write:
+        expected = Series(
+            [1, 2, 3],
+            index=pd.MultiIndex.from_tuples([((1, 2), 3), ((1, 2), 4), ((2, 3), 4)]),
+        )
+        tm.assert_series_equal(ser, expected)
+
+
+def test_midx_read_only_bool_indexer():
+    # GH#56635
+    def mklbl(prefix, n):
+        return [f"{prefix}{i}" for i in range(n)]
+
+    idx = pd.MultiIndex.from_product(
+        [mklbl("A", 4), mklbl("B", 2), mklbl("C", 4), mklbl("D", 2)]
+    )
+    cols = pd.MultiIndex.from_tuples(
+        [("a", "foo"), ("a", "bar"), ("b", "foo"), ("b", "bah")], names=["lvl0", "lvl1"]
+    )
+    df = DataFrame(1, index=idx, columns=cols).sort_index().sort_index(axis=1)
+
+    mask = df[("a", "foo")] == 1
+    expected_mask = mask.copy()
+    result = df.loc[pd.IndexSlice[mask, :, ["C1", "C3"]], :]
+    expected = df.loc[pd.IndexSlice[:, :, ["C1", "C3"]], :]
+    tm.assert_frame_equal(result, expected)
+    tm.assert_series_equal(mask, expected_mask)
+
+
+def test_loc_enlarging_with_dataframe(using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3]})
+    rhs = DataFrame({"b": [1, 2, 3], "c": [4, 5, 6]})
+    rhs_orig = rhs.copy()
+    df.loc[:, ["b", "c"]] = rhs
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df, "b"), get_array(rhs, "b"))
+        assert np.shares_memory(get_array(df, "c"), get_array(rhs, "c"))
+        assert not df._mgr._has_no_reference(1)
+    else:
+        assert not np.shares_memory(get_array(df, "b"), get_array(rhs, "b"))
+
+    df.iloc[0, 1] = 100
+    tm.assert_frame_equal(rhs, rhs_orig)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_internals.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_internals.py
new file mode 100644
index 0000000000000000000000000000000000000000..a727331307d7e9086144aa8d27f70ffa83973620
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_internals.py
@@ -0,0 +1,151 @@
+import numpy as np
+import pytest
+
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import DataFrame
+import pandas._testing as tm
+from pandas.tests.copy_view.util import get_array
+
+
+@td.skip_array_manager_invalid_test
+def test_consolidate(using_copy_on_write):
+    # create unconsolidated DataFrame
+    df = DataFrame({"a": [1, 2, 3], "b": [0.1, 0.2, 0.3]})
+    df["c"] = [4, 5, 6]
+
+    # take a viewing subset
+    subset = df[:]
+
+    # each block of subset references a block of df
+    assert all(blk.refs.has_reference() for blk in subset._mgr.blocks)
+
+    # consolidate the two int64 blocks
+    subset._consolidate_inplace()
+
+    # the float64 block still references the parent one because it still a view
+    assert subset._mgr.blocks[0].refs.has_reference()
+    # equivalent of assert np.shares_memory(df["b"].values, subset["b"].values)
+    # but avoids caching df["b"]
+    assert np.shares_memory(get_array(df, "b"), get_array(subset, "b"))
+
+    # the new consolidated int64 block does not reference another
+    assert not subset._mgr.blocks[1].refs.has_reference()
+
+    # the parent dataframe now also only is linked for the float column
+    assert not df._mgr.blocks[0].refs.has_reference()
+    assert df._mgr.blocks[1].refs.has_reference()
+    assert not df._mgr.blocks[2].refs.has_reference()
+
+    # and modifying subset still doesn't modify parent
+    if using_copy_on_write:
+        subset.iloc[0, 1] = 0.0
+        assert not df._mgr.blocks[1].refs.has_reference()
+        assert df.loc[0, "b"] == 0.1
+
+
+@pytest.mark.single_cpu
+@td.skip_array_manager_invalid_test
+def test_switch_options():
+    # ensure we can switch the value of the option within one session
+    # (assuming data is constructed after switching)
+
+    # using the option_context to ensure we set back to global option value
+    # after running the test
+    with pd.option_context("mode.copy_on_write", False):
+        df = DataFrame({"a": [1, 2, 3], "b": [0.1, 0.2, 0.3]})
+        subset = df[:]
+        subset.iloc[0, 0] = 0
+        # df updated with CoW disabled
+        assert df.iloc[0, 0] == 0
+
+        pd.options.mode.copy_on_write = True
+        df = DataFrame({"a": [1, 2, 3], "b": [0.1, 0.2, 0.3]})
+        subset = df[:]
+        subset.iloc[0, 0] = 0
+        # df not updated with CoW enabled
+        assert df.iloc[0, 0] == 1
+
+        pd.options.mode.copy_on_write = False
+        df = DataFrame({"a": [1, 2, 3], "b": [0.1, 0.2, 0.3]})
+        subset = df[:]
+        subset.iloc[0, 0] = 0
+        # df updated with CoW disabled
+        assert df.iloc[0, 0] == 0
+
+
+@td.skip_array_manager_invalid_test
+@pytest.mark.parametrize("dtype", [np.intp, np.int8])
+@pytest.mark.parametrize(
+    "locs, arr",
+    [
+        ([0], np.array([-1, -2, -3])),
+        ([1], np.array([-1, -2, -3])),
+        ([5], np.array([-1, -2, -3])),
+        ([0, 1], np.array([[-1, -2, -3], [-4, -5, -6]]).T),
+        ([0, 2], np.array([[-1, -2, -3], [-4, -5, -6]]).T),
+        ([0, 1, 2], np.array([[-1, -2, -3], [-4, -5, -6], [-4, -5, -6]]).T),
+        ([1, 2], np.array([[-1, -2, -3], [-4, -5, -6]]).T),
+        ([1, 3], np.array([[-1, -2, -3], [-4, -5, -6]]).T),
+        ([1, 3], np.array([[-1, -2, -3], [-4, -5, -6]]).T),
+    ],
+)
+def test_iset_splits_blocks_inplace(using_copy_on_write, locs, arr, dtype):
+    # Nothing currently calls iset with
+    # more than 1 loc with inplace=True (only happens with inplace=False)
+    # but ensure that it works
+    df = DataFrame(
+        {
+            "a": [1, 2, 3],
+            "b": [4, 5, 6],
+            "c": [7, 8, 9],
+            "d": [10, 11, 12],
+            "e": [13, 14, 15],
+            "f": ["a", "b", "c"],
+        },
+    )
+    arr = arr.astype(dtype)
+    df_orig = df.copy()
+    df2 = df.copy(deep=None)  # Trigger a CoW (if enabled, otherwise makes copy)
+    df2._mgr.iset(locs, arr, inplace=True)
+
+    tm.assert_frame_equal(df, df_orig)
+
+    if using_copy_on_write:
+        for i, col in enumerate(df.columns):
+            if i not in locs:
+                assert np.shares_memory(get_array(df, col), get_array(df2, col))
+    else:
+        for col in df.columns:
+            assert not np.shares_memory(get_array(df, col), get_array(df2, col))
+
+
+def test_exponential_backoff():
+    # GH#55518
+    df = DataFrame({"a": [1, 2, 3]})
+    for i in range(490):
+        df.copy(deep=False)
+
+    assert len(df._mgr.blocks[0].refs.referenced_blocks) == 491
+
+    df = DataFrame({"a": [1, 2, 3]})
+    dfs = [df.copy(deep=False) for i in range(510)]
+
+    for i in range(20):
+        df.copy(deep=False)
+    assert len(df._mgr.blocks[0].refs.referenced_blocks) == 531
+    assert df._mgr.blocks[0].refs.clear_counter == 1000
+
+    for i in range(500):
+        df.copy(deep=False)
+
+    # Don't reduce since we still have over 500 objects alive
+    assert df._mgr.blocks[0].refs.clear_counter == 1000
+
+    dfs = dfs[:300]
+    for i in range(500):
+        df.copy(deep=False)
+
+    # Reduce since there are less than 500 objects alive
+    assert df._mgr.blocks[0].refs.clear_counter == 500
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_interp_fillna.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_interp_fillna.py
new file mode 100644
index 0000000000000000000000000000000000000000..ddc5879a56d544a5bbcbc9ef72b35d20d6f3b91b
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_interp_fillna.py
@@ -0,0 +1,432 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    NA,
+    ArrowDtype,
+    DataFrame,
+    Interval,
+    NaT,
+    Series,
+    Timestamp,
+    interval_range,
+    option_context,
+)
+import pandas._testing as tm
+from pandas.tests.copy_view.util import get_array
+
+
+@pytest.mark.parametrize("method", ["pad", "nearest", "linear"])
+def test_interpolate_no_op(using_copy_on_write, method):
+    df = DataFrame({"a": [1, 2]})
+    df_orig = df.copy()
+
+    warn = None
+    if method == "pad":
+        warn = FutureWarning
+    msg = "DataFrame.interpolate with method=pad is deprecated"
+    with tm.assert_produces_warning(warn, match=msg):
+        result = df.interpolate(method=method)
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(result, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(result, "a"), get_array(df, "a"))
+
+    result.iloc[0, 0] = 100
+
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "a"), get_array(df, "a"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize("func", ["ffill", "bfill"])
+def test_interp_fill_functions(using_copy_on_write, func):
+    # Check that these takes the same code paths as interpolate
+    df = DataFrame({"a": [1, 2]})
+    df_orig = df.copy()
+
+    result = getattr(df, func)()
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(result, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(result, "a"), get_array(df, "a"))
+
+    result.iloc[0, 0] = 100
+
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "a"), get_array(df, "a"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize("func", ["ffill", "bfill"])
+@pytest.mark.parametrize(
+    "vals", [[1, np.nan, 2], [Timestamp("2019-12-31"), NaT, Timestamp("2020-12-31")]]
+)
+def test_interpolate_triggers_copy(using_copy_on_write, vals, func):
+    df = DataFrame({"a": vals})
+    result = getattr(df, func)()
+
+    assert not np.shares_memory(get_array(result, "a"), get_array(df, "a"))
+    if using_copy_on_write:
+        # Check that we don't have references when triggering a copy
+        assert result._mgr._has_no_reference(0)
+
+
+@pytest.mark.parametrize(
+    "vals", [[1, np.nan, 2], [Timestamp("2019-12-31"), NaT, Timestamp("2020-12-31")]]
+)
+def test_interpolate_inplace_no_reference_no_copy(using_copy_on_write, vals):
+    df = DataFrame({"a": vals})
+    arr = get_array(df, "a")
+    df.interpolate(method="linear", inplace=True)
+
+    assert np.shares_memory(arr, get_array(df, "a"))
+    if using_copy_on_write:
+        # Check that we don't have references when triggering a copy
+        assert df._mgr._has_no_reference(0)
+
+
+@pytest.mark.parametrize(
+    "vals", [[1, np.nan, 2], [Timestamp("2019-12-31"), NaT, Timestamp("2020-12-31")]]
+)
+def test_interpolate_inplace_with_refs(using_copy_on_write, vals, warn_copy_on_write):
+    df = DataFrame({"a": [1, np.nan, 2]})
+    df_orig = df.copy()
+    arr = get_array(df, "a")
+    view = df[:]
+    with tm.assert_cow_warning(warn_copy_on_write):
+        df.interpolate(method="linear", inplace=True)
+
+    if using_copy_on_write:
+        # Check that copy was triggered in interpolate and that we don't
+        # have any references left
+        assert not np.shares_memory(arr, get_array(df, "a"))
+        tm.assert_frame_equal(df_orig, view)
+        assert df._mgr._has_no_reference(0)
+        assert view._mgr._has_no_reference(0)
+    else:
+        assert np.shares_memory(arr, get_array(df, "a"))
+
+
+@pytest.mark.parametrize("func", ["ffill", "bfill"])
+@pytest.mark.parametrize("dtype", ["float64", "Float64"])
+def test_interp_fill_functions_inplace(
+    using_copy_on_write, func, warn_copy_on_write, dtype
+):
+    # Check that these takes the same code paths as interpolate
+    df = DataFrame({"a": [1, np.nan, 2]}, dtype=dtype)
+    df_orig = df.copy()
+    arr = get_array(df, "a")
+    view = df[:]
+
+    with tm.assert_cow_warning(warn_copy_on_write and dtype == "float64"):
+        getattr(df, func)(inplace=True)
+
+    if using_copy_on_write:
+        # Check that copy was triggered in interpolate and that we don't
+        # have any references left
+        assert not np.shares_memory(arr, get_array(df, "a"))
+        tm.assert_frame_equal(df_orig, view)
+        assert df._mgr._has_no_reference(0)
+        assert view._mgr._has_no_reference(0)
+    else:
+        assert np.shares_memory(arr, get_array(df, "a")) is (dtype == "float64")
+
+
+def test_interpolate_cleaned_fill_method(using_copy_on_write):
+    # Check that "method is set to None" case works correctly
+    df = DataFrame({"a": ["a", np.nan, "c"], "b": 1})
+    df_orig = df.copy()
+
+    msg = "DataFrame.interpolate with object dtype"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        result = df.interpolate(method="linear")
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(result, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(result, "a"), get_array(df, "a"))
+
+    result.iloc[0, 0] = Timestamp("2021-12-31")
+
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(result, "a"), get_array(df, "a"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_interpolate_object_convert_no_op(using_copy_on_write):
+    df = DataFrame({"a": ["a", "b", "c"], "b": 1})
+    arr_a = get_array(df, "a")
+    msg = "DataFrame.interpolate with method=pad is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        df.interpolate(method="pad", inplace=True)
+
+    # Now CoW makes a copy, it should not!
+    if using_copy_on_write:
+        assert df._mgr._has_no_reference(0)
+        assert np.shares_memory(arr_a, get_array(df, "a"))
+
+
+def test_interpolate_object_convert_copies(using_copy_on_write):
+    df = DataFrame({"a": Series([1, 2], dtype=object), "b": 1})
+    arr_a = get_array(df, "a")
+    msg = "DataFrame.interpolate with method=pad is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        df.interpolate(method="pad", inplace=True)
+
+    if using_copy_on_write:
+        assert df._mgr._has_no_reference(0)
+        assert not np.shares_memory(arr_a, get_array(df, "a"))
+
+
+def test_interpolate_downcast(using_copy_on_write):
+    df = DataFrame({"a": [1, np.nan, 2.5], "b": 1})
+    arr_a = get_array(df, "a")
+    msg = "DataFrame.interpolate with method=pad is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        df.interpolate(method="pad", inplace=True, downcast="infer")
+
+    if using_copy_on_write:
+        assert df._mgr._has_no_reference(0)
+    assert np.shares_memory(arr_a, get_array(df, "a"))
+
+
+def test_interpolate_downcast_reference_triggers_copy(using_copy_on_write):
+    df = DataFrame({"a": [1, np.nan, 2.5], "b": 1})
+    df_orig = df.copy()
+    arr_a = get_array(df, "a")
+    view = df[:]
+    msg = "DataFrame.interpolate with method=pad is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        df.interpolate(method="pad", inplace=True, downcast="infer")
+
+    if using_copy_on_write:
+        assert df._mgr._has_no_reference(0)
+        assert not np.shares_memory(arr_a, get_array(df, "a"))
+        tm.assert_frame_equal(df_orig, view)
+    else:
+        tm.assert_frame_equal(df, view)
+
+
+def test_fillna(using_copy_on_write):
+    df = DataFrame({"a": [1.5, np.nan], "b": 1})
+    df_orig = df.copy()
+
+    df2 = df.fillna(5.5)
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df, "b"), get_array(df2, "b"))
+    else:
+        assert not np.shares_memory(get_array(df, "b"), get_array(df2, "b"))
+
+    df2.iloc[0, 1] = 100
+    tm.assert_frame_equal(df_orig, df)
+
+
+def test_fillna_dict(using_copy_on_write):
+    df = DataFrame({"a": [1.5, np.nan], "b": 1})
+    df_orig = df.copy()
+
+    df2 = df.fillna({"a": 100.5})
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df, "b"), get_array(df2, "b"))
+        assert not np.shares_memory(get_array(df, "a"), get_array(df2, "a"))
+    else:
+        assert not np.shares_memory(get_array(df, "b"), get_array(df2, "b"))
+
+    df2.iloc[0, 1] = 100
+    tm.assert_frame_equal(df_orig, df)
+
+
+@pytest.mark.parametrize("downcast", [None, False])
+def test_fillna_inplace(using_copy_on_write, downcast):
+    df = DataFrame({"a": [1.5, np.nan], "b": 1})
+    arr_a = get_array(df, "a")
+    arr_b = get_array(df, "b")
+
+    msg = "The 'downcast' keyword in fillna is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        df.fillna(5.5, inplace=True, downcast=downcast)
+    assert np.shares_memory(get_array(df, "a"), arr_a)
+    assert np.shares_memory(get_array(df, "b"), arr_b)
+    if using_copy_on_write:
+        assert df._mgr._has_no_reference(0)
+        assert df._mgr._has_no_reference(1)
+
+
+def test_fillna_inplace_reference(using_copy_on_write, warn_copy_on_write):
+    df = DataFrame({"a": [1.5, np.nan], "b": 1})
+    df_orig = df.copy()
+    arr_a = get_array(df, "a")
+    arr_b = get_array(df, "b")
+    view = df[:]
+
+    with tm.assert_cow_warning(warn_copy_on_write):
+        df.fillna(5.5, inplace=True)
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df, "a"), arr_a)
+        assert np.shares_memory(get_array(df, "b"), arr_b)
+        assert view._mgr._has_no_reference(0)
+        assert df._mgr._has_no_reference(0)
+        tm.assert_frame_equal(view, df_orig)
+    else:
+        assert np.shares_memory(get_array(df, "a"), arr_a)
+        assert np.shares_memory(get_array(df, "b"), arr_b)
+    expected = DataFrame({"a": [1.5, 5.5], "b": 1})
+    tm.assert_frame_equal(df, expected)
+
+
+def test_fillna_interval_inplace_reference(using_copy_on_write, warn_copy_on_write):
+    # Set dtype explicitly to avoid implicit cast when setting nan
+    ser = Series(
+        interval_range(start=0, end=5), name="a", dtype="interval[float64, right]"
+    )
+    ser.iloc[1] = np.nan
+
+    ser_orig = ser.copy()
+    view = ser[:]
+    with tm.assert_cow_warning(warn_copy_on_write):
+        ser.fillna(value=Interval(left=0, right=5), inplace=True)
+
+    if using_copy_on_write:
+        assert not np.shares_memory(
+            get_array(ser, "a").left.values, get_array(view, "a").left.values
+        )
+        tm.assert_series_equal(view, ser_orig)
+    else:
+        assert np.shares_memory(
+            get_array(ser, "a").left.values, get_array(view, "a").left.values
+        )
+
+
+def test_fillna_series_empty_arg(using_copy_on_write):
+    ser = Series([1, np.nan, 2])
+    ser_orig = ser.copy()
+    result = ser.fillna({})
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(ser), get_array(result))
+    else:
+        assert not np.shares_memory(get_array(ser), get_array(result))
+
+    ser.iloc[0] = 100.5
+    tm.assert_series_equal(ser_orig, result)
+
+
+def test_fillna_series_empty_arg_inplace(using_copy_on_write):
+    ser = Series([1, np.nan, 2])
+    arr = get_array(ser)
+    ser.fillna({}, inplace=True)
+
+    assert np.shares_memory(get_array(ser), arr)
+    if using_copy_on_write:
+        assert ser._mgr._has_no_reference(0)
+
+
+def test_fillna_ea_noop_shares_memory(
+    using_copy_on_write, any_numeric_ea_and_arrow_dtype
+):
+    df = DataFrame({"a": [1, NA, 3], "b": 1}, dtype=any_numeric_ea_and_arrow_dtype)
+    df_orig = df.copy()
+    df2 = df.fillna(100)
+
+    assert not np.shares_memory(get_array(df, "a"), get_array(df2, "a"))
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df, "b"), get_array(df2, "b"))
+        assert not df2._mgr._has_no_reference(1)
+    elif isinstance(df.dtypes.iloc[0], ArrowDtype):
+        # arrow is immutable, so no-ops do not need to copy underlying array
+        assert np.shares_memory(get_array(df, "b"), get_array(df2, "b"))
+    else:
+        assert not np.shares_memory(get_array(df, "b"), get_array(df2, "b"))
+
+    tm.assert_frame_equal(df_orig, df)
+
+    df2.iloc[0, 1] = 100
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df, "b"), get_array(df2, "b"))
+        assert df2._mgr._has_no_reference(1)
+        assert df._mgr._has_no_reference(1)
+    tm.assert_frame_equal(df_orig, df)
+
+
+def test_fillna_inplace_ea_noop_shares_memory(
+    using_copy_on_write, warn_copy_on_write, any_numeric_ea_and_arrow_dtype
+):
+    df = DataFrame({"a": [1, NA, 3], "b": 1}, dtype=any_numeric_ea_and_arrow_dtype)
+    df_orig = df.copy()
+    view = df[:]
+    with tm.assert_cow_warning(warn_copy_on_write):
+        df.fillna(100, inplace=True)
+
+    if isinstance(df["a"].dtype, ArrowDtype) or using_copy_on_write:
+        assert not np.shares_memory(get_array(df, "a"), get_array(view, "a"))
+    else:
+        # MaskedArray can actually respect inplace=True
+        assert np.shares_memory(get_array(df, "a"), get_array(view, "a"))
+
+    assert np.shares_memory(get_array(df, "b"), get_array(view, "b"))
+    if using_copy_on_write:
+        assert not df._mgr._has_no_reference(1)
+        assert not view._mgr._has_no_reference(1)
+
+    with tm.assert_cow_warning(
+        warn_copy_on_write and "pyarrow" not in any_numeric_ea_and_arrow_dtype
+    ):
+        df.iloc[0, 1] = 100
+    if isinstance(df["a"].dtype, ArrowDtype) or using_copy_on_write:
+        tm.assert_frame_equal(df_orig, view)
+    else:
+        # we actually have a view
+        tm.assert_frame_equal(df, view)
+
+
+def test_fillna_chained_assignment(using_copy_on_write):
+    df = DataFrame({"a": [1, np.nan, 2], "b": 1})
+    df_orig = df.copy()
+    if using_copy_on_write:
+        with tm.raises_chained_assignment_error():
+            df["a"].fillna(100, inplace=True)
+        tm.assert_frame_equal(df, df_orig)
+
+        with tm.raises_chained_assignment_error():
+            df[["a"]].fillna(100, inplace=True)
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        with tm.assert_produces_warning(None):
+            with option_context("mode.chained_assignment", None):
+                df[["a"]].fillna(100, inplace=True)
+
+        with tm.assert_produces_warning(None):
+            with option_context("mode.chained_assignment", None):
+                df[df.a > 5].fillna(100, inplace=True)
+
+        with tm.assert_produces_warning(FutureWarning, match="inplace method"):
+            df["a"].fillna(100, inplace=True)
+
+
+@pytest.mark.parametrize("func", ["interpolate", "ffill", "bfill"])
+def test_interpolate_chained_assignment(using_copy_on_write, func):
+    df = DataFrame({"a": [1, np.nan, 2], "b": 1})
+    df_orig = df.copy()
+    if using_copy_on_write:
+        with tm.raises_chained_assignment_error():
+            getattr(df["a"], func)(inplace=True)
+        tm.assert_frame_equal(df, df_orig)
+
+        with tm.raises_chained_assignment_error():
+            getattr(df[["a"]], func)(inplace=True)
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        with tm.assert_produces_warning(FutureWarning, match="inplace method"):
+            getattr(df["a"], func)(inplace=True)
+
+        with tm.assert_produces_warning(None):
+            with option_context("mode.chained_assignment", None):
+                getattr(df[["a"]], func)(inplace=True)
+
+        with tm.assert_produces_warning(None):
+            with option_context("mode.chained_assignment", None):
+                getattr(df[df["a"] > 1], func)(inplace=True)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_methods.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_methods.py
new file mode 100644
index 0000000000000000000000000000000000000000..5d1eefccbb1e723320da889f2874b79b12ce3d0e
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_methods.py
@@ -0,0 +1,2055 @@
+import numpy as np
+import pytest
+
+from pandas.errors import SettingWithCopyWarning
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    Period,
+    Series,
+    Timestamp,
+    date_range,
+    option_context,
+    period_range,
+)
+import pandas._testing as tm
+from pandas.tests.copy_view.util import get_array
+
+
+def test_copy(using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_copy = df.copy()
+
+    # the deep copy by defaults takes a shallow copy of the Index
+    assert df_copy.index is not df.index
+    assert df_copy.columns is not df.columns
+    assert df_copy.index.is_(df.index)
+    assert df_copy.columns.is_(df.columns)
+
+    # the deep copy doesn't share memory
+    assert not np.shares_memory(get_array(df_copy, "a"), get_array(df, "a"))
+    if using_copy_on_write:
+        assert not df_copy._mgr.blocks[0].refs.has_reference()
+        assert not df_copy._mgr.blocks[1].refs.has_reference()
+
+    # mutating copy doesn't mutate original
+    df_copy.iloc[0, 0] = 0
+    assert df.iloc[0, 0] == 1
+
+
+def test_copy_shallow(using_copy_on_write, warn_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_copy = df.copy(deep=False)
+
+    # the shallow copy also makes a shallow copy of the index
+    if using_copy_on_write:
+        assert df_copy.index is not df.index
+        assert df_copy.columns is not df.columns
+        assert df_copy.index.is_(df.index)
+        assert df_copy.columns.is_(df.columns)
+    else:
+        assert df_copy.index is df.index
+        assert df_copy.columns is df.columns
+
+    # the shallow copy still shares memory
+    assert np.shares_memory(get_array(df_copy, "a"), get_array(df, "a"))
+    if using_copy_on_write:
+        assert df_copy._mgr.blocks[0].refs.has_reference()
+        assert df_copy._mgr.blocks[1].refs.has_reference()
+
+    if using_copy_on_write:
+        # mutating shallow copy doesn't mutate original
+        df_copy.iloc[0, 0] = 0
+        assert df.iloc[0, 0] == 1
+        # mutating triggered a copy-on-write -> no longer shares memory
+        assert not np.shares_memory(get_array(df_copy, "a"), get_array(df, "a"))
+        # but still shares memory for the other columns/blocks
+        assert np.shares_memory(get_array(df_copy, "c"), get_array(df, "c"))
+    else:
+        # mutating shallow copy does mutate original
+        with tm.assert_cow_warning(warn_copy_on_write):
+            df_copy.iloc[0, 0] = 0
+        assert df.iloc[0, 0] == 0
+        # and still shares memory
+        assert np.shares_memory(get_array(df_copy, "a"), get_array(df, "a"))
+
+
+@pytest.mark.parametrize("copy", [True, None, False])
+@pytest.mark.parametrize(
+    "method",
+    [
+        lambda df, copy: df.rename(columns=str.lower, copy=copy),
+        lambda df, copy: df.reindex(columns=["a", "c"], copy=copy),
+        lambda df, copy: df.reindex_like(df, copy=copy),
+        lambda df, copy: df.align(df, copy=copy)[0],
+        lambda df, copy: df.set_axis(["a", "b", "c"], axis="index", copy=copy),
+        lambda df, copy: df.rename_axis(index="test", copy=copy),
+        lambda df, copy: df.rename_axis(columns="test", copy=copy),
+        lambda df, copy: df.astype({"b": "int64"}, copy=copy),
+        # lambda df, copy: df.swaplevel(0, 0, copy=copy),
+        lambda df, copy: df.swapaxes(0, 0, copy=copy),
+        lambda df, copy: df.truncate(0, 5, copy=copy),
+        lambda df, copy: df.infer_objects(copy=copy),
+        lambda df, copy: df.to_timestamp(copy=copy),
+        lambda df, copy: df.to_period(freq="D", copy=copy),
+        lambda df, copy: df.tz_localize("US/Central", copy=copy),
+        lambda df, copy: df.tz_convert("US/Central", copy=copy),
+        lambda df, copy: df.set_flags(allows_duplicate_labels=False, copy=copy),
+    ],
+    ids=[
+        "rename",
+        "reindex",
+        "reindex_like",
+        "align",
+        "set_axis",
+        "rename_axis0",
+        "rename_axis1",
+        "astype",
+        # "swaplevel",  # only series
+        "swapaxes",
+        "truncate",
+        "infer_objects",
+        "to_timestamp",
+        "to_period",
+        "tz_localize",
+        "tz_convert",
+        "set_flags",
+    ],
+)
+def test_methods_copy_keyword(
+    request, method, copy, using_copy_on_write, using_array_manager
+):
+    index = None
+    if "to_timestamp" in request.node.callspec.id:
+        index = period_range("2012-01-01", freq="D", periods=3)
+    elif "to_period" in request.node.callspec.id:
+        index = date_range("2012-01-01", freq="D", periods=3)
+    elif "tz_localize" in request.node.callspec.id:
+        index = date_range("2012-01-01", freq="D", periods=3)
+    elif "tz_convert" in request.node.callspec.id:
+        index = date_range("2012-01-01", freq="D", periods=3, tz="Europe/Brussels")
+
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]}, index=index)
+
+    if "swapaxes" in request.node.callspec.id:
+        msg = "'DataFrame.swapaxes' is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            df2 = method(df, copy=copy)
+    else:
+        df2 = method(df, copy=copy)
+
+    share_memory = using_copy_on_write or copy is False
+
+    if request.node.callspec.id.startswith("reindex-"):
+        # TODO copy=False without CoW still returns a copy in this case
+        if not using_copy_on_write and not using_array_manager and copy is False:
+            share_memory = False
+
+    if share_memory:
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+
+@pytest.mark.parametrize("copy", [True, None, False])
+@pytest.mark.parametrize(
+    "method",
+    [
+        lambda ser, copy: ser.rename(index={0: 100}, copy=copy),
+        lambda ser, copy: ser.rename(None, copy=copy),
+        lambda ser, copy: ser.reindex(index=ser.index, copy=copy),
+        lambda ser, copy: ser.reindex_like(ser, copy=copy),
+        lambda ser, copy: ser.align(ser, copy=copy)[0],
+        lambda ser, copy: ser.set_axis(["a", "b", "c"], axis="index", copy=copy),
+        lambda ser, copy: ser.rename_axis(index="test", copy=copy),
+        lambda ser, copy: ser.astype("int64", copy=copy),
+        lambda ser, copy: ser.swaplevel(0, 1, copy=copy),
+        lambda ser, copy: ser.swapaxes(0, 0, copy=copy),
+        lambda ser, copy: ser.truncate(0, 5, copy=copy),
+        lambda ser, copy: ser.infer_objects(copy=copy),
+        lambda ser, copy: ser.to_timestamp(copy=copy),
+        lambda ser, copy: ser.to_period(freq="D", copy=copy),
+        lambda ser, copy: ser.tz_localize("US/Central", copy=copy),
+        lambda ser, copy: ser.tz_convert("US/Central", copy=copy),
+        lambda ser, copy: ser.set_flags(allows_duplicate_labels=False, copy=copy),
+    ],
+    ids=[
+        "rename (dict)",
+        "rename",
+        "reindex",
+        "reindex_like",
+        "align",
+        "set_axis",
+        "rename_axis0",
+        "astype",
+        "swaplevel",
+        "swapaxes",
+        "truncate",
+        "infer_objects",
+        "to_timestamp",
+        "to_period",
+        "tz_localize",
+        "tz_convert",
+        "set_flags",
+    ],
+)
+def test_methods_series_copy_keyword(request, method, copy, using_copy_on_write):
+    index = None
+    if "to_timestamp" in request.node.callspec.id:
+        index = period_range("2012-01-01", freq="D", periods=3)
+    elif "to_period" in request.node.callspec.id:
+        index = date_range("2012-01-01", freq="D", periods=3)
+    elif "tz_localize" in request.node.callspec.id:
+        index = date_range("2012-01-01", freq="D", periods=3)
+    elif "tz_convert" in request.node.callspec.id:
+        index = date_range("2012-01-01", freq="D", periods=3, tz="Europe/Brussels")
+    elif "swaplevel" in request.node.callspec.id:
+        index = MultiIndex.from_arrays([[1, 2, 3], [4, 5, 6]])
+
+    ser = Series([1, 2, 3], index=index)
+
+    if "swapaxes" in request.node.callspec.id:
+        msg = "'Series.swapaxes' is deprecated"
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            ser2 = method(ser, copy=copy)
+    else:
+        ser2 = method(ser, copy=copy)
+
+    share_memory = using_copy_on_write or copy is False
+
+    if share_memory:
+        assert np.shares_memory(get_array(ser2), get_array(ser))
+    else:
+        assert not np.shares_memory(get_array(ser2), get_array(ser))
+
+
+@pytest.mark.parametrize("copy", [True, None, False])
+def test_transpose_copy_keyword(using_copy_on_write, copy, using_array_manager):
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+    result = df.transpose(copy=copy)
+    share_memory = using_copy_on_write or copy is False or copy is None
+    share_memory = share_memory and not using_array_manager
+
+    if share_memory:
+        assert np.shares_memory(get_array(df, "a"), get_array(result, 0))
+    else:
+        assert not np.shares_memory(get_array(df, "a"), get_array(result, 0))
+
+
+# -----------------------------------------------------------------------------
+# DataFrame methods returning new DataFrame using shallow copy
+
+
+def test_reset_index(using_copy_on_write):
+    # Case: resetting the index (i.e. adding a new column) + mutating the
+    # resulting dataframe
+    df = DataFrame(
+        {"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]}, index=[10, 11, 12]
+    )
+    df_orig = df.copy()
+    df2 = df.reset_index()
+    df2._mgr._verify_integrity()
+
+    if using_copy_on_write:
+        # still shares memory (df2 is a shallow copy)
+        assert np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+        assert np.shares_memory(get_array(df2, "c"), get_array(df, "c"))
+    # mutating df2 triggers a copy-on-write for that column / block
+    df2.iloc[0, 2] = 0
+    assert not np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "c"), get_array(df, "c"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize("index", [pd.RangeIndex(0, 2), Index([1, 2])])
+def test_reset_index_series_drop(using_copy_on_write, index):
+    ser = Series([1, 2], index=index)
+    ser_orig = ser.copy()
+    ser2 = ser.reset_index(drop=True)
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(ser), get_array(ser2))
+        assert not ser._mgr._has_no_reference(0)
+    else:
+        assert not np.shares_memory(get_array(ser), get_array(ser2))
+
+    ser2.iloc[0] = 100
+    tm.assert_series_equal(ser, ser_orig)
+
+
+def test_groupby_column_index_in_references():
+    df = DataFrame(
+        {"A": ["a", "b", "c", "d"], "B": [1, 2, 3, 4], "C": ["a", "a", "b", "b"]}
+    )
+    df = df.set_index("A")
+    key = df["C"]
+    result = df.groupby(key, observed=True).sum()
+    expected = df.groupby("C", observed=True).sum()
+    tm.assert_frame_equal(result, expected)
+
+
+def test_rename_columns(using_copy_on_write):
+    # Case: renaming columns returns a new dataframe
+    # + afterwards modifying the result
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+    df2 = df.rename(columns=str.upper)
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "A"), get_array(df, "a"))
+    df2.iloc[0, 0] = 0
+    assert not np.shares_memory(get_array(df2, "A"), get_array(df, "a"))
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "C"), get_array(df, "c"))
+    expected = DataFrame({"A": [0, 2, 3], "B": [4, 5, 6], "C": [0.1, 0.2, 0.3]})
+    tm.assert_frame_equal(df2, expected)
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_rename_columns_modify_parent(using_copy_on_write):
+    # Case: renaming columns returns a new dataframe
+    # + afterwards modifying the original (parent) dataframe
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df2 = df.rename(columns=str.upper)
+    df2_orig = df2.copy()
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "A"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "A"), get_array(df, "a"))
+    df.iloc[0, 0] = 0
+    assert not np.shares_memory(get_array(df2, "A"), get_array(df, "a"))
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "C"), get_array(df, "c"))
+    expected = DataFrame({"a": [0, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    tm.assert_frame_equal(df, expected)
+    tm.assert_frame_equal(df2, df2_orig)
+
+
+def test_pipe(using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": 1.5})
+    df_orig = df.copy()
+
+    def testfunc(df):
+        return df
+
+    df2 = df.pipe(testfunc)
+
+    assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+    # mutating df2 triggers a copy-on-write for that column
+    df2.iloc[0, 0] = 0
+    if using_copy_on_write:
+        tm.assert_frame_equal(df, df_orig)
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        expected = DataFrame({"a": [0, 2, 3], "b": 1.5})
+        tm.assert_frame_equal(df, expected)
+
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    assert np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+
+
+def test_pipe_modify_df(using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": 1.5})
+    df_orig = df.copy()
+
+    def testfunc(df):
+        df.iloc[0, 0] = 100
+        return df
+
+    df2 = df.pipe(testfunc)
+
+    assert np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+
+    if using_copy_on_write:
+        tm.assert_frame_equal(df, df_orig)
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        expected = DataFrame({"a": [100, 2, 3], "b": 1.5})
+        tm.assert_frame_equal(df, expected)
+
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    assert np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+
+
+def test_reindex_columns(using_copy_on_write):
+    # Case: reindexing the column returns a new dataframe
+    # + afterwards modifying the result
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+    df2 = df.reindex(columns=["a", "c"])
+
+    if using_copy_on_write:
+        # still shares memory (df2 is a shallow copy)
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    # mutating df2 triggers a copy-on-write for that column
+    df2.iloc[0, 0] = 0
+    assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "c"), get_array(df, "c"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize(
+    "index",
+    [
+        lambda idx: idx,
+        lambda idx: idx.view(),
+        lambda idx: idx.copy(),
+        lambda idx: list(idx),
+    ],
+    ids=["identical", "view", "copy", "values"],
+)
+def test_reindex_rows(index, using_copy_on_write):
+    # Case: reindexing the rows with an index that matches the current index
+    # can use a shallow copy
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+    df2 = df.reindex(index=index(df.index))
+
+    if using_copy_on_write:
+        # still shares memory (df2 is a shallow copy)
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    # mutating df2 triggers a copy-on-write for that column
+    df2.iloc[0, 0] = 0
+    assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "c"), get_array(df, "c"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_drop_on_column(using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+    df2 = df.drop(columns="a")
+    df2._mgr._verify_integrity()
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+        assert np.shares_memory(get_array(df2, "c"), get_array(df, "c"))
+    else:
+        assert not np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+        assert not np.shares_memory(get_array(df2, "c"), get_array(df, "c"))
+    df2.iloc[0, 0] = 0
+    assert not np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "c"), get_array(df, "c"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_select_dtypes(using_copy_on_write):
+    # Case: selecting columns using `select_dtypes()` returns a new dataframe
+    # + afterwards modifying the result
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+    df2 = df.select_dtypes("int64")
+    df2._mgr._verify_integrity()
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+    # mutating df2 triggers a copy-on-write for that column/block
+    df2.iloc[0, 0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize(
+    "filter_kwargs", [{"items": ["a"]}, {"like": "a"}, {"regex": "a"}]
+)
+def test_filter(using_copy_on_write, filter_kwargs):
+    # Case: selecting columns using `filter()` returns a new dataframe
+    # + afterwards modifying the result
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+    df2 = df.filter(**filter_kwargs)
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+    # mutating df2 triggers a copy-on-write for that column/block
+    if using_copy_on_write:
+        df2.iloc[0, 0] = 0
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_shift_no_op(using_copy_on_write):
+    df = DataFrame(
+        [[1, 2], [3, 4], [5, 6]],
+        index=date_range("2020-01-01", "2020-01-03"),
+        columns=["a", "b"],
+    )
+    df_orig = df.copy()
+    df2 = df.shift(periods=0)
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+    df.iloc[0, 0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df, "a"), get_array(df2, "a"))
+        assert np.shares_memory(get_array(df, "b"), get_array(df2, "b"))
+    tm.assert_frame_equal(df2, df_orig)
+
+
+def test_shift_index(using_copy_on_write):
+    df = DataFrame(
+        [[1, 2], [3, 4], [5, 6]],
+        index=date_range("2020-01-01", "2020-01-03"),
+        columns=["a", "b"],
+    )
+    df2 = df.shift(periods=1, axis=0)
+
+    assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+
+def test_shift_rows_freq(using_copy_on_write):
+    df = DataFrame(
+        [[1, 2], [3, 4], [5, 6]],
+        index=date_range("2020-01-01", "2020-01-03"),
+        columns=["a", "b"],
+    )
+    df_orig = df.copy()
+    df_orig.index = date_range("2020-01-02", "2020-01-04")
+    df2 = df.shift(periods=1, freq="1D")
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+    df.iloc[0, 0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df, "a"), get_array(df2, "a"))
+    tm.assert_frame_equal(df2, df_orig)
+
+
+def test_shift_columns(using_copy_on_write, warn_copy_on_write):
+    df = DataFrame(
+        [[1, 2], [3, 4], [5, 6]], columns=date_range("2020-01-01", "2020-01-02")
+    )
+    df2 = df.shift(periods=1, axis=1)
+
+    assert np.shares_memory(get_array(df2, "2020-01-02"), get_array(df, "2020-01-01"))
+    with tm.assert_cow_warning(warn_copy_on_write):
+        df.iloc[0, 0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(
+            get_array(df2, "2020-01-02"), get_array(df, "2020-01-01")
+        )
+        expected = DataFrame(
+            [[np.nan, 1], [np.nan, 3], [np.nan, 5]],
+            columns=date_range("2020-01-01", "2020-01-02"),
+        )
+        tm.assert_frame_equal(df2, expected)
+
+
+def test_pop(using_copy_on_write, warn_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+    view_original = df[:]
+    result = df.pop("a")
+
+    assert np.shares_memory(result.values, get_array(view_original, "a"))
+    assert np.shares_memory(get_array(df, "b"), get_array(view_original, "b"))
+
+    if using_copy_on_write:
+        result.iloc[0] = 0
+        assert not np.shares_memory(result.values, get_array(view_original, "a"))
+    with tm.assert_cow_warning(warn_copy_on_write):
+        df.iloc[0, 0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df, "b"), get_array(view_original, "b"))
+        tm.assert_frame_equal(view_original, df_orig)
+    else:
+        expected = DataFrame({"a": [1, 2, 3], "b": [0, 5, 6], "c": [0.1, 0.2, 0.3]})
+        tm.assert_frame_equal(view_original, expected)
+
+
+@pytest.mark.parametrize(
+    "func",
+    [
+        lambda x, y: x.align(y),
+        lambda x, y: x.align(y.a, axis=0),
+        lambda x, y: x.align(y.a.iloc[slice(0, 1)], axis=1),
+    ],
+)
+def test_align_frame(using_copy_on_write, func):
+    df = DataFrame({"a": [1, 2, 3], "b": "a"})
+    df_orig = df.copy()
+    df_changed = df[["b", "a"]].copy()
+    df2, _ = func(df, df_changed)
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+    df2.iloc[0, 0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_align_series(using_copy_on_write):
+    ser = Series([1, 2])
+    ser_orig = ser.copy()
+    ser_other = ser.copy()
+    ser2, ser_other_result = ser.align(ser_other)
+
+    if using_copy_on_write:
+        assert np.shares_memory(ser2.values, ser.values)
+        assert np.shares_memory(ser_other_result.values, ser_other.values)
+    else:
+        assert not np.shares_memory(ser2.values, ser.values)
+        assert not np.shares_memory(ser_other_result.values, ser_other.values)
+
+    ser2.iloc[0] = 0
+    ser_other_result.iloc[0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(ser2.values, ser.values)
+        assert not np.shares_memory(ser_other_result.values, ser_other.values)
+    tm.assert_series_equal(ser, ser_orig)
+    tm.assert_series_equal(ser_other, ser_orig)
+
+
+def test_align_copy_false(using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+    df_orig = df.copy()
+    df2, df3 = df.align(df, copy=False)
+
+    assert np.shares_memory(get_array(df, "b"), get_array(df2, "b"))
+    assert np.shares_memory(get_array(df, "a"), get_array(df2, "a"))
+
+    if using_copy_on_write:
+        df2.loc[0, "a"] = 0
+        tm.assert_frame_equal(df, df_orig)  # Original is unchanged
+
+        df3.loc[0, "a"] = 0
+        tm.assert_frame_equal(df, df_orig)  # Original is unchanged
+
+
+def test_align_with_series_copy_false(using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+    ser = Series([1, 2, 3], name="x")
+    ser_orig = ser.copy()
+    df_orig = df.copy()
+    df2, ser2 = df.align(ser, copy=False, axis=0)
+
+    assert np.shares_memory(get_array(df, "b"), get_array(df2, "b"))
+    assert np.shares_memory(get_array(df, "a"), get_array(df2, "a"))
+    assert np.shares_memory(get_array(ser, "x"), get_array(ser2, "x"))
+
+    if using_copy_on_write:
+        df2.loc[0, "a"] = 0
+        tm.assert_frame_equal(df, df_orig)  # Original is unchanged
+
+        ser2.loc[0] = 0
+        tm.assert_series_equal(ser, ser_orig)  # Original is unchanged
+
+
+def test_to_frame(using_copy_on_write, warn_copy_on_write):
+    # Case: converting a Series to a DataFrame with to_frame
+    ser = Series([1, 2, 3])
+    ser_orig = ser.copy()
+
+    df = ser[:].to_frame()
+
+    # currently this always returns a "view"
+    assert np.shares_memory(ser.values, get_array(df, 0))
+
+    with tm.assert_cow_warning(warn_copy_on_write):
+        df.iloc[0, 0] = 0
+
+    if using_copy_on_write:
+        # mutating df triggers a copy-on-write for that column
+        assert not np.shares_memory(ser.values, get_array(df, 0))
+        tm.assert_series_equal(ser, ser_orig)
+    else:
+        # but currently select_dtypes() actually returns a view -> mutates parent
+        expected = ser_orig.copy()
+        expected.iloc[0] = 0
+        tm.assert_series_equal(ser, expected)
+
+    # modify original series -> don't modify dataframe
+    df = ser[:].to_frame()
+    with tm.assert_cow_warning(warn_copy_on_write):
+        ser.iloc[0] = 0
+
+    if using_copy_on_write:
+        tm.assert_frame_equal(df, ser_orig.to_frame())
+    else:
+        expected = ser_orig.copy().to_frame()
+        expected.iloc[0, 0] = 0
+        tm.assert_frame_equal(df, expected)
+
+
+@pytest.mark.parametrize("ax", ["index", "columns"])
+def test_swapaxes_noop(using_copy_on_write, ax):
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+    df_orig = df.copy()
+    msg = "'DataFrame.swapaxes' is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        df2 = df.swapaxes(ax, ax)
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+    # mutating df2 triggers a copy-on-write for that column/block
+    df2.iloc[0, 0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_swapaxes_single_block(using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]}, index=["x", "y", "z"])
+    df_orig = df.copy()
+    msg = "'DataFrame.swapaxes' is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        df2 = df.swapaxes("index", "columns")
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "x"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "x"), get_array(df, "a"))
+
+    # mutating df2 triggers a copy-on-write for that column/block
+    df2.iloc[0, 0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df2, "x"), get_array(df, "a"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_swapaxes_read_only_array():
+    df = DataFrame({"a": [1, 2], "b": 3})
+    msg = "'DataFrame.swapaxes' is deprecated"
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        df = df.swapaxes(axis1="index", axis2="columns")
+    df.iloc[0, 0] = 100
+    expected = DataFrame({0: [100, 3], 1: [2, 3]}, index=["a", "b"])
+    tm.assert_frame_equal(df, expected)
+
+
+@pytest.mark.parametrize(
+    "method, idx",
+    [
+        (lambda df: df.copy(deep=False).copy(deep=False), 0),
+        (lambda df: df.reset_index().reset_index(), 2),
+        (lambda df: df.rename(columns=str.upper).rename(columns=str.lower), 0),
+        (lambda df: df.copy(deep=False).select_dtypes(include="number"), 0),
+    ],
+    ids=["shallow-copy", "reset_index", "rename", "select_dtypes"],
+)
+def test_chained_methods(request, method, idx, using_copy_on_write, warn_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+
+    # when not using CoW, only the copy() variant actually gives a view
+    df2_is_view = not using_copy_on_write and request.node.callspec.id == "shallow-copy"
+
+    # modify df2 -> don't modify df
+    df2 = method(df)
+    with tm.assert_cow_warning(warn_copy_on_write and df2_is_view):
+        df2.iloc[0, idx] = 0
+    if not df2_is_view:
+        tm.assert_frame_equal(df, df_orig)
+
+    # modify df -> don't modify df2
+    df2 = method(df)
+    with tm.assert_cow_warning(warn_copy_on_write and df2_is_view):
+        df.iloc[0, 0] = 0
+    if not df2_is_view:
+        tm.assert_frame_equal(df2.iloc[:, idx:], df_orig)
+
+
+@pytest.mark.parametrize("obj", [Series([1, 2], name="a"), DataFrame({"a": [1, 2]})])
+def test_to_timestamp(using_copy_on_write, obj):
+    obj.index = Index([Period("2012-1-1", freq="D"), Period("2012-1-2", freq="D")])
+
+    obj_orig = obj.copy()
+    obj2 = obj.to_timestamp()
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(obj2, "a"), get_array(obj, "a"))
+    else:
+        assert not np.shares_memory(get_array(obj2, "a"), get_array(obj, "a"))
+
+    # mutating obj2 triggers a copy-on-write for that column / block
+    obj2.iloc[0] = 0
+    assert not np.shares_memory(get_array(obj2, "a"), get_array(obj, "a"))
+    tm.assert_equal(obj, obj_orig)
+
+
+@pytest.mark.parametrize("obj", [Series([1, 2], name="a"), DataFrame({"a": [1, 2]})])
+def test_to_period(using_copy_on_write, obj):
+    obj.index = Index([Timestamp("2019-12-31"), Timestamp("2020-12-31")])
+
+    obj_orig = obj.copy()
+    obj2 = obj.to_period(freq="Y")
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(obj2, "a"), get_array(obj, "a"))
+    else:
+        assert not np.shares_memory(get_array(obj2, "a"), get_array(obj, "a"))
+
+    # mutating obj2 triggers a copy-on-write for that column / block
+    obj2.iloc[0] = 0
+    assert not np.shares_memory(get_array(obj2, "a"), get_array(obj, "a"))
+    tm.assert_equal(obj, obj_orig)
+
+
+def test_set_index(using_copy_on_write):
+    # GH 49473
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+    df2 = df.set_index("a")
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+    else:
+        assert not np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+
+    # mutating df2 triggers a copy-on-write for that column / block
+    df2.iloc[0, 1] = 0
+    assert not np.shares_memory(get_array(df2, "c"), get_array(df, "c"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_set_index_mutating_parent_does_not_mutate_index():
+    df = DataFrame({"a": [1, 2, 3], "b": 1})
+    result = df.set_index("a")
+    expected = result.copy()
+
+    df.iloc[0, 0] = 100
+    tm.assert_frame_equal(result, expected)
+
+
+def test_add_prefix(using_copy_on_write):
+    # GH 49473
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+    df2 = df.add_prefix("CoW_")
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "CoW_a"), get_array(df, "a"))
+    df2.iloc[0, 0] = 0
+
+    assert not np.shares_memory(get_array(df2, "CoW_a"), get_array(df, "a"))
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "CoW_c"), get_array(df, "c"))
+    expected = DataFrame(
+        {"CoW_a": [0, 2, 3], "CoW_b": [4, 5, 6], "CoW_c": [0.1, 0.2, 0.3]}
+    )
+    tm.assert_frame_equal(df2, expected)
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_add_suffix(using_copy_on_write):
+    # GH 49473
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+    df2 = df.add_suffix("_CoW")
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "a_CoW"), get_array(df, "a"))
+    df2.iloc[0, 0] = 0
+    assert not np.shares_memory(get_array(df2, "a_CoW"), get_array(df, "a"))
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "c_CoW"), get_array(df, "c"))
+    expected = DataFrame(
+        {"a_CoW": [0, 2, 3], "b_CoW": [4, 5, 6], "c_CoW": [0.1, 0.2, 0.3]}
+    )
+    tm.assert_frame_equal(df2, expected)
+    tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize("axis, val", [(0, 5.5), (1, np.nan)])
+def test_dropna(using_copy_on_write, axis, val):
+    df = DataFrame({"a": [1, 2, 3], "b": [4, val, 6], "c": "d"})
+    df_orig = df.copy()
+    df2 = df.dropna(axis=axis)
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+    df2.iloc[0, 0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize("val", [5, 5.5])
+def test_dropna_series(using_copy_on_write, val):
+    ser = Series([1, val, 4])
+    ser_orig = ser.copy()
+    ser2 = ser.dropna()
+
+    if using_copy_on_write:
+        assert np.shares_memory(ser2.values, ser.values)
+    else:
+        assert not np.shares_memory(ser2.values, ser.values)
+
+    ser2.iloc[0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(ser2.values, ser.values)
+    tm.assert_series_equal(ser, ser_orig)
+
+
+@pytest.mark.parametrize(
+    "method",
+    [
+        lambda df: df.head(),
+        lambda df: df.head(2),
+        lambda df: df.tail(),
+        lambda df: df.tail(3),
+    ],
+)
+def test_head_tail(method, using_copy_on_write, warn_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+    df2 = method(df)
+    df2._mgr._verify_integrity()
+
+    if using_copy_on_write:
+        # We are explicitly deviating for CoW here to make an eager copy (avoids
+        # tracking references for very cheap ops)
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+        assert not np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+
+    # modify df2 to trigger CoW for that block
+    with tm.assert_cow_warning(warn_copy_on_write):
+        df2.iloc[0, 0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        # without CoW enabled, head and tail return views. Mutating df2 also mutates df.
+        assert np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+        with tm.assert_cow_warning(warn_copy_on_write):
+            df2.iloc[0, 0] = 1
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_infer_objects(using_copy_on_write):
+    df = DataFrame({"a": [1, 2], "b": "c", "c": 1, "d": "x"})
+    df_orig = df.copy()
+    df2 = df.infer_objects()
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+        assert np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+        assert not np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+
+    df2.iloc[0, 0] = 0
+    df2.iloc[0, 1] = "d"
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+        assert not np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_infer_objects_no_reference(using_copy_on_write):
+    df = DataFrame(
+        {
+            "a": [1, 2],
+            "b": "c",
+            "c": 1,
+            "d": Series(
+                [Timestamp("2019-12-31"), Timestamp("2020-12-31")], dtype="object"
+            ),
+            "e": "b",
+        }
+    )
+    df = df.infer_objects()
+
+    arr_a = get_array(df, "a")
+    arr_b = get_array(df, "b")
+    arr_d = get_array(df, "d")
+
+    df.iloc[0, 0] = 0
+    df.iloc[0, 1] = "d"
+    df.iloc[0, 3] = Timestamp("2018-12-31")
+    if using_copy_on_write:
+        assert np.shares_memory(arr_a, get_array(df, "a"))
+        # TODO(CoW): Block splitting causes references here
+        assert not np.shares_memory(arr_b, get_array(df, "b"))
+        assert np.shares_memory(arr_d, get_array(df, "d"))
+
+
+def test_infer_objects_reference(using_copy_on_write):
+    df = DataFrame(
+        {
+            "a": [1, 2],
+            "b": "c",
+            "c": 1,
+            "d": Series(
+                [Timestamp("2019-12-31"), Timestamp("2020-12-31")], dtype="object"
+            ),
+        }
+    )
+    view = df[:]  # noqa: F841
+    df = df.infer_objects()
+
+    arr_a = get_array(df, "a")
+    arr_b = get_array(df, "b")
+    arr_d = get_array(df, "d")
+
+    df.iloc[0, 0] = 0
+    df.iloc[0, 1] = "d"
+    df.iloc[0, 3] = Timestamp("2018-12-31")
+    if using_copy_on_write:
+        assert not np.shares_memory(arr_a, get_array(df, "a"))
+        assert not np.shares_memory(arr_b, get_array(df, "b"))
+        assert np.shares_memory(arr_d, get_array(df, "d"))
+
+
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        {"before": "a", "after": "b", "axis": 1},
+        {"before": 0, "after": 1, "axis": 0},
+    ],
+)
+def test_truncate(using_copy_on_write, kwargs):
+    df = DataFrame({"a": [1, 2, 3], "b": 1, "c": 2})
+    df_orig = df.copy()
+    df2 = df.truncate(**kwargs)
+    df2._mgr._verify_integrity()
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+    df2.iloc[0, 0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize("method", ["assign", "drop_duplicates"])
+def test_assign_drop_duplicates(using_copy_on_write, method):
+    df = DataFrame({"a": [1, 2, 3]})
+    df_orig = df.copy()
+    df2 = getattr(df, method)()
+    df2._mgr._verify_integrity()
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+    df2.iloc[0, 0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize("obj", [Series([1, 2]), DataFrame({"a": [1, 2]})])
+def test_take(using_copy_on_write, obj):
+    # Check that no copy is made when we take all rows in original order
+    obj_orig = obj.copy()
+    obj2 = obj.take([0, 1])
+
+    if using_copy_on_write:
+        assert np.shares_memory(obj2.values, obj.values)
+    else:
+        assert not np.shares_memory(obj2.values, obj.values)
+
+    obj2.iloc[0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(obj2.values, obj.values)
+    tm.assert_equal(obj, obj_orig)
+
+
+@pytest.mark.parametrize("obj", [Series([1, 2]), DataFrame({"a": [1, 2]})])
+def test_between_time(using_copy_on_write, obj):
+    obj.index = date_range("2018-04-09", periods=2, freq="1D20min")
+    obj_orig = obj.copy()
+    obj2 = obj.between_time("0:00", "1:00")
+
+    if using_copy_on_write:
+        assert np.shares_memory(obj2.values, obj.values)
+    else:
+        assert not np.shares_memory(obj2.values, obj.values)
+
+    obj2.iloc[0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(obj2.values, obj.values)
+    tm.assert_equal(obj, obj_orig)
+
+
+def test_reindex_like(using_copy_on_write):
+    df = DataFrame({"a": [1, 2], "b": "a"})
+    other = DataFrame({"b": "a", "a": [1, 2]})
+
+    df_orig = df.copy()
+    df2 = df.reindex_like(other)
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+    df2.iloc[0, 1] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_sort_index(using_copy_on_write):
+    # GH 49473
+    ser = Series([1, 2, 3])
+    ser_orig = ser.copy()
+    ser2 = ser.sort_index()
+
+    if using_copy_on_write:
+        assert np.shares_memory(ser.values, ser2.values)
+    else:
+        assert not np.shares_memory(ser.values, ser2.values)
+
+    # mutating ser triggers a copy-on-write for the column / block
+    ser2.iloc[0] = 0
+    assert not np.shares_memory(ser2.values, ser.values)
+    tm.assert_series_equal(ser, ser_orig)
+
+
+@pytest.mark.parametrize(
+    "obj, kwargs",
+    [(Series([1, 2, 3], name="a"), {}), (DataFrame({"a": [1, 2, 3]}), {"by": "a"})],
+)
+def test_sort_values(using_copy_on_write, obj, kwargs):
+    obj_orig = obj.copy()
+    obj2 = obj.sort_values(**kwargs)
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(obj2, "a"), get_array(obj, "a"))
+    else:
+        assert not np.shares_memory(get_array(obj2, "a"), get_array(obj, "a"))
+
+    # mutating df triggers a copy-on-write for the column / block
+    obj2.iloc[0] = 0
+    assert not np.shares_memory(get_array(obj2, "a"), get_array(obj, "a"))
+    tm.assert_equal(obj, obj_orig)
+
+
+@pytest.mark.parametrize(
+    "obj, kwargs",
+    [(Series([1, 2, 3], name="a"), {}), (DataFrame({"a": [1, 2, 3]}), {"by": "a"})],
+)
+def test_sort_values_inplace(using_copy_on_write, obj, kwargs, warn_copy_on_write):
+    obj_orig = obj.copy()
+    view = obj[:]
+    obj.sort_values(inplace=True, **kwargs)
+
+    assert np.shares_memory(get_array(obj, "a"), get_array(view, "a"))
+
+    # mutating obj triggers a copy-on-write for the column / block
+    with tm.assert_cow_warning(warn_copy_on_write):
+        obj.iloc[0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(obj, "a"), get_array(view, "a"))
+        tm.assert_equal(view, obj_orig)
+    else:
+        assert np.shares_memory(get_array(obj, "a"), get_array(view, "a"))
+
+
+@pytest.mark.parametrize("decimals", [-1, 0, 1])
+def test_round(using_copy_on_write, warn_copy_on_write, decimals):
+    df = DataFrame({"a": [1, 2], "b": "c"})
+    df_orig = df.copy()
+    df2 = df.round(decimals=decimals)
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+        # TODO: Make inplace by using out parameter of ndarray.round?
+        if decimals >= 0:
+            # Ensure lazy copy if no-op
+            assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+        else:
+            assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+    df2.iloc[0, 1] = "d"
+    df2.iloc[0, 0] = 4
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_reorder_levels(using_copy_on_write):
+    index = MultiIndex.from_tuples(
+        [(1, 1), (1, 2), (2, 1), (2, 2)], names=["one", "two"]
+    )
+    df = DataFrame({"a": [1, 2, 3, 4]}, index=index)
+    df_orig = df.copy()
+    df2 = df.reorder_levels(order=["two", "one"])
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+    df2.iloc[0, 0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_series_reorder_levels(using_copy_on_write):
+    index = MultiIndex.from_tuples(
+        [(1, 1), (1, 2), (2, 1), (2, 2)], names=["one", "two"]
+    )
+    ser = Series([1, 2, 3, 4], index=index)
+    ser_orig = ser.copy()
+    ser2 = ser.reorder_levels(order=["two", "one"])
+
+    if using_copy_on_write:
+        assert np.shares_memory(ser2.values, ser.values)
+    else:
+        assert not np.shares_memory(ser2.values, ser.values)
+
+    ser2.iloc[0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(ser2.values, ser.values)
+    tm.assert_series_equal(ser, ser_orig)
+
+
+@pytest.mark.parametrize("obj", [Series([1, 2, 3]), DataFrame({"a": [1, 2, 3]})])
+def test_swaplevel(using_copy_on_write, obj):
+    index = MultiIndex.from_tuples([(1, 1), (1, 2), (2, 1)], names=["one", "two"])
+    obj.index = index
+    obj_orig = obj.copy()
+    obj2 = obj.swaplevel()
+
+    if using_copy_on_write:
+        assert np.shares_memory(obj2.values, obj.values)
+    else:
+        assert not np.shares_memory(obj2.values, obj.values)
+
+    obj2.iloc[0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(obj2.values, obj.values)
+    tm.assert_equal(obj, obj_orig)
+
+
+def test_frame_set_axis(using_copy_on_write):
+    # GH 49473
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [0.1, 0.2, 0.3]})
+    df_orig = df.copy()
+    df2 = df.set_axis(["a", "b", "c"], axis="index")
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+    # mutating df2 triggers a copy-on-write for that column / block
+    df2.iloc[0, 0] = 0
+    assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_series_set_axis(using_copy_on_write):
+    # GH 49473
+    ser = Series([1, 2, 3])
+    ser_orig = ser.copy()
+    ser2 = ser.set_axis(["a", "b", "c"], axis="index")
+
+    if using_copy_on_write:
+        assert np.shares_memory(ser, ser2)
+    else:
+        assert not np.shares_memory(ser, ser2)
+
+    # mutating ser triggers a copy-on-write for the column / block
+    ser2.iloc[0] = 0
+    assert not np.shares_memory(ser2, ser)
+    tm.assert_series_equal(ser, ser_orig)
+
+
+def test_set_flags(using_copy_on_write, warn_copy_on_write):
+    ser = Series([1, 2, 3])
+    ser_orig = ser.copy()
+    ser2 = ser.set_flags(allows_duplicate_labels=False)
+
+    assert np.shares_memory(ser, ser2)
+
+    # mutating ser triggers a copy-on-write for the column / block
+    with tm.assert_cow_warning(warn_copy_on_write):
+        ser2.iloc[0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(ser2, ser)
+        tm.assert_series_equal(ser, ser_orig)
+    else:
+        assert np.shares_memory(ser2, ser)
+        expected = Series([0, 2, 3])
+        tm.assert_series_equal(ser, expected)
+
+
+@pytest.mark.parametrize("kwargs", [{"mapper": "test"}, {"index": "test"}])
+def test_rename_axis(using_copy_on_write, kwargs):
+    df = DataFrame({"a": [1, 2, 3, 4]}, index=Index([1, 2, 3, 4], name="a"))
+    df_orig = df.copy()
+    df2 = df.rename_axis(**kwargs)
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+    df2.iloc[0, 0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize(
+    "func, tz", [("tz_convert", "Europe/Berlin"), ("tz_localize", None)]
+)
+def test_tz_convert_localize(using_copy_on_write, func, tz):
+    # GH 49473
+    ser = Series(
+        [1, 2], index=date_range(start="2014-08-01 09:00", freq="h", periods=2, tz=tz)
+    )
+    ser_orig = ser.copy()
+    ser2 = getattr(ser, func)("US/Central")
+
+    if using_copy_on_write:
+        assert np.shares_memory(ser.values, ser2.values)
+    else:
+        assert not np.shares_memory(ser.values, ser2.values)
+
+    # mutating ser triggers a copy-on-write for the column / block
+    ser2.iloc[0] = 0
+    assert not np.shares_memory(ser2.values, ser.values)
+    tm.assert_series_equal(ser, ser_orig)
+
+
+def test_droplevel(using_copy_on_write):
+    # GH 49473
+    index = MultiIndex.from_tuples([(1, 1), (1, 2), (2, 1)], names=["one", "two"])
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [7, 8, 9]}, index=index)
+    df_orig = df.copy()
+    df2 = df.droplevel(0)
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "c"), get_array(df, "c"))
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "c"), get_array(df, "c"))
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+    # mutating df2 triggers a copy-on-write for that column / block
+    df2.iloc[0, 0] = 0
+
+    assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "b"), get_array(df, "b"))
+
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_squeeze(using_copy_on_write, warn_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3]})
+    df_orig = df.copy()
+    series = df.squeeze()
+
+    # Should share memory regardless of CoW since squeeze is just an iloc
+    assert np.shares_memory(series.values, get_array(df, "a"))
+
+    # mutating squeezed df triggers a copy-on-write for that column/block
+    with tm.assert_cow_warning(warn_copy_on_write):
+        series.iloc[0] = 0
+    if using_copy_on_write:
+        assert not np.shares_memory(series.values, get_array(df, "a"))
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        # Without CoW the original will be modified
+        assert np.shares_memory(series.values, get_array(df, "a"))
+        assert df.loc[0, "a"] == 0
+
+
+def test_items(using_copy_on_write, warn_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [7, 8, 9]})
+    df_orig = df.copy()
+
+    # Test this twice, since the second time, the item cache will be
+    # triggered, and we want to make sure it still works then.
+    for i in range(2):
+        for name, ser in df.items():
+            assert np.shares_memory(get_array(ser, name), get_array(df, name))
+
+            # mutating df triggers a copy-on-write for that column / block
+            with tm.assert_cow_warning(warn_copy_on_write):
+                ser.iloc[0] = 0
+
+            if using_copy_on_write:
+                assert not np.shares_memory(get_array(ser, name), get_array(df, name))
+                tm.assert_frame_equal(df, df_orig)
+            else:
+                # Original frame will be modified
+                assert df.loc[0, name] == 0
+
+
+@pytest.mark.parametrize("dtype", ["int64", "Int64"])
+def test_putmask(using_copy_on_write, dtype, warn_copy_on_write):
+    df = DataFrame({"a": [1, 2], "b": 1, "c": 2}, dtype=dtype)
+    view = df[:]
+    df_orig = df.copy()
+    with tm.assert_cow_warning(warn_copy_on_write):
+        df[df == df] = 5
+
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(view, "a"), get_array(df, "a"))
+        tm.assert_frame_equal(view, df_orig)
+    else:
+        # Without CoW the original will be modified
+        assert np.shares_memory(get_array(view, "a"), get_array(df, "a"))
+        assert view.iloc[0, 0] == 5
+
+
+@pytest.mark.parametrize("dtype", ["int64", "Int64"])
+def test_putmask_no_reference(using_copy_on_write, dtype):
+    df = DataFrame({"a": [1, 2], "b": 1, "c": 2}, dtype=dtype)
+    arr_a = get_array(df, "a")
+    df[df == df] = 5
+
+    if using_copy_on_write:
+        assert np.shares_memory(arr_a, get_array(df, "a"))
+
+
+@pytest.mark.parametrize("dtype", ["float64", "Float64"])
+def test_putmask_aligns_rhs_no_reference(using_copy_on_write, dtype):
+    df = DataFrame({"a": [1.5, 2], "b": 1.5}, dtype=dtype)
+    arr_a = get_array(df, "a")
+    df[df == df] = DataFrame({"a": [5.5, 5]})
+
+    if using_copy_on_write:
+        assert np.shares_memory(arr_a, get_array(df, "a"))
+
+
+@pytest.mark.parametrize(
+    "val, exp, warn", [(5.5, True, FutureWarning), (5, False, None)]
+)
+def test_putmask_dont_copy_some_blocks(
+    using_copy_on_write, val, exp, warn, warn_copy_on_write
+):
+    df = DataFrame({"a": [1, 2], "b": 1, "c": 1.5})
+    view = df[:]
+    df_orig = df.copy()
+    indexer = DataFrame(
+        [[True, False, False], [True, False, False]], columns=list("abc")
+    )
+    if warn_copy_on_write:
+        with tm.assert_cow_warning():
+            df[indexer] = val
+    else:
+        with tm.assert_produces_warning(warn, match="incompatible dtype"):
+            df[indexer] = val
+
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(view, "a"), get_array(df, "a"))
+        # TODO(CoW): Could split blocks to avoid copying the whole block
+        assert np.shares_memory(get_array(view, "b"), get_array(df, "b")) is exp
+        assert np.shares_memory(get_array(view, "c"), get_array(df, "c"))
+        assert df._mgr._has_no_reference(1) is not exp
+        assert not df._mgr._has_no_reference(2)
+        tm.assert_frame_equal(view, df_orig)
+    elif val == 5:
+        # Without CoW the original will be modified, the other case upcasts, e.g. copy
+        assert np.shares_memory(get_array(view, "a"), get_array(df, "a"))
+        assert np.shares_memory(get_array(view, "c"), get_array(df, "c"))
+        assert view.iloc[0, 0] == 5
+
+
+@pytest.mark.parametrize("dtype", ["int64", "Int64"])
+@pytest.mark.parametrize(
+    "func",
+    [
+        lambda ser: ser.where(ser > 0, 10),
+        lambda ser: ser.mask(ser <= 0, 10),
+    ],
+)
+def test_where_mask_noop(using_copy_on_write, dtype, func):
+    ser = Series([1, 2, 3], dtype=dtype)
+    ser_orig = ser.copy()
+
+    result = func(ser)
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(ser), get_array(result))
+    else:
+        assert not np.shares_memory(get_array(ser), get_array(result))
+
+    result.iloc[0] = 10
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(ser), get_array(result))
+    tm.assert_series_equal(ser, ser_orig)
+
+
+@pytest.mark.parametrize("dtype", ["int64", "Int64"])
+@pytest.mark.parametrize(
+    "func",
+    [
+        lambda ser: ser.where(ser < 0, 10),
+        lambda ser: ser.mask(ser >= 0, 10),
+    ],
+)
+def test_where_mask(using_copy_on_write, dtype, func):
+    ser = Series([1, 2, 3], dtype=dtype)
+    ser_orig = ser.copy()
+
+    result = func(ser)
+
+    assert not np.shares_memory(get_array(ser), get_array(result))
+    tm.assert_series_equal(ser, ser_orig)
+
+
+@pytest.mark.parametrize("dtype, val", [("int64", 10.5), ("Int64", 10)])
+@pytest.mark.parametrize(
+    "func",
+    [
+        lambda df, val: df.where(df < 0, val),
+        lambda df, val: df.mask(df >= 0, val),
+    ],
+)
+def test_where_mask_noop_on_single_column(using_copy_on_write, dtype, val, func):
+    df = DataFrame({"a": [1, 2, 3], "b": [-4, -5, -6]}, dtype=dtype)
+    df_orig = df.copy()
+
+    result = func(df, val)
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df, "b"), get_array(result, "b"))
+        assert not np.shares_memory(get_array(df, "a"), get_array(result, "a"))
+    else:
+        assert not np.shares_memory(get_array(df, "b"), get_array(result, "b"))
+
+    result.iloc[0, 1] = 10
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df, "b"), get_array(result, "b"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+@pytest.mark.parametrize("func", ["mask", "where"])
+def test_chained_where_mask(using_copy_on_write, func):
+    df = DataFrame({"a": [1, 4, 2], "b": 1})
+    df_orig = df.copy()
+    if using_copy_on_write:
+        with tm.raises_chained_assignment_error():
+            getattr(df["a"], func)(df["a"] > 2, 5, inplace=True)
+        tm.assert_frame_equal(df, df_orig)
+
+        with tm.raises_chained_assignment_error():
+            getattr(df[["a"]], func)(df["a"] > 2, 5, inplace=True)
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        with tm.assert_produces_warning(FutureWarning, match="inplace method"):
+            getattr(df["a"], func)(df["a"] > 2, 5, inplace=True)
+
+        with tm.assert_produces_warning(None):
+            with option_context("mode.chained_assignment", None):
+                getattr(df[["a"]], func)(df["a"] > 2, 5, inplace=True)
+
+        with tm.assert_produces_warning(None):
+            with option_context("mode.chained_assignment", None):
+                getattr(df[df["a"] > 1], func)(df["a"] > 2, 5, inplace=True)
+
+
+def test_asfreq_noop(using_copy_on_write):
+    df = DataFrame(
+        {"a": [0.0, None, 2.0, 3.0]},
+        index=date_range("1/1/2000", periods=4, freq="min"),
+    )
+    df_orig = df.copy()
+    df2 = df.asfreq(freq="min")
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+    # mutating df2 triggers a copy-on-write for that column / block
+    df2.iloc[0, 0] = 0
+
+    assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_iterrows(using_copy_on_write):
+    df = DataFrame({"a": 0, "b": 1}, index=[1, 2, 3])
+    df_orig = df.copy()
+
+    for _, sub in df.iterrows():
+        sub.iloc[0] = 100
+    if using_copy_on_write:
+        tm.assert_frame_equal(df, df_orig)
+
+
+def test_interpolate_creates_copy(using_copy_on_write, warn_copy_on_write):
+    # GH#51126
+    df = DataFrame({"a": [1.5, np.nan, 3]})
+    view = df[:]
+    expected = df.copy()
+
+    with tm.assert_cow_warning(warn_copy_on_write):
+        df.ffill(inplace=True)
+    with tm.assert_cow_warning(warn_copy_on_write):
+        df.iloc[0, 0] = 100.5
+
+    if using_copy_on_write:
+        tm.assert_frame_equal(view, expected)
+    else:
+        expected = DataFrame({"a": [100.5, 1.5, 3]})
+        tm.assert_frame_equal(view, expected)
+
+
+def test_isetitem(using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [7, 8, 9]})
+    df_orig = df.copy()
+    df2 = df.copy(deep=None)  # Trigger a CoW
+    df2.isetitem(1, np.array([-1, -2, -3]))  # This is inplace
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df, "c"), get_array(df2, "c"))
+        assert np.shares_memory(get_array(df, "a"), get_array(df2, "a"))
+    else:
+        assert not np.shares_memory(get_array(df, "c"), get_array(df2, "c"))
+        assert not np.shares_memory(get_array(df, "a"), get_array(df2, "a"))
+
+    df2.loc[0, "a"] = 0
+    tm.assert_frame_equal(df, df_orig)  # Original is unchanged
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df, "c"), get_array(df2, "c"))
+    else:
+        assert not np.shares_memory(get_array(df, "c"), get_array(df2, "c"))
+
+
+@pytest.mark.parametrize(
+    "dtype", ["int64", "float64"], ids=["single-block", "mixed-block"]
+)
+def test_isetitem_series(using_copy_on_write, dtype):
+    df = DataFrame({"a": [1, 2, 3], "b": np.array([4, 5, 6], dtype=dtype)})
+    ser = Series([7, 8, 9])
+    ser_orig = ser.copy()
+    df.isetitem(0, ser)
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df, "a"), get_array(ser))
+        assert not df._mgr._has_no_reference(0)
+
+    # mutating dataframe doesn't update series
+    df.loc[0, "a"] = 0
+    tm.assert_series_equal(ser, ser_orig)
+
+    # mutating series doesn't update dataframe
+    df = DataFrame({"a": [1, 2, 3], "b": np.array([4, 5, 6], dtype=dtype)})
+    ser = Series([7, 8, 9])
+    df.isetitem(0, ser)
+
+    ser.loc[0] = 0
+    expected = DataFrame({"a": [7, 8, 9], "b": np.array([4, 5, 6], dtype=dtype)})
+    tm.assert_frame_equal(df, expected)
+
+
+def test_isetitem_frame(using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": 1, "c": 2})
+    rhs = DataFrame({"a": [4, 5, 6], "b": 2})
+    df.isetitem([0, 1], rhs)
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df, "a"), get_array(rhs, "a"))
+        assert np.shares_memory(get_array(df, "b"), get_array(rhs, "b"))
+        assert not df._mgr._has_no_reference(0)
+    else:
+        assert not np.shares_memory(get_array(df, "a"), get_array(rhs, "a"))
+        assert not np.shares_memory(get_array(df, "b"), get_array(rhs, "b"))
+    expected = df.copy()
+    rhs.iloc[0, 0] = 100
+    rhs.iloc[0, 1] = 100
+    tm.assert_frame_equal(df, expected)
+
+
+@pytest.mark.parametrize("key", ["a", ["a"]])
+def test_get(using_copy_on_write, warn_copy_on_write, key):
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+    df_orig = df.copy()
+
+    result = df.get(key)
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(result, "a"), get_array(df, "a"))
+        result.iloc[0] = 0
+        assert not np.shares_memory(get_array(result, "a"), get_array(df, "a"))
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        # for non-CoW it depends on whether we got a Series or DataFrame if it
+        # is a view or copy or triggers a warning or not
+        if warn_copy_on_write:
+            warn = FutureWarning if isinstance(key, str) else None
+        else:
+            warn = SettingWithCopyWarning if isinstance(key, list) else None
+        with option_context("chained_assignment", "warn"):
+            with tm.assert_produces_warning(warn):
+                result.iloc[0] = 0
+
+        if isinstance(key, list):
+            tm.assert_frame_equal(df, df_orig)
+        else:
+            assert df.iloc[0, 0] == 0
+
+
+@pytest.mark.parametrize("axis, key", [(0, 0), (1, "a")])
+@pytest.mark.parametrize(
+    "dtype", ["int64", "float64"], ids=["single-block", "mixed-block"]
+)
+def test_xs(
+    using_copy_on_write, warn_copy_on_write, using_array_manager, axis, key, dtype
+):
+    single_block = (dtype == "int64") and not using_array_manager
+    is_view = single_block or (using_array_manager and axis == 1)
+    df = DataFrame(
+        {"a": [1, 2, 3], "b": [4, 5, 6], "c": np.array([7, 8, 9], dtype=dtype)}
+    )
+    df_orig = df.copy()
+
+    result = df.xs(key, axis=axis)
+
+    if axis == 1 or single_block:
+        assert np.shares_memory(get_array(df, "a"), get_array(result))
+    elif using_copy_on_write:
+        assert result._mgr._has_no_reference(0)
+
+    if using_copy_on_write or (is_view and not warn_copy_on_write):
+        result.iloc[0] = 0
+    elif warn_copy_on_write:
+        with tm.assert_cow_warning(single_block or axis == 1):
+            result.iloc[0] = 0
+    else:
+        with option_context("chained_assignment", "warn"):
+            with tm.assert_produces_warning(SettingWithCopyWarning):
+                result.iloc[0] = 0
+
+    if using_copy_on_write or (not single_block and axis == 0):
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        assert df.iloc[0, 0] == 0
+
+
+@pytest.mark.parametrize("axis", [0, 1])
+@pytest.mark.parametrize("key, level", [("l1", 0), (2, 1)])
+def test_xs_multiindex(
+    using_copy_on_write, warn_copy_on_write, using_array_manager, key, level, axis
+):
+    arr = np.arange(18).reshape(6, 3)
+    index = MultiIndex.from_product([["l1", "l2"], [1, 2, 3]], names=["lev1", "lev2"])
+    df = DataFrame(arr, index=index, columns=list("abc"))
+    if axis == 1:
+        df = df.transpose().copy()
+    df_orig = df.copy()
+
+    result = df.xs(key, level=level, axis=axis)
+
+    if level == 0:
+        assert np.shares_memory(
+            get_array(df, df.columns[0]), get_array(result, result.columns[0])
+        )
+
+    if warn_copy_on_write:
+        warn = FutureWarning if level == 0 else None
+    elif not using_copy_on_write and not using_array_manager:
+        warn = SettingWithCopyWarning
+    else:
+        warn = None
+    with option_context("chained_assignment", "warn"):
+        with tm.assert_produces_warning(warn):
+            result.iloc[0, 0] = 0
+
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_update_frame(using_copy_on_write, warn_copy_on_write):
+    df1 = DataFrame({"a": [1.0, 2.0, 3.0], "b": [4.0, 5.0, 6.0]})
+    df2 = DataFrame({"b": [100.0]}, index=[1])
+    df1_orig = df1.copy()
+    view = df1[:]
+
+    # TODO(CoW) better warning message?
+    with tm.assert_cow_warning(warn_copy_on_write):
+        df1.update(df2)
+
+    expected = DataFrame({"a": [1.0, 2.0, 3.0], "b": [4.0, 100.0, 6.0]})
+    tm.assert_frame_equal(df1, expected)
+    if using_copy_on_write:
+        # df1 is updated, but its view not
+        tm.assert_frame_equal(view, df1_orig)
+        assert np.shares_memory(get_array(df1, "a"), get_array(view, "a"))
+        assert not np.shares_memory(get_array(df1, "b"), get_array(view, "b"))
+    else:
+        tm.assert_frame_equal(view, expected)
+
+
+def test_update_series(using_copy_on_write, warn_copy_on_write):
+    ser1 = Series([1.0, 2.0, 3.0])
+    ser2 = Series([100.0], index=[1])
+    ser1_orig = ser1.copy()
+    view = ser1[:]
+
+    if warn_copy_on_write:
+        with tm.assert_cow_warning():
+            ser1.update(ser2)
+    else:
+        ser1.update(ser2)
+
+    expected = Series([1.0, 100.0, 3.0])
+    tm.assert_series_equal(ser1, expected)
+    if using_copy_on_write:
+        # ser1 is updated, but its view not
+        tm.assert_series_equal(view, ser1_orig)
+    else:
+        tm.assert_series_equal(view, expected)
+
+
+def test_update_chained_assignment(using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3]})
+    ser2 = Series([100.0], index=[1])
+    df_orig = df.copy()
+    if using_copy_on_write:
+        with tm.raises_chained_assignment_error():
+            df["a"].update(ser2)
+        tm.assert_frame_equal(df, df_orig)
+
+        with tm.raises_chained_assignment_error():
+            df[["a"]].update(ser2.to_frame())
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        with tm.assert_produces_warning(FutureWarning, match="inplace method"):
+            df["a"].update(ser2)
+
+        with tm.assert_produces_warning(None):
+            with option_context("mode.chained_assignment", None):
+                df[["a"]].update(ser2.to_frame())
+
+        with tm.assert_produces_warning(None):
+            with option_context("mode.chained_assignment", None):
+                df[df["a"] > 1].update(ser2.to_frame())
+
+
+def test_inplace_arithmetic_series(using_copy_on_write):
+    ser = Series([1, 2, 3])
+    ser_orig = ser.copy()
+    data = get_array(ser)
+    ser *= 2
+    if using_copy_on_write:
+        # https://github.com/pandas-dev/pandas/pull/55745
+        # changed to NOT update inplace because there is no benefit (actual
+        # operation already done non-inplace). This was only for the optics
+        # of updating the backing array inplace, but we no longer want to make
+        # that guarantee
+        assert not np.shares_memory(get_array(ser), data)
+        tm.assert_numpy_array_equal(data, get_array(ser_orig))
+    else:
+        assert np.shares_memory(get_array(ser), data)
+        tm.assert_numpy_array_equal(data, get_array(ser))
+
+
+def test_inplace_arithmetic_series_with_reference(
+    using_copy_on_write, warn_copy_on_write
+):
+    ser = Series([1, 2, 3])
+    ser_orig = ser.copy()
+    view = ser[:]
+    with tm.assert_cow_warning(warn_copy_on_write):
+        ser *= 2
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(ser), get_array(view))
+        tm.assert_series_equal(ser_orig, view)
+    else:
+        assert np.shares_memory(get_array(ser), get_array(view))
+
+
+@pytest.mark.parametrize("copy", [True, False])
+def test_transpose(using_copy_on_write, copy, using_array_manager):
+    df = DataFrame({"a": [1, 2, 3], "b": 1})
+    df_orig = df.copy()
+    result = df.transpose(copy=copy)
+
+    if not copy and not using_array_manager or using_copy_on_write:
+        assert np.shares_memory(get_array(df, "a"), get_array(result, 0))
+    else:
+        assert not np.shares_memory(get_array(df, "a"), get_array(result, 0))
+
+    result.iloc[0, 0] = 100
+    if using_copy_on_write:
+        tm.assert_frame_equal(df, df_orig)
+
+
+def test_transpose_different_dtypes(using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": 1.5})
+    df_orig = df.copy()
+    result = df.T
+
+    assert not np.shares_memory(get_array(df, "a"), get_array(result, 0))
+    result.iloc[0, 0] = 100
+    if using_copy_on_write:
+        tm.assert_frame_equal(df, df_orig)
+
+
+def test_transpose_ea_single_column(using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3]}, dtype="Int64")
+    result = df.T
+
+    assert not np.shares_memory(get_array(df, "a"), get_array(result, 0))
+
+
+def test_transform_frame(using_copy_on_write, warn_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": 1})
+    df_orig = df.copy()
+
+    def func(ser):
+        ser.iloc[0] = 100
+        return ser
+
+    with tm.assert_cow_warning(warn_copy_on_write):
+        df.transform(func)
+    if using_copy_on_write:
+        tm.assert_frame_equal(df, df_orig)
+
+
+def test_transform_series(using_copy_on_write, warn_copy_on_write):
+    ser = Series([1, 2, 3])
+    ser_orig = ser.copy()
+
+    def func(ser):
+        ser.iloc[0] = 100
+        return ser
+
+    with tm.assert_cow_warning(warn_copy_on_write):
+        ser.transform(func)
+    if using_copy_on_write:
+        tm.assert_series_equal(ser, ser_orig)
+
+
+def test_count_read_only_array():
+    df = DataFrame({"a": [1, 2], "b": 3})
+    result = df.count()
+    result.iloc[0] = 100
+    expected = Series([100, 2], index=["a", "b"])
+    tm.assert_series_equal(result, expected)
+
+
+def test_series_view(using_copy_on_write, warn_copy_on_write):
+    ser = Series([1, 2, 3])
+    ser_orig = ser.copy()
+
+    with tm.assert_produces_warning(FutureWarning, match="is deprecated"):
+        ser2 = ser.view()
+    assert np.shares_memory(get_array(ser), get_array(ser2))
+    if using_copy_on_write:
+        assert not ser2._mgr._has_no_reference(0)
+
+    with tm.assert_cow_warning(warn_copy_on_write):
+        ser2.iloc[0] = 100
+
+    if using_copy_on_write:
+        tm.assert_series_equal(ser_orig, ser)
+    else:
+        expected = Series([100, 2, 3])
+        tm.assert_series_equal(ser, expected)
+
+
+def test_insert_series(using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3]})
+    ser = Series([1, 2, 3])
+    ser_orig = ser.copy()
+    df.insert(loc=1, value=ser, column="b")
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(ser), get_array(df, "b"))
+        assert not df._mgr._has_no_reference(1)
+    else:
+        assert not np.shares_memory(get_array(ser), get_array(df, "b"))
+
+    df.iloc[0, 1] = 100
+    tm.assert_series_equal(ser, ser_orig)
+
+
+def test_eval(using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": 1})
+    df_orig = df.copy()
+
+    result = df.eval("c = a+b")
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df, "a"), get_array(result, "a"))
+    else:
+        assert not np.shares_memory(get_array(df, "a"), get_array(result, "a"))
+
+    result.iloc[0, 0] = 100
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_eval_inplace(using_copy_on_write, warn_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": 1})
+    df_orig = df.copy()
+    df_view = df[:]
+
+    df.eval("c = a+b", inplace=True)
+    assert np.shares_memory(get_array(df, "a"), get_array(df_view, "a"))
+
+    with tm.assert_cow_warning(warn_copy_on_write):
+        df.iloc[0, 0] = 100
+    if using_copy_on_write:
+        tm.assert_frame_equal(df_view, df_orig)
+
+
+def test_apply_modify_row(using_copy_on_write, warn_copy_on_write):
+    # Case: applying a function on each row as a Series object, where the
+    # function mutates the row object (which needs to trigger CoW if row is a view)
+    df = DataFrame({"A": [1, 2], "B": [3, 4]})
+    df_orig = df.copy()
+
+    def transform(row):
+        row["B"] = 100
+        return row
+
+    with tm.assert_cow_warning(warn_copy_on_write):
+        df.apply(transform, axis=1)
+
+    if using_copy_on_write:
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        assert df.loc[0, "B"] == 100
+
+    # row Series is a copy
+    df = DataFrame({"A": [1, 2], "B": ["b", "c"]})
+    df_orig = df.copy()
+
+    with tm.assert_produces_warning(None):
+        df.apply(transform, axis=1)
+
+    tm.assert_frame_equal(df, df_orig)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_replace.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_replace.py
new file mode 100644
index 0000000000000000000000000000000000000000..6d16bc308388359b69e07d77a5fef153b4eb248f
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_replace.py
@@ -0,0 +1,481 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    Categorical,
+    DataFrame,
+    option_context,
+)
+import pandas._testing as tm
+from pandas.tests.copy_view.util import get_array
+
+
+@pytest.mark.parametrize(
+    "replace_kwargs",
+    [
+        {"to_replace": {"a": 1, "b": 4}, "value": -1},
+        # Test CoW splits blocks to avoid copying unchanged columns
+        {"to_replace": {"a": 1}, "value": -1},
+        {"to_replace": {"b": 4}, "value": -1},
+        {"to_replace": {"b": {4: 1}}},
+        # TODO: Add these in a further optimization
+        # We would need to see which columns got replaced in the mask
+        # which could be expensive
+        # {"to_replace": {"b": 1}},
+        # 1
+    ],
+)
+def test_replace(using_copy_on_write, replace_kwargs):
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": ["foo", "bar", "baz"]})
+    df_orig = df.copy()
+
+    df_replaced = df.replace(**replace_kwargs)
+
+    if using_copy_on_write:
+        if (df_replaced["b"] == df["b"]).all():
+            assert np.shares_memory(get_array(df_replaced, "b"), get_array(df, "b"))
+        assert np.shares_memory(get_array(df_replaced, "c"), get_array(df, "c"))
+
+    # mutating squeezed df triggers a copy-on-write for that column/block
+    df_replaced.loc[0, "c"] = -1
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df_replaced, "c"), get_array(df, "c"))
+
+    if "a" in replace_kwargs["to_replace"]:
+        arr = get_array(df_replaced, "a")
+        df_replaced.loc[0, "a"] = 100
+        assert np.shares_memory(get_array(df_replaced, "a"), arr)
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_replace_regex_inplace_refs(using_copy_on_write, warn_copy_on_write):
+    df = DataFrame({"a": ["aaa", "bbb"]})
+    df_orig = df.copy()
+    view = df[:]
+    arr = get_array(df, "a")
+    with tm.assert_cow_warning(warn_copy_on_write):
+        df.replace(to_replace=r"^a.*$", value="new", inplace=True, regex=True)
+    if using_copy_on_write:
+        assert not np.shares_memory(arr, get_array(df, "a"))
+        assert df._mgr._has_no_reference(0)
+        tm.assert_frame_equal(view, df_orig)
+    else:
+        assert np.shares_memory(arr, get_array(df, "a"))
+
+
+def test_replace_regex_inplace(using_copy_on_write):
+    df = DataFrame({"a": ["aaa", "bbb"]})
+    arr = get_array(df, "a")
+    df.replace(to_replace=r"^a.*$", value="new", inplace=True, regex=True)
+    if using_copy_on_write:
+        assert df._mgr._has_no_reference(0)
+    assert np.shares_memory(arr, get_array(df, "a"))
+
+    df_orig = df.copy()
+    df2 = df.replace(to_replace=r"^b.*$", value="new", regex=True)
+    tm.assert_frame_equal(df_orig, df)
+    assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+
+def test_replace_regex_inplace_no_op(using_copy_on_write):
+    df = DataFrame({"a": [1, 2]})
+    arr = get_array(df, "a")
+    df.replace(to_replace=r"^a.$", value="new", inplace=True, regex=True)
+    if using_copy_on_write:
+        assert df._mgr._has_no_reference(0)
+    assert np.shares_memory(arr, get_array(df, "a"))
+
+    df_orig = df.copy()
+    df2 = df.replace(to_replace=r"^x.$", value="new", regex=True)
+    tm.assert_frame_equal(df_orig, df)
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+
+def test_replace_mask_all_false_second_block(using_copy_on_write):
+    df = DataFrame({"a": [1.5, 2, 3], "b": 100.5, "c": 1, "d": 2})
+    df_orig = df.copy()
+
+    df2 = df.replace(to_replace=1.5, value=55.5)
+
+    if using_copy_on_write:
+        # TODO: Block splitting would allow us to avoid copying b
+        assert np.shares_memory(get_array(df, "c"), get_array(df2, "c"))
+        assert not np.shares_memory(get_array(df, "a"), get_array(df2, "a"))
+
+    else:
+        assert not np.shares_memory(get_array(df, "c"), get_array(df2, "c"))
+        assert not np.shares_memory(get_array(df, "a"), get_array(df2, "a"))
+
+    df2.loc[0, "c"] = 1
+    tm.assert_frame_equal(df, df_orig)  # Original is unchanged
+
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df, "c"), get_array(df2, "c"))
+        # TODO: This should split and not copy the whole block
+        # assert np.shares_memory(get_array(df, "d"), get_array(df2, "d"))
+
+
+def test_replace_coerce_single_column(using_copy_on_write, using_array_manager):
+    df = DataFrame({"a": [1.5, 2, 3], "b": 100.5})
+    df_orig = df.copy()
+
+    df2 = df.replace(to_replace=1.5, value="a")
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df, "b"), get_array(df2, "b"))
+        assert not np.shares_memory(get_array(df, "a"), get_array(df2, "a"))
+
+    elif not using_array_manager:
+        assert np.shares_memory(get_array(df, "b"), get_array(df2, "b"))
+        assert not np.shares_memory(get_array(df, "a"), get_array(df2, "a"))
+
+    if using_copy_on_write:
+        df2.loc[0, "b"] = 0.5
+        tm.assert_frame_equal(df, df_orig)  # Original is unchanged
+        assert not np.shares_memory(get_array(df, "b"), get_array(df2, "b"))
+
+
+def test_replace_to_replace_wrong_dtype(using_copy_on_write):
+    df = DataFrame({"a": [1.5, 2, 3], "b": 100.5})
+    df_orig = df.copy()
+
+    df2 = df.replace(to_replace="xxx", value=1.5)
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df, "b"), get_array(df2, "b"))
+        assert np.shares_memory(get_array(df, "a"), get_array(df2, "a"))
+
+    else:
+        assert not np.shares_memory(get_array(df, "b"), get_array(df2, "b"))
+        assert not np.shares_memory(get_array(df, "a"), get_array(df2, "a"))
+
+    df2.loc[0, "b"] = 0.5
+    tm.assert_frame_equal(df, df_orig)  # Original is unchanged
+
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df, "b"), get_array(df2, "b"))
+
+
+def test_replace_list_categorical(using_copy_on_write):
+    df = DataFrame({"a": ["a", "b", "c"]}, dtype="category")
+    arr = get_array(df, "a")
+    msg = (
+        r"The behavior of Series\.replace \(and DataFrame.replace\) "
+        "with CategoricalDtype"
+    )
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        df.replace(["c"], value="a", inplace=True)
+    assert np.shares_memory(arr.codes, get_array(df, "a").codes)
+    if using_copy_on_write:
+        assert df._mgr._has_no_reference(0)
+
+    df_orig = df.copy()
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        df2 = df.replace(["b"], value="a")
+    assert not np.shares_memory(arr.codes, get_array(df2, "a").codes)
+
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_replace_list_inplace_refs_categorical(using_copy_on_write):
+    df = DataFrame({"a": ["a", "b", "c"]}, dtype="category")
+    view = df[:]
+    df_orig = df.copy()
+    msg = (
+        r"The behavior of Series\.replace \(and DataFrame.replace\) "
+        "with CategoricalDtype"
+    )
+    with tm.assert_produces_warning(FutureWarning, match=msg):
+        df.replace(["c"], value="a", inplace=True)
+    if using_copy_on_write:
+        assert not np.shares_memory(
+            get_array(view, "a").codes, get_array(df, "a").codes
+        )
+        tm.assert_frame_equal(df_orig, view)
+    else:
+        # This could be inplace
+        assert not np.shares_memory(
+            get_array(view, "a").codes, get_array(df, "a").codes
+        )
+
+
+@pytest.mark.parametrize("to_replace", [1.5, [1.5], []])
+def test_replace_inplace(using_copy_on_write, to_replace):
+    df = DataFrame({"a": [1.5, 2, 3]})
+    arr_a = get_array(df, "a")
+    df.replace(to_replace=1.5, value=15.5, inplace=True)
+
+    assert np.shares_memory(get_array(df, "a"), arr_a)
+    if using_copy_on_write:
+        assert df._mgr._has_no_reference(0)
+
+
+@pytest.mark.parametrize("to_replace", [1.5, [1.5]])
+def test_replace_inplace_reference(using_copy_on_write, to_replace, warn_copy_on_write):
+    df = DataFrame({"a": [1.5, 2, 3]})
+    arr_a = get_array(df, "a")
+    view = df[:]
+    with tm.assert_cow_warning(warn_copy_on_write):
+        df.replace(to_replace=to_replace, value=15.5, inplace=True)
+
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df, "a"), arr_a)
+        assert df._mgr._has_no_reference(0)
+        assert view._mgr._has_no_reference(0)
+    else:
+        assert np.shares_memory(get_array(df, "a"), arr_a)
+
+
+@pytest.mark.parametrize("to_replace", ["a", 100.5])
+def test_replace_inplace_reference_no_op(using_copy_on_write, to_replace):
+    df = DataFrame({"a": [1.5, 2, 3]})
+    arr_a = get_array(df, "a")
+    view = df[:]
+    df.replace(to_replace=to_replace, value=15.5, inplace=True)
+
+    assert np.shares_memory(get_array(df, "a"), arr_a)
+    if using_copy_on_write:
+        assert not df._mgr._has_no_reference(0)
+        assert not view._mgr._has_no_reference(0)
+
+
+@pytest.mark.parametrize("to_replace", [1, [1]])
+@pytest.mark.parametrize("val", [1, 1.5])
+def test_replace_categorical_inplace_reference(using_copy_on_write, val, to_replace):
+    df = DataFrame({"a": Categorical([1, 2, 3])})
+    df_orig = df.copy()
+    arr_a = get_array(df, "a")
+    view = df[:]
+    msg = (
+        r"The behavior of Series\.replace \(and DataFrame.replace\) "
+        "with CategoricalDtype"
+    )
+    warn = FutureWarning if val == 1.5 else None
+    with tm.assert_produces_warning(warn, match=msg):
+        df.replace(to_replace=to_replace, value=val, inplace=True)
+
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df, "a").codes, arr_a.codes)
+        assert df._mgr._has_no_reference(0)
+        assert view._mgr._has_no_reference(0)
+        tm.assert_frame_equal(view, df_orig)
+    else:
+        assert np.shares_memory(get_array(df, "a").codes, arr_a.codes)
+
+
+@pytest.mark.parametrize("val", [1, 1.5])
+def test_replace_categorical_inplace(using_copy_on_write, val):
+    df = DataFrame({"a": Categorical([1, 2, 3])})
+    arr_a = get_array(df, "a")
+    msg = (
+        r"The behavior of Series\.replace \(and DataFrame.replace\) "
+        "with CategoricalDtype"
+    )
+    warn = FutureWarning if val == 1.5 else None
+    with tm.assert_produces_warning(warn, match=msg):
+        df.replace(to_replace=1, value=val, inplace=True)
+
+    assert np.shares_memory(get_array(df, "a").codes, arr_a.codes)
+    if using_copy_on_write:
+        assert df._mgr._has_no_reference(0)
+
+    expected = DataFrame({"a": Categorical([val, 2, 3])})
+    tm.assert_frame_equal(df, expected)
+
+
+@pytest.mark.parametrize("val", [1, 1.5])
+def test_replace_categorical(using_copy_on_write, val):
+    df = DataFrame({"a": Categorical([1, 2, 3])})
+    df_orig = df.copy()
+    msg = (
+        r"The behavior of Series\.replace \(and DataFrame.replace\) "
+        "with CategoricalDtype"
+    )
+    warn = FutureWarning if val == 1.5 else None
+    with tm.assert_produces_warning(warn, match=msg):
+        df2 = df.replace(to_replace=1, value=val)
+
+    if using_copy_on_write:
+        assert df._mgr._has_no_reference(0)
+        assert df2._mgr._has_no_reference(0)
+    assert not np.shares_memory(get_array(df, "a").codes, get_array(df2, "a").codes)
+    tm.assert_frame_equal(df, df_orig)
+
+    arr_a = get_array(df2, "a").codes
+    df2.iloc[0, 0] = 2.0
+    assert np.shares_memory(get_array(df2, "a").codes, arr_a)
+
+
+@pytest.mark.parametrize("method", ["where", "mask"])
+def test_masking_inplace(using_copy_on_write, method, warn_copy_on_write):
+    df = DataFrame({"a": [1.5, 2, 3]})
+    df_orig = df.copy()
+    arr_a = get_array(df, "a")
+    view = df[:]
+
+    method = getattr(df, method)
+    if warn_copy_on_write:
+        with tm.assert_cow_warning():
+            method(df["a"] > 1.6, -1, inplace=True)
+    else:
+        method(df["a"] > 1.6, -1, inplace=True)
+
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df, "a"), arr_a)
+        assert df._mgr._has_no_reference(0)
+        assert view._mgr._has_no_reference(0)
+        tm.assert_frame_equal(view, df_orig)
+    else:
+        assert np.shares_memory(get_array(df, "a"), arr_a)
+
+
+def test_replace_empty_list(using_copy_on_write):
+    df = DataFrame({"a": [1, 2]})
+
+    df2 = df.replace([], [])
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+        assert not df._mgr._has_no_reference(0)
+    else:
+        assert not np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+
+    arr_a = get_array(df, "a")
+    df.replace([], [])
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df, "a"), arr_a)
+        assert not df._mgr._has_no_reference(0)
+        assert not df2._mgr._has_no_reference(0)
+
+
+@pytest.mark.parametrize("value", ["d", None])
+def test_replace_object_list_inplace(using_copy_on_write, value):
+    df = DataFrame({"a": ["a", "b", "c"]})
+    arr = get_array(df, "a")
+    df.replace(["c"], value, inplace=True)
+    if using_copy_on_write or value is None:
+        assert np.shares_memory(arr, get_array(df, "a"))
+    else:
+        # This could be inplace
+        assert not np.shares_memory(arr, get_array(df, "a"))
+    if using_copy_on_write:
+        assert df._mgr._has_no_reference(0)
+
+
+def test_replace_list_multiple_elements_inplace(using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3]})
+    arr = get_array(df, "a")
+    df.replace([1, 2], 4, inplace=True)
+    if using_copy_on_write:
+        assert np.shares_memory(arr, get_array(df, "a"))
+        assert df._mgr._has_no_reference(0)
+    else:
+        assert np.shares_memory(arr, get_array(df, "a"))
+
+
+def test_replace_list_none(using_copy_on_write):
+    df = DataFrame({"a": ["a", "b", "c"]})
+
+    df_orig = df.copy()
+    df2 = df.replace(["b"], value=None)
+    tm.assert_frame_equal(df, df_orig)
+
+    assert not np.shares_memory(get_array(df, "a"), get_array(df2, "a"))
+
+
+def test_replace_list_none_inplace_refs(using_copy_on_write, warn_copy_on_write):
+    df = DataFrame({"a": ["a", "b", "c"]})
+    arr = get_array(df, "a")
+    df_orig = df.copy()
+    view = df[:]
+    with tm.assert_cow_warning(warn_copy_on_write):
+        df.replace(["a"], value=None, inplace=True)
+    if using_copy_on_write:
+        assert df._mgr._has_no_reference(0)
+        assert not np.shares_memory(arr, get_array(df, "a"))
+        tm.assert_frame_equal(df_orig, view)
+    else:
+        assert np.shares_memory(arr, get_array(df, "a"))
+
+
+def test_replace_columnwise_no_op_inplace(using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": [1, 2, 3]})
+    view = df[:]
+    df_orig = df.copy()
+    df.replace({"a": 10}, 100, inplace=True)
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(view, "a"), get_array(df, "a"))
+        df.iloc[0, 0] = 100
+        tm.assert_frame_equal(view, df_orig)
+
+
+def test_replace_columnwise_no_op(using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": [1, 2, 3]})
+    df_orig = df.copy()
+    df2 = df.replace({"a": 10}, 100)
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df2, "a"), get_array(df, "a"))
+    df2.iloc[0, 0] = 100
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_replace_chained_assignment(using_copy_on_write):
+    df = DataFrame({"a": [1, np.nan, 2], "b": 1})
+    df_orig = df.copy()
+    if using_copy_on_write:
+        with tm.raises_chained_assignment_error():
+            df["a"].replace(1, 100, inplace=True)
+        tm.assert_frame_equal(df, df_orig)
+
+        with tm.raises_chained_assignment_error():
+            df[["a"]].replace(1, 100, inplace=True)
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        with tm.assert_produces_warning(None):
+            with option_context("mode.chained_assignment", None):
+                df[["a"]].replace(1, 100, inplace=True)
+
+        with tm.assert_produces_warning(None):
+            with option_context("mode.chained_assignment", None):
+                df[df.a > 5].replace(1, 100, inplace=True)
+
+        with tm.assert_produces_warning(FutureWarning, match="inplace method"):
+            df["a"].replace(1, 100, inplace=True)
+
+
+def test_replace_listlike(using_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": [1, 2, 3]})
+    df_orig = df.copy()
+
+    result = df.replace([200, 201], [11, 11])
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(result, "a"), get_array(df, "a"))
+    else:
+        assert not np.shares_memory(get_array(result, "a"), get_array(df, "a"))
+
+    result.iloc[0, 0] = 100
+    tm.assert_frame_equal(df, df)
+
+    result = df.replace([200, 2], [10, 10])
+    assert not np.shares_memory(get_array(df, "a"), get_array(result, "a"))
+    tm.assert_frame_equal(df, df_orig)
+
+
+def test_replace_listlike_inplace(using_copy_on_write, warn_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": [1, 2, 3]})
+    arr = get_array(df, "a")
+    df.replace([200, 2], [10, 11], inplace=True)
+    assert np.shares_memory(get_array(df, "a"), arr)
+
+    view = df[:]
+    df_orig = df.copy()
+    with tm.assert_cow_warning(warn_copy_on_write):
+        df.replace([200, 3], [10, 11], inplace=True)
+    if using_copy_on_write:
+        assert not np.shares_memory(get_array(df, "a"), arr)
+        tm.assert_frame_equal(view, df_orig)
+    else:
+        assert np.shares_memory(get_array(df, "a"), arr)
+        tm.assert_frame_equal(df, view)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_setitem.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_setitem.py
new file mode 100644
index 0000000000000000000000000000000000000000..bc3b939734534520f0cf7051dbc72989d0caf990
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_setitem.py
@@ -0,0 +1,156 @@
+import numpy as np
+
+from pandas import (
+    DataFrame,
+    Index,
+    MultiIndex,
+    RangeIndex,
+    Series,
+)
+import pandas._testing as tm
+from pandas.tests.copy_view.util import get_array
+
+# -----------------------------------------------------------------------------
+# Copy/view behaviour for the values that are set in a DataFrame
+
+
+def test_set_column_with_array():
+    # Case: setting an array as a new column (df[col] = arr) copies that data
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+    arr = np.array([1, 2, 3], dtype="int64")
+
+    df["c"] = arr
+
+    # the array data is copied
+    assert not np.shares_memory(get_array(df, "c"), arr)
+    # and thus modifying the array does not modify the DataFrame
+    arr[0] = 0
+    tm.assert_series_equal(df["c"], Series([1, 2, 3], name="c"))
+
+
+def test_set_column_with_series(using_copy_on_write):
+    # Case: setting a series as a new column (df[col] = s) copies that data
+    # (with delayed copy with CoW)
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+    ser = Series([1, 2, 3])
+
+    df["c"] = ser
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df, "c"), get_array(ser))
+    else:
+        # the series data is copied
+        assert not np.shares_memory(get_array(df, "c"), get_array(ser))
+
+    # and modifying the series does not modify the DataFrame
+    ser.iloc[0] = 0
+    assert ser.iloc[0] == 0
+    tm.assert_series_equal(df["c"], Series([1, 2, 3], name="c"))
+
+
+def test_set_column_with_index(using_copy_on_write):
+    # Case: setting an index as a new column (df[col] = idx) copies that data
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+    idx = Index([1, 2, 3])
+
+    df["c"] = idx
+
+    # the index data is copied
+    assert not np.shares_memory(get_array(df, "c"), idx.values)
+
+    idx = RangeIndex(1, 4)
+    arr = idx.values
+
+    df["d"] = idx
+
+    assert not np.shares_memory(get_array(df, "d"), arr)
+
+
+def test_set_columns_with_dataframe(using_copy_on_write):
+    # Case: setting a DataFrame as new columns copies that data
+    # (with delayed copy with CoW)
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+    df2 = DataFrame({"c": [7, 8, 9], "d": [10, 11, 12]})
+
+    df[["c", "d"]] = df2
+
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(df, "c"), get_array(df2, "c"))
+    else:
+        # the data is copied
+        assert not np.shares_memory(get_array(df, "c"), get_array(df2, "c"))
+
+    # and modifying the set DataFrame does not modify the original DataFrame
+    df2.iloc[0, 0] = 0
+    tm.assert_series_equal(df["c"], Series([7, 8, 9], name="c"))
+
+
+def test_setitem_series_no_copy(using_copy_on_write):
+    # Case: setting a Series as column into a DataFrame can delay copying that data
+    df = DataFrame({"a": [1, 2, 3]})
+    rhs = Series([4, 5, 6])
+    rhs_orig = rhs.copy()
+
+    # adding a new column
+    df["b"] = rhs
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(rhs), get_array(df, "b"))
+
+    df.iloc[0, 1] = 100
+    tm.assert_series_equal(rhs, rhs_orig)
+
+
+def test_setitem_series_no_copy_single_block(using_copy_on_write):
+    # Overwriting an existing column that is a single block
+    df = DataFrame({"a": [1, 2, 3], "b": [0.1, 0.2, 0.3]})
+    rhs = Series([4, 5, 6])
+    rhs_orig = rhs.copy()
+
+    df["a"] = rhs
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(rhs), get_array(df, "a"))
+
+    df.iloc[0, 0] = 100
+    tm.assert_series_equal(rhs, rhs_orig)
+
+
+def test_setitem_series_no_copy_split_block(using_copy_on_write):
+    # Overwriting an existing column that is part of a larger block
+    df = DataFrame({"a": [1, 2, 3], "b": 1})
+    rhs = Series([4, 5, 6])
+    rhs_orig = rhs.copy()
+
+    df["b"] = rhs
+    if using_copy_on_write:
+        assert np.shares_memory(get_array(rhs), get_array(df, "b"))
+
+    df.iloc[0, 1] = 100
+    tm.assert_series_equal(rhs, rhs_orig)
+
+
+def test_setitem_series_column_midx_broadcasting(using_copy_on_write):
+    # Setting a Series to multiple columns will repeat the data
+    # (currently copying the data eagerly)
+    df = DataFrame(
+        [[1, 2, 3], [3, 4, 5]],
+        columns=MultiIndex.from_arrays([["a", "a", "b"], [1, 2, 3]]),
+    )
+    rhs = Series([10, 11])
+    df["a"] = rhs
+    assert not np.shares_memory(get_array(rhs), df._get_column_array(0))
+    if using_copy_on_write:
+        assert df._mgr._has_no_reference(0)
+
+
+def test_set_column_with_inplace_operator(using_copy_on_write, warn_copy_on_write):
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+
+    # this should not raise any warning
+    with tm.assert_produces_warning(None):
+        df["a"] += 1
+
+    # when it is not in a chain, then it should produce a warning
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+    ser = df["a"]
+    with tm.assert_cow_warning(warn_copy_on_write):
+        ser += 1
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_util.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..ff55330d70b28c5459a4c0915dd93c8640a91add
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/test_util.py
@@ -0,0 +1,14 @@
+import numpy as np
+
+from pandas import DataFrame
+from pandas.tests.copy_view.util import get_array
+
+
+def test_get_array_numpy():
+    df = DataFrame({"a": [1, 2, 3]})
+    assert np.shares_memory(get_array(df, "a"), get_array(df, "a"))
+
+
+def test_get_array_masked():
+    df = DataFrame({"a": [1, 2, 3]}, dtype="Int64")
+    assert np.shares_memory(get_array(df, "a"), get_array(df, "a"))
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/util.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/util.py
new file mode 100644
index 0000000000000000000000000000000000000000..969334424936559767b0bca87093acfec52f9763
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/copy_view/util.py
@@ -0,0 +1,30 @@
+from pandas import (
+    Categorical,
+    Index,
+    Series,
+)
+from pandas.core.arrays import BaseMaskedArray
+
+
+def get_array(obj, col=None):
+    """
+    Helper method to get array for a DataFrame column or a Series.
+
+    Equivalent of df[col].values, but without going through normal getitem,
+    which triggers tracking references / CoW (and we might be testing that
+    this is done by some other operation).
+    """
+    if isinstance(obj, Index):
+        arr = obj._values
+    elif isinstance(obj, Series) and (col is None or obj.name == col):
+        arr = obj._values
+    else:
+        assert col is not None
+        icol = obj.columns.get_loc(col)
+        assert isinstance(icol, int)
+        arr = obj._get_column_array(icol)
+    if isinstance(arr, BaseMaskedArray):
+        return arr._data
+    elif isinstance(arr, Categorical):
+        return arr
+    return getattr(arr, "_ndarray", arr)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/__init__.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/__pycache__/test_append.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/__pycache__/test_append.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..972a9f3b3ebff64ed5e7d7d0eaa55a02556fe3cb
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/__pycache__/test_append.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/__pycache__/test_store.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/__pycache__/test_store.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a279431cbff17c3850ae21ec226e6732aabc95f2
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/__pycache__/test_store.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/__pycache__/test_subclass.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/__pycache__/test_subclass.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..deafceaf4397281d71ef7ab00a5e49a7b7a53a1d
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/__pycache__/test_subclass.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/common.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/common.py
new file mode 100644
index 0000000000000000000000000000000000000000..62582b212eb387c94b095ca54029f971dc54e777
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/common.py
@@ -0,0 +1,50 @@
+from collections.abc import Generator
+from contextlib import contextmanager
+import pathlib
+import tempfile
+
+import pytest
+
+from pandas.io.pytables import HDFStore
+
+tables = pytest.importorskip("tables")
+# set these parameters so we don't have file sharing
+tables.parameters.MAX_NUMEXPR_THREADS = 1
+tables.parameters.MAX_BLOSC_THREADS = 1
+tables.parameters.MAX_THREADS = 1
+
+
+def safe_close(store):
+    try:
+        if store is not None:
+            store.close()
+    except OSError:
+        pass
+
+
+# contextmanager to ensure the file cleanup
+@contextmanager
+def ensure_clean_store(
+    path, mode="a", complevel=None, complib=None, fletcher32=False
+) -> Generator[HDFStore, None, None]:
+    with tempfile.TemporaryDirectory() as tmpdirname:
+        tmp_path = pathlib.Path(tmpdirname, path)
+        with HDFStore(
+            tmp_path,
+            mode=mode,
+            complevel=complevel,
+            complib=complib,
+            fletcher32=fletcher32,
+        ) as store:
+            yield store
+
+
+def _maybe_remove(store, key):
+    """
+    For tests using tables, try removing the table to be sure there is
+    no content from previous tests using the same table name.
+    """
+    try:
+        store.remove(key)
+    except (ValueError, KeyError):
+        pass
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/test_append.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/test_append.py
new file mode 100644
index 0000000000000000000000000000000000000000..00a81a4f1f385d044a21b987cfa9c5d2c65d1f0d
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/test_append.py
@@ -0,0 +1,986 @@
+import datetime
+from datetime import timedelta
+import re
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import Timestamp
+import pandas.util._test_decorators as td
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Index,
+    Series,
+    _testing as tm,
+    concat,
+    date_range,
+    read_hdf,
+)
+from pandas.tests.io.pytables.common import (
+    _maybe_remove,
+    ensure_clean_store,
+)
+
+pytestmark = pytest.mark.single_cpu
+
+tables = pytest.importorskip("tables")
+
+
+@pytest.mark.filterwarnings("ignore::tables.NaturalNameWarning")
+def test_append(setup_path):
+    with ensure_clean_store(setup_path) as store:
+        # this is allowed by almost always don't want to do it
+        # tables.NaturalNameWarning):
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((20, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=date_range("2000-01-01", periods=20, freq="B"),
+        )
+        _maybe_remove(store, "df1")
+        store.append("df1", df[:10])
+        store.append("df1", df[10:])
+        tm.assert_frame_equal(store["df1"], df)
+
+        _maybe_remove(store, "df2")
+        store.put("df2", df[:10], format="table")
+        store.append("df2", df[10:])
+        tm.assert_frame_equal(store["df2"], df)
+
+        _maybe_remove(store, "df3")
+        store.append("/df3", df[:10])
+        store.append("/df3", df[10:])
+        tm.assert_frame_equal(store["df3"], df)
+
+        # this is allowed by almost always don't want to do it
+        # tables.NaturalNameWarning
+        _maybe_remove(store, "/df3 foo")
+        store.append("/df3 foo", df[:10])
+        store.append("/df3 foo", df[10:])
+        tm.assert_frame_equal(store["df3 foo"], df)
+
+        # dtype issues - mizxed type in a single object column
+        df = DataFrame(data=[[1, 2], [0, 1], [1, 2], [0, 0]])
+        df["mixed_column"] = "testing"
+        df.loc[2, "mixed_column"] = np.nan
+        _maybe_remove(store, "df")
+        store.append("df", df)
+        tm.assert_frame_equal(store["df"], df)
+
+        # uints - test storage of uints
+        uint_data = DataFrame(
+            {
+                "u08": Series(
+                    np.random.default_rng(2).integers(0, high=255, size=5),
+                    dtype=np.uint8,
+                ),
+                "u16": Series(
+                    np.random.default_rng(2).integers(0, high=65535, size=5),
+                    dtype=np.uint16,
+                ),
+                "u32": Series(
+                    np.random.default_rng(2).integers(0, high=2**30, size=5),
+                    dtype=np.uint32,
+                ),
+                "u64": Series(
+                    [2**58, 2**59, 2**60, 2**61, 2**62],
+                    dtype=np.uint64,
+                ),
+            },
+            index=np.arange(5),
+        )
+        _maybe_remove(store, "uints")
+        store.append("uints", uint_data)
+        tm.assert_frame_equal(store["uints"], uint_data, check_index_type=True)
+
+        # uints - test storage of uints in indexable columns
+        _maybe_remove(store, "uints")
+        # 64-bit indices not yet supported
+        store.append("uints", uint_data, data_columns=["u08", "u16", "u32"])
+        tm.assert_frame_equal(store["uints"], uint_data, check_index_type=True)
+
+
+def test_append_series(setup_path):
+    with ensure_clean_store(setup_path) as store:
+        # basic
+        ss = Series(range(20), dtype=np.float64, index=[f"i_{i}" for i in range(20)])
+        ts = Series(
+            np.arange(10, dtype=np.float64), index=date_range("2020-01-01", periods=10)
+        )
+        ns = Series(np.arange(100))
+
+        store.append("ss", ss)
+        result = store["ss"]
+        tm.assert_series_equal(result, ss)
+        assert result.name is None
+
+        store.append("ts", ts)
+        result = store["ts"]
+        tm.assert_series_equal(result, ts)
+        assert result.name is None
+
+        ns.name = "foo"
+        store.append("ns", ns)
+        result = store["ns"]
+        tm.assert_series_equal(result, ns)
+        assert result.name == ns.name
+
+        # select on the values
+        expected = ns[ns > 60]
+        result = store.select("ns", "foo>60")
+        tm.assert_series_equal(result, expected)
+
+        # select on the index and values
+        expected = ns[(ns > 70) & (ns.index < 90)]
+        result = store.select("ns", "foo>70 and index<90")
+        tm.assert_series_equal(result, expected, check_index_type=True)
+
+        # multi-index
+        mi = DataFrame(np.random.default_rng(2).standard_normal((5, 1)), columns=["A"])
+        mi["B"] = np.arange(len(mi))
+        mi["C"] = "foo"
+        mi.loc[3:5, "C"] = "bar"
+        mi.set_index(["C", "B"], inplace=True)
+        s = mi.stack(future_stack=True)
+        s.index = s.index.droplevel(2)
+        store.append("mi", s)
+        tm.assert_series_equal(store["mi"], s, check_index_type=True)
+
+
+def test_append_some_nans(setup_path):
+    with ensure_clean_store(setup_path) as store:
+        df = DataFrame(
+            {
+                "A": Series(np.random.default_rng(2).standard_normal(20)).astype(
+                    "int32"
+                ),
+                "A1": np.random.default_rng(2).standard_normal(20),
+                "A2": np.random.default_rng(2).standard_normal(20),
+                "B": "foo",
+                "C": "bar",
+                "D": Timestamp("2001-01-01").as_unit("ns"),
+                "E": Timestamp("2001-01-02").as_unit("ns"),
+            },
+            index=np.arange(20),
+        )
+        # some nans
+        _maybe_remove(store, "df1")
+        df.loc[0:15, ["A1", "B", "D", "E"]] = np.nan
+        store.append("df1", df[:10])
+        store.append("df1", df[10:])
+        tm.assert_frame_equal(store["df1"], df, check_index_type=True)
+
+        # first column
+        df1 = df.copy()
+        df1["A1"] = np.nan
+        _maybe_remove(store, "df1")
+        store.append("df1", df1[:10])
+        store.append("df1", df1[10:])
+        tm.assert_frame_equal(store["df1"], df1, check_index_type=True)
+
+        # 2nd column
+        df2 = df.copy()
+        df2["A2"] = np.nan
+        _maybe_remove(store, "df2")
+        store.append("df2", df2[:10])
+        store.append("df2", df2[10:])
+        tm.assert_frame_equal(store["df2"], df2, check_index_type=True)
+
+        # datetimes
+        df3 = df.copy()
+        df3["E"] = np.nan
+        _maybe_remove(store, "df3")
+        store.append("df3", df3[:10])
+        store.append("df3", df3[10:])
+        tm.assert_frame_equal(store["df3"], df3, check_index_type=True)
+
+
+def test_append_all_nans(setup_path):
+    with ensure_clean_store(setup_path) as store:
+        df = DataFrame(
+            {
+                "A1": np.random.default_rng(2).standard_normal(20),
+                "A2": np.random.default_rng(2).standard_normal(20),
+            },
+            index=np.arange(20),
+        )
+        df.loc[0:15, :] = np.nan
+
+        # nan some entire rows (dropna=True)
+        _maybe_remove(store, "df")
+        store.append("df", df[:10], dropna=True)
+        store.append("df", df[10:], dropna=True)
+        tm.assert_frame_equal(store["df"], df[-4:], check_index_type=True)
+
+        # nan some entire rows (dropna=False)
+        _maybe_remove(store, "df2")
+        store.append("df2", df[:10], dropna=False)
+        store.append("df2", df[10:], dropna=False)
+        tm.assert_frame_equal(store["df2"], df, check_index_type=True)
+
+        # tests the option io.hdf.dropna_table
+        with pd.option_context("io.hdf.dropna_table", False):
+            _maybe_remove(store, "df3")
+            store.append("df3", df[:10])
+            store.append("df3", df[10:])
+            tm.assert_frame_equal(store["df3"], df)
+
+        with pd.option_context("io.hdf.dropna_table", True):
+            _maybe_remove(store, "df4")
+            store.append("df4", df[:10])
+            store.append("df4", df[10:])
+            tm.assert_frame_equal(store["df4"], df[-4:])
+
+            # nan some entire rows (string are still written!)
+            df = DataFrame(
+                {
+                    "A1": np.random.default_rng(2).standard_normal(20),
+                    "A2": np.random.default_rng(2).standard_normal(20),
+                    "B": "foo",
+                    "C": "bar",
+                },
+                index=np.arange(20),
+            )
+
+            df.loc[0:15, :] = np.nan
+
+            _maybe_remove(store, "df")
+            store.append("df", df[:10], dropna=True)
+            store.append("df", df[10:], dropna=True)
+            tm.assert_frame_equal(store["df"], df, check_index_type=True)
+
+            _maybe_remove(store, "df2")
+            store.append("df2", df[:10], dropna=False)
+            store.append("df2", df[10:], dropna=False)
+            tm.assert_frame_equal(store["df2"], df, check_index_type=True)
+
+            # nan some entire rows (but since we have dates they are still
+            # written!)
+            df = DataFrame(
+                {
+                    "A1": np.random.default_rng(2).standard_normal(20),
+                    "A2": np.random.default_rng(2).standard_normal(20),
+                    "B": "foo",
+                    "C": "bar",
+                    "D": Timestamp("2001-01-01").as_unit("ns"),
+                    "E": Timestamp("2001-01-02").as_unit("ns"),
+                },
+                index=np.arange(20),
+            )
+
+            df.loc[0:15, :] = np.nan
+
+            _maybe_remove(store, "df")
+            store.append("df", df[:10], dropna=True)
+            store.append("df", df[10:], dropna=True)
+            tm.assert_frame_equal(store["df"], df, check_index_type=True)
+
+            _maybe_remove(store, "df2")
+            store.append("df2", df[:10], dropna=False)
+            store.append("df2", df[10:], dropna=False)
+            tm.assert_frame_equal(store["df2"], df, check_index_type=True)
+
+
+def test_append_frame_column_oriented(setup_path):
+    with ensure_clean_store(setup_path) as store:
+        # column oriented
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=date_range("2000-01-01", periods=10, freq="B"),
+        )
+        df.index = df.index._with_freq(None)  # freq doesn't round-trip
+
+        _maybe_remove(store, "df1")
+        store.append("df1", df.iloc[:, :2], axes=["columns"])
+        store.append("df1", df.iloc[:, 2:])
+        tm.assert_frame_equal(store["df1"], df)
+
+        result = store.select("df1", "columns=A")
+        expected = df.reindex(columns=["A"])
+        tm.assert_frame_equal(expected, result)
+
+        # selection on the non-indexable
+        result = store.select("df1", ("columns=A", "index=df.index[0:4]"))
+        expected = df.reindex(columns=["A"], index=df.index[0:4])
+        tm.assert_frame_equal(expected, result)
+
+        # this isn't supported
+        msg = re.escape(
+            "passing a filterable condition to a non-table indexer "
+            "[Filter: Not Initialized]"
+        )
+        with pytest.raises(TypeError, match=msg):
+            store.select("df1", "columns=A and index>df.index[4]")
+
+
+def test_append_with_different_block_ordering(setup_path):
+    # GH 4096; using same frames, but different block orderings
+    with ensure_clean_store(setup_path) as store:
+        for i in range(10):
+            df = DataFrame(
+                np.random.default_rng(2).standard_normal((10, 2)), columns=list("AB")
+            )
+            df["index"] = range(10)
+            df["index"] += i * 10
+            df["int64"] = Series([1] * len(df), dtype="int64")
+            df["int16"] = Series([1] * len(df), dtype="int16")
+
+            if i % 2 == 0:
+                del df["int64"]
+                df["int64"] = Series([1] * len(df), dtype="int64")
+            if i % 3 == 0:
+                a = df.pop("A")
+                df["A"] = a
+
+            df.set_index("index", inplace=True)
+
+            store.append("df", df)
+
+    # test a different ordering but with more fields (like invalid
+    # combinations)
+    with ensure_clean_store(setup_path) as store:
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 2)),
+            columns=list("AB"),
+            dtype="float64",
+        )
+        df["int64"] = Series([1] * len(df), dtype="int64")
+        df["int16"] = Series([1] * len(df), dtype="int16")
+        store.append("df", df)
+
+        # store additional fields in different blocks
+        df["int16_2"] = Series([1] * len(df), dtype="int16")
+        msg = re.escape(
+            "cannot match existing table structure for [int16] on appending data"
+        )
+        with pytest.raises(ValueError, match=msg):
+            store.append("df", df)
+
+        # store multiple additional fields in different blocks
+        df["float_3"] = Series([1.0] * len(df), dtype="float64")
+        msg = re.escape(
+            "cannot match existing table structure for [A,B] on appending data"
+        )
+        with pytest.raises(ValueError, match=msg):
+            store.append("df", df)
+
+
+def test_append_with_strings(setup_path):
+    with ensure_clean_store(setup_path) as store:
+
+        def check_col(key, name, size):
+            assert (
+                getattr(store.get_storer(key).table.description, name).itemsize == size
+            )
+
+        # avoid truncation on elements
+        df = DataFrame([[123, "asdqwerty"], [345, "dggnhebbsdfbdfb"]])
+        store.append("df_big", df)
+        tm.assert_frame_equal(store.select("df_big"), df)
+        check_col("df_big", "values_block_1", 15)
+
+        # appending smaller string ok
+        df2 = DataFrame([[124, "asdqy"], [346, "dggnhefbdfb"]])
+        store.append("df_big", df2)
+        expected = concat([df, df2])
+        tm.assert_frame_equal(store.select("df_big"), expected)
+        check_col("df_big", "values_block_1", 15)
+
+        # avoid truncation on elements
+        df = DataFrame([[123, "asdqwerty"], [345, "dggnhebbsdfbdfb"]])
+        store.append("df_big2", df, min_itemsize={"values": 50})
+        tm.assert_frame_equal(store.select("df_big2"), df)
+        check_col("df_big2", "values_block_1", 50)
+
+        # bigger string on next append
+        store.append("df_new", df)
+        df_new = DataFrame([[124, "abcdefqhij"], [346, "abcdefghijklmnopqrtsuvwxyz"]])
+        msg = (
+            r"Trying to store a string with len \[26\] in "
+            r"\[values_block_1\] column but\n"
+            r"this column has a limit of \[15\]!\n"
+            "Consider using min_itemsize to preset the sizes on these "
+            "columns"
+        )
+        with pytest.raises(ValueError, match=msg):
+            store.append("df_new", df_new)
+
+        # min_itemsize on Series index (GH 11412)
+        df = DataFrame(
+            {
+                "A": [0.0, 1.0, 2.0, 3.0, 4.0],
+                "B": [0.0, 1.0, 0.0, 1.0, 0.0],
+                "C": Index(["foo1", "foo2", "foo3", "foo4", "foo5"], dtype=object),
+                "D": date_range("20130101", periods=5),
+            }
+        ).set_index("C")
+        store.append("ss", df["B"], min_itemsize={"index": 4})
+        tm.assert_series_equal(store.select("ss"), df["B"])
+
+        # same as above, with data_columns=True
+        store.append("ss2", df["B"], data_columns=True, min_itemsize={"index": 4})
+        tm.assert_series_equal(store.select("ss2"), df["B"])
+
+        # min_itemsize in index without appending (GH 10381)
+        store.put("ss3", df, format="table", min_itemsize={"index": 6})
+        # just make sure there is a longer string:
+        df2 = df.copy().reset_index().assign(C="longer").set_index("C")
+        store.append("ss3", df2)
+        tm.assert_frame_equal(store.select("ss3"), concat([df, df2]))
+
+        # same as above, with a Series
+        store.put("ss4", df["B"], format="table", min_itemsize={"index": 6})
+        store.append("ss4", df2["B"])
+        tm.assert_series_equal(store.select("ss4"), concat([df["B"], df2["B"]]))
+
+        # with nans
+        _maybe_remove(store, "df")
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=date_range("2000-01-01", periods=10, freq="B"),
+        )
+        df["string"] = "foo"
+        df.loc[df.index[1:4], "string"] = np.nan
+        df["string2"] = "bar"
+        df.loc[df.index[4:8], "string2"] = np.nan
+        df["string3"] = "bah"
+        df.loc[df.index[1:], "string3"] = np.nan
+        store.append("df", df)
+        result = store.select("df")
+        tm.assert_frame_equal(result, df)
+
+    with ensure_clean_store(setup_path) as store:
+        df = DataFrame({"A": "foo", "B": "bar"}, index=range(10))
+
+        # a min_itemsize that creates a data_column
+        _maybe_remove(store, "df")
+        store.append("df", df, min_itemsize={"A": 200})
+        check_col("df", "A", 200)
+        assert store.get_storer("df").data_columns == ["A"]
+
+        # a min_itemsize that creates a data_column2
+        _maybe_remove(store, "df")
+        store.append("df", df, data_columns=["B"], min_itemsize={"A": 200})
+        check_col("df", "A", 200)
+        assert store.get_storer("df").data_columns == ["B", "A"]
+
+        # a min_itemsize that creates a data_column2
+        _maybe_remove(store, "df")
+        store.append("df", df, data_columns=["B"], min_itemsize={"values": 200})
+        check_col("df", "B", 200)
+        check_col("df", "values_block_0", 200)
+        assert store.get_storer("df").data_columns == ["B"]
+
+        # infer the .typ on subsequent appends
+        _maybe_remove(store, "df")
+        store.append("df", df[:5], min_itemsize=200)
+        store.append("df", df[5:], min_itemsize=200)
+        tm.assert_frame_equal(store["df"], df)
+
+        # invalid min_itemsize keys
+        df = DataFrame(["foo", "foo", "foo", "barh", "barh", "barh"], columns=["A"])
+        _maybe_remove(store, "df")
+        msg = re.escape(
+            "min_itemsize has the key [foo] which is not an axis or data_column"
+        )
+        with pytest.raises(ValueError, match=msg):
+            store.append("df", df, min_itemsize={"foo": 20, "foobar": 20})
+
+
+def test_append_with_empty_string(setup_path):
+    with ensure_clean_store(setup_path) as store:
+        # with all empty strings (GH 12242)
+        df = DataFrame({"x": ["a", "b", "c", "d", "e", "f", ""]})
+        store.append("df", df[:-1], min_itemsize={"x": 1})
+        store.append("df", df[-1:], min_itemsize={"x": 1})
+        tm.assert_frame_equal(store.select("df"), df)
+
+
+def test_append_with_data_columns(setup_path):
+    with ensure_clean_store(setup_path) as store:
+        df = DataFrame(
+            np.random.default_rng(2).standard_normal((10, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=date_range("2000-01-01", periods=10, freq="B"),
+        )
+        df.iloc[0, df.columns.get_loc("B")] = 1.0
+        _maybe_remove(store, "df")
+        store.append("df", df[:2], data_columns=["B"])
+        store.append("df", df[2:])
+        tm.assert_frame_equal(store["df"], df)
+
+        # check that we have indices created
+        assert store._handle.root.df.table.cols.index.is_indexed is True
+        assert store._handle.root.df.table.cols.B.is_indexed is True
+
+        # data column searching
+        result = store.select("df", "B>0")
+        expected = df[df.B > 0]
+        tm.assert_frame_equal(result, expected)
+
+        # data column searching (with an indexable and a data_columns)
+        result = store.select("df", "B>0 and index>df.index[3]")
+        df_new = df.reindex(index=df.index[4:])
+        expected = df_new[df_new.B > 0]
+        tm.assert_frame_equal(result, expected)
+
+        # data column selection with a string data_column
+        df_new = df.copy()
+        df_new["string"] = "foo"
+        df_new.loc[df_new.index[1:4], "string"] = np.nan
+        df_new.loc[df_new.index[5:6], "string"] = "bar"
+        _maybe_remove(store, "df")
+        store.append("df", df_new, data_columns=["string"])
+        result = store.select("df", "string='foo'")
+        expected = df_new[df_new.string == "foo"]
+        tm.assert_frame_equal(result, expected)
+
+        # using min_itemsize and a data column
+        def check_col(key, name, size):
+            assert (
+                getattr(store.get_storer(key).table.description, name).itemsize == size
+            )
+
+    with ensure_clean_store(setup_path) as store:
+        _maybe_remove(store, "df")
+        store.append("df", df_new, data_columns=["string"], min_itemsize={"string": 30})
+        check_col("df", "string", 30)
+        _maybe_remove(store, "df")
+        store.append("df", df_new, data_columns=["string"], min_itemsize=30)
+        check_col("df", "string", 30)
+        _maybe_remove(store, "df")
+        store.append("df", df_new, data_columns=["string"], min_itemsize={"values": 30})
+        check_col("df", "string", 30)
+
+    with ensure_clean_store(setup_path) as store:
+        df_new["string2"] = "foobarbah"
+        df_new["string_block1"] = "foobarbah1"
+        df_new["string_block2"] = "foobarbah2"
+        _maybe_remove(store, "df")
+        store.append(
+            "df",
+            df_new,
+            data_columns=["string", "string2"],
+            min_itemsize={"string": 30, "string2": 40, "values": 50},
+        )
+        check_col("df", "string", 30)
+        check_col("df", "string2", 40)
+        check_col("df", "values_block_1", 50)
+
+    with ensure_clean_store(setup_path) as store:
+        # multiple data columns
+        df_new = df.copy()
+        df_new.iloc[0, df_new.columns.get_loc("A")] = 1.0
+        df_new.iloc[0, df_new.columns.get_loc("B")] = -1.0
+        df_new["string"] = "foo"
+
+        sl = df_new.columns.get_loc("string")
+        df_new.iloc[1:4, sl] = np.nan
+        df_new.iloc[5:6, sl] = "bar"
+
+        df_new["string2"] = "foo"
+        sl = df_new.columns.get_loc("string2")
+        df_new.iloc[2:5, sl] = np.nan
+        df_new.iloc[7:8, sl] = "bar"
+        _maybe_remove(store, "df")
+        store.append("df", df_new, data_columns=["A", "B", "string", "string2"])
+        result = store.select("df", "string='foo' and string2='foo' and A>0 and B<0")
+        expected = df_new[
+            (df_new.string == "foo")
+            & (df_new.string2 == "foo")
+            & (df_new.A > 0)
+            & (df_new.B < 0)
+        ]
+        tm.assert_frame_equal(result, expected, check_freq=False)
+        # FIXME: 2020-05-07 freq check randomly fails in the CI
+
+        # yield an empty frame
+        result = store.select("df", "string='foo' and string2='cool'")
+        expected = df_new[(df_new.string == "foo") & (df_new.string2 == "cool")]
+        tm.assert_frame_equal(result, expected)
+
+    with ensure_clean_store(setup_path) as store:
+        # doc example
+        df_dc = df.copy()
+        df_dc["string"] = "foo"
+        df_dc.loc[df_dc.index[4:6], "string"] = np.nan
+        df_dc.loc[df_dc.index[7:9], "string"] = "bar"
+        df_dc["string2"] = "cool"
+        df_dc["datetime"] = Timestamp("20010102").as_unit("ns")
+        df_dc.loc[df_dc.index[3:5], ["A", "B", "datetime"]] = np.nan
+
+        _maybe_remove(store, "df_dc")
+        store.append(
+            "df_dc", df_dc, data_columns=["B", "C", "string", "string2", "datetime"]
+        )
+        result = store.select("df_dc", "B>0")
+
+        expected = df_dc[df_dc.B > 0]
+        tm.assert_frame_equal(result, expected)
+
+        result = store.select("df_dc", ["B > 0", "C > 0", "string == foo"])
+        expected = df_dc[(df_dc.B > 0) & (df_dc.C > 0) & (df_dc.string == "foo")]
+        tm.assert_frame_equal(result, expected, check_freq=False)
+        # FIXME: 2020-12-07 intermittent build failures here with freq of
+        #  None instead of BDay(4)
+
+    with ensure_clean_store(setup_path) as store:
+        # doc example part 2
+
+        index = date_range("1/1/2000", periods=8)
+        df_dc = DataFrame(
+            np.random.default_rng(2).standard_normal((8, 3)),
+            index=index,
+            columns=["A", "B", "C"],
+        )
+        df_dc["string"] = "foo"
+        df_dc.loc[df_dc.index[4:6], "string"] = np.nan
+        df_dc.loc[df_dc.index[7:9], "string"] = "bar"
+        df_dc[["B", "C"]] = df_dc[["B", "C"]].abs()
+        df_dc["string2"] = "cool"
+
+        # on-disk operations
+        store.append("df_dc", df_dc, data_columns=["B", "C", "string", "string2"])
+
+        result = store.select("df_dc", "B>0")
+        expected = df_dc[df_dc.B > 0]
+        tm.assert_frame_equal(result, expected)
+
+        result = store.select("df_dc", ["B > 0", "C > 0", 'string == "foo"'])
+        expected = df_dc[(df_dc.B > 0) & (df_dc.C > 0) & (df_dc.string == "foo")]
+        tm.assert_frame_equal(result, expected)
+
+
+def test_append_hierarchical(tmp_path, setup_path, multiindex_dataframe_random_data):
+    df = multiindex_dataframe_random_data
+    df.columns.name = None
+
+    with ensure_clean_store(setup_path) as store:
+        store.append("mi", df)
+        result = store.select("mi")
+        tm.assert_frame_equal(result, df)
+
+        # GH 3748
+        result = store.select("mi", columns=["A", "B"])
+        expected = df.reindex(columns=["A", "B"])
+        tm.assert_frame_equal(result, expected)
+
+    path = tmp_path / "test.hdf"
+    df.to_hdf(path, key="df", format="table")
+    result = read_hdf(path, "df", columns=["A", "B"])
+    expected = df.reindex(columns=["A", "B"])
+    tm.assert_frame_equal(result, expected)
+
+
+def test_append_misc(setup_path):
+    with ensure_clean_store(setup_path) as store:
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
+        store.append("df", df, chunksize=1)
+        result = store.select("df")
+        tm.assert_frame_equal(result, df)
+
+        store.append("df1", df, expectedrows=10)
+        result = store.select("df1")
+        tm.assert_frame_equal(result, df)
+
+
+@pytest.mark.parametrize("chunksize", [10, 200, 1000])
+def test_append_misc_chunksize(setup_path, chunksize):
+    # more chunksize in append tests
+    df = DataFrame(
+        1.1 * np.arange(120).reshape((30, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=Index([f"i-{i}" for i in range(30)], dtype=object),
+    )
+    df["string"] = "foo"
+    df["float322"] = 1.0
+    df["float322"] = df["float322"].astype("float32")
+    df["bool"] = df["float322"] > 0
+    df["time1"] = Timestamp("20130101").as_unit("ns")
+    df["time2"] = Timestamp("20130102").as_unit("ns")
+    with ensure_clean_store(setup_path, mode="w") as store:
+        store.append("obj", df, chunksize=chunksize)
+        result = store.select("obj")
+        tm.assert_frame_equal(result, df)
+
+
+def test_append_misc_empty_frame(setup_path):
+    # empty frame, GH4273
+    with ensure_clean_store(setup_path) as store:
+        # 0 len
+        df_empty = DataFrame(columns=list("ABC"))
+        store.append("df", df_empty)
+        with pytest.raises(KeyError, match="'No object named df in the file'"):
+            store.select("df")
+
+        # repeated append of 0/non-zero frames
+        df = DataFrame(np.random.default_rng(2).random((10, 3)), columns=list("ABC"))
+        store.append("df", df)
+        tm.assert_frame_equal(store.select("df"), df)
+        store.append("df", df_empty)
+        tm.assert_frame_equal(store.select("df"), df)
+
+        # store
+        df = DataFrame(columns=list("ABC"))
+        store.put("df2", df)
+        tm.assert_frame_equal(store.select("df2"), df)
+
+
+# TODO(ArrayManager) currently we rely on falling back to BlockManager, but
+# the conversion from AM->BM converts the invalid object dtype column into
+# a datetime64 column no longer raising an error
+@td.skip_array_manager_not_yet_implemented
+def test_append_raise(setup_path):
+    with ensure_clean_store(setup_path) as store:
+        # test append with invalid input to get good error messages
+
+        # list in column
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
+        df["invalid"] = [["a"]] * len(df)
+        assert df.dtypes["invalid"] == np.object_
+        msg = re.escape(
+            """Cannot serialize the column [invalid]
+because its data contents are not [string] but [mixed] object dtype"""
+        )
+        with pytest.raises(TypeError, match=msg):
+            store.append("df", df)
+
+        # multiple invalid columns
+        df["invalid2"] = [["a"]] * len(df)
+        df["invalid3"] = [["a"]] * len(df)
+        with pytest.raises(TypeError, match=msg):
+            store.append("df", df)
+
+        # datetime with embedded nans as object
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
+        s = Series(datetime.datetime(2001, 1, 2), index=df.index)
+        s = s.astype(object)
+        s[0:5] = np.nan
+        df["invalid"] = s
+        assert df.dtypes["invalid"] == np.object_
+        msg = "too many timezones in this block, create separate data columns"
+        with pytest.raises(TypeError, match=msg):
+            store.append("df", df)
+
+        # directly ndarray
+        msg = "value must be None, Series, or DataFrame"
+        with pytest.raises(TypeError, match=msg):
+            store.append("df", np.arange(10))
+
+        # series directly
+        msg = re.escape(
+            "cannot properly create the storer for: "
+            "[group->df,value-><class 'pandas.core.series.Series'>]"
+        )
+        with pytest.raises(TypeError, match=msg):
+            store.append("df", Series(np.arange(10)))
+
+        # appending an incompatible table
+        df = DataFrame(
+            1.1 * np.arange(120).reshape((30, 4)),
+            columns=Index(list("ABCD"), dtype=object),
+            index=Index([f"i-{i}" for i in range(30)], dtype=object),
+        )
+        store.append("df", df)
+
+        df["foo"] = "foo"
+        msg = re.escape(
+            "invalid combination of [non_index_axes] on appending data "
+            "[(1, ['A', 'B', 'C', 'D', 'foo'])] vs current table "
+            "[(1, ['A', 'B', 'C', 'D'])]"
+        )
+        with pytest.raises(ValueError, match=msg):
+            store.append("df", df)
+
+        # incompatible type (GH 41897)
+        _maybe_remove(store, "df")
+        df["foo"] = Timestamp("20130101")
+        store.append("df", df)
+        df["foo"] = "bar"
+        msg = re.escape(
+            "invalid combination of [values_axes] on appending data "
+            "[name->values_block_1,cname->values_block_1,"
+            "dtype->bytes24,kind->string,shape->(1, 30)] "
+            "vs current table "
+            "[name->values_block_1,cname->values_block_1,"
+            "dtype->datetime64[s],kind->datetime64[s],shape->None]"
+        )
+        with pytest.raises(ValueError, match=msg):
+            store.append("df", df)
+
+
+def test_append_with_timedelta(setup_path):
+    # GH 3577
+    # append timedelta
+
+    ts = Timestamp("20130101").as_unit("ns")
+    df = DataFrame(
+        {
+            "A": ts,
+            "B": [ts + timedelta(days=i, seconds=10) for i in range(10)],
+        }
+    )
+    df["C"] = df["A"] - df["B"]
+    df.loc[3:5, "C"] = np.nan
+
+    with ensure_clean_store(setup_path) as store:
+        # table
+        _maybe_remove(store, "df")
+        store.append("df", df, data_columns=True)
+        result = store.select("df")
+        tm.assert_frame_equal(result, df)
+
+        result = store.select("df", where="C<100000")
+        tm.assert_frame_equal(result, df)
+
+        result = store.select("df", where="C<pd.Timedelta('-3D')")
+        tm.assert_frame_equal(result, df.iloc[3:])
+
+        result = store.select("df", "C<'-3D'")
+        tm.assert_frame_equal(result, df.iloc[3:])
+
+        # a bit hacky here as we don't really deal with the NaT properly
+
+        result = store.select("df", "C<'-500000s'")
+        result = result.dropna(subset=["C"])
+        tm.assert_frame_equal(result, df.iloc[6:])
+
+        result = store.select("df", "C<'-3.5D'")
+        result = result.iloc[1:]
+        tm.assert_frame_equal(result, df.iloc[4:])
+
+        # fixed
+        _maybe_remove(store, "df2")
+        store.put("df2", df)
+        result = store.select("df2")
+        tm.assert_frame_equal(result, df)
+
+
+def test_append_to_multiple(setup_path):
+    df1 = DataFrame(
+        np.random.default_rng(2).standard_normal((10, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=date_range("2000-01-01", periods=10, freq="B"),
+    )
+    df2 = df1.copy().rename(columns="{}_2".format)
+    df2["foo"] = "bar"
+    df = concat([df1, df2], axis=1)
+
+    with ensure_clean_store(setup_path) as store:
+        # exceptions
+        msg = "append_to_multiple requires a selector that is in passed dict"
+        with pytest.raises(ValueError, match=msg):
+            store.append_to_multiple(
+                {"df1": ["A", "B"], "df2": None}, df, selector="df3"
+            )
+
+        with pytest.raises(ValueError, match=msg):
+            store.append_to_multiple({"df1": None, "df2": None}, df, selector="df3")
+
+        msg = (
+            "append_to_multiple must have a dictionary specified as the way to "
+            "split the value"
+        )
+        with pytest.raises(ValueError, match=msg):
+            store.append_to_multiple("df1", df, "df1")
+
+        # regular operation
+        store.append_to_multiple({"df1": ["A", "B"], "df2": None}, df, selector="df1")
+        result = store.select_as_multiple(
+            ["df1", "df2"], where=["A>0", "B>0"], selector="df1"
+        )
+        expected = df[(df.A > 0) & (df.B > 0)]
+        tm.assert_frame_equal(result, expected)
+
+
+def test_append_to_multiple_dropna(setup_path):
+    df1 = DataFrame(
+        np.random.default_rng(2).standard_normal((10, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=date_range("2000-01-01", periods=10, freq="B"),
+    )
+    df2 = DataFrame(
+        np.random.default_rng(2).standard_normal((10, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=date_range("2000-01-01", periods=10, freq="B"),
+    ).rename(columns="{}_2".format)
+    df1.iloc[1, df1.columns.get_indexer(["A", "B"])] = np.nan
+    df = concat([df1, df2], axis=1)
+
+    with ensure_clean_store(setup_path) as store:
+        # dropna=True should guarantee rows are synchronized
+        store.append_to_multiple(
+            {"df1": ["A", "B"], "df2": None}, df, selector="df1", dropna=True
+        )
+        result = store.select_as_multiple(["df1", "df2"])
+        expected = df.dropna()
+        tm.assert_frame_equal(result, expected, check_index_type=True)
+        tm.assert_index_equal(store.select("df1").index, store.select("df2").index)
+
+
+def test_append_to_multiple_dropna_false(setup_path):
+    df1 = DataFrame(
+        np.random.default_rng(2).standard_normal((10, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=date_range("2000-01-01", periods=10, freq="B"),
+    )
+    df2 = df1.copy().rename(columns="{}_2".format)
+    df1.iloc[1, df1.columns.get_indexer(["A", "B"])] = np.nan
+    df = concat([df1, df2], axis=1)
+
+    with ensure_clean_store(setup_path) as store, pd.option_context(
+        "io.hdf.dropna_table", True
+    ):
+        # dropna=False shouldn't synchronize row indexes
+        store.append_to_multiple(
+            {"df1a": ["A", "B"], "df2a": None}, df, selector="df1a", dropna=False
+        )
+
+        msg = "all tables must have exactly the same nrows!"
+        with pytest.raises(ValueError, match=msg):
+            store.select_as_multiple(["df1a", "df2a"])
+
+        assert not store.select("df1a").index.equals(store.select("df2a").index)
+
+
+def test_append_to_multiple_min_itemsize(setup_path):
+    # GH 11238
+    df = DataFrame(
+        {
+            "IX": np.arange(1, 21),
+            "Num": np.arange(1, 21),
+            "BigNum": np.arange(1, 21) * 88,
+            "Str": ["a" for _ in range(20)],
+            "LongStr": ["abcde" for _ in range(20)],
+        }
+    )
+    expected = df.iloc[[0]]
+
+    with ensure_clean_store(setup_path) as store:
+        store.append_to_multiple(
+            {
+                "index": ["IX"],
+                "nums": ["Num", "BigNum"],
+                "strs": ["Str", "LongStr"],
+            },
+            df.iloc[[0]],
+            "index",
+            min_itemsize={"Str": 10, "LongStr": 100, "Num": 2},
+        )
+        result = store.select_as_multiple(["index", "nums", "strs"])
+        tm.assert_frame_equal(result, expected, check_index_type=True)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/test_complex.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/test_complex.py
new file mode 100644
index 0000000000000000000000000000000000000000..c5cac5a5caf090d85d7284103459c6f03d3d41ce
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/test_complex.py
@@ -0,0 +1,195 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+from pandas.tests.io.pytables.common import ensure_clean_store
+
+from pandas.io.pytables import read_hdf
+
+
+def test_complex_fixed(tmp_path, setup_path):
+    df = DataFrame(
+        np.random.default_rng(2).random((4, 5)).astype(np.complex64),
+        index=list("abcd"),
+        columns=list("ABCDE"),
+    )
+
+    path = tmp_path / setup_path
+    df.to_hdf(path, key="df")
+    reread = read_hdf(path, "df")
+    tm.assert_frame_equal(df, reread)
+
+    df = DataFrame(
+        np.random.default_rng(2).random((4, 5)).astype(np.complex128),
+        index=list("abcd"),
+        columns=list("ABCDE"),
+    )
+    path = tmp_path / setup_path
+    df.to_hdf(path, key="df")
+    reread = read_hdf(path, "df")
+    tm.assert_frame_equal(df, reread)
+
+
+def test_complex_table(tmp_path, setup_path):
+    df = DataFrame(
+        np.random.default_rng(2).random((4, 5)).astype(np.complex64),
+        index=list("abcd"),
+        columns=list("ABCDE"),
+    )
+
+    path = tmp_path / setup_path
+    df.to_hdf(path, key="df", format="table")
+    reread = read_hdf(path, key="df")
+    tm.assert_frame_equal(df, reread)
+
+    df = DataFrame(
+        np.random.default_rng(2).random((4, 5)).astype(np.complex128),
+        index=list("abcd"),
+        columns=list("ABCDE"),
+    )
+
+    path = tmp_path / setup_path
+    df.to_hdf(path, key="df", format="table", mode="w")
+    reread = read_hdf(path, "df")
+    tm.assert_frame_equal(df, reread)
+
+
+def test_complex_mixed_fixed(tmp_path, setup_path):
+    complex64 = np.array(
+        [1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j], dtype=np.complex64
+    )
+    complex128 = np.array(
+        [1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j], dtype=np.complex128
+    )
+    df = DataFrame(
+        {
+            "A": [1, 2, 3, 4],
+            "B": ["a", "b", "c", "d"],
+            "C": complex64,
+            "D": complex128,
+            "E": [1.0, 2.0, 3.0, 4.0],
+        },
+        index=list("abcd"),
+    )
+    path = tmp_path / setup_path
+    df.to_hdf(path, key="df")
+    reread = read_hdf(path, "df")
+    tm.assert_frame_equal(df, reread)
+
+
+def test_complex_mixed_table(tmp_path, setup_path):
+    complex64 = np.array(
+        [1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j], dtype=np.complex64
+    )
+    complex128 = np.array(
+        [1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j], dtype=np.complex128
+    )
+    df = DataFrame(
+        {
+            "A": [1, 2, 3, 4],
+            "B": ["a", "b", "c", "d"],
+            "C": complex64,
+            "D": complex128,
+            "E": [1.0, 2.0, 3.0, 4.0],
+        },
+        index=list("abcd"),
+    )
+
+    with ensure_clean_store(setup_path) as store:
+        store.append("df", df, data_columns=["A", "B"])
+        result = store.select("df", where="A>2")
+        tm.assert_frame_equal(df.loc[df.A > 2], result)
+
+    path = tmp_path / setup_path
+    df.to_hdf(path, key="df", format="table")
+    reread = read_hdf(path, "df")
+    tm.assert_frame_equal(df, reread)
+
+
+def test_complex_across_dimensions_fixed(tmp_path, setup_path):
+    complex128 = np.array([1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j])
+    s = Series(complex128, index=list("abcd"))
+    df = DataFrame({"A": s, "B": s})
+
+    objs = [s, df]
+    comps = [tm.assert_series_equal, tm.assert_frame_equal]
+    for obj, comp in zip(objs, comps):
+        path = tmp_path / setup_path
+        obj.to_hdf(path, key="obj", format="fixed")
+        reread = read_hdf(path, "obj")
+        comp(obj, reread)
+
+
+def test_complex_across_dimensions(tmp_path, setup_path):
+    complex128 = np.array([1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j])
+    s = Series(complex128, index=list("abcd"))
+    df = DataFrame({"A": s, "B": s})
+
+    path = tmp_path / setup_path
+    df.to_hdf(path, key="obj", format="table")
+    reread = read_hdf(path, "obj")
+    tm.assert_frame_equal(df, reread)
+
+
+def test_complex_indexing_error(setup_path):
+    complex128 = np.array(
+        [1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j], dtype=np.complex128
+    )
+    df = DataFrame(
+        {"A": [1, 2, 3, 4], "B": ["a", "b", "c", "d"], "C": complex128},
+        index=list("abcd"),
+    )
+
+    msg = (
+        "Columns containing complex values can be stored "
+        "but cannot be indexed when using table format. "
+        "Either use fixed format, set index=False, "
+        "or do not include the columns containing complex "
+        "values to data_columns when initializing the table."
+    )
+
+    with ensure_clean_store(setup_path) as store:
+        with pytest.raises(TypeError, match=msg):
+            store.append("df", df, data_columns=["C"])
+
+
+def test_complex_series_error(tmp_path, setup_path):
+    complex128 = np.array([1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j, 1.0 + 1.0j])
+    s = Series(complex128, index=list("abcd"))
+
+    msg = (
+        "Columns containing complex values can be stored "
+        "but cannot be indexed when using table format. "
+        "Either use fixed format, set index=False, "
+        "or do not include the columns containing complex "
+        "values to data_columns when initializing the table."
+    )
+
+    path = tmp_path / setup_path
+    with pytest.raises(TypeError, match=msg):
+        s.to_hdf(path, key="obj", format="t")
+
+    path = tmp_path / setup_path
+    s.to_hdf(path, key="obj", format="t", index=False)
+    reread = read_hdf(path, "obj")
+    tm.assert_series_equal(s, reread)
+
+
+def test_complex_append(setup_path):
+    df = DataFrame(
+        {
+            "a": np.random.default_rng(2).standard_normal(100).astype(np.complex128),
+            "b": np.random.default_rng(2).standard_normal(100),
+        }
+    )
+
+    with ensure_clean_store(setup_path) as store:
+        store.append("df", df, data_columns=["b"])
+        store.append("df", df)
+        result = store.select("df")
+        tm.assert_frame_equal(pd.concat([df, df], axis=0), result)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/test_read.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/test_read.py
new file mode 100644
index 0000000000000000000000000000000000000000..e4a3ea1fc9db871275f07d1d39f75cc1f91216d2
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/test_read.py
@@ -0,0 +1,412 @@
+from contextlib import closing
+from pathlib import Path
+import re
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslibs import Timestamp
+from pandas.compat import is_platform_windows
+
+import pandas as pd
+from pandas import (
+    DataFrame,
+    HDFStore,
+    Index,
+    Series,
+    _testing as tm,
+    date_range,
+    read_hdf,
+)
+from pandas.tests.io.pytables.common import (
+    _maybe_remove,
+    ensure_clean_store,
+)
+from pandas.util import _test_decorators as td
+
+from pandas.io.pytables import TableIterator
+
+pytestmark = pytest.mark.single_cpu
+
+
+def test_read_missing_key_close_store(tmp_path, setup_path):
+    # GH 25766
+    path = tmp_path / setup_path
+    df = DataFrame({"a": range(2), "b": range(2)})
+    df.to_hdf(path, key="k1")
+
+    with pytest.raises(KeyError, match="'No object named k2 in the file'"):
+        read_hdf(path, "k2")
+
+    # smoke test to test that file is properly closed after
+    # read with KeyError before another write
+    df.to_hdf(path, key="k2")
+
+
+def test_read_index_error_close_store(tmp_path, setup_path):
+    # GH 25766
+    path = tmp_path / setup_path
+    df = DataFrame({"A": [], "B": []}, index=[])
+    df.to_hdf(path, key="k1")
+
+    with pytest.raises(IndexError, match=r"list index out of range"):
+        read_hdf(path, "k1", stop=0)
+
+    # smoke test to test that file is properly closed after
+    # read with IndexError before another write
+    df.to_hdf(path, key="k1")
+
+
+def test_read_missing_key_opened_store(tmp_path, setup_path):
+    # GH 28699
+    path = tmp_path / setup_path
+    df = DataFrame({"a": range(2), "b": range(2)})
+    df.to_hdf(path, key="k1")
+
+    with HDFStore(path, "r") as store:
+        with pytest.raises(KeyError, match="'No object named k2 in the file'"):
+            read_hdf(store, "k2")
+
+        # Test that the file is still open after a KeyError and that we can
+        # still read from it.
+        read_hdf(store, "k1")
+
+
+def test_read_column(setup_path):
+    df = DataFrame(
+        np.random.default_rng(2).standard_normal((10, 4)),
+        columns=Index(list("ABCD"), dtype=object),
+        index=date_range("2000-01-01", periods=10, freq="B"),
+    )
+
+    with ensure_clean_store(setup_path) as store:
+        _maybe_remove(store, "df")
+
+        # GH 17912
+        # HDFStore.select_column should raise a KeyError
+        # exception if the key is not a valid store
+        with pytest.raises(KeyError, match="No object named df in the file"):
+            store.select_column("df", "index")
+
+        store.append("df", df)
+        # error
+        with pytest.raises(
+            KeyError, match=re.escape("'column [foo] not found in the table'")
+        ):
+            store.select_column("df", "foo")
+
+        msg = re.escape("select_column() got an unexpected keyword argument 'where'")
+        with pytest.raises(TypeError, match=msg):
+            store.select_column("df", "index", where=["index>5"])
+
+        # valid
+        result = store.select_column("df", "index")
+        tm.assert_almost_equal(result.values, Series(df.index).values)
+        assert isinstance(result, Series)
+
+        # not a data indexable column
+        msg = re.escape(
+            "column [values_block_0] can not be extracted individually; "
+            "it is not data indexable"
+        )
+        with pytest.raises(ValueError, match=msg):
+            store.select_column("df", "values_block_0")
+
+        # a data column
+        df2 = df.copy()
+        df2["string"] = "foo"
+        store.append("df2", df2, data_columns=["string"])
+        result = store.select_column("df2", "string")
+        tm.assert_almost_equal(result.values, df2["string"].values)
+
+        # a data column with NaNs, result excludes the NaNs
+        df3 = df.copy()
+        df3["string"] = "foo"
+        df3.loc[df3.index[4:6], "string"] = np.nan
+        store.append("df3", df3, data_columns=["string"])
+        result = store.select_column("df3", "string")
+        tm.assert_almost_equal(result.values, df3["string"].values)
+
+        # start/stop
+        result = store.select_column("df3", "string", start=2)
+        tm.assert_almost_equal(result.values, df3["string"].values[2:])
+
+        result = store.select_column("df3", "string", start=-2)
+        tm.assert_almost_equal(result.values, df3["string"].values[-2:])
+
+        result = store.select_column("df3", "string", stop=2)
+        tm.assert_almost_equal(result.values, df3["string"].values[:2])
+
+        result = store.select_column("df3", "string", stop=-2)
+        tm.assert_almost_equal(result.values, df3["string"].values[:-2])
+
+        result = store.select_column("df3", "string", start=2, stop=-2)
+        tm.assert_almost_equal(result.values, df3["string"].values[2:-2])
+
+        result = store.select_column("df3", "string", start=-2, stop=2)
+        tm.assert_almost_equal(result.values, df3["string"].values[-2:2])
+
+        # GH 10392 - make sure column name is preserved
+        df4 = DataFrame({"A": np.random.default_rng(2).standard_normal(10), "B": "foo"})
+        store.append("df4", df4, data_columns=True)
+        expected = df4["B"]
+        result = store.select_column("df4", "B")
+        tm.assert_series_equal(result, expected)
+
+
+def test_pytables_native_read(datapath):
+    with ensure_clean_store(
+        datapath("io", "data", "legacy_hdf/pytables_native.h5"), mode="r"
+    ) as store:
+        d2 = store["detector/readout"]
+    assert isinstance(d2, DataFrame)
+
+
+@pytest.mark.skipif(is_platform_windows(), reason="native2 read fails oddly on windows")
+def test_pytables_native2_read(datapath):
+    with ensure_clean_store(
+        datapath("io", "data", "legacy_hdf", "pytables_native2.h5"), mode="r"
+    ) as store:
+        str(store)
+        d1 = store["detector"]
+    assert isinstance(d1, DataFrame)
+
+
+def test_legacy_table_fixed_format_read_py2(datapath):
+    # GH 24510
+    # legacy table with fixed format written in Python 2
+    with ensure_clean_store(
+        datapath("io", "data", "legacy_hdf", "legacy_table_fixed_py2.h5"), mode="r"
+    ) as store:
+        result = store.select("df")
+    expected = DataFrame(
+        [[1, 2, 3, "D"]],
+        columns=["A", "B", "C", "D"],
+        index=Index(["ABC"], name="INDEX_NAME"),
+    )
+    tm.assert_frame_equal(expected, result)
+
+
+def test_legacy_table_fixed_format_read_datetime_py2(datapath):
+    # GH 31750
+    # legacy table with fixed format and datetime64 column written in Python 2
+    expected = DataFrame(
+        [[Timestamp("2020-02-06T18:00")]],
+        columns=["A"],
+        index=Index(["date"]),
+        dtype="M8[ns]",
+    )
+    with ensure_clean_store(
+        datapath("io", "data", "legacy_hdf", "legacy_table_fixed_datetime_py2.h5"),
+        mode="r",
+    ) as store:
+        result = store.select("df")
+    tm.assert_frame_equal(expected, result)
+
+
+def test_legacy_table_read_py2(datapath):
+    # issue: 24925
+    # legacy table written in Python 2
+    with ensure_clean_store(
+        datapath("io", "data", "legacy_hdf", "legacy_table_py2.h5"), mode="r"
+    ) as store:
+        result = store.select("table")
+
+    expected = DataFrame({"a": ["a", "b"], "b": [2, 3]})
+    tm.assert_frame_equal(expected, result)
+
+
+def test_read_hdf_open_store(tmp_path, setup_path):
+    # GH10330
+    # No check for non-string path_or-buf, and no test of open store
+    df = DataFrame(
+        np.random.default_rng(2).random((4, 5)),
+        index=list("abcd"),
+        columns=list("ABCDE"),
+    )
+    df.index.name = "letters"
+    df = df.set_index(keys="E", append=True)
+
+    path = tmp_path / setup_path
+    df.to_hdf(path, key="df", mode="w")
+    direct = read_hdf(path, "df")
+    with HDFStore(path, mode="r") as store:
+        indirect = read_hdf(store, "df")
+        tm.assert_frame_equal(direct, indirect)
+        assert store.is_open
+
+
+def test_read_hdf_index_not_view(tmp_path, setup_path):
+    # GH 37441
+    # Ensure that the index of the DataFrame is not a view
+    # into the original recarray that pytables reads in
+    df = DataFrame(
+        np.random.default_rng(2).random((4, 5)),
+        index=[0, 1, 2, 3],
+        columns=list("ABCDE"),
+    )
+
+    path = tmp_path / setup_path
+    df.to_hdf(path, key="df", mode="w", format="table")
+
+    df2 = read_hdf(path, "df")
+    assert df2.index._data.base is None
+    tm.assert_frame_equal(df, df2)
+
+
+def test_read_hdf_iterator(tmp_path, setup_path):
+    df = DataFrame(
+        np.random.default_rng(2).random((4, 5)),
+        index=list("abcd"),
+        columns=list("ABCDE"),
+    )
+    df.index.name = "letters"
+    df = df.set_index(keys="E", append=True)
+
+    path = tmp_path / setup_path
+    df.to_hdf(path, key="df", mode="w", format="t")
+    direct = read_hdf(path, "df")
+    iterator = read_hdf(path, "df", iterator=True)
+    with closing(iterator.store):
+        assert isinstance(iterator, TableIterator)
+        indirect = next(iterator.__iter__())
+    tm.assert_frame_equal(direct, indirect)
+
+
+def test_read_nokey(tmp_path, setup_path):
+    # GH10443
+    df = DataFrame(
+        np.random.default_rng(2).random((4, 5)),
+        index=list("abcd"),
+        columns=list("ABCDE"),
+    )
+
+    # Categorical dtype not supported for "fixed" format. So no need
+    # to test with that dtype in the dataframe here.
+    path = tmp_path / setup_path
+    df.to_hdf(path, key="df", mode="a")
+    reread = read_hdf(path)
+    tm.assert_frame_equal(df, reread)
+    df.to_hdf(path, key="df2", mode="a")
+
+    msg = "key must be provided when HDF5 file contains multiple datasets."
+    with pytest.raises(ValueError, match=msg):
+        read_hdf(path)
+
+
+def test_read_nokey_table(tmp_path, setup_path):
+    # GH13231
+    df = DataFrame({"i": range(5), "c": Series(list("abacd"), dtype="category")})
+
+    path = tmp_path / setup_path
+    df.to_hdf(path, key="df", mode="a", format="table")
+    reread = read_hdf(path)
+    tm.assert_frame_equal(df, reread)
+    df.to_hdf(path, key="df2", mode="a", format="table")
+
+    msg = "key must be provided when HDF5 file contains multiple datasets."
+    with pytest.raises(ValueError, match=msg):
+        read_hdf(path)
+
+
+def test_read_nokey_empty(tmp_path, setup_path):
+    path = tmp_path / setup_path
+    store = HDFStore(path)
+    store.close()
+    msg = re.escape(
+        "Dataset(s) incompatible with Pandas data types, not table, or no "
+        "datasets found in HDF5 file."
+    )
+    with pytest.raises(ValueError, match=msg):
+        read_hdf(path)
+
+
+def test_read_from_pathlib_path(tmp_path, setup_path):
+    # GH11773
+    expected = DataFrame(
+        np.random.default_rng(2).random((4, 5)),
+        index=list("abcd"),
+        columns=list("ABCDE"),
+    )
+    filename = tmp_path / setup_path
+    path_obj = Path(filename)
+
+    expected.to_hdf(path_obj, key="df", mode="a")
+    actual = read_hdf(path_obj, key="df")
+
+    tm.assert_frame_equal(expected, actual)
+
+
+@td.skip_if_no("py.path")
+def test_read_from_py_localpath(tmp_path, setup_path):
+    # GH11773
+    from py.path import local as LocalPath
+
+    expected = DataFrame(
+        np.random.default_rng(2).random((4, 5)),
+        index=list("abcd"),
+        columns=list("ABCDE"),
+    )
+    filename = tmp_path / setup_path
+    path_obj = LocalPath(filename)
+
+    expected.to_hdf(path_obj, key="df", mode="a")
+    actual = read_hdf(path_obj, key="df")
+
+    tm.assert_frame_equal(expected, actual)
+
+
+@pytest.mark.parametrize("format", ["fixed", "table"])
+def test_read_hdf_series_mode_r(tmp_path, format, setup_path):
+    # GH 16583
+    # Tests that reading a Series saved to an HDF file
+    # still works if a mode='r' argument is supplied
+    series = Series(range(10), dtype=np.float64)
+    path = tmp_path / setup_path
+    series.to_hdf(path, key="data", format=format)
+    result = read_hdf(path, key="data", mode="r")
+    tm.assert_series_equal(result, series)
+
+
+@pytest.mark.filterwarnings(r"ignore:Period with BDay freq is deprecated:FutureWarning")
+@pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
+def test_read_py2_hdf_file_in_py3(datapath):
+    # GH 16781
+
+    # tests reading a PeriodIndex DataFrame written in Python2 in Python3
+
+    # the file was generated in Python 2.7 like so:
+    #
+    # df = DataFrame([1.,2,3], index=pd.PeriodIndex(
+    #              ['2015-01-01', '2015-01-02', '2015-01-05'], freq='B'))
+    # df.to_hdf('periodindex_0.20.1_x86_64_darwin_2.7.13.h5', 'p')
+
+    expected = DataFrame(
+        [1.0, 2, 3],
+        index=pd.PeriodIndex(["2015-01-01", "2015-01-02", "2015-01-05"], freq="B"),
+    )
+
+    with ensure_clean_store(
+        datapath(
+            "io", "data", "legacy_hdf", "periodindex_0.20.1_x86_64_darwin_2.7.13.h5"
+        ),
+        mode="r",
+    ) as store:
+        result = store["p"]
+    tm.assert_frame_equal(result, expected)
+
+
+def test_read_infer_string(tmp_path, setup_path):
+    # GH#54431
+    pytest.importorskip("pyarrow")
+    df = DataFrame({"a": ["a", "b", None]})
+    path = tmp_path / setup_path
+    df.to_hdf(path, key="data", format="table")
+    with pd.option_context("future.infer_string", True):
+        result = read_hdf(path, key="data", mode="r")
+    expected = DataFrame(
+        {"a": ["a", "b", None]},
+        dtype="string[pyarrow_numpy]",
+        columns=Index(["a"], dtype="string[pyarrow_numpy]"),
+    )
+    tm.assert_frame_equal(result, expected)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/test_retain_attributes.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/test_retain_attributes.py
new file mode 100644
index 0000000000000000000000000000000000000000..6284b826c3cf01fed6ce50e5519f6c2f543b8c64
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/test_retain_attributes.py
@@ -0,0 +1,92 @@
+import pytest
+
+from pandas import (
+    DataFrame,
+    DatetimeIndex,
+    Series,
+    _testing as tm,
+    date_range,
+    errors,
+    read_hdf,
+)
+from pandas.tests.io.pytables.common import (
+    _maybe_remove,
+    ensure_clean_store,
+)
+
+pytestmark = pytest.mark.single_cpu
+
+
+def test_retain_index_attributes(setup_path, unit):
+    # GH 3499, losing frequency info on index recreation
+    dti = date_range("2000-1-1", periods=3, freq="h", unit=unit)
+    df = DataFrame({"A": Series(range(3), index=dti)})
+
+    with ensure_clean_store(setup_path) as store:
+        _maybe_remove(store, "data")
+        store.put("data", df, format="table")
+
+        result = store.get("data")
+        tm.assert_frame_equal(df, result)
+
+        for attr in ["freq", "tz", "name"]:
+            for idx in ["index", "columns"]:
+                assert getattr(getattr(df, idx), attr, None) == getattr(
+                    getattr(result, idx), attr, None
+                )
+
+        dti2 = date_range("2002-1-1", periods=3, freq="D", unit=unit)
+        # try to append a table with a different frequency
+        with tm.assert_produces_warning(errors.AttributeConflictWarning):
+            df2 = DataFrame({"A": Series(range(3), index=dti2)})
+            store.append("data", df2)
+
+        assert store.get_storer("data").info["index"]["freq"] is None
+
+        # this is ok
+        _maybe_remove(store, "df2")
+        dti3 = DatetimeIndex(
+            ["2001-01-01", "2001-01-02", "2002-01-01"], dtype=f"M8[{unit}]"
+        )
+        df2 = DataFrame(
+            {
+                "A": Series(
+                    range(3),
+                    index=dti3,
+                )
+            }
+        )
+        store.append("df2", df2)
+        dti4 = date_range("2002-1-1", periods=3, freq="D", unit=unit)
+        df3 = DataFrame({"A": Series(range(3), index=dti4)})
+        store.append("df2", df3)
+
+
+def test_retain_index_attributes2(tmp_path, setup_path):
+    path = tmp_path / setup_path
+
+    with tm.assert_produces_warning(errors.AttributeConflictWarning):
+        df = DataFrame(
+            {"A": Series(range(3), index=date_range("2000-1-1", periods=3, freq="h"))}
+        )
+        df.to_hdf(path, key="data", mode="w", append=True)
+        df2 = DataFrame(
+            {"A": Series(range(3), index=date_range("2002-1-1", periods=3, freq="D"))}
+        )
+
+        df2.to_hdf(path, key="data", append=True)
+
+        idx = date_range("2000-1-1", periods=3, freq="h")
+        idx.name = "foo"
+        df = DataFrame({"A": Series(range(3), index=idx)})
+        df.to_hdf(path, key="data", mode="w", append=True)
+
+    assert read_hdf(path, key="data").index.name == "foo"
+
+    with tm.assert_produces_warning(errors.AttributeConflictWarning):
+        idx2 = date_range("2001-1-1", periods=3, freq="h")
+        idx2.name = "bar"
+        df2 = DataFrame({"A": Series(range(3), index=idx2)})
+        df2.to_hdf(path, key="data", append=True)
+
+    assert read_hdf(path, "data").index.name is None
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/test_subclass.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/test_subclass.py
new file mode 100644
index 0000000000000000000000000000000000000000..03622faa2b5a8f65d709c23cab23fd3680084cb4
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/io/pytables/test_subclass.py
@@ -0,0 +1,52 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+
+from pandas.io.pytables import (
+    HDFStore,
+    read_hdf,
+)
+
+pytest.importorskip("tables")
+
+
+class TestHDFStoreSubclass:
+    # GH 33748
+    def test_supported_for_subclass_dataframe(self, tmp_path):
+        data = {"a": [1, 2], "b": [3, 4]}
+        sdf = tm.SubclassedDataFrame(data, dtype=np.intp)
+
+        expected = DataFrame(data, dtype=np.intp)
+
+        path = tmp_path / "temp.h5"
+        sdf.to_hdf(path, key="df")
+        result = read_hdf(path, "df")
+        tm.assert_frame_equal(result, expected)
+
+        path = tmp_path / "temp.h5"
+        with HDFStore(path) as store:
+            store.put("df", sdf)
+        result = read_hdf(path, "df")
+        tm.assert_frame_equal(result, expected)
+
+    def test_supported_for_subclass_series(self, tmp_path):
+        data = [1, 2, 3]
+        sser = tm.SubclassedSeries(data, dtype=np.intp)
+
+        expected = Series(data, dtype=np.intp)
+
+        path = tmp_path / "temp.h5"
+        sser.to_hdf(path, key="ser")
+        result = read_hdf(path, "ser")
+        tm.assert_series_equal(result, expected)
+
+        path = tmp_path / "temp.h5"
+        with HDFStore(path) as store:
+            store.put("ser", sser)
+        result = read_hdf(path, "ser")
+        tm.assert_series_equal(result, expected)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/plotting/__pycache__/test_boxplot_method.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/plotting/__pycache__/test_boxplot_method.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4a14df985dad5676a4d9f139305866d0b5861dec
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/plotting/__pycache__/test_boxplot_method.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/plotting/__pycache__/test_hist_method.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/plotting/__pycache__/test_hist_method.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8534510af785d6733f921b2b95a41516eceb1900
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/plotting/__pycache__/test_hist_method.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/plotting/__pycache__/test_misc.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/plotting/__pycache__/test_misc.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e6307a2a1b614573918f4cdc99bb2e72ec3c8e9b
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/plotting/__pycache__/test_misc.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/plotting/__pycache__/test_series.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/plotting/__pycache__/test_series.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..135f061c1c8ef58d9eedb19b1f3c1dc112418f87
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/plotting/__pycache__/test_series.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/plotting/__pycache__/test_style.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/plotting/__pycache__/test_style.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f1c00a70b028761eacbcc0efdfc2de7b061d443c
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/plotting/__pycache__/test_style.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/__init__.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_almost_equal.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_almost_equal.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b0a72a2f3f43762056327fc40bdc2f969152b1a7
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_almost_equal.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_categorical_equal.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_categorical_equal.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..88228cf29940a15dbdd9788618918f891cae7fe0
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_categorical_equal.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_numpy_array_equal.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_numpy_array_equal.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e77c4267a50cf679f3936407043cf26950a8999a
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_assert_numpy_array_equal.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_deprecate.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_deprecate.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c952d1f7fa511b599208847ca40bec91ff717d72
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_deprecate.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_doc.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_doc.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..38ad394a362262c7f1164ad27a0acdc287b0db5c
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_doc.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_rewrite_warning.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_rewrite_warning.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..df403fd58aac1c0f34e638f958422f53585a6e76
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_rewrite_warning.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_show_versions.cpython-310.pyc b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_show_versions.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..95b9a5949dfeca2ca8b63676e01c5ae466587ec2
Binary files /dev/null and b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/__pycache__/test_show_versions.cpython-310.pyc differ
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/conftest.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/conftest.py
new file mode 100644
index 0000000000000000000000000000000000000000..b68bcc93431d015a5b9bdc47bdd7e46dd531b703
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/conftest.py
@@ -0,0 +1,26 @@
+import pytest
+
+
+@pytest.fixture(params=[True, False])
+def check_dtype(request):
+    return request.param
+
+
+@pytest.fixture(params=[True, False])
+def check_exact(request):
+    return request.param
+
+
+@pytest.fixture(params=[True, False])
+def check_index_type(request):
+    return request.param
+
+
+@pytest.fixture(params=[0.5e-3, 0.5e-5])
+def rtol(request):
+    return request.param
+
+
+@pytest.fixture(params=[True, False])
+def check_categorical(request):
+    return request.param
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_assert_almost_equal.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_assert_almost_equal.py
new file mode 100644
index 0000000000000000000000000000000000000000..4e692084f7352f873b8c7354e7651b432058a1a5
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_assert_almost_equal.py
@@ -0,0 +1,586 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    NA,
+    DataFrame,
+    Index,
+    NaT,
+    Series,
+    Timestamp,
+)
+import pandas._testing as tm
+
+
+def _assert_almost_equal_both(a, b, **kwargs):
+    """
+    Check that two objects are approximately equal.
+
+    This check is performed commutatively.
+
+    Parameters
+    ----------
+    a : object
+        The first object to compare.
+    b : object
+        The second object to compare.
+    **kwargs
+        The arguments passed to `tm.assert_almost_equal`.
+    """
+    tm.assert_almost_equal(a, b, **kwargs)
+    tm.assert_almost_equal(b, a, **kwargs)
+
+
+def _assert_not_almost_equal(a, b, **kwargs):
+    """
+    Check that two objects are not approximately equal.
+
+    Parameters
+    ----------
+    a : object
+        The first object to compare.
+    b : object
+        The second object to compare.
+    **kwargs
+        The arguments passed to `tm.assert_almost_equal`.
+    """
+    try:
+        tm.assert_almost_equal(a, b, **kwargs)
+        msg = f"{a} and {b} were approximately equal when they shouldn't have been"
+        pytest.fail(reason=msg)
+    except AssertionError:
+        pass
+
+
+def _assert_not_almost_equal_both(a, b, **kwargs):
+    """
+    Check that two objects are not approximately equal.
+
+    This check is performed commutatively.
+
+    Parameters
+    ----------
+    a : object
+        The first object to compare.
+    b : object
+        The second object to compare.
+    **kwargs
+        The arguments passed to `tm.assert_almost_equal`.
+    """
+    _assert_not_almost_equal(a, b, **kwargs)
+    _assert_not_almost_equal(b, a, **kwargs)
+
+
+@pytest.mark.parametrize(
+    "a,b",
+    [
+        (1.1, 1.1),
+        (1.1, 1.100001),
+        (np.int16(1), 1.000001),
+        (np.float64(1.1), 1.1),
+        (np.uint32(5), 5),
+    ],
+)
+def test_assert_almost_equal_numbers(a, b):
+    _assert_almost_equal_both(a, b)
+
+
+@pytest.mark.parametrize(
+    "a,b",
+    [
+        (1.1, 1),
+        (1.1, True),
+        (1, 2),
+        (1.0001, np.int16(1)),
+        # The following two examples are not "almost equal" due to tol.
+        (0.1, 0.1001),
+        (0.0011, 0.0012),
+    ],
+)
+def test_assert_not_almost_equal_numbers(a, b):
+    _assert_not_almost_equal_both(a, b)
+
+
+@pytest.mark.parametrize(
+    "a,b",
+    [
+        (1.1, 1.1),
+        (1.1, 1.100001),
+        (1.1, 1.1001),
+        (0.000001, 0.000005),
+        (1000.0, 1000.0005),
+        # Testing this example, as per #13357
+        (0.000011, 0.000012),
+    ],
+)
+def test_assert_almost_equal_numbers_atol(a, b):
+    # Equivalent to the deprecated check_less_precise=True, enforced in 2.0
+    _assert_almost_equal_both(a, b, rtol=0.5e-3, atol=0.5e-3)
+
+
+@pytest.mark.parametrize("a,b", [(1.1, 1.11), (0.1, 0.101), (0.000011, 0.001012)])
+def test_assert_not_almost_equal_numbers_atol(a, b):
+    _assert_not_almost_equal_both(a, b, atol=1e-3)
+
+
+@pytest.mark.parametrize(
+    "a,b",
+    [
+        (1.1, 1.1),
+        (1.1, 1.100001),
+        (1.1, 1.1001),
+        (1000.0, 1000.0005),
+        (1.1, 1.11),
+        (0.1, 0.101),
+    ],
+)
+def test_assert_almost_equal_numbers_rtol(a, b):
+    _assert_almost_equal_both(a, b, rtol=0.05)
+
+
+@pytest.mark.parametrize("a,b", [(0.000011, 0.000012), (0.000001, 0.000005)])
+def test_assert_not_almost_equal_numbers_rtol(a, b):
+    _assert_not_almost_equal_both(a, b, rtol=0.05)
+
+
+@pytest.mark.parametrize(
+    "a,b,rtol",
+    [
+        (1.00001, 1.00005, 0.001),
+        (-0.908356 + 0.2j, -0.908358 + 0.2j, 1e-3),
+        (0.1 + 1.009j, 0.1 + 1.006j, 0.1),
+        (0.1001 + 2.0j, 0.1 + 2.001j, 0.01),
+    ],
+)
+def test_assert_almost_equal_complex_numbers(a, b, rtol):
+    _assert_almost_equal_both(a, b, rtol=rtol)
+    _assert_almost_equal_both(np.complex64(a), np.complex64(b), rtol=rtol)
+    _assert_almost_equal_both(np.complex128(a), np.complex128(b), rtol=rtol)
+
+
+@pytest.mark.parametrize(
+    "a,b,rtol",
+    [
+        (0.58310768, 0.58330768, 1e-7),
+        (-0.908 + 0.2j, -0.978 + 0.2j, 0.001),
+        (0.1 + 1j, 0.1 + 2j, 0.01),
+        (-0.132 + 1.001j, -0.132 + 1.005j, 1e-5),
+        (0.58310768j, 0.58330768j, 1e-9),
+    ],
+)
+def test_assert_not_almost_equal_complex_numbers(a, b, rtol):
+    _assert_not_almost_equal_both(a, b, rtol=rtol)
+    _assert_not_almost_equal_both(np.complex64(a), np.complex64(b), rtol=rtol)
+    _assert_not_almost_equal_both(np.complex128(a), np.complex128(b), rtol=rtol)
+
+
+@pytest.mark.parametrize("a,b", [(0, 0), (0, 0.0), (0, np.float64(0)), (0.00000001, 0)])
+def test_assert_almost_equal_numbers_with_zeros(a, b):
+    _assert_almost_equal_both(a, b)
+
+
+@pytest.mark.parametrize("a,b", [(0.001, 0), (1, 0)])
+def test_assert_not_almost_equal_numbers_with_zeros(a, b):
+    _assert_not_almost_equal_both(a, b)
+
+
+@pytest.mark.parametrize("a,b", [(1, "abc"), (1, [1]), (1, object())])
+def test_assert_not_almost_equal_numbers_with_mixed(a, b):
+    _assert_not_almost_equal_both(a, b)
+
+
+@pytest.mark.parametrize(
+    "left_dtype", ["M8[ns]", "m8[ns]", "float64", "int64", "object"]
+)
+@pytest.mark.parametrize(
+    "right_dtype", ["M8[ns]", "m8[ns]", "float64", "int64", "object"]
+)
+def test_assert_almost_equal_edge_case_ndarrays(left_dtype, right_dtype):
+    # Empty compare.
+    _assert_almost_equal_both(
+        np.array([], dtype=left_dtype),
+        np.array([], dtype=right_dtype),
+        check_dtype=False,
+    )
+
+
+def test_assert_almost_equal_sets():
+    # GH#51727
+    _assert_almost_equal_both({1, 2, 3}, {1, 2, 3})
+
+
+def test_assert_almost_not_equal_sets():
+    # GH#51727
+    msg = r"{1, 2, 3} != {1, 2, 4}"
+    with pytest.raises(AssertionError, match=msg):
+        _assert_almost_equal_both({1, 2, 3}, {1, 2, 4})
+
+
+def test_assert_almost_equal_dicts():
+    _assert_almost_equal_both({"a": 1, "b": 2}, {"a": 1, "b": 2})
+
+
+@pytest.mark.parametrize(
+    "a,b",
+    [
+        ({"a": 1, "b": 2}, {"a": 1, "b": 3}),
+        ({"a": 1, "b": 2}, {"a": 1, "b": 2, "c": 3}),
+        ({"a": 1}, 1),
+        ({"a": 1}, "abc"),
+        ({"a": 1}, [1]),
+    ],
+)
+def test_assert_not_almost_equal_dicts(a, b):
+    _assert_not_almost_equal_both(a, b)
+
+
+@pytest.mark.parametrize("val", [1, 2])
+def test_assert_almost_equal_dict_like_object(val):
+    dict_val = 1
+    real_dict = {"a": val}
+
+    class DictLikeObj:
+        def keys(self):
+            return ("a",)
+
+        def __getitem__(self, item):
+            if item == "a":
+                return dict_val
+
+    func = (
+        _assert_almost_equal_both if val == dict_val else _assert_not_almost_equal_both
+    )
+    func(real_dict, DictLikeObj(), check_dtype=False)
+
+
+def test_assert_almost_equal_strings():
+    _assert_almost_equal_both("abc", "abc")
+
+
+@pytest.mark.parametrize(
+    "a,b", [("abc", "abcd"), ("abc", "abd"), ("abc", 1), ("abc", [1])]
+)
+def test_assert_not_almost_equal_strings(a, b):
+    _assert_not_almost_equal_both(a, b)
+
+
+@pytest.mark.parametrize(
+    "a,b", [([1, 2, 3], [1, 2, 3]), (np.array([1, 2, 3]), np.array([1, 2, 3]))]
+)
+def test_assert_almost_equal_iterables(a, b):
+    _assert_almost_equal_both(a, b)
+
+
+@pytest.mark.parametrize(
+    "a,b",
+    [
+        # Class is different.
+        (np.array([1, 2, 3]), [1, 2, 3]),
+        # Dtype is different.
+        (np.array([1, 2, 3]), np.array([1.0, 2.0, 3.0])),
+        # Can't compare generators.
+        (iter([1, 2, 3]), [1, 2, 3]),
+        ([1, 2, 3], [1, 2, 4]),
+        ([1, 2, 3], [1, 2, 3, 4]),
+        ([1, 2, 3], 1),
+    ],
+)
+def test_assert_not_almost_equal_iterables(a, b):
+    _assert_not_almost_equal(a, b)
+
+
+def test_assert_almost_equal_null():
+    _assert_almost_equal_both(None, None)
+
+
+@pytest.mark.parametrize("a,b", [(None, np.nan), (None, 0), (np.nan, 0)])
+def test_assert_not_almost_equal_null(a, b):
+    _assert_not_almost_equal(a, b)
+
+
+@pytest.mark.parametrize(
+    "a,b",
+    [
+        (np.inf, np.inf),
+        (np.inf, float("inf")),
+        (np.array([np.inf, np.nan, -np.inf]), np.array([np.inf, np.nan, -np.inf])),
+    ],
+)
+def test_assert_almost_equal_inf(a, b):
+    _assert_almost_equal_both(a, b)
+
+
+objs = [NA, np.nan, NaT, None, np.datetime64("NaT"), np.timedelta64("NaT")]
+
+
+@pytest.mark.parametrize("left", objs)
+@pytest.mark.parametrize("right", objs)
+def test_mismatched_na_assert_almost_equal_deprecation(left, right):
+    left_arr = np.array([left], dtype=object)
+    right_arr = np.array([right], dtype=object)
+
+    msg = "Mismatched null-like values"
+
+    if left is right:
+        _assert_almost_equal_both(left, right, check_dtype=False)
+        tm.assert_numpy_array_equal(left_arr, right_arr)
+        tm.assert_index_equal(
+            Index(left_arr, dtype=object), Index(right_arr, dtype=object)
+        )
+        tm.assert_series_equal(
+            Series(left_arr, dtype=object), Series(right_arr, dtype=object)
+        )
+        tm.assert_frame_equal(
+            DataFrame(left_arr, dtype=object), DataFrame(right_arr, dtype=object)
+        )
+
+    else:
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            _assert_almost_equal_both(left, right, check_dtype=False)
+
+        # TODO: to get the same deprecation in assert_numpy_array_equal we need
+        #  to change/deprecate the default for strict_nan to become True
+        # TODO: to get the same deprecation in assert_index_equal we need to
+        #  change/deprecate array_equivalent_object to be stricter, as
+        #  assert_index_equal uses Index.equal which uses array_equivalent.
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            tm.assert_series_equal(
+                Series(left_arr, dtype=object), Series(right_arr, dtype=object)
+            )
+        with tm.assert_produces_warning(FutureWarning, match=msg):
+            tm.assert_frame_equal(
+                DataFrame(left_arr, dtype=object), DataFrame(right_arr, dtype=object)
+            )
+
+
+def test_assert_not_almost_equal_inf():
+    _assert_not_almost_equal_both(np.inf, 0)
+
+
+@pytest.mark.parametrize(
+    "a,b",
+    [
+        (Index([1.0, 1.1]), Index([1.0, 1.100001])),
+        (Series([1.0, 1.1]), Series([1.0, 1.100001])),
+        (np.array([1.1, 2.000001]), np.array([1.1, 2.0])),
+        (DataFrame({"a": [1.0, 1.1]}), DataFrame({"a": [1.0, 1.100001]})),
+    ],
+)
+def test_assert_almost_equal_pandas(a, b):
+    _assert_almost_equal_both(a, b)
+
+
+def test_assert_almost_equal_object():
+    a = [Timestamp("2011-01-01"), Timestamp("2011-01-01")]
+    b = [Timestamp("2011-01-01"), Timestamp("2011-01-01")]
+    _assert_almost_equal_both(a, b)
+
+
+def test_assert_almost_equal_value_mismatch():
+    msg = "expected 2\\.00000 but got 1\\.00000, with rtol=1e-05, atol=1e-08"
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_almost_equal(1, 2)
+
+
+@pytest.mark.parametrize(
+    "a,b,klass1,klass2",
+    [(np.array([1]), 1, "ndarray", "int"), (1, np.array([1]), "int", "ndarray")],
+)
+def test_assert_almost_equal_class_mismatch(a, b, klass1, klass2):
+    msg = f"""numpy array are different
+
+numpy array classes are different
+\\[left\\]:  {klass1}
+\\[right\\]: {klass2}"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_almost_equal(a, b)
+
+
+def test_assert_almost_equal_value_mismatch1():
+    msg = """numpy array are different
+
+numpy array values are different \\(66\\.66667 %\\)
+\\[left\\]:  \\[nan, 2\\.0, 3\\.0\\]
+\\[right\\]: \\[1\\.0, nan, 3\\.0\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_almost_equal(np.array([np.nan, 2, 3]), np.array([1, np.nan, 3]))
+
+
+def test_assert_almost_equal_value_mismatch2():
+    msg = """numpy array are different
+
+numpy array values are different \\(50\\.0 %\\)
+\\[left\\]:  \\[1, 2\\]
+\\[right\\]: \\[1, 3\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_almost_equal(np.array([1, 2]), np.array([1, 3]))
+
+
+def test_assert_almost_equal_value_mismatch3():
+    msg = """numpy array are different
+
+numpy array values are different \\(16\\.66667 %\\)
+\\[left\\]:  \\[\\[1, 2\\], \\[3, 4\\], \\[5, 6\\]\\]
+\\[right\\]: \\[\\[1, 3\\], \\[3, 4\\], \\[5, 6\\]\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_almost_equal(
+            np.array([[1, 2], [3, 4], [5, 6]]), np.array([[1, 3], [3, 4], [5, 6]])
+        )
+
+
+def test_assert_almost_equal_value_mismatch4():
+    msg = """numpy array are different
+
+numpy array values are different \\(25\\.0 %\\)
+\\[left\\]:  \\[\\[1, 2\\], \\[3, 4\\]\\]
+\\[right\\]: \\[\\[1, 3\\], \\[3, 4\\]\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_almost_equal(np.array([[1, 2], [3, 4]]), np.array([[1, 3], [3, 4]]))
+
+
+def test_assert_almost_equal_shape_mismatch_override():
+    msg = """Index are different
+
+Index shapes are different
+\\[left\\]:  \\(2L*,\\)
+\\[right\\]: \\(3L*,\\)"""
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_almost_equal(np.array([1, 2]), np.array([3, 4, 5]), obj="Index")
+
+
+def test_assert_almost_equal_unicode():
+    # see gh-20503
+    msg = """numpy array are different
+
+numpy array values are different \\(33\\.33333 %\\)
+\\[left\\]:  \\[á, à, ä\\]
+\\[right\\]: \\[á, à, å\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_almost_equal(np.array(["á", "à", "ä"]), np.array(["á", "à", "å"]))
+
+
+def test_assert_almost_equal_timestamp():
+    a = np.array([Timestamp("2011-01-01"), Timestamp("2011-01-01")])
+    b = np.array([Timestamp("2011-01-01"), Timestamp("2011-01-02")])
+
+    msg = """numpy array are different
+
+numpy array values are different \\(50\\.0 %\\)
+\\[left\\]:  \\[2011-01-01 00:00:00, 2011-01-01 00:00:00\\]
+\\[right\\]: \\[2011-01-01 00:00:00, 2011-01-02 00:00:00\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_almost_equal(a, b)
+
+
+def test_assert_almost_equal_iterable_length_mismatch():
+    msg = """Iterable are different
+
+Iterable length are different
+\\[left\\]:  2
+\\[right\\]: 3"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_almost_equal([1, 2], [3, 4, 5])
+
+
+def test_assert_almost_equal_iterable_values_mismatch():
+    msg = """Iterable are different
+
+Iterable values are different \\(50\\.0 %\\)
+\\[left\\]:  \\[1, 2\\]
+\\[right\\]: \\[1, 3\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_almost_equal([1, 2], [1, 3])
+
+
+subarr = np.empty(2, dtype=object)
+subarr[:] = [np.array([None, "b"], dtype=object), np.array(["c", "d"], dtype=object)]
+
+NESTED_CASES = [
+    # nested array
+    (
+        np.array([np.array([50, 70, 90]), np.array([20, 30])], dtype=object),
+        np.array([np.array([50, 70, 90]), np.array([20, 30])], dtype=object),
+    ),
+    # >1 level of nesting
+    (
+        np.array(
+            [
+                np.array([np.array([50, 70]), np.array([90])], dtype=object),
+                np.array([np.array([20, 30])], dtype=object),
+            ],
+            dtype=object,
+        ),
+        np.array(
+            [
+                np.array([np.array([50, 70]), np.array([90])], dtype=object),
+                np.array([np.array([20, 30])], dtype=object),
+            ],
+            dtype=object,
+        ),
+    ),
+    # lists
+    (
+        np.array([[50, 70, 90], [20, 30]], dtype=object),
+        np.array([[50, 70, 90], [20, 30]], dtype=object),
+    ),
+    # mixed array/list
+    (
+        np.array([np.array([1, 2, 3]), np.array([4, 5])], dtype=object),
+        np.array([[1, 2, 3], [4, 5]], dtype=object),
+    ),
+    (
+        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,
+        ),
+        np.array([[[1, 2, 3], [4, 5]], [[6], [7, 8], [9]]], dtype=object),
+    ),
+    # same-length lists
+    (
+        np.array([subarr, None], dtype=object),
+        np.array([[[None, "b"], ["c", "d"]], None], dtype=object),
+    ),
+    # dicts
+    (
+        np.array([{"f1": 1, "f2": np.array(["a", "b"], dtype=object)}], dtype=object),
+        np.array([{"f1": 1, "f2": np.array(["a", "b"], dtype=object)}], dtype=object),
+    ),
+    (
+        np.array([{"f1": 1, "f2": np.array(["a", "b"], dtype=object)}], dtype=object),
+        np.array([{"f1": 1, "f2": ["a", "b"]}], dtype=object),
+    ),
+    # array/list of dicts
+    (
+        np.array(
+            [
+                np.array(
+                    [{"f1": 1, "f2": np.array(["a", "b"], dtype=object)}], dtype=object
+                ),
+                np.array([], dtype=object),
+            ],
+            dtype=object,
+        ),
+        np.array([[{"f1": 1, "f2": ["a", "b"]}], []], dtype=object),
+    ),
+]
+
+
+@pytest.mark.filterwarnings("ignore:elementwise comparison failed:DeprecationWarning")
+@pytest.mark.parametrize("a,b", NESTED_CASES)
+def test_assert_almost_equal_array_nested(a, b):
+    _assert_almost_equal_both(a, b)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_assert_frame_equal.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_assert_frame_equal.py
new file mode 100644
index 0000000000000000000000000000000000000000..79132591b15b3d58781c70c1a0ac5ae77c213521
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_assert_frame_equal.py
@@ -0,0 +1,393 @@
+import pytest
+
+import pandas as pd
+from pandas import DataFrame
+import pandas._testing as tm
+
+
+@pytest.fixture(params=[True, False])
+def by_blocks_fixture(request):
+    return request.param
+
+
+@pytest.fixture(params=["DataFrame", "Series"])
+def obj_fixture(request):
+    return request.param
+
+
+def _assert_frame_equal_both(a, b, **kwargs):
+    """
+    Check that two DataFrame equal.
+
+    This check is performed commutatively.
+
+    Parameters
+    ----------
+    a : DataFrame
+        The first DataFrame to compare.
+    b : DataFrame
+        The second DataFrame to compare.
+    kwargs : dict
+        The arguments passed to `tm.assert_frame_equal`.
+    """
+    tm.assert_frame_equal(a, b, **kwargs)
+    tm.assert_frame_equal(b, a, **kwargs)
+
+
+@pytest.mark.parametrize("check_like", [True, False])
+def test_frame_equal_row_order_mismatch(check_like, obj_fixture):
+    df1 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}, index=["a", "b", "c"])
+    df2 = DataFrame({"A": [3, 2, 1], "B": [6, 5, 4]}, index=["c", "b", "a"])
+
+    if not check_like:  # Do not ignore row-column orderings.
+        msg = f"{obj_fixture}.index are different"
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_frame_equal(df1, df2, check_like=check_like, obj=obj_fixture)
+    else:
+        _assert_frame_equal_both(df1, df2, check_like=check_like, obj=obj_fixture)
+
+
+@pytest.mark.parametrize(
+    "df1,df2",
+    [
+        (DataFrame({"A": [1, 2, 3]}), DataFrame({"A": [1, 2, 3, 4]})),
+        (DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}), DataFrame({"A": [1, 2, 3]})),
+    ],
+)
+def test_frame_equal_shape_mismatch(df1, df2, obj_fixture):
+    msg = f"{obj_fixture} are different"
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_frame_equal(df1, df2, obj=obj_fixture)
+
+
+@pytest.mark.parametrize(
+    "df1,df2,msg",
+    [
+        # Index
+        (
+            DataFrame.from_records({"a": [1, 2], "c": ["l1", "l2"]}, index=["a"]),
+            DataFrame.from_records({"a": [1.0, 2.0], "c": ["l1", "l2"]}, index=["a"]),
+            "DataFrame\\.index are different",
+        ),
+        # MultiIndex
+        (
+            DataFrame.from_records(
+                {"a": [1, 2], "b": [2.1, 1.5], "c": ["l1", "l2"]}, index=["a", "b"]
+            ),
+            DataFrame.from_records(
+                {"a": [1.0, 2.0], "b": [2.1, 1.5], "c": ["l1", "l2"]}, index=["a", "b"]
+            ),
+            "MultiIndex level \\[0\\] are different",
+        ),
+    ],
+)
+def test_frame_equal_index_dtype_mismatch(df1, df2, msg, check_index_type):
+    kwargs = {"check_index_type": check_index_type}
+
+    if check_index_type:
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_frame_equal(df1, df2, **kwargs)
+    else:
+        tm.assert_frame_equal(df1, df2, **kwargs)
+
+
+def test_empty_dtypes(check_dtype):
+    columns = ["col1", "col2"]
+    df1 = DataFrame(columns=columns)
+    df2 = DataFrame(columns=columns)
+
+    kwargs = {"check_dtype": check_dtype}
+    df1["col1"] = df1["col1"].astype("int64")
+
+    if check_dtype:
+        msg = r"Attributes of DataFrame\..* are different"
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_frame_equal(df1, df2, **kwargs)
+    else:
+        tm.assert_frame_equal(df1, df2, **kwargs)
+
+
+@pytest.mark.parametrize("check_like", [True, False])
+def test_frame_equal_index_mismatch(check_like, obj_fixture, using_infer_string):
+    if using_infer_string:
+        dtype = "string"
+    else:
+        dtype = "object"
+    msg = f"""{obj_fixture}\\.index are different
+
+{obj_fixture}\\.index values are different \\(33\\.33333 %\\)
+\\[left\\]:  Index\\(\\['a', 'b', 'c'\\], dtype='{dtype}'\\)
+\\[right\\]: Index\\(\\['a', 'b', 'd'\\], dtype='{dtype}'\\)
+At positional index 2, first diff: c != d"""
+
+    df1 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}, index=["a", "b", "c"])
+    df2 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}, index=["a", "b", "d"])
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_frame_equal(df1, df2, check_like=check_like, obj=obj_fixture)
+
+
+@pytest.mark.parametrize("check_like", [True, False])
+def test_frame_equal_columns_mismatch(check_like, obj_fixture, using_infer_string):
+    if using_infer_string:
+        dtype = "string"
+    else:
+        dtype = "object"
+    msg = f"""{obj_fixture}\\.columns are different
+
+{obj_fixture}\\.columns values are different \\(50\\.0 %\\)
+\\[left\\]:  Index\\(\\['A', 'B'\\], dtype='{dtype}'\\)
+\\[right\\]: Index\\(\\['A', 'b'\\], dtype='{dtype}'\\)"""
+
+    df1 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}, index=["a", "b", "c"])
+    df2 = DataFrame({"A": [1, 2, 3], "b": [4, 5, 6]}, index=["a", "b", "c"])
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_frame_equal(df1, df2, check_like=check_like, obj=obj_fixture)
+
+
+def test_frame_equal_block_mismatch(by_blocks_fixture, obj_fixture):
+    obj = obj_fixture
+    msg = f"""{obj}\\.iloc\\[:, 1\\] \\(column name="B"\\) are different
+
+{obj}\\.iloc\\[:, 1\\] \\(column name="B"\\) values are different \\(33\\.33333 %\\)
+\\[index\\]: \\[0, 1, 2\\]
+\\[left\\]:  \\[4, 5, 6\\]
+\\[right\\]: \\[4, 5, 7\\]"""
+
+    df1 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+    df2 = DataFrame({"A": [1, 2, 3], "B": [4, 5, 7]})
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_frame_equal(df1, df2, by_blocks=by_blocks_fixture, obj=obj_fixture)
+
+
+@pytest.mark.parametrize(
+    "df1,df2,msg",
+    [
+        (
+            DataFrame({"A": ["á", "à", "ä"], "E": ["é", "è", "ë"]}),
+            DataFrame({"A": ["á", "à", "ä"], "E": ["é", "è", "e̊"]}),
+            """{obj}\\.iloc\\[:, 1\\] \\(column name="E"\\) are different
+
+{obj}\\.iloc\\[:, 1\\] \\(column name="E"\\) values are different \\(33\\.33333 %\\)
+\\[index\\]: \\[0, 1, 2\\]
+\\[left\\]:  \\[é, è, ë\\]
+\\[right\\]: \\[é, è, e̊\\]""",
+        ),
+        (
+            DataFrame({"A": ["á", "à", "ä"], "E": ["é", "è", "ë"]}),
+            DataFrame({"A": ["a", "a", "a"], "E": ["e", "e", "e"]}),
+            """{obj}\\.iloc\\[:, 0\\] \\(column name="A"\\) are different
+
+{obj}\\.iloc\\[:, 0\\] \\(column name="A"\\) values are different \\(100\\.0 %\\)
+\\[index\\]: \\[0, 1, 2\\]
+\\[left\\]:  \\[á, à, ä\\]
+\\[right\\]: \\[a, a, a\\]""",
+        ),
+    ],
+)
+def test_frame_equal_unicode(df1, df2, msg, by_blocks_fixture, obj_fixture):
+    # see gh-20503
+    #
+    # Test ensures that `tm.assert_frame_equals` raises the right exception
+    # when comparing DataFrames containing differing unicode objects.
+    msg = msg.format(obj=obj_fixture)
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_frame_equal(df1, df2, by_blocks=by_blocks_fixture, obj=obj_fixture)
+
+
+def test_assert_frame_equal_extension_dtype_mismatch():
+    # https://github.com/pandas-dev/pandas/issues/32747
+    left = DataFrame({"a": [1, 2, 3]}, dtype="Int64")
+    right = left.astype(int)
+
+    msg = (
+        "Attributes of DataFrame\\.iloc\\[:, 0\\] "
+        '\\(column name="a"\\) are different\n\n'
+        'Attribute "dtype" are different\n'
+        "\\[left\\]:  Int64\n"
+        "\\[right\\]: int[32|64]"
+    )
+
+    tm.assert_frame_equal(left, right, check_dtype=False)
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_frame_equal(left, right, check_dtype=True)
+
+
+def test_assert_frame_equal_interval_dtype_mismatch():
+    # https://github.com/pandas-dev/pandas/issues/32747
+    left = DataFrame({"a": [pd.Interval(0, 1)]}, dtype="interval")
+    right = left.astype(object)
+
+    msg = (
+        "Attributes of DataFrame\\.iloc\\[:, 0\\] "
+        '\\(column name="a"\\) are different\n\n'
+        'Attribute "dtype" are different\n'
+        "\\[left\\]:  interval\\[int64, right\\]\n"
+        "\\[right\\]: object"
+    )
+
+    tm.assert_frame_equal(left, right, check_dtype=False)
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_frame_equal(left, right, check_dtype=True)
+
+
+def test_assert_frame_equal_ignore_extension_dtype_mismatch():
+    # https://github.com/pandas-dev/pandas/issues/35715
+    left = DataFrame({"a": [1, 2, 3]}, dtype="Int64")
+    right = DataFrame({"a": [1, 2, 3]}, dtype="Int32")
+    tm.assert_frame_equal(left, right, check_dtype=False)
+
+
+def test_assert_frame_equal_ignore_extension_dtype_mismatch_cross_class():
+    # https://github.com/pandas-dev/pandas/issues/35715
+    left = DataFrame({"a": [1, 2, 3]}, dtype="Int64")
+    right = DataFrame({"a": [1, 2, 3]}, dtype="int64")
+    tm.assert_frame_equal(left, right, check_dtype=False)
+
+
+@pytest.mark.parametrize(
+    "dtype",
+    [
+        ("timedelta64[ns]"),
+        ("datetime64[ns, UTC]"),
+        ("Period[D]"),
+    ],
+)
+def test_assert_frame_equal_datetime_like_dtype_mismatch(dtype):
+    df1 = DataFrame({"a": []}, dtype=dtype)
+    df2 = DataFrame({"a": []})
+    tm.assert_frame_equal(df1, df2, check_dtype=False)
+
+
+def test_allows_duplicate_labels():
+    left = DataFrame()
+    right = DataFrame().set_flags(allows_duplicate_labels=False)
+    tm.assert_frame_equal(left, left)
+    tm.assert_frame_equal(right, right)
+    tm.assert_frame_equal(left, right, check_flags=False)
+    tm.assert_frame_equal(right, left, check_flags=False)
+
+    with pytest.raises(AssertionError, match="<Flags"):
+        tm.assert_frame_equal(left, right)
+
+    with pytest.raises(AssertionError, match="<Flags"):
+        tm.assert_frame_equal(left, right)
+
+
+def test_assert_frame_equal_columns_mixed_dtype():
+    # GH#39168
+    df = DataFrame([[0, 1, 2]], columns=["foo", "bar", 42], index=[1, "test", 2])
+    tm.assert_frame_equal(df, df, check_like=True)
+
+
+def test_frame_equal_extension_dtype(frame_or_series, any_numeric_ea_dtype):
+    # GH#39410
+    obj = frame_or_series([1, 2], dtype=any_numeric_ea_dtype)
+    tm.assert_equal(obj, obj, check_exact=True)
+
+
+@pytest.mark.parametrize("indexer", [(0, 1), (1, 0)])
+def test_frame_equal_mixed_dtypes(frame_or_series, any_numeric_ea_dtype, indexer):
+    dtypes = (any_numeric_ea_dtype, "int64")
+    obj1 = frame_or_series([1, 2], dtype=dtypes[indexer[0]])
+    obj2 = frame_or_series([1, 2], dtype=dtypes[indexer[1]])
+    tm.assert_equal(obj1, obj2, check_exact=True, check_dtype=False)
+
+
+def test_assert_frame_equal_check_like_different_indexes():
+    # GH#39739
+    df1 = DataFrame(index=pd.Index([], dtype="object"))
+    df2 = DataFrame(index=pd.RangeIndex(start=0, stop=0, step=1))
+    with pytest.raises(AssertionError, match="DataFrame.index are different"):
+        tm.assert_frame_equal(df1, df2, check_like=True)
+
+
+def test_assert_frame_equal_checking_allow_dups_flag():
+    # GH#45554
+    left = DataFrame([[1, 2], [3, 4]])
+    left.flags.allows_duplicate_labels = False
+
+    right = DataFrame([[1, 2], [3, 4]])
+    right.flags.allows_duplicate_labels = True
+    tm.assert_frame_equal(left, right, check_flags=False)
+
+    with pytest.raises(AssertionError, match="allows_duplicate_labels"):
+        tm.assert_frame_equal(left, right, check_flags=True)
+
+
+def test_assert_frame_equal_check_like_categorical_midx():
+    # GH#48975
+    left = DataFrame(
+        [[1], [2], [3]],
+        index=pd.MultiIndex.from_arrays(
+            [
+                pd.Categorical(["a", "b", "c"]),
+                pd.Categorical(["a", "b", "c"]),
+            ]
+        ),
+    )
+    right = DataFrame(
+        [[3], [2], [1]],
+        index=pd.MultiIndex.from_arrays(
+            [
+                pd.Categorical(["c", "b", "a"]),
+                pd.Categorical(["c", "b", "a"]),
+            ]
+        ),
+    )
+    tm.assert_frame_equal(left, right, check_like=True)
+
+
+def test_assert_frame_equal_ea_column_definition_in_exception_mask():
+    # GH#50323
+    df1 = DataFrame({"a": pd.Series([pd.NA, 1], dtype="Int64")})
+    df2 = DataFrame({"a": pd.Series([1, 1], dtype="Int64")})
+
+    msg = r'DataFrame.iloc\[:, 0\] \(column name="a"\) NA mask values are different'
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_frame_equal(df1, df2)
+
+
+def test_assert_frame_equal_ea_column_definition_in_exception():
+    # GH#50323
+    df1 = DataFrame({"a": pd.Series([pd.NA, 1], dtype="Int64")})
+    df2 = DataFrame({"a": pd.Series([pd.NA, 2], dtype="Int64")})
+
+    msg = r'DataFrame.iloc\[:, 0\] \(column name="a"\) values are different'
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_frame_equal(df1, df2)
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_frame_equal(df1, df2, check_exact=True)
+
+
+def test_assert_frame_equal_ts_column():
+    # GH#50323
+    df1 = DataFrame({"a": [pd.Timestamp("2019-12-31"), pd.Timestamp("2020-12-31")]})
+    df2 = DataFrame({"a": [pd.Timestamp("2020-12-31"), pd.Timestamp("2020-12-31")]})
+
+    msg = r'DataFrame.iloc\[:, 0\] \(column name="a"\) values are different'
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_frame_equal(df1, df2)
+
+
+def test_assert_frame_equal_set():
+    # GH#51727
+    df1 = DataFrame({"set_column": [{1, 2, 3}, {4, 5, 6}]})
+    df2 = DataFrame({"set_column": [{1, 2, 3}, {4, 5, 6}]})
+    tm.assert_frame_equal(df1, df2)
+
+
+def test_assert_frame_equal_set_mismatch():
+    # GH#51727
+    df1 = DataFrame({"set_column": [{1, 2, 3}, {4, 5, 6}]})
+    df2 = DataFrame({"set_column": [{1, 2, 3}, {4, 5, 7}]})
+
+    msg = r'DataFrame.iloc\[:, 0\] \(column name="set_column"\) values are different'
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_frame_equal(df1, df2)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_assert_index_equal.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_assert_index_equal.py
new file mode 100644
index 0000000000000000000000000000000000000000..dc6efdcec380e3ebae8a2292307acdf390f20bb3
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_assert_index_equal.py
@@ -0,0 +1,319 @@
+import numpy as np
+import pytest
+
+from pandas import (
+    NA,
+    Categorical,
+    CategoricalIndex,
+    Index,
+    MultiIndex,
+    NaT,
+    RangeIndex,
+)
+import pandas._testing as tm
+
+
+def test_index_equal_levels_mismatch():
+    msg = """Index are different
+
+Index levels are different
+\\[left\\]:  1, Index\\(\\[1, 2, 3\\], dtype='int64'\\)
+\\[right\\]: 2, MultiIndex\\(\\[\\('A', 1\\),
+            \\('A', 2\\),
+            \\('B', 3\\),
+            \\('B', 4\\)\\],
+           \\)"""
+
+    idx1 = Index([1, 2, 3])
+    idx2 = MultiIndex.from_tuples([("A", 1), ("A", 2), ("B", 3), ("B", 4)])
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_index_equal(idx1, idx2, exact=False)
+
+
+def test_index_equal_values_mismatch(check_exact):
+    msg = """MultiIndex level \\[1\\] are different
+
+MultiIndex level \\[1\\] values are different \\(25\\.0 %\\)
+\\[left\\]:  Index\\(\\[2, 2, 3, 4\\], dtype='int64'\\)
+\\[right\\]: Index\\(\\[1, 2, 3, 4\\], dtype='int64'\\)"""
+
+    idx1 = MultiIndex.from_tuples([("A", 2), ("A", 2), ("B", 3), ("B", 4)])
+    idx2 = MultiIndex.from_tuples([("A", 1), ("A", 2), ("B", 3), ("B", 4)])
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_index_equal(idx1, idx2, check_exact=check_exact)
+
+
+def test_index_equal_length_mismatch(check_exact):
+    msg = """Index are different
+
+Index length are different
+\\[left\\]:  3, Index\\(\\[1, 2, 3\\], dtype='int64'\\)
+\\[right\\]: 4, Index\\(\\[1, 2, 3, 4\\], dtype='int64'\\)"""
+
+    idx1 = Index([1, 2, 3])
+    idx2 = Index([1, 2, 3, 4])
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_index_equal(idx1, idx2, check_exact=check_exact)
+
+
+@pytest.mark.parametrize("exact", [False, "equiv"])
+def test_index_equal_class(exact):
+    idx1 = Index([0, 1, 2])
+    idx2 = RangeIndex(3)
+
+    tm.assert_index_equal(idx1, idx2, exact=exact)
+
+
+def test_int_float_index_equal_class_mismatch(check_exact):
+    msg = """Index are different
+
+Attribute "inferred_type" are different
+\\[left\\]:  integer
+\\[right\\]: floating"""
+
+    idx1 = Index([1, 2, 3])
+    idx2 = Index([1, 2, 3], dtype=np.float64)
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_index_equal(idx1, idx2, exact=True, check_exact=check_exact)
+
+
+def test_range_index_equal_class_mismatch(check_exact):
+    msg = """Index are different
+
+Index classes are different
+\\[left\\]:  Index\\(\\[1, 2, 3\\], dtype='int64'\\)
+\\[right\\]: """
+
+    idx1 = Index([1, 2, 3])
+    idx2 = RangeIndex(range(3))
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_index_equal(idx1, idx2, exact=True, check_exact=check_exact)
+
+
+def test_index_equal_values_close(check_exact):
+    idx1 = Index([1, 2, 3.0])
+    idx2 = Index([1, 2, 3.0000000001])
+
+    if check_exact:
+        msg = """Index are different
+
+Index values are different \\(33\\.33333 %\\)
+\\[left\\]:  Index\\(\\[1.0, 2.0, 3.0], dtype='float64'\\)
+\\[right\\]: Index\\(\\[1.0, 2.0, 3.0000000001\\], dtype='float64'\\)"""
+
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_index_equal(idx1, idx2, check_exact=check_exact)
+    else:
+        tm.assert_index_equal(idx1, idx2, check_exact=check_exact)
+
+
+def test_index_equal_values_less_close(check_exact, rtol):
+    idx1 = Index([1, 2, 3.0])
+    idx2 = Index([1, 2, 3.0001])
+    kwargs = {"check_exact": check_exact, "rtol": rtol}
+
+    if check_exact or rtol < 0.5e-3:
+        msg = """Index are different
+
+Index values are different \\(33\\.33333 %\\)
+\\[left\\]:  Index\\(\\[1.0, 2.0, 3.0], dtype='float64'\\)
+\\[right\\]: Index\\(\\[1.0, 2.0, 3.0001\\], dtype='float64'\\)"""
+
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_index_equal(idx1, idx2, **kwargs)
+    else:
+        tm.assert_index_equal(idx1, idx2, **kwargs)
+
+
+def test_index_equal_values_too_far(check_exact, rtol):
+    idx1 = Index([1, 2, 3])
+    idx2 = Index([1, 2, 4])
+    kwargs = {"check_exact": check_exact, "rtol": rtol}
+
+    msg = """Index are different
+
+Index values are different \\(33\\.33333 %\\)
+\\[left\\]:  Index\\(\\[1, 2, 3\\], dtype='int64'\\)
+\\[right\\]: Index\\(\\[1, 2, 4\\], dtype='int64'\\)"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_index_equal(idx1, idx2, **kwargs)
+
+
+@pytest.mark.parametrize("check_order", [True, False])
+def test_index_equal_value_order_mismatch(check_exact, rtol, check_order):
+    idx1 = Index([1, 2, 3])
+    idx2 = Index([3, 2, 1])
+
+    msg = """Index are different
+
+Index values are different \\(66\\.66667 %\\)
+\\[left\\]:  Index\\(\\[1, 2, 3\\], dtype='int64'\\)
+\\[right\\]: Index\\(\\[3, 2, 1\\], dtype='int64'\\)"""
+
+    if check_order:
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_index_equal(
+                idx1, idx2, check_exact=check_exact, rtol=rtol, check_order=True
+            )
+    else:
+        tm.assert_index_equal(
+            idx1, idx2, check_exact=check_exact, rtol=rtol, check_order=False
+        )
+
+
+def test_index_equal_level_values_mismatch(check_exact, rtol):
+    idx1 = MultiIndex.from_tuples([("A", 2), ("A", 2), ("B", 3), ("B", 4)])
+    idx2 = MultiIndex.from_tuples([("A", 1), ("A", 2), ("B", 3), ("B", 4)])
+    kwargs = {"check_exact": check_exact, "rtol": rtol}
+
+    msg = """MultiIndex level \\[1\\] are different
+
+MultiIndex level \\[1\\] values are different \\(25\\.0 %\\)
+\\[left\\]:  Index\\(\\[2, 2, 3, 4\\], dtype='int64'\\)
+\\[right\\]: Index\\(\\[1, 2, 3, 4\\], dtype='int64'\\)"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_index_equal(idx1, idx2, **kwargs)
+
+
+@pytest.mark.parametrize(
+    "name1,name2",
+    [(None, "x"), ("x", "x"), (np.nan, np.nan), (NaT, NaT), (np.nan, NaT)],
+)
+def test_index_equal_names(name1, name2):
+    idx1 = Index([1, 2, 3], name=name1)
+    idx2 = Index([1, 2, 3], name=name2)
+
+    if name1 == name2 or name1 is name2:
+        tm.assert_index_equal(idx1, idx2)
+    else:
+        name1 = "'x'" if name1 == "x" else name1
+        name2 = "'x'" if name2 == "x" else name2
+        msg = f"""Index are different
+
+Attribute "names" are different
+\\[left\\]:  \\[{name1}\\]
+\\[right\\]: \\[{name2}\\]"""
+
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_index_equal(idx1, idx2)
+
+
+def test_index_equal_category_mismatch(check_categorical, using_infer_string):
+    if using_infer_string:
+        dtype = "string"
+    else:
+        dtype = "object"
+    msg = f"""Index are different
+
+Attribute "dtype" are different
+\\[left\\]:  CategoricalDtype\\(categories=\\['a', 'b'\\], ordered=False, \
+categories_dtype={dtype}\\)
+\\[right\\]: CategoricalDtype\\(categories=\\['a', 'b', 'c'\\], \
+ordered=False, categories_dtype={dtype}\\)"""
+
+    idx1 = Index(Categorical(["a", "b"]))
+    idx2 = Index(Categorical(["a", "b"], categories=["a", "b", "c"]))
+
+    if check_categorical:
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_index_equal(idx1, idx2, check_categorical=check_categorical)
+    else:
+        tm.assert_index_equal(idx1, idx2, check_categorical=check_categorical)
+
+
+@pytest.mark.parametrize("exact", [False, True])
+def test_index_equal_range_categories(check_categorical, exact):
+    # GH41263
+    msg = """\
+Index are different
+
+Index classes are different
+\\[left\\]:  RangeIndex\\(start=0, stop=10, step=1\\)
+\\[right\\]: Index\\(\\[0, 1, 2, 3, 4, 5, 6, 7, 8, 9\\], dtype='int64'\\)"""
+
+    rcat = CategoricalIndex(RangeIndex(10))
+    icat = CategoricalIndex(list(range(10)))
+
+    if check_categorical and exact:
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_index_equal(rcat, icat, check_categorical=True, exact=True)
+    else:
+        tm.assert_index_equal(
+            rcat, icat, check_categorical=check_categorical, exact=exact
+        )
+
+
+def test_assert_index_equal_different_inferred_types():
+    # GH#31884
+    msg = """\
+Index are different
+
+Attribute "inferred_type" are different
+\\[left\\]:  mixed
+\\[right\\]: datetime"""
+
+    idx1 = Index([NA, np.datetime64("nat")])
+    idx2 = Index([NA, NaT])
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_index_equal(idx1, idx2)
+
+
+def test_assert_index_equal_different_names_check_order_false():
+    # GH#47328
+    idx1 = Index([1, 3], name="a")
+    idx2 = Index([3, 1], name="b")
+    with pytest.raises(AssertionError, match='"names" are different'):
+        tm.assert_index_equal(idx1, idx2, check_order=False, check_names=True)
+
+
+def test_assert_index_equal_mixed_dtype():
+    # GH#39168
+    idx = Index(["foo", "bar", 42])
+    tm.assert_index_equal(idx, idx, check_order=False)
+
+
+def test_assert_index_equal_ea_dtype_order_false(any_numeric_ea_dtype):
+    # GH#47207
+    idx1 = Index([1, 3], dtype=any_numeric_ea_dtype)
+    idx2 = Index([3, 1], dtype=any_numeric_ea_dtype)
+    tm.assert_index_equal(idx1, idx2, check_order=False)
+
+
+def test_assert_index_equal_object_ints_order_false():
+    # GH#47207
+    idx1 = Index([1, 3], dtype="object")
+    idx2 = Index([3, 1], dtype="object")
+    tm.assert_index_equal(idx1, idx2, check_order=False)
+
+
+@pytest.mark.parametrize("check_categorical", [True, False])
+@pytest.mark.parametrize("check_names", [True, False])
+def test_assert_ea_index_equal_non_matching_na(check_names, check_categorical):
+    # GH#48608
+    idx1 = Index([1, 2], dtype="Int64")
+    idx2 = Index([1, NA], dtype="Int64")
+    with pytest.raises(AssertionError, match="50.0 %"):
+        tm.assert_index_equal(
+            idx1, idx2, check_names=check_names, check_categorical=check_categorical
+        )
+
+
+@pytest.mark.parametrize("check_categorical", [True, False])
+def test_assert_multi_index_dtype_check_categorical(check_categorical):
+    # GH#52126
+    idx1 = MultiIndex.from_arrays([Categorical(np.array([1, 2], dtype=np.uint64))])
+    idx2 = MultiIndex.from_arrays([Categorical(np.array([1, 2], dtype=np.int64))])
+    if check_categorical:
+        with pytest.raises(
+            AssertionError, match=r"^MultiIndex level \[0\] are different"
+        ):
+            tm.assert_index_equal(idx1, idx2, check_categorical=check_categorical)
+    else:
+        tm.assert_index_equal(idx1, idx2, check_categorical=check_categorical)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_assert_interval_array_equal.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_assert_interval_array_equal.py
new file mode 100644
index 0000000000000000000000000000000000000000..8cc4ade3d7e95c4f0974fddc23aa7de0c36b56c5
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_assert_interval_array_equal.py
@@ -0,0 +1,81 @@
+import pytest
+
+from pandas import interval_range
+import pandas._testing as tm
+
+
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        {"start": 0, "periods": 4},
+        {"start": 1, "periods": 5},
+        {"start": 5, "end": 10, "closed": "left"},
+    ],
+)
+def test_interval_array_equal(kwargs):
+    arr = interval_range(**kwargs).values
+    tm.assert_interval_array_equal(arr, arr)
+
+
+def test_interval_array_equal_closed_mismatch():
+    kwargs = {"start": 0, "periods": 5}
+    arr1 = interval_range(closed="left", **kwargs).values
+    arr2 = interval_range(closed="right", **kwargs).values
+
+    msg = """\
+IntervalArray are different
+
+Attribute "closed" are different
+\\[left\\]:  left
+\\[right\\]: right"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_interval_array_equal(arr1, arr2)
+
+
+def test_interval_array_equal_periods_mismatch():
+    kwargs = {"start": 0}
+    arr1 = interval_range(periods=5, **kwargs).values
+    arr2 = interval_range(periods=6, **kwargs).values
+
+    msg = """\
+IntervalArray.left are different
+
+IntervalArray.left shapes are different
+\\[left\\]:  \\(5,\\)
+\\[right\\]: \\(6,\\)"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_interval_array_equal(arr1, arr2)
+
+
+def test_interval_array_equal_end_mismatch():
+    kwargs = {"start": 0, "periods": 5}
+    arr1 = interval_range(end=10, **kwargs).values
+    arr2 = interval_range(end=20, **kwargs).values
+
+    msg = """\
+IntervalArray.left are different
+
+IntervalArray.left values are different \\(80.0 %\\)
+\\[left\\]:  \\[0, 2, 4, 6, 8\\]
+\\[right\\]: \\[0, 4, 8, 12, 16\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_interval_array_equal(arr1, arr2)
+
+
+def test_interval_array_equal_start_mismatch():
+    kwargs = {"periods": 4}
+    arr1 = interval_range(start=0, **kwargs).values
+    arr2 = interval_range(start=1, **kwargs).values
+
+    msg = """\
+IntervalArray.left are different
+
+IntervalArray.left values are different \\(100.0 %\\)
+\\[left\\]:  \\[0, 1, 2, 3\\]
+\\[right\\]: \\[1, 2, 3, 4\\]"""
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_interval_array_equal(arr1, arr2)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_assert_series_equal.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_assert_series_equal.py
new file mode 100644
index 0000000000000000000000000000000000000000..1878e7d8380648be2c5c57119ab0a28c45884a05
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_assert_series_equal.py
@@ -0,0 +1,484 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    Categorical,
+    DataFrame,
+    Series,
+)
+import pandas._testing as tm
+
+
+def _assert_series_equal_both(a, b, **kwargs):
+    """
+    Check that two Series equal.
+
+    This check is performed commutatively.
+
+    Parameters
+    ----------
+    a : Series
+        The first Series to compare.
+    b : Series
+        The second Series to compare.
+    kwargs : dict
+        The arguments passed to `tm.assert_series_equal`.
+    """
+    tm.assert_series_equal(a, b, **kwargs)
+    tm.assert_series_equal(b, a, **kwargs)
+
+
+def _assert_not_series_equal(a, b, **kwargs):
+    """
+    Check that two Series are not equal.
+
+    Parameters
+    ----------
+    a : Series
+        The first Series to compare.
+    b : Series
+        The second Series to compare.
+    kwargs : dict
+        The arguments passed to `tm.assert_series_equal`.
+    """
+    try:
+        tm.assert_series_equal(a, b, **kwargs)
+        msg = "The two Series were equal when they shouldn't have been"
+
+        pytest.fail(msg=msg)
+    except AssertionError:
+        pass
+
+
+def _assert_not_series_equal_both(a, b, **kwargs):
+    """
+    Check that two Series are not equal.
+
+    This check is performed commutatively.
+
+    Parameters
+    ----------
+    a : Series
+        The first Series to compare.
+    b : Series
+        The second Series to compare.
+    kwargs : dict
+        The arguments passed to `tm.assert_series_equal`.
+    """
+    _assert_not_series_equal(a, b, **kwargs)
+    _assert_not_series_equal(b, a, **kwargs)
+
+
+@pytest.mark.parametrize("data", [range(3), list("abc"), list("áàä")])
+def test_series_equal(data):
+    _assert_series_equal_both(Series(data), Series(data))
+
+
+@pytest.mark.parametrize(
+    "data1,data2",
+    [
+        (range(3), range(1, 4)),
+        (list("abc"), list("xyz")),
+        (list("áàä"), list("éèë")),
+        (list("áàä"), list(b"aaa")),
+        (range(3), range(4)),
+    ],
+)
+def test_series_not_equal_value_mismatch(data1, data2):
+    _assert_not_series_equal_both(Series(data1), Series(data2))
+
+
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        {"dtype": "float64"},  # dtype mismatch
+        {"index": [1, 2, 4]},  # index mismatch
+        {"name": "foo"},  # name mismatch
+    ],
+)
+def test_series_not_equal_metadata_mismatch(kwargs):
+    data = range(3)
+    s1 = Series(data)
+
+    s2 = Series(data, **kwargs)
+    _assert_not_series_equal_both(s1, s2)
+
+
+@pytest.mark.parametrize("data1,data2", [(0.12345, 0.12346), (0.1235, 0.1236)])
+@pytest.mark.parametrize("dtype", ["float32", "float64", "Float32"])
+@pytest.mark.parametrize("decimals", [0, 1, 2, 3, 5, 10])
+def test_less_precise(data1, data2, dtype, decimals):
+    rtol = 10**-decimals
+    s1 = Series([data1], dtype=dtype)
+    s2 = Series([data2], dtype=dtype)
+
+    if decimals in (5, 10) or (decimals >= 3 and abs(data1 - data2) >= 0.0005):
+        msg = "Series values are different"
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_series_equal(s1, s2, rtol=rtol)
+    else:
+        _assert_series_equal_both(s1, s2, rtol=rtol)
+
+
+@pytest.mark.parametrize(
+    "s1,s2,msg",
+    [
+        # Index
+        (
+            Series(["l1", "l2"], index=[1, 2]),
+            Series(["l1", "l2"], index=[1.0, 2.0]),
+            "Series\\.index are different",
+        ),
+        # MultiIndex
+        (
+            DataFrame.from_records(
+                {"a": [1, 2], "b": [2.1, 1.5], "c": ["l1", "l2"]}, index=["a", "b"]
+            ).c,
+            DataFrame.from_records(
+                {"a": [1.0, 2.0], "b": [2.1, 1.5], "c": ["l1", "l2"]}, index=["a", "b"]
+            ).c,
+            "MultiIndex level \\[0\\] are different",
+        ),
+    ],
+)
+def test_series_equal_index_dtype(s1, s2, msg, check_index_type):
+    kwargs = {"check_index_type": check_index_type}
+
+    if check_index_type:
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_series_equal(s1, s2, **kwargs)
+    else:
+        tm.assert_series_equal(s1, s2, **kwargs)
+
+
+@pytest.mark.parametrize("check_like", [True, False])
+def test_series_equal_order_mismatch(check_like):
+    s1 = Series([1, 2, 3], index=["a", "b", "c"])
+    s2 = Series([3, 2, 1], index=["c", "b", "a"])
+
+    if not check_like:  # Do not ignore index ordering.
+        with pytest.raises(AssertionError, match="Series.index are different"):
+            tm.assert_series_equal(s1, s2, check_like=check_like)
+    else:
+        _assert_series_equal_both(s1, s2, check_like=check_like)
+
+
+@pytest.mark.parametrize("check_index", [True, False])
+def test_series_equal_index_mismatch(check_index):
+    s1 = Series([1, 2, 3], index=["a", "b", "c"])
+    s2 = Series([1, 2, 3], index=["c", "b", "a"])
+
+    if check_index:  # Do not ignore index.
+        with pytest.raises(AssertionError, match="Series.index are different"):
+            tm.assert_series_equal(s1, s2, check_index=check_index)
+    else:
+        _assert_series_equal_both(s1, s2, check_index=check_index)
+
+
+def test_series_invalid_param_combination():
+    left = Series(dtype=object)
+    right = Series(dtype=object)
+    with pytest.raises(
+        ValueError, match="check_like must be False if check_index is False"
+    ):
+        tm.assert_series_equal(left, right, check_index=False, check_like=True)
+
+
+def test_series_equal_length_mismatch(rtol):
+    msg = """Series are different
+
+Series length are different
+\\[left\\]:  3, RangeIndex\\(start=0, stop=3, step=1\\)
+\\[right\\]: 4, RangeIndex\\(start=0, stop=4, step=1\\)"""
+
+    s1 = Series([1, 2, 3])
+    s2 = Series([1, 2, 3, 4])
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_series_equal(s1, s2, rtol=rtol)
+
+
+def test_series_equal_numeric_values_mismatch(rtol):
+    msg = """Series are different
+
+Series values are different \\(33\\.33333 %\\)
+\\[index\\]: \\[0, 1, 2\\]
+\\[left\\]:  \\[1, 2, 3\\]
+\\[right\\]: \\[1, 2, 4\\]"""
+
+    s1 = Series([1, 2, 3])
+    s2 = Series([1, 2, 4])
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_series_equal(s1, s2, rtol=rtol)
+
+
+def test_series_equal_categorical_values_mismatch(rtol, using_infer_string):
+    if using_infer_string:
+        msg = """Series are different
+
+Series values are different \\(66\\.66667 %\\)
+\\[index\\]: \\[0, 1, 2\\]
+\\[left\\]:  \\['a', 'b', 'c'\\]
+Categories \\(3, string\\): \\[a, b, c\\]
+\\[right\\]: \\['a', 'c', 'b'\\]
+Categories \\(3, string\\): \\[a, b, c\\]"""
+    else:
+        msg = """Series are different
+
+Series values are different \\(66\\.66667 %\\)
+\\[index\\]: \\[0, 1, 2\\]
+\\[left\\]:  \\['a', 'b', 'c'\\]
+Categories \\(3, object\\): \\['a', 'b', 'c'\\]
+\\[right\\]: \\['a', 'c', 'b'\\]
+Categories \\(3, object\\): \\['a', 'b', 'c'\\]"""
+
+    s1 = Series(Categorical(["a", "b", "c"]))
+    s2 = Series(Categorical(["a", "c", "b"]))
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_series_equal(s1, s2, rtol=rtol)
+
+
+def test_series_equal_datetime_values_mismatch(rtol):
+    msg = """Series are different
+
+Series values are different \\(100.0 %\\)
+\\[index\\]: \\[0, 1, 2\\]
+\\[left\\]:  \\[1514764800000000000, 1514851200000000000, 1514937600000000000\\]
+\\[right\\]: \\[1549065600000000000, 1549152000000000000, 1549238400000000000\\]"""
+
+    s1 = Series(pd.date_range("2018-01-01", periods=3, freq="D"))
+    s2 = Series(pd.date_range("2019-02-02", periods=3, freq="D"))
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_series_equal(s1, s2, rtol=rtol)
+
+
+def test_series_equal_categorical_mismatch(check_categorical, using_infer_string):
+    if using_infer_string:
+        dtype = "string"
+    else:
+        dtype = "object"
+    msg = f"""Attributes of Series are different
+
+Attribute "dtype" are different
+\\[left\\]:  CategoricalDtype\\(categories=\\['a', 'b'\\], ordered=False, \
+categories_dtype={dtype}\\)
+\\[right\\]: CategoricalDtype\\(categories=\\['a', 'b', 'c'\\], \
+ordered=False, categories_dtype={dtype}\\)"""
+
+    s1 = Series(Categorical(["a", "b"]))
+    s2 = Series(Categorical(["a", "b"], categories=list("abc")))
+
+    if check_categorical:
+        with pytest.raises(AssertionError, match=msg):
+            tm.assert_series_equal(s1, s2, check_categorical=check_categorical)
+    else:
+        _assert_series_equal_both(s1, s2, check_categorical=check_categorical)
+
+
+def test_assert_series_equal_extension_dtype_mismatch():
+    # https://github.com/pandas-dev/pandas/issues/32747
+    left = Series(pd.array([1, 2, 3], dtype="Int64"))
+    right = left.astype(int)
+
+    msg = """Attributes of Series are different
+
+Attribute "dtype" are different
+\\[left\\]:  Int64
+\\[right\\]: int[32|64]"""
+
+    tm.assert_series_equal(left, right, check_dtype=False)
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_series_equal(left, right, check_dtype=True)
+
+
+def test_assert_series_equal_interval_dtype_mismatch():
+    # https://github.com/pandas-dev/pandas/issues/32747
+    left = Series([pd.Interval(0, 1)], dtype="interval")
+    right = left.astype(object)
+
+    msg = """Attributes of Series are different
+
+Attribute "dtype" are different
+\\[left\\]:  interval\\[int64, right\\]
+\\[right\\]: object"""
+
+    tm.assert_series_equal(left, right, check_dtype=False)
+
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_series_equal(left, right, check_dtype=True)
+
+
+def test_series_equal_series_type():
+    class MySeries(Series):
+        pass
+
+    s1 = Series([1, 2])
+    s2 = Series([1, 2])
+    s3 = MySeries([1, 2])
+
+    tm.assert_series_equal(s1, s2, check_series_type=False)
+    tm.assert_series_equal(s1, s2, check_series_type=True)
+
+    tm.assert_series_equal(s1, s3, check_series_type=False)
+    tm.assert_series_equal(s3, s1, check_series_type=False)
+
+    with pytest.raises(AssertionError, match="Series classes are different"):
+        tm.assert_series_equal(s1, s3, check_series_type=True)
+
+    with pytest.raises(AssertionError, match="Series classes are different"):
+        tm.assert_series_equal(s3, s1, check_series_type=True)
+
+
+def test_series_equal_exact_for_nonnumeric():
+    # https://github.com/pandas-dev/pandas/issues/35446
+    s1 = Series(["a", "b"])
+    s2 = Series(["a", "b"])
+    s3 = Series(["b", "a"])
+
+    tm.assert_series_equal(s1, s2, check_exact=True)
+    tm.assert_series_equal(s2, s1, check_exact=True)
+
+    msg = """Series are different
+
+Series values are different \\(100\\.0 %\\)
+\\[index\\]: \\[0, 1\\]
+\\[left\\]:  \\[a, b\\]
+\\[right\\]: \\[b, a\\]"""
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_series_equal(s1, s3, check_exact=True)
+
+    msg = """Series are different
+
+Series values are different \\(100\\.0 %\\)
+\\[index\\]: \\[0, 1\\]
+\\[left\\]:  \\[b, a\\]
+\\[right\\]: \\[a, b\\]"""
+    with pytest.raises(AssertionError, match=msg):
+        tm.assert_series_equal(s3, s1, check_exact=True)
+
+
+def test_assert_series_equal_ignore_extension_dtype_mismatch():
+    # https://github.com/pandas-dev/pandas/issues/35715
+    left = Series([1, 2, 3], dtype="Int64")
+    right = Series([1, 2, 3], dtype="Int32")
+    tm.assert_series_equal(left, right, check_dtype=False)
+
+
+def test_assert_series_equal_ignore_extension_dtype_mismatch_cross_class():
+    # https://github.com/pandas-dev/pandas/issues/35715
+    left = Series([1, 2, 3], dtype="Int64")
+    right = Series([1, 2, 3], dtype="int64")
+    tm.assert_series_equal(left, right, check_dtype=False)
+
+
+def test_allows_duplicate_labels():
+    left = Series([1])
+    right = Series([1]).set_flags(allows_duplicate_labels=False)
+    tm.assert_series_equal(left, left)
+    tm.assert_series_equal(right, right)
+    tm.assert_series_equal(left, right, check_flags=False)
+    tm.assert_series_equal(right, left, check_flags=False)
+
+    with pytest.raises(AssertionError, match="<Flags"):
+        tm.assert_series_equal(left, right)
+
+    with pytest.raises(AssertionError, match="<Flags"):
+        tm.assert_series_equal(left, right)
+
+
+def test_assert_series_equal_identical_na(nulls_fixture):
+    ser = Series([nulls_fixture])
+
+    tm.assert_series_equal(ser, ser.copy())
+
+    # while we're here do Index too
+    idx = pd.Index(ser)
+    tm.assert_index_equal(idx, idx.copy(deep=True))
+
+
+def test_identical_nested_series_is_equal():
+    # GH#22400
+    x = Series(
+        [
+            0,
+            0.0131142231938,
+            1.77774652865e-05,
+            np.array([0.4722720840328748, 0.4216929783681722]),
+        ]
+    )
+    y = Series(
+        [
+            0,
+            0.0131142231938,
+            1.77774652865e-05,
+            np.array([0.4722720840328748, 0.4216929783681722]),
+        ]
+    )
+    # These two arrays should be equal, nesting could cause issue
+
+    tm.assert_series_equal(x, x)
+    tm.assert_series_equal(x, x, check_exact=True)
+    tm.assert_series_equal(x, y)
+    tm.assert_series_equal(x, y, check_exact=True)
+
+
+@pytest.mark.parametrize("dtype", ["datetime64", "timedelta64"])
+def test_check_dtype_false_different_reso(dtype):
+    # GH 52449
+    ser_s = Series([1000213, 2131232, 21312331]).astype(f"{dtype}[s]")
+    ser_ms = ser_s.astype(f"{dtype}[ms]")
+    with pytest.raises(AssertionError, match="Attributes of Series are different"):
+        tm.assert_series_equal(ser_s, ser_ms)
+    tm.assert_series_equal(ser_ms, ser_s, check_dtype=False)
+
+    ser_ms -= Series([1, 1, 1]).astype(f"{dtype}[ms]")
+
+    with pytest.raises(AssertionError, match="Series are different"):
+        tm.assert_series_equal(ser_s, ser_ms)
+
+    with pytest.raises(AssertionError, match="Series are different"):
+        tm.assert_series_equal(ser_s, ser_ms, check_dtype=False)
+
+
+@pytest.mark.parametrize("dtype", ["Int64", "int64"])
+def test_large_unequal_ints(dtype):
+    # https://github.com/pandas-dev/pandas/issues/55882
+    left = Series([1577840521123000], dtype=dtype)
+    right = Series([1577840521123543], dtype=dtype)
+    with pytest.raises(AssertionError, match="Series are different"):
+        tm.assert_series_equal(left, right)
+
+
+@pytest.mark.parametrize("dtype", [None, object])
+@pytest.mark.parametrize("check_exact", [True, False])
+@pytest.mark.parametrize("val", [3, 3.5])
+def test_ea_and_numpy_no_dtype_check(val, check_exact, dtype):
+    # GH#56651
+    left = Series([1, 2, val], dtype=dtype)
+    right = Series(pd.array([1, 2, val]))
+    tm.assert_series_equal(left, right, check_dtype=False, check_exact=check_exact)
+
+
+def test_assert_series_equal_int_tol():
+    # GH#56646
+    left = Series([81, 18, 121, 38, 74, 72, 81, 81, 146, 81, 81, 170, 74, 74])
+    right = Series([72, 9, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72])
+    tm.assert_series_equal(left, right, rtol=1.5)
+
+    tm.assert_frame_equal(left.to_frame(), right.to_frame(), rtol=1.5)
+    tm.assert_extension_array_equal(
+        left.astype("Int64").values, right.astype("Int64").values, rtol=1.5
+    )
+
+
+def test_assert_series_equal_index_exact_default():
+    # GH#57067
+    ser1 = Series(np.zeros(6, dtype=int), [0, 0.2, 0.4, 0.6, 0.8, 1])
+    ser2 = Series(np.zeros(6, dtype=int), np.linspace(0, 1, 6))
+    tm.assert_series_equal(ser1, ser2)
+    tm.assert_frame_equal(ser1.to_frame(), ser2.to_frame())
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_deprecate_kwarg.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_deprecate_kwarg.py
new file mode 100644
index 0000000000000000000000000000000000000000..b165e9fba0e4f2a9986ddc40c73aa1058d14a9ec
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_deprecate_kwarg.py
@@ -0,0 +1,90 @@
+import pytest
+
+from pandas.util._decorators import deprecate_kwarg
+
+import pandas._testing as tm
+
+
+@deprecate_kwarg("old", "new")
+def _f1(new=False):
+    return new
+
+
+_f2_mappings = {"yes": True, "no": False}
+
+
+@deprecate_kwarg("old", "new", _f2_mappings)
+def _f2(new=False):
+    return new
+
+
+def _f3_mapping(x):
+    return x + 1
+
+
+@deprecate_kwarg("old", "new", _f3_mapping)
+def _f3(new=0):
+    return new
+
+
+@pytest.mark.parametrize("key,klass", [("old", FutureWarning), ("new", None)])
+def test_deprecate_kwarg(key, klass):
+    x = 78
+
+    with tm.assert_produces_warning(klass):
+        assert _f1(**{key: x}) == x
+
+
+@pytest.mark.parametrize("key", list(_f2_mappings.keys()))
+def test_dict_deprecate_kwarg(key):
+    with tm.assert_produces_warning(FutureWarning):
+        assert _f2(old=key) == _f2_mappings[key]
+
+
+@pytest.mark.parametrize("key", ["bogus", 12345, -1.23])
+def test_missing_deprecate_kwarg(key):
+    with tm.assert_produces_warning(FutureWarning):
+        assert _f2(old=key) == key
+
+
+@pytest.mark.parametrize("x", [1, -1.4, 0])
+def test_callable_deprecate_kwarg(x):
+    with tm.assert_produces_warning(FutureWarning):
+        assert _f3(old=x) == _f3_mapping(x)
+
+
+def test_callable_deprecate_kwarg_fail():
+    msg = "((can only|cannot) concatenate)|(must be str)|(Can't convert)"
+
+    with pytest.raises(TypeError, match=msg):
+        _f3(old="hello")
+
+
+def test_bad_deprecate_kwarg():
+    msg = "mapping from old to new argument values must be dict or callable!"
+
+    with pytest.raises(TypeError, match=msg):
+
+        @deprecate_kwarg("old", "new", 0)
+        def f4(new=None):
+            return new
+
+
+@deprecate_kwarg("old", None)
+def _f4(old=True, unchanged=True):
+    return old, unchanged
+
+
+@pytest.mark.parametrize("key", ["old", "unchanged"])
+def test_deprecate_keyword(key):
+    x = 9
+
+    if key == "old":
+        klass = FutureWarning
+        expected = (x, True)
+    else:
+        klass = None
+        expected = (True, x)
+
+    with tm.assert_produces_warning(klass):
+        assert _f4(**{key: x}) == expected
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_numba.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_numba.py
new file mode 100644
index 0000000000000000000000000000000000000000..27b68ff0f60447e6695d786de9a72ecbb59f7884
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_numba.py
@@ -0,0 +1,12 @@
+import pytest
+
+import pandas.util._test_decorators as td
+
+from pandas import option_context
+
+
+@td.skip_if_installed("numba")
+def test_numba_not_installed_option_context():
+    with pytest.raises(ImportError, match="Missing optional"):
+        with option_context("compute.use_numba", True):
+            pass
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_shares_memory.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_shares_memory.py
new file mode 100644
index 0000000000000000000000000000000000000000..00a897d574a07ac262afa17de6752e5c95e3964e
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_shares_memory.py
@@ -0,0 +1,30 @@
+import pandas.util._test_decorators as td
+
+import pandas as pd
+import pandas._testing as tm
+
+
+def test_shares_memory_interval():
+    obj = pd.interval_range(1, 5)
+
+    assert tm.shares_memory(obj, obj)
+    assert tm.shares_memory(obj, obj._data)
+    assert tm.shares_memory(obj, obj[::-1])
+    assert tm.shares_memory(obj, obj[:2])
+
+    assert not tm.shares_memory(obj, obj._data.copy())
+
+
+@td.skip_if_no("pyarrow")
+def test_shares_memory_string():
+    # GH#55823
+    import pyarrow as pa
+
+    obj = pd.array(["a", "b"], dtype="string[pyarrow]")
+    assert tm.shares_memory(obj, obj)
+
+    obj = pd.array(["a", "b"], dtype="string[pyarrow_numpy]")
+    assert tm.shares_memory(obj, obj)
+
+    obj = pd.array(["a", "b"], dtype=pd.ArrowDtype(pa.string()))
+    assert tm.shares_memory(obj, obj)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_util.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..dfb8587d3924e1441ac9da0aeeaa5585c6b4fe6c
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_util.py
@@ -0,0 +1,58 @@
+import os
+
+import pytest
+
+from pandas import (
+    array,
+    compat,
+)
+import pandas._testing as tm
+
+
+def test_numpy_err_state_is_default():
+    expected = {"over": "warn", "divide": "warn", "invalid": "warn", "under": "ignore"}
+    import numpy as np
+
+    # The error state should be unchanged after that import.
+    assert np.geterr() == expected
+
+
+def test_convert_rows_list_to_csv_str():
+    rows_list = ["aaa", "bbb", "ccc"]
+    ret = tm.convert_rows_list_to_csv_str(rows_list)
+
+    if compat.is_platform_windows():
+        expected = "aaa\r\nbbb\r\nccc\r\n"
+    else:
+        expected = "aaa\nbbb\nccc\n"
+
+    assert ret == expected
+
+
+@pytest.mark.parametrize("strict_data_files", [True, False])
+def test_datapath_missing(datapath):
+    with pytest.raises(ValueError, match="Could not find file"):
+        datapath("not_a_file")
+
+
+def test_datapath(datapath):
+    args = ("io", "data", "csv", "iris.csv")
+
+    result = datapath(*args)
+    expected = os.path.join(os.path.dirname(os.path.dirname(__file__)), *args)
+
+    assert result == expected
+
+
+def test_external_error_raised():
+    with tm.external_error_raised(TypeError):
+        raise TypeError("Should not check this error message, so it will pass")
+
+
+def test_is_sorted():
+    arr = array([1, 2, 3], dtype="Int64")
+    tm.assert_is_sorted(arr)
+
+    arr = array([4, 2, 3], dtype="Int64")
+    with pytest.raises(AssertionError, match="ExtensionArray are different"):
+        tm.assert_is_sorted(arr)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_validate_args.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_validate_args.py
new file mode 100644
index 0000000000000000000000000000000000000000..eef0931ec28efd02e3db7a85b0b3260742c1ff2d
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_validate_args.py
@@ -0,0 +1,70 @@
+import pytest
+
+from pandas.util._validators import validate_args
+
+
+@pytest.fixture
+def _fname():
+    return "func"
+
+
+def test_bad_min_fname_arg_count(_fname):
+    msg = "'max_fname_arg_count' must be non-negative"
+
+    with pytest.raises(ValueError, match=msg):
+        validate_args(_fname, (None,), -1, "foo")
+
+
+def test_bad_arg_length_max_value_single(_fname):
+    args = (None, None)
+    compat_args = ("foo",)
+
+    min_fname_arg_count = 0
+    max_length = len(compat_args) + min_fname_arg_count
+    actual_length = len(args) + min_fname_arg_count
+    msg = (
+        rf"{_fname}\(\) takes at most {max_length} "
+        rf"argument \({actual_length} given\)"
+    )
+
+    with pytest.raises(TypeError, match=msg):
+        validate_args(_fname, args, min_fname_arg_count, compat_args)
+
+
+def test_bad_arg_length_max_value_multiple(_fname):
+    args = (None, None)
+    compat_args = {"foo": None}
+
+    min_fname_arg_count = 2
+    max_length = len(compat_args) + min_fname_arg_count
+    actual_length = len(args) + min_fname_arg_count
+    msg = (
+        rf"{_fname}\(\) takes at most {max_length} "
+        rf"arguments \({actual_length} given\)"
+    )
+
+    with pytest.raises(TypeError, match=msg):
+        validate_args(_fname, args, min_fname_arg_count, compat_args)
+
+
+@pytest.mark.parametrize("i", range(1, 3))
+def test_not_all_defaults(i, _fname):
+    bad_arg = "foo"
+    msg = (
+        f"the '{bad_arg}' parameter is not supported "
+        rf"in the pandas implementation of {_fname}\(\)"
+    )
+
+    compat_args = {"foo": 2, "bar": -1, "baz": 3}
+    arg_vals = (1, -1, 3)
+
+    with pytest.raises(ValueError, match=msg):
+        validate_args(_fname, arg_vals[:i], 2, compat_args)
+
+
+def test_validation(_fname):
+    # No exceptions should be raised.
+    validate_args(_fname, (None,), 2, {"out": None})
+
+    compat_args = {"axis": 1, "out": None}
+    validate_args(_fname, (1, None), 2, compat_args)
diff --git a/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_validate_inclusive.py b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_validate_inclusive.py
new file mode 100644
index 0000000000000000000000000000000000000000..c1254c614ab305c447090b148ea6a036569f76e6
--- /dev/null
+++ b/env-llmeval/lib/python3.10/site-packages/pandas/tests/util/test_validate_inclusive.py
@@ -0,0 +1,40 @@
+import numpy as np
+import pytest
+
+from pandas.util._validators import validate_inclusive
+
+import pandas as pd
+
+
+@pytest.mark.parametrize(
+    "invalid_inclusive",
+    (
+        "ccc",
+        2,
+        object(),
+        None,
+        np.nan,
+        pd.NA,
+        pd.DataFrame(),
+    ),
+)
+def test_invalid_inclusive(invalid_inclusive):
+    with pytest.raises(
+        ValueError,
+        match="Inclusive has to be either 'both', 'neither', 'left' or 'right'",
+    ):
+        validate_inclusive(invalid_inclusive)
+
+
+@pytest.mark.parametrize(
+    "valid_inclusive, expected_tuple",
+    (
+        ("left", (True, False)),
+        ("right", (False, True)),
+        ("both", (True, True)),
+        ("neither", (False, False)),
+    ),
+)
+def test_valid_inclusive(valid_inclusive, expected_tuple):
+    resultant_tuple = validate_inclusive(valid_inclusive)
+    assert expected_tuple == resultant_tuple